djlint 1.30.0 → 1.30.2

package/src/djlint/formatter/attributes.py

@@ -1,212 +0,0 @@
-"""Format attributes."""
-
-from functools import partial
-
-import regex as re
-
-from ..helpers import child_of_ignored_block
-from ..settings import Config
-
-
-def format_template_tags(config: Config, attributes: str, spacing: int) -> str:
-    """Format template tags in attributes."""
-    # find break tags, add breaks + indent
-    # find unindent lines and move back
-    # put short stuff back on one line
-
-    def add_indentation(config: Config, attributes: str, spacing: int) -> str:
-        """Indent template tags.
-
-        |    <form class="this"
-        |    ----- attribute name
-        |
-        |    <form class="this"
-        |---^ leading space
-        |
-        |    <form class="this"
-        |    ^----^ base indent
-        |
-        """
-        indent = 0
-        indented = ""
-        indent_adder = spacing or 0
-
-        for line_number, line in enumerate(attributes.splitlines()):
-            # when checking for template tag, use "match" to force start of line check.
-            if re.match(
-                re.compile(config.template_unindent, re.I | re.X), line.strip()
-            ):
-                indent = indent - 1
-                tmp = (indent * config.indent) + (indent_adder * " ") + line.strip()
-
-            elif re.match(
-                re.compile(config.tag_unindent_line, re.I | re.X), line.strip()
-            ):
-                # if we are leaving an indented group, then remove the indent_adder
-                tmp = (
-                    max(indent - 1, 0) * config.indent
-                    + indent_adder * " "
-                    + line.strip()
-                )
-
-            elif re.search(
-                re.compile(config.template_indent, re.I | re.X), line.strip()
-            ) and not re.search(
-                re.compile(config.template_unindent, re.I | re.X), line.strip()
-            ):
-                # for open tags, search, but then check that they are not closed.
-                tmp = (indent * config.indent) + (indent_adder * " ") + line.strip()
-                indent = indent + 1
-
-            else:
-                tmp = (indent * config.indent) + (indent_adder * " ") + line.strip()
-
-            if line_number == 0:
-                # don't touch first line
-                indented += line.strip()
-            elif tmp.strip():
-                indented += f"\n{tmp}"
-
-        return indented
-
-    def add_break(pattern: str, match: re.Match) -> str:
-        """Make a decision if a break should be added."""
-        if pattern == "before":
-            return f"\n{match.group()}"
-
-        return f"{match.group(1)}\n{match.group(2).strip()}"
-
-    break_char = config.break_before
-
-    func = partial(add_break, "before")
-
-    attributes = re.sub(
-        re.compile(
-            break_char
-            + r".\K((?:{%|{{\#)[ ]*?(?:"
-            + config.break_template_tags
-            + ")[^}]+?[%|}]})",
-            flags=re.IGNORECASE | re.MULTILINE | re.VERBOSE,
-        ),
-        func,
-        attributes,
-    )
-
-    func = partial(add_break, "after")
-    # break after
-    attributes = re.sub(
-        re.compile(
-            r"((?:{%|{{\#)[ ]*?(?:"
-            + config.break_template_tags
-            + ")[^}]+?[%|}]})([^\n]+)$",
-            flags=re.IGNORECASE | re.MULTILINE | re.VERBOSE,
-        ),
-        func,
-        attributes,
-    )
-    attributes = add_indentation(config, attributes, spacing)
-
-    return attributes
-
-
-def format_attributes(config: Config, html: str, match: re.match) -> str:
-    """Spread long attributes over multiple lines."""
-    # check that we are not inside an ignored block
-    if (
-        child_of_ignored_block(config, html, match)
-        or len(match.group(3).strip()) < config.max_attribute_length
-    ):
-        return match.group()
-
-    leading_space = match.group(1)
-
-    tag = match.group(2) + " "
-
-    spacing = leading_space + len(tag) * " "
-
-    attributes = []
-
-    # format attributes as groups
-    for attr_grp in re.finditer(
-        config.attribute_pattern, match.group(3).strip(), re.VERBOSE
-    ):
-        attrib_name = attr_grp.group(1)
-        is_quoted = attr_grp.group(2) and attr_grp.group(2)[0] in ["'", '"']
-        quote = attr_grp.group(2)[0] if is_quoted else '"'
-
-        attrib_value = None
-
-        if attr_grp.group(2) and attr_grp.group(2)[0] == attr_grp.group(2)[-1]:
-            if attr_grp.group(2)[0] == "'":
-                attrib_value = attr_grp.group(2).strip("'")
-
-            elif attr_grp.group(2)[0] == '"':
-                attrib_value = attr_grp.group(2).strip('"')
-
-            else:
-                attrib_value = attr_grp.group(2)
-        else:
-            attrib_value = attr_grp.group(2)
-
-        standalone = attr_grp.group(3)
-
-        quote_length = 1
-
-        if attrib_name and attrib_value:
-            # for the equals sign
-            quote_length += 1
-
-        if config.format_attribute_template_tags:
-            join_space = "\n" + spacing
-        else:
-            join_space = (
-                "\n" + spacing + int(quote_length + len(attrib_name or "")) * " "
-            )
-
-        # format style attribute
-        if attrib_name and attrib_name.lower() == "style":
-            attrib_value = (";" + join_space).join(
-                [value.strip() for value in attrib_value.split(";") if value.strip()]
-            )
-
-        elif attrib_name and attrib_name.lower() in ["srcset", "data-srcset", "sizes"]:
-            # vw
-            attrib_value = ("w," + join_space).join(
-                [value.strip() for value in attrib_value.split("w,") if value.strip()]
-            )
-            # px
-            attrib_value = ("x," + join_space).join(
-                [value.strip() for value in attrib_value.split("x,") if value.strip()]
-            )
-
-        # format template stuff
-        if config.format_attribute_template_tags:
-            if attrib_value and attrib_name not in config.ignored_attributes:
-                attrib_value = format_template_tags(
-                    config,
-                    attrib_value,
-                    int(len(spacing) + len(attrib_name or "") + quote_length),
-                )
-
-            if standalone:
-                standalone = format_template_tags(
-                    config, standalone, int(len(spacing) + len(attrib_name or ""))
-                )
-
-        if attrib_name and attrib_value or is_quoted:
-            attrib_value = attrib_value or ""
-            attributes.append(f"{attrib_name}={quote}{attrib_value}{quote}")
-        else:
-            attributes.append(
-                (attrib_name or "") + (attrib_value or "") + (standalone or "")
-            )
-    attribute_string = ("\n" + spacing).join([x for x in attributes if x])
-
-    close = match.group(4)
-
-    attribute_string = f"{leading_space}{tag}{attribute_string}{close}"
-
-    # clean trailing spaces added by breaks
-    attribute_string = "\n".join([x.rstrip() for x in attribute_string.splitlines()])
-
-    return f"{attribute_string}"

