djlint 1.28.0 → 1.30.0

package/src/djlint/src.py

@@ -0,0 +1,91 @@
+"""Build src file list."""
+import re
+from pathlib import Path
+from typing import List
+
+from click import echo
+from colorama import Fore
+
+from .settings import Config
+
+
+def get_src(src: List[Path], config: Config) -> List[Path]:
+    """Get source files."""
+    paths = []
+    for item in src:
+        # normalize path
+
+        normalized_item = item.resolve()
+
+        if (
+            Path.is_file(normalized_item)
+            and no_pragma(config, normalized_item)
+            and (
+                (
+                    config.use_gitignore
+                    and not config.gitignore.match_file(normalized_item)
+                )
+                or not config.use_gitignore
+            )
+        ):
+            paths.append(normalized_item)
+            continue
+
+        # remove leading . from extension
+        extension = str(config.extension)
+        extension = extension[1:] if extension.startswith(".") else extension
+
+        paths.extend(
+            filter(
+                lambda x: not re.search(config.exclude, x.as_posix(), re.VERBOSE)
+                and no_pragma(config, x)
+                and (
+                    (config.use_gitignore and not config.gitignore.match_file(x))
+                    or not config.use_gitignore
+                ),
+                list(normalized_item.glob(f"**/*.{extension}")),
+            )
+        )
+
+    if len(paths) == 0:
+        echo(Fore.BLUE + "No files to check! 😢")
+
+    return paths
+
+
+html_patterns = [re.compile(r"<!--\s*djlint\:on\s*-->")]
+django_jinja_patterns = [
+    re.compile(r"\{#\s*djlint\:on\s*#\}"),
+    re.compile(r"\{%\s*comment\s*%\}\s*djlint\:on\s*\{%\s*endcomment\s*%\}"),
+]
+nunjucks_patterns = [re.compile(r"\{#\s*djlint\:on\s*#\}")]
+handlebars_patterns = [re.compile(r"\{\{!--\s*djlint\:on\s*--\}\}")]
+golang_patterns = [re.compile(r"\{\{-?\s*/\*\s*djlint\:on\s*\*/\s*-?\}\}")]
+
+
+def no_pragma(config: Config, this_file: Path) -> bool:
+    """Verify there is no pragma present."""
+    if config.require_pragma is False:
+        return True
+
+    with this_file.open(encoding="utf8") as open_file:
+        first_line = open_file.readline()
+
+        pragma_patterns = {
+            "html": html_patterns,
+            "django": django_jinja_patterns + html_patterns,
+            "jinja": django_jinja_patterns + html_patterns,
+            "nunjucks": nunjucks_patterns + html_patterns,
+            "handlebars": handlebars_patterns + html_patterns,
+            "golang": golang_patterns + html_patterns,
+            "angular": html_patterns,
+            "all": django_jinja_patterns
+            + nunjucks_patterns
+            + handlebars_patterns
+            + golang_patterns
+            + html_patterns,
+        }
+
+        return any(
+            re.match(pattern, first_line) for pattern in pragma_patterns[config.profile]
+        )

package/tests/conftest.py

