rumdl 0.0.66__tar.gz → 0.0.67__tar.gz

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

@@ -1704,7 +1704,7 @@ dependencies = [
 
 [[package]]
 name = "rumdl"
-version = "0.0.66"
+version = "0.0.67"
 dependencies = [
  "anyhow",
  "assert_cmd",

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

@@ -1,6 +1,6 @@
 [package]
 name = "rumdl"
-version = "0.0.66"
+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>"]

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

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

{rumdl-0.0.66 → 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.66 → 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,
                     });
                 }
             }
@@ -99,84 +131,30 @@ impl Rule for MD007ULIndent {
         self.check(ctx)
     }
 
-            fn fix(&self, ctx: &crate::lint_context::LintContext) -> Result<String, LintError> {
-        let content = ctx.content;
-
-        // Get the warnings to know which lines need indentation fixing
+    fn fix(&self, ctx: &crate::lint_context::LintContext) -> Result<String, LintError> {
+        // Get all warnings with their fixes
         let warnings = self.check(ctx)?;
-        let mut lines_to_fix: std::collections::HashSet<usize> = std::collections::HashSet::new();
-        for warning in &warnings {
-            lines_to_fix.insert(warning.line);
-        }
-
-        let element_cache = ElementCache::new(content);
-        let lines: Vec<&str> = content.lines().collect();
-        let mut result_lines: Vec<String> = Vec::new();
 
-        // Check if any list items have tabs that need normalization
-        let mut has_tabs = false;
-        for &line in &lines {
-            if line.contains('\t') && element_cache.get_list_items().iter().any(|item| item.line_number == lines.iter().position(|&l| l == line).unwrap_or(0) + 1) {
-                has_tabs = true;
-                break;
-            }
-        }
-
-        // If no warnings and no tabs to normalize, return original content
-        if warnings.is_empty() && !has_tabs {
-            return Ok(content.to_string());
+        // If no warnings, return original content
+        if warnings.is_empty() {
+            return Ok(ctx.content.to_string());
         }
 
-        for (line_idx, &line) in lines.iter().enumerate() {
-            let line_number = line_idx + 1;
-
-            // Check if this line is a list item
-            if let Some(item) = element_cache.get_list_items().iter().find(|item| item.line_number == line_number) {
-                if matches!(item.marker_type, ListMarkerType::Asterisk | ListMarkerType::Plus | ListMarkerType::Minus) {
-                    // Determine if we need to fix this line
-                    let needs_indentation_fix = lines_to_fix.contains(&line_number);
-                    let needs_tab_normalization = line.contains('\t');
-
-                    if needs_indentation_fix || needs_tab_normalization {
-                        let expected_indent = item.nesting_level * self.indent;
-
-                        // Reconstruct the line with correct indentation
-                        let marker_char = match item.marker_type {
-                            ListMarkerType::Asterisk => '*',
-                            ListMarkerType::Plus => '+',
-                            ListMarkerType::Minus => '-',
-                            _ => unreachable!(),
-                        };
-
-                        // Extract the content after the marker and space
-                        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 correct_indent = " ".repeat(expected_indent);
-                            let fixed_line = format!("{}{}{}{}{}", item.blockquote_prefix, correct_indent, marker_char, space_after_marker, content_part);
-                            result_lines.push(fixed_line);
-                        } else {
-                            // Fallback: just use the original line
-                            result_lines.push(line.to_string());
-                        }
-                    } else {
-                        result_lines.push(line.to_string());
-                    }
-                } else {
-                    result_lines.push(line.to_string());
-                }
-            } else {
-                result_lines.push(line.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));
+
+        // 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);
             }
         }
 
-        let result = result_lines.join("\n");
-        if content.ends_with('\n') {
-            Ok(result + "\n")
-        } else {
-            Ok(result)
-        }
+        Ok(result)
     }
 
     /// Get the category of this rule for selective processing