package/src/djlint/formatter/compress.py

@@ -1,64 +0,0 @@
-"""Compress html.
-
-1. flatten attributes
-"""
-
-import regex as re
-from HtmlTagNames import html_tag_names
-from HtmlVoidElements import html_void_elements
-
-from ..helpers import child_of_unformatted_block
-from ..settings import Config
-
-
-def compress_html(html: str, config: Config) -> str:
-    """Compress html."""
-
-    def _fix_case(tag):
-        if config.ignore_case is False and tag.lower() in html_tag_names:
-            return tag.lower()
-
-        if config.ignore_case is False and tag.lower() == "doctype":
-            return "DOCTYPE"
-        return tag
-
-    def _clean_tag(match: re.Match) -> str:
-        """Flatten multiline attributes back to one line.
-
-        Skip when attribute is ignored.
-        Attribute name can be in group one or group 2.
-        for now, skipping if they are anywhere
-
-        tags starting ignored blocks can have their attributes formatted,
-        for example <textarea class="..." id="..."> can be formatted.
-        """
-        if child_of_unformatted_block(config, html, match):
-            return match.group()
-
-        open_braket = match.group(1)
-        tag = _fix_case(match.group(2))
-
-        attributes = (
-            (" " + " ".join(x.strip() for x in match.group(3).strip().splitlines()))
-            if match.group(3)
-            else ""
-        )
-        if tag.lower() in html_void_elements and config.close_void_tags:
-            close_braket = " />"
-        else:
-            close_braket = (
-                match.group(4) if "/" not in match.group(4) else f" {match.group(4)}"
-            )
-
-        return f"{open_braket}{tag}{attributes}{close_braket}"
-
-    html = re.sub(
-        re.compile(
-            config.html_tag_regex,
-            flags=re.MULTILINE | re.VERBOSE | re.IGNORECASE,
-        ),
-        _clean_tag,
-        html,
-    )
-
-    return html

