makejinja 2.4.0__tar.gz → 2.6.0__tar.gz

{makejinja-2.4.0 → makejinja-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: makejinja
-Version: 2.4.0
+Version: 2.6.0
 Summary: Generate entire directory structures using Jinja templates with support for external data and custom plugins.
 Home-page: https://mirkolenz.github.io/makejinja/
 License: MIT

{makejinja-2.4.0 → makejinja-2.6.0}/makejinja/app.py

@@ -2,6 +2,7 @@ import itertools
 import json
 import os
 import shutil
+import subprocess
 import sys
 import tomllib
 from collections import abc
@@ -20,18 +21,32 @@ from makejinja.plugin import Data, MutableData, PathFilter, Plugin
 
 __all__ = ["makejinja"]
 
+STDOUT_PATH = Path("/dev/stdout").resolve()
+STDIN_PATH = Path("/dev/stdin").resolve()
+
+
+def log(message: str, config: Config) -> None:
+    if not config.quiet and config.output != STDOUT_PATH:
+        print(message)
+
+
+def exec(cmd: str) -> None:
+    subprocess.run(cmd, shell=True, check=True)
+
 
 def makejinja(config: Config):
     """makejinja can be used to automatically generate files from [Jinja templates](https://jinja.palletsprojects.com/en/3.1.x/templates/)."""
 
+    for cmd in config.exec_pre:
+        exec(cmd)
+
     for path in config.import_paths:
         sys.path.append(str(path.resolve()))
 
     data = load_data(config)
 
     if config.output.is_dir() and config.clean:
-        if not config.quiet:
-            print(f"Remove output '{config.output}'")
+        log(f"Remove output '{config.output}'", config)
 
         shutil.rmtree(config.output)
 
@@ -61,7 +76,7 @@ def makejinja(config: Config):
     rendered_dirs: dict[Path, Path] = {}
 
     for user_input_path in config.inputs:
-        if user_input_path.is_file():
+        if user_input_path.is_file() or user_input_path == STDIN_PATH:
             handle_input_file(user_input_path, config, env, rendered_files)
         elif user_input_path.is_dir():
             handle_input_dir(
@@ -75,6 +90,9 @@ def makejinja(config: Config):
 
     postprocess_rendered_dirs(config, rendered_dirs)
 
+    for cmd in config.exec_post:
+        exec(cmd)
+
 
 def postprocess_rendered_dirs(
     config: Config,
@@ -85,24 +103,24 @@ def postprocess_rendered_dirs(
         rendered_dirs.items(), key=lambda x: x[0], reverse=True
     ):
         if not config.keep_empty and not any(output_path.iterdir()):
-            if not config.quiet:
-                print(f"Remove empty dir '{output_path}'")
-
+            log(f"Remove empty dir '{output_path}'", config)
             shutil.rmtree(output_path)
 
         elif config.copy_metadata:
-            if not config.quiet:
-                print(f"Copy dir metadata '{input_path}' -> '{output_path}'")
-
+            log(f"Copy dir metadata '{input_path}' -> '{output_path}'", config)
             shutil.copystat(input_path, output_path)
 
 
 def single_input_output_file(config: Config) -> bool:
     """Check if the user provided a single input and a single output"""
     return (
-        len(config.inputs) == 1
-        and config.inputs[0].is_file()
-        and (config.output.suffix != "" or config.output.is_file())
+        len(config.inputs) <= 1
+        and not any(path.is_dir() for path in config.inputs)
+        and (
+            config.output == STDOUT_PATH
+            or config.output.suffix != ""
+            or config.output.is_file()
+        )
         and not config.output.is_dir()
     )
 
@@ -142,6 +160,8 @@ def handle_input_dir(
         for include_pattern in config.include_patterns
         for input_path in sorted(user_input_path.glob(include_pattern))
     )
+    # If the user provided a Jinja suffix, enforce it
+    enforce_jinja_suffix = bool(config.jinja_suffix)
 
     for input_path in input_paths:
         relative_path = input_path.relative_to(user_input_path)
@@ -154,8 +174,7 @@ def handle_input_dir(
             not path_filter(input_path) for path_filter in plugin_path_filters
         )
         if exclude_pattern_match or path_filter_match:
-            if not config.quiet:
-                print(f"Skip excluded path '{input_path}'")
+            log(f"Skip excluded path '{input_path}'", config)
 
         elif input_path.is_file() and output_path not in rendered_files:
             render_file(
@@ -164,7 +183,7 @@ def handle_input_dir(
                 output_path,
                 config,
                 env,
-                enforce_jinja_suffix=True,
+                enforce_jinja_suffix,
             )
             rendered_files[output_path] = input_path
 
@@ -190,7 +209,11 @@ def init_jinja_env(
     data: Data,
 ) -> Environment:
     file_loader = DictLoader(
-        {path.name: path.read_text() for path in config.inputs if path.is_file()}
+        {
+            path.name: path.read_text()
+            for path in config.inputs
+            if path.is_file() or path == STDIN_PATH
+        }
     )
     dir_loader = FileSystemLoader([path for path in config.inputs if path.is_dir()])
     loaders: list[BaseLoader] = [file_loader, dir_loader]
@@ -297,13 +320,11 @@ def load_data(config: Config) -> dict[str, Any]:
 
     for path in collect_files(config.data):
         if loader := DATA_LOADERS.get(path.suffix):
-            if not config.quiet:
-                print(f"Load data '{path}'")
+            log(f"Load data '{path}'", config)
 
             data |= loader(path)
         else:
-            if not config.quiet:
-                print(f"Skip unsupported data '{path}'")
+            log(f"Skip unsupported data '{path}'", config)
 
     for key, value in config.data_vars.items():
         dict_nested_set(data, key, value)
@@ -355,11 +376,9 @@ def load_plugin(
 
 def render_dir(input: Path, output: Path, config: Config) -> None:
     if output.exists() and not config.force:
-        if not config.quiet:
-            print(f"Skip existing dir '{output}'")
+        log(f"Skip existing dir '{output}'", config)
     else:
-        if not config.quiet:
-            print(f"Create dir '{input}' -> '{output}'")
+        log(f"Create dir '{input}' -> '{output}'", config)
 
         output.mkdir(exist_ok=True)
 
@@ -372,9 +391,8 @@ def render_file(
     env: Environment,
     enforce_jinja_suffix: bool,
 ) -> None:
-    if output.exists() and not config.force:
-        if not config.quiet:
-            print(f"Skip existing file '{output}'")
+    if output.exists() and not config.force and output != STDOUT_PATH:
+        log(f"Skip existing file '{output}'", config)
 
     elif input.suffix == config.jinja_suffix or not enforce_jinja_suffix:
         template = env.get_template(template_name)
@@ -383,11 +401,9 @@ def render_file(
         # Write the rendered template if it has content
         # Prevents empty macro definitions
         if rendered.strip() == "" and not config.keep_empty:
-            if not config.quiet:
-                print(f"Skip empty file '{input}'")
+            log(f"Skip empty file '{input}'", config)
         else:
-            if not config.quiet:
-                print(f"Render file '{input}' -> '{output}'")
+            log(f"Render file '{input}' -> '{output}'", config)
 
             with output.open("w") as fp:
                 fp.write(rendered)
@@ -396,7 +412,6 @@ def render_file(
                 shutil.copystat(input, output)
 
     else:
-        if not config.quiet:
-            print(f"Copy file '{input}' -> '{output}'")
+        log(f"Copy file '{input}' -> '{output}'", config)
 
         shutil.copy2(input, output)

{makejinja-2.4.0 → makejinja-2.6.0}/makejinja/config.py

@@ -207,13 +207,14 @@ class Config:
             Multiple can be provided.
         """,
     )
-    jinja_suffix: str = ts.option(
+    jinja_suffix: str | None = ts.option(
         default=".jinja",
         help="""
             File ending of Jinja template files.
             All files with this suffix in `inputs` matched by `pattern` are passed to the Jinja renderer.
             This suffix is not enforced for individual files passed to `inputs`.
             **Note:** Should be provided *with* the leading dot.
+            If empty, all files are considered to be Jinja templates.
         """,
     )
     keep_jinja_suffix: bool = ts.option(
@@ -322,6 +323,18 @@ class Config:
         """
         ),
     )
+    exec_pre: tuple[str, ...] = ts.option(
+        default=tuple(),
+        help="""
+            Shell commands to execute before rendering.
+        """,
+    )
+    exec_post: tuple[str, ...] = ts.option(
+        default=tuple(),
+        help="""
+            Shell commands to execute after rendering.
+        """,
+    )
     clean: bool = ts.option(
         default=False,
         click={"param_decls": ("--clean", "-c")},
@@ -402,5 +415,12 @@ OPTION_GROUPS = {
                 "--prefix-line-comment",
             ],
         },
+        {
+            "name": "Shell Hooks",
+            "options": [
+                "--exec-pre",
+                "--exec-post",
+            ],
+        },
     ]
 }

{makejinja-2.4.0 → makejinja-2.6.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "makejinja"
-version = "2.4.0"
+version = "2.6.0"
 description = "Generate entire directory structures using Jinja templates with support for external data and custom plugins."
 authors = ["Mirko Lenz <mirko@mirkolenz.com>"]
 license = "MIT"
@@ -57,8 +57,8 @@ typed-settings = { version = ">=23.1, <25", extras = [
 immutables = "^0.20"
 
 [tool.poetry.group.dev.dependencies]
-pytest = "^7.4"
-pytest-cov = "^4.1"
+pytest = "^8.0.0"
+pytest-cov = "^5.0.0"
 
 [tool.poetry.group.docs.dependencies]
 pdoc = "^14.1"