rumdl 0.0.122__tar.gz → 0.0.123__tar.gz

{rumdl-0.0.122 → rumdl-0.0.123}/CHANGELOG.md

@@ -7,6 +7,30 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.123] - 2025-08-21
+
+## [0.0.123] - 2025-08-21
+
+### Added
+- **MD013**: Comprehensive markdown pattern preservation during text reflow
+  - Preserves reference links, footnotes, math formulas, wiki links, and more
+  - Centralized regex patterns for better maintainability
+
+### Fixed
+- **CLI**: Correct unfixable rules status display and fix counts (closes #56)
+  - Rules marked as unfixable now show `[unfixable]` in yellow instead of `[fixed]`
+  - Fix count now correctly excludes unfixable rules (e.g., "3 of 6" instead of "6 of 6")
+  - Added FixCapability enum to Rule trait for compile-time safety
+- **MD013**: Preserve reference links during text reflow
+  - Reference-style links are now properly preserved when reflowing text
+  - Fixed indicator display to correctly show `[fixed]` when issues are resolved
+- **Tests**: Mark kramdown definition list doctest as text to fix test failures
+
+### Changed
+- **Internal**: Centralized markdown pattern regexes and extended reflow support
+  - Improved code organization and reduced duplication
+  - Better performance through shared regex compilation
+
 ## [0.0.122] - 2025-08-19
 
 ## [0.0.121] - 2025-08-19
@@ -372,7 +396,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.122...HEAD
+[Unreleased]: https://github.com/rvben/rumdl/compare/v0.0.123...HEAD
+[0.0.123]: https://github.com/rvben/rumdl/compare/v0.0.122...v0.0.123
 [0.0.122]: https://github.com/rvben/rumdl/compare/v0.0.121...v0.0.122
 [0.0.121]: https://github.com/rvben/rumdl/compare/v0.0.120...v0.0.121
 [0.0.120]: https://github.com/rvben/rumdl/compare/v0.0.119...v0.0.120

{rumdl-0.0.122 → rumdl-0.0.123}/Cargo.lock

@@ -530,9 +530,9 @@ checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
 [[package]]
 name = "form_urlencoded"
-version = "1.2.1"
+version = "1.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e13624c2627564efccf4934284bdd98cbaa14e79b0b5a141218e507b3a823456"
+checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
 dependencies = [
  "percent-encoding",
 ]
@@ -806,9 +806,9 @@ dependencies = [
 
 [[package]]
 name = "idna"
-version = "1.0.3"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "686f825264d630750a544639377bae737628043f20d38bbc029e8f29ea968a7e"
+checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"
 dependencies = [
  "idna_adapter",
  "smallvec",
@@ -1126,9 +1126,9 @@ dependencies = [
 
 [[package]]
 name = "percent-encoding"
-version = "2.3.1"
+version = "2.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"
+checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
 
 [[package]]
 name = "pin-project"
@@ -1493,7 +1493,7 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "rumdl"
-version = "0.0.122"
+version = "0.0.123"
 dependencies = [
  "anyhow",
  "assert_cmd",
@@ -1751,15 +1751,15 @@ checksum = "e502f78cdbb8ba4718f566c418c52bc729126ffd16baee5baa718cf25dd5a69a"
 
 [[package]]
 name = "tempfile"
-version = "3.20.0"
+version = "3.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8a64e3985349f2441a1a9ef0b853f869006c3855f2cda6862a94d26ebb9d6a1"
+checksum = "15b61f8f20e3a6f7e0649d825294eaf317edce30f82cf6026e7e4cb9222a7d1e"
 dependencies = [
  "fastrand",
  "getrandom",
  "once_cell",
  "rustix",
- "windows-sys 0.59.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -1770,18 +1770,18 @@ checksum = "8f50febec83f5ee1df3015341d8bd429f2d1cc62bcba7ea2076759d315084683"
 
 [[package]]
 name = "thiserror"
-version = "2.0.15"
+version = "2.0.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "80d76d3f064b981389ecb4b6b7f45a0bf9fdac1d5b9204c7bd6714fecc302850"
+checksum = "3467d614147380f2e4e374161426ff399c91084acd2363eaf549172b3d5e60c0"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "2.0.15"
+version = "2.0.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44d29feb33e986b6ea906bd9c3559a856983f92371b3eaa5e83782a351623de0"
+checksum = "6c5e1be1c48b9172ee610da68fd9cd2770e7a4056cb3fc98710ee6906f0c7960"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2080,9 +2080,9 @@ checksum = "673aac59facbab8a9007c7f6108d11f63b603f7cabff99fabf650fea5c32b861"
 
 [[package]]
 name = "url"
-version = "2.5.4"
+version = "2.5.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32f8b686cadd1473f4bd0117a5d28d36b1ade384ea9b5069a1c40aefed7fda60"
+checksum = "137a3c834eaf7139b73688502f3f1141a0337c5d8e4d9b536f9b8c796e26a7c4"
 dependencies = [
  "form_urlencoded",
  "idna",
@@ -2206,11 +2206,11 @@ dependencies = [
 
 [[package]]
 name = "winapi-util"
-version = "0.1.9"
+version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
+checksum = "0978bf7171b3d90bac376700cb56d606feb40f251a475a5d6634613564460b22"
 dependencies = [
- "windows-sys 0.59.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]

{rumdl-0.0.122 → rumdl-0.0.123}/Cargo.toml

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

{rumdl-0.0.122 → rumdl-0.0.123}/PKG-INFO

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

{rumdl-0.0.122 → rumdl-0.0.123}/src/main.rs

@@ -2355,6 +2355,26 @@ fn print_statistics(warnings: &[rumdl::rule::LintWarning]) {
     );
 }
 
+// Helper function to check if a rule is actually fixable based on configuration
+fn is_rule_actually_fixable(config: &rumdl_config::Config, rule_name: &str) -> bool {
+    // Check unfixable list
+    if config
+        .global
+        .unfixable
+        .iter()
+        .any(|r| r.eq_ignore_ascii_case(rule_name))
+    {
+        return false;
+    }
+
+    // Check fixable list if specified
+    if !config.global.fixable.is_empty() {
+        return config.global.fixable.iter().any(|r| r.eq_ignore_ascii_case(rule_name));
+    }
+
+    true
+}
+
 // Process file with output formatter
 #[allow(clippy::too_many_arguments)]
 fn process_file_with_formatter(
@@ -2371,7 +2391,7 @@ fn process_file_with_formatter(
 
     // Call the original process_file_inner to get warnings
     let (all_warnings, mut content, total_warnings, fixable_warnings) =
-        process_file_inner(file_path, rules, verbose, quiet);
+        process_file_inner(file_path, rules, verbose, quiet, config);
 
     if total_warnings == 0 {
         return (false, 0, 0, 0, Vec::new());
@@ -2408,14 +2428,25 @@ fn process_file_with_formatter(
             // Create a custom formatter that shows [fixed] instead of [*]
             let mut output = String::new();
             for warning in &all_warnings {
+                let rule_name = warning.rule_name.unwrap_or("unknown");
+
+                // Check if the rule is actually fixable based on configuration
+                let is_fixable = is_rule_actually_fixable(config, rule_name);
+
                 let was_fixed = warning.fix.is_some()
+                    && is_fixable
                     && !remaining_warnings.iter().any(|w| {
                         w.line == warning.line && w.column == warning.column && w.rule_name == warning.rule_name
                     });
 
-                let rule_name = warning.rule_name.unwrap_or("unknown");
-                let fix_indicator = if was_fixed {
-                    " [fixed]".green().to_string()
+                let fix_indicator = if warning.fix.is_some() {
+                    if !is_fixable {
+                        " [unfixable]".yellow().to_string()
+                    } else if was_fixed {
+                        " [fixed]".green().to_string()
+                    } else {
+                        String::new()
+                    }
                 } else {
                     String::new()
                 };
@@ -2454,6 +2485,7 @@ fn process_file_inner(
     rules: &[Box<dyn Rule>],
     verbose: bool,
     quiet: bool,
+    config: &rumdl_config::Config,
 ) -> (Vec<rumdl::rule::LintWarning>, String, usize, usize) {
     use std::time::Instant;
 
@@ -2507,8 +2539,11 @@ fn process_file_inner(
 
     let total_warnings = all_warnings.len();
 
-    // Count fixable issues
-    let fixable_warnings = all_warnings.iter().filter(|w| w.fix.is_some()).count();
+    // Count fixable issues (excluding unfixable rules)
+    let fixable_warnings = all_warnings
+        .iter()
+        .filter(|w| w.fix.is_some() && w.rule_name.is_some_and(|name| is_rule_actually_fixable(config, name)))
+        .count();
 
     let lint_end_time = Instant::now();
     let lint_time = lint_end_time.duration_since(lint_start);

{rumdl-0.0.122 → rumdl-0.0.123}/src/rule.rs

@@ -81,6 +81,17 @@ pub enum RuleCategory {
     Other,
 }
 
+/// Capability of a rule to fix issues
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum FixCapability {
+    /// Rule can automatically fix all violations it detects
+    FullyFixable,
+    /// Rule can fix some violations based on context
+    ConditionallyFixable,
+    /// Rule cannot fix violations (by design)
+    Unfixable,
+}
+
 /// Remove marker /// TRAIT_MARKER_V1
 pub trait Rule: DynClone + Send + Sync {
     fn name(&self) -> &'static str;
@@ -148,6 +159,11 @@ pub trait Rule: DynClone + Send + Sync {
         None
     }
 
+    /// Declares the fix capability of this rule
+    fn fix_capability(&self) -> FixCapability {
+        FixCapability::FullyFixable // Safe default for backward compatibility
+    }
+
     /// Factory: create a rule from config (if present), or use defaults.
     fn from_config(_config: &crate::config::Config) -> Box<dyn Rule>
     where

{rumdl-0.0.122 → rumdl-0.0.123}/src/rules/md013_line_length.rs

@@ -209,9 +209,6 @@ impl Rule for MD013LineLength {
             content.lines().collect()
         };
 
-        // Pre-compute LineIndex for efficient byte range calculations
-        let line_index = crate::utils::range_utils::LineIndex::new(content.to_string());
-
         // Create a quick lookup set for heading lines
         let heading_lines_set: std::collections::HashSet<usize> = structure.heading_lines.iter().cloned().collect();
 
@@ -309,40 +306,19 @@ impl Rule for MD013LineLength {
                 }
             }
 
-            // Generate simplified fix (avoid expensive sentence splitting for now)
-            let fix = if !self.should_skip_line_for_fix(line, line_num, structure) {
-                // First try trimming trailing whitespace
-                let last_char = line.chars().last();
-                if last_char == Some(' ') || last_char == Some('\t') {
-                    let trimmed = line.trim_end();
-                    // Calculate trimmed length to avoid re-scanning
-                    let trimmed_len = self.calculate_effective_length(trimmed);
-                    if trimmed_len <= line_limit {
-                        let line_start = line_index.line_col_to_byte_range(line_number, 1).start;
-                        let line_end = if line_number < lines.len() {
-                            line_index.line_col_to_byte_range(line_number + 1, 1).start - 1
-                        } else {
-                            content.len()
-                        };
-                        Some(crate::rule::Fix {
-                            range: line_start..line_end,
-                            replacement: trimmed.to_string(),
-                        })
-                    } else {
-                        None
-                    }
-                } else {
-                    None // Skip expensive sentence splitting for performance
-                }
+            // Only provide a fix if reflow is enabled
+            let fix = if self.config.enable_reflow && !self.should_skip_line_for_fix(line, line_num, structure) {
+                // Provide a placeholder fix to indicate that reflow will happen
+                // The actual reflow is done in the fix() method
+                Some(crate::rule::Fix {
+                    range: 0..0,                // Placeholder range
+                    replacement: String::new(), // Placeholder replacement
+                })
             } else {
                 None
             };
 
-            let message = if let Some(ref _fix_obj) = fix {
-                format!("Line length {effective_length} exceeds {line_limit} characters (can trim whitespace)")
-            } else {
-                format!("Line length {effective_length} exceeds {line_limit} characters")
-            };
+            let message = format!("Line length {effective_length} exceeds {line_limit} characters");
 
             // Calculate precise character range for the excess portion
             let (start_line, start_col, end_line, end_col) = calculate_excess_range(line_number, line, line_limit);
@@ -362,7 +338,7 @@ impl Rule for MD013LineLength {
     }
 
     fn fix(&self, ctx: &crate::lint_context::LintContext) -> Result<String, LintError> {
-        // If reflow is enabled, use the new text reflow functionality
+        // Only fix if reflow is enabled
         if self.config.enable_reflow {
             let reflow_options = crate::utils::text_reflow::ReflowOptions {
                 line_length: self.config.line_length,
@@ -373,50 +349,8 @@ impl Rule for MD013LineLength {
             return Ok(crate::utils::text_reflow::reflow_markdown(ctx.content, &reflow_options));
         }
 
-        // Otherwise, use the existing fix logic (trimming whitespace)
-        // Get all warnings with their fixes
-        let warnings = self.check(ctx)?;
-
-        // If no warnings, return original content without allocation
-        if warnings.is_empty() {
-            return Ok(ctx.content.to_string());
-        }
-
-        // Collect all fixes - check if any exist before allocating
-        let mut has_any_fix = false;
-        for w in &warnings {
-            if w.fix.is_some() {
-                has_any_fix = true;
-                break;
-            }
-        }
-
-        if !has_any_fix {
-            return Ok(ctx.content.to_string());
-        }
-
-        // Now collect fixes since we know there's at least one
-        let mut fixes: Vec<_> = warnings
-            .iter()
-            .filter_map(|w| w.fix.as_ref().map(|f| (f.range.start, f.range.end, &f.replacement)))
-            .collect();
-
-        // This should not happen given our check above, but just in case
-        if fixes.is_empty() {
-            return Ok(ctx.content.to_string());
-        }
-
-        fixes.sort_by(|a, b| b.0.cmp(&a.0));
-
-        // Apply fixes from end to beginning to preserve byte offsets
-        let mut result = ctx.content.to_string();
-        for (start, end, replacement) in fixes {
-            if start < result.len() && end <= result.len() && start <= end {
-                result.replace_range(start..end, replacement);
-            }
-        }
-
-        Ok(result)
+        // Without reflow, MD013 has no fixes available
+        Ok(ctx.content.to_string())
     }
 
     fn as_any(&self) -> &dyn std::any::Any {
@@ -753,20 +687,19 @@ mod tests {
     }
 
     #[test]
-    fn test_trailing_whitespace_fix() {
+    fn test_no_fix_without_reflow() {
         let rule = MD013LineLength::new(60, false, false, false, false);
         let content = "This line has trailing whitespace that makes it too long      ";
         let ctx = LintContext::new(content);
         let result = rule.check(&ctx).unwrap();
 
         assert_eq!(result.len(), 1);
-        // The line without spaces is 56 chars, within limit of 60
-        assert!(result[0].fix.is_some());
-        assert!(result[0].message.contains("can trim whitespace"));
+        // Without enable_reflow, no fix is provided
+        assert!(result[0].fix.is_none());
 
-        // Apply fix
+        // Fix method returns content unchanged
         let fixed = rule.fix(&ctx).unwrap();
-        assert_eq!(fixed.trim(), "This line has trailing whitespace that makes it too long");
+        assert_eq!(fixed, content);
     }
 
     #[test]
@@ -841,15 +774,14 @@ Another long line that should trigger a warning."#;
     }
 
     #[test]
-    fn test_fix_preserves_content() {
+    fn test_fix_without_reflow_preserves_content() {
         let rule = MD013LineLength::new(50, false, false, false, false);
         let content = "Line 1\nThis line has trailing spaces and is too long      \nLine 3";
         let ctx = LintContext::new(content);
 
+        // Without enable_reflow, content is unchanged
         let fixed = rule.fix(&ctx).unwrap();
-        assert!(fixed.contains("Line 1"));
-        assert!(fixed.contains("Line 3"));
-        assert!(!fixed.contains("      \n")); // Trailing spaces removed
+        assert_eq!(fixed, content);
     }
 
     #[test]
@@ -1105,4 +1037,173 @@ And a bullet list:
         // Since there's no trailing whitespace, content should be unchanged
         assert_eq!(fixed, content);
     }
+
+    #[test]
+    fn test_reflow_with_hard_line_breaks() {
+        // Test that lines with exactly 2 trailing spaces are preserved as hard breaks
+        let config = MD013Config {
+            line_length: 40,
+            enable_reflow: true,
+            ..Default::default()
+        };
+        let rule = MD013LineLength::from_config_struct(config);
+
+        // Test with exactly 2 spaces (hard line break)
+        let content = "This line has a hard break at the end  \nAnd this continues on the next line that is also quite long and needs wrapping";
+        let ctx = LintContext::new(content);
+        let fixed = rule.fix(&ctx).unwrap();
+
+        // Should preserve the hard line break (2 spaces)
+        assert!(
+            fixed.contains("  \n"),
+            "Hard line break with exactly 2 spaces should be preserved"
+        );
+    }
+
+    #[test]
+    fn test_reflow_preserves_reference_links() {
+        let config = MD013Config {
+            line_length: 40,
+            enable_reflow: true,
+            ..Default::default()
+        };
+        let rule = MD013LineLength::from_config_struct(config);
+
+        let content = "This is a very long line with a [reference link][ref] that should not be broken apart when reflowing the text.
+
+[ref]: https://example.com";
+        let ctx = LintContext::new(content);
+        let fixed = rule.fix(&ctx).unwrap();
+
+        // Reference link should remain intact
+        assert!(fixed.contains("[reference link][ref]"));
+        assert!(!fixed.contains("[ reference link]"));
+        assert!(!fixed.contains("[ref ]"));
+    }
+
+    #[test]
+    fn test_reflow_with_nested_markdown_elements() {
+        let config = MD013Config {
+            line_length: 35,
+            enable_reflow: true,
+            ..Default::default()
+        };
+        let rule = MD013LineLength::from_config_struct(config);
+
+        let content = "This text has **bold with `code` inside** and should handle it properly when wrapping";
+        let ctx = LintContext::new(content);
+        let fixed = rule.fix(&ctx).unwrap();
+
+        // Nested elements should be preserved
+        assert!(fixed.contains("**bold with `code` inside**"));
+    }
+
+    #[test]
+    fn test_reflow_with_unbalanced_markdown() {
+        // Test edge case with unbalanced markdown
+        let config = MD013Config {
+            line_length: 30,
+            enable_reflow: true,
+            ..Default::default()
+        };
+        let rule = MD013LineLength::from_config_struct(config);
+
+        let content = "This has **unbalanced bold that goes on for a very long time without closing";
+        let ctx = LintContext::new(content);
+        let fixed = rule.fix(&ctx).unwrap();
+
+        // Should handle gracefully without panic
+        // The text reflow handles unbalanced markdown by treating it as a bold element
+        // Check that the content is properly reflowed without panic
+        assert!(!fixed.is_empty());
+        // Verify the content is wrapped to 30 chars
+        for line in fixed.lines() {
+            assert!(line.len() <= 30 || line.starts_with("**"), "Line exceeds limit: {line}");
+        }
+    }
+
+    #[test]
+    fn test_reflow_fix_indicator() {
+        // Test that enable_reflow provides fix indicators
+        let config = MD013Config {
+            line_length: 30,
+            enable_reflow: true,
+            ..Default::default()
+        };
+        let rule = MD013LineLength::from_config_struct(config);
+
+        let content = "This is a very long line that definitely exceeds the thirty character limit";
+        let ctx = LintContext::new(content);
+        let warnings = rule.check(&ctx).unwrap();
+
+        // Should have a fix indicator when enable_reflow is true
+        assert!(!warnings.is_empty());
+        assert!(
+            warnings[0].fix.is_some(),
+            "Should provide fix indicator when enable_reflow is true"
+        );
+    }
+
+    #[test]
+    fn test_no_fix_indicator_without_reflow() {
+        // Test that without enable_reflow, no fix is provided
+        let config = MD013Config {
+            line_length: 30,
+            enable_reflow: false,
+            ..Default::default()
+        };
+        let rule = MD013LineLength::from_config_struct(config);
+
+        let content = "This is a very long line that definitely exceeds the thirty character limit";
+        let ctx = LintContext::new(content);
+        let warnings = rule.check(&ctx).unwrap();
+
+        // Should NOT have a fix indicator when enable_reflow is false
+        assert!(!warnings.is_empty());
+        assert!(
+            warnings[0].fix.is_none(),
+            "Should not provide fix when enable_reflow is false"
+        );
+    }
+
+    #[test]
+    fn test_reflow_preserves_all_reference_link_types() {
+        let config = MD013Config {
+            line_length: 40,
+            enable_reflow: true,
+            ..Default::default()
+        };
+        let rule = MD013LineLength::from_config_struct(config);
+
+        let content = "Test [full reference][ref] and [collapsed][] and [shortcut] reference links in a very long line.
+
+[ref]: https://example.com
+[collapsed]: https://example.com
+[shortcut]: https://example.com";
+
+        let ctx = LintContext::new(content);
+        let fixed = rule.fix(&ctx).unwrap();
+
+        // All reference link types should be preserved
+        assert!(fixed.contains("[full reference][ref]"));
+        assert!(fixed.contains("[collapsed][]"));
+        assert!(fixed.contains("[shortcut]"));
+    }
+
+    #[test]
+    fn test_reflow_handles_images_correctly() {
+        let config = MD013Config {
+            line_length: 40,
+            enable_reflow: true,
+            ..Default::default()
+        };
+        let rule = MD013LineLength::from_config_struct(config);
+
+        let content = "This line has an ![image alt text](https://example.com/image.png) that should not be broken when reflowing.";
+        let ctx = LintContext::new(content);
+        let fixed = rule.fix(&ctx).unwrap();
+
+        // Image should remain intact
+        assert!(fixed.contains("![image alt text](https://example.com/image.png)"));
+    }
 }

{rumdl-0.0.122 → rumdl-0.0.123}/src/rules/md033_no_inline_html.rs

@@ -425,6 +425,10 @@ impl Rule for MD033NoInlineHtml {
         Ok(ctx.content.to_string())
     }
 
+    fn fix_capability(&self) -> crate::rule::FixCapability {
+        crate::rule::FixCapability::Unfixable
+    }
+
     /// Get the category of this rule for selective processing
     fn category(&self) -> RuleCategory {
         RuleCategory::Html

{rumdl-0.0.122 → rumdl-0.0.123}/src/rules/md052_reference_links_images.rs

@@ -1,8 +1,7 @@
 use crate::rule::{LintError, LintResult, LintWarning, Rule, Severity};
 use crate::utils::range_utils::calculate_match_range;
-use crate::utils::regex_cache::HTML_COMMENT_PATTERN;
+use crate::utils::regex_cache::{HTML_COMMENT_PATTERN, SHORTCUT_REF_REGEX};
 use crate::utils::skip_context::{is_in_front_matter, is_in_math_context, is_in_table_cell};
-use fancy_regex::Regex as FancyRegex;
 use lazy_static::lazy_static;
 use regex::Regex;
 use std::collections::{HashMap, HashSet};
@@ -12,21 +11,6 @@ lazy_static! {
     // Note: \S* instead of \S+ to allow empty definitions like [ref]:
     static ref REF_REGEX: Regex = Regex::new(r"^\s*\[([^\]]+)\]:\s*.*").unwrap();
 
-    // Pattern to match reference links and images ONLY: [text][reference] or ![text][reference]
-    // These need lookbehind for escaped brackets
-    // Use a more sophisticated pattern that handles nested brackets
-    static ref REF_LINK_REGEX: FancyRegex = FancyRegex::new(r"(?<!\\)\[((?:[^\[\]\\]|\\.|\[[^\]]*\])*)\]\[([^\]]*)\]").unwrap();
-    static ref REF_IMAGE_REGEX: FancyRegex = FancyRegex::new(r"(?<!\\)!\[((?:[^\[\]\\]|\\.|\[[^\]]*\])*)\]\[([^\]]*)\]").unwrap();
-
-    // Pattern for shortcut reference links [reference]
-    // Must not be preceded by ] or ) (to avoid matching second part of [text][ref] or reversed links (url)[text])
-    // Must not be followed by [ or ( (to avoid matching first part of [text][ref] or [text](url))
-    static ref SHORTCUT_REF_REGEX: FancyRegex = FancyRegex::new(r"(?<![\\)\]])\[([^\]]+)\](?!\s*[\[\(])").unwrap();
-
-    // Pattern to match inline links and images (to exclude them)
-    static ref INLINE_LINK_REGEX: FancyRegex = FancyRegex::new(r"(?<!\\)\[([^\]]+)\]\(([^)]+)\)").unwrap();
-    static ref INLINE_IMAGE_REGEX: FancyRegex = FancyRegex::new(r"(?<!\\)!\[([^\]]+)\]\(([^)]+)\)").unwrap();
-
     // Pattern for list items to exclude from reference checks (standard regex is fine)
     static ref LIST_ITEM_REGEX: Regex = Regex::new(r"^\s*[-*+]\s+(?:\[[xX\s]\]\s+)?").unwrap();