package/src/djlint/formatter/condense.py

@@ -1,221 +0,0 @@
-"""Condense HTML.
-
-1. Put short html tags back on one line
-2. Put short template tags back on one line
-"""
-
-from functools import partial
-
-import regex as re
-
-from ..helpers import (
-    inside_ignored_block,
-    inside_protected_trans_block,
-    is_safe_closing_tag,
-)
-from ..settings import Config
-
-
-def clean_whitespace(html: str, config: Config) -> str:
-    """Compress back tags that do not need to be expanded."""
-    # put empty tags on one line
-
-    def strip_space(config: Config, html: str, match: re.Match) -> str:
-        """Trim leading whitespace."""
-        # either inside a block, or this is a newline + closing block tag.
-        # if it is a newline + closing block we can format it.
-
-        if inside_ignored_block(config, html, match) and not is_safe_closing_tag(
-            config, match.group()
-        ):
-            return match.group()
-
-        # trimmed blocks should not be here.
-        # we need to full html to check what type of
-        # opening block it was - trimmed or not trimmed
-        if inside_protected_trans_block(config, html[: match.end()], match):
-            return match.group().rstrip()
-
-        return match.group(1)
-
-    func = partial(strip_space, config, html)
-
-    line_contents = r"(.*?)"
-    trailing_contents = r"\n \t"
-
-    if config.preserve_blank_lines:
-        line_contents = r"([^\n]+?)"
-        trailing_contents = r" \t"
-
-    if not config.preserve_leading_space:
-        # remove any leading/trailing space
-        html = re.sub(
-            re.compile(rf"^[ \t]*{line_contents}[{trailing_contents}]*$", re.M),
-            func,
-            html,
-        )
-
-    else:
-        # only remove leading space in front of tags
-        # <, {%
-        html = re.sub(
-            re.compile(rf"^[ \t]*((?:<|{{%).*?)[{trailing_contents}]*$", re.M),
-            func,
-            html,
-        )
-        html = re.sub(
-            re.compile(rf"^{line_contents}[{trailing_contents}]*$", re.M), func, html
-        )
-
-    def add_blank_line_after(config: Config, html: str, match: re.Match) -> str:
-        """Add break after if not in ignored block."""
-        if inside_ignored_block(config, html, match):
-            return match.group()
-
-        # check that next line is not blank.
-        if html[match.end() : match.end() + 1] != "\n":  # noqa:E203
-            return match.group() + "\n"
-
-        return match.group()
-
-    func = partial(add_blank_line_after, config, html)
-
-    # should we add blank lines after load tags?
-    if config.blank_line_after_tag:
-        for tag in [x.strip() for x in config.blank_line_after_tag.split(",")]:
-            html = re.sub(
-                re.compile(
-                    rf"((?:{{%\s*?{tag}\b[^}}]+?%}}\n?)+)",
-                    re.IGNORECASE | re.MULTILINE | re.DOTALL,
-                ),
-                func,
-                html,
-            )
-
-    def add_blank_line_before(config: Config, html: str, match: re.Match) -> str:
-        """Add break before if not in ignored block and not first line in file."""
-        if inside_ignored_block(config, html, match) or match.start() == 0:
-            return match.group()
-
-        return "\n" + match.group()
-
-    func = partial(add_blank_line_before, config, html)
-
-    # should we add blank lines before load tags?
-    if config.blank_line_before_tag:
-        for tag in [x.strip() for x in config.blank_line_before_tag.split(",")]:
-            html = re.sub(
-                re.compile(
-                    rf"(?<!^\n)((?:{{%\s*?{tag}\b[^}}]+?%}}\n?)+)",
-                    re.IGNORECASE | re.MULTILINE | re.DOTALL,
-                ),
-                func,
-                html,
-            )
-
-    # add line after yaml front matter
-
-    def yaml_add_blank_line_after(html: str, match: re.Match) -> str:
-        """Add break after if not in ignored block."""
-        if match.start() == 0 and not html.startswith("\n\n", match.end()):
-            # verify there are not already blank lines
-            return match.group() + "\n"
-
-        return match.group()
-
-    if config.no_line_after_yaml is False:
-        func = partial(yaml_add_blank_line_after, html)
-        html = re.sub(
-            re.compile(
-                r"(^---.+?---)$",
-                re.MULTILINE | re.DOTALL,
-            ),
-            func,
-            html,
-        )
-
-    return html
-
-
-def condense_html(html, config):
-    """Put short tags back on a single line."""
-    if config.preserve_leading_space:
-        # if a user is attempting to reuse any leading
-        # space for other purposes, we should not try to remove it.
-        return html
-
-    def condense_line(config: Config, html: str, match: re.Match) -> str:
-        """Put contents on a single line if below max line length."""
-        # match.group(1) contains the opening tag, which may be split over multiple lines
-        if config.line_break_after_multiline_tag:
-            combined_length = len(match.group(1) + match.group(3) + match.group(4))
-        else:
-            combined_length = len(
-                match.group(1).splitlines()[-1] + match.group(3) + match.group(4)
-            )
-
-        if (
-            not inside_ignored_block(config, html, match)
-            and combined_length < config.max_line_length
-            and if_blank_line_after_match(config, match.group(3))
-            and if_blank_line_before_match(config, match.group(3))
-        ):
-            return match.group(1) + match.group(3) + match.group(4)
-
-        return match.group()
-
-    def if_blank_line_after_match(config: Config, html: str) -> bool:
-        """Check if there should be a blank line after."""
-        if config.blank_line_after_tag:
-            return not any(
-                re.findall(
-                    re.compile(
-                        rf"((?:{{%\s*?{tag}[^}}]+?%}}\n?)+)",
-                        re.IGNORECASE | re.MULTILINE | re.DOTALL,
-                    ),
-                    html,
-                )
-                for tag in [x.strip() for x in config.blank_line_after_tag.split(",")]
-            )
-        return True
-
-    def if_blank_line_before_match(config: Config, html: str) -> bool:
-        """Check if there should be a blank line before."""
-        if config.blank_line_before_tag:
-            return not any(
-                re.findall(
-                    re.compile(
-                        rf"((?:{{%\s*?{tag}[^}}]+?%}}\n?)+)",
-                        re.IGNORECASE | re.MULTILINE | re.DOTALL,
-                    ),
-                    html,
-                )
-                for tag in [x.strip() for x in config.blank_line_before_tag.split(",")]
-            )
-        return True
-
-    # add blank lines before tags
-    func = partial(condense_line, config, html)
-
-    # put short single line tags on one line
-    html = re.sub(
-        re.compile(
-            rf"(<({config.optional_single_line_html_tags})\b(?:\"[^\"]*\"|'[^']*'|{{[^}}]*}}|[^'\">{{}}])*>)\s*([^<\n]*?)\s*?(</(\2)>)",
-            re.IGNORECASE | re.MULTILINE | re.DOTALL | re.VERBOSE,
-        ),
-        func,
-        html,
-    )
-
-    # put short template tags back on one line. must have leading space
-    # jinja +%} and {%+ intentionally omitted.
-    html = re.sub(
-        re.compile(
-            rf"((?:\s|^){{%-?[ ]*?({config.optional_single_line_template_tags})(?:(?!\n|%}}).)*?%}})\s*([^%\n]*?)\s*?({{%-?[ ]+?end(\2)[ ]*?%}})",
-            flags=re.IGNORECASE | re.MULTILINE | re.VERBOSE,
-        ),
-        func,
-        html,
-    )
-
-    return html

