rumdl 0.0.53__tar.gz → 0.0.55__tar.gz

{rumdl-0.0.53 → rumdl-0.0.55}/Cargo.lock

@@ -1385,7 +1385,7 @@ dependencies = [
 
 [[package]]
 name = "rumdl"
-version = "0.0.53"
+version = "0.0.55"
 dependencies = [
  "anyhow",
  "assert_cmd",

{rumdl-0.0.53 → rumdl-0.0.55}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rumdl"
-version = "0.0.53"
+version = "0.0.55"
 edition = "2021"
 description = "A fast Markdown linter written in Rust (Ru(st) MarkDown Linter)"
 authors = ["Ruben J. Jongejan <ruben.jongejan@gmail.com>"]

{rumdl-0.0.53 → rumdl-0.0.55}/Makefile

@@ -12,6 +12,7 @@ clean:
 fmt:
 	cargo fmt
 	cargo clippy --fix --allow-dirty --allow-staged
+	cargo fix --allow-dirty --allow-staged
 
 lint:
 	cargo clippy --all-targets --all-features -- -D warnings
@@ -117,14 +118,14 @@ version-push:
 # Combined targets for one-step release
 release-major: version-major version-push
 release-minor: version-minor version-push
-release-patch: version-patch version-push 
+release-patch: version-patch version-push
 
 maturin-build:
 	uv run --with pip,maturin[zig],cffi maturin build --release
 
 maturin-sdist:
 	uv run --with pip,maturin[zig],cffi maturin sdist
-	
+
 run:
 	cargo run --release --bin rumdl check .
 

{rumdl-0.0.53 → rumdl-0.0.55}/PKG-INFO

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

rumdl-0.0.55/src/rules/md007_ul_indent.rs

@@ -0,0 +1,185 @@
+/// Rule MD007: Unordered list indentation
+///
+/// See [docs/md007.md](../../docs/md007.md) for full documentation, configuration, and examples.
+use crate::rule::{LintError, LintResult, LintWarning, Rule, RuleCategory, Severity};
+use crate::utils::document_structure::{DocumentStructure, DocumentStructureExtensions};
+use crate::utils::element_cache::{ElementCache, ListMarkerType};
+use lazy_static::lazy_static;
+use regex::Regex;
+use toml;
+
+#[derive(Debug, Clone)]
+pub struct MD007ULIndent {
+    pub indent: usize,
+}
+
+impl Default for MD007ULIndent {
+    fn default() -> Self {
+        Self { indent: 2 }
+    }
+}
+
+impl MD007ULIndent {
+    pub fn new(indent: usize) -> Self {
+        Self { indent }
+    }
+
+    #[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();
+        }
+
+        let lines: Vec<&str> = content.lines().collect();
+        let mut in_code_block = false;
+
+        for (i, line) in lines.iter().enumerate() {
+            if i > line_idx {
+                break;
+            }
+
+            if CODE_BLOCK_MARKER.is_match(line.trim_start()) {
+                in_code_block = !in_code_block;
+            }
+
+            if i == line_idx {
+                return in_code_block;
+            }
+        }
+
+        false
+    }
+}
+
+impl Rule for MD007ULIndent {
+    fn name(&self) -> &'static str {
+        "MD007"
+    }
+
+    fn description(&self) -> &'static str {
+        "Unordered list indentation"
+    }
+
+    fn check(&self, ctx: &crate::lint_context::LintContext) -> LintResult {
+        let content = ctx.content;
+        let element_cache = ElementCache::new(content);
+        let mut warnings = Vec::new();
+        for item in element_cache.get_list_items() {
+            // Only unordered list items
+            // Skip list items inside code blocks (including YAML/front matter)
+            if element_cache.is_in_code_block(item.line_number) {
+                continue;
+            }
+            if matches!(item.marker_type, ListMarkerType::Asterisk | ListMarkerType::Plus | ListMarkerType::Minus) {
+                let expected_indent = item.nesting_level * self.indent;
+                if item.indentation != expected_indent {
+                    warnings.push(LintWarning {
+                        rule_name: Some(self.name()),
+                        message: format!(
+                            "Incorrect indentation: expected {} spaces for nesting level {}, found {}",
+                            expected_indent, item.nesting_level, item.indentation
+                        ),
+                        line: item.line_number,
+                        column: item.blockquote_prefix.len() + item.indentation + 1, // correct column for marker
+                        severity: Severity::Warning,
+                        fix: None,
+                    });
+                }
+            }
+        }
+        Ok(warnings)
+    }
+
+    /// Optimized check using document structure
+    fn check_with_structure(
+        &self,
+        ctx: &crate::lint_context::LintContext,
+        _doc_structure: &DocumentStructure,
+    ) -> LintResult {
+        self.check(ctx)
+    }
+
+    fn fix(&self, ctx: &crate::lint_context::LintContext) -> Result<String, LintError> {
+        let content = ctx.content;
+        let element_cache = ElementCache::new(content);
+        let mut lines: Vec<&str> = content.lines().collect();
+        for item in element_cache.get_list_items() {
+            if element_cache.is_in_code_block(item.line_number) {
+                continue;
+            }
+            if matches!(item.marker_type, ListMarkerType::Asterisk | ListMarkerType::Plus | ListMarkerType::Minus) {
+                let expected_indent = item.nesting_level * self.indent;
+                if item.indentation != expected_indent {
+                    // Reconstruct the line: blockquote_prefix + correct_indent + marker + spaces_after_marker + content
+                    let correct_indent = " ".repeat(expected_indent);
+                    let marker = &item.marker;
+                    let after_marker = " ".repeat(item.spaces_after_marker.max(1));
+                    let new_line = format!(
+                        "{}{}{}{}{}",
+                        item.blockquote_prefix,
+                        correct_indent,
+                        marker,
+                        after_marker,
+                        item.content
+                    );
+                    lines[item.line_number - 1] = Box::leak(new_line.into_boxed_str());
+                }
+            }
+        }
+        Ok(lines.join("\n"))
+    }
+
+    /// Get the category of this rule for selective processing
+    fn category(&self) -> RuleCategory {
+        RuleCategory::List
+    }
+
+    /// Check if this rule should be skipped
+    fn should_skip(&self, ctx: &crate::lint_context::LintContext) -> bool {
+        ctx.content.is_empty()
+            || (!ctx.content.contains('*')
+                && !ctx.content.contains('-')
+                && !ctx.content.contains('+'))
+    }
+
+    fn as_any(&self) -> &dyn std::any::Any {
+        self
+    }
+
+    fn default_config_section(&self) -> Option<(String, toml::Value)> {
+        let mut map = toml::map::Map::new();
+        map.insert(
+            "indent".to_string(),
+            toml::Value::Integer(self.indent as i64),
+        );
+        Some((self.name().to_string(), toml::Value::Table(map)))
+    }
+
+    fn from_config(config: &crate::config::Config) -> Box<dyn Rule>
+    where
+        Self: Sized,
+    {
+        let indent =
+            crate::config::get_rule_config_value::<usize>(config, "MD007", "indent").unwrap_or(2);
+        Box::new(MD007ULIndent::new(indent))
+    }
+}
+
+impl DocumentStructureExtensions for MD007ULIndent {
+    fn has_relevant_elements(
+        &self,
+        _ctx: &crate::lint_context::LintContext,
+        doc_structure: &DocumentStructure,
+    ) -> bool {
+        // Use the document structure to check if there are any unordered list elements
+        !doc_structure.list_lines.is_empty()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::lint_context::LintContext;
+
+    // Remove test_with_document_structure, as the rule no longer uses DocumentStructure for its logic
+}

{rumdl-0.0.53 → rumdl-0.0.55}/src/rules/md030_list_marker_space.rs

@@ -7,7 +7,7 @@ use crate::rules::list_utils::ListType;
 use crate::utils::range_utils::LineIndex;
 
 use crate::lint_context::LintContext;
-use crate::rule::{Fix, LintError, LintResult, LintWarning, Rule, RuleCategory, Severity};
+use crate::rule::{Fix, LintResult, LintWarning, Rule, RuleCategory, Severity};
 use crate::utils::document_structure::{DocumentStructure, DocumentStructureExtensions};
 use fancy_regex::Regex;
 use lazy_static::lazy_static;
@@ -73,68 +73,6 @@ impl MD030ListMarkerSpace {
             line.to_string()
         }
     }
