From 4973a32466cf945f67bac5d8da2649fd41eff6f4 Mon Sep 17 00:00:00 2001
From: Timo Ludwig <ti.ludwig@web.de>
Date: Mon, 8 May 2023 23:04:31 +0200
Subject: [PATCH 1/2] feat(formatter): Add option to not condense
 multi-line-tags

---
 docs/src/_data/configuration.json             | 23 +++++
 src/djlint/__init__.py                        |  7 ++
 src/djlint/formatter/condense.py              | 13 ++-
 src/djlint/formatter/expand.py                |  2 +-
 src/djlint/settings.py                        |  7 ++
 .../test_line_break_after_multiline_tag.py    | 95 +++++++++++++++++++
 6 files changed, 142 insertions(+), 5 deletions(-)
 create mode 100644 tests/test_html/test_line_break_after_multiline_tag.py

diff --git a/docs/src/_data/configuration.json b/docs/src/_data/configuration.json
index 28e5f55b2..aac12ed9f 100644
--- a/docs/src/_data/configuration.json
+++ b/docs/src/_data/configuration.json
@@ -252,6 +252,29 @@
       }
     ]
   },
+  {
+    "name": "line_break_after_multiline_tag",
+    "tags": ["formatter"],
+    "description": {
+      "en": "Do not condense the content of multi-line tags into the line of the last attribute.",
+      "ru": "Не сжимайте содержимое многострочных тегов в строку последнего атрибута.",
+      "fr": "Ne pas condenser le contenu des balises multilignes dans la ligne du dernier attribut."
+    },
+    "usage": [
+      {
+        "name": "pyproject.toml",
+        "value": "line_break_after_multiline_tag=true"
+      },
+      {
+        "name": ".djlintrc",
+        "value": "\"line_break_after_multiline_tag\": \"true\""
+      },
+      {
+        "name": "cli",
+        "value": "--line-break-after-multiline-tag"
+      }
+    ]
+  },
   {
     "name": "profile",
     "tags": ["linter", "formatter"],
diff --git a/src/djlint/__init__.py b/src/djlint/__init__.py
index e25c946c9..88021a508 100644
--- a/src/djlint/__init__.py
+++ b/src/djlint/__init__.py
@@ -157,6 +157,11 @@
     default="",
     help="Add an additional blank line before {% <tag> ... %} tag groups.",
 )
+@click.option(
+    "--line-break-after-multiline-tag",
+    is_flag=True,
+    help="Do not condense the content of multi-line tags into the line of the last attribute.",
+)
 @click.option(
     "--custom-blocks",
     type=str,
@@ -247,6 +252,7 @@ def main(
     ignore_blocks: str,
     blank_line_after_tag: str,
     blank_line_before_tag: str,
+    line_break_after_multiline_tag: bool,
     custom_blocks: str,
     custom_html: str,
     exclude: str,
@@ -284,6 +290,7 @@ def main(
         ignore_blocks=ignore_blocks,
         blank_line_after_tag=blank_line_after_tag,
         blank_line_before_tag=blank_line_before_tag,
+        line_break_after_multiline_tag=line_break_after_multiline_tag,
         custom_blocks=custom_blocks,
         custom_html=custom_html,
         exclude=exclude,
diff --git a/src/djlint/formatter/condense.py b/src/djlint/formatter/condense.py
index 77de4d262..c81aa6269 100644
--- a/src/djlint/formatter/condense.py
+++ b/src/djlint/formatter/condense.py
@@ -134,12 +134,17 @@ def condense_html(html, config):
 
     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 (
-                len(match.group(1).splitlines()[-1] + match.group(3) + match.group(4))
-                < config.max_line_length
-            )
+            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))
         ):
diff --git a/src/djlint/formatter/expand.py b/src/djlint/formatter/expand.py
index d661dcfcd..f435143f3 100644
--- a/src/djlint/formatter/expand.py
+++ b/src/djlint/formatter/expand.py
@@ -20,7 +20,7 @@ def add_html_line(out_format: str, match: re.Match) -> str:
 
         Do not add whitespace if the tag is in a non indent block.
 
