rumdl 0.0.142__tar.gz → 0.0.143__tar.gz

{rumdl-0.0.142 → rumdl-0.0.143}/Cargo.lock

@@ -1045,6 +1045,16 @@ version = "0.2.175"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6a82ae493e598baaea5209805c49bbf2ea7de956d50d7da0da1164f9c6d28543"
 
+[[package]]
+name = "libmimalloc-sys"
+version = "0.1.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "667f4fec20f29dfc6bc7357c582d91796c169ad7e2fce709468aefeb2c099870"
+dependencies = [
+ "cc",
+ "libc",
+]
+
 [[package]]
 name = "libredox"
 version = "0.1.10"
@@ -1130,6 +1140,15 @@ dependencies = [
  "autocfg",
 ]
 
+[[package]]
+name = "mimalloc"
+version = "0.1.48"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1ee66a4b64c74f4ef288bcbb9192ad9c3feaad75193129ac8509af543894fd8"
+dependencies = [
+ "libmimalloc-sys",
+]
+
 [[package]]
 name = "miniz_oxide"
 version = "0.8.9"
@@ -1625,7 +1644,7 @@ checksum = "caf4aa5b0f434c91fe5c7f1ecb6a5ece2130b02ad2a590589dda5146df959001"
 
 [[package]]
 name = "rumdl"
