rumdl 0.0.100__tar.gz → 0.0.102__tar.gz

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

@@ -7,8 +7,30 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.102] - 2025-07-24
+
+## [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 +247,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.100...HEAD
+[Unreleased]: https://github.com/rvben/rumdl/compare/v0.0.102...HEAD
+[0.0.102]: https://github.com/rvben/rumdl/compare/v0.0.101...v0.0.102
+[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.102}/Cargo.lock

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

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

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

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

{rumdl-0.0.100 → rumdl-0.0.102}/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.102}/src/rules/md005_list_indent.rs

@@ -7,29 +7,63 @@ 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;
 
 impl MD005ListIndent {
-    // Determine the expected indentation for a list item at a specific level
+    // Determine the expected indentation for a list item
+    // Each nested item should align with the text content of its parent
     #[inline]
-    fn get_expected_indent(level: usize) -> usize {
+    fn get_expected_indent(level: usize, parent_text_position: Option<usize>) -> usize {
         if level == 1 {
             0 // Top level items should be at the start of the line
+        } else if let Some(pos) = parent_text_position {
+            // Align with parent's text content
+            pos
         } else {
-            2 * (level - 1) // Nested items should be indented by 2 spaces per level
+            // Fallback to standard nested indentation: 2 spaces per level
+            2 * (level - 1)
+        }
+    }
+
+    /// Get parent info for any list item to determine proper text alignment
+    /// Returns parent_text_position where the child should align
+    fn get_parent_text_position(
+        &self,
+        ctx: &crate::lint_context::LintContext,
+        current_line: usize,
+        current_indent: usize,
+    ) -> Option<usize> {
+        // Look backward from current line to find parent item
+        for line_idx in (1..current_line).rev() {
+            if let Some(line_info) = ctx.line_info(line_idx) {
+                if let Some(list_item) = &line_info.list_item {
+                    // Found a list item - check if it's at a lower indentation (parent level)
+                    if list_item.marker_column < current_indent {
+                        // This is a parent item - calculate where child should align
+                        if list_item.is_ordered {
+                            // For ordered lists, align with text start
+                            let text_start_pos = list_item.marker_column + list_item.marker.len() + 1; // +1 for space after marker
+                            return Some(text_start_pos);
+                        } else {
+                            // For unordered lists, align with text start
+                            let text_start_pos = list_item.marker_column + 2; // "* " or "- " or "+ "
+                            return Some(text_start_pos);
+                        }
+                    }
+                }
+                // If we encounter non-blank, non-list content at column 0, stop looking
+                else if !line_info.is_blank && line_info.indent == 0 {
+                    break;
+                }
+            }
         }
+        None
     }
 
     /// Group related list blocks that should be treated as one logical list structure
@@ -144,7 +178,19 @@ impl MD005ListIndent {
             // Sort by line number to process in order
             group.sort_by_key(|(line_num, _, _)| *line_num);
 
-            let expected_indent = Self::get_expected_indent(level);
+            // Get parent text position for proper alignment
+            let parent_text_position = if level > 1 {
+                // Get parent info from the first item in the group
+                if let Some((line_num, indent, _)) = group.first() {
+                    self.get_parent_text_position(ctx, *line_num, *indent)
+                } else {
+                    None
+                }
+            } else {
+                None
+            };
+
+            let expected_indent = Self::get_expected_indent(level, parent_text_position);
 
             // Check if items in this level have consistent indentation
             let indents: std::collections::HashSet<usize> = group.iter().map(|(_, indent, _)| *indent).collect();
@@ -401,11 +447,13 @@ mod tests {
         let content = "\
 1. Item 1
 2. Item 2
-  1. Nested 1
-  2. Nested 2
+   1. Nested 1
+   2. Nested 2
 3. Item 3";
         let ctx = LintContext::new(content);
         let result = rule.check(&ctx).unwrap();
+        // With dynamic alignment, nested items should align with parent's text content
+        // Ordered items starting with "1. " have text at column 3, so nested items need 3 spaces
         assert!(result.is_empty());
     }
 
@@ -418,9 +466,11 @@ mod tests {
    * Nested 1";
         let ctx = LintContext::new(content);
         let result = rule.check(&ctx).unwrap();
-        assert_eq!(result.len(), 2);
+        // With dynamic alignment, line 3 correctly aligns with line 2's text position
+        // Only line 2 is incorrectly indented
+        assert_eq!(result.len(), 1);
         let fixed = rule.fix(&ctx).unwrap();
-        assert_eq!(fixed, "* Item 1\n  * Item 2\n    * Nested 1");
+        assert_eq!(fixed, "* Item 1\n  * Item 2\n   * Nested 1");
     }
 
     #[test]
@@ -434,7 +484,10 @@ mod tests {
         let result = rule.check(&ctx).unwrap();
         assert_eq!(result.len(), 1);
         let fixed = rule.fix(&ctx).unwrap();
-        assert_eq!(fixed, "1. Item 1\n  2. Item 2\n    1. Nested 1");
+        // With dynamic alignment, ordered items align with parent's text content
+        // Line 1 text starts at col 3, so line 2 should have 3 spaces
+        // Line 3 already correctly aligns with line 2's text position
+        assert_eq!(fixed, "1. Item 1\n   2. Item 2\n    1. Nested 1");
     }
 
     #[test]
@@ -461,12 +514,15 @@ mod tests {
         let result = rule.check(&ctx).unwrap();
         assert_eq!(result.len(), 2);
         let fixed = rule.fix(&ctx).unwrap();
+        // With dynamic alignment:
+        // Level 2 aligns with Level 1's text (2 spaces)
+        // Level 3 aligns with Level 2's text (5 spaces: 2 + "* " + 1)
         assert_eq!(
             fixed,
             "\
 * Level 1
   * Level 2
-    * Level 3"
+     * Level 3"
         );
     }
 
@@ -525,11 +581,14 @@ Even more text";
 * Back to 1";
         let ctx = LintContext::new(content);
         let result = rule.check(&ctx).unwrap();
-        assert_eq!(result.len(), 4);
+        // With dynamic alignment, fewer items need correction
+        // Lines 2,4: should align with Level 1's text (2 spaces)
+        // Line 5: should align with "Back to 2"'s text (5 spaces)
+        assert_eq!(result.len(), 3);
         let fixed = rule.fix(&ctx).unwrap();
         assert_eq!(
             fixed,
-            "* Level 1\n  * Level 2\n    * Level 3\n  * Back to 2\n      1. Ordered 3\n    2. Still 3\n* Back to 1"
+            "* Level 1\n  * Level 2\n     * Level 3\n  * Back to 2\n     1. Ordered 3\n     2. Still 3\n* Back to 1"
         );
     }
 
@@ -692,16 +751,14 @@ Even more text";
    * Wrong 4";
         let ctx = LintContext::new(content);
         let fixed = rule.fix(&ctx).unwrap();
-        // Verify all items are correctly indented
+        // With dynamic alignment, items align with their parent's text content
         let lines: Vec<&str> = fixed.lines().collect();
         assert_eq!(lines[0], "* Item 1");
         assert_eq!(lines[1], "  * Wrong 1");
-        assert_eq!(lines[2], "    * Wrong 2");
-        assert_eq!(lines[3], "      * Wrong 3");
-        // The "Correct" item with 2 spaces is treated as level 3 after the 4-space item
-        // This is because MD005 tracks consistency within the current list context
-        assert_eq!(lines[4], "    * Correct");
-        assert_eq!(lines[5], "    * Wrong 4");
+        assert_eq!(lines[2], "   * Wrong 2"); // Aligns with line 2's text
+        assert_eq!(lines[3], "     * Wrong 3"); // Aligns with line 3's text
+        assert_eq!(lines[4], "   * Correct"); // Back to level 2, aligns with line 1's text
+        assert_eq!(lines[5], "   * Wrong 4"); // Same level as "Correct"
     }
 
     #[test]
@@ -791,6 +848,56 @@ Even more text";
         assert!(result.iter().any(|w| w.line == 2 && w.message.contains("found 3")));
     }
 
