rumdl 0.0.144__tar.gz → 0.0.145__tar.gz

{rumdl-0.0.144 → rumdl-0.0.145}/Cargo.lock

@@ -1644,7 +1644,7 @@ checksum = "caf4aa5b0f434c91fe5c7f1ecb6a5ece2130b02ad2a590589dda5146df959001"
 
 [[package]]
 name = "rumdl"
-version = "0.0.144"
+version = "0.0.145"
 dependencies = [
  "anyhow",
  "assert_cmd",

{rumdl-0.0.144 → rumdl-0.0.145}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rumdl"
-version = "0.0.144"
+version = "0.0.145"
 edition = "2024"
 rust-version = "1.89.0"
 description = "A fast Markdown linter written in Rust (Ru(st) MarkDown Linter)"

{rumdl-0.0.144 → rumdl-0.0.145}/PKG-INFO

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

{rumdl-0.0.144 → rumdl-0.0.145}/src/lib.rs

@@ -25,7 +25,6 @@ pub use rules::*;
 
 pub use crate::lint_context::{LineInfo, LintContext, ListItemInfo};
 use crate::rule::{LintResult, Rule, RuleCategory};
-use crate::utils::document_structure::DocumentStructure;
 use std::time::Instant;
 
 /// Content characteristics for efficient rule filtering
@@ -151,9 +150,6 @@ pub fn lint(
     let _total_rules = rules.len();
     let _applicable_count = applicable_rules.len();
 
-    // Parse DocumentStructure once
-    let structure = DocumentStructure::new(content);
-
     // Parse AST once for rules that can benefit from it
     let ast_rules_count = applicable_rules.iter().filter(|rule| rule.uses_ast()).count();
     let ast = if ast_rules_count > 0 {
@@ -177,15 +173,11 @@ pub fn lint(
                     .unwrap_or_else(|| rule.check_with_ast(&lint_ctx, ast_ref))
             } else {
                 // Fallback to regular check if no AST
-                rule.as_maybe_document_structure()
-                    .and_then(|ext| ext.check_with_structure_opt(&lint_ctx, &structure))
-                    .unwrap_or_else(|| rule.check(&lint_ctx))
+                rule.check(&lint_ctx)
             }
         } else {
-            // 2. Document structure path
-            rule.as_maybe_document_structure()
-                .and_then(|ext| ext.check_with_structure_opt(&lint_ctx, &structure))
-                .unwrap_or_else(|| rule.check(&lint_ctx))
+            // 2. Regular check path
+            rule.check(&lint_ctx)
         };
 
         match result {

{rumdl-0.0.144 → rumdl-0.0.145}/src/lint_context.rs

@@ -75,6 +75,8 @@ pub struct LineInfo {
     pub in_code_block: bool,
     /// Whether this line is inside front matter
     pub in_front_matter: bool,
+    /// Whether this line is inside an HTML block
+    pub in_html_block: bool,
     /// List item information if this line starts a list item
     pub list_item: Option<ListItemInfo>,
     /// Heading information if this line is a heading
@@ -393,7 +395,7 @@ impl<'a> LintContext<'a> {
         let code_blocks = CodeBlockUtils::detect_code_blocks(content);
 
         // Pre-compute line information
-        let lines = Self::compute_line_info(content, &line_offsets, &code_blocks, flavor);
+        let mut lines = Self::compute_line_info(content, &line_offsets, &code_blocks, flavor);
 
         // Parse code spans early so we can exclude them from link/image parsing
         let ast = get_cached_ast(content);
@@ -405,6 +407,9 @@ impl<'a> LintContext<'a> {
         let reference_defs = Self::parse_reference_defs(content, &lines);
         let list_blocks = Self::parse_list_blocks(&lines);
 
+        // Detect HTML blocks
+        Self::detect_html_blocks(&mut lines);
+
         // Compute character frequency for fast content analysis
         let char_frequency = Self::compute_char_frequency(content);
 
@@ -575,6 +580,45 @@ impl<'a> LintContext<'a> {
             .find(|block| line_num >= block.start_line && line_num <= block.end_line)
     }
 
+    // Compatibility methods for DocumentStructure migration
+
+    /// Check if a line is within a code block
+    pub fn is_in_code_block(&self, line_num: usize) -> bool {
+        if line_num == 0 || line_num > self.lines.len() {
+            return false;
+        }
+        self.lines[line_num - 1].in_code_block
+    }
+
+    /// Check if a line is within front matter
+    pub fn is_in_front_matter(&self, line_num: usize) -> bool {
+        if line_num == 0 || line_num > self.lines.len() {
+            return false;
+        }
+        self.lines[line_num - 1].in_front_matter
+    }
+
+    /// Check if a line is within an HTML block
+    pub fn is_in_html_block(&self, line_num: usize) -> bool {
+        if line_num == 0 || line_num > self.lines.len() {
+            return false;
+        }
+        self.lines[line_num - 1].in_html_block
+    }
+
+    /// Check if a line and column is within a code span
+    pub fn is_in_code_span(&self, line_num: usize, col: usize) -> bool {
+        if line_num == 0 || line_num > self.lines.len() {
+            return false;
+        }
+
+        // Use the code spans cache to check
+        let code_spans = self.code_spans();
+        code_spans
+            .iter()
+            .any(|span| span.line == line_num && col >= span.start_col && col <= span.end_col)
+    }
+
     /// Check if content has any instances of a specific character (fast)
     pub fn has_char(&self, ch: char) -> bool {
         match ch {
@@ -1120,6 +1164,7 @@ impl<'a> LintContext<'a> {
                 is_blank,
                 in_code_block,
                 in_front_matter: in_front_matter && i <= front_matter_end,
+                in_html_block: false, // Will be populated after line creation
                 list_item,
                 heading: None,    // Will be populated in second pass for Setext headings
                 blockquote: None, // Will be populated after line creation
@@ -1365,6 +1410,107 @@ impl<'a> LintContext<'a> {
         lines
     }
 
+    /// Detect HTML blocks in the content
+    fn detect_html_blocks(lines: &mut [LineInfo]) {
+        // HTML block elements that trigger block context
+        const BLOCK_ELEMENTS: &[&str] = &[
+            "address",
+            "article",
+            "aside",
+            "blockquote",
+            "details",
+            "dialog",
+            "dd",
+            "div",
+            "dl",
+            "dt",
+            "fieldset",
+            "figcaption",
+            "figure",
+            "footer",
+            "form",
+            "h1",
+            "h2",
+            "h3",
+            "h4",
+            "h5",
+            "h6",
+            "header",
+            "hr",
+            "li",
+            "main",
+            "nav",
+            "ol",
+            "p",
+            "pre",
+            "section",
+            "table",
+            "tbody",
+            "td",
+            "tfoot",
+            "th",
+            "thead",
+            "tr",
+            "ul",
+        ];
+
+        let mut i = 0;
+        while i < lines.len() {
+            // Skip if already in code block or front matter
+            if lines[i].in_code_block || lines[i].in_front_matter {
+                i += 1;
+                continue;
+            }
+
+            let trimmed = lines[i].content.trim_start();
+
+            // Check if line starts with an HTML tag
+            if trimmed.starts_with('<') && trimmed.len() > 1 {
+                // Extract tag name safely
+                let after_bracket = &trimmed[1..];
+                let is_closing = after_bracket.starts_with('/');
+                let tag_start = if is_closing { &after_bracket[1..] } else { after_bracket };
+
+                // Extract tag name (stop at space, >, /, or end of string)
+                let tag_name = tag_start
+                    .chars()
+                    .take_while(|c| c.is_ascii_alphabetic() || *c == '-')
+                    .collect::<String>()
+                    .to_lowercase();
+
+                // Check if it's a block element
+                if !tag_name.is_empty() && BLOCK_ELEMENTS.contains(&tag_name.as_str()) {
+                    // Mark this line as in HTML block
+                    lines[i].in_html_block = true;
+
+                    // For simplicity, just mark lines until we find a closing tag or reach a blank line
+                    // This avoids complex nesting logic that might cause infinite loops
+                    if !is_closing {
+                        let closing_tag = format!("</{tag_name}>");
+                        let mut j = i + 1;
+                        while j < lines.len() && j < i + 100 {
+                            // Limit search to 100 lines
+                            // Stop at blank lines
+                            if lines[j].is_blank {
+                                break;
+                            }
+
+                            lines[j].in_html_block = true;
+
+                            // Check if this line contains the closing tag
+                            if lines[j].content.contains(&closing_tag) {
+                                break;
+                            }
+                            j += 1;
+                        }
+                    }
+                }
+            }
+
+            i += 1;
+        }
+    }
+
     /// Parse all inline code spans in the content using AST
     fn parse_code_spans(content: &str, lines: &[LineInfo], ast: &Node) -> Vec<CodeSpan> {
         let mut code_spans = Vec::new();

{rumdl-0.0.144 → rumdl-0.0.145}/src/rule.rs

@@ -9,7 +9,6 @@ use thiserror::Error;
 
 // Import document structure
 use crate::lint_context::LintContext;
-use crate::utils::document_structure::DocumentStructure;
 
 // Import markdown AST for shared parsing
 pub use markdown::mdast::Node as MarkdownAst;
@@ -99,29 +98,12 @@ pub trait Rule: DynClone + Send + Sync {
     fn check(&self, ctx: &LintContext) -> LintResult;
     fn fix(&self, ctx: &LintContext) -> Result<String, LintError>;
 
-    /// Enhanced check method using document structure
-    /// By default, calls the regular check method if not overridden
-    fn check_with_structure(&self, ctx: &LintContext, _structure: &DocumentStructure) -> LintResult {
-        self.check(ctx)
-    }
-
     /// AST-based check method for rules that can benefit from shared AST parsing
     /// By default, calls the regular check method if not overridden
     fn check_with_ast(&self, ctx: &LintContext, _ast: &MarkdownAst) -> LintResult {
         self.check(ctx)
     }
 
-    /// Combined check method using both document structure and AST
-    /// By default, calls the regular check method if not overridden
-    fn check_with_structure_and_ast(
-        &self,
-        ctx: &LintContext,
-        _structure: &DocumentStructure,
-        _ast: &MarkdownAst,
-    ) -> LintResult {
-        self.check(ctx)
-    }
-
     /// Check if this rule should quickly skip processing based on content
     fn should_skip(&self, _ctx: &LintContext) -> bool {
         false
@@ -137,16 +119,12 @@ pub trait Rule: DynClone + Send + Sync {
         false
     }
 
-    /// Check if this rule can benefit from document structure
-    fn uses_document_structure(&self) -> bool {
-        false
-    }
-
     fn as_any(&self) -> &dyn std::any::Any;
 
-    fn as_maybe_document_structure(&self) -> Option<&dyn MaybeDocumentStructure> {
-        None
-    }
+    // DocumentStructure has been merged into LintContext - this method is no longer used
+    // fn as_maybe_document_structure(&self) -> Option<&dyn MaybeDocumentStructure> {
+    //     None
+    // }
 
     fn as_maybe_ast(&self) -> Option<&dyn MaybeAst> {
         None
@@ -332,6 +310,9 @@ pub fn is_rule_disabled_by_comment(content: &str, rule_name: &str) -> bool {
     is_rule_disabled_at_line(content, rule_name, lines.len())
 }
 
+// DocumentStructure has been merged into LintContext - these traits are no longer needed
+// The functionality is now directly available through LintContext methods
+/*
 // Helper trait for dynamic dispatch to check_with_structure
 pub trait MaybeDocumentStructure {
     fn check_with_structure_opt(
@@ -363,6 +344,7 @@ impl MaybeDocumentStructure for dyn Rule {
         None
     }
 }
+*/
 
 // Helper trait for dynamic dispatch to check_with_ast
 pub trait MaybeAst {

{rumdl-0.0.144 → rumdl-0.0.145}/src/rules/md001_heading_increment.rs

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

{rumdl-0.0.144 → rumdl-0.0.145}/src/rules/md002_first_heading_h1.rs

@@ -289,10 +289,6 @@ impl Rule for MD002FirstHeadingH1 {
         self
     }
 
-    fn as_maybe_document_structure(&self) -> Option<&dyn crate::rule::MaybeDocumentStructure> {
-        None
-    }
-
     fn default_config_section(&self) -> Option<(String, toml::Value)> {
         let default_config = MD002Config::default();
         let json_value = serde_json::to_value(&default_config).ok()?;

{rumdl-0.0.144 → rumdl-0.0.145}/src/rules/md003_heading_style.rs

@@ -250,10 +250,6 @@ impl Rule for MD003HeadingStyle {
         self
     }
 
-    fn as_maybe_document_structure(&self) -> Option<&dyn crate::rule::MaybeDocumentStructure> {
-        None
-    }
-
     fn default_config_section(&self) -> Option<(String, toml::Value)> {
         let default_config = MD003Config::default();
         let json_value = serde_json::to_value(&default_config).ok()?;

{rumdl-0.0.144 → rumdl-0.0.145}/src/rules/md004_unordered_list_style.rs

@@ -50,7 +50,6 @@ use crate::LintContext;
 ///
 /// Consistent list markers improve readability and reduce distraction, especially in large documents or when collaborating with others. This rule helps enforce a uniform style across all unordered lists.
 use crate::rule::{Fix, LintError, LintResult, LintWarning, Rule, RuleCategory, Severity};
-use crate::utils::document_structure::DocumentStructureExtensions;
 use toml;
 
 mod md004_config;
@@ -98,10 +97,6 @@ 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() {
@@ -358,17 +353,6 @@ impl Rule for MD004UnorderedListStyle {
     }
 }
 
-impl DocumentStructureExtensions for MD004UnorderedListStyle {
-    fn has_relevant_elements(
-        &self,
-        ctx: &crate::lint_context::LintContext,
-        _doc_structure: &crate::utils::document_structure::DocumentStructure,
-    ) -> bool {
-        // Quick check for any list markers and unordered list blocks
-        ctx.content.contains(['*', '-', '+']) && ctx.list_blocks.iter().any(|block| !block.is_ordered)
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

{rumdl-0.0.144 → rumdl-0.0.145}/src/rules/md005_list_indent.rs

@@ -6,7 +6,6 @@
 use crate::utils::range_utils::{LineIndex, calculate_match_range};
 
 use crate::rule::{Fix, LintError, LintResult, LintWarning, Rule, RuleCategory, Severity};
-use crate::utils::document_structure::DocumentStructure;
 // No regex patterns needed for this rule
 use std::collections::HashMap;
 use toml;
@@ -559,29 +558,10 @@ impl Rule for MD005ListIndent {
         ctx.content.is_empty() || !ctx.lines.iter().any(|line| line.list_item.is_some())
     }
 
-    /// Optimized check using document structure
-    fn check_with_structure(
-        &self,
-        ctx: &crate::lint_context::LintContext,
-        structure: &DocumentStructure,
-    ) -> LintResult {
-        // If no lists in structure, return early
-        if structure.list_lines.is_empty() {
-            return Ok(Vec::new());
-        }
-
-        // Use optimized check - it's already efficient enough
-        self.check_optimized(ctx)
-    }
-
     fn as_any(&self) -> &dyn std::any::Any {
         self
     }
 
-    fn as_maybe_document_structure(&self) -> Option<&dyn crate::rule::MaybeDocumentStructure> {
-        Some(self)
-    }
-
     fn default_config_section(&self) -> Option<(String, toml::Value)> {
         None
     }
@@ -627,21 +607,10 @@ impl Rule for MD005ListIndent {
     }
 }
 
-impl crate::utils::document_structure::DocumentStructureExtensions for MD005ListIndent {
-    fn has_relevant_elements(
-        &self,
-        _ctx: &crate::lint_context::LintContext,
-        doc_structure: &crate::utils::document_structure::DocumentStructure,
-    ) -> bool {
-        !doc_structure.list_lines.is_empty()
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::lint_context::LintContext;
-    use crate::utils::document_structure::DocumentStructureExtensions;
 
     #[test]
     fn test_valid_unordered_list() {
@@ -796,28 +765,25 @@ Even more text";
     }
 
     #[test]
-    fn test_with_document_structure() {
+    fn test_with_lint_context() {
         let rule = MD005ListIndent::default();
 
         // Test with consistent list indentation
         let content = "* Item 1\n* Item 2\n  * Nested item\n  * Another nested item";
-        let structure = DocumentStructure::new(content);
         let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Standard);
-        let result = rule.check_with_structure(&ctx, &structure).unwrap();
+        let result = rule.check(&ctx).unwrap();
         assert!(result.is_empty());
 
         // Test with inconsistent list indentation
         let content = "* Item 1\n* Item 2\n * Nested item\n  * Another nested item";
-        let structure = DocumentStructure::new(content);
         let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Standard);
-        let result = rule.check_with_structure(&ctx, &structure).unwrap();
+        let result = rule.check(&ctx).unwrap();
         assert!(!result.is_empty()); // Should have at least one warning
 
         // Test with different level indentation issues
         let content = "* Item 1\n  * Nested item\n * Another nested item with wrong indent";
-        let structure = DocumentStructure::new(content);
         let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Standard);
-        let result = rule.check_with_structure(&ctx, &structure).unwrap();
+        let result = rule.check(&ctx).unwrap();
         assert!(!result.is_empty()); // Should have at least one warning
     }
 
@@ -1007,17 +973,15 @@ Even more text";
     }
 
     #[test]
-    fn test_has_relevant_elements() {
+    fn test_should_skip_validation() {
         let rule = MD005ListIndent::default();
         let content = "* List item";
         let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Standard);
-        let doc_structure = DocumentStructure::new(content);
-        assert!(rule.has_relevant_elements(&ctx, &doc_structure));
+        assert!(!rule.should_skip(&ctx));
 
         let content = "No lists here";
         let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Standard);
-        let doc_structure = DocumentStructure::new(content);
-        assert!(!rule.has_relevant_elements(&ctx, &doc_structure));
+        assert!(rule.should_skip(&ctx));
     }
 
     #[test]