-        Do not add whiatespace if the tag is a in a template 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)
diff --git a/src/djlint/settings.py b/src/djlint/settings.py
index 2c6f8a680..73756c7f5 100644
--- a/src/djlint/settings.py
+++ b/src/djlint/settings.py
@@ -237,6 +237,7 @@ def __init__(
         custom_blocks: str = "",
         blank_line_after_tag: str = "",
         blank_line_before_tag: str = "",
+        line_break_after_multiline_tag: bool = False,
         custom_html: str = "",
         exclude: str = "",
         extend_exclude: str = "",
@@ -430,6 +431,12 @@ def __init__(
             str
         ] = blank_line_before_tag or djlint_settings.get("blank_line_before_tag", None)
 
+        # add line break after multi-line tags
+        self.line_break_after_multiline_tag: bool = (
+            line_break_after_multiline_tag
+            or djlint_settings.get("line_break_after_multiline_tag", False)
+        )
+
         # contents of tags will not be formatted
         self.ignored_block_opening: str = r"""
               <style
diff --git a/tests/test_html/test_line_break_after_multiline_tag.py b/tests/test_html/test_line_break_after_multiline_tag.py
new file mode 100644
index 000000000..a2950de10
--- /dev/null
+++ b/tests/test_html/test_line_break_after_multiline_tag.py
@@ -0,0 +1,95 @@
+"""Tests html details/summary tag.
+
+poetry run pytest tests/test_html/test_tag_details_summary.py
+"""
+import pytest
+
+from src.djlint.reformat import formatter
+from tests.conftest import config_builder, printer
+
+test_data = [
+    pytest.param(
+        (
+            '<div attribute="value" attributea="value" attributeb="value" attributec="value" attributed="value" attributef="value">string</div>\n'
+        ),
+        (
+            '<div attribute="value"\n'
+            '     attributea="value"\n'
+            '     attributeb="value"\n'
+            '     attributec="value"\n'
+            '     attributed="value"\n'
+            '     attributef="value">string</div>\n'
+        ),
+        ({}),
+        id="no_line_break_after_multiline_tag",
+    ),
+    pytest.param(
+        (
+            '<div attribute="value"\n'
+            '     attributea="value"\n'
+            '     attributeb="value"\n'
+            '     attributec="value"\n'
+            '     attributed="value"\n'
+            '     attributef="value">\n'
+            "    string\n"
+            "</div>\n"
+        ),
+        (
+            '<div attribute="value"\n'
+            '     attributea="value"\n'
+            '     attributeb="value"\n'
+            '     attributec="value"\n'
+            '     attributed="value"\n'
+            '     attributef="value">string</div>\n'
+        ),
+        ({}),
+        id="no_line_break_after_multiline_tag_when_already_split",
+    ),
+    pytest.param(
+        (
+            '<div attribute="value" attributea="value" attributeb="value" attributec="value" attributed="value" attributef="value">string</div>\n'
+        ),
+        (
+            '<div attribute="value"\n'
+            '     attributea="value"\n'
+            '     attributeb="value"\n'
+            '     attributec="value"\n'
+            '     attributed="value"\n'
+            '     attributef="value">\n'
+            "    string\n"
+            "</div>\n"
+        ),
+        ({"line_break_after_multiline_tag": True}),
+        id="line_break_after_multiline_tag",
+    ),
+    pytest.param(
+        (
+            '<div attribute="value"\n'
+            '     attributea="value"\n'
+            '     attributeb="value"\n'
+            '     attributec="value"\n'
+            '     attributed="value"\n'
+            '     attributef="value">string</div>\n'
+        ),
+        (
+            '<div attribute="value"\n'
+            '     attributea="value"\n'
+            '     attributeb="value"\n'
+            '     attributec="value"\n'
+            '     attributed="value"\n'
+            '     attributef="value">\n'
+            "    string\n"
+            "</div>\n"
+        ),
+        ({"line_break_after_multiline_tag": True}),
+        id="line_break_after_multiline_tag_when_already_condensed",
+    ),
+]
+
+
+@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

From 66c9187f585b1692a2fb4cdc23d9788aa48606b1 Mon Sep 17 00:00:00 2001
From: Christopher Pickering <christopher@going.bg>
Date: Tue, 9 May 2023 08:25:00 -0500
Subject: [PATCH 2/2] fix(linter): fixed overly greedy H037, improved linter
 tests

closes #631
---
 src/djlint/rules.yaml                     |   2 +-
 tests/conftest.py                         |  55 ++-
 tests/test_linter/test_django_linter.py   | 411 ++++++++++++++++------
 tests/test_linter/test_h037.py            |  65 ++++
 tests/test_linter/test_jinja_linter.py    | 195 +++++-----
 tests/test_linter/test_linter.py          |  14 -
 tests/test_linter/test_nunjucks_linter.py |  90 ++---
 7 files changed, 526 insertions(+), 306 deletions(-)
 create mode 100644 tests/test_linter/test_h037.py

diff --git a/src/djlint/rules.yaml b/src/djlint/rules.yaml
index ad12c3cf8..790356596 100644
--- a/src/djlint/rules.yaml
+++ b/src/djlint/rules.yaml
@@ -276,4 +276,4 @@
     message: Duplicate attribute found.
     flags: re.I
     patterns:
-    - <\w[^>]*?\s([a-z][a-z-]*?)(?==.+?\1=[^>]*?>)
+    - <\w[^>]*?\s\K([a-z][a-z-]*?)(?==[^>]+?\1=[^>]*?>)
diff --git a/tests/conftest.py b/tests/conftest.py
index 871a35bab..e212a65c6 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -134,24 +134,17 @@ def printer(expected, source, actual):
         print(f"{ color.get(diff[:1], Style.RESET_ALL)}{diff}{Style.RESET_ALL}")
 
 
-def lint_printer(source, expected, excluded, actual):
+def lint_printer(source, expected, actual):
     width, _ = shutil.get_terminal_size()
 
     expected_text = "Expected Rules"
-    excluded_text = "Excluded Rules"
     actual_text = "Actual"
     source_text = "Source"
 
     expected_width = int((width - len(expected_text) - 2) / 2)
-    excluded_width = int((width - len(excluded_text) - 2) / 2)
     actual_width = int((width - len(actual_text) - 2) / 2)
     source_width = int((width - len(source_text) - 2) / 2)
 
-    def padder(value, width):
-        if len(value) < width:
-            return str(value) + " " * (width - len(value))
-        return value[:20]
-
     print()
     print(
         f"{Fore.BLUE}{Style.BRIGHT}{'─' * source_width} {source_text} {'─' * source_width}{Style.RESET_ALL}"
@@ -160,42 +153,34 @@ def padder(value, width):
     print(source)
     print()
 
-    if expected != ():
-        print(
-            f"{Fore.BLUE}{Style.BRIGHT}{'─' * expected_width} {expected_text} {'─' * expected_width}{Style.RESET_ALL}"
-        )
-        print()
-        for x in expected:
-            if isinstance(x, tuple):
-                print(f"{x[0]}, line #{x[1]}")
-            else:
-                print(x)
-        print()
-    if excluded != ():
+    print(
+        f"{Fore.BLUE}{Style.BRIGHT}{'─' * expected_width} {expected_text} {'─' * expected_width}{Style.RESET_ALL}"
+    )
+    print()
+    for x in expected:
         print(
-            f"{Fore.BLUE}{Style.BRIGHT}{'─' * excluded_width} {excluded_text} {'─' * excluded_width}{Style.RESET_ALL}"
+            f"{Fore.RED}{Style.BRIGHT}{x['code']}{Style.RESET_ALL} {x['line']} {x['match']}"
         )
+        print(f'     {x["message"]}')
         print()
-        for x in excluded:
-            if isinstance(x, tuple):
-                print(f"{x[0]}, line #{x[1]}")
-            else:
-                print(x)
-        print()
+
     print(
         f"{Fore.BLUE}{Style.BRIGHT}{'─' * actual_width} {actual_text} {'─' * actual_width}{Style.RESET_ALL}"
     )
     print()
 
-    if actual:
-        max_code = max(len(x["code"]) for x in actual)
-        max_line = max(len(x["line"]) for x in actual)
-        max_match = min(max(len(x["match"]) for x in actual), 20)
-        for x in actual:
-            print(
-                f'{padder(x["code"],max_code)} {padder(x["line"], max_line)} {padder(x["match"],max_match)} >> {x["message"]}'
-            )
+    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()
 
 
diff --git a/tests/test_linter/test_django_linter.py b/tests/test_linter/test_django_linter.py
index 65146d8ca..ce083a1bf 100644
--- a/tests/test_linter/test_django_linter.py
+++ b/tests/test_linter/test_django_linter.py
@@ -1,22 +1,8 @@
-"""Djlint linter rule tests.
-
-run::
-
-   pytest tests/test_linter.py --cov=src/djlint --cov-branch \
-          --cov-report xml:coverage.xml --cov-report term-missing
-
-   # for a single test
-
-   pytest tests/test_linter/test_linter.py::test_random
-
-Test setup
-
-(html, (list of codes that should file, plus optional line number))
+"""Djlint linter rule tests for django.
 
+poetry run pytest tests/test_linter/test_django_linter.py
 
 """
-# pylint: disable=C0116,C0103,C0302
-
 
 import pytest
 
@@ -26,54 +12,117 @@
 test_data = [
     pytest.param(
         ("{{test }}\n{% test%}<a>"),
-        ([("T001", 1), ("T001", 2)]),
-        (),
+        (
+            [
+                {
+                    "code": "T001",
+                    "line": "1:0",
+                    "match": "{{test",
+                    "message": "Variables should be wrapped in a single whitespace.",
+                },
+                {
+                    "code": "T001",
+                    "line": "2:3",
+                    "match": "test%}",
+                    "message": "Variables should be wrapped in a single whitespace.",
+                },
+                {
+                    "code": "H025",
+                    "line": "2:9",
+                    "match": "<a>",
+                    "message": "Tag seems to be an orphan.",
+                },
+            ]
+        ),
         id="T001",
     ),
     pytest.param(
         ("{% extends 'this' %}"),
         (
             [
-                ("T002", 1),
+                {
+                    "code": "T002",
+                    "line": "1:0",
+                    "match": "{% extends 'this' %}",
+                    "message": "Double quotes should be used in tags.",
+                }
             ]
         ),
-        (),
         id="T002",
     ),
     pytest.param(
         ("{% extends this %}"),
-        (),
-        (["T002"]),
+        ([]),
         id="T002_unquoted_var_names",
     ),
     pytest.param(
         ("{% with a='this' %}"),
-        (["T002"]),
-        (),
+        (
+            [
+                {
+                    "code": "T002",
+                    "line": "1:0",
+                    "match": "{% with a='this' %}",
+                    "message": "Double quotes should be used in tags.",
+                }
+            ]
+        ),
         id="T002_with",
     ),
     pytest.param(
         ("{% trans 'this' %}"),
-        (["T002"]),
-        (),
+        (
+            [
+                {
+                    "code": "T002",
+                    "line": "1:0",
+                    "match": "{% trans 'this' %}",
+                    "message": "Double quotes should be used in tags.",
+                }
+            ]
+        ),
         id="T002_trans",
     ),
     pytest.param(
         ("{% translate 'this' %}"),
-        (["T002"]),
-        (),
+        (
+            [
+                {
+                    "code": "T002",
+                    "line": "1:0",
+                    "match": "{% translate 'this' ",
+                    "message": "Double quotes should be used in tags.",
+                }
+            ]
+        ),
         id="T002_translate",
     ),
     pytest.param(
         ("{% include 'this' %}"),
-        (["T002"]),
-        (),
+        (
+            [
+                {
+                    "code": "T002",
+                    "line": "1:0",
+                    "match": "{% include 'this' %}",
+                    "message": "Double quotes should be used in tags.",
+                }
+            ]
+        ),
         id="T002_include",
     ),
     pytest.param(
         ("{% now 'Y-m-d G:i:s' %}"),
-        (["T002"]),
-        (),
+        (
+            [
+                {
+                    "code": "T002",
+                    "line": "1:0",
+                    "match": "{% now 'Y-m-d G:i:s'",
+                    "message": "Double quotes should be used in tags.",
+                }
+            ]
+        ),
         id="T002_now",
     ),
     pytest.param(
@@ -83,14 +132,21 @@
             '{% include "template.html" %}\n'
             "<div {% fpr %} data-{{ name }}='{{ value }}'{% endfor %}/>"
         ),
-        (),
-        (["T002"]),
+        (
+            [
+                {
+                    "code": "H025",
+                    "line": "2:0",
+                    "match": '<div class="card" da',
+                    "message": "Tag seems to be an orphan.",
+                }
+            ]
+        ),
         id="T002_test_greedy_regex",
     ),
     pytest.param(
         ("{% if form.action_url %}\n" "   ='stuff'\n" " {% endif %}"),
-        (),
-        (["T002"]),
+        ([]),
         id="T002_test_greedy_regex_2",
     ),
     pytest.param(
@@ -98,20 +154,44 @@
             '{% include "template.html" %}\n'
             " {% include \"template.html\" with type='mono' %}"
         ),
-        ([("T002", 2)]),
-        (),
+        (
+            [
+                {
+                    "code": "T002",
+                    "line": "2:1",
+                    "match": '{% include "template',
+                    "message": "Double quotes should be used in tags.",
+                }
+            ]
+        ),
         id="T002_test_line_num",
     ),
     pytest.param(
         ("{% endblock %}"),
-        ([("T003", 1)]),
-        (),
+        (
+            [
+                {
+                    "code": "T003",
+                    "line": "1:0",
+                    "match": "{% endblock %}",
+                    "message": "Endblock should have name. Ex: {% endblock body %}.",
+                }
+            ]
+        ),
         id="T003",
     ),
     pytest.param(
         ('<link src="/static/there">'),
-        ([("D004", 1)]),
-        (),
+        (
+            [
+                {
+                    "code": "D004",
+                    "line": "1:0",
+                    "match": '<link src="/static/',
+                    "message": "(Django) Static urls should follow {% static path/to/file %} pattern.",
+                }
+            ]
+        ),
         id="DJ004",
     ),
     pytest.param(
@@ -119,14 +199,42 @@
             '<a href="/Collections?handler=RemoveAgreement&id=@a.Id">\n'
             '<form action="/Collections"></form></a>'
         ),
