makejinja 2.7.2__tar.gz → 2.8.0__tar.gz

{makejinja-2.7.2/src/makejinja.egg-info → makejinja-2.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: makejinja
-Version: 2.7.2
+Version: 2.8.0
 Summary: Generate entire directory structures using Jinja templates with support for external data and custom plugins
 Author-email: Mirko Lenz <mirko@mirkolenz.com>
 Project-URL: Repository, https://github.com/mirkolenz/makejinja
@@ -39,12 +39,15 @@ Requires-Dist: pyyaml<7,>=6
 Requires-Dist: rich-click<2,>=1
 Requires-Dist: typed-settings[attrs,cattrs,click]<25,>=23
 Requires-Dist: immutables<1,>=0.20
+Dynamic: license-file
 
 <!-- markdownlint-disable MD033 MD041 -->
-<h2><p align="center">makejinja</p></h2>
+<h1><p align="center">makejinja</p></h1>
+
 <p align="center">
   <img width="256px" alt="makejinja logo" src="https://raw.githubusercontent.com/mirkolenz/makejinja/main/assets/logo.png" />
 </p>
+
 <p align="center">
   <a href="https://pypi.org/project/makejinja/">PyPI</a> |
   <a href="https://github.com/users/mirkolenz/packages/container/package/makejinja">Docker</a> |
@@ -52,51 +55,72 @@ Requires-Dist: immutables<1,>=0.20
   <a href="https://github.com/mirkolenz/makejinja/tree/main/tests/data">Example</a> |
   <a href="https://jinja.palletsprojects.com/en/3.1.x/templates">Jinja reference</a>
 </p>
+
 <p align="center">
   Generate entire directory structures using Jinja templates with support for external data and custom plugins.
 </p>
 
+<p align="center">
+  <img alt="makejinja demonstration" src="https://mirkolenz.github.io/makejinja/assets/demo.gif" />
+</p>
+
 ---
 
-# makejinja
+<!-- PDOC_START -->
 
 makejinja can be used to automatically generate files from [Jinja templates](https://jinja.palletsprojects.com/en/3.1.x/templates).
 It is conceptually similar to [Ansible templates](https://docs.ansible.com/ansible/latest/collections/ansible/builtin/template_module.html) since both are built on top of Jinja.
 However, makejinja is a standalone tool that can be used without Ansible and offers some advanced features like custom plugins.
-A use case for this tool is generating config files for [Home Assistant](https://www.home-assistant.io/):
-Using the same language that the built-in templates use, you can greatly simplify your configuration.
-An [example for Home Assistant](https://github.com/mirkolenz/makejinja/tree/main/tests/data) can be found in the tests directory.
 
-## Highlights
+A popular use case is generating config files for [Home Assistant](https://www.home-assistant.io/):
+Using the same Jinja language that Home Assistant's built-in templates use, you can greatly simplify your configuration management.
+makejinja's custom delimiter support prevents conflicts with Home Assistant's own template syntax, while file-specific data loading enables modular dashboard and automation generation.
+Our comprehensive [Home Assistant example](https://github.com/mirkolenz/makejinja/tree/main/tests/data) demonstrates dashboard generation with custom plugins, multiple data sources, and advanced template organization.
+
+## Key Features
+
+- **Multi-Source Data Integration**: Load variables from YAML, TOML, and Python files, with support for file-specific data sources and runtime variable injection.
+- **Custom Template Delimiters**: Configure Jinja delimiters (e.g., `<% %>` instead of `{{ }}`) to avoid conflicts with target file formats like Home Assistant, Kubernetes, or Terraform.
+- **Flexible Directory Processing**: Process multiple input directories with complex nested structures, preserving hierarchy while applying powerful template transformations.
+- **Extensible Plugin System**: Create custom [plugins](https://mirkolenz.github.io/makejinja/makejinja/plugin.html#Plugin) with filters, functions, and path filtering logic for specialized requirements.
+- **Production-Ready**: Comprehensive CLI interface, configuration file support, and Python library API for seamless workflow integration.
 
-- Recursively render nested directories containing template files to a common output directory.
-- Load data files containing variables to use in your Jinja templates from YAML, TOML, and Python files.
-- Write custom [plugins](https://mirkolenz.github.io/makejinja/makejinja/plugin.html#Plugin) to extend the functionality of makejinja.
-- Adjust all Jinja options (e.g., whitespace behavior and delimiters) to your needs via CLI flags or a config file.
+## Use Cases
+
+- **Configuration Management**: Generate environment-specific configs (dev/staging/prod) from shared templates with different data sources.
+- **Home Assistant Dashboards**: Create complex dashboards and automations using Jinja syntax without conflicts. See our [complete example](https://github.com/mirkolenz/makejinja/tree/main/tests/data).
+- **Infrastructure as Code**: Generate Kubernetes manifests, Terraform modules, or Docker Compose files with consistent patterns across environments.
+- **Web Development**: Generate HTML pages, CSS files, or JavaScript configs from data sources for static sites or multi-tenant applications.
+- **Database Schemas**: Create SQL migration scripts, database configurations, or ORM models based on structured schema definitions.
+- **Network Configuration**: Generate router configs, firewall rules, or network device settings from centralized network topology data.
+- **Monitoring & Alerting**: Create Grafana dashboards, Prometheus rules, or alerting configurations from service inventories.
+- **Documentation & CI/CD**: Create project docs, API specifications, or pipeline definitions from structured data sources.
 
 ## Installation
 
-The tool is written in Python and can be installed via pip, nix, and docker.
+The tool is written in Python and can be installed via uv, nix, and docker.
 It can be used as a CLI tool or as a Python library.
 
-### PIP
+### UV
 
-makejinja is available on [PyPI](https://pypi.org/project/makejinja/) and can be installed via `pip`:
+makejinja is available on [PyPI](https://pypi.org/project/makejinja/) and can be installed via `uv`:
 
 ```shell
-pip install makejinja
+uv tool install makejinja
 makejinja -i ./input -o ./output
 ```
 
 ### Nix
 
-If you use the `nix` package manager, you can add this repository as an input to your flake and use `makejinja.packages.${system}.default` or apply the overlay `makejinja.overlays.default`.
-You can also run it directly as follows:
+makejinja is packaged in nixpkgs.
+To use the most recent version, you can run it via `nix run`:
 
 ```shell
 nix run github:mirkolenz/makejinja -- -i ./input -o ./output
 ```
 
+Alternatively, you can add this repository as an input to your flake and use `makejinja.packages.${system}.default`.
+
 ### Docker
 
 We automatically publish an image to the [GitHub Container Registry](https://ghcr.io/mirkolenz/makejinja).

makejinja-2.8.0/README.md

@@ -0,0 +1,94 @@
+<!-- markdownlint-disable MD033 MD041 -->
+<h1><p align="center">makejinja</p></h1>
+
+<p align="center">
+  <img width="256px" alt="makejinja logo" src="https://raw.githubusercontent.com/mirkolenz/makejinja/main/assets/logo.png" />
+</p>
+
+<p align="center">
+  <a href="https://pypi.org/project/makejinja/">PyPI</a> |
+  <a href="https://github.com/users/mirkolenz/packages/container/package/makejinja">Docker</a> |
+  <a href="https://mirkolenz.github.io/makejinja">Docs</a> |
+  <a href="https://github.com/mirkolenz/makejinja/tree/main/tests/data">Example</a> |
+  <a href="https://jinja.palletsprojects.com/en/3.1.x/templates">Jinja reference</a>
+</p>
+
+<p align="center">
+  Generate entire directory structures using Jinja templates with support for external data and custom plugins.
+</p>
+
+<p align="center">
+  <img alt="makejinja demonstration" src="https://mirkolenz.github.io/makejinja/assets/demo.gif" />
+</p>
+
+---
+
+<!-- PDOC_START -->
+
+makejinja can be used to automatically generate files from [Jinja templates](https://jinja.palletsprojects.com/en/3.1.x/templates).
+It is conceptually similar to [Ansible templates](https://docs.ansible.com/ansible/latest/collections/ansible/builtin/template_module.html) since both are built on top of Jinja.
+However, makejinja is a standalone tool that can be used without Ansible and offers some advanced features like custom plugins.
+
+A popular use case is generating config files for [Home Assistant](https://www.home-assistant.io/):
+Using the same Jinja language that Home Assistant's built-in templates use, you can greatly simplify your configuration management.
+makejinja's custom delimiter support prevents conflicts with Home Assistant's own template syntax, while file-specific data loading enables modular dashboard and automation generation.
+Our comprehensive [Home Assistant example](https://github.com/mirkolenz/makejinja/tree/main/tests/data) demonstrates dashboard generation with custom plugins, multiple data sources, and advanced template organization.
+
+## Key Features
+
+- **Multi-Source Data Integration**: Load variables from YAML, TOML, and Python files, with support for file-specific data sources and runtime variable injection.
+- **Custom Template Delimiters**: Configure Jinja delimiters (e.g., `<% %>` instead of `{{ }}`) to avoid conflicts with target file formats like Home Assistant, Kubernetes, or Terraform.
+- **Flexible Directory Processing**: Process multiple input directories with complex nested structures, preserving hierarchy while applying powerful template transformations.
+- **Extensible Plugin System**: Create custom [plugins](https://mirkolenz.github.io/makejinja/makejinja/plugin.html#Plugin) with filters, functions, and path filtering logic for specialized requirements.
+- **Production-Ready**: Comprehensive CLI interface, configuration file support, and Python library API for seamless workflow integration.
+
+## Use Cases
+
+- **Configuration Management**: Generate environment-specific configs (dev/staging/prod) from shared templates with different data sources.
+- **Home Assistant Dashboards**: Create complex dashboards and automations using Jinja syntax without conflicts. See our [complete example](https://github.com/mirkolenz/makejinja/tree/main/tests/data).
+- **Infrastructure as Code**: Generate Kubernetes manifests, Terraform modules, or Docker Compose files with consistent patterns across environments.
+- **Web Development**: Generate HTML pages, CSS files, or JavaScript configs from data sources for static sites or multi-tenant applications.
+- **Database Schemas**: Create SQL migration scripts, database configurations, or ORM models based on structured schema definitions.
+- **Network Configuration**: Generate router configs, firewall rules, or network device settings from centralized network topology data.
+- **Monitoring & Alerting**: Create Grafana dashboards, Prometheus rules, or alerting configurations from service inventories.
+- **Documentation & CI/CD**: Create project docs, API specifications, or pipeline definitions from structured data sources.
+
+## Installation
+
+The tool is written in Python and can be installed via uv, nix, and docker.
+It can be used as a CLI tool or as a Python library.
+
+### UV
+
+makejinja is available on [PyPI](https://pypi.org/project/makejinja/) and can be installed via `uv`:
+
+```shell
+uv tool install makejinja
+makejinja -i ./input -o ./output
+```
+
+### Nix
+
+makejinja is packaged in nixpkgs.
+To use the most recent version, you can run it via `nix run`:
+
+```shell
+nix run github:mirkolenz/makejinja -- -i ./input -o ./output
+```
+
+Alternatively, you can add this repository as an input to your flake and use `makejinja.packages.${system}.default`.
+
+### Docker
+
+We automatically publish an image to the [GitHub Container Registry](https://ghcr.io/mirkolenz/makejinja).
+To use it, mount a directory to the container and pass the options as the command:
+
+```shell
+docker run --rm -v $(pwd)/data:/data ghcr.io/mirkolenz/makejinja:latest -i /data/input -o /data/output
+```
+
+## Usage in Terminal / Command Line
+
+In its default configuration, makejinja searches the input directory recursively for files ending in `.jinja`.
+It then renders these files and writes them to the output directory, preserving the directory structure.
+Our [documentation](https://mirkolenz.github.io/makejinja/makejinja/cli.html) contains a detailed description of all options and can also be accessed via `makejinja --help`.

{makejinja-2.7.2 → makejinja-2.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "makejinja"
-version = "2.7.2"
+version = "2.8.0"
 description = "Generate entire directory structures using Jinja templates with support for external data and custom plugins"
 authors = [{ name = "Mirko Lenz", email = "mirko@mirkolenz.com" }]
 readme = "README.md"
@@ -75,8 +75,10 @@ addopts = "--cov makejinja --cov-report term-missing"
 
 [tool.ruff]
 target-version = "py311"
+
+[tool.ruff.lint]
 select = ["E", "W", "F", "B", "UP"]
 ignore = ["E501"]
 
-[tool.ruff.pydocstyle]
+[tool.ruff.lint.pydocstyle]
 convention = "google"

{makejinja-2.7.2 → makejinja-2.8.0}/src/makejinja/__init__.py

@@ -1,10 +1,10 @@
 """
 **[🌟 GitHub Project 🌟](https://github.com/mirkolenz/makejinja)**
 
-![Screencast demo](../../assets/demo.gif)
+![makejinja demonstration](../../assets/demo.gif)
 
 .. include:: ../../README.md
-   :start-after: # makejinja
+   :start-after: <!-- PDOC_START -->
 
 ## Usage as a Library
 

{makejinja-2.7.2 → makejinja-2.8.0}/src/makejinja/app.py

@@ -332,6 +332,26 @@ def load_data(config: Config) -> dict[str, Any]:
     return data
 
 
+def load_file_data(template_name: str, config: Config) -> dict[str, Any]:
+    file_data: dict[str, Any] = {}
+
+    if data_paths := config.file_data.get(template_name):
+        for data_path in data_paths:
+            if data_path.exists() and (loader := DATA_LOADERS.get(data_path.suffix)):
+                log(
+                    f"Load file-specific data '{data_path}' for template '{template_name}'",
+                    config,
+                )
+                file_data |= loader(data_path)
+            else:
+                log(
+                    f"Skip missing or unsupported file-specific data '{data_path}'",
+                    config,
+                )
+
+    return file_data
+
+
 def load_plugin(
     plugin_name: str, env: Environment, data: Data, config: Config
 ) -> Plugin:
@@ -396,7 +416,8 @@ def render_file(
 
     elif input.suffix == config.jinja_suffix or not enforce_jinja_suffix:
         template = env.get_template(template_name)
-        rendered = template.render()
+        file_data = load_file_data(template_name, config)
+        rendered = template.render(file_data)
 
         # Write the rendered template if it has content
         # Prevents empty macro definitions

{makejinja-2.7.2 → makejinja-2.8.0}/src/makejinja/config.py

@@ -277,6 +277,19 @@ class Config:
             """,
         },
     )
+    file_data: abc.Mapping[str, tuple[Path, ...]] = ts.option(
+        default=frozendict(),
+        click={
+            "param_decls": ("--file-data",),
+            "help": """
+                Load file-specific data for individual templates.
+                Format: template_file=data_file1,data_file2,...
+                Example: --file-data "home.yaml.jinja=home_data.yaml,common.yaml"
+                The data from these files will be available only when rendering the specified template.
+                **Note:** This option may be passed multiple times.
+            """,
+        },
+    )
     loaders: tuple[str, ...] = ts.option(
         default=tuple(),
         click={
@@ -392,6 +405,7 @@ OPTION_GROUPS = {
             "options": [
                 "--data",
                 "--data-var",
+                "--file-data",
                 "--plugin",
                 "--import-path",
                 "--extension",

{makejinja-2.7.2 → makejinja-2.8.0/src/makejinja.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: makejinja
-Version: 2.7.2
+Version: 2.8.0
 Summary: Generate entire directory structures using Jinja templates with support for external data and custom plugins
 Author-email: Mirko Lenz <mirko@mirkolenz.com>
 Project-URL: Repository, https://github.com/mirkolenz/makejinja
@@ -39,12 +39,15 @@ Requires-Dist: pyyaml<7,>=6
 Requires-Dist: rich-click<2,>=1
 Requires-Dist: typed-settings[attrs,cattrs,click]<25,>=23
 Requires-Dist: immutables<1,>=0.20
+Dynamic: license-file
 
 <!-- markdownlint-disable MD033 MD041 -->
-<h2><p align="center">makejinja</p></h2>
+<h1><p align="center">makejinja</p></h1>
+
 <p align="center">
   <img width="256px" alt="makejinja logo" src="https://raw.githubusercontent.com/mirkolenz/makejinja/main/assets/logo.png" />
 </p>
+
 <p align="center">
   <a href="https://pypi.org/project/makejinja/">PyPI</a> |
   <a href="https://github.com/users/mirkolenz/packages/container/package/makejinja">Docker</a> |
@@ -52,51 +55,72 @@ Requires-Dist: immutables<1,>=0.20
   <a href="https://github.com/mirkolenz/makejinja/tree/main/tests/data">Example</a> |
   <a href="https://jinja.palletsprojects.com/en/3.1.x/templates">Jinja reference</a>
 </p>
+
 <p align="center">
   Generate entire directory structures using Jinja templates with support for external data and custom plugins.
 </p>
 
+<p align="center">
+  <img alt="makejinja demonstration" src="https://mirkolenz.github.io/makejinja/assets/demo.gif" />
+</p>
+
 ---
 
-# makejinja
+<!-- PDOC_START -->
 
 makejinja can be used to automatically generate files from [Jinja templates](https://jinja.palletsprojects.com/en/3.1.x/templates).
 It is conceptually similar to [Ansible templates](https://docs.ansible.com/ansible/latest/collections/ansible/builtin/template_module.html) since both are built on top of Jinja.
 However, makejinja is a standalone tool that can be used without Ansible and offers some advanced features like custom plugins.
-A use case for this tool is generating config files for [Home Assistant](https://www.home-assistant.io/):
-Using the same language that the built-in templates use, you can greatly simplify your configuration.
-An [example for Home Assistant](https://github.com/mirkolenz/makejinja/tree/main/tests/data) can be found in the tests directory.
 
-## Highlights
+A popular use case is generating config files for [Home Assistant](https://www.home-assistant.io/):
+Using the same Jinja language that Home Assistant's built-in templates use, you can greatly simplify your configuration management.
+makejinja's custom delimiter support prevents conflicts with Home Assistant's own template syntax, while file-specific data loading enables modular dashboard and automation generation.
+Our comprehensive [Home Assistant example](https://github.com/mirkolenz/makejinja/tree/main/tests/data) demonstrates dashboard generation with custom plugins, multiple data sources, and advanced template organization.
+
+## Key Features
+
+- **Multi-Source Data Integration**: Load variables from YAML, TOML, and Python files, with support for file-specific data sources and runtime variable injection.
+- **Custom Template Delimiters**: Configure Jinja delimiters (e.g., `<% %>` instead of `{{ }}`) to avoid conflicts with target file formats like Home Assistant, Kubernetes, or Terraform.
+- **Flexible Directory Processing**: Process multiple input directories with complex nested structures, preserving hierarchy while applying powerful template transformations.
+- **Extensible Plugin System**: Create custom [plugins](https://mirkolenz.github.io/makejinja/makejinja/plugin.html#Plugin) with filters, functions, and path filtering logic for specialized requirements.
+- **Production-Ready**: Comprehensive CLI interface, configuration file support, and Python library API for seamless workflow integration.
 
-- Recursively render nested directories containing template files to a common output directory.
-- Load data files containing variables to use in your Jinja templates from YAML, TOML, and Python files.
-- Write custom [plugins](https://mirkolenz.github.io/makejinja/makejinja/plugin.html#Plugin) to extend the functionality of makejinja.
-- Adjust all Jinja options (e.g., whitespace behavior and delimiters) to your needs via CLI flags or a config file.
+## Use Cases
+
+- **Configuration Management**: Generate environment-specific configs (dev/staging/prod) from shared templates with different data sources.
+- **Home Assistant Dashboards**: Create complex dashboards and automations using Jinja syntax without conflicts. See our [complete example](https://github.com/mirkolenz/makejinja/tree/main/tests/data).
+- **Infrastructure as Code**: Generate Kubernetes manifests, Terraform modules, or Docker Compose files with consistent patterns across environments.
+- **Web Development**: Generate HTML pages, CSS files, or JavaScript configs from data sources for static sites or multi-tenant applications.
+- **Database Schemas**: Create SQL migration scripts, database configurations, or ORM models based on structured schema definitions.
+- **Network Configuration**: Generate router configs, firewall rules, or network device settings from centralized network topology data.
+- **Monitoring & Alerting**: Create Grafana dashboards, Prometheus rules, or alerting configurations from service inventories.
+- **Documentation & CI/CD**: Create project docs, API specifications, or pipeline definitions from structured data sources.
 
 ## Installation
 
-The tool is written in Python and can be installed via pip, nix, and docker.
+The tool is written in Python and can be installed via uv, nix, and docker.
 It can be used as a CLI tool or as a Python library.
 
-### PIP
+### UV
 
-makejinja is available on [PyPI](https://pypi.org/project/makejinja/) and can be installed via `pip`:
+makejinja is available on [PyPI](https://pypi.org/project/makejinja/) and can be installed via `uv`:
 
 ```shell
-pip install makejinja
+uv tool install makejinja
 makejinja -i ./input -o ./output
 ```
 
 ### Nix
 
-If you use the `nix` package manager, you can add this repository as an input to your flake and use `makejinja.packages.${system}.default` or apply the overlay `makejinja.overlays.default`.
-You can also run it directly as follows:
+makejinja is packaged in nixpkgs.
+To use the most recent version, you can run it via `nix run`:
 
 ```shell
 nix run github:mirkolenz/makejinja -- -i ./input -o ./output
 ```
 
+Alternatively, you can add this repository as an input to your flake and use `makejinja.packages.${system}.default`.
+
 ### Docker
 
 We automatically publish an image to the [GitHub Container Registry](https://ghcr.io/mirkolenz/makejinja).

makejinja-2.8.0/tests/test_makejinja.py

@@ -0,0 +1,152 @@
+from dataclasses import dataclass
+from pathlib import Path
+
+import pytest
+from click.testing import CliRunner
+
+
+@dataclass(slots=True, frozen=True)
+class MakejinjaPaths:
+    """Paths used in makejinja test execution.
+
+    Attributes:
+        input: Path to input template directories
+        baseline: Path to expected output files
+        output: Path to actual generated output files
+    """
+
+    input: Path
+    baseline: Path
+    output: Path
+
+    def __repr__(self) -> str:
+        return "makejinja"
+
+
+@pytest.fixture(scope="session")
+def test_run(tmp_path_factory: pytest.TempPathFactory) -> MakejinjaPaths:
+    """Execute makejinja on test data and return paths to input, expected, and actual output."""
+    assert __package__ is not None
+    data_path = Path(__package__, "data")
+    input_path = data_path / "input"
+    baseline_path = data_path / "output"
+    output_path = tmp_path_factory.mktemp("data")
+
+    with pytest.MonkeyPatch.context() as m:
+        m.chdir(data_path)
+        runner = CliRunner()
+
+        # Need to import it AFTER chdir
+        from makejinja.cli import makejinja_cli
+
+        runner.invoke(
+            makejinja_cli,
+            [
+                # Override it here to use our tmp_path
+                "--output",
+                str(output_path),
+            ],
+            catch_exceptions=False,
+            color=True,
+        )
+
+    return MakejinjaPaths(input_path, baseline_path, output_path)
+
+
+def _dir_content(path: Path) -> set[Path]:
+    return {item.relative_to(path) for item in path.rglob("*")}
+
+
+def test_output_structure(test_run: MakejinjaPaths):
+    """Test that makejinja generates the expected directory structure."""
+    expected_files = _dir_content(test_run.baseline)
+    actual_files = _dir_content(test_run.output)
+
+    if expected_files != actual_files:
+        missing = sorted(expected_files - actual_files)
+        extra = sorted(actual_files - expected_files)
+        pytest.fail(f"Directory structure mismatch. Missing: {missing}, Extra: {extra}")
+
+
+def test_template_rendering(test_run: MakejinjaPaths):
+    """Test that makejinja renders all templates with correct content."""
+    paths = _dir_content(test_run.baseline)
+
+    for item in paths:
+        baseline_path = test_run.baseline / item
+        output_path = test_run.output / item
+
+        if baseline_path.is_file() and output_path.is_file():
+            expected_content = baseline_path.read_text()
+            actual_content = output_path.read_text()
+
+            if expected_content.strip() != actual_content.strip():
+                pytest.fail(
+                    f"Content mismatch in {item}: expected '{expected_content.strip()}', got '{actual_content.strip()}'"
+                )
+
+
+def test_custom_delimiters(test_run: MakejinjaPaths):
+    """Test that custom Jinja delimiters (<< >>, <% %>) work correctly."""
+    not_empty_file = test_run.output / "not-empty.yaml"
+    content = not_empty_file.read_text()
+
+    assert "NOT EMPTY" in content, (
+        f"Custom delimiters not working. Expected 'NOT EMPTY' in {not_empty_file}"
+    )
+
+
+def test_file_specific_data(test_run: MakejinjaPaths):
+    """Test that file-specific data loading works correctly."""
+    file_specific_output = test_run.output / "file-specific.yaml"
+    content = file_specific_output.read_text()
+
+    # Should contain data from data1.yaml
+    assert "Value from data1" in content, (
+        f"File-specific data not loaded. Expected 'Value from data1' in {file_specific_output}"
+    )
+    assert "item1" in content and "item2" in content, (
+        f"File-specific list data not loaded correctly in {file_specific_output}"
+    )
+
+
+def test_plugin_features(test_run: MakejinjaPaths):
+    """Test that custom plugin filters and functions work."""
+    # Test that secret files are excluded by plugin path filter
+    secret_file = test_run.output / "secret.yaml"
+    assert not secret_file.exists(), (
+        f"Secret file should be excluded by plugin but exists: {secret_file}"
+    )
+
+
+def test_partial_inclusion(test_run: MakejinjaPaths):
+    """Test that partial template inclusion works."""
+    ui_lovelace_file = test_run.output / "ui-lovelace.yaml"
+    content = ui_lovelace_file.read_text()
+
+    # Should contain content from include.yaml.partial
+    assert "icon: mdi:home" in content, (
+        f"Partial inclusion not working. Expected 'icon: mdi:home' in {ui_lovelace_file}"
+    )
+
+
+def test_empty_template_handling(test_run: MakejinjaPaths):
+    """Test that empty templates are handled correctly."""
+    # The empty.yaml.jinja should not produce output (contains only comments)
+    empty_file = test_run.output / "empty.yaml"
+    assert not empty_file.exists(), (
+        f"Empty template should not generate output file but {empty_file} exists"
+    )
+
+
+def test_nested_directory_processing(test_run: MakejinjaPaths):
+    """Test that nested directories are processed correctly."""
+    nested_file = test_run.output / "views" / "home.yaml"
+    assert nested_file.exists(), (
+        f"Nested directory processing failed. Expected {nested_file} to exist"
+    )
+
+    content = nested_file.read_text()
+    assert len(content.strip()) > 0, (
+        f"Nested template should have content but {nested_file} is empty"
+    )

makejinja-2.7.2/README.md

@@ -1,71 +0,0 @@
-<!-- markdownlint-disable MD033 MD041 -->
-<h2><p align="center">makejinja</p></h2>
-<p align="center">
-  <img width="256px" alt="makejinja logo" src="https://raw.githubusercontent.com/mirkolenz/makejinja/main/assets/logo.png" />
-</p>
-<p align="center">
-  <a href="https://pypi.org/project/makejinja/">PyPI</a> |
-  <a href="https://github.com/users/mirkolenz/packages/container/package/makejinja">Docker</a> |
-  <a href="https://mirkolenz.github.io/makejinja">Docs</a> |
-  <a href="https://github.com/mirkolenz/makejinja/tree/main/tests/data">Example</a> |
-  <a href="https://jinja.palletsprojects.com/en/3.1.x/templates">Jinja reference</a>
-</p>
-<p align="center">
-  Generate entire directory structures using Jinja templates with support for external data and custom plugins.
-</p>
-
----
-
-# makejinja
-
-makejinja can be used to automatically generate files from [Jinja templates](https://jinja.palletsprojects.com/en/3.1.x/templates).
-It is conceptually similar to [Ansible templates](https://docs.ansible.com/ansible/latest/collections/ansible/builtin/template_module.html) since both are built on top of Jinja.
-However, makejinja is a standalone tool that can be used without Ansible and offers some advanced features like custom plugins.
-A use case for this tool is generating config files for [Home Assistant](https://www.home-assistant.io/):
-Using the same language that the built-in templates use, you can greatly simplify your configuration.
-An [example for Home Assistant](https://github.com/mirkolenz/makejinja/tree/main/tests/data) can be found in the tests directory.
-
-## Highlights
-
-- Recursively render nested directories containing template files to a common output directory.
-- Load data files containing variables to use in your Jinja templates from YAML, TOML, and Python files.
-- Write custom [plugins](https://mirkolenz.github.io/makejinja/makejinja/plugin.html#Plugin) to extend the functionality of makejinja.
-- Adjust all Jinja options (e.g., whitespace behavior and delimiters) to your needs via CLI flags or a config file.
-
-## Installation
-
-The tool is written in Python and can be installed via pip, nix, and docker.
-It can be used as a CLI tool or as a Python library.
-
-### PIP
-
-makejinja is available on [PyPI](https://pypi.org/project/makejinja/) and can be installed via `pip`:
-
-```shell
-pip install makejinja
-makejinja -i ./input -o ./output
-```
-
-### Nix
-
-If you use the `nix` package manager, you can add this repository as an input to your flake and use `makejinja.packages.${system}.default` or apply the overlay `makejinja.overlays.default`.
-You can also run it directly as follows:
-
-```shell
-nix run github:mirkolenz/makejinja -- -i ./input -o ./output
-```
-
-### Docker
-
-We automatically publish an image to the [GitHub Container Registry](https://ghcr.io/mirkolenz/makejinja).
-To use it, mount a directory to the container and pass the options as the command:
-
-```shell
-docker run --rm -v $(pwd)/data:/data ghcr.io/mirkolenz/makejinja:latest -i /data/input -o /data/output
-```
-
-## Usage in Terminal / Command Line
-
-In its default configuration, makejinja searches the input directory recursively for files ending in `.jinja`.
-It then renders these files and writes them to the output directory, preserving the directory structure.
-Our [documentation](https://mirkolenz.github.io/makejinja/makejinja/cli.html) contains a detailed description of all options and can also be accessed via `makejinja --help`.

makejinja-2.7.2/tests/test_makejinja.py

@@ -1,66 +0,0 @@
-from dataclasses import dataclass
-from pathlib import Path
-
-import pytest
-from click.testing import CliRunner
-
-
-@dataclass
-class Paths:
-    input: Path
-    baseline: Path
-    output: Path
-
-    def __repr__(self) -> str:
-        return "makejinja"
-
-
-@pytest.fixture(scope="session")
-def exec(tmp_path_factory: pytest.TempPathFactory) -> Paths:
-    assert __package__ is not None
-    data_path = Path(__package__, "data")
-    input_path = data_path / "input"
-    baseline_path = data_path / "output"
-    output_path = tmp_path_factory.mktemp("data")
-
-    with pytest.MonkeyPatch.context() as m:
-        m.chdir(data_path)
-        runner = CliRunner()
-
-        # Need to import it AFTER chdir
-        from makejinja.cli import makejinja_cli
-
-        runner.invoke(
-            makejinja_cli,
-            [
-                # Override it here to use our tmp_path
-                "--output",
-                str(output_path),
-            ],
-            catch_exceptions=False,
-            color=True,
-        )
-
-    return Paths(input_path, baseline_path, output_path)
-
-
-def _dir_content(path: Path) -> set[Path]:
-    return {item.relative_to(path) for item in path.rglob("*")}
-
-
-def test_dir_content(exec: Paths):
-    assert _dir_content(exec.baseline) == _dir_content(exec.output)
-
-
-def test_file_content(exec: Paths):
-    paths = _dir_content(exec.baseline)
-
-    for item in paths:
-        baseline_path = exec.baseline / item
-        output_path = exec.output / item
-
-        if baseline_path.is_file() and output_path.is_file():
-            baseline = baseline_path.read_text()
-            output = output_path.read_text()
-
-            assert baseline.strip() == output.strip(), str(item)