@@ -0,0 +1,239 @@
+"""Djlint test config."""
+# pylint: disable=W0621,C0116
+import difflib
+import os
+import re
+import shutil
+import tempfile
+from pathlib import Path
+from types import SimpleNamespace
+from typing import Dict, Generator, List, Optional, TextIO
+
+import pytest
+from _pytest.reports import BaseReport
+from _pytest.terminal import TerminalReporter
+from click.testing import CliRunner
+from colorama import Fore, Style
+
+from src.djlint import main as djlint
+from src.djlint.settings import Config
+
+
+class MyReporter(TerminalReporter):  # type: ignore
+    """Override default reporter to print more interesting details."""
+
+    def short_test_summary(self):
+        """Override summary."""
+        failed = self.stats.get("failed", [])
+
+        if failed:
+            self.write_sep("=", "Short Test Summary")
+            for rep in failed:
+                self.write_line(f"failed {rep.nodeid}")
+
+    def summary_failures(self) -> None:
+        """Override failure printer."""
+        if self.config.option.tbstyle != "no":
+            reports: List[BaseReport] = self.getreports("failed")
+            if not reports:
+                return
+            self.write_sep("=", "FAILURES")
+            if self.config.option.tbstyle == "line":
+                for rep in reports:
+                    line = self._getcrashline(rep)
+                    self.write_line(line)
+            else:
+                for rep in reports:
+                    msg = self._getfailureheadline(rep)
+                    self.write_sep("_", msg, red=True, bold=True)
+                    # modified version of _outrep_summary()
+                    # only show error if not assertion error,
+                    # otherwise our print function shows the diff better.
+                    if not re.search(r"AssertionError:", rep.longreprtext):
+                        rep.toterminal(self._tw)
+                    showcapture = self.config.option.showcapture
+                    if showcapture == "no":
+                        return
+                    for secname, content in rep.sections:
+                        if showcapture != "all" and showcapture not in secname:
+                            continue
+                        # self._tw.sep("-", secname)
+                        line_content = content
+                        if content[-1:] == "\n":
+                            line_content = content[:-1]
+                        self._tw.line(line_content)
+                    # continue original code
+                    self._handle_teardown_sections(rep.nodeid)
+
+
+@pytest.hookimpl(trylast=True)
+def pytest_configure(config):
+    vanilla_reporter = config.pluginmanager.getplugin("terminalreporter")
+    my_reporter = MyReporter(config)
+    config.pluginmanager.unregister(vanilla_reporter)
+    config.pluginmanager.register(my_reporter, "terminalreporter")
+
+
+@pytest.fixture()
+def runner() -> CliRunner:
+    """Click runner for djlint tests."""
+    return CliRunner()
+
+
+@pytest.fixture()
+def tmp_file() -> Generator:
+    """Create a temp file for formatting."""
+    # pylint: disable=R1732
+    tmp = tempfile.NamedTemporaryFile(delete=False)
+    yield tmp
+    tmp.close()
+    os.unlink(tmp.name)
+
+
+def printer(expected, source, actual):
+    width, _ = shutil.get_terminal_size()
+
+    expected_text = "Expected"
+    actual_text = "Actual"
+    diff_text = "Diff"
+    source_text = "Source"
+
+    expected_width = int((width - len(expected_text) - 2) / 2)
+    actual_width = int((width - len(actual_text) - 2) / 2)
+    diff_width = int((width - len(diff_text) - 2) / 2)
+    source_width = int((width - len(source_text) - 2) / 2)
+
+    color = {"-": Fore.YELLOW, "+": Fore.GREEN, "@": Style.BRIGHT + Fore.BLUE}
+
+    print()
+    print(
+        f"{Fore.BLUE}{Style.BRIGHT}{'─' * source_width} {source_text} {'─' * source_width}{Style.RESET_ALL}"
+    )
+    print()
+    print(source)
+    print()
+    print(
+        f"{Fore.BLUE}{Style.BRIGHT}{'─' * expected_width} {expected_text} {'─' * expected_width}{Style.RESET_ALL}"
+    )
+    print()
+    print(expected)
+    print()
+    print(
+        f"{Fore.BLUE}{Style.BRIGHT}{'─' * actual_width} {actual_text} {'─' * actual_width}{Style.RESET_ALL}"
+    )
+    print()
+    print(actual)
+    print()
+    print(
+        f"{Fore.BLUE}{Style.BRIGHT}{'─' * diff_width} {diff_text} {'─' * diff_width}{Style.RESET_ALL}"
+    )
+    print()
+    for diff in list(difflib.unified_diff(expected.split("\n"), actual.split("\n")))[
+        2:
+    ]:
+        print(f"{ color.get(diff[:1], Style.RESET_ALL)}{diff}{Style.RESET_ALL}")
+
+
+def lint_printer(source, expected, actual):
+    width, _ = shutil.get_terminal_size()
+
+    expected_text = "Expected Rules"
+    actual_text = "Actual"
+    source_text = "Source"
+
+    expected_width = int((width - len(expected_text) - 2) / 2)
+    actual_width = int((width - len(actual_text) - 2) / 2)
+    source_width = int((width - len(source_text) - 2) / 2)
+
+    print()
+    print(
+        f"{Fore.BLUE}{Style.BRIGHT}{'─' * source_width} {source_text} {'─' * source_width}{Style.RESET_ALL}"
+    )
+    print()
+    print(source)
+    print()
+
+    print(
+        f"{Fore.BLUE}{Style.BRIGHT}{'─' * expected_width} {expected_text} {'─' * expected_width}{Style.RESET_ALL}"
+    )
+    print()
+    for x in expected:
+        print(
+            f"{Fore.RED}{Style.BRIGHT}{x['code']}{Style.RESET_ALL} {x['line']} {x['match']}"
+        )
+        print(f'     {x["message"]}')
+        print()
+
+    print(
+        f"{Fore.BLUE}{Style.BRIGHT}{'─' * actual_width} {actual_text} {'─' * actual_width}{Style.RESET_ALL}"
+    )
+    print()
+
+    for x in actual:
+        print(
+            f"{Fore.RED}{Style.BRIGHT}{x['code']}{Style.RESET_ALL} {x['line']} {x['match']}"
+        )
+        print(f'     {x["message"]}')
+        print()
+    if len(actual) == 0:
+        print(f"{Fore.YELLOW}No codes found.{Style.RESET_ALL}")
+        print()
+
+    else:
+        print(f"{Fore.YELLOW}{actual}{Style.RESET_ALL}")
+        print()
+
+
+def write_to_file(the_file: str, the_text: bytes) -> None:
+    """Shortcode for write some bytes to a file."""
+    with open(the_file, mode="w+b") as open_file:
+        open_file.write(the_text)
+
+
+def reformat(
+    the_file: TextIO, runner: CliRunner, the_text: bytes, profile: str = "html"
+) -> SimpleNamespace:
+    write_to_file(the_file.name, the_text)
+    result = runner.invoke(djlint, [the_file.name, "--profile", profile, "--reformat"])
+    return SimpleNamespace(
+        **{
+            "text": Path(the_file.name).read_text(encoding="utf8"),
+            "exit_code": result.exit_code,
+        }
+    )
+
+
+def config_builder(args: Optional[Dict] = None) -> Config:
+    if args:
+        return Config("dummy/source.html", **args)
+    return Config("dummy/source.html")
+
+
+@pytest.fixture()
+def basic_config() -> Config:
+    """Return a config object with default basic options."""
+    return Config("dummy/source.html")
+
+
+@pytest.fixture()
+def django_config() -> Config:
+    """Return a config object with django profile."""
+    return Config("dummy/source.html", profile="django")
+
+
+@pytest.fixture()
+def jinja_config() -> Config:
+    """Return a config object with jinja."""
+    return Config("dummy/source.html", profile="jinja")
+
+
+@pytest.fixture()
+def handlebars_config() -> Config:
+    """Return a config object with handlebars."""
+    return Config("dummy/source.html", profile="handlebars")
+
+
+@pytest.fixture()
+def nunjucks_config() -> Config:
+    """Return a config object with nunjucks."""
+    return Config("dummy/source.html", profile="nunjucks")