-        ([("D018", 1), ("D018", 2)]),
-        (),
+        (
+            [
+                {
+                    "code": "D018",
+                    "line": "1:0",
+                    "match": '<a href="/Collection',
+                    "message": "(Django) Internal links should use the {% url ... %} pattern.",
+                },
+                {
+                    "code": "D018",
+                    "line": "2:0",
+                    "match": '<form action="/Colle',
+                    "message": "(Django) Internal links should use the {% url ... %} pattern.",
+                },
+            ]
+        ),
         id="DJ018",
     ),
     pytest.param(
         ('<a href="javascript:abc()">\n' '<form action="javascript:abc()"></form></a>'),
-        (),
-        ([("D018", 1), ("D018", 2)]),
+        (
+            [
+                {
+                    "code": "H019",
+                    "line": "1:0",
+                    "match": '<a href="javascript:',
+                    "message": "Replace 'javascript:abc()' with on_ event and real url.",
+                },
+                {
+                    "code": "H019",
+                    "line": "2:0",
+                    "match": '<form action="javasc',
+                    "message": "Replace 'javascript:abc()' with on_ event and real url.",
+                },
+            ]
+        ),
         id="DJ018_no_match",
     ),
     pytest.param(
@@ -134,169 +242,244 @@
             '<a href="#">\n<form action="#"><a href="#tab">\n'
             '<form action="#go"></form></a></form></a>'
         ),
