added possibility to include spec files

Author: danielepanozzo

README.md

@@ -150,15 +150,23 @@ Optional parameters:
 
 The entry must be a boolean value.
 
+### "type": "include"
+
+Mandatory parameter: 
+* spec_file: ["spec.json"]
+
+The entry must be valid with respect to the json spec provided in spec_file. spec_file can be a global path, or relative to the paths provided in the advanced option jse.include_directories
+
 ## Defaults
 
 Every rule associated with an optional parameter of an object must specify a default value, using the default field.
 
 # Advanced options
 ```cpp
-jse.strict            // DEFAULT: false - if strict == false, a json is valid even if it has entries not validated by a rule
-jse.skip_file_check   // DEFAULT: true - disable checking for existance of file and folders
-jse.boxing_primitive  // DEFAULT: true - always try to convert any type t to a list of t for the purpose of finding a valid rule
+jse.strict              // DEFAULT: false - if strict == false, a json is valid even if it has entries not validated by a rule
+jse.skip_file_check     // DEFAULT: true - disable checking for existance of file and folders
+jse.boxing_primitive    // DEFAULT: true - always try to convert any type t to a list of t for the purpose of finding a valid rule
+jse.include_directories // DEFAULT: empty - list of strings containing additional paths where json spec are possibly located
 ```
 
 ## Authors

data/rules_02.json

@@ -0,0 +1,12 @@
+[
+    {
+        "pointer": "/",
+        "type": "object",
+        "required": ["field1"]
+    },
+    {
+        "pointer": "/field1",
+        "type": "float",
+        "min": 45
+    }
+]

src/jse/jse.cpp

@@ -4,6 +4,7 @@
 #include <filesystem> // C++17
 #include <sstream>
 #include <algorithm>
+#include <fstream>
 ////////////////////////////////////////////////////////////////////////////////
 
 namespace jse
@@ -46,19 +47,111 @@ namespace jse
 
     namespace
     {
+        // adds key after the provided pointer, correctly handling the json special case that root has an ending /
         std::string append_pointer(const std::string &pointer, const std::string &key)
         {
             if (pointer == "/")
                 return "/" + key;
             else
                 return pointer + "/" + key;
         }
+
+        // adds key before the provided pointer, correctly handling the json special case that root has an ending /
+        std::string prepend_pointer(const std::string &pointer, const std::string &key)
+        {
+            if (key == "/")
+                return pointer;
+            else
+                return key + "/" + pointer;
+        }
+
     } // namespace
 
