rumdl 0.0.58__tar.gz → 0.0.59__tar.gz

{rumdl-0.0.58 → rumdl-0.0.59}/Cargo.lock

@@ -1368,7 +1368,7 @@ dependencies = [
 
 [[package]]
 name = "rumdl"
-version = "0.0.58"
+version = "0.0.59"
 dependencies = [
  "anyhow",
  "assert_cmd",

{rumdl-0.0.58 → rumdl-0.0.59}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rumdl"
-version = "0.0.58"
+version = "0.0.59"
 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.58 → rumdl-0.0.59}/PKG-INFO

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

{rumdl-0.0.58 → rumdl-0.0.59}/src/main.rs

@@ -1388,11 +1388,11 @@ fn process_file(
     // Fix issues if requested
     let mut warnings_fixed = 0;
     if _fix {
-        // Skip rules that don't have fixes
+        // Apply fixes for rules that have warnings, regardless of whether individual warnings have fixes
         for rule in rules {
             if all_warnings
                 .iter()
-                .any(|w| w.rule_name == Some(rule.name()) && w.fix.is_some())
+                .any(|w| w.rule_name == Some(rule.name()))
             {
                 let ctx = LintContext::new(&content);
                 match rule.fix(&ctx) {
@@ -1402,7 +1402,7 @@ fn process_file(
                             // Apply fixes for this rule - we consider all warnings for the rule fixed
                             warnings_fixed += all_warnings
                                 .iter()
-                                .filter(|w| w.rule_name == Some(rule.name()) && w.fix.is_some())
+                                .filter(|w| w.rule_name == Some(rule.name()))
                                 .count();
                         }
                     }

{rumdl-0.0.58 → rumdl-0.0.59}/src/rules/blockquote_utils.rs

@@ -5,11 +5,11 @@ lazy_static! {
     // Pattern to match blockquote lines
     static ref BLOCKQUOTE_LINE: Regex = Regex::new(r"^(\s*)>\s?(.*)$").unwrap();
 
-    // Pattern to match empty blockquote lines
-    static ref EMPTY_BLOCKQUOTE_LINE: Regex = Regex::new(r"^(\s*)>\s*$").unwrap();
+    // Pattern to match empty blockquote lines (> with no space or content)
+    static ref EMPTY_BLOCKQUOTE_LINE: Regex = Regex::new(r"^(\s*)>$").unwrap();
 
-    // Pattern to match nested empty blockquote lines
-    static ref NESTED_EMPTY_BLOCKQUOTE_LINE: Regex = Regex::new(r"^(\s*)>+\s*$").unwrap();
+    // Pattern to match nested empty blockquote lines (>> with no space or content)
+    static ref NESTED_EMPTY_BLOCKQUOTE_LINE: Regex = Regex::new(r"^(\s*)>+$").unwrap();
 
     // Pattern to match blockquote lines with no space after >
     static ref BLOCKQUOTE_NO_SPACE: Regex = Regex::new(r"^(\s*)>([^\s].*)$").unwrap();
@@ -32,12 +32,12 @@ impl BlockquoteUtils {
 
     /// Check if a line is an empty blockquote (> with no content)
     pub fn is_empty_blockquote(line: &str) -> bool {
-        // Check for simple empty blockquote
+        // Check for simple empty blockquote (> with no space)
         if EMPTY_BLOCKQUOTE_LINE.is_match(line) {
             return true;
         }
 
-        // Check for nested empty blockquote
+        // Check for nested empty blockquote (>> with no space)
         if NESTED_EMPTY_BLOCKQUOTE_LINE.is_match(line) {
             return true;
         }
@@ -51,6 +51,22 @@ impl BlockquoteUtils {
         false
     }
 
+    /// Check if an empty blockquote line needs fixing for MD028
+    /// This is more restrictive than is_empty_blockquote - only flags lines that actually need fixing
+    pub fn needs_md028_fix(line: &str) -> bool {
+        // Only flag blockquotes that have NO space after the > marker
+        // Lines with a single space ("> ") are already correct and don't need fixing
+        if EMPTY_BLOCKQUOTE_LINE.is_match(line) {
+            return true;
+        }
+
+        if NESTED_EMPTY_BLOCKQUOTE_LINE.is_match(line) {
+            return true;
+        }
+
+        false
+    }
+
     /// Check if a blockquote line has no space after the > marker
     pub fn has_no_space_after_marker(line: &str) -> bool {
         BLOCKQUOTE_NO_SPACE.is_match(line)

{rumdl-0.0.58 → rumdl-0.0.59}/src/rules/md001_heading_increment.rs

@@ -76,77 +76,14 @@ impl Rule for MD001HeadingIncrement {
             return Ok(vec![]);
         }
 
-        let structure = DocumentStructure::new(content);
-        if structure.heading_lines.is_empty() {
+        // Quick check for headings
+        if !content.contains('#') && !content.contains("===") && !content.contains("---") {
             return Ok(vec![]);
         }
 
-        let line_index = LineIndex::new(content.to_string());
-        let mut warnings = Vec::new();
-        let mut prev_level = 0;
-        let lines: Vec<&str> = content.lines().collect();
-
-        // Process headings using pre-computed heading information
-        for i in 0..structure.heading_lines.len() {
-            let line_num = structure.heading_lines[i];
-            let level = structure.heading_levels[i];
-
-            // Check if this heading level is more than one level deeper than the previous
-            if prev_level > 0 && level > prev_level + 1 {
-                let adjusted_line_num = line_num - 1; // Convert 1-indexed to 0-indexed
-                let indentation = if adjusted_line_num < lines.len() {
-                    HeadingUtils::get_indentation(lines[adjusted_line_num])
-                } else {
-                    0
-                };
-
-                // Get the heading text
-                let heading_text = if adjusted_line_num < lines.len() {
-                    lines[adjusted_line_num]
-                        .trim_start()
-                        .trim_start_matches('#')
-                        .trim()
-                        .to_string()
-                } else {
-                    String::new()
-                };
-
-                // Determine heading style
-                let style = if adjusted_line_num + 1 < lines.len()
-                    && (lines[adjusted_line_num + 1].trim().starts_with('=')
-                        || lines[adjusted_line_num + 1].trim().starts_with('-'))
-                {
-                    if lines[adjusted_line_num + 1].trim().starts_with('=') {
-                        HeadingStyle::Setext1
-                    } else {
-                        HeadingStyle::Setext2
-                    }
-                } else {
-                    HeadingStyle::Atx
-                };
-
-                // Create a fix with the correct heading level
-                let fixed_level = prev_level + 1;
-                let replacement =
-                    HeadingUtils::convert_heading_style(&heading_text, fixed_level as u32, style);
-
-                warnings.push(LintWarning {
-                    rule_name: Some(self.name()),
-                    line: line_num,
-                    column: indentation + 1,
-                    message: format!("Heading level should be {} for this level", prev_level + 1),
-                    severity: Severity::Warning,
-                    fix: Some(Fix {
-                        range: line_index.line_col_to_byte_range(line_num, indentation + 1),
-                        replacement: format!("{}{}", " ".repeat(indentation), replacement),
-                    }),
-                });
-            }
-
-            prev_level = level;
-        }
-
-        Ok(warnings)
+        // Fallback path: create structure manually (should rarely be used)
+        let structure = DocumentStructure::new(content);
+        self.check_with_structure(ctx, &structure)
     }
 
     /// Optimized check using document structure
@@ -312,6 +249,10 @@ impl Rule for MD001HeadingIncrement {
         self
     }
 
+    fn as_maybe_document_structure(&self) -> Option<&dyn crate::rule::MaybeDocumentStructure> {
+        Some(self)
+    }
+
     fn from_config(_config: &crate::config::Config) -> Box<dyn Rule>
     where
         Self: Sized,

{rumdl-0.0.58 → rumdl-0.0.59}/src/rules/md002_first_heading_h1.rs

@@ -333,6 +333,10 @@ impl Rule for MD002FirstHeadingH1 {
         self
     }
 
+    fn as_maybe_document_structure(&self) -> Option<&dyn crate::rule::MaybeDocumentStructure> {
+        Some(self)
+    }
+
     fn default_config_section(&self) -> Option<(String, toml::Value)> {
         let mut map = toml::map::Map::new();
         map.insert("level".to_string(), toml::Value::Integer(self.level as i64));

{rumdl-0.0.58 → rumdl-0.0.59}/src/rules/md003_heading_style.rs

@@ -160,64 +160,9 @@ impl Rule for MD003HeadingStyle {
             return Ok(Vec::new());
         }
 
-        let mut result = Vec::new();
-
-        // Create DocumentStructure and use it for heading info
+        // Fallback path: create structure manually (should rarely be used)
         let structure = DocumentStructure::new(content);
-        let target_style = self.get_target_style(content, Some(&structure));
-
-        let lines: Vec<&str> = content.lines().collect();
-        for (idx, &line_num) in structure.heading_lines.iter().enumerate() {
-            let level = structure.heading_levels[idx];
-            let region = structure.heading_regions[idx];
-            // Determine the current style of the heading
-            let style = if region.0 != region.1 {
-                // Setext heading (has an underline)
-                if level == 1 {
-                    HeadingStyle::Setext1
-                } else {
-                    HeadingStyle::Setext2
-                }
-            } else {
-                // ATX heading
-                let line = lines.get(line_num - 1).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
-            // This will flag level 3+ as violations since they can't be represented as Setext
-            let expected_style = if target_style == HeadingStyle::Setext1
-                || target_style == HeadingStyle::Setext2
-            {
-                if level == 1 {
-                    HeadingStyle::Setext1
-                } else {
-                    HeadingStyle::Setext2
-                }
-            } else {
-                target_style
-            };
-
-            if style != expected_style {
-                result.push(LintWarning {
-                    rule_name: Some(self.name()),
-                    line: line_num,
-                    column: 1,
-                    message: format!(
-                        "Heading style should be {:?} (found {:?})",
-                        expected_style, style
-                    ),
-                    severity: Severity::Warning,
-                    fix: None,
-                });
-            }
-        }
-
-        Ok(result)
+        self.check_with_structure(ctx, &structure)
     }
 
     fn fix(&self, ctx: &crate::lint_context::LintContext) -> Result<String, LintError> {
@@ -468,6 +413,10 @@ impl Rule for MD003HeadingStyle {
         self
     }
 
+    fn as_maybe_document_structure(&self) -> Option<&dyn crate::rule::MaybeDocumentStructure> {
+        Some(self)
+    }
+
     fn default_config_section(&self) -> Option<(String, toml::Value)> {
         let mut map = toml::map::Map::new();
         map.insert(
@@ -488,6 +437,17 @@ impl Rule for MD003HeadingStyle {
     }
 }
 
+impl crate::utils::document_structure::DocumentStructureExtensions for MD003HeadingStyle {
+    fn has_relevant_elements(
+        &self,
+        _ctx: &crate::lint_context::LintContext,
+        doc_structure: &crate::utils::document_structure::DocumentStructure,
+    ) -> bool {
+        // This rule is only relevant if there are headings
+        !doc_structure.heading_lines.is_empty()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

{rumdl-0.0.58 → rumdl-0.0.59}/src/rules/md004_unordered_list_style.rs

@@ -167,7 +167,21 @@ impl Rule for MD004UnorderedListStyle {
         "Use consistent style for unordered list markers"
     }
 
+    fn as_maybe_document_structure(&self) -> Option<&dyn crate::rule::MaybeDocumentStructure> {
+        Some(self)
+    }
+
     fn check(&self, ctx: &LintContext) -> LintResult {
+        // Early returns for performance
+        if ctx.content.is_empty() {
+            return Ok(Vec::new());
+        }
+
+        // Quick check for any list markers before processing
+        if !ctx.content.contains(|c: char| c == '*' || c == '-' || c == '+') {
+            return Ok(Vec::new());
+        }
+
         let mut warnings = Vec::new();
         let content = &ctx.content;
         let mut in_code_block = false;

{rumdl-0.0.58 → rumdl-0.0.59}/src/rules/md005_list_indent.rs

@@ -743,11 +743,15 @@ impl Rule for MD005ListIndent {
         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>
+    fn from_config(config: &crate::config::Config) -> Box<dyn Rule>
     where
         Self: Sized,
     {

{rumdl-0.0.58 → rumdl-0.0.59}/src/rules/md006_start_bullets.rs

@@ -309,6 +309,10 @@ impl Rule for MD006StartBullets {
         self
     }
 
+    fn as_maybe_document_structure(&self) -> Option<&dyn crate::rule::MaybeDocumentStructure> {
+        Some(self)
+    }
+
     fn from_config(_config: &crate::config::Config) -> Box<dyn Rule>
     where
         Self: Sized,

{rumdl-0.0.58 → rumdl-0.0.59}/src/rules/md007_ul_indent.rs

@@ -216,6 +216,10 @@ impl Rule for MD007ULIndent {
         self
     }
 
+    fn as_maybe_document_structure(&self) -> Option<&dyn crate::rule::MaybeDocumentStructure> {
+        Some(self)
+    }
+
     fn default_config_section(&self) -> Option<(String, toml::Value)> {
         let mut map = toml::map::Map::new();
         map.insert(

{rumdl-0.0.58 → rumdl-0.0.59}/src/rules/md012_no_multiple_blanks.rs

@@ -63,8 +63,29 @@ impl Rule for MD012NoMultipleBlanks {
         "Multiple consecutive blank lines"
     }
 
+    fn as_maybe_document_structure(&self) -> Option<&dyn crate::rule::MaybeDocumentStructure> {
+        Some(self)
+    }
+
     fn check(&self, ctx: &crate::lint_context::LintContext) -> LintResult {
         let content = ctx.content;
+
+        // Early return for empty content
+        if content.is_empty() {
+            return Ok(Vec::new());
+        }
+
+        // Quick check for consecutive newlines or potential whitespace-only lines before processing
+        // Look for multiple consecutive lines that could be blank (empty or whitespace-only)
+        let lines: Vec<&str> = content.lines().collect();
+        let has_potential_blanks = lines.windows(2).any(|pair| {
+            pair[0].trim().is_empty() && pair[1].trim().is_empty()
+        });
+
+        if !has_potential_blanks {
+            return Ok(Vec::new());
+        }
+
         let _line_index = LineIndex::new(content.to_string());
 
         let mut warnings = Vec::new();
@@ -72,8 +93,6 @@ impl Rule for MD012NoMultipleBlanks {
         let mut blank_count = 0;
         let mut blank_start = 0;
 
-        let lines: Vec<&str> = content.lines().collect();
-
         for (line_num, &line) in lines.iter().enumerate() {
             // Skip code blocks and front matter
             if Self::is_in_code_block(&lines, line_num)
@@ -255,3 +274,14 @@ impl Rule for MD012NoMultipleBlanks {
         Box::new(MD012NoMultipleBlanks::new(maximum))
     }
 }
+
+impl crate::utils::document_structure::DocumentStructureExtensions for MD012NoMultipleBlanks {
+    fn has_relevant_elements(
+        &self,
+        ctx: &crate::lint_context::LintContext,
+        _structure: &crate::utils::document_structure::DocumentStructure,
+    ) -> bool {
+        // MD012 checks for consecutive blank lines, so it's relevant for any non-empty content
+        !ctx.content.is_empty()
+    }
+}

{rumdl-0.0.58 → rumdl-0.0.59}/src/rules/md013_line_length.rs

@@ -2,7 +2,7 @@
 ///
 /// See [docs/md013.md](../../docs/md013.md) for full documentation, configuration, and examples.
 use crate::rule::{LintError, LintResult, LintWarning, Rule, Severity};
-use crate::utils::document_structure::DocumentStructure;
+use crate::utils::document_structure::{DocumentStructure, DocumentStructureExtensions};
 use lazy_static::lazy_static;
 use regex::Regex;
 use toml;
@@ -119,13 +119,31 @@ impl Rule for MD013LineLength {
 
     fn check(&self, ctx: &crate::lint_context::LintContext) -> LintResult {
         let content = ctx.content;
-        let mut warnings = Vec::new();
+
+        // Early return for empty content
+        if content.is_empty() {
+            return Ok(Vec::new());
+        }
+
+        // Fallback path: create structure manually (should rarely be used)
         let structure = DocumentStructure::new(content);
+        self.check_with_structure(ctx, &structure)
+    }
+
+    /// Optimized check using pre-computed document structure
+    fn check_with_structure(
+        &self,
+        ctx: &crate::lint_context::LintContext,
+        structure: &DocumentStructure,
+    ) -> LintResult {
+        let content = ctx.content;
+        let mut warnings = Vec::new();
         let lines: Vec<&str> = content.lines().collect();
 
         // Create a quick lookup set for heading lines
         let heading_lines_set: std::collections::HashSet<usize> =
             structure.heading_lines.iter().cloned().collect();
+
         // Create a quick lookup for setext headings (where start_line != end_line in regions)
         let _setext_lines_set: std::collections::HashSet<usize> = structure
             .heading_regions
@@ -133,6 +151,7 @@ impl Rule for MD013LineLength {
             .filter(|(start, end)| start != end)
             .flat_map(|(start, end)| (*start..=*end).collect::<Vec<usize>>())
             .collect();
+
         // Create a quick lookup set for list item lines (including continuations)
         let _list_lines_set: std::collections::HashSet<usize> =
             structure.list_lines.iter().cloned().collect();
@@ -168,7 +187,7 @@ impl Rule for MD013LineLength {
                 }
 
                 // Skip lines that are only a URL, image ref, or link ref
-                if self.should_ignore_line(line, &lines, line_num, &structure) {
+                if self.should_ignore_line(line, &lines, line_num, structure) {
                     continue;
                 }
             }
@@ -207,6 +226,10 @@ impl Rule for MD013LineLength {
         self
     }
 
+    fn as_maybe_document_structure(&self) -> Option<&dyn crate::rule::MaybeDocumentStructure> {
+        Some(self)
+    }
+
     fn default_config_section(&self) -> Option<(String, toml::Value)> {
         let mut map = toml::map::Map::new();
         map.insert(
@@ -248,3 +271,14 @@ impl Rule for MD013LineLength {
         ))
     }
 }
+
+impl DocumentStructureExtensions for MD013LineLength {
+    fn has_relevant_elements(
+        &self,
+        ctx: &crate::lint_context::LintContext,
+        _doc_structure: &DocumentStructure,
+    ) -> bool {
+        // This rule always applies unless content is empty
+        !ctx.content.is_empty()
+    }
+}

{rumdl-0.0.58 → rumdl-0.0.59}/src/rules/md018_no_missing_space_atx.rs

@@ -74,6 +74,13 @@ impl Rule for MD018NoMissingSpaceAtx {
 
     fn check(&self, ctx: &crate::lint_context::LintContext) -> LintResult {
         let content = ctx.content;
+
+        // Early return for empty content or content without ATX headings
+        if content.is_empty() || !content.contains('#') {
+            return Ok(Vec::new());
+        }
+
+        // Fallback path: create structure manually (should rarely be used)
         let structure = DocumentStructure::new(content);
         self.check_with_structure(ctx, &structure)
     }
@@ -171,6 +178,10 @@ impl Rule for MD018NoMissingSpaceAtx {
         self
     }
 
+    fn as_maybe_document_structure(&self) -> Option<&dyn crate::rule::MaybeDocumentStructure> {
+        Some(self)
+    }
+
     fn from_config(_config: &crate::config::Config) -> Box<dyn Rule>
     where
         Self: Sized,

{rumdl-0.0.58 → rumdl-0.0.59}/src/rules/md019_no_multiple_space_atx.rs

@@ -60,6 +60,13 @@ impl Rule for MD019NoMultipleSpaceAtx {
 
     fn check(&self, ctx: &crate::lint_context::LintContext) -> LintResult {
         let content = ctx.content;
+
+        // Early return for empty content or content without ATX headings
+        if content.is_empty() || !content.contains('#') {
+            return Ok(Vec::new());
+        }
+
+        // Fallback path: create structure manually (should rarely be used)
         let structure = DocumentStructure::new(content);
         self.check_with_structure(ctx, &structure)
     }
@@ -160,6 +167,10 @@ impl Rule for MD019NoMultipleSpaceAtx {
         self
     }
 
+    fn as_maybe_document_structure(&self) -> Option<&dyn crate::rule::MaybeDocumentStructure> {
+        Some(self)
+    }
+
     fn from_config(_config: &crate::config::Config) -> Box<dyn Rule>
     where
         Self: Sized,

{rumdl-0.0.58 → rumdl-0.0.59}/src/rules/md020_no_missing_space_closed_atx.rs

@@ -221,6 +221,10 @@ impl Rule for MD020NoMissingSpaceClosedAtx {
         self
     }
 
+    fn as_maybe_document_structure(&self) -> Option<&dyn crate::rule::MaybeDocumentStructure> {
+        Some(self)
+    }
+
     fn from_config(_config: &crate::config::Config) -> Box<dyn Rule>
     where
         Self: Sized,

{rumdl-0.0.58 → rumdl-0.0.59}/src/rules/md021_no_multiple_space_closed_atx.rs

@@ -224,6 +224,10 @@ impl Rule for MD021NoMultipleSpaceClosedAtx {
         self
     }
 
+    fn as_maybe_document_structure(&self) -> Option<&dyn crate::rule::MaybeDocumentStructure> {
+        Some(self)
+    }
+
     fn from_config(_config: &crate::config::Config) -> Box<dyn Rule>
     where
         Self: Sized,