-        (),
-        ([("D018", 1), ("D018", 2)]),
+        ([]),
         id="DJ018_has_urls",
     ),
     pytest.param(
         ('<div class="em-ajaxLogs" data-src="/table/task/{{ t.id }}/log"></div>'),
-        ([("D018", 1)]),
-        (),
+        (
+            [
+                {
+                    "code": "D018",
+                    "line": "1:0",
+                    "match": '<div class="em-ajaxL',
+                    "message": "(Django) Internal links should use the {% url ... %} pattern.",
+                }
+            ]
+        ),
         id="DJ018_data_src",
     ),
     pytest.param(
         ('<a href="mailto:joe"></a><a href="tel:joe"></a>'),
-        (),
-        (["D018"]),
+        ([]),
         id="DJ018_mailto",
     ),
     pytest.param(
         ('<a href="data:,Hello%2C%20World%21"></a>'),
-        (),
-        (["D018"]),
+        ([]),
         id="DJ018_data",
     ),
     pytest.param(
         ('<div data-row-selection-action="highlight"></div>'),
-        (),
-        (["D018"]),
+        ([]),
         id="DJ018_attribute_names",
     ),
     pytest.param(
         ('<form action="{% url \'something\' %}" data-action="xxx"></form>'),
-        (),
-        (["D018"]),
+        (
+            [
+                {
+                    "code": "H037",
+                    "line": "1:6",
+                    "match": "action",
+                    "message": "Duplicate attribute found.",
+                }
+            ]
+        ),
         id="DJ018_data_action",
     ),
     pytest.param(
         ("{% blah 'asdf %}"),
-        (["T027"]),
-        (),
+        (
+            [
+                {
+                    "code": "T027",
+                    "line": "1:0",
+                    "match": "{% blah 'asdf %}",
+                    "message": "Unclosed string found in template syntax.",
+                }
+            ]
+        ),
         id="T027",
     ),
     pytest.param(
         ("{% blah 'asdf' %}{{ blah \"asdf\" }}"),
-        (),
-        (["T027"]),
+        ([]),
         id="T027_no",
     ),
     pytest.param(
         ("{% blah 'asdf' 'blah %}"),
-        (["T027"]),
-        (),
+        (
+            [
+                {
+                    "code": "T027",
+                    "line": "1:0",
+                    "match": "{% blah 'asdf' 'blah",
+                    "message": "Unclosed string found in template syntax.",
+                }
+            ]
+        ),
         id="T027_long_name",
     ),
     pytest.param(
         ('{% trans "Check box if you\'re interested in this location." %}'),
-        (),
-        (["T027"]),
+        ([]),
         id="T027_trans",
     ),
     pytest.param(
         (
             "{% macro rendersubmit(buttons=[], class=\"\", index='', url='', that=\"\" , test='') -%}"
         ),
-        (),
-        (["T027"]),
+        ([]),
         id="T027_mixed_quotes",
     ),
     pytest.param(
         ("<a href=\"{{ blah 'asdf' -}}\">"),
-        (),
-        (["T028"]),
+        (
+            [
+                {
+                    "code": "H025",
+                    "line": "1:0",
+                    "match": "<a href=\"{{ blah 'as",
+                    "message": "Tag seems to be an orphan.",
+                }
+            ]
+        ),
         id="T028_no",
     ),
     pytest.param(
         ("<a {{ blah 'asdf' }}>"),
-        (),
-        (["T028"]),
+        (
+            [
+                {
+                    "code": "H025",
+                    "line": "1:0",
+                    "match": "<a {{ blah 'asdf' }}",
+                    "message": "Tag seems to be an orphan.",
+                }
+            ]
+        ),
         id="T028_no_2",
     ),
     pytest.param(
         ("<a {% blah 'asdf' %}>"),
-        (),
-        (["T028"]),
+        (
+            [
+                {
+                    "code": "H025",
+                    "line": "1:0",
+                    "match": "<a {% blah 'asdf' %}",
+                    "message": "Tag seems to be an orphan.",
+                }
+            ]
+        ),
         id="T028_no_3",
     ),
     pytest.param(
         ("{% blah 'asdf' %}"),
-        (),
-        (["T028"]),
+        ([]),
         id="T028_no_5",
     ),
     pytest.param(
         ("{% for 'asdf' %}"),
-        (),
-        (["T028"]),
+        ([]),
         id="T028_no_6",
     ),
     pytest.param(
         ('<input class="{% if %}{% endif %}" />'),
-        (),
-        (["T028"]),
+        ([]),
         id="T028_no_7",
     ),
     pytest.param(
         ("{% static ''  \"  \"  'foo/bar.min.css' %}"),
-        (["T032"]),
-        (),
+        (
+            [
+                {
+                    "code": "T032",
+                    "line": "1:0",
+                    "match": "{% static ''",
+                    "message": "Extra whitespace found in template tags.",
+                }
+            ]
+        ),
         id="T032",
     ),
     pytest.param(
         ("{% static  ''  %}"),
-        (["T032"]),
-        (),
+        (
+            [
+                {
+                    "code": "T001",
+                    "line": "1:12",
+                    "match": "'  %}",
+                    "message": "Variables should be wrapped in a single whitespace.",
+                },
+                {
+                    "code": "T032",
+                    "line": "1:0",
+                    "match": "{% static",
+                    "message": "Extra whitespace found in template tags.",
+                },
+            ]
+        ),
         id="T032_2",
     ),
     pytest.param(
         ("{% static '' \"     \" 'foo/bar.min.css' %}"),
-        (),
-        (["T032"]),
+        ([]),
         id="T032_no",
     ),
     pytest.param(
         ("{{ static ''  \"  \"  'foo/bar.min.css' }}"),
-        (["T032"]),
-        (),
+        (
+            [
+                {
+                    "code": "T032",
+                    "line": "1:0",
+                    "match": "{{ static ''",
+                    "message": "Extra whitespace found in template tags.",
+                }
+            ]
+        ),
         id="T032_3",
     ),
     pytest.param(
         ("{{ static  ''  }}"),
-        (["T032"]),
-        (),
+        (
+            [
+                {
+                    "code": "T001",
+                    "line": "1:12",
+                    "match": "'  }}",
+                    "message": "Variables should be wrapped in a single whitespace.",
+                },
+                {
+                    "code": "T032",
+                    "line": "1:0",
+                    "match": "{{ static",
+                    "message": "Extra whitespace found in template tags.",
+                },
+            ]
+        ),
         id="T032_4",
     ),
     pytest.param(
         ("{{ static '' \"     \" 'foo/bar.min.css' }}"),
-        (),
-        (["T032"]),
+        ([]),
         id="T032_no_2",
     ),
 ]
 
 
