More robust support for comments.

Author: adamghill

src/dj_angles/replacers/__init__.py

@@ -1,9 +1,10 @@
 import logging
-import re
 
 from dj_angles.replacers.attributes import replace_attributes
+from dj_angles.replacers.comments import mask_comments
 from dj_angles.replacers.tags import replace_tags
 from dj_angles.replacers.variables import replace_variables
+from dj_angles.settings import get_setting
 
 logger = logging.getLogger(__name__)
 
@@ -20,20 +21,9 @@ def convert_template(html: str, *, origin=None) -> str:
     """
 
     # 0. Mask comments
-    comments = []
+    initial_tag_regex = get_setting("initial_tag_regex", default=r"(dj-)")
 
-    def mask_match(match):
-        comments.append(match.group(0))
-        return f"__DJ_ANGLES_COMMENT_{len(comments) - 1}__"
-
-    # Django single line comments {# ... #}
-    html = re.sub(r"\{#.*?#\}", mask_match, html, flags=re.DOTALL)
-
-    # Django block comments {% comment %}...{% endcomment %}
-    html = re.sub(r"\{%\s*comment\s*%\}.*?\{%\s*endcomment\s*%\}", mask_match, html, flags=re.DOTALL | re.IGNORECASE)
-
-    # Custom dj-comment Tags <dj-comment>...</dj-comment>
-    html = re.sub(r"<dj-comment>.*?</dj-comment>", mask_match, html, flags=re.DOTALL | re.IGNORECASE)
+    (html, comments) = mask_comments(html, initial_tag_regex=initial_tag_regex)
 
     # 1. Replace attributes, e.g. `<div dj-if="condition">`
     html = replace_attributes(html)

src/dj_angles/replacers/comments.py

@@ -0,0 +1,101 @@
+import re
+
+
+def mask_comments(html: str, initial_tag_regex: str = r"(dj-)") -> tuple[str, list[str]]:
+    """Mask Django and custom comments in the HTML string.
+
+    Args:
+        html: The HTML string to process.
+        initial_tag_regex: The regex for the tag prefix.
+
+    Returns:
+        A tuple containing the masked HTML string and a list of original comments.
+    """
+    comments = []
+
+    # Combined pattern for all comment types
+    # 1. Django comment block start: {% comment %}
+    # 2. Django comment block end: {% endcomment %}
+    # 3. Custom comment start: <prefix-comment>
+    # 4. Custom comment end: </prefix-comment>
+    # 5. Django single line comment: {# ... #}
+    comment_pattern = re.compile(
+        r"(?P<django_block_start>\{%\s*comment\s*%\})"
+        r"|(?P<django_block_end>\{%\s*endcomment\s*%\})"
+        r"|(?P<dj_comment_start><" + initial_tag_regex + r"comment(?:>|\s[^>]*>))"
+        r"|(?P<dj_comment_end></" + initial_tag_regex + r"comment>)"
+        r"|(?P<django_single>\{#.*?#\})",
+        flags=re.IGNORECASE | re.DOTALL,
+    )
+
+    masked_html_parts = []
+    last_pos = 0
+    active_comment_start = None
+    nesting_depth = 0
+    in_django_block = False
+
+    for match in comment_pattern.finditer(html):
+        # If we are inside a Django block comment, we ONLY look for the end of THAT block
+        if in_django_block:
+            if match.group("django_block_end"):
+                in_django_block = False
+
+                if active_comment_start is not None:
+                    full_comment = html[active_comment_start : match.end()]
+                    comments.append(full_comment)
+                    masked_html_parts.append(f"__DJ_ANGLES_COMMENT_{len(comments) - 1}__")
+                    active_comment_start = None
+                    last_pos = match.end()
+            continue
+
+        # If we are inside a dj-comment block, manage nesting depth
+        if nesting_depth > 0:
+            if match.group("dj_comment_start"):
+                nesting_depth += 1
+            elif match.group("dj_comment_end"):
+                nesting_depth -= 1
+
+                if nesting_depth == 0:
+                    if active_comment_start is not None:
+                        full_comment = html[active_comment_start : match.end()]
+                        comments.append(full_comment)
+                        masked_html_parts.append(f"__DJ_ANGLES_COMMENT_{len(comments) - 1}__")
+                        active_comment_start = None
+                        last_pos = match.end()
+            continue
+
+        # Not currently in any comment, looking for start
+        if match.group("django_single"):
+            # Single line comment - immediate replacement
+            masked_html_parts.append(html[last_pos : match.start()])
+            full_comment = match.group(0)
+            comments.append(full_comment)
+            masked_html_parts.append(f"__DJ_ANGLES_COMMENT_{len(comments) - 1}__")
+            last_pos = match.end()
+
+        elif match.group("django_block_start"):
+            # Start of Django block
+            masked_html_parts.append(html[last_pos : match.start()])
+            active_comment_start = match.start()
+            last_pos = match.start()  # Set last_pos to start of unclosed block
+            in_django_block = True
+
+        elif match.group("dj_comment_start"):
+            # Start of dj-comment
+            masked_html_parts.append(html[last_pos : match.start()])
+            active_comment_start = match.start()
+            last_pos = match.start()  # Set last_pos to start of unclosed block
+            nesting_depth = 1
+
+        elif match.group("django_block_end") or match.group("dj_comment_end"):
+            # Orphaned end tag - mask it to prevent crashes in subsequent replacers
+            masked_html_parts.append(html[last_pos : match.start()])
+            full_comment = match.group(0)
+            comments.append(full_comment)
+            masked_html_parts.append(f"__DJ_ANGLES_COMMENT_{len(comments) - 1}__")
+            last_pos = match.end()
+
+    # Add remaining text (either everything since last match, or the unclosed block)
+    masked_html_parts.append(html[last_pos:])
+
+    return "".join(masked_html_parts), comments

tests/dj_angles/replacers/test_comments.py

@@ -15,17 +15,13 @@ def test_commented_out_tag_is_ignored():
 
     actual = convert_template(template)
 
-    # Let's see what we get. I suspect it currently converts it.
-    print(f"\nACTUAL:\n{actual}")
-
     # If we want it to be ignored, this assertion should pass:
     assert "<dj-include 'fake-partial.html' />" in actual
 
 
 def test_single_line_comment_ignored():
     template = "{# <dj-include 'fake-partial.html' /> #}"
     actual = convert_template(template)
-    print(f"\nACTUAL SINGLE LINE:\n{actual}")
     assert "<dj-include 'fake-partial.html' />" in actual
 
 
@@ -36,5 +32,30 @@ def test_custom_dj_comment_ignored():
 </dj-comment>
 """
     actual = convert_template(template)
