Merge pull request #5 from easeq/master

Changed order of arguments for comparison rule

Author: easeq

README.md

@@ -23,19 +23,19 @@ Define your conditionals using an array with logical rule ('and' or 'or') as the
 General representation of a logical rule is as follows:
 
 ```js
-['{your logical rule}', [{your conditional rule 1}], [{your conditional rule 2}], ...]
+['{your logical rule}', [{your comparison rule 1}], [{your comparison rule 2}], ...]
 ```
 
-Conditional rule is an array with 3 elements:
+Comparison rule is an array with 3 elements:
 
+-   The comparison rule.
 -   The key of the object whose value needs to be compared with a condition.
 -   The comparison value.
--   The comparison rule.
 
 General representation of a comparison rule is as follows:
 
 ```js
-['{key}', '{comparison value}', '{comparison rule}']
+['{comparison rule}', '{key}', '{comparison value}']
 ```
 
 ## Example
@@ -61,36 +61,36 @@ let data = {
 #### To simply check one rule (say) data.a = 1
 
 ```js
-let rule = ['a', 1, 'is']
+let rule = ['is', 'a', 1]
 ```
 
 or
 
 #### Check whether data.c.e\[0\].f = 1
 ```js
-let rule = ['c.e[0]`.f', 1, 'is']
+let rule = ['is', 'c.e[0]`.f', 1]
 ```
 
 ### Rules with multiple comparisons
 
 #### Check whether both data.a = 1 and data.b = 2
 
 ```js
-let rule = ['and', ['a', 1, 'is'], ['b', 2, 'is']]
+let rule = ['and', ['is', 'a', 1], ['is', 'b', 2]]
 ```
 
 #### Check whether either data.a = 1 or data.b = 2
 
 ```js
-let rule = ['or', ['a', 1, 'is'], ['b', 2, 'is']]
+let rule = ['or', ['is', 'a', 1], ['is', 'b', 2]]
 ```
 
 ### Complex rules
 
 #### Check whether (data.a = 1 and data.b = 2) or (data.b = 2 and data.c.d != 'string')
 
 ```js
-let rule = ['or', ['and', ['a', 1, 'is'], ['b', 2, 'is']], ['and', ['b', 2, 'is'], ['c.d', 'string', 'isNot']]]
+let rule = ['or', ['and', ['is', 'a', 1], ['is', 'b', 2]], ['and', ['is', 'b', 2], ['is', 'c.d', 'string']]]
 ```
 
 ### Evaluating rules

package-lock.json

@@ -1,6 +1,6 @@
 {
     "name": "@flipbyte/when-condition",
-    "version": "0.1.2",
+    "version": "0.2.0",
     "description": "Check conditional statements and return true/false",
     "main": "lib/index.js",
     "module": "es/index.js",

package.json

@@ -19,15 +19,15 @@ var rules = {
     // },
     anyOf: function(key, values, data) {
         if(!Array.isArray(values)) {
-            throw Error('"anyOf" condition requires an array as #2 argument');
+            throw Error('"anyOf" condition requires an array as #3 argument');
         }
 
         let dataValue = get(data, key);
         return values.includes(dataValue);
     },
     noneOf: function(key, values, data) {
         if(!Array.isArray(values)) {
-            throw Error('"noneOf" condition requires an array as #2 argument');
+            throw Error('"noneOf" condition requires an array as #3 argument');
         }
 
         let dataValue = get(data, key);
@@ -58,7 +58,7 @@ const isValidCondition = (conditions) => {
     return false;
 }
 
-const processRule = ([key, value, condition], data) => {
+const processRule = ([condition, key, value], data) => {
     if(typeof condition !== 'string' || rules[condition] === undefined) {
         throw Error('Invalid comparison rule ' + condition + '.');
     }

src/index.js

@@ -1,4 +1,3 @@
-
 import when from '../src/index';
 
 describe('and', () => {
@@ -8,43 +7,13 @@ describe('and', () => {
     }
 
     it('is', () => {
-        expect(when(['and', ['name', 'John Doe', 'is'], ['age', 18, 'is']], data)).to.equal(true)
-        expect(when(['and', ['name', 'John Doe', 'is'], ['age', 17, 'is']], data)).to.equal(false)
+        expect(when(['and', ['is', 'name', 'John Doe'], ['is', 'age', 18]], data)).to.equal(true)
+        expect(when(['and', ['is', 'name', 'John Doe'], ['is', 'age', 17]], data)).to.equal(false)
     })
 
     it('isNot', () => {
-        expect(when(['and', ['name', 'John Doe', 'isNot'], ['age', 18, 'isNot']], data)).to.equal(false)
-        expect(when(['and', ['name', 'John Doe', 'isNot'], ['age', 17, 'isNot']], data)).to.equal(false)
-        expect(when(['and', ['name', 'John', 'isNot'], ['age', 17, 'isNot']], data)).to.equal(true)
+        expect(when(['and', ['isNot', 'name', 'John Doe'], ['isNot', 'age', 18]], data)).to.equal(false)
+        expect(when(['and', ['isNot', 'name', 'John Doe'], ['isNot', 'age', 17]], data)).to.equal(false)
+        expect(when(['and', ['isNot', 'name', 'John'], ['isNot', 'age', 17]], data)).to.equal(true)
     })
-
-    // it('single rule using "or"', () => {
-    //     expect(when(['or', ['name', 'John Doe', 'is']], data)).to.equal(true)
-    //     expect(when(['or', ['name', 'John', 'is']], data)).to.equal(false)
-    // })
-    //
-    // it('deep object key', () => {
-    //     let data = {
-    //         contact: {
-    //             person: {
-    //                 name: 'John Doe'
-    //             }
-    //         }
-    //     }
-    //     expect(when(['contact.person.name', 'John Doe', 'is'], data)).to.equal(true)
-    //     expect(when(['contact.person.lastName', 'John Doe', 'is'], data)).to.equal(false)
-    // })
-    //
-    // it('deep object array key', () => {
-    //     let data = {
-    //         contact: {
-    //             person: [{
-    //                 name: 'John Doe'
-    //             }]
-    //         }
-    //     }
-    //     expect(when(['contact.person.0.name', 'John Doe', 'is'], data)).to.equal(true)
-    //     expect(when(['contact.person[0].name', 'John Doe', 'is'], data)).to.equal(true)
-    //     expect(when(['contact.person[1].name', 'John Doe', 'is'], data)).to.equal(false)
-    // })
 })

tests/and.test.js

@@ -1,25 +1,24 @@
-
 import when from '../src/index';
 
 describe('anyOf', () => {
     let data = { name: 'John Doe' }
 
     it('single rule', () => {
-        expect(when(['name', ['John Doe', 'John'], 'anyOf'], data)).to.equal(true)
-        expect(when(['name', ['John Doe', 'John'], 'anyOf'], data)).to.equal(true)
-        expect(when(['name', ['Doe', 'John'], 'anyOf'], data)).to.equal(false)
+        expect(when(['anyOf', 'name', ['John Doe', 'John']], data)).to.equal(true)
+        expect(when(['anyOf', 'name', ['John Doe', 'John']], data)).to.equal(true)
+        expect(when(['anyOf', 'name', ['Doe', 'John']], data)).to.equal(false)
     })
 
     it('single rule using "and"', () => {
-        expect(when(['and', ['name', ['John Doe', 'John'], 'anyOf']], data)).to.equal(true)
-        expect(when(['and', ['name', ['John Doe', 'John'], 'anyOf']], data)).to.equal(true)
-        expect(when(['and', ['name', ['Doe', 'John'], 'anyOf']], data)).to.equal(false)
+        expect(when(['and', ['anyOf', 'name', ['John Doe', 'John']]], data)).to.equal(true)
+        expect(when(['and', ['anyOf', 'name', ['John Doe', 'John']]], data)).to.equal(true)
+        expect(when(['and', ['anyOf', 'name', ['Doe', 'John']]], data)).to.equal(false)
     })
 
     it('single rule using "or"', () => {
-        expect(when(['or', ['name', ['John Doe', 'John'], 'anyOf']], data)).to.equal(true)
-        expect(when(['or', ['name', ['John Doe', 'John'], 'anyOf']], data)).to.equal(true)
-        expect(when(['or', ['name', ['Doe', 'John'], 'anyOf']], data)).to.equal(false)
+        expect(when(['or', ['anyOf', 'name', ['John Doe', 'John']]], data)).to.equal(true)
+        expect(when(['or', ['anyOf', 'name', ['John Doe', 'John']]], data)).to.equal(true)
+        expect(when(['or', ['anyOf', 'name', ['Doe', 'John']]], data)).to.equal(false)
     })
 
     it('deep object key', () => {
@@ -31,9 +30,9 @@ describe('anyOf', () => {
             }
         }
 
-        expect(when(['contact.person.name', ['John Doe', 'John'], 'anyOf'], data)).to.equal(true)
-        expect(when(['contact.person.name', ['John Doe', 'John'], 'anyOf'], data)).to.equal(true)
-        expect(when(['contact.person.name', ['Doe', 'John'], 'anyOf'], data)).to.equal(false)
+        expect(when(['anyOf', 'contact.person.name', ['John Doe', 'John']], data)).to.equal(true)
+        expect(when(['anyOf', 'contact.person.name', ['John Doe', 'John']], data)).to.equal(true)
+        expect(when(['anyOf', 'contact.person.name', ['Doe', 'John']], data)).to.equal(false)
     })
 
     it('deep object array key', () => {
@@ -45,15 +44,15 @@ describe('anyOf', () => {
             }
         }
 
-        expect(when(['contact.person.0.name', ['John Doe', 'John'], 'anyOf'], data)).to.equal(true)
-        expect(when(['contact.person[0].name', ['John Doe', 'John'], 'anyOf'], data)).to.equal(true)
-        expect(when(['contact.person[0].name', ['Doe', 'John'], 'anyOf'], data)).to.equal(false)
-        expect(when(['contact.person[1].name', ['Doe', 'John', 'John Doe'], 'anyOf'], data)).to.equal(false)
+        expect(when(['anyOf', 'contact.person.0.name', ['John Doe', 'John']], data)).to.equal(true)
+        expect(when(['anyOf', 'contact.person[0].name', ['John Doe', 'John']], data)).to.equal(true)
+        expect(when(['anyOf', 'contact.person[0].name', ['Doe', 'John']], data)).to.equal(false)
+        expect(when(['anyOf', 'contact.person[1].name', ['Doe', 'John', 'John Doe']], data)).to.equal(false)
     })
 
     it('throws error when values is not of type array', () => {
         (function() {
-            when(['name', 'John', 'anyOf'], data)
-        }.should.throw(/"anyOf" condition requires an array as #2 argument/));
+            when(['anyOf', 'name', 'John'], data)
+        }.should.throw(/"anyOf" condition requires an array as #3 argument/));
     })
 })

tests/anyOf.test.js

@@ -1,28 +1,27 @@
-
 import when from '../src/index';
 
 describe('gt', () => {
     let data = { age: 18 }
 
     it('single rule', () => {
-        expect(when(['age', 19, 'gt'], data)).to.equal(false)
-        expect(when(['age', '19', 'gt'], data)).to.equal(false)
-        expect(when(['age', 18, 'gt'], data)).to.equal(false)
-        expect(when(['age', 16, 'gt'], data)).to.equal(true)
+        expect(when(['gt', 'age', 19], data)).to.equal(false)
+        expect(when(['gt', 'age', '19'], data)).to.equal(false)
+        expect(when(['gt', 'age', 18], data)).to.equal(false)
+        expect(when(['gt', 'age', 16], data)).to.equal(true)
     })
 
     it('single rule using "and"', () => {
-        expect(when(['and', ['age', 19, 'gt']], data)).to.equal(false)
-        expect(when(['and', ['age', '19', 'gt']], data)).to.equal(false)
-        expect(when(['and', ['age', 18, 'gt']], data)).to.equal(false)
-        expect(when(['and', ['age', 16, 'gt']], data)).to.equal(true)
+        expect(when(['and', ['gt', 'age', 19]], data)).to.equal(false)
+        expect(when(['and', ['gt', 'age', '19']], data)).to.equal(false)
+        expect(when(['and', ['gt', 'age', 18]], data)).to.equal(false)
+        expect(when(['and', ['gt', 'age', 16]], data)).to.equal(true)
     })
 
     it('single rule using "or"', () => {
-        expect(when(['or', ['age', 19, 'gt']], data)).to.equal(false)
-        expect(when(['or', ['age', '19', 'gt']], data)).to.equal(false)
-        expect(when(['or', ['age', 18, 'gt']], data)).to.equal(false)
-        expect(when(['or', ['age', 16, 'gt']], data)).to.equal(true)
+        expect(when(['or', ['gt', 'age', 19]], data)).to.equal(false)
+        expect(when(['or', ['gt', 'age', '19']], data)).to.equal(false)
+        expect(when(['or', ['gt', 'age', 18]], data)).to.equal(false)
+        expect(when(['or', ['gt', 'age', 16]], data)).to.equal(true)
     })
 
     it('deep object key', () => {
@@ -35,10 +34,10 @@ describe('gt', () => {
             }
         }
 
-        expect(when(['contact.person.age', 19, 'gt'], data)).to.equal(false)
-        expect(when(['contact.person.age', '19', 'gt'], data)).to.equal(false)
-        expect(when(['contact.person.age', 18, 'gt'], data)).to.equal(false)
-        expect(when(['contact.person.age', 16, 'gt'], data)).to.equal(true)
+        expect(when(['gt', 'contact.person.age', 19], data)).to.equal(false)
+        expect(when(['gt', 'contact.person.age', '19'], data)).to.equal(false)
+        expect(when(['gt', 'contact.person.age', 18], data)).to.equal(false)
+        expect(when(['gt', 'contact.person.age', 16], data)).to.equal(true)
     })
 
     it('deep object array key', () => {
@@ -51,20 +50,20 @@ describe('gt', () => {
             }
         }
 
-        expect(when(['contact.person.0.age', 19, 'gt'], data)).to.equal(false)
-        expect(when(['contact.person.0.age', '19', 'gt'], data)).to.equal(false)
-        expect(when(['contact.person.0.age', 18, 'gt'], data)).to.equal(false)
-        expect(when(['contact.person.0.age', 16, 'gt'], data)).to.equal(true)
+        expect(when(['gt', 'contact.person.0.age', 19], data)).to.equal(false)
+        expect(when(['gt', 'contact.person.0.age', '19'], data)).to.equal(false)
+        expect(when(['gt', 'contact.person.0.age', 18], data)).to.equal(false)
+        expect(when(['gt', 'contact.person.0.age', 16], data)).to.equal(true)
 
-        expect(when(['contact.person[0].age', 19, 'gt'], data)).to.equal(false)
-        expect(when(['contact.person[0].age', '19', 'gt'], data)).to.equal(false)
-        expect(when(['contact.person[0].age', 18, 'gt'], data)).to.equal(false)
-        expect(when(['contact.person[0].age', 16, 'gt'], data)).to.equal(true)
+        expect(when(['gt', 'contact.person[0].age', 19], data)).to.equal(false)
+        expect(when(['gt', 'contact.person[0].age', '19'], data)).to.equal(false)
+        expect(when(['gt', 'contact.person[0].age', 18], data)).to.equal(false)
+        expect(when(['gt', 'contact.person[0].age', 16], data)).to.equal(true)
 
-        expect(when(['contact.person[1].age', 19, 'gt'], data)).to.equal(false)
-        expect(when(['contact.person[1].age', '19', 'gt'], data)).to.equal(false)
-        expect(when(['contact.person[1].age', 18, 'gt'], data)).to.equal(false)
-        expect(when(['contact.person[1].age', 16, 'gt'], data)).to.equal(false)
+        expect(when(['gt', 'contact.person[1].age', 19], data)).to.equal(false)
+        expect(when(['gt', 'contact.person[1].age', '19'], data)).to.equal(false)
+        expect(when(['gt', 'contact.person[1].age', 18], data)).to.equal(false)
+        expect(when(['gt', 'contact.person[1].age', 16], data)).to.equal(false)
 
     })
 })