Merge pull request #3 from geometryprocessing/inject_include

danielepanozzo · web-flow · commit 401484eb8210 · 2023-10-13T14:09:23.000-04:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -34,6 +34,7 @@ project(JSE
 option(JSE_WITH_SANITIZERS    "Enable sanitizers in compilation targets"   OFF)
 # Misc.
 option(JSE_WITH_TESTS         "Build unit-tests" ${JSE_TOPLEVEL_PROJECT})
+option(JSE_WITH_APP           "Compiles applications" ${JSE_TOPLEVEL_PROJECT})
 
 include(CMakeDependentOption)
 
@@ -121,3 +122,18 @@ if(JSE_WITH_TESTS)
 
     add_subdirectory(tests)
 endif()
+
+################################################################################
+# Applications
+################################################################################
+
+if(JSE_WITH_APP)
+
+add_executable(jse_app src/main.cpp)
+
+target_compile_options(jse_app PRIVATE "-rdynamic")
+target_link_libraries(jse_app PUBLIC
+    jse::jse
+)
+
+endif()
diff --git a/README.md b/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
diff --git a/data/rules_02.json b/data/rules_02.json
@@ -0,0 +1,12 @@
+[
+    {
+        "pointer": "/",
+        "type": "object",
+        "required": ["field1"]
+    },
+    {
+        "pointer": "/field1",
+        "type": "float",
+        "min": 45
+    }
+]
diff --git a/data/rules_03.json b/data/rules_03.json
@@ -0,0 +1,22 @@
+[
+    {
+        "pointer": "/",
+        "type": "object",
+        "required": ["field1"]
+    },
+    {
+        "pointer": "/field1",
+        "type": "float",
+        "min": 45
+    },
+    {
+        "pointer": "/object1",
+        "type": "object",
+        "required": ["field1"]
+    },
+    {
+        "pointer": "/object1/field1",
+        "type": "float",
+        "min": 45
+    }
+]
diff --git a/data/rules_04.json b/data/rules_04.json
@@ -0,0 +1,12 @@
+[
+{
+    "pointer": "/",
+    "type": "include",
+    "spec_file": "rules_02.json"
+},
+{
+    "pointer": "/object1",
+    "type": "include",
+    "spec_file": "rules_02.json"
+}
+]
diff --git a/src/jse/jse.cpp b/src/jse/jse.cpp
@@ -4,6 +4,7 @@
 #include <filesystem> // C++17
 #include <sstream>
 #include <algorithm>
+#include <fstream>
 ////////////////////////////////////////////////////////////////////////////////
 
 namespace jse
@@ -46,19 +47,114 @@ 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 if (pointer == "/")
+                return key;
+            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 (const 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 (const 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 (const 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");
+                                string new_pointer = prepend_pointer(pointer,prefix);
+                                i_rule.at("pointer") = new_pointer;
+                            }
+
+                            // save modified rules
+                            for (const 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 std::runtime_error("Failed to replace the include rule: " + pointer);
+                        assert(replaced == true);
+                    }
+                }
+            }
+
+            // now that we replaced the include, copy it back to current
+            current = enriched;
+        }
+
+        throw std::runtime_error("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 +312,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 +460,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
diff --git a/src/jse/jse.h b/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);
diff --git a/src/main.cpp b/src/main.cpp
@@ -0,0 +1,57 @@
+#include <iostream>
+#include <cstdlib>
+#include <jse/jse.h>
+#include <string>
+#include <vector>
+#include <fstream>
+
+
+using namespace std;
+using namespace jse;
+
+int main(int argc, char *argv[]) {
+    try
+    {
+
+        if (argc < 3) {
+            cerr << "This utility recursively replaces the include rules with their corresponding rule files." << endl;
+            cerr << "Usage: " << argv[0] << " input.json output.json folder1 folder2 ..." << endl;
+            return EXIT_FAILURE;
+        }
+
+        // First parameter is the input json
+        string sinput = argv[1];
+
+        // Second parameter is the output json
+        string soutput = argv[2];
+
+        // Other parameters are optional include directories
+        // where the parser will look for rule files
+        vector<std::string> arg;
+        for (size_t i=3;i<argc;++i)
+            arg.push_back(string(argv[i]));
+
+        // Initialize JSE
+        JSE jse;
+        jse.include_directories = arg;
+
+        // Load the input json
+        std::ifstream input_f(sinput);
+        json rules = json::parse(input_f);
+
+        // Try to replace the includes, might throw exceptions
+        json new_rules = jse.inject_include(rules);
+
+        // Write the new rule file
+        std::ofstream file(soutput);
+        file << new_rules;
+
+        return EXIT_SUCCESS;
+    }
+    catch(const std::exception &exc)
+    {
+        std::cout << exc.what() << std::endl;
+        return EXIT_FAILURE;
+    }
+
+}
diff --git a/tests/test_validator.cpp b/tests/test_validator.cpp
@@ -219,6 +219,38 @@ 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"
+        },
+        {
+            "pointer": "/object1",
+            "type": "include",
+            "spec_file": "rules_02.json"
+        }
+        ]
+        )"_json;
+
+    JSE jse;
+    jse.include_directories.push_back(root_path);
+    json new_rules = jse.inject_include(rules);
+
+    std::ifstream ifs2(root_path + "/rules_03.json");
+    json matching = json::parse(ifs2);
+
+    INFO(new_rules);
+    INFO(matching);
+
+    INFO(jse.log2str());
+    REQUIRE(new_rules == matching);
+}
+
+
 TEST_CASE("file_01", "[validator]")
 {
     std::ifstream ifs1(root_path + "/input_01.json");
