Merge branch 'main' of github.com:geometryprocessing/simple-json-validator into main

Author: DuoZhangRobotics

.vscode/launch.json

@@ -6,7 +6,7 @@
         "type": "cppdbg",
         "request": "launch",
         "program": "/home/daniele/git/simple-json-validator/build/tests/unit_tests",
-        "args": ["file_type"],
+        "args": ["type_string"],
         "stopAtEntry": false,
         "cwd": "/home/daniele/git/simple-json-validator/build/",
         "environment": [],

data/input_01.json

@@ -7,7 +7,7 @@
                     0,
                     0
                 ],
-                "rotation": -30,
+                "rotation": [-30],
                 "scale": [
                     5,
                     0.02
@@ -27,8 +27,8 @@
                     0.26,
                     0.4503
                 ],
-                "rotation": -30,
-                "scale": 1.0
+                "rotation": [-30],
+                "scale": [1.0]
             },
             "volume_selection": "../data/dummy.txt",
             "surface_selection": 2,

data/rules_01.json

@@ -6,74 +6,95 @@
         "doc": "Root of the configuration file."
     },
     {
-        "pointer": "/geometry/",
+        "pointer": "/geometry",
+        "type": "list",
+        "min": 1,
+        "doc": "List of /geometry objects."
+    },
+    {
+        "pointer": "/geometry/*",
         "type": "object",
         "required": ["mesh"],
         "optional": ["transformation","volume_selection","surface_selection","n_refs","advanced"],
         "doc": "Each geometry object stores a mesh, a set of transformations applied to it after loading, and a set of selections, which can be used to specify boundary conditions and materials."
     },
     {
-        "pointer": "/geometry/mesh/",
+        "pointer": "/geometry/*/mesh",
         "type": "file",
         "extensions": [".obj",".msh"],
         "doc": "Path of the mesh file to load."
     },
     {
-        "pointer": "/geometry/transformation/",
+        "pointer": "/geometry/*/transformation",
         "type": "object",
         "default": null,
         "optional": ["translation","rotation","scale"],
         "doc": "Geometric transformations applied to the geometry after loading it."
     },
     {
-        "pointer": "/geometry/transformation/translation/",
+        "pointer": "/geometry/*/transformation/translation",
+        "type": "list",
+        "default": null
+    },
+    {
+        "pointer": "/geometry/*/transformation/rotation",
+        "type": "list",
+        "default": null
+    },
+    {
+        "pointer": "/geometry/*/transformation/scale",
+        "type": "list",
+        "default": null
+    },
+    {
+        "pointer": "/geometry/*/transformation/translation/*",
         "type": "float",
         "default": [0,0,0],
         "doc": "Translation vector (2 entries for 2D problems, 3 entries for 3D problems)."
     },
     {
-        "pointer": "/geometry/transformation/rotation/",
+        "pointer": "/geometry/*/transformation/rotation/*",
         "default": 0,
         "type": "float"
     },
     {
-        "pointer": "/geometry/transformation/scale/",
+        "pointer": "/geometry/*/transformation/scale/*",
         "default": 0,
         "type": "float"
     },
     {
-        "pointer": "/geometry/volume_selection/",
+        "pointer": "/geometry/*/volume_selection",
         "type": "int",
         "default": 0
     },
     {
-        "pointer": "/geometry/volume_selection/",
+        "pointer": "/geometry/*/volume_selection",
         "type": "file",
         "extensions": [".txt"]
     },
     {
-        "pointer": "/geometry/surface_selection/",
+        "pointer": "/geometry/*/surface_selection",
         "type": "int",
         "default": null
     },
     {
-        "pointer": "/geometry/surface_selection/",
+        "pointer": "/geometry/*/surface_selection",
         "type": "file",
         "extensions": [".txt"]
     },
     {
-        "pointer": "/geometry/n_refs/",
+        "pointer": "/geometry/*/n_refs",
         "type": "int",
         "default": 0
     },
     {
-        "pointer": "/geometry/advanced/",
+        "pointer": "/geometry/*/advanced",
         "type": "object",
         "optional": ["normalize_mesh"],
         "default": null
     },
     {
-        "pointer": "/geometry/advanced/normalize_mesh/",
+        "pointer": "/geometry/*/advanced/normalize_mesh",
         "type": "bool",
         "default": false
     }

