djlint 1.30.0 → 1.30.2

package/src/djlint/formatter/indent.py

@@ -1,418 +0,0 @@
-"""djLint add indentation to html."""
-
-from functools import partial
-
-import json5 as json
-import regex as re
-
-from ..helpers import (
-    inside_ignored_block,
-    is_ignored_block_closing,
-    is_ignored_block_opening,
-    is_safe_closing_tag,
-)
-from ..settings import Config
-from .attributes import format_attributes
-
-
-def indent_html(rawcode: str, config: Config) -> str:
-    """Indent raw code."""
-    if config.profile not in ["handlebars", "golang"]:
-        # we can try to fix template tags. ignore handlebars
-        # this should be done before indenting to line length
-        # calc is preserved.
-
-        def fix_tag_spacing(html: str, match: re.Match) -> str:
-            if inside_ignored_block(config, html, match):
-                return match.group()
-
-            return f"{match.group(1)} {match.group(2)} {match.group(3)}"
-
-        """
-        We should have tags like this:
-        {{ tag }}
-        {%- tag atrib -%}
-        """
-        func = partial(fix_tag_spacing, rawcode)
-
-        rawcode = re.sub(
-            r"({%-?\+?)[ ]*?(\w(?:(?!%}).)*?)[ ]*?(\+?-?%})", func, rawcode
-        )
-
-        rawcode = re.sub(r"({{)[ ]*?(\w(?:(?!}}).)*?)[ ]*?(\+?-?}})", func, rawcode)
-
-    elif config.profile == "handlebars":
-
-        def fix_handlebars_template_tags(html: str, match: re.Match) -> str:
-            if inside_ignored_block(config, html, match):
-                return match.group()
-
-            return f"{match.group(1)} {match.group(2)}"
-
-        func = partial(fix_handlebars_template_tags, rawcode)
-        # handlebars templates
-        rawcode = re.sub(r"({{#(?:each|if).+?[^ ])(}})", func, rawcode)
-
-    rawcode_flat_list = re.split("\n", rawcode)
-
-    indent = config.indent
-
-    beautified_code = ""
-    indent_level = 0
-    in_set_tag = False
-    is_raw_first_line = False
-    is_block_raw = False
-
-    slt_html = config.indent_html_tags
-
-    # here using all tags cause we allow empty tags on one line
-    always_self_closing_html = config.always_self_closing_html_tags
-
-    # here using all tags cause we allow empty tags on one line
-    slt_template = config.optional_single_line_template_tags
-
-    # nested ignored blocks..
-    ignored_level = 0
-
-    for item in rawcode_flat_list:
-        # if a raw tag first line
-        if not is_block_raw and is_ignored_block_opening(config, item):
-            is_raw_first_line = True
-
-        # if a raw tag then start ignoring
-        if is_ignored_block_opening(config, item):
-            is_block_raw = True
-            ignored_level += 1
-
-        if is_safe_closing_tag(config, item):
-            ignored_level -= 1
-            ignored_level = max(ignored_level, 0)
-            if is_block_raw is True and ignored_level == 0:
-                is_block_raw = False
-
-        if (
-            re.findall(
-                rf"^\s*?(?:{config.ignored_inline_blocks})",
-                item,
-                flags=re.IGNORECASE | re.VERBOSE | re.MULTILINE,
-            )
-            and is_block_raw is False
-        ):
-            tmp = (indent * indent_level) + item + "\n"
-
-        # if a one-line, inline tag, just process it, only if line starts w/ it
-        # or if it is trailing text
-
-        elif (
-            (
-                re.findall(
-                    re.compile(
-                        rf"""^(?:[^<\s].*?)? # start of a line, optionally with some text
-                    (?:
-                        (?:<({slt_html})>)(?:.*?)(?:</(?:\1)>) # <span>stuff</span> >>>> match 1
-                       |(?:<({slt_html})\b[^>]+?>)(?:.*?)(?:</(?:\2)>) # <span stuff>stuff</span> >>> match 2
-                       |(?:<(?:{always_self_closing_html})\b[^>]*?/?>) # <img stuff />
-                       |(?:<(?:{slt_html})\b[^>]*?/>) # <img />
-                       |(?:{{%[ ]*?({slt_template})[ ]+?.*?%}})(?:.*?)(?:{{%[ ]+?end(?:\3)[ ]+?.*?%}}) # >>> match 3
-                       |{config.ignored_inline_blocks}
-                    )[ \t]*?
-                    (?:
-                    .*? # anything
-                    (?: # followed by another slt
-                        (?:<({slt_html})>)(?:.*?)(?:</(?:\4)>) # <span>stuff</span> >>>> match 1
-                       |(?:<({slt_html})\b[^>]+?>)(?:.*?)(?:</(?:\5)>) # <span stuff>stuff</span> >>> match 2
-                       |(?:<(?:{always_self_closing_html})\b[^>]*?/?>) # <img stuff />
-                       |(?:<(?:{slt_html})\b[^>]*?/>) # <img />
-                       |(?:{{%[ ]*?({slt_template})[ ]+?.*?%}})(?:.*?)(?:{{%[ ]+?end(?:\6)[ ]+?.*?%}}) # >>> match 3
-                       |{config.ignored_inline_blocks}
-                    )[ \t]*?
-                    )*? # optional of course
-                    [^<]*?$ # with no other tags following until end of line
-                """,
-                        re.IGNORECASE | re.VERBOSE | re.MULTILINE,
-                    ),
-                    item,
-                )
-            )
-            and is_block_raw is False
-        ):
-            tmp = (indent * indent_level) + item + "\n"
-
-        # closing set tag
-        elif (
-            re.search(
-                re.compile(
-                    r"^(?!.*\{\%).*%\}.*$",
-                    re.IGNORECASE | re.MULTILINE | re.VERBOSE,
-                ),
-                item,
-            )
-            and is_block_raw is False
-            and in_set_tag is True
-        ):
-            indent_level = max(indent_level - 1, 0)
-            in_set_tag = False
-            tmp = (indent * indent_level) + item + "\n"
-
-        # closing curly brace inside a set tag
-        elif (
-            re.search(
-                re.compile(
-                    r"^[ ]*}|^[ ]*]",
-                    re.IGNORECASE | re.MULTILINE | re.VERBOSE,
-                ),
-                item,
-            )
-            and is_block_raw is False
-            and in_set_tag is True
-        ):
-            indent_level = max(indent_level - 1, 0)
-            tmp = (indent * indent_level) + item + "\n"
-
-        # if unindent, move left
-        elif (
-            re.search(
-                config.tag_unindent,
-                item,
-                re.IGNORECASE | re.MULTILINE | re.VERBOSE,
-            )
-            and is_block_raw is False
-            and not is_safe_closing_tag(config, item)
-            # and not ending in a slt like <span><strong></strong>.
-            and not re.findall(
-                rf"(<({slt_html})>)(.*?)(</(\2)>[^<]*?$)",
-                item,
-                re.IGNORECASE | re.VERBOSE | re.MULTILINE,
-            )
-            and not re.findall(
-                rf"(<({slt_html})\\b[^>]+?>)(.*?)(</(\2)>[^<]*?$)",
-                item,
-                re.IGNORECASE | re.VERBOSE | re.MULTILINE,
-            )
-        ):
-            # block to catch inline block followed by a non-break tag
-            if (
-                len(
-                    re.findall(
-                        rf"(^<({slt_html})>)(.*?)(</(\2)>)",
-                        item,
-                        re.IGNORECASE | re.VERBOSE | re.MULTILINE,
-                    )
-                    or re.findall(
-                        re.compile(
-                            rf"(^<({slt_html})\b[^>]+?>)(.*?)(</(\2)>)",
-                            re.IGNORECASE | re.VERBOSE | re.MULTILINE,
-                        ),
-                        item,
-                    )
-                )
-                > 0
-            ):
-                # unindent after instead of before
-                tmp = (indent * indent_level) + item + "\n"
-                indent_level = max(indent_level - 1, 0)
-            else:
-                indent_level = max(indent_level - 1, 0)
-                tmp = (indent * indent_level) + item + "\n"
-
-        elif (
-            re.search(
-                r"^" + str(config.tag_unindent_line),
-                item,
-                re.IGNORECASE | re.MULTILINE | re.VERBOSE,
-            )
-            and is_block_raw is False
-        ):
-            tmp = (indent * (indent_level - 1)) + item + "\n"
-
-        # if indent, move right
-
-        # opening set tag
-        elif (
-            re.search(
-                re.compile(
-                    r"^([ ]*{%[ ]*?set)(?!.*%}).*$",
-                    re.IGNORECASE | re.MULTILINE | re.VERBOSE,
-                ),
-                item,
-            )
-            and is_block_raw is False
-            and in_set_tag is False
-        ):
-            tmp = (indent * indent_level) + item + "\n"
-            indent_level = indent_level + 1
-            in_set_tag = True
-
-        # opening curly brace inside a set tag
-        elif (
-            re.search(
-                re.compile(
-                    r"(\{(?![^{}]*%[}\s])(?=[^{}]*$)|\[(?=[^\]]*$))",
-                    re.IGNORECASE | re.MULTILINE | re.VERBOSE,
-                ),
-                item,
-            )
-            and is_block_raw is False
-            and in_set_tag is True
-        ):
-            tmp = (indent * indent_level) + item + "\n"
-            indent_level = indent_level + 1
-
-        elif (
-            re.search(
-                re.compile(
-                    r"^(?:" + str(config.tag_indent) + r")",
-                    re.IGNORECASE | re.MULTILINE | re.VERBOSE,
-                ),
-                item,
-            )
-            and is_block_raw is False
-        ):
-            tmp = (indent * indent_level) + item + "\n"
-            indent_level = indent_level + 1
-
-        elif is_raw_first_line is True or (
-            is_safe_closing_tag(config, item) and is_block_raw is False
-        ):
-            tmp = (indent * indent_level) + item + "\n"
-
-        elif is_block_raw is True or not item.strip():
-            tmp = item + "\n"
-
-        # otherwise, just leave same level
-        elif not config.preserve_leading_space:
-            # if we are not trying to preserve indenting
-            # on text, the add it now.
-            tmp = (indent * indent_level) + item + "\n"
-        else:
-            tmp = item + "\n"
-
-        # if a opening raw tag then start ignoring.. only if there is no closing tag
-        # on the same line
-        if is_ignored_block_opening(config, item):
-            is_block_raw = True
-            is_raw_first_line = False
-
-        # if a normal tag, we can try to expand attributes
-        elif is_block_raw is False:
-            # get leading space, and attributes
-
-            func = partial(format_attributes, config, item)
-
-            tmp = re.sub(
-                re.compile(
-                    rf"(\s*?)(<(?:{config.indent_html_tags})\b)((?:\"[^\"]*\"|'[^']*'|{{[^}}]*}}|[^'\">{{}}\/])+?)(\s?/?>)",
-                    re.VERBOSE | re.IGNORECASE,
-                ),
-                func,
-                tmp,
-            )
-
-        # turn off raw block if we hit end - for one line raw blocks, but not an inline raw
-        if is_ignored_block_closing(config, item):
-            if not is_safe_closing_tag(config, item):
-                ignored_level -= 1
-                ignored_level = max(ignored_level, 0)
-            if ignored_level == 0:
-                is_block_raw = False
-
-        beautified_code = beautified_code + tmp
-
-    # try to fix internal formatting of set tag
-    def format_data(config: Config, contents: str, tag_size: int, leading_space) -> str:
-        try:
-            # try to format the contents as json
-            data = json.loads(contents)
-            contents = json.dumps(data, trailing_commas=False, ensure_ascii=False)
-
-            if tag_size + len(contents) >= config.max_line_length:
-                # if the line is too long we can indent the json
-                contents = json.dumps(
-                    data,
-                    indent=config.indent_size,
-                    trailing_commas=False,
-                    ensure_ascii=False,
-                )
-
-        except:
-            # was not json.. try to eval as set
-            try:
-                evaluated = str(eval(contents))
-                # need to unwrap the eval
-                contents = (
-                    evaluated[1:-1]
-                    if contents[:1] != "(" and evaluated[:1] == "("
-                    else evaluated
-                )
-            except:
-                contents = contents.strip()
-
-        return (f"\n{leading_space}").join(contents.splitlines())
-
-    def format_set(config: Config, html: str, match: re.Match) -> str:
-        if inside_ignored_block(config, html, match):
-            return match.group()
-
-        leading_space = match.group(1)
-        open_bracket = match.group(2)
-        tag = match.group(3)
-        close_bracket = match.group(5)
-        contents = match.group(4).strip()
-        contents_split = contents.split("=", 1)
-
-        if len(contents_split) > 1:
-            contents = (
-                contents_split[0].strip()
-                + " = "
-                + format_data(
-                    config,
-                    contents_split[-1],
-                    len(f"{open_bracket} {tag}  {close_bracket}"),
-                    leading_space,
-                )
-            )
-
-        return f"{leading_space}{open_bracket} {tag} {contents} {close_bracket}"
-
-    def format_function(config: Config, html: str, match: re.Match) -> str:
-        if inside_ignored_block(config, html, match):
-            return match.group()
-        leading_space = match.group(1)
-        open_bracket = match.group(2)
-        tag = match.group(3).strip()
-        close_bracket = match.group(5)
-        contents = format_data(
-            config,
-            match.group(4).strip()[1:-1],
-            len(f"{open_bracket} {tag}() {close_bracket}"),
-            leading_space,
-        )
-
-        return f"{leading_space}{open_bracket} {tag}({contents}) {close_bracket}"
-
-    func = partial(format_set, config, beautified_code)
-    # format set contents
-    beautified_code = re.sub(
-        re.compile(
-            r"([ ]*)({%-?)[ ]*(set)[ ]+?((?:(?!%}).)*?)(-?%})",
-            flags=re.IGNORECASE | re.MULTILINE | re.VERBOSE | re.DOTALL,
-        ),
-        func,
-        beautified_code,
-    )
-
-    func = partial(format_function, config, beautified_code)
-    # format function contents
-    beautified_code = re.sub(
-        re.compile(
-            r"([ ]*)({{-?\+?)[ ]*?((?:(?!}}).)*?\w)(\([^\)]*?\)[ ]*)((?:(?!}}).)*?-?\+?}})",
-            flags=re.IGNORECASE | re.MULTILINE | re.VERBOSE | re.DOTALL,
-        ),
-        func,
-        beautified_code,
-    )
-
-    if not config.preserve_blank_lines:
-        beautified_code = beautified_code.lstrip()
-
-    return beautified_code.rstrip() + "\n"

package/src/djlint/formatter/js.py

@@ -1,58 +0,0 @@
-"""djLint function to call jsbeautifier."""
-from functools import partial
-
-import jsbeautifier
-import regex as re
-from jsbeautifier.javascript.options import BeautifierOptions
-
-from ..helpers import child_of_unformatted_block
-from ..settings import Config
-
-
-def format_js(html: str, config: Config) -> str:
-    """Format javascript inside <script> 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.js_config["indent_level"] = 1
-        opts = BeautifierOptions(config.js_config)
-        beautified_lines = jsbeautifier.beautify(match.group(3), opts).splitlines()
-
-        config.js_config["indent_level"] = 2
-        opts = BeautifierOptions(config.js_config)
-        beautified_lines_test = jsbeautifier.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"([ ]*?)(<(?:script)\b(?:\"[^\"]*\"|'[^']*'|{[^}]*}|[^'\">{}])*>)(.*?)(?=</script>)",
-            re.IGNORECASE | re.DOTALL,
-        ),
-        func,
-        html,
-    )