+
+    // enriches a given json spec with included json specs
+    json JSE::inject_include(const json &rules)
+    {
+        std::vector<string> dirs = include_directories;
+        dirs.push_back(""); // adding default path
+
+        // max 10 levels of nesting to avoid infinite loops
+        json current = rules;
+
+        for (size_t x = 0; x < 10; x++)
+        {
+            // check if the rules have any include
+            bool include_present = false;
+            for (auto rule : current)
+                if (rule.at("type") == "include")
+                    include_present = true;
+            
+            // if there are no includes, return the current ones
+            if (!include_present)
+                return current;
+
+            json enriched;
+            // otherwise, do a round of replacement
+            for (auto rule : current)
+            {
+                // copy all rules that are not include
+                if (rule.at("type") != "include") 
+                {
+                    enriched.push_back(rule);
+                }
+                // if the rule is an include, expand the node with a copy of the included file
+                else
+                {
+                    bool replaced = false;
+                    // the include file could be in any of the include directories
+                    for (auto dir : dirs)
+                    {
+                        string spec_file = rule.at("spec_file");
+                        string f = dir + spec_file;
+                        // check if the file exists
+                        if (std::filesystem::is_regular_file(f))
+                        {
+                            std::ifstream ifs(f);
+                            json include_rules = json::parse(ifs);
+
+                            // loop over all rules to add the prefix
+                            for (auto i_rule : include_rules)
+                            {
+                                string prefix = rule.at("pointer");
+                                string pointer = i_rule.at("pointer");
+                                i_rule.at("pointer") = prepend_pointer(pointer,prefix);
+                            }
+
+                            // save modified rules
+                            for (auto i_rule : include_rules)
+                                enriched.push_back(i_rule);
+
+                            // one substitution is enough, give up the search over include dirs
+                            replaced = true;
+                            break;
+                        }
+
+                    }
+
+                    if (!replaced)
+                    {
+                        string pointer = rule.at("pointer");
+                        throw("Failed to replace the include rule: " + pointer);
+                        assert(replaced == true);
+                    }
+                }
+            }
+
+            // now that we replaced the include, copy it back to current
+            current = enriched;
+        }
+
+        throw("Reached maximal 10 levels of include recursion.");
+
+    }
+
+
     bool JSE::verify_json(const string &pointer, json &input, const json &rules)
     {
-        // if (pointer == "/common")
-        //     std::cout << "gotcha" << std::endl;
         // Find all rules that apply for the input node
         // TODO: accelerate this
         std::vector<json> matching_rules = collect_pointer(pointer, rules);
@@ -216,6 +309,8 @@ namespace jse
             return verify_rule_object(input, rule);
         else if (type == "bool")
             return verify_rule_bool(input, rule);
+        else if (type == "include")
+            return verify_rule_include(input, rule);
         else
         {
             log.push_back(log_item("error", "Unknown rule type " + type));
@@ -362,6 +457,14 @@ namespace jse
         return true;
     }
 
+    bool JSE::verify_rule_include(const json &input, const json &rule)
+    {
+        assert(rule.at("type") == "include");
+
+        // An include rule always fails, they should be processed first by the inject_include function
+        return false;
+    }
+
     json JSE::collect_default_rules(const json &rules)
     {
         // Find all rules that apply for the input node

src/jse/jse.h

@@ -18,6 +18,9 @@ namespace jse
         // enriches a given json with default values
         json inject_defaults(const json &input, const json &rules);
 
+        // enriches a given json spec with included json specs
+        json inject_include(const json &rules);
+
         // log to string
         std::string log2str();
 
@@ -26,7 +29,13 @@ namespace jse
 
         // if strict == false, a json is valid even if it has entries not validated by a rule
         bool strict = false;
+
+        // do not check the existance of the file pointed in file nodes
         bool skip_file_check = true;
+
+        // additional directories which can be used for relative paths
+        std::vector<string> include_directories;
+
         // automatic boxing for primitive types
         // if all rules fail for a basic type, try boxing it once and try again
         bool boxing_primitive = true;
@@ -51,6 +60,7 @@ namespace jse
         bool verify_rule_object(const json &input, const json &rule);
         bool verify_rule_bool(const json &input, const json &rule);
         bool verify_rule_list(const json &input, const json &rule);
+        bool verify_rule_include(const json &input, const json &rule);
 
         // Collect all rules having a default
         json collect_default_rules(const json &rules);

tests/test_validator.cpp

@@ -219,6 +219,39 @@ TEST_CASE("type_object", "[validator]")
     REQUIRE(!jse.verify_json(input, rules));
 }
 
+TEST_CASE("include_rule", "[validator]")
+{
+    json rules = R"(
+        [
+        {
+            "pointer": "/",
+            "type": "include",
+            "spec_file": "rules_02.json"
+        }
+        ]
+        )"_json;
+        // ,
+        // {
+        //     "pointer": "/object1",
+        //     "type": "include",
+        //     "spec_file": "rules_02.json"
+        // }
+
+
+
+
+    JSE jse;
+    jse.include_directories.push_back(root_path);
+    json new_rules = jse.inject_include(rules);
+
+    std::ifstream ifs2(root_path + "/rules_01.json");
+    json matching = json::parse(ifs2);
+
+    INFO(jse.log2str());
+    REQUIRE(new_rules == matching);
+}
+
+
 TEST_CASE("file_01", "[validator]")
 {
     std::ifstream ifs1(root_path + "/input_01.json");