rumdl 0.0.168__tar.gz → 0.0.169__tar.gz

{rumdl-0.0.168 → rumdl-0.0.169}/CHANGELOG.md

@@ -7,6 +7,92 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.169] - 2025-10-30
+
+### Performance
+
+**MASSIVE PERFORMANCE IMPROVEMENTS**: This release delivers 7-53x faster linting through systematic elimination of O(n²) bottlenecks and algorithmic optimizations. rumdl is now 16-29x faster than markdownlint-cli2 on real-world repositories.
+
+- **Fix catastrophic O(n²) bottleneck in FilteredLinesIter** ⭐ THE GAME CHANGER
+  - Eliminated `content.lines().collect()` from inside Iterator::next() method
+  - Single-file optimization delivered 7,600x speedup for affected rules
+  - MD011: 6.00s → 0.785ms (7,644x faster)
+  - MD012: 5.95s → 1.643ms (3,621x faster)
+  - Impact: Stress test (10k lines): 9,987ms → 187ms (53x faster)
+  - Impact: Rust Book (478 files): 2,646ms → 269ms (9.8x faster)
+  - Impact: PyO3 (76 files): 2,004ms → 262ms (7.6x faster)
+
+- **Pre-compute LintContext data structures to eliminate redundant work**
+  - LineIndex: Eliminated 46× content cloning across all rules
+  - Jinja template ranges: Pre-computed once instead of O(n×m) scanning
+  - Table blocks: Computed once instead of 4× independent scans per document
+  - HTML comment ranges: Pre-computed with 50-70x speedup
+  - Code block line mapping: Optimized with binary search instead of linear scan
+  - Autodoc blocks (MkDocs): Pre-computed to avoid O(n²) scaling
+
+- **Optimize link and image parsing with binary search**
+  - Replaced linear search with binary search for code span checks
+  - Faster link/image parsing across all reference-based rules
+
+- **Replace regex with byte-level parsing for better performance**
+  - List detection: Manual byte scanning instead of regex
+  - Blockquote prefix: Byte-level parsing instead of regex
+  - Line info parsing: Eliminated redundant blockquote prefix parsing
+
+- **Streaming parser architecture**
+  - Replaced AST parsing with pulldown-cmark streaming for lower memory overhead
+  - Better scalability for very large documents
+
+- **MD046 optimization**
+  - Pre-compute list/tab contexts
+  - Use ctx.code_blocks instead of independent detection
+
+### Benchmarks
+
+**vs Previous Version (v0.0.168):**
+- Rust Book (478 files): 2,646ms → 269ms (9.8x faster)
+- Stress Test (10,514 lines): 9,987ms → 187ms (53.4x faster)
+- PyO3 (76 files): 2,004ms → 262ms (7.6x faster)
+
+**vs markdownlint-cli2 (industry standard):**
+- Rust Book: 10.3s vs 0.35s (29.4x faster)
+- PyO3: 4.4s vs 0.26s (16.9x faster)
+
+**Current Performance:**
+- 0.7ms per file (Rust Book)
+- 6.3x parallelization efficiency
+- Zero O(n²) algorithmic bottlenecks remaining
+
+### Added
+
+- **MDX and Quarto flavor support**
+  - New flavors: `MarkdownFlavor::MDX` and `MarkdownFlavor::Quarto`
+  - JSX component handling: Skip linting inside JSX elements
+  - ESM import/export support: Ignore JavaScript import/export statements
+  - Quarto code chunk support: Recognize `{r}`, `{python}` chunk delimiters
+  - Essential for modern React-based documentation and data science workflows
+
+### Fixed
+
+- **MD011: Intelligent URL vs text detection in reversed links**
+  - Smarter classification of link components as URL or text
+  - Reduces false positives in edge cases like `(Generic<T>)[link]`
+  - Correctly handles `(http://url)[text]` vs `(text)[#anchor]`
+  - Improved heuristics for ambiguous single-word patterns
+
+- **MD013: Preserve HTML blocks in list items during reflow**
+  - HTML blocks inside list items are now preserved during auto-fix
+  - Prevents broken indentation and tag structure
+  - Better handling of complex nested content
+
+### Changed
+
+- Architecture improvements for pre-computation pattern
+  - LintContext now owns shared data structures
+  - Rules consume pre-computed data instead of duplicating work
+  - Consistent binary search APIs for range lookups
+  - Foundation for future optimizations
+
 ## [0.0.168] - 2025-10-28
 
 ### Added

