rumdl 0.0.53__tar.gz → 0.0.54__tar.gz

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

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

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

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

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

rumdl-0.0.54/src/rules/md007_ul_indent.rs

@@ -0,0 +1,222 @@
+/// Rule MD007: Unordered list indentation
+///
+/// See [docs/md007.md](../../docs/md007.md) for full documentation, configuration, and examples.
+use crate::rule::{Fix, LintError, LintResult, LintWarning, Rule, RuleCategory, Severity};
+use crate::utils::document_structure::{DocumentStructure, DocumentStructureExtensions};
+use crate::utils::element_cache::{ElementCache, ListMarkerType};
+use crate::utils::range_utils::LineIndex;
+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 }
+    }
+
+    /// Detect code blocks, including those inside blockquotes
+    fn compute_code_block_lines(content: &str) -> std::collections::HashSet<usize> {
+        let mut code_block_lines = std::collections::HashSet::new();
+        let mut in_code_block = false;
+        let mut fence: Option<String> = None;
+        for (i, line) in content.lines().enumerate() {
+            let trimmed = line.trim_start();
+            if !in_code_block {
+                if trimmed.starts_with("```") || trimmed.starts_with("~~~") {
+                    in_code_block = true;
+                    fence = Some(trimmed[..3].to_string());
+                    code_block_lines.insert(i + 1);
+                    continue;
+                }
+            } else {
+                code_block_lines.insert(i + 1);
+                if let Some(ref f) = fence {
+                    if trimmed.starts_with(f) {
+                        in_code_block = false;
+                        fence = None;
+                    }
+                }
+                continue;
+            }
+        }
+        code_block_lines
+    }
+
+    #[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;
+                println!(
+                    "MD007 DEBUG: line {} | indent={} | nesting={} | expected={} | emit_warning={}",
+                    item.line_number,
+                    item.indentation,
+                    item.nesting_level,
+                    expected_indent,
+                    item.indentation != expected_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.54}/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());

{rumdl-0.0.53 → rumdl-0.0.54}/src/utils/element_cache.rs

