rumdl 0.0.65__tar.gz → 0.0.67__tar.gz

{rumdl-0.0.65 → rumdl-0.0.67}/Cargo.lock

@@ -1704,7 +1704,7 @@ dependencies = [
 
 [[package]]
 name = "rumdl"
-version = "0.0.65"
+version = "0.0.67"
 dependencies = [
  "anyhow",
  "assert_cmd",
@@ -1745,7 +1745,7 @@ dependencies = [
  "tokio-util",
  "toml",
  "toml_edit",
- "tower",
+ "tower 0.5.2",
  "tower-lsp",
  "tower-service",
  "unicode-normalization",
@@ -2182,7 +2182,16 @@ dependencies = [
  "pin-project-lite",
  "tower-layer",
  "tower-service",
- "tracing",
+]
+
+[[package]]
+name = "tower"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d039ad9159c98b70ecfd540b2573b97f7f52c3e8d9f8ad57a24b916a536975f9"
+dependencies = [
+ "tower-layer",
+ "tower-service",
 ]
 
 [[package]]
@@ -2209,7 +2218,7 @@ dependencies = [
  "serde_json",
  "tokio",
  "tokio-util",
- "tower",
+ "tower 0.4.13",
  "tower-lsp-macros",
  "tracing",
 ]
@@ -2237,7 +2246,6 @@ version = "0.1.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "784e0ac535deb450455cbfa28a6f0df145ea1bb7ae51b821cf5e7927fdcfbdd0"
 dependencies = [
- "log",
  "pin-project-lite",
  "tracing-attributes",
  "tracing-core",

{rumdl-0.0.65 → rumdl-0.0.67}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rumdl"
-version = "0.0.65"
+version = "0.0.67"
 edition = "2021"
 description = "A fast Markdown linter written in Rust (Ru(st) MarkDown Linter)"
 authors = ["Ruben J. Jongejan <ruben.jongejan@gmail.com>"]
@@ -60,7 +60,7 @@ seahash = "4.1"
 tower-lsp = "0.20"
 tokio = { version = "1.0", features = ["full"] }
 tokio-util = "0.7"
-tower = "0.4"
+tower = "0.5.2"
 tower-service = "0.3"
 env_logger = "0.11"
 

{rumdl-0.0.65 → rumdl-0.0.67}/PKG-INFO

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

{rumdl-0.0.65 → rumdl-0.0.67}/src/rules/md003_heading_style.rs

@@ -4,9 +4,8 @@
 //! See [docs/md003.md](../../docs/md003.md) for full documentation, configuration, and examples.
 
 use crate::rule::{LintError, LintResult, LintWarning, Rule, RuleCategory, Severity};
-use crate::rules::heading_utils::{HeadingStyle, HeadingUtils};
+use crate::rules::heading_utils::HeadingStyle;
 use crate::utils::document_structure::DocumentStructure;
-use crate::utils::markdown_elements::{ElementQuality, ElementType, MarkdownElements};
 use lazy_static::lazy_static;
 use regex::Regex;
 use std::str::FromStr;
@@ -166,143 +165,29 @@ impl Rule for MD003HeadingStyle {
     }
 
     fn fix(&self, ctx: &crate::lint_context::LintContext) -> Result<String, LintError> {
-        let content = ctx.content;
-        // Early return for empty content
-        if content.is_empty() {
-            return Ok(String::new());
-        }
+        // Get all warnings with their fixes
+        let warnings = self.check(ctx)?;
 
-        // Quick check if there are any headings at all
-        if !QUICK_HEADING_CHECK.is_match(content) {
-            return Ok(content.to_string());
+        // If no warnings, return original content
+        if warnings.is_empty() {
+            return Ok(ctx.content.to_string());
         }
 
-        let mut fixed_content = String::new();
-        let mut last_processed_line = 0;
-        let lines: Vec<&str> = content.lines().collect();
-
-        // Get the target style - use the fallback method since no structure is available
-        let target_style = self.get_target_style(content, None);
-
-        // Get all headings using the MarkdownElements utility
-        let headings = MarkdownElements::detect_headings(content);
-
-        for heading in headings {
-            if heading.element_type != ElementType::Heading
-                || heading.quality != ElementQuality::Valid
-            {
-                continue; // Skip non-headings or invalid headings
-            }
-
-            // Add any lines before this heading
-            for i in last_processed_line..heading.start_line {
-                if !fixed_content.is_empty() {
-                    fixed_content.push('\n');
-                }
-                fixed_content.push_str(lines.get(i).unwrap_or(&""));
+        // Collect all fixes and sort by range start (descending) to apply from end to beginning
+        let mut fixes: Vec<_> = warnings.iter()
+            .filter_map(|w| w.fix.as_ref().map(|f| (f.range.start, f.range.end, &f.replacement)))
+            .collect();
+        fixes.sort_by(|a, b| b.0.cmp(&a.0));
+
+        // Apply fixes from end to beginning to preserve byte offsets
+        let mut result = ctx.content.to_string();
+        for (start, end, replacement) in fixes {
+            if start < result.len() && end <= result.len() && start <= end {
+                result.replace_range(start..end, replacement);
             }
-
-            // Get the heading level
-            if let Some(level_str) = &heading.metadata {
-                if let Ok(level) = level_str.parse::<u32>() {
-                    // Determine the current style of the heading
-                    let style = if heading.end_line > heading.start_line {
-                        // Setext heading (has an underline)
-                        if level == 1 {
-                            HeadingStyle::Setext1
-                        } else {
-                            HeadingStyle::Setext2
-                        }
-                    } else {
-                        // ATX heading
-                        let line = lines.get(heading.start_line).map_or("", |v| *v);
-                        if line.trim().ends_with('#') {
-                            HeadingStyle::AtxClosed
-                        } else {
-                            HeadingStyle::Atx
-                        }
-                    };
-
-                    // For markdownlint parity: when target style is Setext, all headings are expected to be Setext
-                    // For level 3+, we can't actually convert to Setext, so leave as ATX but flag as violation
-                    let expected_style = if target_style == HeadingStyle::Setext1
-                        || target_style == HeadingStyle::Setext2
-                    {
-                        if level > 2 {
-                            // Level 3+ can't be Setext, so keep as ATX but this will be flagged as violation
-                            HeadingStyle::Atx
-                        } else if level == 1 {
-                            HeadingStyle::Setext1
-                        } else {
-                            HeadingStyle::Setext2
-                        }
-                    } else {
-                        target_style
-                    };
-
-                    // If this heading's style doesn't match the target, convert it
-                    if style != expected_style {
-                        // Get the text content from the heading
-                        let text_content = if heading.end_line > heading.start_line {
-                            // Setext heading
-                            lines.get(heading.start_line).unwrap_or(&"").to_string()
-                        } else {
-                            // ATX heading
-                            let line = lines.get(heading.start_line).map_or("", |v| *v);
-                            HeadingUtils::get_heading_text(line).unwrap_or_default()
-                        };
-
-                        // Get indentation
-                        let indentation = if let Some(line) = lines.get(heading.start_line) {
-                            line.chars()
-                                .take_while(|c| c.is_whitespace())
-                                .collect::<String>()
-                        } else {
-                            String::new()
-                        };
-
-                        // Convert heading to target style
-                        let converted_heading = HeadingUtils::convert_heading_style(
-                            &format!("{}{}", indentation, text_content),
-                            level,
-                            expected_style,
-                        );
-
-                        // Add converted heading
-                        if !fixed_content.is_empty() {
-                            fixed_content.push('\n');
-                        }
-                        fixed_content.push_str(&converted_heading);
-                    } else {
-                        // Add original heading lines
-                        for i in heading.start_line..=heading.end_line {
-                            if !fixed_content.is_empty() {
-                                fixed_content.push('\n');
-                            }
-                            fixed_content.push_str(lines.get(i).unwrap_or(&""));
-                        }
-                    }
-
-                    // Update last processed line
-                    last_processed_line = heading.end_line + 1;
-                }
-            }
-        }
-
-        // Add any remaining lines
-        for i in last_processed_line..lines.len() {
-            if !fixed_content.is_empty() {
-                fixed_content.push('\n');
-            }
-            fixed_content.push_str(lines.get(i).unwrap_or(&""));
         }
 
-        // Preserve trailing newline
-        if content.ends_with('\n') && !fixed_content.ends_with('\n') {
-            fixed_content.push('\n');
-        }
-
-        Ok(fixed_content)
+        Ok(result)
     }
 
     fn check_with_structure(
@@ -383,6 +268,63 @@ impl Rule for MD003HeadingStyle {
             };
 
             if style != expected_style {
+                // Generate fix for this heading
+                let fix = {
+                    use crate::rules::heading_utils::HeadingUtils;
+
+                    // Get the text content from the heading
+                    let text_content = if next_line_idx < lines.len() &&
+                        (lines[next_line_idx].trim_start().starts_with('=') ||
+                         lines[next_line_idx].trim_start().starts_with('-')) {
+                        // Setext heading
+                        current_line.to_string()
+                    } else {
+                        // ATX heading
+                        HeadingUtils::get_heading_text(current_line).unwrap_or_default()
+                    };
+
+                    // Get indentation
+                    let indentation = current_line.chars()
+                        .take_while(|c| c.is_whitespace())
+                        .collect::<String>();
+
+                    // Convert heading to target style
+                    let converted_heading = HeadingUtils::convert_heading_style(
+                        &format!("{}{}", indentation, text_content.trim()),
+                        level as u32,
+                        expected_style,
+                    );
+
+                    // Calculate the correct range for the heading
+                    let line_index = crate::utils::range_utils::LineIndex::new(ctx.content.to_string());
+                    let range = if next_line_idx < lines.len() &&
+                        (lines[next_line_idx].trim_start().starts_with('=') ||
+                         lines[next_line_idx].trim_start().starts_with('-')) {
+                        // Setext heading spans two lines
+                        let start_byte = line_index.line_col_to_byte_range(line_num, 1).start;
+                        let end_byte = if line_num + 1 < lines.len() {
+                            line_index.line_col_to_byte_range(line_num + 2, 1).start - 1
+                        } else {
+                            ctx.content.len()
+                        };
+                        start_byte..end_byte
+                    } else {
+                        // ATX heading is single line
+                        let start_byte = line_index.line_col_to_byte_range(line_num, 1).start;
+                        let end_byte = if line_num < lines.len() {
+                            line_index.line_col_to_byte_range(line_num + 1, 1).start - 1
+                        } else {
+                            ctx.content.len()
+                        };
+                        start_byte..end_byte
+                    };
+
+                    Some(crate::rule::Fix {
+                        range,
+                        replacement: converted_heading,
+                    })
+                };
+
                 result.push(LintWarning {
                     rule_name: Some(self.name()),
                     line: line_num, // Already 1-indexed
@@ -392,7 +334,7 @@ impl Rule for MD003HeadingStyle {
                         expected_style, style
                     ),
                     severity: Severity::Warning,
-                    fix: None,
+                    fix,
                 });
             }
         }

{rumdl-0.0.65 → rumdl-0.0.67}/src/rules/md006_start_bullets.rs

@@ -67,6 +67,34 @@ impl MD006StartBullets {
         }
         None
     }
+
+    /// Check if a list item is nested under a parent list item
+    fn is_nested_list_item(lines: &[&str], line_idx: usize) -> bool {
+        if let Some(current_indent) = Self::is_bullet_list_item(lines[line_idx]) {
+            // Look backwards for a parent list item with less indentation
+            for i in (0..line_idx).rev() {
+                let line = lines[i];
+
+                // Skip blank lines
+                if Self::is_blank_line(line) {
+                    continue;
+                }
+
+                // If we find a list item with less indentation, this is nested
+                if let Some(parent_indent) = Self::is_bullet_list_item(line) {
+                    if parent_indent < current_indent {
+                        return true;
+                    }
+                }
+
+                // If we hit non-list content, stop looking
+                if Self::is_bullet_list_item(line).is_none() {
+                    break;
+                }
+            }
+        }
+        false
+    }
 }
 
 impl Rule for MD006StartBullets {
@@ -116,6 +144,8 @@ impl Rule for MD006StartBullets {
                 Node::ListItem(ListItem {
                     position, children, ..
                 }) => {
+                    // Only flag top-level list items (depth == 1) that are indented
+                    // but make sure they're actually top-level and not nested sub-lists
                     if depth == 1 && !in_blockquote {
                         if let Some(pos) = position {
                             let line_idx = pos.start.line.saturating_sub(1);
@@ -123,17 +153,23 @@ impl Rule for MD006StartBullets {
                                 if let Some(cap) = BULLET_PATTERN.captures(line) {
                                     let indent = cap[1].len();
                                     if indent > 0 {
-                                        result.push(LintWarning {
-                                            rule_name: Some("MD006"),
-                                            severity: Severity::Warning,
-                                            line: line_idx + 1,
-                                            column: 1,
-                                            message: "Consider starting bulleted lists at the beginning of the line".to_string(),
-                                            fix: Some(Fix {
-                                                range: 0..indent,
-                                                replacement: "".to_string(),
-                                            }),
-                                        });
+                                        // Check if this is actually a nested list item
+                                        // by looking for a parent list item above it
+                                        let is_nested = MD006StartBullets::is_nested_list_item(lines, line_idx);
+
+                                        if !is_nested {
+                                            result.push(LintWarning {
+                                                rule_name: Some("MD006"),
+                                                severity: Severity::Warning,
+                                                line: line_idx + 1,
+                                                column: 1,
+                                                message: "Consider starting bulleted lists at the beginning of the line".to_string(),
+                                                fix: Some(Fix {
+                                                    range: 0..indent,
+                                                    replacement: "".to_string(),
+                                                }),
+                                            });
+                                        }
                                     }
                                 }
                             }
@@ -310,7 +346,7 @@ impl Rule for MD006StartBullets {
     }
 
     fn as_maybe_document_structure(&self) -> Option<&dyn crate::rule::MaybeDocumentStructure> {
-        Some(self)
+        None
     }
 
     fn from_config(_config: &crate::config::Config) -> Box<dyn Rule>

{rumdl-0.0.65 → rumdl-0.0.67}/src/rules/md007_ul_indent.rs

@@ -73,6 +73,38 @@ impl Rule for MD007ULIndent {
             if matches!(item.marker_type, ListMarkerType::Asterisk | ListMarkerType::Plus | ListMarkerType::Minus) {
                 let expected_indent = item.nesting_level * self.indent;
                 if item.indentation != expected_indent {
+                    // Generate fix for this list item
+                    let fix = {
+                        let lines: Vec<&str> = content.lines().collect();
+                        if let Some(line) = lines.get(item.line_number - 1) {
+                            // Extract the marker and content
+                            let re = regex::Regex::new(r"^(\s*)([*+-])(\s+)(.*)$").unwrap();
+                            if let Some(caps) = re.captures(line) {
+                                let content_part = caps.get(4).map_or("", |m| m.as_str());
+                                let space_after_marker = caps.get(3).map_or(" ", |m| m.as_str());
+                                let marker_char = caps.get(2).map_or("*", |m| m.as_str());
+                                let correct_indent = " ".repeat(expected_indent);
+                                let fixed_line = format!("{}{}{}{}{}", item.blockquote_prefix, correct_indent, marker_char, space_after_marker, content_part);
+
+                                let line_index = crate::utils::range_utils::LineIndex::new(content.to_string());
+                                let line_start = line_index.line_col_to_byte_range(item.line_number, 1).start;
+                                let line_end = if item.line_number < lines.len() {
+                                    line_index.line_col_to_byte_range(item.line_number + 1, 1).start - 1
+                                } else {
+                                    content.len()
+                                };
+                                Some(crate::rule::Fix {
+                                    range: line_start..line_end,
+                                    replacement: fixed_line,
+                                })
+                            } else {
+                                None
+                            }
+                        } else {
+                            None
+                        }
+                    };
+
                     warnings.push(LintWarning {
                         rule_name: Some(self.name()),
                         message: format!(
@@ -82,7 +114,7 @@ impl Rule for MD007ULIndent {
                         line: item.line_number,
                         column: item.blockquote_prefix.len() + item.indentation + 1, // correct column for marker
                         severity: Severity::Warning,
-                        fix: None,
+                        fix,
                     });
                 }
             }
@@ -100,103 +132,29 @@ impl Rule for MD007ULIndent {
     }
 
     fn fix(&self, ctx: &crate::lint_context::LintContext) -> Result<String, LintError> {
-        let content = ctx.content;
-        let tab_str = " ".repeat(self.indent);
-        let mut lines: Vec<String> = content
-            .lines()
-            .map(|l| {
-                // Normalize leading tabs to spaces
-                let mut norm = String::new();
-                let mut chars = l.chars().peekable();
-                while let Some(&c) = chars.peek() {
-                    if c == '\t' {
-                        norm.push_str(&tab_str);
-                        chars.next();
-                    } else if c == ' ' {
-                        norm.push(' ');
-                        chars.next();
-                    } else {
-                        break;
-                    }
-                }
-                norm.extend(chars);
-                norm
-            })
+        // Get all warnings with their fixes
+        let warnings = self.check(ctx)?;
+
+        // If no warnings, return original content
+        if warnings.is_empty() {
+            return Ok(ctx.content.to_string());
+        }
+
+        // Collect all fixes and sort by range start (descending) to apply from end to beginning
+        let mut fixes: Vec<_> = warnings.iter()
+            .filter_map(|w| w.fix.as_ref().map(|f| (f.range.start, f.range.end, &f.replacement)))
             .collect();
+        fixes.sort_by(|a, b| b.0.cmp(&a.0));
 
-        // Recompute logical nesting for each unordered list item
-        let mut prev_items: Vec<(usize, usize, usize)> = Vec::new(); // (blockquote_depth, indent, nesting_level)
-        for (_, line) in lines.iter_mut().enumerate() {
-            let orig_line = line.clone();
-            // Inline blockquote prefix parsing (since parse_blockquote_prefix is private)
-            let mut rest = orig_line.as_str();
-            let mut blockquote_prefix = String::new();
-            let mut blockquote_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);
-                    blockquote_prefix.push('>');
-                    blockquote_prefix.push_str(spaces);
-                    rest = after_marker;
-                    blockquote_depth += 1;
-                } else {
-                    break;
-                }
-            }
-            // Only process unordered list items outside code blocks
-            if rest.trim().is_empty() || rest.starts_with("```") || rest.starts_with("~~~") {
-                // Do NOT clear prev_items on blank lines; only skip processing
-                continue;
-            }
-            // Use the same regex as element_cache
-            let re = regex::Regex::new(r"^(?P<indent>[ ]*)(?P<marker>[*+-])(?P<after>[ ]+)(?P<content>.*)$").unwrap();
-            if let Some(caps) = re.captures(rest) {
-                let indent_str = caps.name("indent").map_or("", |m| m.as_str());
-                let marker = caps.name("marker").unwrap().as_str();
-                let after = caps.name("after").map_or(" ", |m| m.as_str());
-                let content = caps.name("content").map_or("", |m| m.as_str());
-                let indent = indent_str.len();
-                // Compute logical nesting level
-                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 {
-                        nesting_level = last_level + 1;
-                    } else {
-                        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));
-                // Reconstruct line with correct indentation
-                let correct_indent = " ".repeat(nesting_level * self.indent);
-                *line = format!("{}{}{}{}{}", blockquote_prefix, correct_indent, marker, after, content);
-            } else {
-                // Only clear prev_items if the line is not blank and not a list item
-                if !rest.trim().is_empty() {
-                    prev_items.clear();
-                }
+        // Apply fixes from end to beginning to preserve byte offsets
+        let mut result = ctx.content.to_string();
+        for (start, end, replacement) in fixes {
+            if start < result.len() && end <= result.len() && start <= end {
+                result.replace_range(start..end, replacement);
             }
         }
-        Ok(lines.join("\n"))
+
+        Ok(result)
     }
 
     /// Get the category of this rule for selective processing