Handle includes in python scripts

Author: zfergus

docs/spec2html.py

@@ -6,6 +6,10 @@
 from mako.template import Template
 from mako.lookup import TemplateLookup
 
+import sys
+sys.path.append(str(pathlib.Path(__file__).parents[1] / "scripts"))
+from inject_include import inject_include  # noqa
+
 
 class json_navigator:
     def __init__(self, ijson):
@@ -32,6 +36,9 @@ def rules_from_pointer(self, pointer):
     with open(args.input) as input_file:
         input = json.load(input_file)
 
+    # TODO: Expose the include path as a parameter
+    input = inject_include(input, [pathlib.Path(args.input).parent])
+
     # print(input)
 
     print("02 - Templating")

scripts/generate_defaults.py

@@ -1,6 +1,11 @@
 import argparse
 import json
 from collections import OrderedDict
+import pathlib
+
+import sys
+sys.path.append(str(pathlib.Path(__file__).parent))
+from inject_include import inject_include  # noqa
 
 
 def find_rules(spec, pointer):
@@ -12,11 +17,11 @@ def generate_defaults(spec, root="/"):
     rules = find_rules(spec, root)
 
     default_rule = list(filter(lambda rule: "default" in rule, rules))
-    assert(len(default_rule) <= 1)
+    assert (len(default_rule) <= 1)
 
     object_rules = list(filter(lambda rule: rule["type"] == "object", rules))
 
-    if(default_rule and default_rule[0]["default"] is not None and not object_rules):
+    if (default_rule and default_rule[0]["default"] is not None and not object_rules):
         return default_rule[0]["default"]
     else:
         for i, rule in enumerate(object_rules):
@@ -51,6 +56,9 @@ def main():
     with open(args.spec_path) as f:
         spec = json.load(f)
 
+    # TODO: Expose the include path as a parameter
+    spec = inject_include(spec, [pathlib.Path(args.spec_path).parent])
+
     defaults = generate_defaults(spec)
 
     with open(args.output, "w") as f:

scripts/inject_include.py

@@ -0,0 +1,73 @@
+import json
+import pathlib
+
+
+def prepend_pointer(pointer, key):
+    if key == "/":
+        return pointer
+    elif pointer == "/":
+        return key
+    else:
+        return key + pointer
+
+
+def inject_include(rules: dict, dirs=None):
+    if dirs is None:
+        dirs = []
+    dirs.append("")  # adding default path
+    dirs = [pathlib.Path(d) for d in dirs]
+
+    # max 10 levels of nesting to avoid infinite loops
+    current = rules
+
+    for _ in range(10):
+        # check if the rules have any include
+        include_present = any(rule["type"] == "include" for rule in current)
+
+        # if there are no includes, return the current ones
+        if not include_present:
+            return current
+
+        enriched = []
+        # otherwise, do a round of replacement
+        for rule in current:
+            # copy all rules that are not include
+            if rule["type"] != "include":
+                enriched.append(rule)
+                continue
+
+            # if the rule is an include, expand the node with a copy of the included file
+            replaced = False
+            # the include file could be in any of the include directories
+            for dir in dirs:
+                spec_file = rule["spec_file"]
+                f = dir / spec_file
+                # check if the file exists
+                if f.is_file():
+                    with open(f, 'r') as ifs:
+                        include_rules = json.load(ifs)
+
+                    # loop over all rules to add the prefix
+                    for i_rule in include_rules:
+                        prefix = rule["pointer"]
+                        pointer = i_rule["pointer"]
+                        new_pointer = prepend_pointer(pointer, prefix)
+                        i_rule["pointer"] = new_pointer
+
+                    # save modified rules
+                    for i_rule in include_rules:
+                        enriched.append(i_rule)
+
+                    # one substitution is enough, give up the search over include dirs
+                    replaced = True
+                    break
+
+            if not replaced:
+                pointer = rule["pointer"]
+                raise RuntimeError(
+                    f"Failed to replace the include rule: {pointer}")
+
+        # now that we replaced the include, copy it back to current
+        current = enriched
+
+    raise RuntimeError("Reached maximal 10 levels of include recursion.")