rumdl 0.0.100__tar.gz → 0.0.101__tar.gz

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

@@ -7,8 +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
@@ -225,7 +245,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.100...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

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

@@ -1493,7 +1493,7 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "rumdl"
-version = "0.0.100"
+version = "0.0.101"
 dependencies = [
  "anyhow",
  "assert_cmd",

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

@@ -1,6 +1,6 @@
 [package]
 name = "rumdl"
-version = "0.0.100"
+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.100 → rumdl-0.0.101}/PKG-INFO

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

{rumdl-0.0.100 → 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.100 → 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.100 → 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.100 → 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.100 → 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.100 → 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.100 → 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();

{rumdl-0.0.100 → rumdl-0.0.101}/src/rules/md013_line_length.rs

@@ -5,35 +5,14 @@ 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::range_utils::calculate_excess_range;
-use lazy_static::lazy_static;
-use regex::Regex;
+use crate::utils::regex_cache::{
+    IMAGE_REF_PATTERN, INLINE_LINK_REGEX as MARKDOWN_LINK_PATTERN, LINK_REF_PATTERN, URL_IN_TEXT, URL_PATTERN,
+};
 use toml;
 
 pub mod md013_config;
 use md013_config::MD013Config;
 
-lazy_static! {
-    static ref URL_PATTERN: Regex = Regex::new(r"^https?://\S+$").unwrap();
-    static ref IMAGE_REF_PATTERN: Regex = Regex::new(r"^!\[.*?\]\[.*?\]$" ).unwrap();
-    static ref LINK_REF_PATTERN: Regex = Regex::new(r"^\[.*?\]:\s*https?://\S+$").unwrap();
-
-    // Pattern to find URLs anywhere in text
-    static ref URL_IN_TEXT: Regex = Regex::new(r"https?://\S+").unwrap();
-
-    // Pattern to find markdown links [text](url) for URL exclusion
-    static ref MARKDOWN_LINK_PATTERN: Regex = Regex::new(r"\[([^\]]*)\]\(([^)]+)\)").unwrap();
-
-    // Sentence splitting patterns
-    static ref SENTENCE_END: Regex = Regex::new(r"[.!?]\s+[A-Z]").unwrap();
-    static ref ABBREVIATION: Regex = Regex::new(r"\b(?:Mr|Mrs|Ms|Dr|Prof|Sr|Jr|vs|etc|i\.e|e\.g|Inc|Corp|Ltd|Co|St|Ave|Blvd|Rd|Ph\.D|M\.D|B\.A|M\.A|Ph\.D|U\.S|U\.K|U\.N|N\.Y|L\.A|D\.C)\.\s+[A-Z]").unwrap();
-    static ref DECIMAL_NUMBER: Regex = Regex::new(r"\d+\.\s*\d+").unwrap();
-    static ref LIST_ITEM: Regex = Regex::new(r"^\s*\d+\.\s+").unwrap();
-
-    // Link detection patterns
-    static ref INLINE_LINK: Regex = Regex::new(r"\[([^\]]*)\]\(([^)]*)\)").unwrap();
-    static ref REFERENCE_LINK: Regex = Regex::new(r"\[([^\]]*)\]\[([^\]]*)\]").unwrap();
-}
-
 #[derive(Clone, Default)]
 pub struct MD013LineLength {
     config: MD013Config,

{rumdl-0.0.100 → rumdl-0.0.101}/src/rules/md020_no_missing_space_closed_atx.rs

@@ -7,16 +7,9 @@ use lazy_static::lazy_static;
 use regex::Regex;
 
 lazy_static! {
-    static ref CLOSED_ATX_NO_SPACE_PATTERN: Regex =
-        Regex::new(r"^(\s*)(#+)([^#\s].*?)([^#\s])(#+)\s*$").unwrap();
-    static ref CLOSED_ATX_NO_SPACE_START_PATTERN: Regex =
-        Regex::new(r"^(\s*)(#+)([^#\s].*?)\s(#+)\s*$").unwrap();
-    static ref CLOSED_ATX_NO_SPACE_END_PATTERN: Regex =
-        Regex::new(r"^(\s*)(#+)\s(.*?)([^#\s])(#+)\s*$").unwrap();
-
-    // Matches code fence blocks
-    static ref CODE_FENCE_PATTERN: Regex =
-        Regex::new(r"^(\s*)(`{3,}|~{3,})").unwrap();
+    static ref CLOSED_ATX_NO_SPACE_PATTERN: Regex = Regex::new(r"^(\s*)(#+)([^#\s].*?)([^#\s])(#+)\s*$").unwrap();
+    static ref CLOSED_ATX_NO_SPACE_START_PATTERN: Regex = Regex::new(r"^(\s*)(#+)([^#\s].*?)\s(#+)\s*$").unwrap();
+    static ref CLOSED_ATX_NO_SPACE_END_PATTERN: Regex = Regex::new(r"^(\s*)(#+)\s(.*?)([^#\s])(#+)\s*$").unwrap();
 }
 
 #[derive(Clone)]

{rumdl-0.0.100 → rumdl-0.0.101}/src/rules/md025_single_title.rs

@@ -3,26 +3,14 @@
 /// See [docs/md025.md](../../docs/md025.md) for full documentation, configuration, and examples.
 use crate::rule::{Fix, LintError, LintResult, LintWarning, Rule, RuleCategory, Severity};
 use crate::utils::range_utils::{LineIndex, calculate_match_range};
-use lazy_static::lazy_static;
-use regex::Regex;
+use crate::utils::regex_cache::{
+    HR_ASTERISK, HR_DASH, HR_SPACED_ASTERISK, HR_SPACED_DASH, HR_SPACED_UNDERSCORE, HR_UNDERSCORE,
+};
 use toml;
 
 mod md025_config;
 use md025_config::MD025Config;
 
-lazy_static! {
-    // Pattern for quick check if content has any headings at all
-    static ref HEADING_CHECK: Regex = Regex::new(r"(?m)^(?:\s*)#").unwrap();
-
-    // Horizontal rule patterns (from MD035)
-    static ref HR_DASH: Regex = Regex::new(r"^\-{3,}\s*$").unwrap();
-    static ref HR_ASTERISK: Regex = Regex::new(r"^\*{3,}\s*$").unwrap();
-    static ref HR_UNDERSCORE: Regex = Regex::new(r"^_{3,}\s*$").unwrap();
-    static ref HR_SPACED_DASH: Regex = Regex::new(r"^(\-\s+){2,}\-\s*$").unwrap();
-    static ref HR_SPACED_ASTERISK: Regex = Regex::new(r"^(\*\s+){2,}\*\s*$").unwrap();
-    static ref HR_SPACED_UNDERSCORE: Regex = Regex::new(r"^(_\s+){2,}_\s*$").unwrap();
-}
-
 #[derive(Clone, Default)]
 pub struct MD025SingleTitle {
     config: MD025Config,

{rumdl-0.0.100 → rumdl-0.0.101}/src/rules/md029_ordered_list_prefix.rs

@@ -4,13 +4,12 @@
 use crate::rule::{Fix, LintError, LintResult, LintWarning, Rule, RuleCategory, Severity};
 use crate::utils::document_structure::{DocumentStructure, DocumentStructureExtensions};
 use crate::utils::range_utils::LineIndex;
+use crate::utils::regex_cache::ORDERED_LIST_MARKER_REGEX;
 use lazy_static::lazy_static;
 use regex::Regex;
 use serde::{Deserialize, Serialize};
 
 lazy_static! {
-    static ref ORDERED_LIST_ITEM_REGEX: Regex = Regex::new(r"^(\s*)\d+\.\s").unwrap();
-    static ref LIST_NUMBER_REGEX: Regex = Regex::new(r"^\s*(\d+)\.\s").unwrap();
     static ref FIX_LINE_REGEX: Regex = Regex::new(r"^(\s*)\d+(\.\s.*)$").unwrap();
 }
 
@@ -43,9 +42,9 @@ impl MD029OrderedListPrefix {
 
     #[inline]
     fn get_list_number(line: &str) -> Option<usize> {
-        LIST_NUMBER_REGEX
+        ORDERED_LIST_MARKER_REGEX
             .captures(line)
-            .and_then(|cap| cap[1].parse::<usize>().ok())
+            .and_then(|cap| cap[2].parse::<usize>().ok())
     }
 
     #[inline]
@@ -93,7 +92,7 @@ impl Rule for MD029OrderedListPrefix {
         }
 
         // Quick check for any ordered list markers before processing
-        if !ctx.content.contains('.') || !ctx.content.lines().any(|line| ORDERED_LIST_ITEM_REGEX.is_match(line)) {
+        if !ctx.content.contains('.') || !ctx.content.lines().any(|line| ORDERED_LIST_MARKER_REGEX.is_match(line)) {
             return Ok(Vec::new());
         }
 

{rumdl-0.0.100 → rumdl-0.0.101}/src/rules/md031_blanks_around_fences.rs

@@ -4,12 +4,6 @@
 use crate::rule::{Fix, LintError, LintResult, LintWarning, Rule, RuleCategory, Severity};
 use crate::utils::document_structure::{DocumentStructure, DocumentStructureExtensions};
 use crate::utils::range_utils::{LineIndex, calculate_line_range};
-use lazy_static::lazy_static;
-use regex::Regex;
-
-lazy_static! {
-    static ref CODE_FENCE: Regex = Regex::new(r"^(```|~~~)").unwrap();
-}
 
 /// Rule MD031: Fenced code blocks should be surrounded by blank lines
 #[derive(Clone)]

{rumdl-0.0.100 → rumdl-0.0.101}/src/rules/md032_blanks_around_lists.rs

@@ -2,11 +2,11 @@ use crate::rule::{Fix, LintError, LintResult, LintWarning, Rule, RuleCategory, S
 use crate::utils::document_structure::document_structure_from_str;
 use crate::utils::document_structure::{DocumentStructure, DocumentStructureExtensions};
 use crate::utils::range_utils::{LineIndex, calculate_line_range};
+use crate::utils::regex_cache::BLOCKQUOTE_PREFIX_RE;
 use lazy_static::lazy_static;
 use regex::Regex;
 
 lazy_static! {
-    static ref BLOCKQUOTE_PREFIX_RE: Regex = Regex::new(r"^(\s*>)+(\s*)").unwrap();
     static ref BLANK_LINE_RE: Regex = Regex::new(r"^\s*$").unwrap();
 }
 

{rumdl-0.0.100 → rumdl-0.0.101}/src/rules/md034_no_bare_urls.rs

@@ -6,6 +6,7 @@ use crate::rule::{
 };
 use crate::utils::early_returns;
 use crate::utils::range_utils::calculate_url_range;
+use crate::utils::regex_cache::EMAIL_PATTERN;
 
 use crate::lint_context::LintContext;
 use fancy_regex::Regex as FancyRegex;
@@ -30,9 +31,6 @@ lazy_static! {
     // Updated to support IPv6 addresses
     static ref ANGLE_LINK_PATTERN: Regex = Regex::new(r#"<((?:https?|ftps?)://(?:\[[0-9a-fA-F:]+(?:%[a-zA-Z0-9]+)?\]|[^>]+)|[^@\s]+@[^@\s]+\.[^@\s>]+)>"#).unwrap();
 
-    // Pattern to match code fences
-    static ref CODE_FENCE_RE: Regex = Regex::new(r#"^(`{3,}|~{3,})"#).unwrap();
-
     // Add regex to identify lines containing only a badge link
     static ref BADGE_LINK_LINE: Regex = Regex::new(r#"^\s*\[!\[[^\]]*\]\([^)]*\)\]\([^)]*\)\s*$"#).unwrap();
 
@@ -55,10 +53,6 @@ lazy_static! {
     // Note: This is permissive to match markdownlint behavior, allowing technically invalid IPv6 for examples
     static ref IPV6_URL_REGEX: Regex = Regex::new(r#"(https?|ftps?)://\[[0-9a-fA-F:%.\-a-zA-Z]+\](?::\d+)?(?:/[^\s<>\[\]()\\'\"`]*)?(?:\?[^\s<>\[\]()\\'\"`]*)?(?:#[^\s<>\[\]()\\'\"`]*)?"#).unwrap();
 
-    // Add regex for email addresses - matches markdownlint behavior
-    // Detects email addresses that should be autolinked like URLs
-    static ref EMAIL_REGEX: Regex = Regex::new(r#"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}"#).unwrap();
-
     // Add regex for reference definitions
     // Updated to support IPv6 addresses
     static ref REFERENCE_DEF_RE: Regex = Regex::new(r"^\s*\[[^\]]+\]:\s*(?:https?|ftps?)://\S+$").unwrap();
@@ -219,7 +213,7 @@ impl MD034NoBareUrls {
             }
 
             // Check for emails in this line
-            for email_match in EMAIL_REGEX.find_iter(line_content) {
+            for email_match in EMAIL_PATTERN.find_iter(line_content) {
                 let global_start = line_info.byte_offset + email_match.start();
                 let global_end = line_info.byte_offset + email_match.end();
                 all_matches.push((global_start, global_end, true));
@@ -383,7 +377,7 @@ impl MD034NoBareUrls {
                 }
 
                 // Check for email addresses
-                for email_match in EMAIL_REGEX.find_iter(text_str) {
+                for email_match in EMAIL_PATTERN.find_iter(text_str) {
                     let email_start = email_match.start();
                     let email_end = email_match.end();
                     let before = if email_start == 0 {

{rumdl-0.0.100 → rumdl-0.0.101}/src/rules/md035_hr_style.rs

@@ -6,22 +6,14 @@
 use crate::utils::range_utils::{LineIndex, calculate_line_range};
 
 use crate::rule::{Fix, LintError, LintResult, LintWarning, Rule, Severity};
-use lazy_static::lazy_static;
-use regex::Regex;
+use crate::utils::regex_cache::{
+    HR_ASTERISK, HR_DASH, HR_SPACED_ASTERISK, HR_SPACED_DASH, HR_SPACED_UNDERSCORE, HR_UNDERSCORE,
+};
 use toml;
 
 mod md035_config;
 use md035_config::MD035Config;
 
-lazy_static! {
-    static ref HR_DASH: Regex = Regex::new(r"^-{3,}\s*$").unwrap();
-    static ref HR_ASTERISK: Regex = Regex::new(r"^\*{3,}\s*$").unwrap();
-    static ref HR_UNDERSCORE: Regex = Regex::new(r"^_{3,}\s*$").unwrap();
-    static ref HR_SPACED_DASH: Regex = Regex::new(r"^(-\s+){2,}-\s*$").unwrap();
-    static ref HR_SPACED_ASTERISK: Regex = Regex::new(r"^(\*\s+){2,}\*\s*$").unwrap();
-    static ref HR_SPACED_UNDERSCORE: Regex = Regex::new(r"^(_\s+){2,}_\s*$").unwrap();
-}
-
 /// Represents the style for horizontal rules
 #[derive(Clone, Default)]
 pub struct MD035HRStyle {

{rumdl-0.0.100 → rumdl-0.0.101}/src/rules/md037_spaces_around_emphasis.rs

@@ -6,13 +6,7 @@ use crate::utils::document_structure::{DocumentStructure, DocumentStructureExten
 use crate::utils::emphasis_utils::{
     EmphasisSpan, find_emphasis_markers, find_emphasis_spans, has_doc_patterns, replace_inline_code,
 };
-use lazy_static::lazy_static;
-use regex::Regex;
-
-lazy_static! {
-    // List markers pattern - used to avoid confusion with emphasis
-    static ref LIST_MARKER: Regex = Regex::new(r"^\s*[*+-]\s+").unwrap();
-}
+use crate::utils::regex_cache::UNORDERED_LIST_MARKER_REGEX;
 
 /// Check if an emphasis span has spacing issues that should be flagged
 #[inline]
@@ -198,9 +192,9 @@ impl MD037NoSpaceInEmphasis {
 
         // Optimized list detection with fast path
         if (line.starts_with(' ') || line.starts_with('*') || line.starts_with('+') || line.starts_with('-'))
-            && LIST_MARKER.is_match(line)
+            && UNORDERED_LIST_MARKER_REGEX.is_match(line)
         {
-            if let Some(caps) = LIST_MARKER.captures(line) {
+            if let Some(caps) = UNORDERED_LIST_MARKER_REGEX.captures(line) {
                 if let Some(full_match) = caps.get(0) {
                     let list_marker_end = full_match.end();
                     if list_marker_end < line.len() {

{rumdl-0.0.100 → rumdl-0.0.101}/src/rules/md041_first_line_heading.rs

@@ -1,16 +1,9 @@
-use crate::utils::range_utils::{LineIndex, calculate_line_range};
-
 use crate::rule::{Fix, LintError, LintResult, LintWarning, Rule, Severity};
 use crate::rules::front_matter_utils::FrontMatterUtils;
-use fancy_regex::Regex as FancyRegex;
-use lazy_static::lazy_static;
+use crate::utils::range_utils::{LineIndex, calculate_line_range};
+use crate::utils::regex_cache::HTML_HEADING_PATTERN;
 use regex::Regex;
 
-lazy_static! {
-    /// Pattern for HTML heading tags
-    static ref HTML_HEADING_PATTERN: FancyRegex = FancyRegex::new(r"^\s*<h([1-6])(?:\s[^>]*)?>.*</h\1>\s*$").unwrap();
-}
-
 /// Rule MD041: First line in file should be a top-level heading
 ///
 /// See [docs/md041.md](../../docs/md041.md) for full documentation, configuration, and examples.

{rumdl-0.0.100 → rumdl-0.0.101}/src/rules/md045_no_alt_text.rs

@@ -1,14 +1,9 @@
 use crate::rule::{Fix, LintError, LintResult, LintWarning, Rule, Severity};
-use lazy_static::lazy_static;
-use regex::Regex;
+use crate::utils::regex_cache::IMAGE_REGEX;
 
 pub mod md045_config;
 use md045_config::MD045Config;
 
-lazy_static! {
-    static ref IMAGE_REGEX: Regex = Regex::new(r"!\[([^\]]*)\](\([^)]+\))").unwrap();
-}
-
 /// Rule MD045: Images should have alt text
 ///
 /// See [docs/md045.md](../../docs/md045.md) for full documentation, configuration, and examples.
@@ -140,7 +135,7 @@ impl Rule for MD045NoAltText {
         for caps in IMAGE_REGEX.captures_iter(content) {
             let full_match = caps.get(0).unwrap();
             let alt_text = caps.get(1).map_or("", |m| m.as_str());
-            let url_part = caps.get(2).map_or("", |m| m.as_str());
+            let url = caps.get(2).map_or("", |m| m.as_str());
 
             // Add text before this match
             result.push_str(&content[last_end..full_match.start()]);
@@ -151,8 +146,10 @@ impl Rule for MD045NoAltText {
                 result.push_str(&caps[0]);
             } else if alt_text.trim().is_empty() {
                 // Generate a more helpful placeholder based on the image URL
-                let placeholder = self.generate_placeholder_text(url_part);
-                result.push_str(&format!("![{placeholder}]{url_part}"));
+                // The centralized regex captures just the URL, so we need to add parentheses
+                let url_part = format!("({url})");
+                let placeholder = self.generate_placeholder_text(&url_part);
+                result.push_str(&format!("![{placeholder}]({url})"));
             } else {
                 // Keep the original if alt text is not empty
                 result.push_str(&caps[0]);