package/tests/test_cli.py

@@ -0,0 +1,71 @@
+"""Test for cli inputs.
+
+poetry run pytest tests/test_cli.py
+"""
+from click.testing import CliRunner
+
+from src.djlint import main as djlint
+
+
+def test_cli(runner: CliRunner) -> None:
+    # missing options:
+    result = runner.invoke(
+        djlint,
+        [
+            "-",
+            "--check",
+            "--blank-line-after-tag",
+            "p",
+            "--blank-line-before-tag",
+            "p",
+            "--custom-blocks",
+            "toc",
+            "--custom-html",
+            "asdf",
+            "--exclude",
+            ".asdf",
+            "--extend-exclude",
+            ".asdf",
+            "--extension",
+            "html.dj",
+            "--format-attribute-template-tags",
+            "--format-css",
+            "--format-js",
+            "--ignore",
+            "H014,H015",
+            "--ignore-blocks",
+            "raw",
+            "--ignore-case",
+            "--include",
+            "H014",
+            "--indent",
+            "4",
+            "--linter-output-format",
+            "{code}",
+            "--max-attribute-length",
+            "9",
+            "--max-line-length",
+            "100",
+            "--preserve-blank-lines",
+            "--preserve-leading-space",
+            "--profile",
+            "django",
+            "--require-pragma",
+            "--use-gitignore",
+            "--per-file-ignores",
+            "test.html",
+            "H014",
+            "--per-file-ignores",
+            "test2.html",
+            "H015",
+            "--indent-css",
+            "4",
+            "--indent-js",
+            "4",
+        ],
+        input="<div></div>\n",
+    )
+
+    print(result.output)
+
+    assert result.exit_code == 0

package/tests/test_config/test_blank_line_after_tag.py

