rumdl 0.0.75__tar.gz → 0.0.77__tar.gz

{rumdl-0.0.75 → rumdl-0.0.77}/Cargo.lock

@@ -244,9 +244,9 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
 [[package]]
 name = "cc"
-version = "1.2.24"
+version = "1.2.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16595d3be041c03b09d08d0858631facccee9221e579704070e6e9e4915d3bc7"
+checksum = "d0fc897dc1e865cc67c0e05a836d9d3f1df3cbe442aa4a9473b18e12624a4951"
 dependencies = [
  "shlex",
 ]
@@ -869,12 +869,6 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
-[[package]]
-name = "hermit-abi"
-version = "0.3.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024"
-
 [[package]]
 name = "hermit-abi"
 version = "0.5.1"
@@ -1069,7 +1063,7 @@ version = "0.4.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e04d7f318608d35d4b61ddd75cbdaee86b023ebe2bd5a66ee0915f0bf93095a9"
 dependencies = [
- "hermit-abi 0.5.1",
+ "hermit-abi",
  "libc",
  "windows-sys 0.59.0",
 ]
@@ -1175,9 +1169,9 @@ checksum = "241eaef5fd12c88705a01fc1066c48c4b36e0dd4377dcdc7ec3942cea7a69956"
 
 [[package]]
 name = "lock_api"
