passes tests again

danielepanozzo · danielepanozzo · commit 9b289aad9f38 · 2022-06-16T11:22:46.000-04:00
diff --git a/.vscode/launch.json b/.vscode/launch.json
@@ -6,7 +6,7 @@
         "type": "cppdbg",
         "request": "launch",
         "program": "/home/daniele/git/simple-json-validator/build/tests/unit_tests",
-        "args": ["file_01"],
+        "args": ["file_type"],
         "stopAtEntry": false,
         "cwd": "/home/daniele/git/simple-json-validator/build/",
         "environment": [],
diff --git a/README.md b/README.md
@@ -0,0 +1,5 @@
+1. write a function to complete fields with default
+2. write a function to find all children of a pointer
+3. vector type
+4. * 
+
diff --git a/data/rules_01.json b/data/rules_01.json
@@ -9,6 +9,7 @@
         "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."
     },
     {
@@ -20,24 +21,30 @@
     {
         "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/",
         "type": "float",
+        "default": [0,0,0],
         "doc": "Translation vector (2 entries for 2D problems, 3 entries for 3D problems)."
     },
     {
         "pointer": "/geometry/transformation/rotation/",
+        "default": 0,
         "type": "float"
     },
     {
         "pointer": "/geometry/transformation/scale/",
+        "default": 0,
         "type": "float"
     },
     {
         "pointer": "/geometry/volume_selection/",
-        "type": "int"
+        "type": "int",
+        "default": 0
     },
     {
         "pointer": "/geometry/volume_selection/",
@@ -46,7 +53,8 @@
     },
     {
         "pointer": "/geometry/surface_selection/",
-        "type": "int"
+        "type": "int",
+        "default": null
     },
     {
         "pointer": "/geometry/surface_selection/",
@@ -55,15 +63,19 @@
     },
     {
         "pointer": "/geometry/n_refs/",
-        "type": "int"
+        "type": "int",
+        "default": 0
     },
     {
         "pointer": "/geometry/advanced/",
-        "type": "object"
+        "type": "object",
+        "optional": ["normalize_mesh"],
+        "default": null
     },
     {
         "pointer": "/geometry/advanced/normalize_mesh/",
-        "type": "bool"
+        "type": "bool",
+        "default": false
     }
 
 ]
diff --git a/src/sjv/sjv.cpp b/src/sjv/sjv.cpp
@@ -73,18 +73,50 @@ namespace sjv
         // If it passes and if it is a dictionary, then test all childrens
         if (input.is_structured())
             for (auto &i : input.items())
-                if (!verify_json(pointer + i.key() + "/", i.value(), rules))
+            {
+                string new_pointer = pointer + i.key() + "/";
+                // first of all, let's check if the specs are correct
+                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 (defaults.size() != 0)
+                    {
+                        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"]))
+                {
+                    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."));
+                        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."));
+                    if (strict)
+                        return false;
+                }
+
+                // now let's make sure it can be validated
+                if (!verify_json(new_pointer, i.value(), 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 == "skip_check")
-            return true;
-        else if (type == "float")
+        if (type == "float")
             return verify_rule_float(input, rule);
         else if (type == "int")
             return verify_rule_int(input, rule);
@@ -233,4 +265,24 @@ 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
+        // TODO: accelerate this
+
+        std::vector<json> matching_rules;
+        for (auto i : rules)
+        {
+            if (i.at("pointer") == pointer && i.contains("default"))
+                matching_rules.push_back(i);
+        }
+
+        return matching_rules;
+    };
+
+    bool sjv::contained_in_list(string item, const json& list)
+    {
+        return std::find(list.begin(),list.end(),item) != list.end();
+    };
 } // namespace sjv
diff --git a/src/sjv/sjv.h b/src/sjv/sjv.h
@@ -14,6 +14,8 @@ namespace sjv
     public:
         // 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 
         bool verify_json(const string &pointer, const json &input, const json &rules);
 
         // Dispatcher for rule verification
@@ -28,6 +30,12 @@ namespace sjv
         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);
+
+        // TODO
+        json generate_default_json(const json &rules);
+
         // Working directory
         string cwd = ".";
 
@@ -40,6 +48,9 @@ namespace sjv
 
         // log to string
         std::string log2str();
+
+        // Utils
+        bool contained_in_list(string item, const json& list);
     };
 
 } // namespace sjv
diff --git a/tests/test_validator.cpp b/tests/test_validator.cpp
@@ -21,15 +21,16 @@ TEST_CASE("single_rule", "[validator]")
         [
         {
             "pointer": "/",
-            "type": "skip_check"
+            "type": "object"
         }
         ]
         )"_json;
 
     sjv::sjv sjv;
 
