djlint 1.30.0 → 1.30.2

package/src/djlint/helpers.py

@@ -1,321 +0,0 @@
-"""Collection of shared djLint functions."""
-import regex as re
-
-from .settings import Config
-
-
-def is_ignored_block_opening(config: Config, item: str) -> bool:
-    """Find ignored group opening.
-
-    A valid ignored group opening tag will not be part of a
-    single line block.
-    """
-    last_index = 0
-    inline = list(
-        re.finditer(
-            config.ignored_blocks_inline,
-            item,
-            flags=re.IGNORECASE | re.VERBOSE | re.MULTILINE | re.DOTALL,
-        )
-    )
-
-    if inline:
-        last_index = inline[
-            -1
-        ].end()  # get the last index. The ignored opening should start after this.
-
-    return bool(
-        re.search(
-            re.compile(config.ignored_block_opening, re.IGNORECASE | re.VERBOSE),
-            item[last_index:],
-        )
-    )
-
-
-def inside_protected_trans_block(config: Config, html: str, match: re.Match) -> bool:
-    """Find ignored group closing.
-
-    A valid ignored group closing tag will not be part of a
-    single line block.
-
-    True = non indentable > inside ignored trans block
-    False = indentable > either inside a trans trimmed block, or somewhere else, but not a trans non trimmed :)
-    """
-    last_index = 0
-    close_block = re.search(
-        re.compile(
-            config.ignored_trans_blocks_closing, flags=re.IGNORECASE | re.VERBOSE
-        ),
-        match.group(),
-    )
-
-    if not close_block:
-        return False
-
-    non_trimmed = list(
-        re.finditer(
-            re.compile(
-                config.ignored_trans_blocks,
-                flags=re.IGNORECASE | re.VERBOSE | re.DOTALL,
-            ),
-            html,
-        )
-    )
-
-    trimmed = list(
-        re.finditer(
-            re.compile(
-                config.trans_trimmed_blocks,
-                flags=re.IGNORECASE | re.VERBOSE | re.DOTALL,
-            ),
-            html,
-        )
-    )
-
-    # who is max?
-    if non_trimmed and (not trimmed or non_trimmed[-1].end() > trimmed[-1].end()):
-        # non trimmed!
-        # check that this is not an inline block.
-        non_trimmed_inline = list(
-            re.finditer(
-                re.compile(
-                    config.ignored_trans_blocks,
-                    flags=re.IGNORECASE | re.VERBOSE | re.DOTALL,
-                ),
-                match.group(),
-            )
-        )
-
-        if non_trimmed_inline:
-            last_index = non_trimmed[
-                -1
-            ].end()  # get the last index. The ignored opening should start after this.
-
-            return re.search(
-                re.compile(
-                    config.ignored_trans_blocks_closing,
-                    flags=re.IGNORECASE | re.VERBOSE,
-                ),
-                html[last_index:],
-            )
-
-        return close_block.end(0) <= non_trimmed[-1].end()
-
-    elif trimmed:
-        # inside a trimmed block, we can return true to continue as if
-        # this is a indentable block
-        return close_block.end(0) > trimmed[-1].end()
-    return False
-
-    # print(close_block)
-    # if non_trimmed:
-    #     last_index = non_trimmed[
-    #         -1
-    #     ].end()  # get the last index. The ignored opening should start after this.
-
-    # return re.search(
-    #     re.compile(
-    #         config.ignored_trans_blocks_closing, flags=re.IGNORECASE | re.VERBOSE
-    #     ),
-    #     html[last_index:],
-    # )
-
-
-def is_ignored_block_closing(config: Config, item: str) -> bool:
-    """Find ignored group closing.
-
-    A valid ignored group closing tag will not be part of a
-    single line block.
-    """
-    last_index = 0
-    inline = list(
-        re.finditer(
-            re.compile(config.ignored_inline_blocks, flags=re.IGNORECASE | re.VERBOSE),
-            item,
-        )
-    )
-
-    if inline:
-        last_index = inline[
-            -1
-        ].end()  # get the last index. The ignored opening should start after this.
-
-    return re.search(
-        re.compile(config.ignored_block_closing, flags=re.IGNORECASE | re.VERBOSE),
-        item[last_index:],
-    )
-
-
-def is_safe_closing_tag(config: Config, item: str) -> bool:
-    """Find ignored group opening.
-
-    A valid ignored group opening tag will not be part of a
-    single line block.
-    """
-    last_index = 0
-    inline = list(
-        re.finditer(
-            re.compile(
-                config.ignored_inline_blocks + r" | " + config.ignored_blocks,
-                flags=re.IGNORECASE | re.VERBOSE | re.MULTILINE | re.DOTALL,
-            ),
-            item,
-        )
-    )
-
-    if inline:
-        last_index = inline[
-            -1
-        ].end()  # get the last index. The ignored opening should start after this.
-
-    return re.search(
-        re.compile(config.safe_closing_tag, flags=re.IGNORECASE | re.VERBOSE),
-        item[last_index:],
-    )
-
-
-def inside_template_block(config: Config, html: str, match: re.Match) -> bool:
-    """Check if a re.Match is inside of a template block."""
-    return any(
-        ignored_match.start(0) <= match.start() and match.end(0) <= ignored_match.end()
-        for ignored_match in list(
-            re.finditer(
-                re.compile(
-                    config.template_blocks,
-                    re.DOTALL | re.IGNORECASE | re.VERBOSE | re.MULTILINE,
-                ),
-                html,
-            )
-        )
-    )
-
-
-def inside_ignored_linter_block(config: Config, html: str, match: re.Match) -> bool:
-    """Check if a re.Match is inside of a ignored linter block."""
-    return any(
-        ignored_match.start(0) <= match.start() and match.end(0) <= ignored_match.end()
-        for ignored_match in list(
-            re.finditer(
-                re.compile(
-                    config.ignored_linter_blocks,
-                    re.DOTALL | re.IGNORECASE | re.VERBOSE | re.MULTILINE,
-                ),
-                html,
-            )
-        )
-    )
-
-
-def inside_ignored_block(config: Config, html: str, match: re.Match) -> bool:
-    """Do not add whitespace if the tag is in a non indent block."""
-    return any(
-        ignored_match.start(0) <= match.start() and match.end(0) <= ignored_match.end()
-        for ignored_match in list(
-            re.finditer(
-                re.compile(
-                    config.ignored_blocks,
-                    re.DOTALL | re.IGNORECASE | re.VERBOSE | re.MULTILINE,
-                ),
-                html,
-            )
-        )
-        + list(
-            re.finditer(
-                re.compile(config.ignored_inline_blocks, re.IGNORECASE | re.VERBOSE),
-                html,
-            )
-        )
-    )
-
-
-def child_of_unformatted_block(config: Config, html: str, match: re.Match) -> bool:
-    """Do not add whitespace if the tag is in a non indent block."""
-    return any(
-        ignored_match.start(0) < match.start() and match.end(0) <= ignored_match.end()
-        for ignored_match in list(
-            re.finditer(
-                re.compile(
-                    config.unformatted_blocks,
-                    re.DOTALL | re.IGNORECASE | re.VERBOSE | re.MULTILINE,
-                ),
-                html,
-            )
-        )
-    )
-
-
-def child_of_ignored_block(config: Config, html: str, match: re.Match) -> bool:
-    """Do not add whitespace if the tag is in a non indent block."""
-    return any(
-        ignored_match.start(0) < match.start() and match.end(0) <= ignored_match.end()
-        for ignored_match in list(
-            re.finditer(
-                re.compile(
-                    config.ignored_blocks,
-                    re.DOTALL | re.IGNORECASE | re.VERBOSE | re.MULTILINE,
-                ),
-                html,
-            )
-        )
-        + list(
-            re.finditer(
-                re.compile(config.ignored_inline_blocks, re.IGNORECASE | re.VERBOSE),
-                html,
-            )
-        )
-    )
-
-
-def overlaps_ignored_block(config: Config, html: str, match: re.Match) -> bool:
-    """Do not add whitespace if the tag is in a non indent block."""
-    return any(
-        # don't require the match to be fully inside the ignored block.
-        # poorly build html will probably span ignored blocks and should be ignored.
-        (
-            ignored_match.start(0) <= match.start()
-            and match.start() <= ignored_match.end()
-        )
-        or (
-            ignored_match.start(0) <= match.end() and match.end() <= ignored_match.end()
-        )
-        for ignored_match in list(
-            re.finditer(
-                re.compile(
-                    config.ignored_blocks,
-                    re.DOTALL | re.IGNORECASE | re.VERBOSE | re.MULTILINE | re.DOTALL,
-                ),
-                html,
-            )
-        )
-        + list(
-            re.finditer(
-                re.compile(config.ignored_inline_blocks, re.IGNORECASE | re.VERBOSE),
-                html,
-            )
-        )
-    )
-
-
-def inside_ignored_rule(config: Config, html: str, match: re.Match, rule: str) -> bool:
-    """Check if match is inside an ignored pattern."""
-    for rule_regex in config.ignored_rules:
-        for ignored_match in list(
-            re.finditer(
-                re.compile(rule_regex, re.DOTALL | re.IGNORECASE | re.VERBOSE),
-                html,
-            )
-        ):
-            if (
-                rule in list(set(re.split(r"\s|,", ignored_match.group(1).strip())))
-                and (
-                    ignored_match.start(0) <= match.start()
-                    and match.start() <= ignored_match.end()
-                )
-                or not ignored_match.group(1).strip()
-                and (
-                    ignored_match.start(0) <= match.end()
-                    and match.end() <= ignored_match.end()
-                )
-            ):
-                return True
-    return False

