added minimal float check

Author: danielepanozzo

src/sjv/sjv.cpp

@@ -14,11 +14,15 @@ namespace sjv
     {
         try
         {
-
             // Polymorphism on list, for us a single item or a list are indistinguishable
+            // All the elements in the list must pass the test
             if (input.is_array())
+            {
                 for (auto i : input)
-                    verify_json(pointer, i, rules);
+                    if (!verify_json(pointer, i, rules))
+                        return false;
+                return true;
+            }
 
             // Find all rules that apply for the input node
             // TODO: accelerate this
@@ -29,11 +33,16 @@ namespace sjv
                     matching_rules.push_back(i);
             }
 
-            // There must be at least one, otherwise warning
+            // There must be at least one, otherwise warning and return true if not strict
             if (matching_rules.empty())
+            {
                 std::cout << "WARNING: "
                           << "Unknown entry " << pointer << std::endl;
 
+                if (strict)
+                    return false;
+            }
+
             // Test all rules, only one must pass, otherwise throw exception
             int count = 0;
 
@@ -42,34 +51,57 @@ namespace sjv
                     count++;
 
             if (count != 1)
-                throw matching_rules;
+            {
+                std::cout << "ERROR: Multiple valid rules in this list, only one should be valid:" << std::endl;
+                for (auto i : matching_rules)
+                    std::cout << i << std::endl;
+                return false;
+            }
 
             // If it passes and if it is a dictionary, then test all childrens
+            // TODO: if any of these fails we need to report it somehow
             if (input.is_structured())
                 for (auto &i : input.items())
-                    verify_json(pointer + i.key() + "/", i.value(), rules);
+                    if (!verify_json(pointer + i.key() + "/", i.value(), rules))
+                        return false;
 
             // If they all pass, return true
             return true;
         }
         catch (std::vector<json> e)
         {
-            for (auto i: e)
-                std::cout << "ERROR: " << i << std::endl; 
             return false;
         }
     };
     bool sjv::verify_rule(const json &input, const json &rule)
     {
-        return false;
+        string type = rule.at("type");
+        if (type == "skip_check")
+            return true;
+        else if (type == "float")
+            return verify_rule_float(input, rule);
+        else
+        {
+            std::cout << "ERROR: Unknown type " << std::endl;
+            exit(-1);
+            return false;
+        }
     };
     bool sjv::verify_rule_file(const json &input, const json &rule)
     {
         return false;
     };
-    bool sjv::verify_rule_double(const json &input, const json &rule)
+    bool sjv::verify_rule_float(const json &input, const json &rule)
     {
-        return false;
+        assert(rule.at("type") == "float");
+
+        if (!input.is_number_float())
+            return false;
+
+        if (rule.contains("min") && input < rule["min"])
+            return false;
+
+        return true;
     };
     bool sjv::verify_rule_int(const json &input, const json &rule)
     {

src/sjv/sjv.h

@@ -21,14 +21,17 @@ namespace sjv
 
         // Type-specific rule handlers
         bool verify_rule_file(const json &input, const json &rule);
-        bool verify_rule_double(const json &input, const json &rule);
+        bool verify_rule_float(const json &input, const json &rule);
         bool verify_rule_int(const json &input, const json &rule);
         bool verify_rule_path(const json &input, const json &rule);
         bool verify_rule_string(const json &input, const json &rule);
         bool verify_rule_dict(const json &input, const json &rule);
 
         // Working directory
-        string cwd;
+        string cwd = "";
+
+        // if strict == false, a json is valid even if it has entries not validated by a rule
+        bool strict = false;
     };
 
 } // namespace sjv

tests/test_validator.cpp

@@ -13,18 +13,14 @@ TEST_CASE("single_rule", "[validator]")
 {
     json input = R"( 
         {
-            "field1": "string", 
-            "field2": 42 
         }
         )"_json;
 
     json rules = R"( 
         [
         {
             "pointer": "/",
-            "type": "dict",
-            "key_fields": ["field1"],
-            "mandatory_fields": ["field1"]
+            "type": "skip_check"
         }
         ]
         )"_json;
@@ -33,3 +29,59 @@ TEST_CASE("single_rule", "[validator]")
 
     REQUIRE(sjv.verify_json(input,rules));
 }
+
+TEST_CASE("only_one_rule_can_be_valid", "[validator]")
+{
+    json input = R"( 
+        {
+        }
+        )"_json;
+
+    json rules = R"( 
+        [
+        {
+            "pointer": "/",
+            "type": "skip_check"
+        },
+        {
+            "pointer": "/",
+            "type": "skip_check"
+        }
+        ]
+        )"_json;
+
+    sjv::sjv sjv;
+
+    REQUIRE(!sjv.verify_json(input,rules));
+}
+
+TEST_CASE("min_bound_numeric", "[validator]")
+{
+    json input = R"( 
+        {
+            "field1": 48.5
+        }
+        )"_json;
+
+    json rules = R"( 
+        [
+        {
+            "pointer": "/",
+            "type": "skip_check"
+        },
+        {
+            "pointer": "/field1/",
+            "type": "float",
+            "min": 45
+        }
+        ]
+        )"_json;
+
+    sjv::sjv sjv;
+
+    REQUIRE(sjv.verify_json(input,rules));
+
+    input["field1"] = 40.5;
+
+    REQUIRE(!sjv.verify_json(input,rules));
+}