Refactor some internal variables, add -P toggle for smp_-prefixing

5 files changed, 59 insertions, 45 deletions

diff --git a/src/skaldpress/macros.py b/src/skaldpress/macros.py
index 4c39108..c341695 100644
--- a/src/skaldpress/macros.py
+++ b/src/skaldpress/macros.py
@@ -16,12 +16,12 @@ def sp_all_tagged_by(
     tagged_files = [
         k
         for k, v in macro_processor.py_global_env["macro_processor_state"].items()
-        if f"{macro_processor._get_macro_with_prefix('metadata_prefix')}tags"
+        if f"{macro_processor._get_macro_builtin('metadata_prefix')}tags"
         in v["stored_data"]
         and (
             tag
             in v["stored_data"][
-                f"{macro_processor._get_macro_with_prefix('metadata_prefix')}tags"
+                f"{macro_processor._get_macro_builtin('metadata_prefix')}tags"
             ]
         )
     ]
@@ -35,7 +35,7 @@ def sp_all_tagged_by(
             key=lambda fname: macro_processor.py_global_env["macro_processor_state"][
                 fname
             ]["stored_data"][
-                f"{macro_processor._get_macro_with_prefix('metadata_prefix')}{field}"
+                f"{macro_processor._get_macro_builtin('metadata_prefix')}{field}"
             ],
             reverse=(reversed != ""),
         )
diff --git a/src/skaldpress/main.py b/src/skaldpress/main.py
index 07c6555..9efb919 100644
--- a/src/skaldpress/main.py
+++ b/src/skaldpress/main.py
@@ -54,7 +54,10 @@ def compile_file(smps: smp.macro_processor.MacroProcessorState, file_path, opts)
     #    stored_smp_state = smps.global_state[file_path]["stored_data"]
     #    print(stored_smp_state)
 
-    macro_processor = smps.macro_processor()
+    prefix = "smp_" if opts.prefix_builtins else ""
+    macro_processor = smps.macro_processor(prefix=prefix)
+    for key, value in opts.D.items():
+        macro_processor.define_macro(key, value)
     macro_processor._define_metadata(
         "filename",
         os.path.splitext(os.path.relpath(file_path, opts.content_dir))[0],
@@ -203,8 +206,19 @@ def main():
         dest="static_exclude",
         type=comma_arg,
     )
+    parser.add_argument(
+        "-P",
+        "--prefix-builtins",
+        default=False,
+        action="store_true",
+        help="Prefix builtins with smp_",
+    )
+    parser.add_argument(
+        "-D", nargs="+", metavar="key=value", default=[], action="extend"
+    )
     args = parser.parse_args()
     args.metadata = parse_keyval_args(args.metadata)
+    args.D = parse_keyval_args(args.D)
 
     now = perf_counter()
     filelist_dest = make_filelist_iter(
diff --git a/src/smp/__init__.py b/src/smp/__init__.py
index 5358c29..f7cb937 100644
--- a/src/smp/__init__.py
+++ b/src/smp/__init__.py
@@ -35,13 +35,21 @@ def main():
         "-D", nargs="+", metavar="key=value", default=[], action="extend"
     )
     parser.add_argument(
+        "-P",
+        "--prefix-builtins",
+        default=False,
+        action="store_true",
+        help="Prefix builtins with smp_",
+    )
+    parser.add_argument(
         "file", nargs="?", default=None, help='Input file or "-" for stdin'
     )
     args = parser.parse_args()
     args.D = parse_keyval_args(args.D)
 
     macro_processor_state = smp.macro_processor.MacroProcessorState()
-    macro_processor = macro_processor_state.macro_processor()
+    prefix = "smp_" if args.prefix_builtins else ""
+    macro_processor = macro_processor_state.macro_processor(prefix=prefix)
 
     for key, value in args.D.items():
         macro_processor.define_macro(key, value)
diff --git a/src/smp/builtins.py b/src/smp/builtins.py
index eae32ce..f9d6468 100644
--- a/src/smp/builtins.py
+++ b/src/smp/builtins.py
@@ -75,10 +75,9 @@ def _smp_builtin_add_metadata(
     Not added to macro_processor as macro
     """
     for macro_name, value in metadata.items():
-        if not macro_name.startswith(
-            macro_processor._get_macro_with_prefix("metadata_prefix")
-        ):
-            macro_name = f"{macro_processor._get_macro_with_prefix('metadata_prefix')}{macro_name}"
+        prefix = macro_processor._get_macro_builtin("metadata_prefix")
+        if not macro_name.startswith(prefix):
+            macro_name = f"{prefix}{macro_name}"
 
         macro_value: str | list[str] = str(value)
         if isinstance(value, list):
@@ -91,7 +90,7 @@ def _smp_builtin_add_metadata(
             macro_processor.define_macro(macro_name, macro_value)
 
 
-def smp_builtin_include_file(macro_processor, filename):
+def smp_builtin_include(macro_processor, filename):
     return _smp_builtin_read(
         macro_processor, filename, template_content=None, inline=True
     )
@@ -190,7 +189,7 @@ def smp_builtin_html_from_markdown(macro_processor, text, extensions=list()):
 
 def _smp_builtin_template_content():
     def inner(macro_processor):
-        filename, content, extension = macro_processor._get_macro_with_prefix(
+        filename, content, extension = macro_processor._get_macro_builtin(
             "template_stack_content"
         ).pop()
 
@@ -221,28 +220,28 @@ def _smp_builtin_read(macro_processor, filename, template_content=None, inline=F
         file_content = f.read()
 
     metadata = {}
-    if smp_builtin_iftruthy(macro_processor._get_macro_with_prefix("parse_file_yaml")):
+    if smp_builtin_iftruthy(macro_processor._get_macro_builtin("parse_file_yaml")):
         metadata, file_content = extract_parse_yaml_metadata(file_content)
         _smp_builtin_add_metadata(macro_processor, metadata, overwrite=True)
 
     extension = os.path.splitext(filename)[1][1:] or ""
     if not inline:
-        macro_processor._define_macro_with_prefix("target_file_extension", extension)
+        macro_processor._define_macro_builtin("target_file_extension", extension)
 
     if template_content is not None:
-        macro_processor._get_macro_with_prefix("template_stack").append(filename)
+        macro_processor._get_macro_builtin("template_stack").append(filename)
         macro_processor.macros["CONTENT"] = template_content
 
     content = file_content
 
     if (template := macro_processor._get_metadata("template")) is not None:
 
-        template_prefix = macro_processor._get_macro_with_prefix("template_prefix")
+        template_prefix = macro_processor._get_macro_builtin("template_prefix")
         if not os.path.exists(template):
             template = os.path.join(template_prefix, template)
 
-        if template not in macro_processor._get_macro_with_prefix("template_stack"):
-            macro_processor._get_macro_with_prefix("template_stack_content").append(
+        if template not in macro_processor._get_macro_builtin("template_stack"):
+            macro_processor._get_macro_builtin("template_stack_content").append(
                 (filename, content, extension)
             )
             return _smp_builtin_read(
@@ -264,9 +263,9 @@ def smp_builtin_indent(macro_processor, indent: int, content: str):
 
 
 def smp_builtin_wodl(macro_processor, link, timeout_seconds=5):
-    if (macro_processor._get_macro_with_prefix("wodl_cache")) is None:
-        macro_processor._define_macro_with_prefix("wodl_cache", {})
-    cache = macro_processor._get_macro_with_prefix("wodl_cache")
+    if (macro_processor._get_macro_builtin("wodl_cache")) is None:
+        macro_processor._define_macro_builtin("wodl_cache", {})
+    cache = macro_processor._get_macro_builtin("wodl_cache")
 
     url = urllib.parse.urlparse(link)
 
@@ -292,14 +291,14 @@ def smp_builtin_wodl(macro_processor, link, timeout_seconds=5):
 
 
 def smp_builtin_expand_once(macro_processor, content):
-    if (cache := macro_processor._get_macro_with_prefix("once_cache")) is not None:
+    if (cache := macro_processor._get_macro_builtin("once_cache")) is not None:
         if (exp := cache.get(content)) is not None:
             return exp
     else:
-        macro_processor._define_macro_with_prefix("once_cache", {})
+        macro_processor._define_macro_builtin("once_cache", {})
 
     expanded_content = macro_processor.process_input(content)
-    macro_processor._get_macro_with_prefix("once_cache", expanded_content)
+    macro_processor._get_macro_builtin("once_cache", expanded_content)
     return expanded_content
 
 
diff --git a/src/smp/macro_processor.py b/src/smp/macro_processor.py
index 0e62494..d2a2f94 100644
--- a/src/smp/macro_processor.py
+++ b/src/smp/macro_processor.py
@@ -114,7 +114,7 @@ class MacroProcessor:
         # meaning they will skip steps that are slow.
         env[f"{self.prefix}draft"] = False
         env[f"{self.prefix}metadata_prefix"] = "METADATA_"
-        env[f"{self.prefix}smp_debug"] = "1"
+        env[f"{self.prefix}smp_debug"] = "4"
 
     def define_macro_string(self, macro_name, macro_value):
         self.define_macro(macro_name, str(macro_value))
@@ -122,25 +122,19 @@ class MacroProcessor:
     def define_macro(self, macro_name, macro_value):
         self.macros[macro_name] = macro_value
 
-    def _define_macro_with_prefix(self, macro_name, macro_value, sub_prefix: str = ""):
-        self.macros[f"{self.prefix}{sub_prefix}{macro_name}"] = macro_value
+    def _define_macro_builtin(self, macro_name, macro_value, sub_prefix: str = ""):
+        self.define_macro(f"{self.prefix}{sub_prefix}{macro_name}", macro_value)
 
-    def _get_macro_with_prefix(self, macro_name, sub_prefix: str = "", default=None):
+    def _get_macro_builtin(self, macro_name, sub_prefix: str = "", default=None):
         return self.macros.get(f"{self.prefix}{sub_prefix}{macro_name}", default)
 
     def _get_metadata(self, macro_name, default=None):
-        return self._get_macro_with_prefix(
-            macro_name,
-            sub_prefix=self._get_macro_with_prefix("metadata_prefix"),
-            default=default,
-        )
+        sub_prefix = self._get_macro_builtin("metadata_prefix")
+        return self.macros.get(f"{sub_prefix}{macro_name}", default)
 
     def _define_metadata(self, macro_name, macro_value):
-        return self._define_macro_with_prefix(
-            macro_name,
-            macro_value,
-            sub_prefix=self._get_macro_with_prefix("metadata_prefix"),
-        )
+        sub_prefix = (self._get_macro_builtin("metadata_prefix"),)
+        self.define_macro(f"{sub_prefix}{macro_name}", macro_value)
 
     def log_warning(self, message):
         """
@@ -247,7 +241,7 @@ class MacroProcessor:
 
     def _debug_on(self, level):
         try:
-            if level > int(self._get_macro_with_prefix("smp_debug")):
+            if level > int(self._get_macro_builtin("smp_debug")):
                 return False
         except:
             return False
@@ -492,7 +486,7 @@ class MacroProcessor:
         requested_keys = self._get_metadata("keep_states", [])
         for key in self.macros.keys():
             if (
-                key.startswith(self._get_macro_with_prefix("metadata_prefix"))
+                key.startswith(self._get_macro_builtin("metadata_prefix"))
                 and key not in requested_keys
             ):
                 requested_keys.append(key)
@@ -501,9 +495,8 @@ class MacroProcessor:
             requested_keys = [str(requested_keys)]
 
         needs_recompilation = (
-            f"{self._get_macro_with_prefix('metadata_prefix')}keep_states"
-            in self.macros
-        ) or ("all_tagged_by" in [x[0] for x in self.macro_invocations])
+            f"{self._get_macro_builtin('metadata_prefix')}keep_states" in self.macros
+        ) or (f"{self.prefix}all_tagged_by" in [x[0] for x in self.macro_invocations])
 
         target_filename = self._get_metadata("target_filename")
 
@@ -513,7 +506,7 @@ class MacroProcessor:
                 "stored_data": {
                     k: v for k, v in self.macros.items() if k in requested_keys
                 },
-                "extension": self._get_macro_with_prefix("target_file_extension"),
+                "extension": self._get_macro_builtin("target_file_extension"),
                 "source_path": self.source_file_path,
                 "needs_recompilation": needs_recompilation,
                 "target_filename": target_filename,
@@ -529,9 +522,9 @@ class MacroProcessorState:
     def __init__(self):
         self.global_state = dict()
 
-    def macro_processor(self, macro_processor=None):
+    def macro_processor(self, macro_processor=None, prefix=""):
         if macro_processor is None:
-            macro_processor = MacroProcessor()
+            macro_processor = MacroProcessor(prefix)
 
         macro_processor.py_global_env["macro_processor_state"] = self.global_state
         return macro_processor