-
-    fn precompute_states(&self, lines: &[&str]) -> (Vec<bool>, Vec<bool>) {
-        let mut is_list_line = vec![false; lines.len()];
-        let mut multi_line = vec![false; lines.len()];
-        let mut in_code_block = false;
-
-        // First pass: mark code blocks and list items
-        for (i, &line) in lines.iter().enumerate() {
-            if CODE_BLOCK_REGEX.is_match(line).unwrap_or(false) {
-                in_code_block = !in_code_block;
-                continue;
-            }
-            if !in_code_block {
-                // Check both patterns
-                if let Ok(Some(_)) = LIST_REGEX.captures(line) {
-                    is_list_line[i] = true;
-                } else if let Ok(Some(_)) = LIST_NO_SPACE_REGEX.captures(line) {
-                    is_list_line[i] = true;
-                }
-            }
-        }
-
-        // Second pass: compute multi-line states
-        for i in 0..lines.len() {
-            if is_list_line[i] {
-                let mut found_continuation = false;
-                let curr_indent = lines[i].chars().take_while(|c| c.is_whitespace()).count();
-                let j = i + 1;
-                while j < lines.len() {
-                    let next_line = lines[j];
-                    if next_line.trim().is_empty() {
-                        found_continuation = true; // blank line always makes multi-line
-                        break;
-                    }
-                    let next_indent = next_line.chars().take_while(|c| c.is_whitespace()).count();
-                    let is_next_list = LIST_REGEX.captures(next_line).is_ok()
-                        && LIST_REGEX.captures(next_line).as_ref().unwrap().is_some()
-                        || LIST_NO_SPACE_REGEX.captures(next_line).is_ok()
-                            && LIST_NO_SPACE_REGEX
-                                .captures(next_line)
-                                .as_ref()
-                                .unwrap()
-                                .is_some();
-                    if is_next_list {
-                        if next_indent > curr_indent {
-                            found_continuation = true; // parent of nested list is multi-line
-                        }
-                        break;
-                    }
-                    if next_indent > curr_indent {
-                        found_continuation = true; // paragraph continuation
-                        break;
-                    } else {
-                        break;
-                    }
-                }
-                multi_line[i] = found_continuation;
-            }
-        }
-
-        (is_list_line, multi_line)
-    }
 }
 
 impl Rule for MD030ListMarkerSpace {
@@ -387,48 +325,6 @@ impl Rule for MD030ListMarkerSpace {
         Ok(warnings)
     }
 
-    fn fix(&self, ctx: &LintContext) -> Result<String, LintError> {
-        let content = ctx.content;
-        let mut fixed_lines = Vec::new();
-        let lines: Vec<&str> = content.lines().collect();
-        let (is_list_line, multi_line) = self.precompute_states(&lines);
-        for (i, &line) in lines.iter().enumerate() {
-            if !is_list_line[i] {
-                fixed_lines.push(line.to_string());
-                continue;
-            }
-            // Use LIST_FIX_REGEX to capture marker, spaces, and rest of line
-            if let Ok(Some(caps)) = LIST_FIX_REGEX.captures(line) {
-                let indent = caps.get(1).map_or("", |m| m.as_str());
-                let marker = caps.get(2).map_or("", |m| m.as_str());
-                let spaces = caps.get(3).map_or("", |m| m.as_str());
-                let after = &line[(indent.len() + marker.len() + spaces.len())..];
-                let actual_spaces = spaces.len();
-                let required_spaces = if multi_line[i] {
-                    self.ul_multi
-                } else {
-                    self.ul_single
-                };
-                if actual_spaces < required_spaces {
-                    let fixed_line = format!(
-                        "{}{}{}{}",
-                        indent,
-                        marker,
-                        " ".repeat(required_spaces),
-                        after
-                    );
-                    fixed_lines.push(fixed_line);
-                } else {
-                    fixed_lines.push(line.to_string());
-                }
-                continue;
-            } else {
-                fixed_lines.push(line.to_string());
-            }
-        }
-        Ok(fixed_lines.join("\n"))
-    }
-
     /// Get the category of this rule for selective processing
     fn category(&self) -> RuleCategory {
         RuleCategory::List
@@ -487,6 +383,10 @@ impl Rule for MD030ListMarkerSpace {
             ul_single, ul_multi, ol_single, ol_multi,
         ))
     }
