recursive visitor and prototypes

Author: danielepanozzo

.vscode/launch.json

@@ -0,0 +1,25 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+      {
+        "name": "C/C++: g++ build and debug active file",
+        "type": "cppdbg",
+        "request": "launch",
+        "program": "/home/daniele/git/simple-json-validator/build/tests/unit_tests",
+        "args": [],
+        "stopAtEntry": false,
+        "cwd": "${workspaceFolder}",
+        "environment": [],
+        "externalConsole": false,
+        "MIMode": "gdb",
+        "miDebuggerPath": "/usr/bin/gdb",
+        "setupCommands": [
+          {
+            "description": "Enable pretty-printing for gdb",
+            "text": "-enable-pretty-printing",
+            "ignoreFailures": true
+          }
+        ],
+      }
+    ]
+  }

data/input-rules.json

@@ -1,67 +1,68 @@
 [
     {
-        "name": "defaults",
+        "pointer": "defaults",
         "type": "file",
         "format": ["json"],
         "doc" : "path to another JSON file containing the default parameters (this file will be patched on top of the defaults)"
     },
     {
-        "name": "root_path",
+        "pointer": "root_path",
         "type": "path",
         "required": true,
         "doc": "path to root director in the simulation (by default this is the directory containing this JSON file, so other paths can  be relative to the JSON's path)"
     },
     {
-        "name": "geometry",
-        "type": "[dict]",
+        "pointer": "geometry",
+        "type": "dict",
         "required": true,
+        "list_allowed": true
         "doc": "This is the geometry"
     },
     {
-        "name": "geometry",
+        "pointer": "geometry",
         "type": "dict",
         "required": true,
         "doc": "This is the geometry"
     },
     {
-        "name": "geometry/type",
+        "pointer": "geometry/type",
         "type": "multiplechoice",
         "choices": ["mesh", "plane"],
         "default": "mesh",
         "doc": "What type of geometry is this? (for now only mesh is implemented)"
     },
     {
-        "name": "geometry/mesh",
+        "pointer": "geometry/mesh",
         "type": "file",
         "required": true,
         "fileformat": ["obj","msh"],
         "doc": "Path to mesh file"
     },
     {
-        "name": "geometry/surface_selection",
+        "pointer": "geometry/surface_selection",
         "type": "dict",
         "required_fields": ["id","axis","position"],
         "doc": "Describes a surface selection"        
     },
     {
-        "name": "geometry/surface_selection",
+        "pointer": "geometry/surface_selection",
         "type": "integer",
         "min": 0,
 
     },
     {
-        "name": "geometry/surface_selection",
+        "pointer": "geometry/surface_selection",
         "type": "file",
         "format": ["txt"],
     },
     {
-        "name": "geometry/volume_selection",
+        "pointer": "geometry/volume_selection",
         "like": "geometry/surface_selection",
         "doc": "The following are different ways to specify volume_selection"
     }
 ]
 
 * accepts both lists or single elements transparently
-* if multiple rules apply to the same name, just one needs to pass
+* if multiple rules apply to the same pointer, just one needs to pass
 * any type becomes a list with "[]"
 * warnings if some fields do not have rules

src/sjv/sjv.cpp

@@ -1,9 +1,91 @@
 ////////////////////////////////////////////////////////////////////////////////
 #include <sjv/sjv.h>
-
+#include <iostream>
 ////////////////////////////////////////////////////////////////////////////////
 
 namespace sjv
 {
-    
-}
+    bool sjv::verify_json(const json &input, const json &rules)
+    {
+        return verify_json("/", input, rules);
+    }
+
+    bool sjv::verify_json(const string &pointer, const json &input, const json &rules)
+    {
+        try
+        {
+
+            // Polymorphism on list, for us a single item or a list are indistinguishable
+            if (input.is_array())
+                for (auto i : input)
+                    verify_json(pointer, i, 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)
+                    matching_rules.push_back(i);
+            }
+
+            // There must be at least one, otherwise warning
+            if (matching_rules.empty())
+                std::cout << "WARNING: "
+                          << "Unknown entry " << pointer << std::endl;
+
+            // Test all rules, only one must pass, otherwise throw exception
+            int count = 0;
+
+            for (auto i : matching_rules)
+                if (verify_rule(input, i))
+                    count++;
+
+            if (count != 1)
+                throw matching_rules;
+
+            // If it passes and if it is a dictionary, then test all childrens
+            if (input.is_structured())
+                for (auto &i : input.items())
+                    verify_json(pointer + i.key() + "/", i.value(), rules);
+
+            // 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;
+    };
+    bool sjv::verify_rule_file(const json &input, const json &rule)
+    {
+        return false;
+    };
+    bool sjv::verify_rule_double(const json &input, const json &rule)
+    {
+        return false;
+    };
+    bool sjv::verify_rule_int(const json &input, const json &rule)
+    {
+        return false;
+    };
+    bool sjv::verify_rule_path(const json &input, const json &rule)
+    {
+        return false;
+    };
+    bool sjv::verify_rule_string(const json &input, const json &rule)
+    {
+        return false;
+    };
+    bool sjv::verify_rule_dict(const json &input, const json &rule)
+    {
+        return false;
+    };
+
+} // namespace sjv

src/sjv/sjv.h

@@ -1,13 +1,34 @@
 #pragma once
 
-////////////////////////////////////////////////////////////////////////////////
 #include <nlohmann/json.hpp>
-using json = nlohmann::json;
-
+#include <string>
 #include <memory>
-////////////////////////////////////////////////////////////////////////////////
+
+using json = nlohmann::json;
+using string = std::string;
 
 namespace sjv
 {
+    class sjv
+    {
+    public:
+        // verify the input json against the set of rules in specs
+        bool verify_json(const json &input, const json &rules);
+        bool verify_json(const string &pointer, const json &input, const json &rules);
+
+        // Dispatcher for rule verification
+        bool verify_rule(const json &input, const json &rule);
+
+        // 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_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;
+    };
 
 } // namespace sjv

tests/test_validator.cpp

@@ -9,9 +9,27 @@
 
 using namespace sjv;
 
-
-TEST_CASE("eigen_params", "[solver]")
+TEST_CASE("single_rule", "[validator]")
 {
-    REQUIRE(true);
+    json input = R"( 
+        {
+            "field1": "string", 
+            "field2": 42 
+        }
+        )"_json;
+
+    json rules = R"( 
+        [
+        {
+            "pointer": "/",
+            "type": "dict",
+            "key_fields": ["field1"],
+            "mandatory_fields": ["field1"]
+        }
+        ]
+        )"_json;
+
+    sjv::sjv sjv;
 
+    REQUIRE(sjv.verify_json(input,rules));
 }