{rumdl-0.0.168 → rumdl-0.0.169}/Cargo.lock

@@ -1983,7 +1983,7 @@ dependencies = [
 
 [[package]]
 name = "rumdl"
-version = "0.0.168"
+version = "0.0.169"
 dependencies = [
  "anyhow",
  "assert_cmd",

{rumdl-0.0.168 → rumdl-0.0.169}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rumdl"
-version = "0.0.168"
+version = "0.0.169"
 edition = "2024"
 rust-version = "1.89.0"
 description = "A fast Markdown linter written in Rust (Ru(st) MarkDown Linter)"
@@ -22,26 +22,6 @@ crate-type = ["rlib"]
 name = "rumdl"
 path = "src/main.rs"
 
-[[bench]]
-name = "rule_performance"
-harness = false
-
-[[bench]]
-name = "fix_performance"
-harness = false
-
-[[bench]]
-name = "range_performance"
-harness = false
-
-[[bench]]
-name = "simple_fix_bench"
-harness = false
-
-[[bench]]
-name = "range_utils_benchmark"
-harness = false
-
 [profile.release]
 lto = true           # Enable Link-Time Optimization
 strip = true         # Strip symbols from binary

{rumdl-0.0.168 → rumdl-0.0.169}/Makefile

@@ -115,6 +115,9 @@ fmt:
 	cargo fix --allow-dirty --allow-staged
 
 lint:
+	CARGO_INCREMENTAL=1 cargo clippy --workspace --lib --bins --tests -- -D warnings -D clippy::uninlined_format_args
+
+lint-all:
 	CARGO_INCREMENTAL=1 cargo clippy --all-targets --all-features -- -D warnings -D clippy::uninlined_format_args
 
 lint-fast:

{rumdl-0.0.168 → rumdl-0.0.169}/PKG-INFO

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

rumdl-0.0.169/examples/profile_quadratic.rs

@@ -0,0 +1,75 @@
+fn main() {
+    unsafe {
+        std::env::set_var("RUMDL_PROFILE_QUADRATIC", "1");
+    }
+
+    let sep = "=".repeat(80);
+    println!("{}", sep);
+    println!("PROFILING EACH OPERATION AT DIFFERENT SCALES");
+    println!("{}", sep);
+
+    let sizes = vec![
+        (1_000, "1K lines"),
+        (5_000, "5K lines"),
+        (10_000, "10K lines"),
+        (25_000, "25K lines"),
+        (50_000, "50K lines"),
+    ];
+
+    for (target_lines, label) in sizes {
+        let content = create_content(target_lines);
+        let actual_lines = content.lines().count();
+
+        let dash_line = "-".repeat(80);
+        println!("\n{}", dash_line);
+        println!("{} ({} KB, {} lines)", label, content.len() / 1024, actual_lines);
+        println!("{}", dash_line);
+
+        // Run once to see timings
+        let _ = rumdl_lib::lint_context::LintContext::new(&content, rumdl_lib::config::MarkdownFlavor::Standard);
+        println!();
+    }
+}
+
+fn create_content(target_lines: usize) -> String {
+    let patterns = vec![
+        "# Main Heading\n\n",
+        "## Section Heading\n\n",
+        "### Subsection\n\n",
+        "This is a paragraph with `inline code`, **bold text**, and [a link](https://example.com). It contains multiple sentences to make it realistic. Some more text here with *emphasis* and `more code`.\n\n",
+        "- List item 1 with `code` and [link](https://example.com)\n",
+        "- List item 2 with **bold** and *emphasis*\n",
+        "  - Nested item with `more code`\n",
+        "  - Another nested item\n",
+        "- List item 3\n\n",
+        "1. First numbered item with `code`\n",
+        "2. Second item with [reference link][ref1]\n",
+        "3. Third item with **bold text**\n\n",
+        "> Blockquote with `code` and [a link](https://example.com)\n",
+        "> Second line of blockquote with **bold**\n",
+        "> > Nested blockquote with *emphasis*\n\n",
+        "```rust\nfn example() {\n    println!(\"Hello, world!\");\n    let x = 42;\n}\n```\n\n",
+        "```python\ndef example():\n    print('Hello, world!')\n    x = 42\n```\n\n",
+        "| Header 1 | Header 2 with `code` | Header 3 |\n",
+        "|----------|---------------------|----------|\n",
+        "| Cell 1 with `code` | Cell 2 | Cell 3 with [link](https://example.com) |\n",
+        "| Cell 4 | Cell 5 with **bold** | Cell 6 |\n\n",
+        "<!-- This is a comment -->\n\n",
+        "[ref1]: https://example1.com\n",
+        "[ref2]: https://example2.com \"Title\"\n\n",
+        "\n",
+    ];
+
+    let mut content = String::new();
+    let mut line_count = 0;
+    let mut pattern_idx = 0;
+
+    while line_count < target_lines {
+        let pattern = patterns[pattern_idx % patterns.len()];
+        content.push_str(pattern);
+        line_count += pattern.lines().count();
+        pattern_idx += 1;
+    }
+
+    content
+}

{rumdl-0.0.168 → rumdl-0.0.169}/src/config.rs

@@ -27,6 +27,12 @@ pub enum MarkdownFlavor {
     /// MkDocs flavor with auto-reference support
     #[serde(rename = "mkdocs")]
     MkDocs,
+    /// MDX flavor with JSX and ESM support (.mdx files)
+    #[serde(rename = "mdx")]
+    MDX,
+    /// Quarto/RMarkdown flavor for scientific publishing (.qmd, .Rmd files)
+    #[serde(rename = "quarto")]
+    Quarto,
     // Future flavors can be added here when they have actual implementation differences
     // Planned: GFM (GitHub Flavored Markdown) - for GitHub-specific features like tables, strikethrough
     // Planned: CommonMark - for strict CommonMark compliance
@@ -37,6 +43,8 @@ impl fmt::Display for MarkdownFlavor {
         match self {
             MarkdownFlavor::Standard => write!(f, "standard"),
             MarkdownFlavor::MkDocs => write!(f, "mkdocs"),
+            MarkdownFlavor::MDX => write!(f, "mdx"),
+            MarkdownFlavor::Quarto => write!(f, "quarto"),
         }
     }
 }
@@ -48,6 +56,8 @@ impl FromStr for MarkdownFlavor {
         match s.to_lowercase().as_str() {
             "standard" | "" | "none" => Ok(MarkdownFlavor::Standard),
             "mkdocs" => Ok(MarkdownFlavor::MkDocs),
+            "mdx" => Ok(MarkdownFlavor::MDX),
+            "quarto" | "qmd" | "rmd" | "rmarkdown" => Ok(MarkdownFlavor::Quarto),
             // Accept but warn about unimplemented flavors
             "gfm" | "github" => {
                 eprintln!("Warning: GFM flavor not yet implemented, using standard");
@@ -62,6 +72,51 @@ impl FromStr for MarkdownFlavor {
     }
 }
 
+impl MarkdownFlavor {
+    /// Detect flavor from file extension
+    pub fn from_extension(ext: &str) -> Self {
+        match ext.to_lowercase().as_str() {
+            "mdx" => Self::MDX,
+            "qmd" => Self::Quarto,
+            "rmd" => Self::Quarto,
+            _ => Self::Standard,
+        }
+    }
+
+    /// Detect flavor from file path
+    pub fn from_path(path: &std::path::Path) -> Self {
+        path.extension()
+            .and_then(|e| e.to_str())
+            .map(Self::from_extension)
+            .unwrap_or(Self::Standard)
+    }
+
+    /// Check if this flavor supports ESM imports/exports (MDX-specific)
+    pub fn supports_esm_blocks(self) -> bool {
+        matches!(self, Self::MDX)
+    }
+
+    /// Check if this flavor supports JSX components (MDX-specific)
+    pub fn supports_jsx(self) -> bool {
+        matches!(self, Self::MDX)
+    }
+
+    /// Check if this flavor supports auto-references (MkDocs-specific)
+    pub fn supports_auto_references(self) -> bool {
+        matches!(self, Self::MkDocs)
+    }
+
+    /// Get a human-readable name for this flavor
+    pub fn name(self) -> &'static str {
+        match self {
+            Self::Standard => "Standard",
+            Self::MkDocs => "MkDocs",
+            Self::MDX => "MDX",
+            Self::Quarto => "Quarto",
+        }
+    }
+}
+
 lazy_static! {
     // Map common markdownlint config keys to rumdl rule names
     static ref MARKDOWNLINT_KEY_MAP: HashMap<&'static str, &'static str> = {

{rumdl-0.0.168 → rumdl-0.0.169}/src/file_processor.rs

@@ -717,8 +717,17 @@ pub fn process_file_inner(
         rules.to_vec()
     };
 
-    // Use the standard lint function with the configured flavor
-    let warnings_result = rumdl_lib::lint(&content, &filtered_rules, verbose, config.markdown_flavor());
+    // Determine flavor: use file extension if config uses Standard, otherwise use config flavor
+    let flavor = if config.markdown_flavor() == rumdl_lib::config::MarkdownFlavor::Standard {
+        // Auto-detect from file extension for .mdx, .qmd, .Rmd files
+        rumdl_lib::config::MarkdownFlavor::from_path(Path::new(file_path))
+    } else {
+        // Use explicitly configured flavor
+        config.markdown_flavor()
+    };
+
+    // Use the standard lint function with the determined flavor
+    let warnings_result = rumdl_lib::lint(&content, &filtered_rules, verbose, flavor);
 
     // Clear the environment variable after processing
     unsafe {

{rumdl-0.0.168 → rumdl-0.0.169}/src/filtered_lines.rs

@@ -131,6 +131,7 @@ pub struct FilteredLinesIter<'a> {
     ctx: &'a LintContext<'a>,
     config: LineFilterConfig,
     current_index: usize,
+    content_lines: Vec<&'a str>,
 }
 
 impl<'a> FilteredLinesIter<'a> {
@@ -140,6 +141,7 @@ impl<'a> FilteredLinesIter<'a> {
             ctx,
             config,
             current_index: 0,
+            content_lines: ctx.content.lines().collect(),
         }
     }
 }
@@ -149,7 +151,6 @@ impl<'a> Iterator for FilteredLinesIter<'a> {
 
     fn next(&mut self) -> Option<Self::Item> {
         let lines = &self.ctx.lines;
-        let content_lines: Vec<&str> = self.ctx.content.lines().collect();
 
         while self.current_index < lines.len() {
             let idx = self.current_index;
@@ -161,7 +162,7 @@ impl<'a> Iterator for FilteredLinesIter<'a> {
             }
 
             // Get the actual line content from the document
-            let line_content = content_lines.get(idx).copied().unwrap_or("");
+            let line_content = self.content_lines.get(idx).copied().unwrap_or("");
 
             // Return the filtered line with 1-indexed line number
             return Some(FilteredLine {

{rumdl-0.0.168 → rumdl-0.0.169}/src/lib.rs

@@ -149,35 +149,15 @@ pub fn lint(
     let _total_rules = rules.len();
     let _applicable_count = applicable_rules.len();
 
-    // 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 {
-        Some(crate::utils::ast_utils::get_cached_ast(content))
-    } else {
-        None
-    };
-
-    // Parse LintContext once (migration step) with the provided flavor
+    // Parse LintContext once with the provided flavor
     let lint_ctx = crate::lint_context::LintContext::new(content, flavor);
 
+    let profile_rules = std::env::var("RUMDL_PROFILE_RULES").is_ok();
+
     for rule in applicable_rules {
         let _rule_start = Instant::now();
 
-        // Try optimized paths in order of preference
-        let result = if rule.uses_ast() {
-            if let Some(ref ast_ref) = ast {
-                // 1. AST-based path
-                rule.as_maybe_ast()
-                    .and_then(|ext| ext.check_with_ast_opt(&lint_ctx, ast_ref))
-                    .unwrap_or_else(|| rule.check_with_ast(&lint_ctx, ast_ref))
-            } else {
-                // Fallback to regular check if no AST
-                rule.check(&lint_ctx)
-            }
-        } else {
-            // 2. Regular check path
-            rule.check(&lint_ctx)
-        };
+        let result = rule.check(&lint_ctx);
 
         match result {
             Ok(rule_warnings) => {
@@ -209,12 +189,14 @@ pub fn lint(
             }
         }
 
+        let rule_duration = _rule_start.elapsed();
+        if profile_rules {
+            eprintln!("[RULE] {:6} {:?}", rule.name(), rule_duration);
+        }
+
         #[cfg(not(test))]
-        if _verbose {
-            let rule_duration = _rule_start.elapsed();
-            if rule_duration.as_millis() > 500 {
-                log::debug!("Rule {} took {:?}", rule.name(), rule_duration);
-            }
+        if _verbose && rule_duration.as_millis() > 500 {
+            log::debug!("Rule {} took {:?}", rule.name(), rule_duration);
         }
     }
 
@@ -224,9 +206,6 @@ pub fn lint(
         if skipped_rules > 0 {
             log::debug!("Skipped {skipped_rules} of {_total_rules} rules based on content analysis");
         }
-        if ast.is_some() {
-            log::debug!("Used shared AST for {ast_rules_count} rules");
-        }
     }
 
     Ok(warnings)