-    REQUIRE(sjv.verify_json(input,rules));
-
+    bool b = sjv.verify_json(input,rules);
+    INFO(sjv.log2str());
+    REQUIRE(b);
 }
 
 TEST_CASE("only_one_rule_can_be_valid", "[validator]")
@@ -43,18 +44,20 @@ TEST_CASE("only_one_rule_can_be_valid", "[validator]")
         [
         {
             "pointer": "/",
-            "type": "skip_check"
+            "type": "object"
         },
         {
             "pointer": "/",
-            "type": "skip_check"
+            "type": "object"
         }
         ]
         )"_json;
 
     sjv::sjv sjv;
 
-    REQUIRE(!sjv.verify_json(input,rules));
+    bool b = sjv.verify_json(input,rules);
+    INFO(sjv.log2str());
+    REQUIRE(!b);
 }
 
 TEST_CASE("min_bound_numeric", "[validator]")
@@ -69,7 +72,8 @@ TEST_CASE("min_bound_numeric", "[validator]")
         [
         {
             "pointer": "/",
-            "type": "skip_check"
+            "type": "object",
+            "required": ["field1"]
         },
         {
             "pointer": "/field1/",
@@ -81,11 +85,15 @@ TEST_CASE("min_bound_numeric", "[validator]")
 
     sjv::sjv sjv;
 
-    REQUIRE(sjv.verify_json(input,rules));
+    bool b = sjv.verify_json(input,rules);
+    INFO(sjv.log2str());
+    REQUIRE(b);
 
     input["field1"] = 40.5;
 
-    REQUIRE(!sjv.verify_json(input,rules));
+    b = sjv.verify_json(input,rules);
+    INFO(sjv.log2str());
+    REQUIRE(!b);
 }
 
 TEST_CASE("file_type", "[validator]")
@@ -100,28 +108,40 @@ TEST_CASE("file_type", "[validator]")
         [
         {
             "pointer": "/",
-            "type": "skip_check"
+            "type": "object",
+            "optional": ["file1"]
         },
         {
             "pointer": "/file1/",
             "type": "file",
-            "extensions": [".txt"]
+            "extensions": [".txt"],
+            "default": "somestring"
         }
         ]
         )"_json;
 
     sjv::sjv sjv;
+    bool b;
+
     sjv.cwd = std::filesystem::current_path();
+    sjv.strict = true;
 
-    REQUIRE(!sjv.verify_json(input,rules));
+    b = sjv.verify_json(input,rules);
+    
+    INFO(sjv.log2str());
+    REQUIRE(!b);
 
     input["file1"] = "CMakeCache.txt";
 
-    REQUIRE(sjv.verify_json(input,rules));
+    b = sjv.verify_json(input,rules);
+    INFO(sjv.log2str());
+    REQUIRE(b);
 
     rules[1]["extensions"][0] = ".msh";
 
-    REQUIRE(!sjv.verify_json(input,rules));
+    b = sjv.verify_json(input,rules);
+    INFO(sjv.log2str());
+    REQUIRE(!b);
 
 }
 
