doc/DICTIONARIES.md
# Dictionaries
Polyjuice uses JavaScript objects to find a proper translation for a given rule. The object has the rule name to be translated as key and variable options as its value.
Basically, there is a truth function that will be used to test the value of the rule to be translated, and then its output is going to be matched against a truth table of default values of the destination tool.
The truth function is currently default for all languages, and its implementation is as follows.
```js
var fn = function(input) {
if (typeof input === 'number') {
return true
}
return input ? true : false
}
```
It tells that if the value of the rule is a number, then it is considered true otherwise it is true based on JavaScript existence test. An example of a truth table is shown below.
```json
{
"true": 2,
"false": 0
}
```
## Possible rule values
### Function
```js
module.exports = function(__current__, value) {
return {
'rule-in-eslint': [2, value]
}
}
```
This format tells the interpreter that you will return an object containing all the key/value that should be used. It is useful when you either want to omit a rule or when you want to consider several rules. You must return an object, even if empty.
### String
```js
module.exports = 'rule-in-eslint'
```
This format tells the interpreter that those rules are equivalent. Therefore, using the truth function on the value it gets the corresponding default true/false value from the truth table (or copy it if a number). I.e. if `rule-in-jshint': true` is in the source file, `'rule-in-eslint': 2` will be generated.
### Array
```js
module.exports = ['rule-in-eslint-1', 'rule-in-eslint-2']
```
This will work just as above, applying it to every string in the array.
### Object
```js
module.exports = {
name: 'rule-in-eslint',
truthy: function(__current__, value) {
if (__current__) {
return [2, __current__, value]
}
return [2, value]
},
falsy: [2, 'never']
}
```
#### Attributes
##### `name`
The attribute `name` is **mandatory**. It is the name in the target language.
##### `eval`
The attribute `eval`, if given, should be always a function and works much like using a function directly; However you do not need to provide the target as an object.
##### `truthy`
The attribute `truthy`, if function, is a shorthand for `eval`. It is called after the truth function decides the value is considered `true`. It can also be a string, an array, or any other value that can be directly applied.
##### `falsy`
The attribute `falsy`, if function, is a shorthand for `eval`. It is called after the truth function decides the value is considered `false`. It can also be a string, an array, or any other value that can be directly applied.
##### `target`
When converting from ESLint, the object **must** contain the `target` library it is converting to. ESLint conversions return an object whose keys are the targets read when transpiling a file. For instance:
```js
'rule-in-eslint': {
target: 'jshint',
name: 'rule-in-jshint',
truthy: true
}
```
#### FCFS Policy
Polyjuice has a FCFS policy for transpiling. Therefore, all transpiling functions have two arguments: `__current__` and `value`. The first is the current value for the rule being assessed; It is useful when there is overlapping rules. The latter is the actual value of the rule being assessed in the moment. Bear in mind that the function priority is `eval > test > truthy/falsy`.