-@pytest.mark.parametrize(("source", "expected", "excluded"), test_data)
-def test_django_linter(source, expected, excluded, django_config) -> None:
-    filename = "file"
-    filepath = filename
-    lint = linter(django_config, source, filename, filepath)[filename]
-
-    lint_printer(source, expected, excluded, lint)
+@pytest.mark.parametrize(("source", "expected"), test_data)
+def test_base(source, expected, django_config):
+    filename = "test.html"
+    output = linter(django_config, source, filename, filename)
 
-    def check_rule(rule, lint):
-        if isinstance(rule, tuple):
-            return (
-                any(
-                    x["code"] == rule[0] and int(x["line"].split(":")[0]) == rule[1]
-                    for x in lint
-                )
-                is True
-            )
-        else:
-            return any(x["code"] == rule for x in lint) is True
+    lint_printer(source, expected, output[filename])
 
-    for rule in expected:
-        assert check_rule(rule, lint) is True
+    mismatch = list(filter(lambda x: x not in expected, output[filename])) + list(
+        filter(lambda x: x not in output[filename], expected)
+    )
 
-    for rule in excluded:
-        assert check_rule(rule, lint) is False
+    assert len(mismatch) == 0
diff --git a/tests/test_linter/test_h037.py b/tests/test_linter/test_h037.py
new file mode 100644
index 000000000..c6ae2db79
--- /dev/null
+++ b/tests/test_linter/test_h037.py
@@ -0,0 +1,65 @@
+"""Test twig comment tags.
+
+poetry run pytest tests/test_linter/test_h037.py
+"""
+import pytest
+
+from src.djlint.lint import linter
+from tests.conftest import lint_printer
+
+test_data = [
+    pytest.param(
+        ('<br class="a" id="asdf" class="b" />'),
+        (
+            [
+                {
+                    "code": "H037",
+                    "line": "1:4",
+                    "match": "class",
+                    "message": "Duplicate attribute found.",
+                }
+            ]
+        ),
+        id="one",
+    ),
+    pytest.param(
+        ('<div data-class="a" id="asdf" data-class="b"></div>'),
+        (
+            [
+                {
+                    "code": "H037",
+                    "line": "1:5",
+                    "match": "data-class",
+                    "message": "Duplicate attribute found.",
+                }
+            ]
+        ),
+        id="two",
+    ),
+    pytest.param(
+        ('<div data-class="a" data=asdf class="b"></div>'),
+        ([]),
+        id="mismatch names",
+    ),
+    pytest.param(
+        (
+            '<a href="" ></a><a href=""></a><a href=""></a><a href=""></a><a href=""></a><a href=""></a>'
+        ),
+        ([]),
+        id="repeating tags",
+    ),
+]
+
+
+@pytest.mark.parametrize(("source", "expected"), test_data)
+def test_base(source, expected, nunjucks_config):
+    filename = "test.html"
+    output = linter(nunjucks_config, source, filename, filename)
+
+    lint_printer(source, expected, output[filename])
+
+    mismatch = list(filter(lambda x: x not in expected, output[filename])) + list(
+        filter(lambda x: x not in output[filename], expected)
+    )
+
+    assert len(mismatch) == 0
diff --git a/tests/test_linter/test_jinja_linter.py b/tests/test_linter/test_jinja_linter.py
index 9b6842dd0..96e57a1dc 100644
--- a/tests/test_linter/test_jinja_linter.py
+++ b/tests/test_linter/test_jinja_linter.py
@@ -1,22 +1,8 @@
-"""Djlint linter rule tests.
-
-run::
-
-   pytest tests/test_linter.py --cov=src/djlint --cov-branch \
-          --cov-report xml:coverage.xml --cov-report term-missing
-
-   # for a single test
-
-   pytest tests/test_linter/test_linter.py::test_random
-
-Test setup
-
-(html, (list of codes that should file, plus optional line number))
+"""Djlint linter tests for jinja.
 