@@ -137,7 +157,7 @@ TEST_CASE("type_string", "[validator]")
         [
         {
             "pointer": "/",
-            "type": "skip_check"
+            "type": "object"
         },
         {
             "pointer": "/string1/",
@@ -148,15 +168,22 @@ TEST_CASE("type_string", "[validator]")
 
     sjv::sjv sjv;
 
-    REQUIRE(sjv.verify_json(input,rules));
+    bool b;
+    b = sjv.verify_json(input,rules);
+    INFO(sjv.log2str());
+    REQUIRE(b);
 
     rules[1]["options"][0] = "blah";
 
-    REQUIRE(!sjv.verify_json(input,rules));
+    b = sjv.verify_json(input,rules);
+    INFO(sjv.log2str());
+    REQUIRE(!b);
 
     rules[1]["options"][1] = "teststring";
 
-    REQUIRE(sjv.verify_json(input,rules));
+    b = sjv.verify_json(input,rules);
+    INFO(sjv.log2str());
+    REQUIRE(b);
 
 }
 

Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,7 @@`
`9`	`9`	`"pointer": "/geometry/",`
`10`	`10`	`"type": "object",`
`11`	`11`	`"required": ["mesh"],`
	`12`	`+ "optional": ["transformation","volume_selection","surface_selection","n_refs","advanced"],`
`12`	`13`	`"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."`
`13`	`14`	`},`
`14`	`15`	`{`
`@@ -20,24 +21,30 @@`
`20`	`21`	`{`
`21`	`22`	`"pointer": "/geometry/transformation/",`
`22`	`23`	`"type": "object",`
	`24`	`+ "default": null,`
	`25`	`+ "optional": ["translation","rotation","scale"],`
`23`	`26`	`"doc": "Geometric transformations applied to the geometry after loading it."`
`24`	`27`	`},`
`25`	`28`	`{`
`26`	`29`	`"pointer": "/geometry/transformation/translation/",`
`27`	`30`	`"type": "float",`
	`31`	`+ "default": [0,0,0],`
`28`	`32`	`"doc": "Translation vector (2 entries for 2D problems, 3 entries for 3D problems)."`
`29`	`33`	`},`
`30`	`34`	`{`
`31`	`35`	`"pointer": "/geometry/transformation/rotation/",`
	`36`	`+ "default": 0,`
`32`	`37`	`"type": "float"`
`33`	`38`	`},`
`34`	`39`	`{`
`35`	`40`	`"pointer": "/geometry/transformation/scale/",`
	`41`	`+ "default": 0,`
`36`	`42`	`"type": "float"`
`37`	`43`	`},`
`38`	`44`	`{`
`39`	`45`	`"pointer": "/geometry/volume_selection/",`
`40`		`- "type": "int"`
	`46`	`+ "type": "int",`
	`47`	`+ "default": 0`
`41`	`48`	`},`
`42`	`49`	`{`
`43`	`50`	`"pointer": "/geometry/volume_selection/",`
`@@ -46,7 +53,8 @@`
`46`	`53`	`},`
`47`	`54`	`{`
`48`	`55`	`"pointer": "/geometry/surface_selection/",`
`49`		`- "type": "int"`
	`56`	`+ "type": "int",`
	`57`	`+ "default": null`
`50`	`58`	`},`
`51`	`59`	`{`
`52`	`60`	`"pointer": "/geometry/surface_selection/",`
`@@ -55,15 +63,19 @@`
`55`	`63`	`},`
`56`	`64`	`{`
`57`	`65`	`"pointer": "/geometry/n_refs/",`
`58`		`- "type": "int"`
	`66`	`+ "type": "int",`
	`67`	`+ "default": 0`
`59`	`68`	`},`
`60`	`69`	`{`
`61`	`70`	`"pointer": "/geometry/advanced/",`
`62`		`- "type": "object"`
	`71`	`+ "type": "object",`
	`72`	`+ "optional": ["normalize_mesh"],`
	`73`	`+ "default": null`
`63`	`74`	`},`
`64`	`75`	`{`
`65`	`76`	`"pointer": "/geometry/advanced/normalize_mesh/",`
`66`		`- "type": "bool"`
	`77`	`+ "type": "bool",`
	`78`	`+ "default": false`
`67`	`79`	`}`
`68`	`80`
`69`	`81`	`]`
Original file line number	Diff line number	Diff line change
`@@ -21,15 +21,16 @@ TEST_CASE("single_rule", "[validator]")`
`21`	`21`	`[`
`22`	`22`	`{`
`23`	`23`	`"pointer": "/",`
`24`		`- "type": "skip_check"`
	`24`	`+ "type": "object"`
`25`	`25`	`}`
`26`	`26`	`]`
`27`	`27`	`)"_json;`
`28`	`28`
`29`	`29`	`sjv::sjv sjv;`
`30`	`30`
`31`		`- REQUIRE(sjv.verify_json(input,rules));`
`32`		`-`
	`31`	`+ bool b = sjv.verify_json(input,rules);`
	`32`	`+ INFO(sjv.log2str());`
	`33`	`+ REQUIRE(b);`
`33`	`34`	`}`
`34`	`35`
`35`	`36`	`TEST_CASE("only_one_rule_can_be_valid", "[validator]")`
`@@ -43,18 +44,20 @@ TEST_CASE("only_one_rule_can_be_valid", "[validator]")`
`43`	`44`	`[`
`44`	`45`	`{`
`45`	`46`	`"pointer": "/",`
`46`		`- "type": "skip_check"`
	`47`	`+ "type": "object"`
`47`	`48`	`},`
`48`	`49`	`{`
`49`	`50`	`"pointer": "/",`
`50`		`- "type": "skip_check"`
	`51`	`+ "type": "object"`
`51`	`52`	`}`
`52`	`53`	`]`
`53`	`54`	`)"_json;`
`54`	`55`
`55`	`56`	`sjv::sjv sjv;`
`56`	`57`
`57`		`- REQUIRE(!sjv.verify_json(input,rules));`
	`58`	`+ bool b = sjv.verify_json(input,rules);`
	`59`	`+ INFO(sjv.log2str());`
	`60`	`+ REQUIRE(!b);`
`58`	`61`	`}`
`59`	`62`
`60`	`63`	`TEST_CASE("min_bound_numeric", "[validator]")`
`@@ -69,7 +72,8 @@ TEST_CASE("min_bound_numeric", "[validator]")`
`69`	`72`	`[`
`70`	`73`	`{`
`71`	`74`	`"pointer": "/",`
`72`		`- "type": "skip_check"`
	`75`	`+ "type": "object",`
	`76`	`+ "required": ["field1"]`