+    #[test]
+    fn test_nested_bullets_under_numbered_items() {
+        let rule = MD005ListIndent;
+        let content = "\
+1. **Active Directory/LDAP**
+   - User authentication and directory services
+   - LDAP for user information and validation
+
+2. **Oracle Unified Directory (OUD)**
+   - Extended user directory services
+   - Verification of project account presence and changes";
+        let ctx = LintContext::new(content);
+        let result = rule.check(&ctx).unwrap();
+        // Should have no warnings - 3 spaces is correct for bullets under numbered items
+        assert!(
+            result.is_empty(),
+            "Expected no warnings for bullets with 3 spaces under numbered items, got: {result:?}"
+        );
+    }
+
+    #[test]
+    fn test_nested_bullets_under_numbered_items_wrong_indent() {
+        let rule = MD005ListIndent;
+        let content = "\
+1. **Active Directory/LDAP**
+  - Wrong: only 2 spaces
+   - Correct: 3 spaces";
+        let ctx = LintContext::new(content);
+        let result = rule.check(&ctx).unwrap();
+        // Should flag the 2-space indentation as wrong
+        assert_eq!(result.len(), 2); // Both items flagged due to inconsistency
+        assert!(result.iter().any(|w| w.line == 2 && w.message.contains("found 2")));
+    }
+
+    #[test]
+    fn test_regular_nested_bullets_still_work() {
+        let rule = MD005ListIndent;
+        let content = "\
+* Top level
+  * Second level (2 spaces is correct for bullets under bullets)
+    * Third level (4 spaces)";
+        let ctx = LintContext::new(content);
+        let result = rule.check(&ctx).unwrap();
+        // Should have no warnings - regular bullet nesting still uses 2-space increments
+        assert!(
+            result.is_empty(),
+            "Expected no warnings for regular bullet nesting, got: {result:?}"
+        );
+    }
+
     #[test]
     fn test_fix_range_accuracy() {
         let rule = MD005ListIndent;

{rumdl-0.0.100 → rumdl-0.0.102}/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,15 +15,33 @@ 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 {
+    /// Check if a bullet is nested under an ordered list item
+    fn is_nested_under_ordered_item(
+        &self,
+        ctx: &crate::lint_context::LintContext,
+        current_line: usize,
+        current_indent: usize,
+    ) -> bool {
+        // Look backward from current line to find parent item
+        for line_idx in (1..current_line).rev() {
+            if let Some(line_info) = ctx.line_info(line_idx) {
+                if let Some(list_item) = &line_info.list_item {
+                    // Found a list item - check if it's at a lower indentation (parent level)
+                    if list_item.marker_column < current_indent {
+                        // This is a parent item - check if it's ordered
+                        return list_item.is_ordered;
+                    }
+                }
+                // If we encounter non-blank, non-list content at column 0, stop looking
+                else if !line_info.is_blank && line_info.indent == 0 {
+                    break;
+                }
+            }
+        }
+        false
+    }
+
     /// Optimized check using centralized list blocks
     fn check_optimized(&self, ctx: &crate::lint_context::LintContext) -> LintResult {
         let content = ctx.content;
@@ -56,21 +73,26 @@ impl MD006StartBullets {
                             // Top-level items are always valid
                             is_valid = true;
                         } else {
-                            // Check if this is a valid nested item
-                            match Self::find_relevant_previous_bullet(&lines, line_idx) {
-                                Some((prev_idx, prev_indent)) => {
-                                    match prev_indent.cmp(&indent) {
-                                        std::cmp::Ordering::Less | std::cmp::Ordering::Equal => {
-                                            // Valid nesting or sibling if previous item was valid
-                                            is_valid = valid_bullet_lines[prev_idx];
-                                        }
-                                        std::cmp::Ordering::Greater => {
-                                            // remains invalid
+                            // Check if this is nested under an ordered item with correct indentation (3 spaces)
+                            if indent == 3 && self.is_nested_under_ordered_item(ctx, item_line, indent) {
+                                is_valid = true;
+                            } else {
+                                // Check if this is a valid nested item under another bullet
+                                match Self::find_relevant_previous_bullet(&lines, line_idx) {
+                                    Some((prev_idx, prev_indent)) => {
+                                        match prev_indent.cmp(&indent) {
+                                            std::cmp::Ordering::Less | std::cmp::Ordering::Equal => {
+                                                // Valid nesting or sibling if previous item was valid
+                                                is_valid = valid_bullet_lines[prev_idx];
+                                            }
+                                            std::cmp::Ordering::Greater => {
+                                                // remains invalid
+                                            }
                                         }
                                     }
-                                }
-                                None => {
-                                    // Indented item with no previous bullet remains invalid
+                                    None => {
+                                        // Indented item with no previous bullet remains invalid
+                                    }
                                 }
                             }
                         }
@@ -84,7 +106,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 +145,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 +360,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
@@ -453,4 +475,58 @@ mod tests {
             "Standard nesting (* Item ->   * Item) should NOT generate warnings, found: {result:?}"
         );
     }
+
+    #[test]
+    fn test_bullets_nested_under_numbered_items() {
+        let rule = MD006StartBullets;
+        let content = "\
+1. **Active Directory/LDAP**
+   - User authentication and directory services
+   - LDAP for user information and validation
+
+2. **Oracle Unified Directory (OUD)**
+   - Extended user directory services";
+        let ctx = crate::lint_context::LintContext::new(content);
+        let result = rule.check(&ctx).unwrap();
+        // Should have no warnings - 3 spaces is valid for bullets under numbered items
+        assert!(
+            result.is_empty(),
+            "Expected no warnings for bullets with 3 spaces under numbered items, got: {result:?}"
+        );
+    }
+
+    #[test]
+    fn test_bullets_nested_under_numbered_items_wrong_indent() {
+        let rule = MD006StartBullets;
+        let content = "\
+1. **Active Directory/LDAP**
+  - Wrong: only 2 spaces
+    - Also wrong: 4 spaces";
+        let ctx = crate::lint_context::LintContext::new(content);
+        let result = rule.check(&ctx).unwrap();
+        // Should flag the incorrect indentations
+        assert_eq!(
+            result.len(),
+            2,
+            "Expected warnings for bullets with incorrect spacing under numbered items"
+        );
+        assert!(result.iter().any(|w| w.line == 2));
+        assert!(result.iter().any(|w| w.line == 3));
+    }
+
+    #[test]
+    fn test_regular_bullet_nesting_still_works() {
+        let rule = MD006StartBullets;
+        let content = "\
+* Top level
+  * Nested bullet (2 spaces is correct)
+    * Deeply nested (4 spaces)";
+        let ctx = crate::lint_context::LintContext::new(content);
+        let result = rule.check(&ctx).unwrap();
+        // Should have no warnings - standard bullet nesting still works
+        assert!(
+            result.is_empty(),
+            "Expected no warnings for standard bullet nesting, got: {result:?}"
+        );
+    }
 }