rumdl 0.0.136__tar.gz → 0.0.137__tar.gz

{rumdl-0.0.136 → rumdl-0.0.137}/CHANGELOG.md

@@ -7,6 +7,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.137] - 2025-09-04
+
+### Fixed
+- **MD051**: Fixed GitHub anchor generation for headers with arrow patterns (fixes #82)
+  - Headers like `WAL->L0 Compaction` now correctly generate `#wal-l0-compaction` anchors
+  - Arrow patterns (`->`, `-->`) now convert to the correct number of hyphens based on surrounding spaces
+
 ## [0.0.136] - 2025-09-03
 
 ## [0.0.135] - 2025-09-03
@@ -562,7 +569,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Initial implementation of remaining rules for markdownlint parity
 
-[Unreleased]: https://github.com/rvben/rumdl/compare/v0.0.136...HEAD
+[Unreleased]: https://github.com/rvben/rumdl/compare/v0.0.137...HEAD
+[0.0.137]: https://github.com/rvben/rumdl/compare/v0.0.136...v0.0.137
 [0.0.136]: https://github.com/rvben/rumdl/compare/v0.0.135...v0.0.136
 [0.0.135]: https://github.com/rvben/rumdl/compare/v0.0.134...v0.0.135
 [0.0.134]: https://github.com/rvben/rumdl/compare/v0.0.133...v0.0.134

{rumdl-0.0.136 → rumdl-0.0.137}/Cargo.lock

@@ -1087,9 +1087,9 @@ dependencies = [
 
 [[package]]
 name = "log"
-version = "0.4.27"
+version = "0.4.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
+checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432"
 
 [[package]]
 name = "lsp-types"
@@ -1632,7 +1632,7 @@ checksum = "caf4aa5b0f434c91fe5c7f1ecb6a5ece2130b02ad2a590589dda5146df959001"
 
 [[package]]
 name = "rumdl"
-version = "0.0.136"
+version = "0.0.137"
 dependencies = [
  "anyhow",
  "assert_cmd",

{rumdl-0.0.136 → rumdl-0.0.137}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rumdl"
-version = "0.0.136"
+version = "0.0.137"
 edition = "2024"
 rust-version = "1.89.0"
 description = "A fast Markdown linter written in Rust (Ru(st) MarkDown Linter)"

{rumdl-0.0.136 → rumdl-0.0.137}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rumdl
-Version: 0.0.136
+Version: 0.0.137
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{rumdl-0.0.136 → rumdl-0.0.137}/src/rules/md013_line_length.rs

@@ -1027,6 +1027,32 @@ And a bullet list:
         }
     }
 
+    #[test]
+    fn test_issue_83_numbered_list_with_backticks() {
+        // Test for issue #83: enable_reflow was incorrectly handling numbered lists
+        let config = MD013Config {
+            line_length: 100,
+            reflow: true,
+            ..Default::default()
+        };
+        let rule = MD013LineLength::from_config_struct(config);
+
+        // The exact case from issue #83
+        let content = "1. List `manifest` to find the manifest with the largest ID. Say it's `00000000000000000002.manifest` in this example.";
+        let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Standard);
+
+        let fixed = rule.fix(&ctx).unwrap();
+
+        // The expected output: properly wrapped at 100 chars with correct list formatting
+        // After the fix, it correctly accounts for "1. " (3 chars) leaving 97 for content
+        let expected = "1. List `manifest` to find the manifest with the largest ID. Say it's\n   `00000000000000000002.manifest` in this example.";
+
+        assert_eq!(
+            fixed, expected,
+            "List should be properly reflowed with correct marker and indentation.\nExpected:\n{expected}\nGot:\n{fixed}"
+        );
+    }
+
     #[test]
     fn test_text_reflow_disabled_by_default() {
         let rule = MD013LineLength::new(30, false, false, false, false);

{rumdl-0.0.136 → rumdl-0.0.137}/src/utils/anchor_styles/github.rs

@@ -157,15 +157,33 @@ fn heading_to_fragment_internal(heading: &str) -> String {
 
     // Step 6: Multi-character arrow patterns (order matters!)
     // GitHub.com converts these patterns to specific hyphen sequences
-    // Handle patterns with spaces to avoid double-processing spaces
-    text = text.replace(" --> ", "----"); // space + arrow + space = 4 hyphens total
-    text = text.replace("-->", "----"); // 4 hyphens when no surrounding spaces
-    text = text.replace(" <-> ", "---"); // space + arrow + space = 3 hyphens total
-    text = text.replace("<->", "---"); // 3 hyphens when no surrounding spaces
-    text = text.replace(" ==> ", "--"); // space + arrow + space = 2 hyphens total
-    text = text.replace("==>", "--"); // 2 hyphens when no surrounding spaces
-    text = text.replace(" -> ", "---"); // space + arrow + space = 3 hyphens total
-    text = text.replace("->", "---"); // 3 hyphens when no surrounding spaces
+    // Verified against GitHub.com actual behavior (issue #82)
+    // Pattern: arrow itself becomes N hyphens, each adjacent space adds 1 more
+    // Must handle patterns with most spaces first to avoid partial replacements
+
+    // --> patterns (arrow = 2 hyphens base)
+    text = text.replace(" --> ", "----"); // 2 + 1 + 1 = 4 hyphens
+    text = text.replace(" -->", "---"); // 2 + 1 = 3 hyphens
+    text = text.replace("--> ", "---"); // 2 + 1 = 3 hyphens
+    text = text.replace("-->", "--"); // 2 hyphens
+
+    // <-> patterns (assuming similar pattern, needs verification)
+    text = text.replace(" <-> ", "---"); // estimated: 1 + 1 + 1 = 3 hyphens
+    text = text.replace(" <->", "--"); // estimated: 1 + 1 = 2 hyphens
+    text = text.replace("<-> ", "--"); // estimated: 1 + 1 = 2 hyphens
+    text = text.replace("<->", "-"); // estimated: 1 hyphen
+
+    // ==> patterns (assuming similar pattern, needs verification)
+    text = text.replace(" ==> ", "--"); // estimated pattern
+    text = text.replace(" ==>", "-"); // estimated pattern
+    text = text.replace("==> ", "-"); // estimated pattern
+    text = text.replace("==>", ""); // estimated: might be removed entirely
+
+    // -> patterns (arrow = 1 hyphen base)
+    text = text.replace(" -> ", "---"); // 1 + 1 + 1 = 3 hyphens
+    text = text.replace(" ->", "--"); // 1 + 1 = 2 hyphens
+    text = text.replace("-> ", "--"); // 1 + 1 = 2 hyphens
+    text = text.replace("->", "-"); // 1 hyphen
 
     // Step 7: Remove problematic characters before symbol replacement
     // First remove em-dashes and en-dashes entirely
@@ -899,6 +917,33 @@ mod tests {
         assert_eq!(result, "cbrown----sbrown---unsafe-paths");
     }
 
+    #[test]
+    fn test_github_arrow_patterns_issue_82() {
+        // Test cases for issue #82 - verified against GitHub.com actual behavior
+        // Pattern: arrow itself becomes N hyphens, each adjacent space adds 1 more
+
+        // Single arrow (->) patterns
+        assert_eq!(heading_to_fragment("WAL->L0 Compaction"), "wal-l0-compaction");
+        assert_eq!(heading_to_fragment("foo->bar->baz"), "foo-bar-baz");
+        assert_eq!(heading_to_fragment("a->b"), "a-b");
+        assert_eq!(heading_to_fragment("a ->b"), "a--b");
+        assert_eq!(heading_to_fragment("a-> b"), "a--b");
+        assert_eq!(heading_to_fragment("a -> b"), "a---b");
+
+        // Double arrow (-->) patterns
+        assert_eq!(heading_to_fragment("a-->b"), "a--b");
+        assert_eq!(heading_to_fragment("a -->b"), "a---b");
+        assert_eq!(heading_to_fragment("a--> b"), "a---b");
+        assert_eq!(heading_to_fragment("a --> b"), "a----b");
+
+        // Mixed patterns
+        assert_eq!(heading_to_fragment("cbrown -> sbrown"), "cbrown---sbrown");
+        assert_eq!(
+            heading_to_fragment("cbrown --> sbrown: --unsafe-paths"),
+            "cbrown----sbrown---unsafe-paths"
+        );
+    }
+
     #[test]
     fn test_security_performance_edge_cases() {
         // Test performance with edge cases that could cause issues

{rumdl-0.0.136 → rumdl-0.0.137}/src/utils/text_reflow.rs

@@ -629,20 +629,52 @@ pub fn reflow_markdown(content: &str, options: &ReflowOptions) -> String {
             let indent = line.len() - line.trim_start().len();
             let indent_str = " ".repeat(indent);
 
-            // Find where the content starts after the marker
-            let content_start = line
-                .find(|c: char| !(c.is_whitespace() || c == '-' || c == '*' || c == '+' || c == '.' || c.is_numeric()))
-                .unwrap_or(line.len());
+            // For numbered lists, find the period and the space after it
+            // For bullet lists, find the marker and the space after it
+            let mut marker_end = indent;
+            let mut content_start = indent;
+
+            if trimmed.chars().next().is_some_and(|c| c.is_numeric()) {
+                // Numbered list: find the period
+                if let Some(period_pos) = line[indent..].find('.') {
+                    marker_end = indent + period_pos + 1; // Include the period
+                    content_start = marker_end;
+                    // Skip any spaces after the period to find content start
+                    while content_start < line.len() && line.chars().nth(content_start) == Some(' ') {
+                        content_start += 1;
+                    }
+                }
+            } else {
+                // Bullet list: marker is single character
+                marker_end = indent + 1; // Just the marker character
+                content_start = marker_end;
+                // Skip any spaces after the marker
+                while content_start < line.len() && line.chars().nth(content_start) == Some(' ') {
+                    content_start += 1;
+                }
+            }
 
-            let marker = &line[indent..content_start];
-            let content = &line[content_start..].trim_start();
+            let marker = &line[indent..marker_end];
+            let content = &line[content_start..];
 
             // Calculate the proper indentation for continuation lines
             // We need to align with the text after the marker
-            let trimmed_marker = marker.trim_end();
-            let continuation_spaces = indent + trimmed_marker.len() + 1; // +1 for the space after marker
+            let trimmed_marker = marker;
+            let continuation_spaces = content_start; // Use the actual content start position
+
+            // CRITICAL: Adjust line length to account for list marker and space
+            // For the first line, we need to account for: indent + marker + space
+            // The format is: "{indent_str}{trimmed_marker} {content}"
+            // So available width = line_length - indent - marker_length - 1 (for space)
+            let prefix_length = indent + trimmed_marker.len() + 1; // +1 for space after marker
+
+            // Create adjusted options with reduced line length
+            let adjusted_options = ReflowOptions {
+                line_length: options.line_length.saturating_sub(prefix_length),
+                ..options.clone()
+            };
 
-            let reflowed = reflow_line(content, options);
+            let reflowed = reflow_line(content, &adjusted_options);
             for (j, reflowed_line) in reflowed.iter().enumerate() {
                 if j == 0 {
                     result.push(format!("{indent_str}{trimmed_marker} {reflowed_line}"));
@@ -1063,4 +1095,60 @@ mod tests {
             }
         }
     }
+
+    #[test]
+    fn test_reflow_markdown_numbered_lists() {
+        // Test for issue #83: numbered lists with proper formatting
+        let options = ReflowOptions {
+            line_length: 50,
+            ..Default::default()
+        };
+
+        let content = r#"1. List `manifest` to find the manifest with the largest ID. Say it's `00000000000000000002.manifest` in this example.
+2. Short item
+3. Another long item that definitely exceeds the fifty character limit and needs wrapping"#;
+
+        let result = reflow_markdown(content, &options);
+
+        // Define exact expected output
+        let expected = r#"1. List `manifest` to find the manifest with the
+   largest ID. Say it's
+   `00000000000000000002.manifest` in this
+   example.
+2. Short item
+3. Another long item that definitely exceeds the
+   fifty character limit and needs wrapping"#;
+
+        assert_eq!(
+            result, expected,
+            "Numbered lists should be reflowed with proper markers and indentation.\nExpected:\n{expected}\nGot:\n{result}"
+        );
+    }
+
+    #[test]
+    fn test_reflow_markdown_bullet_lists() {
+        let options = ReflowOptions {
+            line_length: 40,
+            ..Default::default()
+        };
+
+        let content = r#"- First bullet point with a very long line that needs wrapping
+* Second bullet using asterisk
++ Third bullet using plus sign
+- Short one"#;
+
+        let result = reflow_markdown(content, &options);
+
+        // Define exact expected output - each bullet type preserved with proper indentation
+        let expected = r#"- First bullet point with a very long
+  line that needs wrapping
+* Second bullet using asterisk
++ Third bullet using plus sign
+- Short one"#;
+
+        assert_eq!(
+            result, expected,
+            "Bullet lists should preserve markers and indent continuations with 2 spaces.\nExpected:\n{expected}\nGot:\n{result}"
+        );
+    }
 }

{rumdl-0.0.136 → rumdl-0.0.137}/tests/rules/md051_regression_prevention_test.rs

@@ -94,10 +94,10 @@ fn regression_test_historical_patterns() {
         ("A&B", "ab"),
         ("A & B", "a--b"),
         ("A & B & C", "a--b--c"),
-        // Arrow issues - updated to match GitHub behavior (arrows -> multiple hyphens)
-        ("A->B", "a---b"),
-        ("A -> B", "a---b"),
-        ("A --> B", "a----b"),
+        // Arrow issues - updated for issue #82 fix (correct GitHub behavior)
+        ("A->B", "a-b"),       // Fixed: -> now correctly becomes single hyphen
+        ("A -> B", "a---b"),   // Spaces preserved: space+arrow+space = 3 hyphens
+        ("A --> B", "a----b"), // Spaces preserved: space+double-arrow+space = 4 hyphens
         // Colon issues
         ("Title:Subtitle", "titlesubtitle"),
         ("Title: Subtitle", "title-subtitle"),

{rumdl-0.0.136 → rumdl-0.0.137}/tests/rules/md051_test.rs

@@ -1795,3 +1795,38 @@ Table of contents:
     // All links should be valid - no errors
     assert_eq!(result.len(), 0, "All HTML anchor links should be valid");
 }
+
+#[test]
+fn test_issue_82_arrow_patterns() {
+    // Test for issue #82 - headers with arrows should generate correct anchors
+    let content = r#"# Document
+
+## Table of Contents
+- [WAL->L0 Compaction](#wal-l0-compaction)
+- [foo->bar->baz](#foo-bar-baz)
+- [Header->with->Arrows](#header-with-arrows)
+
+## WAL->L0 Compaction
+
+Content about WAL to L0 compaction.
+
+## foo->bar->baz
+
+Content about foo bar baz.
+
+## Header->with->Arrows
+
+Content with arrows.
+"#;
+
+    let rule = MD051LinkFragments::new();
+    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard);
+    let result = rule.check(&ctx).unwrap();
+
+    // All links should be valid with the fixed arrow pattern handling
+    assert_eq!(
+        result.len(),
+        0,
+        "Arrow patterns in headers should generate correct anchors (issue #82)"
+    );
+}

{rumdl-0.0.136 → rumdl-0.0.137}/tests/rules/md052_test.rs

@@ -632,3 +632,28 @@ fn test_undefined_reference_with_nested_brackets() {
     assert_eq!(result.len(), 1);
     assert!(result[0].message.contains("`Dict[str, Any]`"));
 }
+
+#[test]
+fn test_issue_81_toml_code_block_not_parsed() {
+    // Test for issue #81 - TOML code blocks should not be parsed for references
+    let rule = MD052ReferenceLinkImages::new();
+    let content = r#"## Adding new examples
+
+1. Create a new Rust file under `src`.
+2. Add the binary definition to the `Cargo.toml` file, the list is ordered alphabetically by example name:
+
+    ```toml
+    [[bin]]
+    name = "tracing-subscriber"
+    path = "src/tracing_subscriber.rs"
+    test = false
+    ```
+
+3. Add any required dependencies to the `Cargo.toml` file."#;
+    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard);
+    let result = rule.check(&ctx).unwrap();
+    assert!(
+        result.is_empty(),
+        "Should not flag [[bin]] in TOML code block as undefined reference (issue #81)"
+    );
+}