src/sjv/sjv.cpp

@@ -15,24 +15,9 @@ namespace sjv
 
     bool SJV::verify_json(const string &pointer, const json &input, const json &rules)
     {
-        // Polymorphism on list, 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)
-                if (!verify_json(pointer, i, rules))
-                    return false;
-            return true;
-        }
-
         // Find all rules that apply for the input node
         // TODO: accelerate this
-        std::vector<json> matching_rules;
-        for (auto i : rules)
-        {
-            if (i.at("pointer") == pointer)
-                matching_rules.push_back(i);
-        }
+        std::vector<json> matching_rules = collect_pointer(pointer, rules);
 
         // There must be at least one, otherwise warning and return true if not strict
         if (matching_rules.empty())
@@ -52,6 +37,16 @@ namespace sjv
 
         if (count == 0 && !matching_rules.empty())
         {
+            // Before giving up, try boxing a primitive type
+            if (boxing_primitive && !input.is_array())
+            {
+                string new_pointer = (pointer == "/" ? "" : pointer) + "/*";
+                // Make sure there are some rules for the boxed version before recursively checking
+                if (collect_pointer(new_pointer, rules).size() > 0)
+                    if (verify_json(new_pointer, input, rules))
+                      return true;
+            }
+
             std::stringstream s;
             s << "No valid rules in this list:";
             for (auto i : matching_rules)
@@ -71,52 +66,62 @@ namespace sjv
         }
 
         // If it passes and if it is a dictionary, then test all childrens
-        if (input.is_structured())
+        if (input.is_object())
             for (auto &i : input.items())
             {
-                string new_pointer = pointer + i.key() + "/";
+                string new_pointer = (pointer == "/" ? "" : pointer) + "/" + i.key();
                 // first of all, let's check if the specs are correct
-                json defaults = collect_default_rules(new_pointer,rules); 
+                json defaults = collect_default_rules(new_pointer, rules);
 
                 // if it is mandatory, make sure there are no defaults
-                if (matching_rules[0].contains("required") && contained_in_list(i.key(),matching_rules[0]["required"]))
+                if (matching_rules[0].contains("required") && contained_in_list(i.key(), matching_rules[0]["required"]))
                 {
                     if (defaults.size() != 0)
                     {
-                        log.push_back(log_item("error","Inconsistent specifications: " + new_pointer + " is a mandatory field with a default value."));
+                        log.push_back(log_item("error", "Inconsistent specifications: " + new_pointer + " is a mandatory field with a default value."));
                         return false;
                     }
                 }
                 // if it is optional, there should be only one default in the specs
-                else if (matching_rules[0].contains("optional") && contained_in_list(i.key(),matching_rules[0]["optional"]))
+                else if (matching_rules[0].contains("optional") && contained_in_list(i.key(), matching_rules[0]["optional"]))
                 {
                     if (defaults.size() != 1)
                     {
-                        log.push_back(log_item("error","Inconsistent specifications: " + new_pointer + " is an optional field with " + std::to_string(defaults.size()) + " default values."));
+                        log.push_back(log_item("error", "Inconsistent specifications: " + new_pointer + " is an optional field with " + std::to_string(defaults.size()) + " default values."));
                         return false;
                     }
                 }
                 // if it is not mandatory and not optional, something is wrong
                 else
                 {
-                    log.push_back(log_item("warning","Inconsistent specifications: " + new_pointer + " is neither an optional or a mandatory field."));
+                    log.push_back(log_item("warning", "Inconsistent specifications: " + new_pointer + " is neither an optional or a mandatory field."));
                     if (strict)
                         return false;
                 }
 
                 // now let's make sure it can be validated
                 if (!verify_json(new_pointer, i.value(), rules))
                     return false;
-
             }
 