-    print(f"\nACTUAL DJ-COMMENT:\n{actual}")
+
     assert "<dj-include 'fake-partial.html' />" in actual
+
+
+def test_nested_dj_comments():
+    template = """
+    <dj-comment>
+        Outer start
+        <dj-comment>
+            Inner
+        </dj-comment>
+        Outer end
+        <dj-include 'should-be-ignored' />
+    </dj-comment>
+    """
+    actual = convert_template(template)
+
+    # Everything inside the top-level <dj-comment> should be ignored.
+    # So we should see the original <dj-include ...> tag, NOT a processed result.
+    assert "<dj-include 'should-be-ignored' />" in actual
+
+
+def test_orphaned_closing_tag_does_not_crash():
+    template = "Some content </dj-comment> and more content"
+    # This should not raise IndexError: pop from an empty deque
+    actual = convert_template(template)
+    assert "</dj-comment>" in actual

tests/dj_angles/replacers/test_mask_comments.py

@@ -0,0 +1,95 @@
+from dj_angles.replacers.comments import mask_comments
+
+
+def test_mask_django_single_line():
+    html = "Hello {# comment #} World"
+    masked_html, comments = mask_comments(html)
+    assert masked_html == "Hello __DJ_ANGLES_COMMENT_0__ World"
+    assert comments == ["{# comment #}"]
+
+
+def test_mask_django_block():
+    html = "Hello {% comment %} block {% endcomment %} World"
+    masked_html, comments = mask_comments(html)
+    assert masked_html == "Hello __DJ_ANGLES_COMMENT_0__ World"
+    assert comments == ["{% comment %} block {% endcomment %}"]
+
+
+def test_mask_dj_comment():
+    html = "Hello <dj-comment> custom </dj-comment> World"
+    masked_html, comments = mask_comments(html)
+    assert masked_html == "Hello __DJ_ANGLES_COMMENT_0__ World"
+    assert comments == ["<dj-comment> custom </dj-comment>"]
+
+
+def test_mask_nested_dj_comment():
+    html = """
+    <dj-comment>
+        outer
+        <dj-comment>
+            inner
+        </dj-comment>
+        end outer
+    </dj-comment>
+    """
+    masked_html, comments = mask_comments(html)
+    assert "__DJ_ANGLES_COMMENT_0__" in masked_html
+    assert len(comments) == 1
+    assert "outer" in comments[0]
+    assert "inner" in comments[0]
+
+
+def test_mask_multiple_comments():
+    html = "{# one #} middle <dj-comment> two </dj-comment> end"
+    masked_html, comments = mask_comments(html)
+    assert masked_html == "__DJ_ANGLES_COMMENT_0__ middle __DJ_ANGLES_COMMENT_1__ end"
+    assert len(comments) == 2
+    assert comments[0] == "{# one #}"
+    assert comments[1] == "<dj-comment> two </dj-comment>"
+
+
+def test_unclosed_comment():
+    html = "Hello <dj-comment> unclosed"
+    masked_html, comments = mask_comments(html)
+    # Unclosed comments should be treated as text (not masked)
+    assert masked_html == "Hello <dj-comment> unclosed"
+    assert len(comments) == 0
+
+
+def test_django_block_inside_dj_comment():
+    html = "<dj-comment>{% comment %} inner {% endcomment %}</dj-comment>"
+    masked_html, comments = mask_comments(html)
+    assert masked_html == "__DJ_ANGLES_COMMENT_0__"
+    assert len(comments) == 1
+    assert "{% comment %}" in comments[0]
+
+
+def test_mask_custom_prefix():
+    html = "Hello <my-comment> custom </my-comment> World"
+    # Use raw string for prefix to avoid escape issues in test
+    masked_html, comments = mask_comments(html, initial_tag_regex=r"(my-)")
+    assert masked_html == "Hello __DJ_ANGLES_COMMENT_0__ World"
+    assert comments == ["<my-comment> custom </my-comment>"]
+
+
+def test_mask_unclosed_tag():
+    html = "Normal <dj-comment> This is unclosed"
+    masked_html, comments = mask_comments(html)
+    # Unclosed tags are kept as-is, not masked
+    assert masked_html == html
+    assert len(comments) == 0
+
+
+def test_mask_orphaned_closing_tag():
+    html = "Orphaned </dj-comment> tag"
+    masked_html, comments = mask_comments(html)
+    # Orphaned end tags should be masked to prevent downstream crashes
+    assert masked_html == "Orphaned __DJ_ANGLES_COMMENT_0__ tag"
+    assert comments == ["</dj-comment>"]
+
+
+def test_mask_mixed_orphaned_tags():
+    html = "</dj-comment> {% endcomment %}"
+    masked_html, comments = mask_comments(html)
+    assert masked_html == "__DJ_ANGLES_COMMENT_0__ __DJ_ANGLES_COMMENT_1__"
+    assert comments == ["</dj-comment>", "{% endcomment %}"]