package/src/djlint/formatter/css.py

@@ -1,60 +0,0 @@
-"""djLint function to call cssbeautifier."""
-from functools import partial
-
-import cssbeautifier
-import regex as re
-from jsbeautifier.javascript.options import BeautifierOptions
-
-from ..helpers import child_of_unformatted_block
-from ..settings import Config
-
-
-def format_css(html: str, config: Config) -> str:
-    """Format css inside <style> tags."""
-
-    def launch_formatter(config: Config, html: str, match: re.Match) -> str:
-        """Add break after if not in ignored block."""
-        if child_of_unformatted_block(config, html, match):
-            return match.group()
-
-        if not match.group(3).strip():
-            return match.group()
-
-        indent = len(match.group(1)) * " "
-
-        # because of the param options for js-beautifier we cannot pass
-        # in a fixed space leading.
-        # so, call formatter twice, once with a fake indent.
-        # check which lines changed (these are the formattable lines)
-        # and add the leading space to them.
-
-        config.css_config["indent_level"] = 1
-        opts = BeautifierOptions(config.css_config)
-        beautified_lines = cssbeautifier.beautify(match.group(3), opts).splitlines()
-
-        config.js_config["indent_level"] = 2
-        opts = BeautifierOptions(config.js_config)
-        beautified_lines_test = cssbeautifier.beautify(
-            match.group(3), opts
-        ).splitlines()
-
-        beautified = ""
-        for line, test in zip(beautified_lines, beautified_lines_test):
-            beautified += "\n"
-            if line == test:
-                beautified += line
-                continue
-            beautified += indent + line
-
-        return match.group(1) + match.group(2) + beautified + "\n" + indent
-
-    func = partial(launch_formatter, config, html)
-
-    return re.sub(
-        re.compile(
-            r"([ ]*?)(<(?:style)\b(?:\"[^\"]*\"|'[^']*'|{[^}]*}|[^'\">{}])*>)(.*?)(?=</style>)",
-            re.IGNORECASE | re.DOTALL,
-        ),
-        func,
-        html,
-    )