-version = "0.0.142"
+version = "0.0.143"
 dependencies = [
  "anyhow",
  "assert_cmd",
@@ -1644,6 +1663,7 @@ dependencies = [
  "log",
  "markdown",
  "memmap2",
+ "mimalloc",
  "notify",
  "num_cpus",
  "once_cell",
@@ -1662,6 +1682,7 @@ dependencies = [
  "strsim",
  "tempfile",
  "thiserror",
+ "tikv-jemallocator",
  "tokio",
  "tokio-util",
  "toml",
@@ -1933,6 +1954,26 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "tikv-jemalloc-sys"
+version = "0.6.0+5.3.0-1-ge13ca993e8ccb9ba9847cc330696e02839f328f7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd3c60906412afa9c2b5b5a48ca6a5abe5736aec9eb48ad05037a677e52e4e2d"
+dependencies = [
+ "cc",
+ "libc",
+]
+
+[[package]]
+name = "tikv-jemallocator"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4cec5ff18518d81584f477e9bfdf957f5bb0979b0bac3af4ca30b5b3ae2d2865"
+dependencies = [
+ "libc",
+ "tikv-jemalloc-sys",
+]
+
 [[package]]
 name = "tinystr"
 version = "0.8.1"

{rumdl-0.0.142 → rumdl-0.0.143}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rumdl"
-version = "0.0.142"
+version = "0.0.143"
 edition = "2024"
 rust-version = "1.89.0"
 description = "A fast Markdown linter written in Rust (Ru(st) MarkDown Linter)"
@@ -139,3 +139,9 @@ unicode-segmentation = "1.12"
 unicode-width = "0.2"
 unicode-blocks = "0.1"
 unicode-bidi = "0.3"
+
+[target.'cfg(not(target_env = "msvc"))'.dependencies]
+tikv-jemallocator = "0.6"
+
+[target.'cfg(target_env = "msvc")'.dependencies]
+mimalloc = { version = "0.1", default-features = false }

{rumdl-0.0.142 → rumdl-0.0.143}/PKG-INFO

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

{rumdl-0.0.142 → rumdl-0.0.143}/src/main.rs

@@ -1,3 +1,13 @@
+// Use jemalloc for better memory allocation performance on Unix-like systems
+#[cfg(not(target_env = "msvc"))]
+#[global_allocator]
+static GLOBAL: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
+
+// Use mimalloc on Windows for better performance
+#[cfg(target_env = "msvc")]
+#[global_allocator]
+static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
+
 use chrono::Local;
 use clap::{Args, Parser, Subcommand};
 use colored::*;
@@ -3083,6 +3093,7 @@ fn apply_fixes(
     quiet: bool,
     config: &rumdl_config::Config,
 ) -> usize {
+    use std::time::Instant;
     // Store the original warning count by rule
     let mut original_counts: std::collections::HashMap<&str, usize> = std::collections::HashMap::new();
     for warning in all_warnings {
@@ -3091,6 +3102,13 @@ fn apply_fixes(
         }
     }
 
+    // Track which rules actually fixed content
+    let mut rules_that_fixed = Vec::new();
+
+    let mut total_ctx_time = std::time::Duration::ZERO;
+    let mut total_fix_time = std::time::Duration::ZERO;
+    let mut ctx_creations = 0;
+
     // Apply fixes for rules that have warnings, regardless of whether individual warnings have fixes
     for rule in rules {
         let rule_warnings: Vec<_> = all_warnings
@@ -3129,14 +3147,23 @@ fn apply_fixes(
                     continue;
                 }
 
+                let ctx_start = Instant::now();
                 let ctx = LintContext::new(content, config.markdown_flavor());
+                total_ctx_time += ctx_start.elapsed();
+                ctx_creations += 1;
+
+                let fix_start = Instant::now();
                 match rule.fix(&ctx) {
                     Ok(fixed_content) => {
+                        total_fix_time += fix_start.elapsed();
                         if fixed_content != *content {
                             *content = fixed_content;
+                            // Track that this rule made changes
+                            rules_that_fixed.push(rule_name);
                         }
                     }
                     Err(err) => {
+                        total_fix_time += fix_start.elapsed();
                         if !quiet {
                             eprintln!(
                                 "{} Failed to apply fix for rule {}: {}",
@@ -3151,12 +3178,16 @@ fn apply_fixes(
         }
     }
 
-    // Now re-check all rules to see what warnings remain
+    // OPTIMIZATION: Only re-check rules that actually applied fixes or had warnings
     let ctx_after_fixes = LintContext::new(content, config.markdown_flavor());
     let mut remaining_counts: std::collections::HashMap<&str, usize> = std::collections::HashMap::new();
 
     for rule in rules {
-        if let Ok(remaining_warnings) = rule.check(&ctx_after_fixes) {
+        let rule_name = rule.name();
+        // Only re-check if this rule made changes OR if we have original warnings for it
+        if (rules_that_fixed.contains(&rule_name) || original_counts.contains_key(rule_name))
+            && let Ok(remaining_warnings) = rule.check(&ctx_after_fixes)
+        {
             for warning in remaining_warnings {
                 if let Some(rule_name) = warning.rule_name {
                     *remaining_counts.entry(rule_name).or_insert(0) += 1;
@@ -3172,6 +3203,13 @@ fn apply_fixes(
         warnings_fixed += original_count.saturating_sub(remaining);
     }
 
+    if std::env::var("RUMDL_DEBUG_FIX_PERF").is_ok() {
+        eprintln!("DEBUG: LintContext creations: {ctx_creations}");
+        eprintln!("DEBUG: Total LintContext time: {total_ctx_time:?}");
+        eprintln!("DEBUG: Total fix() time: {total_fix_time:?}");
+        eprintln!("DEBUG: Total time: {:?}", total_ctx_time + total_fix_time);
+    }
+
     warnings_fixed
 }
 
@@ -3183,6 +3221,7 @@ fn apply_fixes_stdin(
     quiet: bool,
     config: &rumdl_config::Config,
 ) -> usize {
+    use std::time::Instant;
     // Store the original warning count by rule
     let mut original_counts: std::collections::HashMap<&str, usize> = std::collections::HashMap::new();
     for warning in all_warnings {
@@ -3191,6 +3230,13 @@ fn apply_fixes_stdin(
         }
     }
 
+    // Track which rules actually fixed content
+    let mut rules_that_fixed = Vec::new();
+
+    let mut total_ctx_time = std::time::Duration::ZERO;
+    let mut total_fix_time = std::time::Duration::ZERO;
+    let mut ctx_creations = 0;
+
     // Apply fixes for rules that have warnings, regardless of whether individual warnings have fixes
     for rule in rules {
         let rule_warnings: Vec<_> = all_warnings
@@ -3229,14 +3275,23 @@ fn apply_fixes_stdin(
                     continue;
                 }
 
+                let ctx_start = Instant::now();
                 let ctx = LintContext::new(content, config.markdown_flavor());
+                total_ctx_time += ctx_start.elapsed();
+                ctx_creations += 1;
+
+                let fix_start = Instant::now();
                 match rule.fix(&ctx) {
                     Ok(fixed_content) => {
+                        total_fix_time += fix_start.elapsed();
                         if fixed_content != *content {
                             *content = fixed_content;
+                            // Track that this rule made changes
+                            rules_that_fixed.push(rule_name);
                         }
                     }
                     Err(err) => {
+                        total_fix_time += fix_start.elapsed();
                         if !quiet {
                             eprintln!(
                                 "{} Failed to apply fix for rule {}: {}",
@@ -3251,12 +3306,16 @@ fn apply_fixes_stdin(
         }
     }
 
-    // Now re-check all rules to see what warnings remain
+    // OPTIMIZATION: Only re-check rules that actually applied fixes or had warnings
     let ctx_after_fixes = LintContext::new(content, config.markdown_flavor());
     let mut remaining_counts: std::collections::HashMap<&str, usize> = std::collections::HashMap::new();
 
     for rule in rules {
-        if let Ok(remaining_warnings) = rule.check(&ctx_after_fixes) {
+        let rule_name = rule.name();
+        // Only re-check if this rule made changes OR if we have original warnings for it
+        if (rules_that_fixed.contains(&rule_name) || original_counts.contains_key(rule_name))
+            && let Ok(remaining_warnings) = rule.check(&ctx_after_fixes)
+        {
             for warning in remaining_warnings {
                 if let Some(rule_name) = warning.rule_name {
                     *remaining_counts.entry(rule_name).or_insert(0) += 1;
@@ -3272,6 +3331,13 @@ fn apply_fixes_stdin(
         warnings_fixed += original_count.saturating_sub(remaining);
     }
 
+    if std::env::var("RUMDL_DEBUG_FIX_PERF").is_ok() {
+        eprintln!("DEBUG: LintContext creations: {ctx_creations}");
+        eprintln!("DEBUG: Total LintContext time: {total_ctx_time:?}");
+        eprintln!("DEBUG: Total fix() time: {total_fix_time:?}");
+        eprintln!("DEBUG: Total time: {:?}", total_ctx_time + total_fix_time);
+    }
+
     warnings_fixed
 }
 

{rumdl-0.0.142 → rumdl-0.0.143}/src/rules/md013_line_length.rs

@@ -93,42 +93,8 @@ impl Rule for MD013LineLength {
     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: if total content is shorter than line limit, definitely no violations
-        // BUT: in normalize mode with reflow, we still want to check for multi-line paragraphs
-        if content.len() <= self.config.line_length
-            && !(self.config.reflow && self.config.reflow_mode == ReflowMode::Normalize)
-        {
-            return Ok(Vec::new());
-        }
-
-        // More aggressive early return - check if any line could possibly be long
-        let has_long_lines = if !ctx.lines.is_empty() {
-            ctx.lines
-                .iter()
-                .any(|line| line.content.len() > self.config.line_length)
-        } else {
-            // Fallback: do a quick scan for newlines to estimate max line length
-            let mut max_line_len = 0;
-            let mut current_line_len = 0;
-            for ch in content.chars() {
-                if ch == '\n' {
-                    max_line_len = max_line_len.max(current_line_len);
-                    current_line_len = 0;
-                } else {
-                    current_line_len += 1;
-                }
-            }
-            max_line_len = max_line_len.max(current_line_len);
-            max_line_len > self.config.line_length
-        };
-
-        // In normalize mode, we want to continue even if no long lines
-        if !(has_long_lines || self.config.reflow && self.config.reflow_mode == ReflowMode::Normalize) {
+        // Fast early return using should_skip
+        if self.should_skip(ctx) && !(self.config.reflow && self.config.reflow_mode == ReflowMode::Normalize) {
             return Ok(Vec::new());
         }
 
@@ -189,6 +155,22 @@ impl Rule for MD013LineLength {
             self.config.clone()
         };
 
+        // Pre-filter lines that could be problematic to avoid processing all lines
+        let mut candidate_lines = Vec::new();
+        for (line_idx, line_info) in ctx.lines.iter().enumerate() {
+            // Quick length check first
+            if line_info.content.len() > effective_config.line_length {
+                candidate_lines.push(line_idx);
+            }
+        }
+
+        // If no candidate lines and not in normalize mode, early return
+        if candidate_lines.is_empty()
+            && !(effective_config.reflow && effective_config.reflow_mode == ReflowMode::Normalize)
+        {
+            return Ok(warnings);
+        }
+
         // Use ctx.lines if available for better performance
         let lines: Vec<&str> = if !ctx.lines.is_empty() {
             ctx.lines.iter().map(|l| l.content.as_str()).collect()
@@ -196,31 +178,33 @@ impl Rule for MD013LineLength {
             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();
-
-        // Use TableUtils to find all table blocks in the document
-        let table_blocks = TableUtils::find_table_blocks(content, ctx);
+        // Create a quick lookup set for heading lines (only if needed)
+        let heading_lines_set: std::collections::HashSet<usize> = if !effective_config.headings {
+            structure.heading_lines.iter().cloned().collect()
+        } else {
+            std::collections::HashSet::new()
+        };
 
-        // Pre-compute table lines from the table blocks
-        let table_lines_set: std::collections::HashSet<usize> = {
+        // Use TableUtils to find all table blocks (only if needed)
+        let table_lines_set: std::collections::HashSet<usize> = if !effective_config.tables {
+            let table_blocks = TableUtils::find_table_blocks(content, ctx);
             let mut table_lines = std::collections::HashSet::new();
-
             for table in &table_blocks {
-                // Add header line
-                table_lines.insert(table.header_line + 1); // Convert 0-indexed to 1-indexed
-                // Add delimiter line
+                table_lines.insert(table.header_line + 1);
                 table_lines.insert(table.delimiter_line + 1);
-                // Add all content lines
                 for &line in &table.content_lines {
-                    table_lines.insert(line + 1); // Convert 0-indexed to 1-indexed
+                    table_lines.insert(line + 1);
                 }
             }
             table_lines
+        } else {
+            std::collections::HashSet::new()
         };
 
-        for (line_num, line) in lines.iter().enumerate() {
-            let line_number = line_num + 1;
+        // Only process candidate lines that were pre-filtered
+        for &line_idx in &candidate_lines {
+            let line_number = line_idx + 1;
+            let line = lines[line_idx];
 
             // Calculate effective length excluding unbreakable URLs
             let effective_length = self.calculate_effective_length(line);
@@ -228,7 +212,7 @@ impl Rule for MD013LineLength {
             // Use single line length limit for all content
             let line_limit = effective_config.line_length;
 
-            // Skip short lines immediately
+            // Skip short lines immediately (double-check after effective length calculation)
             if effective_length <= line_limit {
                 continue;
             }
@@ -253,7 +237,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_idx, structure) {
                     continue;
                 }
             }
@@ -647,7 +631,13 @@ impl MD013LineLength {
             return line.chars().count();
         }
 
-        // Quick check: if line doesn't contain "http" or "[", it can't have URLs or markdown links
+        // Quick byte-level check: if line doesn't contain "http" or "[", it can't have URLs or markdown links
+        let bytes = line.as_bytes();
+        if !bytes.contains(&b'h') && !bytes.contains(&b'[') {
+            return line.chars().count();
+        }
+
+        // More precise check for URLs and links
         if !line.contains("http") && !line.contains('[') {
             return line.chars().count();
         }

{rumdl-0.0.142 → rumdl-0.0.143}/src/rules/md028_no_blanks_blockquote.rs

@@ -13,32 +13,42 @@ pub struct MD028NoBlanksBlockquote;
 
 impl MD028NoBlanksBlockquote {
     /// Check if a line is a blockquote line (has > markers)
+    #[inline]
     fn is_blockquote_line(line: &str) -> bool {
+        // Fast path: check for '>' character before doing any string operations
+        if !line.as_bytes().contains(&b'>') {
+            return false;
+        }
         line.trim_start().starts_with('>')
     }
 
-    /// Get the blockquote level (number of > markers)
-    fn get_blockquote_level(line: &str) -> usize {
-        let trimmed = line.trim_start();
+    /// Get the blockquote level (number of > markers) and leading whitespace
+    /// Returns (level, whitespace_end_idx)
+    fn get_blockquote_info(line: &str) -> (usize, usize) {
+        let bytes = line.as_bytes();
+        let mut i = 0;
+
+        // Skip leading whitespace
+        while i < bytes.len() && (bytes[i] == b' ' || bytes[i] == b'\t') {
+            i += 1;
+        }
+
+        let whitespace_end = i;
         let mut level = 0;
-        let chars = trimmed.chars();
 
-        for ch in chars {
-            if ch == '>' {
+        // Count '>' markers
+        while i < bytes.len() {
+            if bytes[i] == b'>' {
                 level += 1;
-            } else if ch != ' ' && ch != '\t' {
+                i += 1;
+            } else if bytes[i] == b' ' || bytes[i] == b'\t' {
+                i += 1;
+            } else {
                 break;
             }
         }
 
-        level
-    }
-
-    /// Get the leading whitespace before the first >
-    fn get_leading_whitespace(line: &str) -> &str {
-        let trimmed_len = line.trim_start().len();
-        let total_len = line.len();
-        &line[..total_len - trimmed_len]
+        (level, whitespace_end)
     }
 
     /// Check if there's substantive content between two blockquote sections
@@ -66,19 +76,24 @@ impl MD028NoBlanksBlockquote {
         // Even multiple consecutive blank lines are flagged as they can be ambiguous
         // (some parsers treat them as one blockquote, others as separate blockquotes).
 
-        // Find previous and next blockquote lines
+        // Find previous and next blockquote lines using fast byte scanning
         let mut prev_quote_idx = None;
         let mut next_quote_idx = None;
 
+        // Scan backwards for previous blockquote
         for i in (0..blank_idx).rev() {
-            if Self::is_blockquote_line(lines[i]) {
+            let line = lines[i];
+            // Fast check: if no '>' character, skip
+            if line.as_bytes().contains(&b'>') && Self::is_blockquote_line(line) {
                 prev_quote_idx = Some(i);
                 break;
             }
         }
 
+        // Scan forwards for next blockquote
         for (i, line) in lines.iter().enumerate().skip(blank_idx + 1) {
-            if Self::is_blockquote_line(line) {
+            // Fast check: if no '>' character, skip
+            if line.as_bytes().contains(&b'>') && Self::is_blockquote_line(line) {
                 next_quote_idx = Some(i);
                 break;
             }
@@ -94,9 +109,9 @@ impl MD028NoBlanksBlockquote {
             return false;
         }
 
-        // Check if levels match
-        let prev_level = Self::get_blockquote_level(lines[prev_idx]);
-        let next_level = Self::get_blockquote_level(lines[next_idx]);
+        // Get blockquote info once per line to avoid repeated parsing
+        let (prev_level, prev_whitespace_end) = Self::get_blockquote_info(lines[prev_idx]);
+        let (next_level, next_whitespace_end) = Self::get_blockquote_info(lines[next_idx]);
 
         // Different levels suggest different contexts
         // But next_level > prev_level could be nested continuation
@@ -104,9 +119,11 @@ impl MD028NoBlanksBlockquote {
             return false;
         }
 
-        // Check indentation consistency
-        let prev_indent = Self::get_leading_whitespace(lines[prev_idx]);
-        let next_indent = Self::get_leading_whitespace(lines[next_idx]);
+        // Check indentation consistency using byte indices
+        let prev_line = lines[prev_idx];
+        let next_line = lines[next_idx];
+        let prev_indent = &prev_line[..prev_whitespace_end];
+        let next_indent = &next_line[..next_whitespace_end];
 
         // Different indentation indicates separate blockquote contexts
         // Same indentation with no content between = same blockquote (blank line inside)
@@ -129,12 +146,15 @@ impl MD028NoBlanksBlockquote {
         }
 
         // This blank line appears to be inside a blockquote
-        // Find the appropriate fix
+        // Find the appropriate fix using optimized parsing
         for i in (0..index).rev() {
-            if Self::is_blockquote_line(lines[i]) {
-                let level = Self::get_blockquote_level(lines[i]);
-                let indent = Self::get_leading_whitespace(lines[i]);
-                let mut fix = indent.to_string();
+            let line = lines[i];
+            // Fast check: if no '>' character, skip
+            if line.as_bytes().contains(&b'>') && Self::is_blockquote_line(line) {
+                let (level, whitespace_end) = Self::get_blockquote_info(line);
+                let indent = &line[..whitespace_end];
+                let mut fix = String::with_capacity(indent.len() + level);
+                fix.push_str(indent);
                 for _ in 0..level {
                     fix.push('>');
                 }
@@ -177,17 +197,35 @@ impl Rule for MD028NoBlanksBlockquote {
         // Get all lines
         let lines: Vec<&str> = ctx.content.lines().collect();
 
-        // Check each line
-        for (line_idx, line) in lines.iter().enumerate() {
-            let line_num = line_idx + 1;
+        // Pre-scan to find blank lines and blockquote lines for faster processing
+        let mut blank_line_indices = Vec::new();
+        let mut has_blockquotes = false;
 
+        for (line_idx, line) in lines.iter().enumerate() {
             // Skip lines in code blocks
             if line_idx < ctx.lines.len() && ctx.lines[line_idx].in_code_block {
                 continue;
             }
 
+            if line.trim().is_empty() {
+                blank_line_indices.push(line_idx);
+            } else if Self::is_blockquote_line(line) {
+                has_blockquotes = true;
+            }
+        }
+
+        // If no blockquotes found, no need to check blank lines
+        if !has_blockquotes {
+            return Ok(Vec::new());
+        }
+
+        // Only check blank lines that could be problematic
+        for &line_idx in &blank_line_indices {
+            let line_num = line_idx + 1;
+
             // Check if this is a problematic blank line inside a blockquote
             if let Some((level, fix_content)) = Self::is_problematic_blank_line(&lines, line_idx) {
+                let line = lines[line_idx];
                 let (start_line, start_col, end_line, end_col) = calculate_line_range(line_num, line);
 
                 warnings.push(LintWarning {