@@ -0,0 +1,135 @@
+"""Test for blank line after tag.
+
+--blank-line-after-tag 'include,load'
+
+poetry run pytest tests/test_config/test_blank_line_after_tag.py
+"""
+import pytest
+
+from src.djlint.reformat import formatter
+from tests.conftest import config_builder, printer
+
+test_data = [
+    pytest.param(
+        (
+            '{% extends "nothing.html" %}{% load stuff %}{% load stuff 2 %}{% include "html_two.html" %}<div></div>'
+        ),
+        (
+            '{% extends "nothing.html" %}\n'
+            "\n"
+            "{% load stuff %}\n"
+            "{% load stuff 2 %}\n"
+            "\n"
+            '{% include "html_two.html" %}\n'
+            "\n"
+            "<div></div>\n"
+        ),
+        ({"blank_line_after_tag": "include,load, extends"}),
+        id="one",
+    ),
+    pytest.param(
+        (
+            '<div class="tab-cnt">\n'
+            '    <div class="tab-dta active" id="details">\n'
+            '        <div class="em-grid">\n'
+            '            {% include "pages/task/details_source.html.j2" %}\n'
+            "\n"
+            "        </div>\n"
+            "    </div>\n"
+            "</div>"
+        ),
+        (
+            '<div class="tab-cnt">\n'
+            '    <div class="tab-dta active" id="details">\n'
+            '        <div class="em-grid">\n'
+            '            {% include "pages/task/details_source.html.j2" %}\n'
+            "\n"
+            "        </div>\n"
+            "    </div>\n"
+            "</div>\n"
+        ),
+        ({"blank_line_after_tag": "include"}),
+        id="blank_nested",
+    ),
+    pytest.param(
+        ("{% block this %}\n" "{% load i18n %}\n" "{% endblock this %}"),
+        ("{% block this %}\n" "    {% load i18n %}\n" "\n" "{% endblock this %}\n"),
+        ({"blank_line_after_tag": "endblock  , junk,load "}),
+        id="nested_indent",
+    ),
+    pytest.param(
+        (
+            "{% block include %}\n"
+            "    {#    {% include 'common/sticky-topbar-hidden-nav.html' %}#}\n"
+            "{% endblock %}\n"
+        ),
+        (
+            "{% block include %}\n"
+            "    {#    {% include 'common/sticky-topbar-hidden-nav.html' %}#}\n"
+            "{% endblock %}\n"
+        ),
+        ({"blank_line_after_tag": "load, extends,endblock"}),
+        id="test inside comment",
+    ),
+    pytest.param(
+        (
+            "{% blocktrans %}my words{% endblocktrans %}\n"
+            "{% block body %}\n"
+            "    <div></div>\n"
+            "{% endblock body %}\n"
+            "\n"
+            "{% block js %}{% endblock %}"
+        ),
+        (
+            "{% blocktrans %}my words{% endblocktrans %}\n"
+            "{% block body %}\n"
+            "    <div></div>\n"
+            "{% endblock body %}\n"
+            "\n"
+            "{% block js %}{% endblock %}\n"
+        ),
+        ({"blank_line_after_tag": "endblock"}),
+        id="endblock is not endblocktrans",
+    ),
+    pytest.param(
+        ("{% extends nothing %}\n" "\n" "<div></div>\n"),
+        ("{% extends nothing %}\n" "\n" "<div></div>\n"),
+        ({"blank_line_after_tag": "load, extends", "preserve_blank_lines": True}),
+        id="option should work with preserve blank lines",
+    ),
+    pytest.param(
+        (
+            "{% block %}stuff{% endblock %}\n"
+            "\n"
+            "{% block %}stuff{% endblock %}\n"
+            "\n"
+        ),
+        ("{% block %}stuff{% endblock %}\n" "\n" "{% block %}stuff{% endblock %}\n"),
+        ({"blank_line_after_tag": "load, extends,     include     ,endblock "}),
+        id="double block",
+    ),
+    pytest.param(
+        (
+            '{% include "pages/task/details/data_source.html.j2" %}\n'
+            '{% include "pages/task/details/query_location.html.j2" %}\n'
+            '{% include "pages/task/details/processing.html.j2" %}\n'
+            '{% include "pages/task/details/destination.html.j2" %}\n'
+        ),
+        (
+            '{% include "pages/task/details/data_source.html.j2" %}\n'
+            '{% include "pages/task/details/query_location.html.j2" %}\n'
+            '{% include "pages/task/details/processing.html.j2" %}\n'
+            '{% include "pages/task/details/destination.html.j2" %}\n'
+        ),
+        ({"blank_line_after_tag": "   include     ,endblock "}),
+        id="test multiple",
+    ),
+]
+
+
+@pytest.mark.parametrize(("source", "expected", "args"), test_data)
+def test_base(source, expected, args):
+    output = formatter(config_builder(args), source)
+
+    printer(expected, source, output)
+    assert expected == output

package/tests/test_config/test_blank_line_before_tag.py

