Merge pull request #10 from easeq/master

Fixes #9

Author: easeq

README.md

@@ -117,14 +117,13 @@ when(function(data) {
 There are 2 types of logical rules:
 -   ```and``` - checks whether all the conditions evaluate to true.
 -   ```or```  - checks whether atleast one condition evaluates to true.
+-   ```not``` - returns the opposite of the evaluated comparison rule. This logical rule takes only one comparison rule.
 
 ## Comparison rules
 
 Following are the available comparison rules:
 -   ```is``` - returns true if the object value strictly matches the comparison value.
--   ```isNot``` - returns true if the object value does not match the comparison value.
 -   ```isOfType``` - returns true if the object value matches the specified type (Ex: string, undefined, etc.).
--   ```isNotOfType``` - returns true if the object value does not matche the specified type (Ex: string, undefined, etc.).
 -   ```anyOf``` - returns true if at least one of the comparison values matches the object key value. The comparison value needs to be an array.
 -   ```allOf``` - returns true if all the object key value matches the comparison values. The comparison value needs to be an array.
 -   ```noneOf``` - returns true if none of the comparison values match the object key value. The comparison value needs to be an array.

package-lock.json

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

package.json

@@ -4,21 +4,13 @@ const get = (obj, path, defaultValue = undefined) => (
         .reduce((a, c) => (a && Object.hasOwnProperty.call(a, c)) ? a[c] : defaultValue, obj)
 );
 
-const logicalOperators = ['and', 'or'];
-
 var rules = {
     is: function(key, value, data) {
         return get(data, key) === value;
     },
-    isNot: function(key, value, data) {
-        return get(data, key) != value;
-    },
     isOfType: function(key, value, data) {
         return typeof get(data, key) === value;
     },
-    isNotOfType: function(key, value, data) {
-        return typeof get(data, key) !== value;
-    },
     allOf: function(key, values, data) {
         if(!Array.isArray(values)) {
             throw Error('"allOf" condition requires an array as #3 argument');
@@ -55,12 +47,28 @@ var rules = {
     lte: function(key, value, data) {
         return get(data, key) <= value
     },
+};
+
+const logicalRules = {
+    and: function(data) {
+        return !data.includes(false);
+    },
+    or: function(data) {
+        return data.includes(true);
+    },
+    not: function(data) {
+        if (data.length !== 1) {
+            throw Error('"not" can have only one comparison rule, multiple rules given');
+        }
+
+        return !data[0];
+    }
 }
 
 const isValidCondition = (conditions) => {
     if(Array.isArray(conditions)
         && Array.isArray(conditions[1])
-        && logicalOperators.includes(conditions[0])
+        && (conditions[0] && logicalRules[conditions[0].toLowerCase()])
     ) {
         return true;
     }
@@ -76,20 +84,16 @@ const processRule = ([condition, key, value], data) => {
     return rules[condition](key, value, data);
 }
 
-const processCondition = (condition, data) => {
-    if(condition.toLowerCase() === 'or') {
-        return data.includes(true);
-    }
-
-    return !data.includes(false);
-}
+const processCondition = (condition, data) => (
+    logicalRules[condition.toLowerCase()](data)
+);
 
 const when = (conditions, data) => {
     if (typeof conditions === 'function') {
         return conditions(data);
     }
 
-    if(!isValidCondition(conditions)) {
+    if (!isValidCondition(conditions)) {
         return processRule(conditions, data);
     }
 

src/index.js

@@ -9,11 +9,15 @@ describe('and', () => {
     it('is', () => {
         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', ['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('a and not b', () => {
+        expect(when(['and', ['is', 'name', 'John Doe'], ['not', ['is', 'age', 18]]], data)).to.equal(false);
+        expect(when(['and', ['is', 'name', 'John Doe'], ['not', ['is', 'age', 17]]], data)).to.equal(true);
+    });
+
+    it('not a and not b', () => {
+        expect(when(['and', ['not', ['is', 'name', 'John Doe']], ['not', ['is', 'age', 18]]], data)).to.equal(false);
+        expect(when(['and', ['not', ['is', 'name', 'John']], ['not', ['is', 'age', 17]]], data)).to.equal(true);
+    });
 })

tests/and.test.js

@@ -0,0 +1,31 @@
+import when from '../src/index';
+
+describe('not', () => {
+    let data = {
+        name: 'John Doe',
+        age: 18
+    }
+
+    it('is', () => {
+        expect(when(['not', ['is', 'name', 'John Doe']], data)).to.equal(false)
+        expect(when(['not', ['is', 'age', 17]], data)).to.equal(true)
+    })
+
+    it('(a and b)', () => {
+        expect(when(['not', ['or', ['is', 'name', 'John Doe'], ['is', 'age', 18]]], data)).to.equal(false)
+        expect(when(['not', ['or', ['is', 'name', 'John Doe'], ['is', 'age', 17]]], data)).to.equal(false)
+        expect(when(['not', ['or', ['is', 'name', 'John'], ['is', 'age', 17]]], data)).to.equal(true)
+    });
+
+    it('(a or b)', () => {
+        expect(when(['not', ['and', ['is', 'name', 'John Doe'], ['is', 'age', 18]]], data)).to.equal(false)
+        expect(when(['not', ['and', ['is', 'name', 'John Doe'], ['is', 'age', 17]]], data)).to.equal(true)
+        expect(when(['not', ['and', ['is', 'name', 'John'], ['is', 'age', 17]]], data)).to.equal(true)
+    });
+
+    it('multiple comparison rules throws error', () => {
+        (function() {
+            expect(when(['not', ['is', 'name', 'John Doe'], ['is', 'age', 18]], data))
+        }.should.throw(/"not" can have only one comparison rule, multiple rules given/));
+    });
+})

tests/isNot.test.js

@@ -9,11 +9,17 @@ describe('or', () => {
     it('is', () => {
         expect(when(['or', ['is', 'name', 'John Doe'], ['is', 'age', 18]], data)).to.equal(true)
         expect(when(['or', ['is', 'name', 'John'], ['is', 'age', 17]], data)).to.equal(false)
-    })
+    });
 
-    it('isNot', () => {
-        expect(when(['or', ['isNot', 'name', 'John Doe'], ['isNot', 'age', 18]], data)).to.equal(false)
-        expect(when(['or', ['isNot', 'name', 'John Doe'], ['isNot', 'age', 17]], data)).to.equal(true)
-        expect(when(['or', ['isNot', 'name', 'John'], ['isNot', 'age', 17]], data)).to.equal(true)
-    })
+    it('a or not b', () => {
+        expect(when(['or', ['is', 'name', 'John Doe'], ['not', ['is', 'age', 18]]], data)).to.equal(true);
+        expect(when(['or', ['is', 'name', 'John Doe'], ['not', ['is', 'age', 17]]], data)).to.equal(true);
+        expect(when(['or', ['is', 'name', 'John'], ['not', ['is', 'age', 18]]], data)).to.equal(false);
+    });
+
+    it('not a or not b', () => {
+        expect(when(['or', ['not', ['is', 'name', 'John Doe']], ['not', ['is', 'age', 18]]], data)).to.equal(false);
+        expect(when(['or', ['not', ['is', 'name', 'John']], ['not', ['is', 'age', 17]]], data)).to.equal(true);
+        expect(when(['or', ['not', ['is', 'name', 'John Doe']], ['not', ['is', 'age', 17]]], data)).to.equal(true);
+    });
 })