rumdl 0.0.136__tar.gz → 0.0.138__tar.gz

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

@@ -7,6 +7,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.138] - 2025-09-05
+
+### Fixed
+- **LSP**: Fixed formatting to return empty array instead of null when no edits available (fixes #79)
+  - Helix editor now properly receives LSP formatting responses
+  - Added textDocument/rangeFormatting support for better editor compatibility
+  - Fixed critical position calculation bug that could cause incorrect text edit ranges
+
+## [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 +577,9 @@ 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.138...HEAD
+[0.0.138]: https://github.com/rvben/rumdl/compare/v0.0.137...v0.0.138
+[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.138}/Cargo.lock

@@ -1012,9 +1012,9 @@ dependencies = [
 
 [[package]]
 name = "js-sys"
-version = "0.3.77"
+version = "0.3.78"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1cfaf33c695fc6e08064efbc1f72ec937429614f25eef83af942d0e227c3a28f"
+checksum = "0c0b063578492ceec17683ef2f8c5e89121fbd0b172cbc280635ab7567db2738"
 dependencies = [
  "once_cell",
  "wasm-bindgen",
@@ -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.138"
 dependencies = [
  "anyhow",
  "assert_cmd",
@@ -2279,21 +2279,22 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.100"
+version = "0.2.101"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1edc8929d7499fc4e8f0be2262a241556cfc54a0bea223790e71446f2aab1ef5"
+checksum = "7e14915cadd45b529bb8d1f343c4ed0ac1de926144b746e2710f9cd05df6603b"
 dependencies = [
  "cfg-if",
  "once_cell",
  "rustversion",
  "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.100"
+version = "0.2.101"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f0a0651a5c2bc21487bde11ee802ccaf4c51935d0d3d42a6101f98161700bc6"
+checksum = "e28d1ba982ca7923fd01448d5c30c6864d0a14109560296a162f80f305fb93bb"
 dependencies = [
  "bumpalo",
  "log",
@@ -2305,9 +2306,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.100"
+version = "0.2.101"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fe63fc6d09ed3792bd0897b314f53de8e16568c2b3f7982f468c0bf9bd0b407"
+checksum = "7c3d463ae3eff775b0c45df9da45d68837702ac35af998361e2c84e7c5ec1b0d"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -2315,9 +2316,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.100"
+version = "0.2.101"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de"
+checksum = "7bb4ce89b08211f923caf51d527662b75bdc9c9c7aab40f86dcb9fb85ac552aa"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2328,18 +2329,18 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.100"
+version = "0.2.101"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a05d73b933a847d6cccdda8f838a22ff101ad9bf93e33684f39c1f5f0eece3d"
+checksum = "f143854a3b13752c6950862c906306adb27c7e839f7414cec8fea35beab624c1"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "web-sys"
-version = "0.3.77"
+version = "0.3.78"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33b6dd2ef9186f1f2072e409e99cd22a975331a6b3591b12c764e0e55c60d5d2"
+checksum = "77e4b637749ff0d92b8fad63aa1f7cff3cbe125fd49c175cd6345e7272638b12"
 dependencies = [
  "js-sys",
  "wasm-bindgen",

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

@@ -1,6 +1,6 @@
 [package]
 name = "rumdl"
-version = "0.0.136"
+version = "0.0.138"
 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.138}/PKG-INFO

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

{rumdl-0.0.136 → rumdl-0.0.138}/src/lsp/server.rs

@@ -160,9 +160,18 @@ impl RumdlLanguageServer {
 
     /// Get the end position of a document
     fn get_end_position(&self, text: &str) -> Position {
-        let lines: Vec<&str> = text.lines().collect();
-        let line = lines.len().saturating_sub(1) as u32;
-        let character = lines.last().map_or(0, |l| l.len() as u32);
+        let mut line = 0u32;
+        let mut character = 0u32;
+
+        for ch in text.chars() {
+            if ch == '\n' {
+                line += 1;
+                character = 0;
+            } else {
+                character += 1;
+            }
+        }
+
         Position { line, character }
     }
 
@@ -331,6 +340,7 @@ impl LanguageServer for RumdlLanguageServer {
                 text_document_sync: Some(TextDocumentSyncCapability::Kind(TextDocumentSyncKind::FULL)),
                 code_action_provider: Some(CodeActionProviderCapability::Simple(true)),
                 document_formatting_provider: Some(OneOf::Left(true)),
+                document_range_formatting_provider: Some(OneOf::Left(true)),
                 diagnostic_provider: Some(DiagnosticServerCapabilities::Options(DiagnosticOptions {
                     identifier: Some("rumdl".to_string()),
                     inter_file_dependencies: false,
@@ -489,22 +499,57 @@ impl LanguageServer for RumdlLanguageServer {
         }
     }
 
+    async fn range_formatting(&self, params: DocumentRangeFormattingParams) -> JsonRpcResult<Option<Vec<TextEdit>>> {
+        // For markdown linting, we format the entire document because:
+        // 1. Many markdown rules have document-wide implications (e.g., heading hierarchy, list consistency)
+        // 2. Fixes often need surrounding context to be applied correctly
+        // 3. This approach is common among linters (ESLint, rustfmt, etc. do similar)
+        log::debug!(
+            "Range formatting requested for {:?}, formatting entire document due to rule interdependencies",
+            params.range
+        );
+
+        let formatting_params = DocumentFormattingParams {
+            text_document: params.text_document,
+            options: params.options,
+            work_done_progress_params: params.work_done_progress_params,
+        };
+
+        self.formatting(formatting_params).await
+    }
+
     async fn formatting(&self, params: DocumentFormattingParams) -> JsonRpcResult<Option<Vec<TextEdit>>> {
         let uri = params.text_document.uri;
 
+        log::debug!("Formatting request for: {uri}");
+
         if let Some(text) = self.documents.read().await.get(&uri) {
+            // Get config with LSP overrides
+            let config_guard = self.config.read().await;
+            let lsp_config = config_guard.clone();
+            drop(config_guard);
+
             // Get all rules from config
             let rumdl_config = self.rumdl_config.read().await;
             let all_rules = rules::all_rules(&rumdl_config);
             let flavor = rumdl_config.markdown_flavor();
 
             // Use the standard filter_rules function which respects config's disabled rules
-            let filtered_rules = rules::filter_rules(&all_rules, &rumdl_config.global);
+            let mut filtered_rules = rules::filter_rules(&all_rules, &rumdl_config.global);
             drop(rumdl_config);
 
+            // Apply LSP config overrides
+            filtered_rules = self.apply_lsp_config_overrides(filtered_rules, &lsp_config);
+
             // Lint the document to get all warnings
             match crate::lint(text, &filtered_rules, false, flavor) {
                 Ok(warnings) => {
+                    log::debug!(
+                        "Found {} warnings, {} with fixes",
+                        warnings.len(),
+                        warnings.iter().filter(|w| w.fix.is_some()).count()
+                    );
+
                     // Check if there are any fixable warnings
                     let has_fixes = warnings.iter().any(|w| w.fix.is_some());
 
@@ -514,6 +559,7 @@ impl LanguageServer for RumdlLanguageServer {
                             Ok(fixed_content) => {
                                 // Only return edits if the content actually changed
                                 if fixed_content != *text {
+                                    log::debug!("Returning formatting edits");
                                     // Create a single TextEdit that replaces the entire document
                                     // Calculate proper end position by iterating through all characters
                                     let mut line = 0u32;
@@ -543,18 +589,23 @@ impl LanguageServer for RumdlLanguageServer {
                                 log::error!("Failed to apply fixes: {e}");
                             }
                         }
+                    } else {
+                        log::debug!("No fixes available for formatting");
                     }
 
-                    // No fixes available or applied
-                    Ok(None)
+                    // No fixes available or applied - return empty array
+                    Ok(Some(Vec::new()))
                 }
                 Err(e) => {
                     log::error!("Failed to format document: {e}");
-                    Ok(None)
+                    // Return empty array on error
+                    Ok(Some(Vec::new()))
                 }
             }
         } else {
-            Ok(None)
+            log::warn!("Document not found in cache: {uri}");
+            // Return empty array when document not found
+            Ok(Some(Vec::new()))
         }
     }
 
@@ -826,10 +877,10 @@ mod tests {
         assert_eq!(pos.line, 0);
         assert_eq!(pos.character, 0);
 
-        // Ends with newline - lines() doesn't include the empty line after \n
+        // Ends with newline - position should be at start of next line
         let pos = server.get_end_position("Hello\n");
-        assert_eq!(pos.line, 0);
-        assert_eq!(pos.character, 5);
+        assert_eq!(pos.line, 1);
+        assert_eq!(pos.character, 0);
     }
 
     #[tokio::test]

{rumdl-0.0.136 → rumdl-0.0.138}/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.138}/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.138}/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.138}/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.138}/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.138}/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)"
+    );
+}