@@ -10,8 +10,8 @@ lazy_static! {
     static ref INDENTED_CODE_BLOCK_REGEX: Regex = Regex::new(r"^(\s{4,})(.+)$").unwrap();
 
     // List detection patterns
-    static ref UNORDERED_LIST_REGEX: FancyRegex = FancyRegex::new(r"^(?P<indent>[ \t]*)(?P<marker>[*+-])(?P<after>[ \t]+)(?P<content>.*)$").unwrap();
-    static ref ORDERED_LIST_REGEX: FancyRegex = FancyRegex::new(r"^(?P<indent>[ \t]*)(?P<marker>\d+\.)(?P<after>[ \t]+)(?P<content>.*)$").unwrap();
+    static ref UNORDERED_LIST_REGEX: FancyRegex = FancyRegex::new(r"^(?P<indent>[ \t]*)(?P<marker>[*+-])(?P<after>[ \t]*)(?P<content>.*)$").unwrap();
+    static ref ORDERED_LIST_REGEX: FancyRegex = FancyRegex::new(r"^(?P<indent>[ \t]*)(?P<marker>\d+\.)(?P<after>[ \t]*)(?P<content>.*)$").unwrap();
 
     // Inline code span pattern
     static ref CODE_SPAN_REGEX: Regex = Regex::new(r"`+").unwrap();
@@ -62,6 +62,8 @@ pub struct ListItem {
     pub spaces_after_marker: usize,
     pub nesting_level: usize,
     pub parent_line_number: Option<usize>,
+    pub blockquote_depth: usize, // Number of leading blockquote markers
+    pub blockquote_prefix: String, // The actual prefix (e.g., "> > ")
 }
 
 /// Cache for Markdown document structural elements
@@ -279,31 +281,92 @@ impl ElementCache {
     fn populate_list_items(&mut self) {
         if let Some(content) = &self.content {
             let lines: Vec<&str> = content.lines().collect();
-            let mut prev_items: Vec<(usize, usize)> = Vec::new(); // (nesting_level, line_number)
+            let mut prev_items: Vec<(usize, usize, usize)> = Vec::new(); // (blockquote_depth, nesting_level, line_number)
             for (i, line) in lines.iter().enumerate() {
                 // Reset stack on blank lines
                 if line.trim().is_empty() {
                     prev_items.clear(); // Reset nesting after blank line
                     continue;
                 }
-                // Always try to match a list item, regardless of indentation
-                if let Some(item) = self.parse_list_item(line, i + 1, &mut prev_items) {
+                // Parse and strip blockquote prefix
+                let (blockquote_depth, blockquote_prefix, rest) = Self::parse_blockquote_prefix(line);
+                // Always call parse_list_item and always push if Some
+                if let Some(item) = self.parse_list_item(rest, i + 1, &mut prev_items, blockquote_depth, blockquote_prefix.clone()) {
                     self.list_items.push(item);
                     self.list_line_map[i] = true;
-                    continue; // If it's a list item, do not treat as code block
                 }
-                // If not a list item, mark as code block if indented (4+ spaces)
-                // (This is for completeness, but code block map is handled elsewhere)
             }
         }
     }
 
+    /// Parse and strip all leading blockquote markers, returning (depth, prefix, rest_of_line)
+    fn parse_blockquote_prefix(line: &str) -> (usize, String, &str) {
+        let mut rest = line;
+        let mut prefix = String::new();
+        let mut depth = 0;
+        loop {
+            let trimmed = rest.trim_start();
+            if trimmed.starts_with('>') {
+                // Find the '>' and a single optional space
+                let after = &trimmed[1..];
+                let mut chars = after.chars();
+                let mut space_count = 0;
+                if let Some(' ') = chars.next() {
+                    space_count = 1;
+                }
+                let (spaces, after_marker) = after.split_at(space_count);
+                prefix.push('>');
+                prefix.push_str(spaces);
+                rest = after_marker;
+                depth += 1;
+            } else {
+                break;
+            }
+        }
+        (depth, prefix, rest)
+    }
+
+    /// Calculate the nesting level for a list item, considering blockquote depth
+    fn calculate_nesting_level(
+        &self,
+        indent: usize,
+        blockquote_depth: usize,
+        prev_items: &mut Vec<(usize, usize, usize)>,
+    ) -> usize {
+        // Only consider previous items with the same blockquote depth
+        let mut nesting_level = 0;
+        if let Some(&(last_bq, last_indent, last_level)) = prev_items.iter().rev().find(|(bq, _, _)| *bq == blockquote_depth) {
+            if indent >= last_indent + 2 {
+                nesting_level = last_level + 1;
+            } else {
+                // Walk back to find the most recent indent <= current indent with same blockquote depth
+                for &(prev_bq, prev_indent, prev_level) in prev_items.iter().rev() {
+                    if prev_bq == blockquote_depth && prev_indent <= indent {
+                        nesting_level = prev_level;
+                        break;
+                    }
+                }
+            }
+        }
+        // Remove stack entries with indent >= current indent and same blockquote depth
+        while let Some(&(prev_bq, prev_indent, _)) = prev_items.last() {
+            if prev_bq != blockquote_depth || prev_indent < indent {
+                break;
+            }
+            prev_items.pop();
+        }
+        prev_items.push((blockquote_depth, indent, nesting_level));
+        nesting_level
+    }
+
     /// Parse a line as a list item and determine its nesting level
     fn parse_list_item(
         &self,
         line: &str,
         line_num: usize,
-        prev_items: &mut Vec<(usize, usize)>,
+        prev_items: &mut Vec<(usize, usize, usize)>,
+        blockquote_depth: usize,
+        blockquote_prefix: String,
     ) -> Option<ListItem> {
         match UNORDERED_LIST_REGEX.captures(line) {
             Ok(Some(captures)) => {
@@ -323,13 +386,13 @@ impl ElementCache {
                     "-" => ListMarkerType::Minus,
                     _ => unreachable!(),
                 };
-                let nesting_level = self.calculate_nesting_level(indentation, prev_items);
-                // Find parent: most recent previous item with lower nesting_level
+                let nesting_level = self.calculate_nesting_level(indentation, blockquote_depth, prev_items);
+                // Find parent: most recent previous item with lower nesting_level and same blockquote depth
                 let parent_line_number = prev_items
                     .iter()
                     .rev()
-                    .find(|(level, _)| *level < nesting_level)
-                    .map(|(_, line_num)| *line_num);
+                    .find(|(bq, _, level)| *bq == blockquote_depth && *level < nesting_level)
+                    .map(|(_, _, line_num)| *line_num);
                 return Some(ListItem {
                     line_number: line_num,
                     indentation,
@@ -340,6 +403,8 @@ impl ElementCache {
                     spaces_after_marker: spaces,
                     nesting_level,
                     parent_line_number,
+                    blockquote_depth,
+                    blockquote_prefix,
                 });
             }
             Ok(None) => {
@@ -361,13 +426,13 @@ impl ElementCache {
                     .map_or("", |m| m.as_str())
                     .trim_start()
                     .to_string();
-                let nesting_level = self.calculate_nesting_level(indentation, prev_items);
-                // Find parent: most recent previous item with lower nesting_level
+                let nesting_level = self.calculate_nesting_level(indentation, blockquote_depth, prev_items);
+                // Find parent: most recent previous item with lower nesting_level and same blockquote depth
                 let parent_line_number = prev_items
                     .iter()
                     .rev()
-                    .find(|(level, _)| *level < nesting_level)
-                    .map(|(_, line_num)| *line_num);
+                    .find(|(bq, _, level)| *bq == blockquote_depth && *level < nesting_level)
+                    .map(|(_, _, line_num)| *line_num);
                 return Some(ListItem {
                     line_number: line_num,
                     indentation,
@@ -378,6 +443,8 @@ impl ElementCache {
                     spaces_after_marker: spaces,
                     nesting_level,
                     parent_line_number,
+                    blockquote_depth,
+                    blockquote_prefix,
                 });
             }
             Ok(None) => {}
@@ -385,39 +452,6 @@ impl ElementCache {
         }
         None
     }
-
-    /// Calculate the nesting level for a list item
-    fn calculate_nesting_level(
-        &self,
-        indent: usize,
-        prev_items: &mut Vec<(usize, usize)>,
-    ) -> usize {
-        // CommonMark: a list item is nested if it is indented at least 2 spaces more than the previous list item
-        let mut nesting_level = 0;
-        if let Some(&(last_indent, last_level)) = prev_items.last() {
-            if indent >= last_indent + 2 {
-                // Nested under previous
-                nesting_level = last_level + 1;
-            } else {
-                // Walk back to find the most recent indent <= current indent
-                for &(prev_indent, prev_level) in prev_items.iter().rev() {
-                    if prev_indent <= indent {
-                        nesting_level = prev_level;
-                        break;
-                    }
-                }
-            }
-        }
-        // Remove stack entries with indent >= current indent
-        while let Some(&(prev_indent, _)) = prev_items.last() {
-            if prev_indent < indent {
-                break;
-            }
-            prev_items.pop();
-        }
-        prev_items.push((indent, nesting_level));
-        nesting_level
-    }
 }
 
 // Thread-local cache for sharing across rules