+
+    fn fix(&self, _ctx: &crate::lint_context::LintContext) -> Result<String, crate::rule::LintError> {
+        Err(crate::rule::LintError::FixFailed("Automatic fixing is not supported for MD030. See todos/md030_fix_strategy.md for details.".to_string()))
+    }
 }
 
 impl DocumentStructureExtensions for MD030ListMarkerSpace {

{rumdl-0.0.53 → rumdl-0.0.55}/src/rules/md035_hr_style.rs

@@ -57,23 +57,35 @@ impl MD035HRStyle {
         }
 
         let line = lines[i].trim();
-
         let prev_line = lines[i - 1].trim();
 
-        // Check if the current line is all dashes or equals signs
-
         let is_dash_line = !line.is_empty() && line.chars().all(|c| c == '-');
-
         let is_equals_line = !line.is_empty() && line.chars().all(|c| c == '=');
-
-        // Check if the previous line is not empty and not a horizontal rule
-
         let prev_line_has_content = !prev_line.is_empty() && !Self::is_horizontal_rule(prev_line);
-
-        // If the current line is all dashes or equals signs and the previous line has content,
-        // it's likely a Setext heading
         (is_dash_line || is_equals_line) && prev_line_has_content
     }
+
+    /// Find the most prevalent HR style in the document (excluding setext headings)
+    fn most_prevalent_hr_style(lines: &[&str]) -> Option<String> {
+        use std::collections::HashMap;
+        let mut counts: HashMap<&str, usize> = HashMap::new();
+        let mut order: Vec<&str> = Vec::new();
+        for (i, line) in lines.iter().enumerate() {
+            if Self::is_horizontal_rule(line) && !Self::is_potential_setext_heading(lines, i) {
+                let style = line.trim();
+                let counter = counts.entry(style).or_insert(0);
+                *counter += 1;
+                if *counter == 1 {
+                    order.push(style);
+                }
+            }
+        }
+        // Find the style with the highest count, breaking ties by first encountered
+        counts
+            .iter()
+            .max_by_key(|&(style, count)| (*count, -(order.iter().position(|&s| s == *style).unwrap_or(usize::MAX) as isize)))
+            .map(|(style, _)| style.to_string())
+    }
 }
 
 impl Rule for MD035HRStyle {
@@ -90,21 +102,11 @@ impl Rule for MD035HRStyle {
         let _line_index = LineIndex::new(content.to_string());
 
         let mut warnings = Vec::new();
-
         let lines: Vec<&str> = content.lines().collect();
 
-        // Use the configured style or find the first HR style
-
-        let expected_style = if self.style.is_empty() {
-            // Find the first HR in the document
-            let mut first_style = "---".to_string(); // Default if none found
-            for (i, line) in lines.iter().enumerate() {
-                if Self::is_horizontal_rule(line) && !Self::is_potential_setext_heading(&lines, i) {
-                    first_style = line.trim().to_string();
-                    break;
-                }
-            }
-            first_style
+        // Use the configured style or find the most prevalent HR style
+        let expected_style = if self.style.is_empty() || self.style == "consistent" {
+            Self::most_prevalent_hr_style(&lines).unwrap_or_else(|| "---".to_string())
         } else {
             self.style.clone()
         };
@@ -148,21 +150,11 @@ impl Rule for MD035HRStyle {
         let _line_index = LineIndex::new(content.to_string());
 
         let mut result = Vec::new();
-
         let lines: Vec<&str> = content.lines().collect();
 
-        // Use the configured style or find the first HR style
-
-        let expected_style = if self.style.is_empty() {
-            // Find the first HR in the document
-            let mut first_style = "---".to_string(); // Default if none found
-            for (i, line) in lines.iter().enumerate() {
-                if Self::is_horizontal_rule(line) && !Self::is_potential_setext_heading(&lines, i) {
-                    first_style = line.trim().to_string();
-                    break;
-                }
-            }
-            first_style
+        // Use the configured style or find the most prevalent HR style
+        let expected_style = if self.style.is_empty() || self.style == "consistent" {
+            Self::most_prevalent_hr_style(&lines).unwrap_or_else(|| "---".to_string())
         } else {
             self.style.clone()
         };
@@ -174,9 +166,6 @@ impl Rule for MD035HRStyle {
                 continue;
             }
 
-            let _trimmed = line.trim();
-
-            // Simplify the horizontal rule detection and replacement
             if Self::is_horizontal_rule(line) {
                 // Here we have a proper horizontal rule - replace it with the expected style
                 result.push(expected_style.clone());