+        // In case of a list
+        // All the elements in the list must pass the test
+        if (input.is_array())
+        {
+            for (auto i : input)
+                if (!verify_json((pointer == "/" ? "" : pointer) + "/*", i, rules))
+                    return false;
+        }
+
         // If they all pass, return true
         return true;
     };
     bool SJV::verify_rule(const json &input, const json &rule)
     {
         string type = rule.at("type");
-        if (type == "float")
+        if (type == "list")
+            return verify_rule_list(input, rule);
+        else if (type == "float")
             return verify_rule_float(input, rule);
         else if (type == "int")
             return verify_rule_int(input, rule);
@@ -152,7 +157,7 @@ namespace sjv
             if (strict)
                 return false;
         }
-                
+
         if (rule.contains("extensions"))
         {
             std::string ext = p.extension();
@@ -179,7 +184,7 @@ namespace sjv
             if (strict)
                 return false;
         }
-                
+
         return true;
     };
     bool SJV::verify_rule_float(const json &input, const json &rule)
@@ -255,6 +260,22 @@ namespace sjv
         return true;
     };
 
+    bool SJV::verify_rule_list(const json &input, const json &rule)
+    {
+        assert(rule.at("type") == "list");
+
+        if (!input.is_array())
+            return false;
+
+        if (rule.contains("min") && !(input.size() >= rule["min"]))
+            return false;
+
+        if (rule.contains("max") && !(input.size() <= rule["max"]))
+            return false;
+
+        return true;
+    }
+
     std::string SJV::log2str()
     {
         std::stringstream s;
@@ -265,7 +286,7 @@ namespace sjv
         }
         return s.str();
     };
-    
+
     json SJV::collect_default_rules(const string &pointer, const json &rules)
     {
         // Find all rules that apply for the input node
@@ -281,8 +302,19 @@ namespace sjv
         return matching_rules;
     };
 
-    bool SJV::contained_in_list(string item, const json& list)
+    bool SJV::contained_in_list(string item, const json &list)
+    {
+        return std::find(list.begin(), list.end(), item) != list.end();
+    };
+
+    std::vector<json> SJV::collect_pointer(const string& pointer, const json& rules)
     {
-        return std::find(list.begin(),list.end(),item) != list.end();
+        std::vector<json> matching_rules;
+        for (auto i : rules)
+        {
+            if (i.at("pointer") == pointer)
+                matching_rules.push_back(i);
+        }
+        return matching_rules;
     };
 } // namespace sjv

src/sjv/sjv.h

@@ -15,7 +15,7 @@ namespace sjv
         // verify the input json against the set of rules in specs
         bool verify_json(const json &input, const json &rules);
 
-        // Verify a node pointed by 
+        // Verify a node pointed by
         bool verify_json(const string &pointer, const json &input, const json &rules);
 
         // Dispatcher for rule verification
@@ -29,9 +29,7 @@ namespace sjv
         bool verify_rule_string(const json &input, const json &rule);
         bool verify_rule_object(const json &input, const json &rule);
         bool verify_rule_bool(const json &input, const json &rule);
-
-        // Collect all rules having a default for a given pointer
-        json collect_default_rules(const string &pointer, const json &rules);
+        bool verify_rule_list(const json &input, const json &rule);
 
         // TODO
         json generate_default_json(const json &rules);
@@ -42,15 +40,25 @@ namespace sjv
         // if strict == false, a json is valid even if it has entries not validated by a rule
         bool strict = false;
 
+        // automatic boxing for primitive types
+        // if all rules fail for a basic type, try boxing it once and try again
+        bool boxing_primitive = true;
+
         // message list
-        typedef std::pair<std::string,std::string> log_item;
+        typedef std::pair<std::string, std::string> log_item;
         std::vector<log_item> log;
 
         // log to string
         std::string log2str();
 
+        // Collect all rules having a default for a given pointer
+        json collect_default_rules(const string &pointer, const json &rules);
+
+        // Collect all rules having a given pointer
+        std::vector<json> collect_pointer(const string &pointer, const json &rules);
+
         // Utils
-        bool contained_in_list(string item, const json& list);
+        bool contained_in_list(string item, const json &list);
     };
 
 } // namespace sjv