-version = "0.4.12"
+version = "0.4.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07af8b9cdd281b7915f413fa73f29ebd5d55d0d3f0155584dade1ff18cea1b17"
+checksum = "96936507f153605bddfcda068dd804796c84324ed2510809e5b2a624c81da765"
 dependencies = [
  "autocfg",
  "scopeguard",
@@ -1272,11 +1266,11 @@ dependencies = [
 
 [[package]]
 name = "num_cpus"
-version = "1.16.0"
+version = "1.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43"
+checksum = "91df4bbde75afed763b708b7eee1e8e7651e02d97f6d5dd763e89367e957b23b"
 dependencies = [
- "hermit-abi 0.3.9",
+ "hermit-abi",
  "libc",
 ]
 
@@ -1325,9 +1319,9 @@ dependencies = [
 
 [[package]]
 name = "parking_lot"
-version = "0.12.3"
+version = "0.12.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1bf18183cf54e8d6059647fc3063646a1801cf30896933ec2311622cc4b9a27"
+checksum = "70d58bf43669b5795d1576d0641cfb6fbb2057bf629506267a92807158584a13"
 dependencies = [
  "lock_api",
  "parking_lot_core",
@@ -1335,9 +1329,9 @@ dependencies = [
 
 [[package]]
 name = "parking_lot_core"
-version = "0.9.10"
+version = "0.9.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8"
+checksum = "bc838d2a56b5b1a6c25f55575dfc605fabb63bb2365f6c2353ef9159aa69e4a5"
 dependencies = [
  "cfg-if",
  "libc",
@@ -1789,7 +1783,7 @@ dependencies = [
 
 [[package]]
 name = "rumdl"
-version = "0.0.75"
+version = "0.0.77"
 dependencies = [
  "anyhow",
  "assert_cmd",

{rumdl-0.0.75 → rumdl-0.0.77}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rumdl"
-version = "0.0.75"
+version = "0.0.77"
 edition = "2021"
 description = "A fast Markdown linter written in Rust (Ru(st) MarkDown Linter)"
 authors = ["Ruben J. Jongejan <ruben.jongejan@gmail.com>"]
@@ -21,6 +21,26 @@ crate-type = ["cdylib", "rlib"]
 name = "rumdl"
 path = "src/main.rs"
 
+[[bench]]
+name = "rule_performance"
+harness = false
+
+[[bench]]
+name = "fix_performance"
+harness = false
+
+[[bench]]
+name = "range_performance"
+harness = false
+
+[[bench]]
+name = "simple_fix_bench"
+harness = false
+
+[[bench]]
+name = "range_utils_benchmark"
+harness = false
+
 [dependencies]
 clap = { version = "4.5", features = ["derive"] }
 colored = "3.0.0"

{rumdl-0.0.75 → rumdl-0.0.77}/PKG-INFO

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

rumdl-0.0.77/src/rules/md005_list_indent.rs

@@ -0,0 +1,451 @@
+//!
+//! Rule MD005: Inconsistent indentation for list items at the same level
+//!
+//! See [docs/md005.md](../../docs/md005.md) for full documentation, configuration, and examples.
+
+use crate::utils::range_utils::{calculate_match_range, LineIndex};
+
+use crate::rule::{Fix, LintError, LintResult, LintWarning, Rule, RuleCategory, Severity};
+use crate::utils::document_structure::DocumentStructure;
+use lazy_static::lazy_static;
+use regex::Regex;
+use std::collections::HashMap;
+use toml;
+
+lazy_static! {
+    static ref LIST_MARKER_REGEX: Regex = Regex::new(r"^\d+[.)]").unwrap();
+    // Pre-compiled pattern for quick list detection
+    static ref QUICK_LIST_CHECK: Regex = Regex::new(r"^( *)([*+\-]|\d+[.)])").unwrap();
+}
+
+/// Rule MD005: Inconsistent indentation for list items at the same level
+#[derive(Clone)]
+pub struct MD005ListIndent;
+
+impl MD005ListIndent {
+    #[inline]
+    fn get_list_marker_info(line: &str) -> Option<(usize, char, usize)> {
+        // Early return for empty or whitespace-only lines
+        if line.is_empty() || line.trim().is_empty() {
+            return None;
+        }
+
+        let indentation = line.len() - line.trim_start().len();
+        let trimmed = line.trim_start();
+
+        // Fast path check for unordered list markers
+        if !trimmed.is_empty() {
+            let first_char = trimmed.chars().next().unwrap();
+
+            // Check for unordered list markers (* - +)
+            if (first_char == '*' || first_char == '-' || first_char == '+')
+                && trimmed.len() > 1
+                && trimmed.chars().nth(1).map_or(false, |c| c.is_whitespace())
+            {
+                return Some((indentation, first_char, 1)); // 1 char marker
+            }
+
+            // Fast path check for ordered list markers (digits followed by . or ))
+            if first_char.is_ascii_digit() {
+                if let Some(marker_match) = LIST_MARKER_REGEX.find(trimmed) {
+                    let marker_char = trimmed.chars().nth(marker_match.end() - 1).unwrap();
+                    if trimmed.len() > marker_match.end()
+                        && trimmed
+                            .chars()
+                            .nth(marker_match.end())
+                            .map_or(false, |c| c.is_whitespace())
+                    {
+                        return Some((indentation, marker_char, marker_match.end()));
+                    }
+                }
+            }
+        }
+
+        None
+    }
+
+    #[inline]
+    fn is_blank_line(line: &str) -> bool {
+        line.trim().is_empty()
+    }
+
+    // Determine the expected indentation for a list item at a specific level
+    #[inline]
+    fn get_expected_indent(level: usize) -> usize {
+        if level == 1 {
+            0 // Top level items should be at the start of the line
+        } else {
+            2 * (level - 1) // Nested items should be indented by 2 spaces per level
+        }
+    }
+
+    // Determine if a line is a continuation of a list item
+    #[inline]
+    fn is_list_continuation(prev_line: &str, current_line: &str) -> bool {
+        // Early return for empty lines
+        if current_line.trim().is_empty() {
+            return false;
+        }
+
+        // If the previous line is a list item and the current line has more indentation
+        // but is not a list item itself, it's a continuation
+        if let Some((prev_indent, _, _)) = Self::get_list_marker_info(prev_line) {
+            let current_indent = current_line.len() - current_line.trim_start().len();
+            return current_indent > prev_indent
+                && Self::get_list_marker_info(current_line).is_none();
+        }
+        false
+    }
+
+    /// Optimized check that combines all passes into one
+    fn check_optimized(&self, ctx: &crate::lint_context::LintContext) -> LintResult {
+        let content = ctx.content;
+
+        // Early returns for common cases
+        if content.is_empty() {
+            return Ok(Vec::new());
+        }
+
+        // Quick check to avoid processing files without list markers
+        if !QUICK_LIST_CHECK.is_match(content) {
+            return Ok(Vec::new());
+        }
+
+        let line_index = LineIndex::new(content.to_string());
+        let lines: Vec<&str> = content.lines().collect();
+
+        // Early return if there are no lines
+        if lines.is_empty() {
+            return Ok(Vec::new());
+        }
+
+        let mut warnings = Vec::new();
+
+        // Pre-compute code blocks once
+        let mut in_code_blocks = vec![false; lines.len()];
+        let mut in_block = false;
+        for (i, line) in lines.iter().enumerate() {
+            let trimmed = line.trim();
+            if trimmed.starts_with("```") || trimmed.starts_with("~~~") {
+                in_block = !in_block;
+            }
+            in_code_blocks[i] = in_block;
+        }
+
+        // Single pass processing with efficient data structures
+        let mut list_items: Vec<(usize, usize, usize)> = Vec::new(); // (line_num, indent, list_id)
+        let mut current_list_id = 0;
+        let mut in_list = false;
+        let mut list_level_maps: HashMap<usize, HashMap<usize, usize>> = HashMap::new(); // list_id -> { indent -> level }
+        let mut level_indents: HashMap<(usize, usize), usize> = HashMap::new(); // (list_id, level) -> expected_indent
+
+        for (line_num, line) in lines.iter().enumerate() {
+            // Skip blank lines and code blocks
+            if Self::is_blank_line(line) || in_code_blocks[line_num] {
+                continue;
+            }
+
+            // Check if this is a list item
+            if let Some((indent, _marker, _)) = Self::get_list_marker_info(line) {
+                // Determine if this starts a new list
+                let is_new_list = !in_list
+                    || indent == 0
+                    || (list_items.last().map_or(false, |(_, prev_indent, _)| {
+                        prev_indent > &0 && indent < prev_indent / 2
+                    }));
+
+                if is_new_list {
+                    current_list_id += 1;
+                    in_list = true;
+                }
+
+                // Determine level for this item
+                let level_map = list_level_maps.entry(current_list_id).or_default();
+                let level = if level_map.is_empty() {
+                    level_map.insert(indent, 1);
+                    level_indents.insert((current_list_id, 1), indent);
+                    1
+                } else {
+                    // Find appropriate level
+                    if let Some(&existing_level) = level_map.get(&indent) {
+                        existing_level
+                    } else {
+                        // Find parent level
+                        let mut level = 1;
+                        let mut parent_indent = 0;
+
+                        for (&prev_indent, &prev_level) in level_map.iter() {
+                            if prev_indent < indent && (prev_level >= level || prev_indent > parent_indent) {
+                                level = prev_level + 1;
+                                parent_indent = prev_indent;
+                            }
+                        }
+
+                        level_map.insert(indent, level);
+                        level
+                    }
+                };
+
+                list_items.push((line_num, indent, current_list_id));
+
+                // Check indentation immediately
+                let expected_indent = Self::get_expected_indent(level);
+                if indent != expected_indent {
+                    let inconsistent_message = format!(
+                        "List item indentation is {} {}, expected {} for level {}",
+                        indent,
+                        if indent == 1 { "space" } else { "spaces" },
+                        expected_indent,
+                        level
+                    );
+
+                    let (start_line, start_col, end_line, end_col) = if indent > 0 {
+                        calculate_match_range(line_num + 1, line, 0, indent)
+                    } else {
+                        calculate_match_range(line_num + 1, line, 0, 1)
+                    };
+
+                    // Fix range should span from start of line to end of indentation
+                    let fix_range = if indent > 0 {
+                        // Replace the current indentation with expected indentation
+                        let start_byte = line_index.line_col_to_byte_range(line_num + 1, 1).start;
+                        let end_byte = line_index.line_col_to_byte_range(line_num + 1, indent + 1).start;
+                        start_byte..end_byte
+                    } else {
+                        // For no indentation, insert at start of line
+                        let byte_pos = line_index.line_col_to_byte_range(line_num + 1, 1).start;
+                        byte_pos..byte_pos
+                    };
+
+                    // Replacement should be just the corrected indentation
+                    let replacement = if expected_indent > 0 {
+                        " ".repeat(expected_indent)
+                    } else {
+                        String::new()
+                    };
+
+                    warnings.push(LintWarning {
+                        rule_name: Some(self.name()),
+                        line: start_line,
+                        column: start_col,
+                        end_line,
+                        end_column: end_col,
+                        message: inconsistent_message,
+                        severity: Severity::Warning,
+                        fix: Some(Fix {
+                            range: fix_range,
+                            replacement,
+                        }),
+                    });
+                }
+
+                // Track level consistency
+                let key = (current_list_id, level);
+                if let Some(reference_indent) = level_indents.get(&key) {
+                    if indent != *reference_indent {
+                        let inconsistent_message = format!(
+                            "List item indentation is inconsistent with other items at the same level (found: {}, expected: {})",
+                            indent, reference_indent
+                        );
+
+                        // Only add if we don't already have a warning for this line
+                        if !warnings.iter().any(|w| w.line == line_num + 1) {
+                            let (start_line, start_col, end_line, end_col) = if indent > 0 {
+                                calculate_match_range(line_num + 1, line, 0, indent)
+                            } else {
+                                calculate_match_range(line_num + 1, line, 0, 1)
+                            };
+
+                            // Fix range should span from start of line to end of indentation
+                            let fix_range = if indent > 0 {
+                                // Replace the current indentation with expected indentation
+                                let start_byte = line_index.line_col_to_byte_range(line_num + 1, 1).start;
+                                let end_byte = line_index.line_col_to_byte_range(line_num + 1, indent + 1).start;
+                                start_byte..end_byte
+                            } else {
+                                // For no indentation, insert at start of line
+                                let byte_pos = line_index.line_col_to_byte_range(line_num + 1, 1).start;
+                                byte_pos..byte_pos
+                            };
+
+                            // Replacement should be just the corrected indentation
+                            let replacement = if *reference_indent > 0 {
+                                " ".repeat(*reference_indent)
+                            } else {
+                                String::new()
+                            };
+
+                            warnings.push(LintWarning {
+                                rule_name: Some(self.name()),
+                                line: start_line,
+                                column: start_col,
+                                end_line,
+                                end_column: end_col,
+                                message: inconsistent_message,
+                                severity: Severity::Warning,
+                                fix: Some(Fix {
+                                    range: fix_range,
+                                    replacement,
+                                }),
+                            });
+                        }
+                    }
+                } else {
+                    level_indents.insert(key, indent);
+                }
+
+            } else {
+                // Check if it's a list continuation
+                if list_items.is_empty() || !in_list {
+                    continue;
+                }
+
+                let (prev_line_num, _, _) = list_items.last().unwrap();
+                if !Self::is_list_continuation(lines[*prev_line_num], line) {
+                    in_list = false;
+                }
+            }
+        }
+
+        Ok(warnings)
+    }
+}
+
+impl Default for MD005ListIndent {
+    fn default() -> Self {
+        Self
+    }
+}
+
+impl Rule for MD005ListIndent {
+    fn name(&self) -> &'static str {
+        "MD005"
+    }
+
+    fn description(&self) -> &'static str {
+        "List indentation should be consistent"
+    }
+
+    fn check(&self, ctx: &crate::lint_context::LintContext) -> LintResult {
+        // Use optimized version
+        self.check_optimized(ctx)
+    }
+
+    fn fix(&self, ctx: &crate::lint_context::LintContext) -> Result<String, LintError> {
+        let warnings = self.check(ctx)?;
+        if warnings.is_empty() {
+            return Ok(ctx.content.to_string());
+        }
+
+        // Sort warnings by position (descending) to apply from end to start
+        let mut warnings_with_fixes: Vec<_> = warnings
+            .into_iter()
+            .filter_map(|w| {
+                if let Some(fix) = w.fix.clone() {
+                    Some((w, fix))
+                } else {
+                    None
+                }
+            })
+            .collect();
+        warnings_with_fixes.sort_by_key(|(_, fix)| std::cmp::Reverse(fix.range.start));
+
+        // Apply fixes to content
+        let mut content = ctx.content.to_string();
+        for (_, fix) in warnings_with_fixes {
+            if fix.range.start <= content.len() && fix.range.end <= content.len() {
+                content.replace_range(fix.range, &fix.replacement);
+            }
+        }
+
+        Ok(content)
+    }
+
+    fn category(&self) -> RuleCategory {
+        RuleCategory::List
+    }
+
+    /// Check if this rule should be skipped
+    fn should_skip(&self, ctx: &crate::lint_context::LintContext) -> bool {
+        let content = ctx.content;
+        content.is_empty() || !QUICK_LIST_CHECK.is_match(content)
+    }
+
+    /// Optimized check using document structure
+    fn check_with_structure(
+        &self,
+        ctx: &crate::lint_context::LintContext,
+        structure: &DocumentStructure,
+    ) -> LintResult {
+        // If no lists in structure, return early
+        if structure.list_lines.is_empty() {
+            return Ok(Vec::new());
+        }
+
+        // Use optimized check - it's already efficient enough
+        self.check_optimized(ctx)
+    }
+
+    fn as_any(&self) -> &dyn std::any::Any {
+        self
+    }
+
+    fn as_maybe_document_structure(&self) -> Option<&dyn crate::rule::MaybeDocumentStructure> {
+        Some(self)
+    }
+
+    fn default_config_section(&self) -> Option<(String, toml::Value)> {
+        None
+    }
+
+    fn from_config(_config: &crate::config::Config) -> Box<dyn Rule>
+    where
+        Self: Sized,
+    {
+        Box::new(MD005ListIndent)
+    }
+}
+
+impl crate::utils::document_structure::DocumentStructureExtensions for MD005ListIndent {
+    fn has_relevant_elements(
+        &self,
+        _ctx: &crate::lint_context::LintContext,
+        doc_structure: &crate::utils::document_structure::DocumentStructure,
+    ) -> bool {
+        !doc_structure.list_lines.is_empty()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::lint_context::LintContext;
+
+    // ... existing tests ...
+
+    #[test]
+    fn test_with_document_structure() {
+        let rule = MD005ListIndent;
+
+        // Test with consistent list indentation
+        let content = "* Item 1\n* Item 2\n  * Nested item\n  * Another nested item";
+        let structure = DocumentStructure::new(content);
+        let ctx = LintContext::new(content);
+        let result = rule.check_with_structure(&ctx, &structure).unwrap();
+        assert!(result.is_empty());
+
+        // Test with inconsistent list indentation
+        let content = "* Item 1\n* Item 2\n * Nested item\n  * Another nested item";
+        let structure = DocumentStructure::new(content);
+        let ctx = LintContext::new(content);
+        let result = rule.check_with_structure(&ctx, &structure).unwrap();
+        assert!(!result.is_empty()); // Should have at least one warning
+
+        // Test with different level indentation issues
+        let content = "* Item 1\n  * Nested item\n * Another nested item with wrong indent";
+        let structure = DocumentStructure::new(content);
+        let ctx = LintContext::new(content);
+        let result = rule.check_with_structure(&ctx, &structure).unwrap();
+        assert!(!result.is_empty()); // Should have at least one warning
+    }
+}

{rumdl-0.0.75 → rumdl-0.0.77}/src/rules/md006_start_bullets.rs

@@ -237,20 +237,21 @@ impl Rule for MD006StartBullets {
                 valid_bullet_lines[line_idx] = is_valid;
 
                 if !is_valid {
-                    let fixed_line = line.trim_start();
-                    let needs_blank_line = line_idx > 0
-                        && !Self::is_blank_line(lines[line_idx - 1])
-                        && Self::is_bullet_list_item(lines[line_idx - 1]).is_none();
-                    let replacement = if needs_blank_line {
-                        format!("\n{}", fixed_line)
+                    // Calculate the precise range for the indentation that needs to be removed
+                    // For "  * Indented bullet", we want to highlight the indentation, marker, and space after marker "  * " (columns 1-4)
+                    let start_col = 1; // Start from beginning of line
+                    let end_col = indent + 3; // Include marker and space after it (indent + 1 for marker + 1 for space + 1 for inclusive range)
+
+                    // For the fix, we need to replace the highlighted part ("  *") with just the bullet marker ("* ")
+                    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) {
+                        format!("{} ", captures.get(2).unwrap().as_str()) // Always use single space
                     } else {
-                        fixed_line.to_string()
+                        "* ".to_string() // fallback
                     };
-
-                    // Calculate the range to highlight: from first indentation character to end of list marker
-                    let start_col = if indent > 0 { 2 } else { 1 }; // Start from first indentation space if indented
-                    let marker_pos = line.find(|c: char| c == '*' || c == '-' || c == '+').unwrap_or(0);
-                    let end_col = marker_pos + 3; // +1 for the marker itself, +1 for 1-based indexing, +1 for space after marker
+                    let replacement = bullet_part;
 
                     result.push(LintWarning {
                 rule_name: Some(self.name()),
@@ -261,8 +262,12 @@ impl Rule for MD006StartBullets {
                 end_column: end_col,
                 message: "List item indentation".to_string(),
                 fix: Some(Fix {
-                range: line_index.line_col_to_byte_range(line_num, 1),
-                replacement,
+                    range: {
+                        let start_byte = line_index.line_col_to_byte_range(line_num, start_col).start;
+                        let end_byte = line_index.line_col_to_byte_range(line_num, end_col).start;
+                        start_byte..end_byte
+                    },
+                    replacement,
             }),
                     });
                 }