+poetry run pytest tests/test_linter/test_jinja_linter.py
 
 """
-# pylint: disable=C0116,C0103,C0302
-
 
 import pytest
 
@@ -26,108 +12,157 @@
 test_data = [
     pytest.param(
         ("{#-test -#}"),
-        (),
-        (["T001"]),
+        ([]),
         id="T001",
     ),
     pytest.param(
         ("{#- test -#}"),
-        (),
-        (["T001"]),
+        ([]),
         id="T001_2",
     ),
     pytest.param(
         ("<div>\n" "     {%\n" '         ("something", "1"),\n' "     %}\n" " </div>"),
-        (),
-        (["T001"]),
+        ([]),
         id="T001_3",
     ),
     pytest.param(
         ("{{- foo }}{{+ bar }}{{ biz -}}{{ baz +}}"),
-        (),
-        (["T001"]),
+        ([]),
         id="T001_4",
     ),
     pytest.param(
         ('<link src="/static/there">'),
-        ([("J004", 1)]),
-        (),
+        (
+            [
+                {
+                    "code": "J004",
+                    "line": "1:0",
+                    "match": '<link src="/static/',
+                    "message": "(Jinja) Static urls should follow {{ url_for('static'..) }} pattern.",
+                }
+            ]
+        ),
         id="J004",
     ),
     pytest.param(
         (
             '<a href="/Collections?handler=RemoveAgreement&id=@a.Id">\n<form action="/Collections"></form></a>'
         ),
-        ([("J018", 1), ("J018", 2)]),
-        (),
+        (
+            [
+                {
+                    "code": "J018",
+                    "line": "1:0",
+                    "match": '<a href="/Collection',
+                    "message": "(Jinja) Internal links should use the {{ url_for() ... }} pattern.",
+                },
+                {
+                    "code": "J018",
+                    "line": "2:0",
+                    "match": '<form action="/Colle',
+                    "message": "(Jinja) Internal links should use the {{ url_for() ... }} pattern.",
+                },
+            ]
+        ),
         id="J018",
     ),
     pytest.param(
         ('<a href="javascript:abc()">\n<form action="javascript:abc()"></form></a>'),
-        (),
-        ([("J018", 1), ("J018", 2)]),
+        (
+            [
+                {
+                    "code": "H019",
+                    "line": "1:0",
+                    "match": '<a href="javascript:',
+                    "message": "Replace 'javascript:abc()' with on_ event and real url.",
+                },
+                {
+                    "code": "H019",
+                    "line": "2:0",
+                    "match": '<form action="javasc',
+                    "message": "Replace 'javascript:abc()' with on_ event and real url.",
+                },
+            ]
+        ),
         id="J018_no",
     ),
     pytest.param(
         ('<a href="onclick:abc()">\n<form action="onclick:abc()"></form></a>'),
-        (),
-        ([("J018", 1), ("J018", 2)]),
+        ([]),
         id="J018_on_events",
     ),
     pytest.param(
         ('<div class="em-ajaxLogs" data-src="/table/task/{{ t.id }}/log"></div>'),
-        ([("J018", 1)]),
-        (),
+        (
+            [
+                {
+                    "code": "J018",
+                    "line": "1:0",
+                    "match": '<div class="em-ajaxL',
+                    "message": "(Jinja) Internal links should use the {{ url_for() ... }} pattern.",
+                }
+            ]
+        ),
         id="J018_data_src",
     ),
     pytest.param(
         ('<a href="mailto:joe"></a><a href="tel:joe"></a>'),
-        (),
-        (["J018"]),
+        ([]),
         id="J018_mailto",
     ),
     pytest.param(
         ('<a href="data:,Hello%2C%20World%21"></a>'),
-        (),
-        (["J018"]),
+        ([]),
         id="J018_data",
     ),
     pytest.param(
         ('<div data-row-selection-action="highlight"></div>'),
-        (),
-        (["J018"]),
+        ([]),
         id="J018_attributes",
     ),
     pytest.param(
         (
             "{% macro rendersubmit(buttons=[], class=\"\", index='', url='', that=\"\" , test='') -%}"
         ),
-        (),
-        (["T027"]),
+        ([]),
         id="T027",
     ),
     pytest.param(
-        ("<a href=\"{% blah 'asdf' -%}\">"),
-        (),
-        (["T028"]),
+        ("<a href=\"{% blah 'asdf' -%}\"></a>"),
+        ([]),
         id="T028",
     ),
     pytest.param(
-        ("<a href=\"{%- if 'asdf' %}\">"),
-        (["T028"]),
-        (),
+        ("<a href=\"{%- if 'asdf' %}\"></a>"),
+        (
+            [
+                {
+                    "code": "T028",
+                    "line": "1:0",
+                    "match": "<a href=\"{%- if 'asd",
+                    "message": "Consider using spaceless tags inside attribute values. {%- if/for -%}",
+                }
+            ]
+        ),
         id="T028_2",
     ),
     pytest.param(
-        ("<a href=\"{%- if 'asdf' %}\">"),
-        (["T028"]),
-        (),
+        ("<a href=\"{%- if 'asdf' %}\"></a>"),
+        (
+            [
+                {
+                    "code": "T028",
+                    "line": "1:0",
+                    "match": "<a href=\"{%- if 'asd",
+                    "message": "Consider using spaceless tags inside attribute values. {%- if/for -%}",
+                }
+            ]
+        ),
         id="T028_3",
     ),
     pytest.param(
-        ("<a href=\"{{- blah 'asdf' }}\">"),
-        (),
-        (["T028"]),
+        ("<a href=\"{{- blah 'asdf' }}\"></a>"),
+        ([]),
         id="T028_4",
     ),
     pytest.param(
@@ -144,20 +179,26 @@
             "      ('https://example.com', 'plum', 'Three'),\n"
             "  ] %}"
         ),
-        (),
-        (["T032"]),
+        ([]),
         id="T032",
     ),
     pytest.param(
         ("{% not ok }%"),
-        (["T034"]),
-        (),
+        (
+            [
+                {
+                    "code": "T034",
+                    "line": "1:0",
+                    "match": "{% not ok }%",
+                    "message": "Did you intend to use {% ... %} instead of {% ... }%?",
+                }
+            ]
+        ),
         id="T034",
     ),
     pytest.param(
         ("{% not ok \n%}"),
-        (),
-        (["T034"]),
+        ([]),
         id="T034",
     ),
     pytest.param(
@@ -166,35 +207,21 @@
             ";      e.g. for a ISO8601 formatted timestring, use: %{%Y-%m-%dT%H:%M:%S%z}t\n"
             "{% endraw %}"
         ),
-        (),
-        (["T034"]),
+        ([]),
         id="raw",
     ),
 ]
 
 
-@pytest.mark.parametrize(("source", "expected", "excluded"), test_data)
-def test_jinja_linter(source, expected, excluded, jinja_config) -> None:
-    filename = "file"
-    filepath = filename
-    lint = linter(jinja_config, source, filename, filepath)[filename]
-
-    lint_printer(source, expected, excluded, lint)
+@pytest.mark.parametrize(("source", "expected"), test_data)
+def test_base(source, expected, jinja_config):
+    filename = "test.html"
+    output = linter(jinja_config, source, filename, filename)
 
-    def check_rule(rule, lint):
-        if isinstance(rule, tuple):
-            return (
-                any(
-                    x["code"] == rule[0] and int(x["line"].split(":")[0]) == rule[1]
-                    for x in lint
-                )
-                is True
-            )
-        else:
-            return any(x["code"] == rule for x in lint) is True
+    lint_printer(source, expected, output[filename])
 
-    for rule in expected:
-        assert check_rule(rule, lint) is True
+    mismatch = list(filter(lambda x: x not in expected, output[filename])) + list(
+        filter(lambda x: x not in output[filename], expected)
+    )
 
-    for rule in excluded:
-        assert check_rule(rule, lint) is False
+    assert len(mismatch) == 0
diff --git a/tests/test_linter/test_linter.py b/tests/test_linter/test_linter.py
index 352416531..6e8a42340 100644
--- a/tests/test_linter/test_linter.py
+++ b/tests/test_linter/test_linter.py
@@ -648,20 +648,6 @@ def test_H036(runner: CliRunner, tmp_file: TextIO) -> None:
     assert "H036" in result.output
 
 
-def test_H037(runner: CliRunner, tmp_file: TextIO) -> None:
-    write_to_file(tmp_file.name, b"<br class='a' id=asdf class='b'>")
-    result = runner.invoke(djlint, [tmp_file.name])
-    assert "H037" in result.output
-
-    write_to_file(tmp_file.name, b"<div data-class='a' id=asdf data-class='b'>")
-    result = runner.invoke(djlint, [tmp_file.name])
-    assert "H037" in result.output
-
-    write_to_file(tmp_file.name, b"<div data-class='a' data=asdf class='b'>")
-    result = runner.invoke(djlint, [tmp_file.name])
-    assert "H037" not in result.output
-
-
 def test_rules_not_matched_in_ignored_block(
     runner: CliRunner, tmp_file: TextIO
 ) -> None:
diff --git a/tests/test_linter/test_nunjucks_linter.py b/tests/test_linter/test_nunjucks_linter.py
index 9c5cf495b..b2d0f7236 100644
--- a/tests/test_linter/test_nunjucks_linter.py
+++ b/tests/test_linter/test_nunjucks_linter.py
@@ -1,23 +1,8 @@
-"""Djlint linter rule tests.
-
-run::
-
-   pytest tests/test_linter.py --cov=src/djlint --cov-branch \
-          --cov-report xml:coverage.xml --cov-report term-missing
-
-   # for a single test
-
-   pytest tests/test_linter/test_linter.py::test_random
-
-Test setup
-
-(html, (list of codes that should file, plus optional line number))
+"""Djlint linter rule tests for nunjucks.
 
+poetry run pytest tests/test_linter/test_nunjucks_linter.py
 
 """