package/src/djlint/lint.py

@@ -1,128 +0,0 @@
-"""Djlint html linter."""
-import importlib
-from pathlib import Path
-from typing import Dict, List
-
-import regex as re
-
-from .helpers import (
-    inside_ignored_linter_block,
-    inside_ignored_rule,
-    overlaps_ignored_block,
-)
-from .settings import Config
-
-flags = {
-    "re.A": re.A,
-    "re.ASCII": re.ASCII,
-    "re.I": re.I,
-    "re.IGNORECASE": re.IGNORECASE,
-    "re.M": re.M,
-    "re.MULTILINE": re.MULTILINE,
-    "re.S": re.S,
-    "re.DOTALL": re.DOTALL,
-    "re.X": re.X,
-    "re.VERBOSE": re.VERBOSE,
-    "re.L": re.L,
-    "re.LOCALE": re.LOCALE,
-}
-
-
-def build_flags(flag_list: str) -> int:
-    """Build list of regex flags."""
-    split_flags = flag_list.split("|")
-
-    combined_flags = 0
-    for flag in split_flags:
-        combined_flags |= flags[flag.strip()]
-    return combined_flags
-
-
-def get_line(start: int, line_ends: List) -> str:
-    """Get the line number and index of match."""
-    line = list(filter(lambda pair: pair["end"] > start, line_ends))[0]
-
-    # pylint: disable=C0209
-    return "%d:%d" % (line_ends.index(line) + 1, start - line["start"])
-
-
-def linter(config: Config, html: str, filename: str, filepath: str) -> Dict:
-    """Lint a html string."""
-    errors: dict = {filename: []}
-    # build list of line ends for file
-    line_ends = [
-        {"start": m.start(), "end": m.end()}
-        for m in re.finditer(r"(?:.*\n)|(?:[^\n]+$)", html)
-    ]
-
-    ignored_rules: List[str] = []
-
-    # remove ignored rules for file
-    for pattern, rules in config.per_file_ignores.items():
-        if re.search(pattern, filepath, re.VERBOSE):
-            ignored_rules += [x.strip() for x in rules.split(",")]
-
-    for rule in config.linter_rules:
-        rule = rule["rule"]
-
-        # skip ignored rules
-        if rule["name"] in ignored_rules:
-            continue
-
-        # rule based on python module
-        if "python_module" in rule:
-            rule_module = importlib.import_module(rule["python_module"])
-            module_errors = rule_module.run(
-                rule=rule,
-                config=config,
-                html=html,
-                filepath=filepath,
-                line_ends=line_ends,
-            )
-            assert isinstance(module_errors, list), (
-                f"Error: {rule['name']} python_module run() should return a list of "
-                "dict with keys: code, line, match, message."
-            )
-            errors[filename].extend(module_errors)
-
-        # rule based on patterns
-        else:
-            for pattern in rule["patterns"]:
-                for match in re.finditer(
-                    re.compile(
-                        pattern, flags=build_flags(rule.get("flags", "re.DOTALL"))
-                    ),
-                    html,
-                ):
-                    if (
-                        overlaps_ignored_block(config, html, match) is False
-                        and inside_ignored_rule(config, html, match, rule["name"])
-                        is False
-                        and inside_ignored_linter_block(config, html, match) is False
-                    ):
-                        errors[filename].append(
-                            {
-                                "code": rule["name"],
-                                "line": get_line(match.start(), line_ends),
-                                "match": match.group().strip()[:20],
-                                "message": rule["message"],
-                            }
-                        )
-
-    # remove duplicate matches
-    for filename, error_dict in errors.items():
-        unique_errors = []
-        for dict_ in error_dict:
-            if dict_ not in unique_errors:
-                unique_errors.append(dict_)
-        errors[filename] = unique_errors
-    return errors
-
-
-def lint_file(config: Config, this_file: Path) -> Dict:
-    """Check file for formatting errors."""
-    filename = str(this_file)
-
-    html = this_file.read_text(encoding="utf8")
-
-    return linter(config, html, filename, this_file.as_posix())

