Merge pull request #7 from easeq/master

Added new rules "allOf" and "isOfType"

Author: easeq

README.md

@@ -124,6 +124,7 @@ 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.
 -   ```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.
 -   ```gt``` - returns true if the object key value is greater than the comparison value
 -   ```gte``` - returns true if the object key value is greater than or equal to the comparison value

package-lock.json

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

package.json

@@ -9,14 +9,17 @@ var rules = {
     isNot: function(key, value, data) {
         return get(data, key) != value;
     },
-    // allOf: function(key, value, data) {
-    //     if(!Array.isArray(value)) {
-    //         throw Error('"allOf" condition requires an array as #2 argument');
-    //     }
-    //
-    //     let dataValue = get(data, key);
-    //     return value.every(currentValue => currentValue === dataValue)
-    // },
+    isOfType: 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');
+        }
+
+        var dataValues = get(data, key);
+        return values.every((currentValue) => dataValues.includes(currentValue))
+    },
     anyOf: function(key, values, data) {
         if(!Array.isArray(values)) {
             throw Error('"anyOf" condition requires an array as #3 argument');

src/index.js

@@ -0,0 +1,69 @@
+import when from '../src/index';
+
+describe('allOf', () => {
+    let data = {
+        brand: ['Apple', 'Samsung', 'Nokia']
+    }
+
+    it('single rule', () => {
+        expect(when(['allOf', 'brand', ['Apple', 'Samsung', 'Nokia']], data)).to.equal(true)
+        expect(when(['allOf', 'brand', ['Nokia', 'Samsung', 'Apple']], data)).to.equal(true)
+        expect(when(['allOf', 'brand', ['Nokia', 'Samsung']], data)).to.equal(true)
+        expect(when(['allOf', 'brand', ['Nokia', 'Another']], data)).to.equal(false)
+        expect(when(['allOf', 'brand', ['Apple', 'Samsung', 'Nokia', 'Another']], data)).to.equal(false)
+    })
+
+    it('single rule using "and"', () => {
+        expect(when(['and', ['allOf', 'brand', ['Apple', 'Samsung', 'Nokia']]], data)).to.equal(true)
+        expect(when(['and', ['allOf', 'brand', ['Nokia', 'Samsung', 'Apple']]], data)).to.equal(true)
+        expect(when(['and', ['allOf', 'brand', ['Nokia', 'Samsung']]], data)).to.equal(true)
+        expect(when(['and', ['allOf', 'brand', ['Nokia', 'Another']]], data)).to.equal(false)
+        expect(when(['and', ['allOf', 'brand', ['Apple', 'Samsung', 'Nokia', 'Another']]], data)).to.equal(false)
+    })
+
+    it('single rule using "or"', () => {
+        expect(when(['or', ['allOf', 'brand', ['Apple', 'Samsung', 'Nokia']]], data)).to.equal(true)
+        expect(when(['or', ['allOf', 'brand', ['Nokia', 'Samsung', 'Apple']]], data)).to.equal(true)
+        expect(when(['or', ['allOf', 'brand', ['Nokia', 'Samsung']]], data)).to.equal(true)
+        expect(when(['or', ['allOf', 'brand', ['Nokia', 'Another']]], data)).to.equal(false)
+        expect(when(['or', ['allOf', 'brand', ['Apple', 'Samsung', 'Nokia', 'Another']]], data)).to.equal(false)
+    })
+
+    it('deep object key', () => {
+        let data = {
+            contact: {
+                person: {
+                    brand: ['Apple', 'Samsung', 'Nokia']
+                }
+            }
+        }
+
+        expect(when(['allOf', 'contact.person.brand', ['Apple', 'Samsung', 'Nokia']], data)).to.equal(true)
+        expect(when(['allOf', 'contact.person.brand', ['Nokia', 'Samsung', 'Apple']], data)).to.equal(true)
+        expect(when(['allOf', 'contact.person.brand', ['Nokia', 'Samsung']], data)).to.equal(true)
+        expect(when(['allOf', 'contact.person.brand', ['Nokia', 'Another']], data)).to.equal(false)
+        expect(when(['allOf', 'contact.person.brand', ['Apple', 'Samsung', 'Nokia', 'Another']], data)).to.equal(false)
+    })
+
+    it('deep object array key', () => {
+        let data = {
+            contact: {
+                person: [{
+                    brand: ['Apple', 'Samsung', 'Nokia']
+                }]
+            }
+        }
+
+        expect(when(['allOf', 'contact.person.0.brand', ['Apple', 'Samsung', 'Nokia']], data)).to.equal(true)
+        expect(when(['allOf', 'contact.person[0].brand', ['Nokia', 'Samsung', 'Apple']], data)).to.equal(true)
+        expect(when(['allOf', 'contact.person[0].brand', ['Nokia', 'Samsung']], data)).to.equal(true)
+        expect(when(['allOf', 'contact.person.0.brand', ['Nokia', 'Another']], data)).to.equal(false)
+        expect(when(['allOf', 'contact.person[0].brand', ['Apple', 'Samsung', 'Nokia', 'Another']], data)).to.equal(false)
+    })
+
+    it('throws error when values is not of type array', () => {
+        (function() {
+            when(['allOf', 'name', 'Apple'], data)
+        }.should.throw(/"allOf" condition requires an array as #3 argument/));
+    })
+})

tests/allOf.test.js

@@ -0,0 +1,45 @@
+import when from '../src/index';
+
+describe('isOfType', () => {
+    let data = { name: 'John Doe' }
+
+    it('single rule', () => {
+        expect(when(['isOfType', 'firstname', 'undefined'], data)).to.equal(true)
+        expect(when(['isOfType', 'name', 'undefined'], data)).to.equal(false)
+    })
+
+    it('single rule using "and"', () => {
+        expect(when(['and', ['isOfType', 'firstname', 'undefined']], data)).to.equal(true)
+        expect(when(['and', ['isOfType', 'name', 'John']], data)).to.equal(false)
+    })
+
+    it('single rule using "or"', () => {
+        expect(when(['or', ['isOfType', 'firstname', 'undefined']], data)).to.equal(true)
+        expect(when(['or', ['isOfType', 'name', 'John']], data)).to.equal(false)
+    })
+
+    it('deep object key', () => {
+        let data = {
+            contact: {
+                person: {
+                    name: 'John Doe'
+                }
+            }
+        }
+        expect(when(['isOfType', 'contact.person.name', 'John Doe'], data)).to.equal(false)
+        expect(when(['isOfType', 'contact.person.lastName', 'undefined'], data)).to.equal(true)
+    })
+
+    it('deep object array key', () => {
+        let data = {
+            contact: {
+                person: [{
+                    name: 'John Doe'
+                }]
+            }
+        }
+        expect(when(['isOfType', 'contact.person.0.name', 'John Doe'], data)).to.equal(false)
+        expect(when(['isOfType', 'contact.person[0].name', 'John Doe'], data)).to.equal(false)
+        expect(when(['isOfType', 'contact.person[1].name', 'undefined'], data)).to.equal(true)
+    })
+})