@@ -0,0 +1,141 @@
+"""Test for blank line before tag.
+
+--blank-line-before-tag 'include,load'
+
+poetry run pytest tests/test_config/test_blank_line_before_tag.py
+"""
+import pytest
+
+from src.djlint.reformat import formatter
+from tests.conftest import config_builder, printer
+
+test_data = [
+    pytest.param(
+        (
+            '{% extends "nothing.html" %}{% load stuff %}{% load stuff 2 %}{% include "html_two.html" %}<div></div>'
+        ),
+        (
+            '{% extends "nothing.html" %}\n'
+            "\n"
+            "{% load stuff %}\n"
+            "{% load stuff 2 %}\n"
+            "\n"
+            '{% include "html_two.html" %}\n'
+            "<div></div>\n"
+        ),
+        ({"blank_line_before_tag": "include,load, extends"}),
+        id="one",
+    ),
+    pytest.param(
+        (
+            '<div class="tab-cnt">\n'
+            '    <div class="tab-dta active" id="details">\n'
+            '        <div class="em-grid">\n'
+            '            {% include "pages/task/details_source.html.j2" %}\n'
+            "\n"
+            "        </div>\n"
+            "    </div>\n"
+            "</div>"
+        ),
+        (
+            '<div class="tab-cnt">\n'
+            '    <div class="tab-dta active" id="details">\n'
+            '        <div class="em-grid">\n'
+            "\n"
+            '            {% include "pages/task/details_source.html.j2" %}\n'
+            "        </div>\n"
+            "    </div>\n"
+            "</div>\n"
+        ),
+        ({"blank_line_before_tag": "include"}),
+        id="blank_nested",
+    ),
+    pytest.param(
+        ("{% block this %}\n" "{% load i18n %}\n" "{% endblock this %}"),
+        (
+            "{% block this %}\n"
+            "\n"
+            "    {% load i18n %}\n"
+            "\n"
+            "{% endblock this %}\n"
+        ),
+        ({"blank_line_before_tag": "endblock  , junk,load "}),
+        id="nested_indent",
+    ),
+    pytest.param(
+        (
+            "{% block include %}\n"
+            "    {#    {% include 'common/sticky-topbar-hidden-nav.html' %}#}\n"
+            "{% endblock %}\n"
+        ),
+        (
+            "{% block include %}\n"
+            "    {#    {% include 'common/sticky-topbar-hidden-nav.html' %}#}\n"
+            "\n"
+            "{% endblock %}\n"
+        ),
+        ({"blank_line_before_tag": "load, extends,endblock"}),
+        id="test inside comment",
+    ),
+    pytest.param(
+        (
+            "{% blocktrans %}my words{% endblocktrans %}\n"
+            "{% block body %}\n"
+            "    <div></div>\n"
+            "{% endblock body %}\n"
+            "\n"
+            "{% block js %}{% endblock %}"
+        ),
+        (
+            "{% blocktrans %}my words{% endblocktrans %}\n"
+            "{% block body %}\n"
+            "    <div></div>\n"
+            "\n"
+            "{% endblock body %}\n"
+            "{% block js %}{% endblock %}\n"
+        ),
+        ({"blank_line_before_tag": "endblock"}),
+        id="endblock is not endblocktrans",
+    ),
+    pytest.param(
+        ("{% extends nothing %}\n" "\n" "<div></div>\n"),
+        ("{% extends nothing %}\n" "\n" "<div></div>\n"),
+        ({"blank_line_before_tag": "load, extends", "preserve_blank_lines": True}),
+        id="option should work with preserve blank lines",
+    ),
+    pytest.param(
+        (
+            "{% block %}stuff{% endblock %}\n"
+            "\n"
+            "{% block %}stuff{% endblock %}\n"
+            "\n"
+        ),
+        ("{% block %}stuff{% endblock %}\n" "{% block %}stuff{% endblock %}\n"),
+        ({"blank_line_before_tag": "load, extends,     include     ,endblock "}),
+        id="double block",
+    ),
+    pytest.param(
+        (
+            '{% include "pages/task/details/data_source.html.j2" %}\n'
+            '{% include "pages/task/details/query_location.html.j2" %}\n'
+            '{% include "pages/task/details/processing.html.j2" %}\n'
+            '{% include "pages/task/details/destination.html.j2" %}\n'
+        ),
+        (
+            '{% include "pages/task/details/data_source.html.j2" %}\n'
+            '{% include "pages/task/details/query_location.html.j2" %}\n'
+            '{% include "pages/task/details/processing.html.j2" %}\n'
+            '{% include "pages/task/details/destination.html.j2" %}\n'
+        ),
+        ({"blank_line_before_tag": "   include     ,endblock "}),
+        id="test multiple",
+    ),
+]
+
+
+@pytest.mark.parametrize(("source", "expected", "args"), test_data)
+def test_base(source, expected, args):
+    output = formatter(config_builder(args), source)
+
+    printer(expected, source, output)
+    assert expected == output