Consolidate delimiter constants into AtomicPattern dataclass

- Remove module-level delimiter constants (JINJA_TAG_OPEN, etc.)
- Add required `open_delim`, `close_delim`, `open_re`, `close_re` fields to AtomicPattern
- Update tag_handling.py to use pattern properties directly (e.g., SINGLE_JINJA_TAG.open_delim)
- Remove unnecessary `or ""` guards since fields are now always strings

Each pattern now contains all its information in one place, making the code
cleaner and easier to maintain.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: jlevy

src/flowmark/linewrapping/atomic_patterns.py

@@ -3,45 +3,30 @@
 
 Each AtomicPattern defines a regex for a specific type of construct (code span, link,
 template tag, etc.) that should be kept together as a single token during line wrapping.
-
-This module also defines the canonical delimiter constants for all supported tag formats.
 """
 
 from __future__ import annotations
 
 import re
 from dataclasses import dataclass
 
-# Delimiter constants for template tags and comments.
-# Raw delimiters
-JINJA_TAG_OPEN = "{%"
-JINJA_TAG_CLOSE = "%}"
-JINJA_COMMENT_OPEN = "{#"
-JINJA_COMMENT_CLOSE = "#}"
-JINJA_VAR_OPEN = "{{"
-JINJA_VAR_CLOSE = "}}"
-HTML_COMMENT_OPEN = "<!--"
-HTML_COMMENT_CLOSE = "-->"
-
-# Regex-escaped delimiters
-JINJA_TAG_OPEN_RE = r"\{%"
-JINJA_TAG_CLOSE_RE = r"%\}"
-JINJA_COMMENT_OPEN_RE = r"\{#"
-JINJA_COMMENT_CLOSE_RE = r"#\}"
-JINJA_VAR_OPEN_RE = r"\{\{"
-JINJA_VAR_CLOSE_RE = r"\}\}"
-HTML_COMMENT_OPEN_RE = r"<!--"
-HTML_COMMENT_CLOSE_RE = r"-->"
-
 
 @dataclass(frozen=True)
 class AtomicPattern:
     """
     Defines a regex pattern for an atomic construct that should not be broken.