`73`	`77`	`},`
`74`	`78`	`{`
`75`	`79`	`"pointer": "/field1/",`
`@@ -81,11 +85,15 @@ TEST_CASE("min_bound_numeric", "[validator]")`
`81`	`85`
`82`	`86`	`sjv::sjv sjv;`
`83`	`87`
`84`		`- REQUIRE(sjv.verify_json(input,rules));`
	`88`	`+ bool b = sjv.verify_json(input,rules);`
	`89`	`+ INFO(sjv.log2str());`
	`90`	`+ REQUIRE(b);`
`85`	`91`
`86`	`92`	`input["field1"] = 40.5;`
`87`	`93`
`88`		`- REQUIRE(!sjv.verify_json(input,rules));`
	`94`	`+ b = sjv.verify_json(input,rules);`
	`95`	`+ INFO(sjv.log2str());`
	`96`	`+ REQUIRE(!b);`
`89`	`97`	`}`
`90`	`98`
`91`	`99`	`TEST_CASE("file_type", "[validator]")`
`@@ -100,28 +108,40 @@ TEST_CASE("file_type", "[validator]")`
`100`	`108`	`[`
`101`	`109`	`{`
`102`	`110`	`"pointer": "/",`
`103`		`- "type": "skip_check"`
	`111`	`+ "type": "object",`
	`112`	`+ "optional": ["file1"]`
`104`	`113`	`},`
`105`	`114`	`{`
`106`	`115`	`"pointer": "/file1/",`
`107`	`116`	`"type": "file",`
`108`		`- "extensions": [".txt"]`
	`117`	`+ "extensions": [".txt"],`
	`118`	`+ "default": "somestring"`
`109`	`119`	`}`
`110`	`120`	`]`
`111`	`121`	`)"_json;`
`112`	`122`
`113`	`123`	`sjv::sjv sjv;`
	`124`	`+ bool b;`
	`125`	`+`
`114`	`126`	`sjv.cwd = std::filesystem::current_path();`
	`127`	`+ sjv.strict = true;`
`115`	`128`
`116`		`- REQUIRE(!sjv.verify_json(input,rules));`
	`129`	`+ b = sjv.verify_json(input,rules);`
	`130`	`+`
	`131`	`+ INFO(sjv.log2str());`
	`132`	`+ REQUIRE(!b);`
`117`	`133`
`118`	`134`	`input["file1"] = "CMakeCache.txt";`
`119`	`135`
`120`		`- REQUIRE(sjv.verify_json(input,rules));`
	`136`	`+ b = sjv.verify_json(input,rules);`
	`137`	`+ INFO(sjv.log2str());`
	`138`	`+ REQUIRE(b);`
`121`	`139`
`122`	`140`	`rules[1]["extensions"][0] = ".msh";`
`123`	`141`
`124`		`- REQUIRE(!sjv.verify_json(input,rules));`
	`142`	`+ b = sjv.verify_json(input,rules);`
	`143`	`+ INFO(sjv.log2str());`
	`144`	`+ REQUIRE(!b);`
`125`	`145`
`126`	`146`	`}`
`127`	`147`
`@@ -137,7 +157,7 @@ TEST_CASE("type_string", "[validator]")`
`137`	`157`	`[`
`138`	`158`	`{`
`139`	`159`	`"pointer": "/",`
`140`		`- "type": "skip_check"`
	`160`	`+ "type": "object"`
`141`	`161`	`},`
`142`	`162`	`{`
`143`	`163`	`"pointer": "/string1/",`
`@@ -148,15 +168,22 @@ TEST_CASE("type_string", "[validator]")`
`148`	`168`
`149`	`169`	`sjv::sjv sjv;`
`150`	`170`
`151`		`- REQUIRE(sjv.verify_json(input,rules));`
	`171`	`+ bool b;`
	`172`	`+ b = sjv.verify_json(input,rules);`
	`173`	`+ INFO(sjv.log2str());`
	`174`	`+ REQUIRE(b);`
`152`	`175`
`153`	`176`	`rules[1]["options"][0] = "blah";`
`154`	`177`
`155`		`- REQUIRE(!sjv.verify_json(input,rules));`
	`178`	`+ b = sjv.verify_json(input,rules);`
	`179`	`+ INFO(sjv.log2str());`
	`180`	`+ REQUIRE(!b);`
`156`	`181`
`157`	`182`	`rules[1]["options"][1] = "teststring";`
`158`	`183`
`159`		`- REQUIRE(sjv.verify_json(input,rules));`
	`184`	`+ b = sjv.verify_json(input,rules);`
	`185`	`+ INFO(sjv.log2str());`
	`186`	`+ REQUIRE(b);`
`160`	`187`
`161`	`188`	`}`
`162`	`189`