fix: broken tests

Author: AndyOGo

src/createJsonLogic.js

@@ -2,18 +2,25 @@ import isArray from './helpers/isArray';
 import isLogic from './helpers/isLogic';
 import getOperator from './helpers/getOperator';
 
-function createJsonLogic(operations = {}, visitors = {}) {
-  Object.keys(operations).forEach(function(name) {
-    const operation = operations[name];
+function createJsonLogic(_operations, _visitors) {
+  const operations = {};
+  const visitors = {};
 
-    addOperation(operation.code || name , operation);
-  });
+  if (_operations) {
+    Object.keys(_operations).forEach(function(name) {
+      const operation = _operations[name];
 
-  Object.keys(visitors).forEach(function(name) {
-    const visitor = visitors[name];
+      addOperation(operation.code || name , operation);
+    });
+  }
 
-    addVisitor(visitor.code || name , visitor);
-  });
+  if (_visitors) {
+    Object.keys(_visitors).forEach(function (name) {
+      const visitor = _visitors[name];
+
+      addVisitor(visitor.code || name, visitor);
+    });
+  }
 
   function addOperation(name, code) {
     operations[name] = code;
@@ -25,7 +32,8 @@ function createJsonLogic(operations = {}, visitors = {}) {
 
   function addVisitor(name, code) {
     if (isArray(name)) {
-      name.forEach(addVisitor);
+      name.forEach((key) => addVisitor(key, code));
+      return;
     }
 
     visitors[name] = code;
@@ -34,6 +42,7 @@ function createJsonLogic(operations = {}, visitors = {}) {
   function removeVisitor(name) {
     if (isArray(name)) {
       name.forEach(removeVisitor);
+      return;
     }
 
     delete visitors[name];
@@ -75,8 +84,13 @@ function createJsonLogic(operations = {}, visitors = {}) {
     // The operation is called with "data" bound to its "this" and "values" passed as arguments.
     // Structured commands like % or > can name formal arguments while flexible commands (like missing or merge) can operate on the pseudo-array arguments
     // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments
-    if(typeof operations[op] === "function") {
-      return operations[op].apply(data, values);
+    const operator = operations[op];
+    if(typeof operator === "function") {
+      if (operator.withApply) {
+        values.unshift(apply);
+      }
+
+      return operator.apply(data, values);
     }else if(op.indexOf(".") > 0) { // Contains a dot, and not in the 0th position
       var sub_ops = String(op).split(".");
       var operation = operations;

src/helpers/truthy.js

@@ -5,7 +5,7 @@ import isArray from './isArray';
 
   Spec and rationale here: http://jsonlogic.com/truthy
   */
-function truthy(a) {
+function truthy(value) {
   if(isArray(value) && value.length === 0) {
     return false;
   }

src/operations/accessor/missing.js

@@ -1,7 +1,7 @@
 import isArray from '../../helpers/isArray';
 import variable from './variable'
 
-function missing() {
+function missing(apply, ...args) {
   /*
   Missing can receive many keys as many arguments, like {"missing:[1,2]}
   Missing can also receive *one* argument that is an array of keys,
@@ -10,11 +10,11 @@ function missing() {
   */
 
   var missing = [];
-  var keys = isArray(arguments[0]) ? arguments[0] : arguments;
+  var keys = isArray(args[0]) ? args[0] : args;
 
   for(var i = 0; i < keys.length; i++) {
     var key = keys[i];
-    var value = variable.call(this, {"var": key});
+    var value = apply({"var": key}, this);
     if(value === null || value === "") {
       missing.push(key);
     }
@@ -23,4 +23,6 @@ function missing() {
   return missing;
 };
 
+missing.withApply = true;
+
 export default missing;

src/operations/accessor/missingSome.js

@@ -1,8 +1,8 @@
 import missing from './missing';
 
-function missingSome(need_count, options) {
+function missingSome(apply, need_count, options) {
   // missing_some takes two arguments, how many (minimum) items must be present, and an array of keys (just like 'missing') to check for presence.
-  var are_missing = missing.call(this, {"missing": options});
+  const are_missing = apply({"missing": options}, this);
 
   if(options.length - are_missing.length >= need_count) {
     return [];
@@ -12,5 +12,6 @@ function missingSome(need_count, options) {
 }
 
 missingSome.code = 'missing_some';
+missingSome.withApply = true;
 
 export default missingSome;

src/operations/arithmetic/substract.js

@@ -6,4 +6,6 @@ function substract(a, b) {
   }
 }
 
+substract.code = '-';
+
 export default substract;

src/operations/logic/strictNotEqual.js

@@ -2,6 +2,6 @@ function strictNotEqual(a, b) {
   return a !== b;
 }
 
-strictNotEqual.code = '1==';
+strictNotEqual.code = '!==';
 
 export default strictNotEqual;

src/operations/logic/truthy.js

@@ -1 +1,5 @@
-export default from '../../helpers/truthy';
+import truthy from '../../helpers/truthy'
+
+truthy.code = '!!';
+
+export default truthy;

src/visitors/accessor/missing.js

@@ -0,0 +1,27 @@
+import isArray from '../../helpers/isArray';
+import variable from '../../operations/accessor/variable'
+
+function missing() {
+  /*
+  Missing can receive many keys as many arguments, like {"missing:[1,2]}
+  Missing can also receive *one* argument that is an array of keys,
+  which typically happens if it's actually acting on the output of another command
+  (like 'if' or 'merge')
+  */
+
+  const missing = [];
+  const keys = isArray(arguments[0]) ? arguments[0] : arguments;
+
+  for(let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    const value = variable.call(this, {"var": key}, arguments);
+
+    if(value === null || value === "") {
+      missing.push(key);
+    }
+  }
+
+  return missing;
+};
+
+export default missing;

src/visitors/accessor/missingSome.js

@@ -0,0 +1,16 @@
+import missing from './missing';
+
+function missingSome(need_count, options) {
+  // missing_some takes two arguments, how many (minimum) items must be present, and an array of keys (just like 'missing') to check for presence.
+  var are_missing = missing.call(this, {"missing": options});
+
+  if(options.length - are_missing.length >= need_count) {
+    return [];
+  }else{
+    return are_missing;
+  }
+}
+
+missingSome.code = 'missing_some';
+
+export default missingSome;

src/visitors/logic/condition.js

@@ -1,6 +1,8 @@
 import truthy from '../../helpers/truthy';
 
 function condition(apply, data, values) {
+  let i;
+
   /* 'if' should be called with a odd number of parameters, 3 or greater
     This works on the pattern:
     if( 0 ){ 1 }else{ 2 };
@@ -14,7 +16,7 @@ function condition(apply, data, values) {
     given one parameter, evaluate and return it. (it's an Else and all the If/ElseIf were false)
     given 0 parameters, return NULL (not great practice, but there was no Else)
     */
-  for(let i = 0; i < values.length - 1; i += 2) {
+  for(i = 0; i < values.length - 1; i += 2) {
     if( truthy( apply(values[i], data) ) ) {
       return apply(values[i+1], data);
     }