package/src/djlint/output.py

@@ -1,220 +0,0 @@
-"""Build djLint console output."""
-import shutil
-from collections import Counter
-from pathlib import Path
-from typing import Any, Dict, List, Optional
-
-import regex as re
-from click import echo
-from colorama import Fore, Style
-
-from .settings import Config
-
-try:
-    # this is used for windows + gitbash to set encoding correctly.
-    import sys
-
-    sys.stdout.reconfigure(encoding="utf-8")  # type: ignore[attr-defined]
-# pylint:disable=W0703
-except BaseException:
-    pass
-
-
-def print_output(
-    config: Config, file_errors: List[Dict[Any, Any]], file_count: int
-) -> int:
-    """Print results to console."""
-    file_quantity = build_quantity(file_count)
-    # format errors
-    reformat_success_message = ""
-    lint_success_message = ""
-    lint_error_count = 0
-    format_error_count = 0
-    print_blanks = config.stdin is False and config.quiet is False
-
-    if print_blanks:
-        echo()
-
-    for error in sorted(file_errors, key=lambda x: next(iter(list(x.values())[0]))):
-        if error.get("format_message") and config.stdin is False:
-            # reformat message
-            format_error_count += build_check_output(error["format_message"], config)
-
-        if error.get("lint_message"):
-            # lint message
-            lint_error_count += build_output(error["lint_message"], config)
-
-    if config.statistics and config.lint:
-        build_stats_output([x.get("lint_message") for x in file_errors], config)
-
-    tense_message = (
-        build_quantity(format_error_count) + " would be"
-        if config.check is True
-        else build_quantity_tense(format_error_count)
-    )
-    reformat_success_message = f"{tense_message} updated."
-
-    error_case = "error" if lint_error_count == 1 else "errors"
-    lint_success_message += (
-        f"Linted {file_quantity}, found {lint_error_count} {error_case}."
-    )
-
-    if print_blanks:
-        echo()
-
-    if (
-        config.quiet is False
-        and config.stdin is False
-        and (config.reformat or config.check)
-    ):
-        reformat_success_color = (
-            Fore.RED + Style.BRIGHT if (format_error_count) > 0 else Fore.BLUE
-        )
-        echo(f"{reformat_success_color}{reformat_success_message}{Style.RESET_ALL}")
-
-    if config.lint and config.quiet is False:
-        lint_success_color = (
-            Fore.RED + Style.BRIGHT if (lint_error_count) > 0 else Fore.BLUE
-        )
-        echo(f"{lint_success_color}{lint_success_message}{Style.RESET_ALL}")
-
-    if print_blanks:
-        echo()
-
-    return lint_error_count + format_error_count
-
-
-def build_relative_path(url: str, project_root: Path) -> str:
-    """Get path relative to project."""
-    url_path = Path(url)
-    if project_root != url_path and project_root in url_path.parents:
-        return str(url_path.relative_to(project_root.resolve()))
-
-    return url
-
-
-def build_output(error: dict, config: Config) -> int:
-    """Build output for file errors."""
-    errors = sorted(
-        list(error.values())[0], key=lambda x: tuple(map(int, x["line"].split(":")))
-    )
-
-    width, _ = shutil.get_terminal_size()
-
-    if len(errors) == 0:
-        return 0
-
-    filename = build_relative_path(list(error.keys())[0], config.project_root.resolve())
-
-    if "{filename}" not in config.linter_output_format and not config.stdin:
-        echo(
-            f"{Fore.GREEN}{Style.BRIGHT}\n{filename}\n{Style.DIM}"
-            + "".join(["─" for x in range(1, width)])
-            + Style.RESET_ALL
-        )
-
-    for message_dict in errors:
-        line = Fore.BLUE + message_dict["line"] + Style.RESET_ALL
-        code = (
-            (Fore.RED if message_dict["code"][:1] == "E" else Fore.YELLOW)
-            + message_dict["code"]
-            + Style.RESET_ALL
-        )
-        message = message_dict["message"]
-        match = (
-            Fore.BLUE
-            + re.sub(r"\s{2,}|\n", " ", message_dict["match"])
-            + Style.RESET_ALL
-        )
-
-        echo(
-            config.linter_output_format.format(
-                filename=filename, line=line, code=code, message=message, match=match
-            ),
-            err=False,
-        )
-
-    return len(errors)
-
-
-def build_check_output(errors: dict, config: Config) -> int:
-    """Build output for reformat check."""
-    if len(errors) == 0:
-        return 0
-
-    color = {"-": Fore.YELLOW, "+": Fore.GREEN, "@": Style.BRIGHT + Fore.BLUE}
-    width, _ = shutil.get_terminal_size()
-
-    if config.quiet is False and len(list(errors.values())[0]) > 0:
-        echo(
-            Fore.GREEN
-            + Style.BRIGHT
-            + "\n"
-            + build_relative_path(list(errors.keys())[0], config.project_root.resolve())
-            + "\n"
-            + Style.DIM
-            + "".join(["─" for x in range(1, width)])
-            + Style.RESET_ALL
-        )
-
-        for diff in list(errors.values())[0][2:]:
-            echo(
-                f"{ color.get(diff[:1], Style.RESET_ALL)}{diff}{Style.RESET_ALL}",
-                err=False,
-            )
-
-    return len(list(filter(lambda x: len(x) > 0, errors.values())))
-
-
-def build_quantity(size: int) -> str:
-    """Count files in a list."""
-    return str(size) + " file" + ("s" if size > 1 or size == 0 else "")
-
-
-def build_quantity_tense(size: int) -> str:
-    """Count files in a list."""
-    return (
-        str(size)
-        + " file"
-        + ("s" if size > 1 or size == 0 else "")
-        + " "
-        + ("were" if size > 1 or size == 0 else "was")
-    )
-
-
-def build_stats_output(errors: List[Optional[Any]], config: Config) -> int:
-    """Build output for linter statistics."""
-    if len(errors) == 0:
-        return 0
-
-    codes = []
-    for error in errors:
-        if error:
-            for code in list(error.values())[0]:
-                codes.append(code["code"])
-
-    messages = {
-        rule["rule"]["name"]: rule["rule"]["message"] for rule in config.linter_rules
-    }
-
-    echo()
-    width, _ = shutil.get_terminal_size()
-    echo(
-        f"{Fore.GREEN}{Style.BRIGHT}Statistics{Style.RESET_ALL}\n{Style.DIM}{'─' * width}{Style.RESET_ALL}"
-    )
-
-    if messages and codes:
-        longest_code = len(max(messages.keys(), key=len))
-        longest_count = len(
-            str(max(Counter(codes).values(), key=lambda x: len(str(x))))
-        )
-
-        for code in sorted(Counter(codes).items()):
-            code_space = (longest_code - len(str(code[0]))) * " "
-            count_space = (longest_count - len(str(code[1]))) * " "
-
-            echo(
-                f"{Fore.YELLOW}{code[0]}{Fore.BLUE} {code_space}{code[1]}{Style.RESET_ALL} {count_space}{messages[code[0]]}"
-            )
-
-    return sum(Counter(codes).values())