package/src/djlint/formatter/expand.py

@@ -1,111 +0,0 @@
-"""Expand html.
-
-1. put html tags on individual lines, if needed.
-2. put template tags on individual lines, if needed.
-"""
-
-from functools import partial
-
-import regex as re
-
-from ..helpers import inside_ignored_block, inside_template_block
-from ..settings import Config
-
-
-def expand_html(html: str, config: Config) -> str:
-    """Split single line html into many lines based on tags."""
-
-    def add_html_line(out_format: str, match: re.Match) -> str:
-        """Add whitespace.
-
-        Do not add whitespace if the tag is in a non indent block.
-
-        Do not add whitespace if the tag is a in a template block
-        """
-        if inside_ignored_block(config, html, match):
-            return match.group(1)
-
-        if inside_template_block(config, html, match):
-            return match.group(1)
-
-        if out_format == "\n%s" and match.start() == 0:
-            return match.group(1)
-
-        return out_format % match.group(1)
-
-    html_tags = config.break_html_tags
-
-    add_left = partial(add_html_line, "\n%s")
-    add_right = partial(add_html_line, "%s\n")
-
-    break_char = config.break_before
-
-    # html tags - break before
-    html = re.sub(
-        re.compile(
-            rf"{break_char}\K(</?(?:{html_tags})\b(\"[^\"]*\"|'[^']*'|{{[^}}]*}}|[^'\">{{}}])*>)",
-            flags=re.IGNORECASE | re.VERBOSE,
-        ),
-        add_left,
-        html,
-    )
-
-    # html tags - break after
-    html = re.sub(
-        re.compile(
-            rf"(</?(?:{html_tags})\b(\"[^\"]*\"|'[^']*'|{{[^}}]*}}|[^'\">{{}}])*>)(?!\s*?\n)(?=[^\n])",
-            flags=re.IGNORECASE | re.VERBOSE,
-        ),
-        add_right,
-        html,
-    )
-
-    # template tag breaks
-    def should_i_move_template_tag(out_format: str, match: re.Match) -> str:
-        # ensure template tag is not inside an html tag and also not the first line of the file
-        if inside_ignored_block(config, html, match):
-            return match.group(1)
-
-        if not re.findall(
-            r"\<(?:" + str(config.indent_html_tags)
-            # added > as not allowed inside a "" or '' to prevent invalid wild html matches
-            # for issue #640
-            + r")\b(?:\"[^\">]*\"|'[^'>]*'|{{[^}]*}}|{%[^%]*%}|{\#[^\#]*\#}|[^>{}])*?"
-            + re.escape(match.group(1))
-            + "$",
-            html[: match.end()],
-            re.MULTILINE | re.VERBOSE,
-        ):
-            if out_format == "\n%s" and match.start() == 0:
-                return match.group(1)
-            return out_format % match.group(1)
-
-        return match.group(1)
-
-    # template tags
-    # break before
-    html = re.sub(
-        re.compile(
-            break_char
-            + r"\K((?:{%|{{\#)[ ]*?(?:"
-            + config.break_template_tags
-            + ")[^}]+?[%}]})",
-            flags=re.IGNORECASE | re.MULTILINE | re.VERBOSE,
-        ),
-        partial(should_i_move_template_tag, "\n%s"),
-        html,
-    )
-
-    # break after
-    html = re.sub(
-        re.compile(
-            r"((?:{%|{{\#)[ ]*?(?:"
-            + config.break_template_tags
-            + ")[^}]+?[%}]})(?=[^\n])",
-            flags=re.IGNORECASE | re.MULTILINE | re.VERBOSE,
-        ),
-        partial(should_i_move_template_tag, "%s\n"),
-        html,
-    )
-
-    return html