-# pylint: disable=C0116,C0103,C0302
-
-
 import pytest
 
 from src.djlint.lint import linter
@@ -26,60 +11,49 @@
 test_data = [
     pytest.param(
         ("{%- test-%}"),
-        ([("T001", 1)]),
-        (),
+        (
+            [
+                {
+                    "code": "T001",
+                    "line": "1:4",
+                    "match": "test-%}",
+                    "message": "Variables should be wrapped in a single whitespace.",
+                }
+            ]
+        ),
         id="T001",
     ),
     pytest.param(
         ("{%-test -%}"),
-        ([("T001", 1)]),
-        (),
+        (
+            [
+                {
+                    "code": "T001",
+                    "line": "1:0",
+                    "match": "{%-test",
+                    "message": "Variables should be wrapped in a single whitespace.",
+                }
+            ]
+        ),
         id="T001_2",
     ),
     pytest.param(
         ("{%- test -%}"),
-        (),
-        (["T001"]),
+        ([]),
         id="T001_3",
     ),
 ]
 
 
-@pytest.mark.parametrize(("source", "expected", "excluded"), test_data)
-def test_jinja_linter(source, expected, excluded, nunjucks_config) -> None:
-    filename = "file"
-    filepath = filename
-    lint = linter(nunjucks_config, source, filename, filepath)[filename]
-
-    lint_printer(source, expected, excluded, lint)
-
-    def check_rule(rule, lint):
-        if isinstance(rule, tuple):
-            return (
-                any(
-                    x["code"] == rule[0] and int(x["line"].split(":")[0]) == rule[1]
-                    for x in lint
-                )
-                is True
-            )
-        else:
-            return any(x["code"] == rule for x in lint) is True
-
-    for rule in expected:
-        assert check_rule(rule, lint) is True
-
-    for rule in excluded:
-        assert check_rule(rule, lint) is False
-
-
-# def test_T001(runner: CliRunner, tmp_file: TextIO) -> None:
+@pytest.mark.parametrize(("source", "expected"), test_data)
+def test_base(source, expected, nunjucks_config):
+    filename = "test.html"
+    output = linter(nunjucks_config, source, filename, filename)
 
+    lint_printer(source, expected, output[filename])
 
-#     write_to_file(tmp_file.name, b"{%-test -%}")
-#     result = runner.invoke(djlint, [tmp_file.name, "--profile", "nunjucks"])
-#     assert result.exit_code == 1
-#     assert "T001 1:" in result.output
+    mismatch = list(filter(lambda x: x not in expected, output[filename])) + list(
+        filter(lambda x: x not in output[filename], expected)
+    )
 
-#     write_to_file(tmp_file.name, b"{%- test -%}")
-#     result = runner.invoke(djlint, [tmp_file.name, "--profile", "nunjucks"])
-#     assert result.exit_code == 0
+    assert len(mismatch) == 0