flowmark 0.6.2__tar.gz → 0.6.3__tar.gz

{flowmark-0.6.2 → flowmark-0.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flowmark
-Version: 0.6.2
+Version: 0.6.3
 Summary: Better auto-formatting for Markdown and plaintext
 Project-URL: Repository, https://github.com/jlevy/flowmark
 Author-email: Joshua Levy <joshua@cal.berkeley.edu>

{flowmark-0.6.2 → flowmark-0.6.3}/src/flowmark/formats/flowmark_markdown.py

@@ -92,6 +92,35 @@ class ExtendedParseInfo(NamedTuple):
     fence_len: int
 
 
+class CustomStrikethrough(gfm_elements.Strikethrough):
+    """
+    Fixed Strikethrough that implements GFM flanking delimiter rules.
+
+    Marko's default pattern `(?<!~)(~|~~)([^~]+)\\1(?!~)` does not enforce
+    that the closing tilde must be right-flanking (not preceded by whitespace)
+    or that the opening tilde must be left-flanking (not followed by whitespace).
+    This causes `~60 seconds, ~130 words` to be incorrectly parsed as
+    strikethrough, since the space before the second `~` makes it left-flanking
+    only, not right-flanking, so it cannot close the span.
+
+    The fixed pattern adds:
+    - `(?!\\s)` after the opening delimiter (left-flanking: not followed by whitespace)
+    - `(?<!\\s)` before the closing delimiter (right-flanking: not preceded by whitespace)
+    - Non-greedy `+?` for correct minimal matching
+    """
+
+    pattern: re.Pattern[str] = re.compile(r"(?<!~)(~{1,2})(?!\s)([^~]+?)(?<!\s)\1(?!~)")
+    priority: int = 5
+    parse_children: bool = True
+    parse_group: int = 2
+
+    @override
+    @classmethod
+    def get_type(cls, snake_case: bool = False) -> str:
+        # Ensure renderer dispatch uses "strikethrough" not "custom_strikethrough".
+        return "strikethrough" if snake_case else "Strikethrough"
+
+
 class CustomFencedCode(block.FencedCode):
     """
     Extended FencedCode that preserves the fence character and length.
@@ -353,7 +382,14 @@ class MarkdownNormalizer(Renderer):
         fence = fence_char * fence_len
 
         lines = [f"{self._prefix}{fence}{lang_text}"]
-        lines.extend(f"{self._second_prefix}{line}" for line in code_content.splitlines())
+        # Don't add prefix to empty lines to avoid trailing whitespace.
+        # Use rstrip() to preserve structural prefixes like ">" for blockquotes.
+        empty_line_prefix = self._second_prefix.rstrip()
+        for line in code_content.splitlines():
+            if line:
+                lines.append(f"{self._second_prefix}{line}")
+            else:
+                lines.append(empty_line_prefix)
         lines.append(f"{self._second_prefix}{fence}")
         self._prefix = self._second_prefix
         # After rendering a code block, don't suppress the next item break
@@ -668,8 +704,10 @@ def flowmark_markdown(
             # Using Marko's full extension system is tricky with our customizations so simpler
             # to do this manually.
             custom_parser = CustomParser()
-            # Add GFM support.
+            # Add GFM support, using our fixed Strikethrough with proper flanking rules.
             for e in GFM.elements:
+                if e is gfm_elements.Strikethrough:
+                    e = CustomStrikethrough
                 assert (
                     e not in custom_parser.block_elements and e not in custom_parser.inline_elements
                 )

{flowmark-0.6.2 → flowmark-0.6.3}/tests/test_fenced_code_blocks.py

@@ -231,3 +231,133 @@ def test_minimum_backticks_computed_from_content():
     # Note: This is technically invalid markdown input (the parser may mishandle it)
     # but we test the code rendering logic's ability to compute minimum needed backticks
     pass  # This is tested indirectly by other tests
+
+
+def test_empty_lines_in_code_block_no_trailing_whitespace():
+    """Test that empty lines in code blocks remain truly empty (no trailing whitespace)."""
+    input_doc = dedent(
+        """
+        ```python
+        line1
+
+        line2
+        ```
+        """
+    ).strip()
+
+    expected_doc = (
+        dedent(
+            """
+            ```python
+            line1
+
+            line2
+            ```
+            """
+        ).strip()
+        + "\n"
+    )
+
+    result = fill_markdown(input_doc, semantic=True)
+    assert result == expected_doc
+    # Verify the empty line has no trailing whitespace
+    assert result.split("\n")[2] == ""
+
+
+def test_empty_lines_in_nested_code_block_no_trailing_whitespace():
+    """Test that empty lines in code blocks inside list items have no trailing whitespace.
+
+    This is the key case: when a code block is nested inside a list item,
+    _second_prefix is non-empty (e.g. "  "), and empty lines must not get that prefix.
+    """
+    input_doc = dedent(
+        """
+        - Example:
+
+          ```python
+          def foo():
+              pass
+
+          def bar():
+              pass
+          ```
+        """
+    ).strip()
+
+    expected_doc = (
+        dedent(
+            """
+            - Example:
+
+              ```python
+              def foo():
+                  pass
+
+              def bar():
+                  pass
+              ```
+            """
+        ).strip()
+        + "\n"
+    )
+
+    result = fill_markdown(input_doc, semantic=True)
+    assert result == expected_doc
+    # Verify the empty line between functions has no trailing whitespace
+    lines = result.split("\n")
+    empty_line_idx = next(
+        i
+        for i in range(len(lines))
+        if lines[i - 1].endswith("pass") and lines[i + 1].strip().startswith("def bar")
+    )
+    assert lines[empty_line_idx] == ""
+
+
+def test_empty_lines_in_quoted_code_block_no_trailing_whitespace():
+    """Test that empty lines in code blocks inside blockquotes preserve > but strip trailing space."""
+    input_doc = dedent(
+        """
+        > ```python
+        > line1
+        >
+        > line2
+        > ```
+        """
+    ).strip()
+
+    # The empty line should have ">" (blockquote marker) but no trailing space.
+    expected_doc = "> ```python\n> line1\n>\n> line2\n> ```\n"
+
+    result = fill_markdown(input_doc, semantic=True)
+    assert result == expected_doc
+
+
+def test_multiple_empty_lines_in_code_block():
+    """Test code blocks with multiple consecutive empty lines stay clean."""
+    input_doc = dedent(
+        """
+        ```python
+        line1
+
+
+        line2
+        ```
+        """
+    ).strip()
+
+    expected_doc = (
+        dedent(
+            """
+            ```python
+            line1
+
+
+            line2
+            ```
+            """
+        ).strip()
+        + "\n"
+    )
+
+    result = fill_markdown(input_doc, semantic=True)
+    assert result == expected_doc

flowmark-0.6.3/tests/test_strikethrough.py

@@ -0,0 +1,100 @@
+"""Test strikethrough and tilde handling.
+
+Tests that flowmark correctly distinguishes between:
+- Actual GFM strikethrough: ~~text~~ or ~text~
+- Literal tildes used as "approximately": ~60 seconds, ~130 words
+"""
+
+from flowmark.formats.flowmark_markdown import flowmark_markdown
+from flowmark.linewrapping.markdown_filling import fill_markdown
+
+
+def test_literal_tildes_before_numbers():
+    """Tildes before numbers (meaning 'approximately') should be preserved as literal."""
+    md = flowmark_markdown()
+
+    result = md("Target: ~60 seconds, ~130 words total\n")
+    assert result == "Target: ~60 seconds, ~130 words total\n"
+
+
+def test_literal_tildes_not_converted_to_double():
+    """The bug: ~60 seconds, ~130 should NOT become ~~60 seconds, ~~130."""
+    result = fill_markdown("Target: ~60 seconds, ~130 words total")
+    assert "~~" not in result
+    assert result.strip() == "Target: ~60 seconds, ~130 words total"
+
+
+def test_double_tilde_strikethrough():
+    """Standard ~~strikethrough~~ should be preserved."""
+    md = flowmark_markdown()
+
+    result = md("This is ~~strikethrough~~ text\n")
+    assert result == "This is ~~strikethrough~~ text\n"
+
+
+def test_single_tilde_strikethrough():
+    """Single-tilde ~strikethrough~ is valid GFM; flowmark normalizes to ~~double~~."""
+    md = flowmark_markdown()
+
+    result = md("This is ~strikethrough~ text\n")
+    assert result == "This is ~~strikethrough~~ text\n"
+
+
+def test_multiple_strikethroughs():
+    """Multiple strikethrough spans in a single line."""
+    md = flowmark_markdown()
+
+    result = md("~one~ and ~two~ items\n")
+    assert result == "~~one~~ and ~~two~~ items\n"
+
+
+def test_single_tilde_no_closer():
+    """A single tilde with no matching closer should remain literal."""
+    md = flowmark_markdown()
+
+    result = md("About ~50% of users\n")
+    assert result == "About ~50% of users\n"
+
+
+def test_tildes_with_space_before_closer():
+    """Tildes where the 'closer' is preceded by whitespace should not be strikethrough."""
+    md = flowmark_markdown()
+
+    # The second ~ is preceded by a space, so it's not right-flanking and can't close.
+    result = md("costs ~100 to ~200\n")
+    assert result == "costs ~100 to ~200\n"
+
+
+def test_tilde_space_after_opener():
+    """A tilde followed by a space is not left-flanking, so no strikethrough."""
+    md = flowmark_markdown()
+
+    result = md("~ spaced ~\n")
+    assert result == "~ spaced ~\n"
+
+
+def test_tilde_space_before_closer():
+    """A tilde preceded by a space is not right-flanking, so no strikethrough."""
+    md = flowmark_markdown()
+
+    result = md("~foo ~\n")
+    assert result == "~foo ~\n"
+
+
+def test_escaped_tildes_preserved():
+    """Backslash-escaped tildes should remain escaped."""
+    md = flowmark_markdown()
+
+    result = md("Target: \\~60 seconds, \\~130 words total\n")
+    assert result == "Target: \\~60 seconds, \\~130 words total\n"
+
+
+def test_strikethrough_in_paragraph():
+    """Strikethrough within a longer paragraph should be preserved during wrapping."""
+    result = fill_markdown(
+        "This paragraph has some ~~deleted text~~ in it and also mentions ~50 users."
+    )
+    assert "~~deleted text~~" in result
+    assert "~50 users" in result
+    # Make sure ~50 doesn't become ~~50
+    assert "~~50" not in result

{flowmark-0.6.2 → flowmark-0.6.3}/tests/test_tag_formatting.py

@@ -676,13 +676,11 @@ def test_list_item_with_tag_on_continuation_line():
     # The tag should NOT have an extra blank line before it
     # The continuation line with the tag should be preserved as-is
     assert "\n\n  <!-- #kg-32zz -->" not in result, (
-        f"Extra blank line incorrectly added before tag on continuation line.\n"
-        f"Result:\n{result}"
+        f"Extra blank line incorrectly added before tag on continuation line.\nResult:\n{result}"
     )
 
     # The proper indented continuation should be preserved
-    assert "tsconfig.base.json)\n  <!-- #kg-32zz -->" in result or \
-           "(tsconfig.base.json)\n<!-- #kg-32zz -->" in result, (
-        f"Tag continuation line not preserved correctly.\n"
-        f"Result:\n{result}"
-    )
+    assert (
+        "tsconfig.base.json)\n  <!-- #kg-32zz -->" in result
+        or "(tsconfig.base.json)\n<!-- #kg-32zz -->" in result
+    ), f"Tag continuation line not preserved correctly.\nResult:\n{result}"

{flowmark-0.6.2 → flowmark-0.6.3}/tests/testdocs/testdoc.expected.auto.md

@@ -484,6 +484,7 @@ More line spacing challenges with multi-paragraph items:
   ```shell
   # Use z in place of cd: switch directories (first time):
   z ~/some/long/path/to/foo
+
   # Thereafter it's faster:
   z foo
   ```
@@ -1665,6 +1666,45 @@ Your feedback is valuable to us.
 
 {% /form %}
 
+## Strikethrough and Tildes
+
+Standard double-tilde ~~strikethrough~~ is the most common form and should always be
+preserved. Single-tilde ~~strikethrough~~ is also valid GFM and should be normalized to
+double tildes.
+
+Here are some ~~deleted words~~ in a sentence.
+And ~~more deleted words~~ in another sentence.
+
+Multiple ~~first~~ and ~~second~~ strikethroughs on one line work fine.
+
+### Tildes as “approximately” (not strikethrough)
+
+Tildes before numbers are commonly used to mean “approximately” and must not be treated
+as strikethrough:
+
+Target: ~60 seconds, ~130 words total
+
+The meeting lasted ~45 minutes.
+We had ~20 attendees.
+The cost was ~$500.
+
+Performance improved from ~200ms to ~50ms, a ~4x improvement.
+
+There were ~1,000 users and ~500 active sessions.
+
+### Escaped tildes
+
+Escaped tildes should be preserved: \~not strikethrough\~
+
+### Edge cases
+
+A lone tilde ~ in text is fine.
+
+Tildes at the end: the value is ~~100~~.
+
+A ~~long strikethrough that spans many words in a single paragraph and may get wrapped
+across lines during formatting~~ should be handled.
+
 ## Summary
 
 All these corner cases should format consistently and predictably.

{flowmark-0.6.2 → flowmark-0.6.3}/tests/testdocs/testdoc.expected.cleaned.md

@@ -484,6 +484,7 @@ More line spacing challenges with multi-paragraph items:
   ```shell
   # Use z in place of cd: switch directories (first time):
   z ~/some/long/path/to/foo
+
   # Thereafter it's faster:
   z foo
   ```
@@ -1665,6 +1666,45 @@ Your feedback is valuable to us.
 
 {% /form %}
 
+## Strikethrough and Tildes
+
+Standard double-tilde ~~strikethrough~~ is the most common form and should always be
+preserved. Single-tilde ~~strikethrough~~ is also valid GFM and should be normalized to
+double tildes.
+
+Here are some ~~deleted words~~ in a sentence.
+And ~~more deleted words~~ in another sentence.
+
+Multiple ~~first~~ and ~~second~~ strikethroughs on one line work fine.
+
+### Tildes as "approximately" (not strikethrough)
+
+Tildes before numbers are commonly used to mean "approximately" and must not be treated
+as strikethrough:
+
+Target: ~60 seconds, ~130 words total
+
+The meeting lasted ~45 minutes.
+We had ~20 attendees.
+The cost was ~$500.
+
+Performance improved from ~200ms to ~50ms, a ~4x improvement.
+
+There were ~1,000 users and ~500 active sessions.
+
+### Escaped tildes
+
+Escaped tildes should be preserved: \~not strikethrough\~
+
+### Edge cases
+
+A lone tilde ~ in text is fine.
+
+Tildes at the end: the value is ~~100~~.
+
+A ~~long strikethrough that spans many words in a single paragraph and may get wrapped
+across lines during formatting~~ should be handled.
+
 ## Summary
 
 All these corner cases should format consistently and predictably.

{flowmark-0.6.2 → flowmark-0.6.3}/tests/testdocs/testdoc.expected.plain.md

@@ -461,6 +461,7 @@ More line spacing challenges with multi-paragraph items:
   ```shell
   # Use z in place of cd: switch directories (first time):
   z ~/some/long/path/to/foo
+
   # Thereafter it's faster:
   z foo
   ```
@@ -1616,6 +1617,43 @@ us.
 
 {% /form %}
 
+## Strikethrough and Tildes
+
+Standard double-tilde ~~strikethrough~~ is the most common form and should always be
+preserved. Single-tilde ~~strikethrough~~ is also valid GFM and should be normalized to
+double tildes.
+
+Here are some ~~deleted words~~ in a sentence. And ~~more deleted words~~ in another
+sentence.
+
+Multiple ~~first~~ and ~~second~~ strikethroughs on one line work fine.
+
+### Tildes as "approximately" (not strikethrough)
+
+Tildes before numbers are commonly used to mean "approximately" and must not be treated
+as strikethrough:
+
+Target: ~60 seconds, ~130 words total
+
+The meeting lasted ~45 minutes. We had ~20 attendees. The cost was ~$500.
+
+Performance improved from ~200ms to ~50ms, a ~4x improvement.
+
+There were ~1,000 users and ~500 active sessions.
+
+### Escaped tildes
+
+Escaped tildes should be preserved: \~not strikethrough\~
+
+### Edge cases
+
+A lone tilde ~ in text is fine.
+
+Tildes at the end: the value is ~~100~~.
+
+A ~~long strikethrough that spans many words in a single paragraph and may get wrapped
+across lines during formatting~~ should be handled.
+
 ## Summary
 
 All these corner cases should format consistently and predictably.

{flowmark-0.6.2 → flowmark-0.6.3}/tests/testdocs/testdoc.expected.semantic.md

@@ -484,6 +484,7 @@ More line spacing challenges with multi-paragraph items:
   ```shell
   # Use z in place of cd: switch directories (first time):
   z ~/some/long/path/to/foo
+
   # Thereafter it's faster:
   z foo
   ```
@@ -1665,6 +1666,45 @@ Your feedback is valuable to us.
 
 {% /form %}
 
+## Strikethrough and Tildes
+
+Standard double-tilde ~~strikethrough~~ is the most common form and should always be
+preserved. Single-tilde ~~strikethrough~~ is also valid GFM and should be normalized to
+double tildes.
+
+Here are some ~~deleted words~~ in a sentence.
+And ~~more deleted words~~ in another sentence.
+
+Multiple ~~first~~ and ~~second~~ strikethroughs on one line work fine.
+
+### Tildes as "approximately" (not strikethrough)
+
+Tildes before numbers are commonly used to mean "approximately" and must not be treated
+as strikethrough:
+
+Target: ~60 seconds, ~130 words total
+
+The meeting lasted ~45 minutes.
+We had ~20 attendees.
+The cost was ~$500.
+
+Performance improved from ~200ms to ~50ms, a ~4x improvement.
+
+There were ~1,000 users and ~500 active sessions.
+
+### Escaped tildes
+
+Escaped tildes should be preserved: \~not strikethrough\~
+
+### Edge cases
+
+A lone tilde ~ in text is fine.
+
+Tildes at the end: the value is ~~100~~.
+
+A ~~long strikethrough that spans many words in a single paragraph and may get wrapped
+across lines during formatting~~ should be handled.
+
 ## Summary
 
 All these corner cases should format consistently and predictably.

{flowmark-0.6.2 → flowmark-0.6.3}/tests/testdocs/testdoc.orig.md

@@ -349,6 +349,7 @@ More line spacing challenges with multi-paragraph items:
   ```shell
   # Use z in place of cd: switch directories (first time):
   z ~/some/long/path/to/foo
+
   # Thereafter it's faster:
   z foo
   ```
@@ -1353,6 +1354,39 @@ Your feedback is valuable to us.
 
 {% /form %}
 
+## Strikethrough and Tildes
+
+Standard double-tilde ~~strikethrough~~ is the most common form and should always be preserved.
+Single-tilde ~strikethrough~ is also valid GFM and should be normalized to double tildes.
+
+Here are some ~~deleted words~~ in a sentence. And ~more deleted words~ in another sentence.
+
+Multiple ~~first~~ and ~~second~~ strikethroughs on one line work fine.
+
+### Tildes as "approximately" (not strikethrough)
+
+Tildes before numbers are commonly used to mean "approximately" and must not be treated as strikethrough:
+
+Target: ~60 seconds, ~130 words total
+
+The meeting lasted ~45 minutes. We had ~20 attendees. The cost was ~$500.
+
+Performance improved from ~200ms to ~50ms, a ~4x improvement.
+
+There were ~1,000 users and ~500 active sessions.
+
+### Escaped tildes
+
+Escaped tildes should be preserved: \~not strikethrough\~
+
+### Edge cases
+
+A lone tilde ~ in text is fine.
+
+Tildes at the end: the value is ~100~.
+
+A ~~long strikethrough that spans many words in a single paragraph and may get wrapped across lines during formatting~~ should be handled.
+
 ## Summary