Fix, predicates run against condition arrays and the elements

Author: Steffan-Ennis

src/checkField.js

@@ -3,32 +3,38 @@ import { isObject } from "./utils";
 
 import { OR, AND, NOT } from "./constants";
 
-export default function checkField(fieldVal, rule) {
-  if (Array.isArray(fieldVal)) {
-    // Simple rule - like emptyString
-    return fieldVal.some(val => checkField(val, rule));
-  } else if (isObject(rule)) {
-    // Complicated rule - like { greater then 10 }
-    return Object.keys(rule).every(p => {
-      let subRule = rule[p];
-      if (p === OR || p === AND) {
-        if (Array.isArray(subRule)) {
-          if (p === OR) {
-            return subRule.some(rule => checkField(fieldVal, rule));
-          } else {
-            return subRule.every(rule => checkField(fieldVal, rule));
-          }
+const parseObjectRule = (rule, fieldVal) => {
+  return Object.keys(rule).every(p => {
+    let subRule = rule[p];
+    if (p === OR || p === AND) {
+      if (Array.isArray(subRule)) {
+        if (p === OR) {
+          return subRule.some(rule => checkField(fieldVal, rule));
         } else {
-          return false;
+          return subRule.every(rule => checkField(fieldVal, rule));
         }
-      } else if (p === NOT) {
-        return !checkField(fieldVal, subRule);
-      } else if (predicate[p]) {
-        return predicate[p](fieldVal, subRule);
       } else {
         return false;
       }
-    });
+    } else if (p === NOT) {
+      return !checkField(fieldVal, subRule);
+    } else if (predicate[p]) {
+      return predicate[p](fieldVal, subRule);
+    } else {
+      return false;
+    }
+  });
+};
+
+export default function checkField(fieldVal, rule) {
+  if (Array.isArray(fieldVal)) {
+    return isObject(rule)
+      ? fieldVal.some(val => checkField(val, rule)) || parseObjectRule(rule)
+      : fieldVal.some(val => checkField(val, rule)) ||
+        predicate[rule](fieldVal);
+  } else if (isObject(rule)) {
+    // Complicated rule - like { greater then 10 }
+    return parseObjectRule(rule, fieldVal);
   } else {
     return predicate[rule](fieldVal);
   }

src/conditionsMeet.js

@@ -20,7 +20,10 @@ export default function conditionsMeet(conditions, formData) {
     } else {
       let refVal = selectn(ref, formData);
       if (Array.isArray(refVal)) {
-        return refVal.some(val => conditionsMeet(refCondition, val));
+        return (
+          refVal.some(val => conditionsMeet(refCondition, val)) ||
+          checkField(refVal, refCondition)
+        );
       } else {
         return checkField(refVal, refCondition);
       }

test/checkField.test.js

@@ -77,6 +77,8 @@ test("invalid rule", () => {
 });
 
 test("check array", () => {
+  expect(checkField([], "empty")).toBeTruthy();
+  expect(checkField([""], "empty")).toBeTruthy();
   expect(checkField([1, 2, 3, 4], { less: 50, greater: 5 })).toBeFalsy();
   expect(checkField([1, 2, 3, 4, 5, 6], { less: 50, greater: 5 })).toBeTruthy();
 

test/conditionsMeet.test.js

@@ -5,11 +5,19 @@ test("sanity checkField", function() {
   expect(() => conditionsMeet({}, 0)).toThrow();
 });
 
+test("run predicate against array and contents", () => {
+  let condition = {
+    options: "empty",
+  };
+  expect(conditionsMeet(condition, [""])).toBeTruthy();
+  expect(conditionsMeet(condition, [])).toBeTruthy();
+});
+
 test("single line", () => {
   let condition = {
     firstName: "empty",
   };
-  expect(conditionsMeet(condition, {})).toBeTruthy();
+  expect(conditionsMeet(condition, [])).toBeTruthy();
   expect(conditionsMeet(condition, { firstName: "some" })).toBeFalsy();
   expect(conditionsMeet(condition, { firstName: "" })).toBeTruthy();
   expect(conditionsMeet(condition, { firstName: undefined })).toBeTruthy();