+
+    For delimiter-based patterns (tags, comments), `open_delim`/`close_delim` store
+    the raw delimiters and `open_re`/`close_re` store regex-escaped versions.
+    For non-delimiter patterns, these are empty strings.
     """
 
     name: str
     pattern: str
+    open_delim: str
+    close_delim: str
+    open_re: str
+    close_re: str
 
 
 def _make_paired_pattern(open_re: str, close_re: str, middle_char: str) -> str:
@@ -58,60 +43,91 @@ def _make_paired_pattern(open_re: str, close_re: str, middle_char: str) -> str:
     )
 
 
-def _make_single_tag_pattern(open_re: str, close_re: str) -> str:
-    """Generate a single tag pattern: opening...closing."""
-    return rf"{open_re}.*?{close_re}"
-
-
 # Inline code spans with backticks (handles multi-backtick like ``code``)
 INLINE_CODE_SPAN = AtomicPattern(
     name="inline_code_span",
     pattern=r"(`+)(?:(?!\1).)+\1",
+    open_delim="",
+    close_delim="",
+    open_re="",
+    close_re="",
 )
 
 # Markdown links: [text](url) or [text][ref] or [text]
 MARKDOWN_LINK = AtomicPattern(
     name="markdown_link",
     pattern=r"\[[^\]]*\](?:\([^)]*\)|\[[^\]]*\])?",
+    open_delim="",
+    close_delim="",
+    open_re="",
+    close_re="",
 )
 
 # Jinja/Markdoc template tags: {% tag %}, {% /tag %}
 SINGLE_JINJA_TAG = AtomicPattern(
     name="single_jinja_tag",
-    pattern=_make_single_tag_pattern(JINJA_TAG_OPEN_RE, JINJA_TAG_CLOSE_RE),
+    pattern=r"\{%.*?%\}",
+    open_delim="{%",
+    close_delim="%}",
+    open_re=r"\{%",
+    close_re=r"%\}",
 )
 
 PAIRED_JINJA_TAG = AtomicPattern(
     name="paired_jinja_tag",
-    pattern=_make_paired_pattern(JINJA_TAG_OPEN_RE, JINJA_TAG_CLOSE_RE, "%"),
+    pattern=_make_paired_pattern(r"\{%", r"%\}", "%"),
+    open_delim="{%",
+    close_delim="%}",
+    open_re=r"\{%",
+    close_re=r"%\}",
 )
 
 # Jinja comments: {# comment #}
 SINGLE_JINJA_COMMENT = AtomicPattern(
     name="single_jinja_comment",
-    pattern=_make_single_tag_pattern(JINJA_COMMENT_OPEN_RE, JINJA_COMMENT_CLOSE_RE),
+    pattern=r"\{#.*?#\}",
+    open_delim="{#",
+    close_delim="#}",
+    open_re=r"\{#",
+    close_re=r"#\}",
 )
 
 PAIRED_JINJA_COMMENT = AtomicPattern(
     name="paired_jinja_comment",
-    pattern=_make_paired_pattern(JINJA_COMMENT_OPEN_RE, JINJA_COMMENT_CLOSE_RE, "#"),
+    pattern=_make_paired_pattern(r"\{#", r"#\}", "#"),
+    open_delim="{#",
+    close_delim="#}",
+    open_re=r"\{#",
+    close_re=r"#\}",
 )
 
 # Jinja variables: {{ variable }}
 SINGLE_JINJA_VAR = AtomicPattern(
     name="single_jinja_var",
-    pattern=_make_single_tag_pattern(JINJA_VAR_OPEN_RE, JINJA_VAR_CLOSE_RE),
+    pattern=r"\{\{.*?\}\}",
+    open_delim="{{",
+    close_delim="}}",
+    open_re=r"\{\{",
+    close_re=r"\}\}",
 )
 
 PAIRED_JINJA_VAR = AtomicPattern(
     name="paired_jinja_var",
-    pattern=_make_paired_pattern(JINJA_VAR_OPEN_RE, JINJA_VAR_CLOSE_RE, "}"),
+    pattern=_make_paired_pattern(r"\{\{", r"\}\}", "}"),
+    open_delim="{{",
+    close_delim="}}",
+    open_re=r"\{\{",
+    close_re=r"\}\}",
 )
 
 # HTML comments: <!-- comment -->
 SINGLE_HTML_COMMENT = AtomicPattern(
     name="single_html_comment",
-    pattern=_make_single_tag_pattern(HTML_COMMENT_OPEN_RE, HTML_COMMENT_CLOSE_RE),
+    pattern=r"<!--.*?-->",
+    open_delim="<!--",
+    close_delim="-->",
+    open_re=r"<!--",
+    close_re=r"-->",
 )
 
 PAIRED_HTML_COMMENT = AtomicPattern(
@@ -121,17 +137,29 @@ def _make_single_tag_pattern(open_re: str, close_re: str) -> str:
         r"\s*"
         r"<!--\s*/[^-]*(?:-[^-]+)*-->"
     ),
+    open_delim="<!--",
+    close_delim="-->",
+    open_re=r"<!--",
+    close_re=r"-->",
 )
 
 # HTML/XML tags: <tag>, </tag>
 HTML_OPEN_TAG = AtomicPattern(
     name="html_open_tag",
     pattern=r"<[a-zA-Z][^>]*>",
+    open_delim="",
+    close_delim="",
+    open_re="",
+    close_re="",
 )
 
 HTML_CLOSE_TAG = AtomicPattern(
     name="html_close_tag",
     pattern=r"</[a-zA-Z][^>]*>",
+    open_delim="",
+    close_delim="",
+    open_re="",
+    close_re="",
 )
 
 # All patterns in priority order (more specific patterns first).

src/flowmark/linewrapping/tag_handling.py

@@ -14,22 +14,6 @@
 import re
 
 from flowmark.linewrapping.atomic_patterns import (
-    HTML_COMMENT_CLOSE,
-    HTML_COMMENT_CLOSE_RE,
-    HTML_COMMENT_OPEN,
-    HTML_COMMENT_OPEN_RE,
-    JINJA_COMMENT_CLOSE,
-    JINJA_COMMENT_CLOSE_RE,
-    JINJA_COMMENT_OPEN,
-    JINJA_COMMENT_OPEN_RE,
-    JINJA_TAG_CLOSE,
-    JINJA_TAG_CLOSE_RE,
-    JINJA_TAG_OPEN,
-    JINJA_TAG_OPEN_RE,
-    JINJA_VAR_CLOSE,
-    JINJA_VAR_CLOSE_RE,
-    JINJA_VAR_OPEN,
-    JINJA_VAR_OPEN_RE,
     PAIRED_HTML_COMMENT,
     PAIRED_JINJA_COMMENT,
     PAIRED_JINJA_TAG,
@@ -74,18 +58,18 @@
 # Pattern to detect adjacent tags (closing tag immediately followed by opening tag)
 # This handles cases like %}{% or --><!-- where there's no space between
 _adjacent_tags_re: re.Pattern[str] = re.compile(
-    rf"({JINJA_TAG_CLOSE_RE})({JINJA_TAG_OPEN_RE})|"
-    rf"({JINJA_COMMENT_CLOSE_RE})({JINJA_COMMENT_OPEN_RE})|"
-    rf"({JINJA_VAR_CLOSE_RE})({JINJA_VAR_OPEN_RE})|"
-    rf"({HTML_COMMENT_CLOSE_RE})({HTML_COMMENT_OPEN_RE})"
+    rf"({SINGLE_JINJA_TAG.close_re})({SINGLE_JINJA_TAG.open_re})|"
+    rf"({SINGLE_JINJA_COMMENT.close_re})({SINGLE_JINJA_COMMENT.open_re})|"
+    rf"({SINGLE_JINJA_VAR.close_re})({SINGLE_JINJA_VAR.open_re})|"
+    rf"({SINGLE_HTML_COMMENT.close_re})({SINGLE_HTML_COMMENT.open_re})"
 )
 
 # Pattern to remove spaces between adjacent tags that were added during word splitting
 _denormalize_tags_re: re.Pattern[str] = re.compile(
-    rf"({JINJA_TAG_CLOSE_RE}) ({JINJA_TAG_OPEN_RE})|"
-    rf"({JINJA_COMMENT_CLOSE_RE}) ({JINJA_COMMENT_OPEN_RE})|"
-    rf"({JINJA_VAR_CLOSE_RE}) ({JINJA_VAR_OPEN_RE})|"
-    rf"({HTML_COMMENT_CLOSE_RE}) ({HTML_COMMENT_OPEN_RE})"
+    rf"({SINGLE_JINJA_TAG.close_re}) ({SINGLE_JINJA_TAG.open_re})|"
+    rf"({SINGLE_JINJA_COMMENT.close_re}) ({SINGLE_JINJA_COMMENT.open_re})|"
+    rf"({SINGLE_JINJA_VAR.close_re}) ({SINGLE_JINJA_VAR.open_re})|"
+    rf"({SINGLE_HTML_COMMENT.close_re}) ({SINGLE_HTML_COMMENT.open_re})"
 )
 
 
@@ -136,18 +120,18 @@ def _is_tag_only_line(line: str) -> bool:
 
     # Check if it starts with a tag
     starts_tag = (
-        stripped.startswith(JINJA_TAG_OPEN)
-        or stripped.startswith(JINJA_COMMENT_OPEN)
-        or stripped.startswith(JINJA_VAR_OPEN)
-        or stripped.startswith(HTML_COMMENT_OPEN)
+        stripped.startswith(SINGLE_JINJA_TAG.open_delim)
+        or stripped.startswith(SINGLE_JINJA_COMMENT.open_delim)
+        or stripped.startswith(SINGLE_JINJA_VAR.open_delim)
+        or stripped.startswith(SINGLE_HTML_COMMENT.open_delim)
     )
 
     # Check if it ends with a tag
     ends_tag = (
-        stripped.endswith(JINJA_TAG_CLOSE)
-        or stripped.endswith(JINJA_COMMENT_CLOSE)
-        or stripped.endswith(JINJA_VAR_CLOSE)
-        or stripped.endswith(HTML_COMMENT_CLOSE)
+        stripped.endswith(SINGLE_JINJA_TAG.close_delim)
+        or stripped.endswith(SINGLE_JINJA_COMMENT.close_delim)
+        or stripped.endswith(SINGLE_JINJA_VAR.close_delim)
+        or stripped.endswith(SINGLE_HTML_COMMENT.close_delim)
     )
 
     return starts_tag and ends_tag
@@ -214,13 +198,13 @@ def line_ends_with_tag(line: str) -> bool:
         return False
     # Check for Jinja-style tags
     if (
-        stripped.endswith(JINJA_TAG_CLOSE)
-        or stripped.endswith(JINJA_COMMENT_CLOSE)
-        or stripped.endswith(JINJA_VAR_CLOSE)
+        stripped.endswith(SINGLE_JINJA_TAG.close_delim)
+        or stripped.endswith(SINGLE_JINJA_COMMENT.close_delim)
+        or stripped.endswith(SINGLE_JINJA_VAR.close_delim)
     ):
         return True
     # Check for HTML comments
-    if stripped.endswith(HTML_COMMENT_CLOSE):
+    if stripped.endswith(SINGLE_HTML_COMMENT.close_delim):
         return True
     return False
 
@@ -232,13 +216,13 @@ def line_starts_with_tag(line: str) -> bool:
         return False
     # Check for Jinja-style tags
     if (
-        stripped.startswith(JINJA_TAG_OPEN)
-        or stripped.startswith(JINJA_COMMENT_OPEN)
-        or stripped.startswith(JINJA_VAR_OPEN)
+        stripped.startswith(SINGLE_JINJA_TAG.open_delim)
+        or stripped.startswith(SINGLE_JINJA_COMMENT.open_delim)
+        or stripped.startswith(SINGLE_JINJA_VAR.open_delim)
     ):
         return True
     # Check for HTML comments
-    if stripped.startswith(HTML_COMMENT_OPEN):
+    if stripped.startswith(SINGLE_HTML_COMMENT.open_delim):
         return True
     return False
 
@@ -444,10 +428,10 @@ def _fix_closing_tag_spacing(text: str) -> str:
 # where a multi-line opening tag ends and a closing tag follows on the same line.
 # Uses named group "closing_tag" to capture the start of the closing tag.
 _multiline_closing_pattern: re.Pattern[str] = re.compile(
-    rf"{JINJA_TAG_CLOSE_RE}\s*(?P<closing_tag>{JINJA_TAG_OPEN_RE}\s*/)|"  # %}{% /
-    rf"{JINJA_COMMENT_CLOSE_RE}\s*(?P<closing_comment>{JINJA_COMMENT_OPEN_RE}\s*/)|"  # #}{# /
-    rf"{JINJA_VAR_CLOSE_RE}\s*(?P<closing_var>{JINJA_VAR_OPEN_RE}\s*/)|"  # }}{{ /
-    rf"{HTML_COMMENT_CLOSE_RE}\s*(?P<closing_html>{HTML_COMMENT_OPEN_RE}\s*/)"  # --><!-- /
+    rf"{SINGLE_JINJA_TAG.close_re}\s*(?P<closing_tag>{SINGLE_JINJA_TAG.open_re}\s*/)|"
+    rf"{SINGLE_JINJA_COMMENT.close_re}\s*(?P<closing_comment>{SINGLE_JINJA_COMMENT.open_re}\s*/)|"
+    rf"{SINGLE_JINJA_VAR.close_re}\s*(?P<closing_var>{SINGLE_JINJA_VAR.open_re}\s*/)|"
+    rf"{SINGLE_HTML_COMMENT.close_re}\s*(?P<closing_html>{SINGLE_HTML_COMMENT.open_re}\s*/)"
 )
 
 
@@ -490,10 +474,10 @@ def _fix_multiline_opening_tag_with_closing(text: str) -> str:
         # Only process lines that are continuations (don't start with a tag opener).
         # If a line starts with a tag opener, the tag began on that line, not a continuation.
         is_tag_start = (
-            stripped.startswith(JINJA_TAG_OPEN)
-            or stripped.startswith(JINJA_COMMENT_OPEN)
-            or stripped.startswith(JINJA_VAR_OPEN)
-            or stripped.startswith(HTML_COMMENT_OPEN)
+            stripped.startswith(SINGLE_JINJA_TAG.open_delim)
+            or stripped.startswith(SINGLE_JINJA_COMMENT.open_delim)
+            or stripped.startswith(SINGLE_JINJA_VAR.open_delim)
+            or stripped.startswith(SINGLE_HTML_COMMENT.open_delim)
         )
 
         if not is_tag_start: