rumdl 0.0.99__tar.gz → 0.0.101__tar.gz

{rumdl-0.0.99 → rumdl-0.0.101}/CHANGELOG.md

@@ -7,6 +7,28 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.101] - 2025-07-23
+
+## [0.0.100] - 2025-07-22
+
+### Performance Improvements
+- **MD032**: Eliminated redundant DocumentStructure creation through optimization interface delegation
+  - Refactored check() method to delegate to check_with_structure() for shared parsing
+  - Added fix_with_structure() helper method for optimized fixing operations
+- **List Processing**: Major refactoring of complex list block merging logic for better maintainability
+  - Extracted merge_adjacent_list_blocks into clean ListBlockMerger struct
+  - Introduced BlockSpacing enum for clear categorization of list spacing types
+  - Separated compatibility checking, spacing analysis, and merging logic into focused methods
+- **Memory Management**: Added comprehensive performance stress tests for deeply nested lists
+  - Created benchmarks for up to 20 levels of nesting with measurable performance baselines
+  - Established performance thresholds: <3ms parsing, <4ms rule checking for extreme nesting
+  - Added memory stress testing to prevent performance regressions
+
+### Code Quality
+- Improved separation of concerns in list processing logic
+- Enhanced code maintainability through better structured algorithms
+- Added comprehensive test coverage for pathological markdown structures
+
 ## [0.0.99] - 2025-07-22
 
 ### Fixed
@@ -223,7 +245,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.99...HEAD
+[Unreleased]: https://github.com/rvben/rumdl/compare/v0.0.101...HEAD
+[0.0.101]: https://github.com/rvben/rumdl/compare/v0.0.100...v0.0.101
+[0.0.100]: https://github.com/rvben/rumdl/compare/v0.0.99...v0.0.100
 [0.0.99]: https://github.com/rvben/rumdl/compare/v0.0.98...v0.0.99
 [0.0.98]: https://github.com/rvben/rumdl/compare/v0.0.97...v0.0.98
 [0.0.97]: https://github.com/rvben/rumdl/compare/v0.0.96...v0.0.97

{rumdl-0.0.99 → rumdl-0.0.101}/Cargo.lock

@@ -859,9 +859,9 @@ checksum = "f4c7245a08504955605670dbf141fceab975f15ca21570696aebe9d2e71576bd"
 
 [[package]]
 name = "io-uring"
-version = "0.7.8"
+version = "0.7.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b86e202f00093dcba4275d4636b93ef9dd75d025ae560d2521b45ea28ab49013"
+checksum = "d93587f37623a1a17d94ef2bc9ada592f5465fe7732084ab7beefabe5c77c0c4"
 dependencies = [
  "bitflags 2.9.1",
  "cfg-if",
@@ -1397,9 +1397,9 @@ checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
 
 [[package]]
 name = "rand"
-version = "0.9.1"
+version = "0.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fbfd9d094a40bf3ae768db9361049ace4c0e04a4fd6b359518bd7b73a73dd97"
+checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
 dependencies = [
  "rand_chacha",
  "rand_core",
@@ -1455,9 +1455,9 @@ dependencies = [
 
 [[package]]
 name = "redox_syscall"
-version = "0.5.13"
+version = "0.5.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d04b7d0ee6b4a0207a0a7adb104d23ecb0b47d6beae7152d0fa34b692b29fd6"
+checksum = "7e8af0dde094006011e6a740d4879319439489813bd0bcdc7d821beaeeff48ec"
 dependencies = [
  "bitflags 2.9.1",
 ]
@@ -1493,7 +1493,7 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "rumdl"
-version = "0.0.99"
+version = "0.0.101"
 dependencies = [
  "anyhow",
  "assert_cmd",

{rumdl-0.0.99 → rumdl-0.0.101}/Cargo.toml

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

{rumdl-0.0.99 → rumdl-0.0.101}/Makefile

@@ -124,6 +124,12 @@ update-readme-version:
 	@rm -f README.md.bak
 	@echo "README.md updated to rev $(NEW_TAG)"
 
+update-all-docs-version:
+	@echo "Updating all documentation to use $(NEW_TAG)..."
+	@perl -i.bak -E 's/rev: v[0-9]+\.[0-9]+\.[0-9]+/rev: $(NEW_TAG)/g' README.md docs/global-settings.md ../rumdl-pre-commit/README.md 2>/dev/null || true
+	@rm -f README.md.bak docs/global-settings.md.bak ../rumdl-pre-commit/README.md.bak 2>/dev/null || true
+	@echo "All documentation updated to rev $(NEW_TAG)"
+
 update-changelog:
 	@echo "Updating CHANGELOG.md for $(NEW_TAG)..."
 	@if [ -f CHANGELOG.md ]; then \
@@ -145,9 +151,9 @@ version-major:
 	$(eval VERSION_NO_V := $(NEW_MAJOR).0.0)
 	@echo "Current: $(CURRENT) -> New: $(NEW_TAG)"
 	@$(MAKE) update-cargo-version VERSION_NO_V=$(VERSION_NO_V)
-	@$(MAKE) update-readme-version NEW_TAG=$(NEW_TAG)
+	@$(MAKE) update-all-docs-version NEW_TAG=$(NEW_TAG)
 	@$(MAKE) update-changelog NEW_TAG=$(NEW_TAG) VERSION_NO_V=$(VERSION_NO_V) CURRENT=$(CURRENT)
-	@git add Cargo.toml Cargo.lock README.md CHANGELOG.md
+	@git add Cargo.toml Cargo.lock README.md docs/global-settings.md CHANGELOG.md
 	@git commit -m "Bump version to $(NEW_TAG)"
 	@git tag -a $(NEW_TAG) -m "Release $(NEW_TAG)"
 	@echo "Version $(NEW_TAG) created and committed. Run 'git push && git push origin $(NEW_TAG)' to trigger release workflow."
@@ -162,9 +168,9 @@ version-minor:
 	$(eval VERSION_NO_V := $(MAJOR).$(NEW_MINOR).0)
 	@echo "Current: $(CURRENT) -> New: $(NEW_TAG)"
 	@$(MAKE) update-cargo-version VERSION_NO_V=$(VERSION_NO_V)
-	@$(MAKE) update-readme-version NEW_TAG=$(NEW_TAG)
+	@$(MAKE) update-all-docs-version NEW_TAG=$(NEW_TAG)
 	@$(MAKE) update-changelog NEW_TAG=$(NEW_TAG) VERSION_NO_V=$(VERSION_NO_V) CURRENT=$(CURRENT)
-	@git add Cargo.toml Cargo.lock README.md CHANGELOG.md
+	@git add Cargo.toml Cargo.lock README.md docs/global-settings.md CHANGELOG.md
 	@git commit -m "Bump version to $(NEW_TAG)"
 	@git tag -a $(NEW_TAG) -m "Release $(NEW_TAG)"
 	@echo "Version $(NEW_TAG) created and committed. Run 'git push && git push origin $(NEW_TAG)' to trigger release workflow."
@@ -180,9 +186,9 @@ version-patch:
 	$(eval VERSION_NO_V := $(MAJOR).$(MINOR).$(NEW_PATCH))
 	@echo "Current: $(CURRENT) -> New: $(NEW_TAG)"
 	@$(MAKE) update-cargo-version VERSION_NO_V=$(VERSION_NO_V)
-	@$(MAKE) update-readme-version NEW_TAG=$(NEW_TAG)
+	@$(MAKE) update-all-docs-version NEW_TAG=$(NEW_TAG)
 	@$(MAKE) update-changelog NEW_TAG=$(NEW_TAG) VERSION_NO_V=$(VERSION_NO_V) CURRENT=$(CURRENT)
-	@git add Cargo.toml Cargo.lock README.md CHANGELOG.md
+	@git add Cargo.toml Cargo.lock README.md docs/global-settings.md CHANGELOG.md
 	@git commit -m "Bump version to $(NEW_TAG)"
 	@git tag -a $(NEW_TAG) -m "Release $(NEW_TAG)"
 	@echo "Version $(NEW_TAG) created and committed. Run 'git push && git push origin $(NEW_TAG)' to trigger release workflow."

{rumdl-0.0.99 → rumdl-0.0.101}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rumdl
-Version: 0.0.99
+Version: 0.0.101
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -242,7 +242,7 @@ Add the following to your `.pre-commit-config.yaml`:
 ```yaml
 repos:
   - repo: https://github.com/rvben/rumdl-pre-commit
-    rev: v0.0.45  # Use the latest release tag
+    rev: v0.0.99  # Use the latest release tag
     hooks:
       - id: rumdl
         # To only check (default):

{rumdl-0.0.99 → rumdl-0.0.101}/README.md

@@ -211,7 +211,7 @@ Add the following to your `.pre-commit-config.yaml`:
 ```yaml
 repos:
   - repo: https://github.com/rvben/rumdl-pre-commit
-    rev: v0.0.45  # Use the latest release tag
+    rev: v0.0.99  # Use the latest release tag
     hooks:
       - id: rumdl
         # To only check (default):

{rumdl-0.0.99 → rumdl-0.0.101}/docs/global-settings.md

@@ -492,7 +492,7 @@ find . -name "*.md" -o -name "*.markdown" | head -10
 
 ```yaml
 - repo: https://github.com/rvben/rumdl-pre-commit
-  rev: v0.0.45
+  rev: v0.0.99
   hooks:
     - id: rumdl
       args: [--config=.rumdl.toml]

rumdl-0.0.101/scripts/update-pre-commit-docs.sh

@@ -0,0 +1,35 @@
+#!/bin/bash
+# Script to update rumdl-pre-commit version references in documentation
+
+set -e
+
+# Get the latest release version
+LATEST_VERSION=$(gh release list --repo rvben/rumdl --limit 1 | awk '{print $1}')
+
+if [ -z "$LATEST_VERSION" ]; then
+    echo "Error: Could not determine latest version"
+    exit 1
+fi
+
+echo "Latest rumdl version: $LATEST_VERSION"
+
+# Update version in all documentation files
+FILES=(
+    "README.md"
+    "docs/global-settings.md"
+    "../rumdl-pre-commit/README.md"
+)
+
+for file in "${FILES[@]}"; do
+    if [ -f "$file" ]; then
+        echo "Updating $file..."
+        # Update rev: vX.X.X patterns
+        sed -i.bak -E "s/rev: v[0-9]+\.[0-9]+\.[0-9]+/rev: $LATEST_VERSION/g" "$file"
+        # Clean up backup files
+        rm -f "${file}.bak"
+    else
+        echo "Warning: $file not found"
+    fi
+done
+
+echo "Documentation updated to use $LATEST_VERSION"

{rumdl-0.0.99 → rumdl-0.0.101}/src/lint_context.rs

@@ -1263,52 +1263,130 @@ fn merge_adjacent_list_blocks(list_blocks: &mut Vec<ListBlock>, lines: &[LineInf
         return;
     }
 
-    let mut merged = Vec::new();
-    let mut current = list_blocks[0].clone();
-
-    for next in list_blocks.iter().skip(1) {
-        // Check if blocks should be merged
-        // For MD032 purposes, consecutive unordered lists with different markers
-        // should be treated as one list block only if truly consecutive
-        let consecutive = next.start_line == current.end_line + 1;
-        let only_blank_between = next.start_line == current.end_line + 2;
-
-        // For ordered lists, we need to be more careful about merging
-        let should_merge_condition = if current.is_ordered && next.is_ordered {
-            // Only merge ordered lists if there's meaningful content between them
-            // (like code blocks, continuation paragraphs) not just blank lines
-            consecutive || has_meaningful_content_between(&current, next, lines)
-        } else {
-            // For unordered lists, use original logic
-            consecutive || (only_blank_between && current.marker == next.marker)
-        };
-
-        let should_merge = next.is_ordered == current.is_ordered
-            && next.blockquote_prefix == current.blockquote_prefix
-            && next.nesting_level == current.nesting_level
-            && should_merge_condition;
-
-        if should_merge {
-            // Merge blocks
-            current.end_line = next.end_line;
-            current.item_lines.extend_from_slice(&next.item_lines);
-
-            // Update marker consistency
-            if !current.is_ordered && current.marker.is_some() && next.marker.is_some() && current.marker != next.marker
-            {
-                current.marker = None; // Mixed markers
+    let mut merger = ListBlockMerger::new(lines);
+    *list_blocks = merger.merge(list_blocks);
+}
+
+/// Helper struct to manage the complex logic of merging list blocks
+struct ListBlockMerger<'a> {
+    lines: &'a [LineInfo],
+}
+
+impl<'a> ListBlockMerger<'a> {
+    fn new(lines: &'a [LineInfo]) -> Self {
+        Self { lines }
+    }
+
+    fn merge(&mut self, list_blocks: &[ListBlock]) -> Vec<ListBlock> {
+        let mut merged = Vec::with_capacity(list_blocks.len());
+        let mut current = list_blocks[0].clone();
+
+        for next in list_blocks.iter().skip(1) {
+            if self.should_merge_blocks(&current, next) {
+                current = self.merge_two_blocks(current, next);
+            } else {
+                merged.push(current);
+                current = next.clone();
             }
-        } else {
-            // Save current and start new
-            merged.push(current);
-            current = next.clone();
         }
+
+        merged.push(current);
+        merged
+    }
+
+    /// Determine if two adjacent list blocks should be merged
+    fn should_merge_blocks(&self, current: &ListBlock, next: &ListBlock) -> bool {
+        // Basic compatibility checks
+        if !self.blocks_are_compatible(current, next) {
+            return false;
+        }
+
+        // Check spacing and content between blocks
+        let spacing = self.analyze_spacing_between(current, next);
+        match spacing {
+            BlockSpacing::Consecutive => true,
+            BlockSpacing::SingleBlank => self.can_merge_with_blank_between(current, next),
+            BlockSpacing::MultipleBlanks | BlockSpacing::ContentBetween => {
+                self.can_merge_with_content_between(current, next)
+            }
+        }
+    }
+
+    /// Check if blocks have compatible structure for merging
+    fn blocks_are_compatible(&self, current: &ListBlock, next: &ListBlock) -> bool {
+        current.is_ordered == next.is_ordered
+            && current.blockquote_prefix == next.blockquote_prefix
+            && current.nesting_level == next.nesting_level
     }
 
-    // Don't forget the last block
-    merged.push(current);
+    /// Analyze the spacing between two list blocks
+    fn analyze_spacing_between(&self, current: &ListBlock, next: &ListBlock) -> BlockSpacing {
+        let gap = next.start_line - current.end_line;
+
+        match gap {
+            1 => BlockSpacing::Consecutive,
+            2 => BlockSpacing::SingleBlank,
+            _ if gap > 2 => {
+                if self.has_only_blank_lines_between(current, next) {
+                    BlockSpacing::MultipleBlanks
+                } else {
+                    BlockSpacing::ContentBetween
+                }
+            }
+            _ => BlockSpacing::Consecutive, // gap == 0, overlapping (shouldn't happen)
+        }
+    }
+
+    /// Check if unordered lists can be merged with a single blank line between
+    fn can_merge_with_blank_between(&self, current: &ListBlock, next: &ListBlock) -> bool {
+        // Only merge unordered lists with same marker across single blank
+        !current.is_ordered && current.marker == next.marker
+    }
+
+    /// Check if ordered lists can be merged when there's content between them
+    fn can_merge_with_content_between(&self, current: &ListBlock, next: &ListBlock) -> bool {
+        // Only consider merging ordered lists with meaningful content between
+        current.is_ordered && next.is_ordered && has_meaningful_content_between(current, next, self.lines)
+    }
+
+    /// Check if there are only blank lines between blocks
+    fn has_only_blank_lines_between(&self, current: &ListBlock, next: &ListBlock) -> bool {
+        for line_num in (current.end_line + 1)..next.start_line {
+            if let Some(line_info) = self.lines.get(line_num - 1) {
+                if !line_info.content.trim().is_empty() {
+                    return false;
+                }
+            }
+        }
+        true
+    }
+
+    /// Merge two compatible list blocks into one
+    fn merge_two_blocks(&self, mut current: ListBlock, next: &ListBlock) -> ListBlock {
+        current.end_line = next.end_line;
+        current.item_lines.extend_from_slice(&next.item_lines);
+
+        // Handle marker consistency for unordered lists
+        if !current.is_ordered && self.markers_differ(&current, next) {
+            current.marker = None; // Mixed markers
+        }
+
+        current
+    }
+
+    /// Check if two blocks have different markers
+    fn markers_differ(&self, current: &ListBlock, next: &ListBlock) -> bool {
+        current.marker.is_some() && next.marker.is_some() && current.marker != next.marker
+    }
+}
 
-    *list_blocks = merged;
+/// Types of spacing between list blocks
+#[derive(Debug, PartialEq)]
+enum BlockSpacing {
+    Consecutive,    // No gap between blocks
+    SingleBlank,    // One blank line between blocks
+    MultipleBlanks, // Multiple blank lines but no content
+    ContentBetween, // Content exists between blocks
 }
 
 /// Check if there's meaningful content (not just blank lines) between two list blocks

{rumdl-0.0.99 → rumdl-0.0.101}/src/main.rs

@@ -609,6 +609,37 @@ fn find_markdown_files(
     // Add support for .markdownlintignore file
     walk_builder.add_custom_ignore_filename(".markdownlintignore");
 
+    // --- Pre-check for explicit file paths ---
+    // If not in discovery mode, validate that specified paths exist
+    if !is_discovery_mode {
+        for path_str in paths {
+            let path = Path::new(path_str);
+            if !path.exists() {
+                return Err(format!("File not found: {path_str}").into());
+            }
+            // If it's a file, check if it's a markdown file and add it directly
+            if path.is_file() {
+                if let Some(ext) = path.extension() {
+                    if ext == "md" || ext == "markdown" {
+                        let cleaned_path = if let Some(stripped) = path_str.strip_prefix("./") {
+                            stripped.to_string()
+                        } else {
+                            path_str.clone()
+                        };
+                        file_paths.push(cleaned_path);
+                    }
+                }
+            }
+        }
+
+        // If we found files directly, skip the walker
+        if !file_paths.is_empty() {
+            file_paths.sort();
+            file_paths.dedup();
+            return Ok(file_paths);
+        }
+    }
+
     // --- Execute Walk ---
 
     for result in walk_builder.build() {
@@ -628,7 +659,12 @@ fn find_markdown_files(
                     file_paths.push(cleaned_path);
                 }
             }
-            Err(err) => eprintln!("Error walking directory: {err}"),
+            Err(err) => {
+                // Only show generic walking errors for directories, not for missing files
+                if is_discovery_mode {
+                    eprintln!("Error walking directory: {err}");
+                }
+            }
         }
     }
 

{rumdl-0.0.99 → rumdl-0.0.101}/src/rules/md005_list_indent.rs

@@ -7,16 +7,10 @@ use crate::utils::range_utils::{LineIndex, calculate_match_range};
 
 use crate::rule::{Fix, LintError, LintResult, LintWarning, Rule, RuleCategory, Severity};
 use crate::utils::document_structure::DocumentStructure;
-use lazy_static::lazy_static;
-use regex::Regex;
+// No regex patterns needed for this rule
 use std::collections::HashMap;
 use toml;
 
-lazy_static! {
-    // Regex to match blockquote prefixes (one or more '>' with optional spaces)
-    static ref BLOCKQUOTE_PREFIX: Regex = Regex::new(r"^(\s*>\s*)+").unwrap();
-}
-
 /// Rule MD005: Inconsistent indentation for list items at the same level
 #[derive(Clone)]
 pub struct MD005ListIndent;

{rumdl-0.0.99 → rumdl-0.0.101}/src/rules/md006_start_bullets.rs

@@ -2,8 +2,7 @@ use crate::utils::range_utils::LineIndex;
 
 use crate::rule::{Fix, LintError, LintResult, LintWarning, Rule, RuleCategory, Severity};
 use crate::utils::document_structure::{DocumentStructure, DocumentStructureExtensions};
-use lazy_static::lazy_static;
-use regex::Regex;
+use crate::utils::regex_cache::UNORDERED_LIST_MARKER_REGEX;
 
 /// Rule MD006: Consider starting bulleted lists at the leftmost column
 ///
@@ -16,14 +15,6 @@ use regex::Regex;
 #[derive(Clone)]
 pub struct MD006StartBullets;
 
-lazy_static! {
-    // Pattern to match bullet list items: captures indentation, marker, and space after marker
-    static ref BULLET_PATTERN: Regex = Regex::new(r"^(\s*)([*+-])(\s+)").unwrap();
-
-    // Pattern to match code fence markers
-    static ref CODE_FENCE_PATTERN: Regex = Regex::new(r"^(\s*)(```|~~~)").unwrap();
-}
-
 impl MD006StartBullets {
     /// Optimized check using centralized list blocks
     fn check_optimized(&self, ctx: &crate::lint_context::LintContext) -> LintResult {
@@ -84,7 +75,7 @@ impl MD006StartBullets {
 
                             // For the fix, we need to replace the highlighted part with just the bullet marker
                             let trimmed = line.trim_start();
-                            let bullet_part = if let Some(captures) = BULLET_PATTERN.captures(trimmed) {
+                            let bullet_part = if let Some(captures) = UNORDERED_LIST_MARKER_REGEX.captures(trimmed) {
                                 let marker = captures.get(2).map_or("*", |m| m.as_str());
                                 format!("{marker} ")
                             } else {
@@ -123,7 +114,7 @@ impl MD006StartBullets {
     }
     /// Checks if a line is a bullet list item and returns its indentation level
     fn is_bullet_list_item(line: &str) -> Option<usize> {
-        if let Some(captures) = BULLET_PATTERN.captures(line) {
+        if let Some(captures) = UNORDERED_LIST_MARKER_REGEX.captures(line) {
             if let Some(indent) = captures.get(1) {
                 return Some(indent.as_str().len());
             }
@@ -338,7 +329,7 @@ impl Rule for MD006StartBullets {
                     let line = lines[line_idx];
                     let trimmed = line.trim_start();
                     // Extract just the bullet marker and normalize to single space
-                    let bullet_part = if let Some(captures) = BULLET_PATTERN.captures(trimmed) {
+                    let bullet_part = if let Some(captures) = UNORDERED_LIST_MARKER_REGEX.captures(trimmed) {
                         format!("{} ", captures.get(2).unwrap().as_str()) // Always use single space
                     } else {
                         "* ".to_string() // fallback

{rumdl-0.0.99 → rumdl-0.0.101}/src/rules/md007_ul_indent.rs

@@ -5,8 +5,7 @@ use crate::rule::{LintError, LintResult, LintWarning, Rule, RuleCategory, Severi
 use crate::rule_config_serde::RuleConfig;
 use crate::utils::document_structure::{DocumentStructure, DocumentStructureExtensions};
 use crate::utils::element_cache::{ElementCache, ListMarkerType};
-use lazy_static::lazy_static;
-use regex::Regex;
+use crate::utils::regex_cache::{CODE_FENCE_REGEX, UNORDERED_LIST_MARKER_REGEX};
 use toml;
 
 mod md007_config;
@@ -17,10 +16,6 @@ pub struct MD007ULIndent {
     config: MD007Config,
 }
 
-lazy_static! {
-    static ref LIST_ITEM_PATTERN: Regex = Regex::new(r"^(\s*)([*+-])(\s+)(.*)$").unwrap();
-}
-
 impl MD007ULIndent {
     pub fn new(indent: usize) -> Self {
         Self {
@@ -38,9 +33,7 @@ impl MD007ULIndent {
 
     #[allow(dead_code)]
     fn is_in_code_block(content: &str, line_idx: usize) -> bool {
-        lazy_static! {
-            static ref CODE_BLOCK_MARKER: Regex = Regex::new(r"^(```|~~~)").unwrap();
-        }
+        // Use centralized code fence pattern
 
         let lines: Vec<&str> = content.lines().collect();
         let mut in_code_block = false;
@@ -50,7 +43,7 @@ impl MD007ULIndent {
                 break;
             }
 
-            if CODE_BLOCK_MARKER.is_match(line.trim_start()) {
+            if CODE_FENCE_REGEX.is_match(line.trim_start()) {
                 in_code_block = !in_code_block;
             }
 
@@ -116,7 +109,7 @@ impl Rule for MD007ULIndent {
                         let lines: Vec<&str> = content.lines().collect();
                         if let Some(line) = lines.get(item.line_number - 1) {
                             // Extract the marker and content
-                            if LIST_ITEM_PATTERN.captures(line).is_some() {
+                            if UNORDERED_LIST_MARKER_REGEX.captures(line).is_some() {
                                 let correct_indent = " ".repeat(expected_indent);
 
                                 // Fix range should match warning range - only the problematic indentation
@@ -212,7 +205,7 @@ impl Rule for MD007ULIndent {
                         let lines: Vec<&str> = content.lines().collect();
                         if let Some(line) = lines.get(item.line_number - 1) {
                             // Extract the marker and content
-                            if LIST_ITEM_PATTERN.captures(line).is_some() {
+                            if UNORDERED_LIST_MARKER_REGEX.captures(line).is_some() {
                                 let correct_indent = " ".repeat(expected_indent);
 
                                 // Fix range should match warning range - only the problematic indentation

{rumdl-0.0.99 → rumdl-0.0.101}/src/rules/md009_trailing_spaces.rs

@@ -1,17 +1,12 @@
 use crate::rule::{Fix, LintError, LintResult, LintWarning, Rule, RuleCategory, Severity};
 use crate::rule_config_serde::RuleConfig;
 use crate::utils::range_utils::{LineIndex, calculate_trailing_range};
-use crate::utils::regex_cache::get_cached_regex;
-use lazy_static::lazy_static;
-use regex::Regex;
+use crate::utils::regex_cache::{ORDERED_LIST_MARKER_REGEX, UNORDERED_LIST_MARKER_REGEX, get_cached_regex};
 
 mod md009_config;
 use md009_config::MD009Config;
 
-lazy_static! {
-    // Optimized regex patterns for fix operations
-    static ref TRAILING_SPACES_REGEX: std::sync::Arc<Regex> = get_cached_regex(r"(?m) +$").unwrap();
-}
+// No need for lazy_static, we'll use get_cached_regex directly
 
 #[derive(Debug, Clone, Default)]
 pub struct MD009TrailingSpaces {
@@ -52,12 +47,7 @@ impl MD009TrailingSpaces {
 
         if let Some(prev) = prev_line {
             // Check for unordered list markers (*, -, +) with proper formatting
-            lazy_static! {
-                static ref LIST_MARKER_REGEX: Regex = Regex::new(r"^(\s*)[-*+]\s+").unwrap();
-                static ref ORDERED_LIST_REGEX: Regex = Regex::new(r"^(\s*)\d+[.)]\s+").unwrap();
-            }
-
-            LIST_MARKER_REGEX.is_match(prev) || ORDERED_LIST_REGEX.is_match(prev)
+            UNORDERED_LIST_MARKER_REGEX.is_match(prev) || ORDERED_LIST_MARKER_REGEX.is_match(prev)
         } else {
             false
         }
@@ -204,7 +194,10 @@ impl Rule for MD009TrailingSpaces {
         // For simple cases (strict mode), use fast regex approach
         if self.config.strict {
             // In strict mode, remove ALL trailing spaces everywhere
-            return Ok(TRAILING_SPACES_REGEX.replace_all(content, "").to_string());
+            return Ok(get_cached_regex(r"(?m) +$")
+                .unwrap()
+                .replace_all(content, "")
+                .to_string());
         }
 
         // For complex cases, we need line-by-line processing but with optimizations

{rumdl-0.0.99 → rumdl-0.0.101}/src/rules/md010_no_hard_tabs.rs

@@ -4,17 +4,12 @@ use crate::rule_config_serde::RuleConfig;
 ///
 /// See [docs/md010.md](../../docs/md010.md) for full documentation, configuration, and examples.
 use crate::utils::range_utils::{LineIndex, calculate_match_range};
-use lazy_static::lazy_static;
-use regex::Regex;
+use crate::utils::regex_cache::{HTML_COMMENT_END, HTML_COMMENT_START};
 
 mod md010_config;
 use md010_config::MD010Config;
 
-lazy_static! {
-    // Pattern to detect HTML comments (start and end tags separately)
-    static ref HTML_COMMENT_START: Regex = Regex::new(r"<!--").unwrap();
-    static ref HTML_COMMENT_END: Regex = Regex::new(r"-->").unwrap();
-}
+// HTML comment patterns are now imported from regex_cache
 
 /// Rule MD010: Hard tabs
 #[derive(Clone, Default)]

{rumdl-0.0.99 → rumdl-0.0.101}/src/rules/md011_no_reversed_links.rs

@@ -14,7 +14,6 @@ lazy_static! {
     static ref REVERSED_LINK_CHECK_REGEX: Regex = Regex::new(
         r"\(([^)]*(?:\([^)]*\)[^)]*)*)\)\[([^\]]+)\]"
     ).unwrap();
-    static ref CODE_FENCE_REGEX: Regex = Regex::new(r"^(\s*)(```|~~~)").unwrap();
 
     // Pattern to detect escaped brackets and parentheses
     static ref ESCAPED_CHARS: Regex = Regex::new(r"\\[\[\]()]").unwrap();