rumdl 0.0.93__tar.gz → 0.0.94__tar.gz

{rumdl-0.0.93 → rumdl-0.0.94}/CHANGELOG.md

@@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.94] - 2025-07-04
+
 ## [0.0.93] - 2025-07-03
 
 ## [0.0.92] - 2025-07-02
@@ -133,7 +135,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Initial implementation of remaining rules for markdownlint parity
 
-[Unreleased]: https://github.com/rvben/rumdl/compare/v0.0.93...HEAD
+[Unreleased]: https://github.com/rvben/rumdl/compare/v0.0.94...HEAD
+[0.0.94]: https://github.com/rvben/rumdl/compare/v0.0.93...v0.0.94
 [0.0.93]: https://github.com/rvben/rumdl/compare/v0.0.92...v0.0.93
 [0.0.92]: https://github.com/rvben/rumdl/compare/v0.0.91...v0.0.92
 [0.0.91]: https://github.com/rvben/rumdl/compare/v0.0.90...v0.0.91

{rumdl-0.0.93 → rumdl-0.0.94}/Cargo.lock

@@ -220,9 +220,9 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
 [[package]]
 name = "cc"
-version = "1.2.27"
+version = "1.2.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d487aa071b5f64da6f19a3e848e3578944b726ee5a4854b82172f02aa876bfdc"
+checksum = "4ad45f4f74e4e20eaa392913b7b33a7091c87e59628f4dd27888205ad888843c"
 dependencies = [
  "shlex",
 ]
@@ -1465,7 +1465,7 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "rumdl"
-version = "0.0.93"
+version = "0.0.94"
 dependencies = [
  "anyhow",
  "assert_cmd",

{rumdl-0.0.93 → rumdl-0.0.94}/Cargo.toml

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

{rumdl-0.0.93 → rumdl-0.0.94}/PKG-INFO

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

rumdl-0.0.94/src/bin/benchmark_rule.rs

@@ -0,0 +1,156 @@
+use rumdl::config::Config;
+use rumdl::lint_context::LintContext;
+use rumdl::rule::Rule;
+use rumdl::rules::all_rules;
+use std::env;
+use std::time::Instant;
+
+fn benchmark_rule(rule: &dyn Rule, test_cases: &[(&str, &str)], iterations: u32) -> Vec<(String, u64, u64)> {
+    let mut results = Vec::new();
+    
+    for (name, content) in test_cases {
+        // Warm up
+        for _ in 0..10 {
+            let ctx = LintContext::new(content);
+            let _ = rule.check(&ctx);
+            let _ = rule.fix(&ctx);
+        }
+        
+        // Benchmark check
+        let start = Instant::now();
+        for _ in 0..iterations {
+            let ctx = LintContext::new(content);
+            let _ = rule.check(&ctx);
+        }
+        let check_time = start.elapsed().as_micros() as u64 / iterations as u64;
+        
+        // Benchmark fix
+        let start = Instant::now();
+        for _ in 0..iterations {
+            let ctx = LintContext::new(content);
+            let _ = rule.fix(&ctx);
+        }
+        let fix_time = start.elapsed().as_micros() as u64 / iterations as u64;
+        
+        results.push((name.to_string(), check_time, fix_time));
+    }
+    
+    results
+}
+
+fn generate_test_content(rule_name: &str) -> Vec<(&'static str, String)> {
+    match rule_name {
+        "MD009" => vec![
+            ("No trailing spaces", "Line without trailing spaces\n".repeat(100)),
+            ("With trailing spaces", "Line with trailing spaces   \n".repeat(100)),
+            ("Mixed content", "Normal line\nLine with spaces  \nAnother normal\n".repeat(50)),
+            ("Empty lines", "\n\n\n".repeat(100)),
+        ],
+        "MD013" => vec![
+            ("Short lines", "Short line\n".repeat(1000)),
+            ("Long lines", "This is a very long line that exceeds the default line length limit of 80 characters and should trigger MD013\n".repeat(500)),
+            ("Mixed lengths", "Short\nThis is a very long line that exceeds the limit\nShort again\n".repeat(300)),
+            ("Code blocks", "```\nThis is a very long line in a code block that should be ignored by MD013\n```\n".repeat(100)),
+        ],
+        "MD047" => vec![
+            ("Correct ending", "Content with proper ending\n".to_string()),
+            ("Missing newline", "Content without newline at end".to_string()),
+            ("Multiple newlines", "Content with multiple newlines\n\n\n".to_string()),
+            ("Empty file", "".to_string()),
+            ("Large file correct", "Line\n".repeat(1000)),
+            ("Large file incorrect", format!("{}\n\n", "Line\n".repeat(1000))),
+        ],
+        "MD038" => vec![
+            ("No code spans", "Regular text without code\n".repeat(100)),
+            ("Correct code spans", "Text with `correct code` spans\n".repeat(100)),
+            ("Spaces in code", "Text with ` spaced code ` spans\n".repeat(100)),
+            ("Multiple backticks", "Text with ``code with ` backtick`` spans\n".repeat(100)),
+            ("Mixed content", "Normal text\n`good code`\n` bad code `\n".repeat(100)),
+        ],
+        "MD044" => vec![
+            ("No proper names", "regular text without any proper names\n".repeat(100)),
+            ("Correct names", "Using JavaScript and Python correctly\n".repeat(100)),
+            ("Incorrect names", "Using javascript and python incorrectly\n".repeat(100)),
+            ("Mixed case", "JavaScript is good, but javascript is bad\n".repeat(100)),
+            ("Many names", "JavaScript Python TypeScript Ruby Go Rust Java\n".repeat(100)),
+        ],
+        "MD034" => vec![
+            ("No URLs", "Simple text without any URLs or links\n".repeat(100)),
+            ("Markdown links", "[link](http://example.com) and [another](https://test.com)\n".repeat(100)),
+            ("Bare URLs", "Check out http://example.com and https://test.com for more\n".repeat(100)),
+            ("Mixed URLs", "Visit [site](http://a.com) or just go to http://b.com directly\n".repeat(100)),
+            ("Complex URLs", "IPv6: http://[2001:db8::1]/path and port: http://example.com:8080/path?query=1\n".repeat(50)),
+            ("Many URLs", {
+                let mut content = String::new();
+                for i in 0..200 {
+                    content.push_str(&format!("URL {}: http://example{}.com/path/{}/file?id={}\n", i, i, i, i));
+                }
+                content
+            }),
+        ],
+        "MD053" => vec![
+            ("No references", "Simple text without any links or references\n".repeat(100)),
+            ("Used references", "[link1][ref1] and [link2][ref2]\n\n[ref1]: http://example1.com\n[ref2]: http://example2.com\n".repeat(50)),
+            ("Unused references", "Some text here\n\n[unused1]: http://unused1.com\n[unused2]: http://unused2.com\n".repeat(50)),
+            ("Mixed references", "[used][ref1]\n\n[ref1]: http://used.com\n[unused]: http://unused.com\n".repeat(100)),
+            ("Many references", {
+                let mut content = String::new();
+                for i in 0..100 {
+                    content.push_str(&format!("[link{}][ref{}]\n", i, i));
+                }
+                content.push_str("\n");
+                for i in 0..200 {
+                    content.push_str(&format!("[ref{}]: http://example{}.com\n", i, i));
+                }
+                content
+            }),
+        ],
+        _ => vec![
+            ("Default test", "Default test content\n".repeat(100)),
+        ],
+    }
+}
+
+fn main() {
+    let args: Vec<String> = env::args().collect();
+    if args.len() != 2 {
+        eprintln!("Usage: {} <rule_name>", args[0]);
+        std::process::exit(1);
+    }
+    
+    let rule_name = &args[1];
+    let config = Config::default();
+    let rules = all_rules(&config);
+    
+    let rule = rules.into_iter()
+        .find(|r| r.name() == rule_name)
+        .unwrap_or_else(|| {
+            eprintln!("Rule {} not found", rule_name);
+            std::process::exit(1);
+        });
+    
+    let test_cases_vec = generate_test_content(rule_name);
+    let test_cases: Vec<(&str, &str)> = test_cases_vec.iter()
+        .map(|(name, content)| (*name, content.as_str()))
+        .collect();
+    
+    println!("Benchmarking {} Rule", rule_name);
+    println!("{}", "=".repeat(50));
+    println!();
+    
+    let results = benchmark_rule(rule.as_ref(), &test_cases, 100);
+    
+    let mut total_check = 0u64;
+    let mut total_fix = 0u64;
+    
+    for (test_name, check_time, fix_time) in &results {
+        println!("{:<30} Check: {:>6} μs  Fix: {:>6} μs", test_name, check_time, fix_time);
+        total_check += check_time;
+        total_fix += fix_time;
+    }
+    
+    println!();
+    println!("Average times:");
+    println!("  Check: {} μs", total_check / results.len() as u64);
+    println!("  Fix:   {} μs", total_fix / results.len() as u64);
+}

{rumdl-0.0.93 → rumdl-0.0.94}/src/bin/measure_code_span_performance.rs

@@ -28,7 +28,7 @@ fn main() {
             times.push(elapsed.as_micros());
 
             if times.len() == 1 {
-                println!("  Code spans detected: {}", ctx.code_spans.len());
+                println!("  Code spans detected: {}", ctx.code_spans().len());
             }
         }
 

{rumdl-0.0.93 → rumdl-0.0.94}/src/lint_context.rs

@@ -243,6 +243,8 @@ pub struct ListBlock {
     pub nesting_level: usize,
 }
 
+use std::sync::{Arc, Mutex};
+
 pub struct LintContext<'a> {
     pub content: &'a str,
     pub line_offsets: Vec<usize>,
@@ -251,7 +253,7 @@ pub struct LintContext<'a> {
     pub links: Vec<ParsedLink>,           // Pre-parsed links
     pub images: Vec<ParsedImage>,         // Pre-parsed images
     pub reference_defs: Vec<ReferenceDef>, // Reference definitions
-    pub code_spans: Vec<CodeSpan>,        // Pre-parsed inline code spans
+    code_spans_cache: Mutex<Option<Arc<Vec<CodeSpan>>>>, // Lazy-loaded inline code spans
     pub list_blocks: Vec<ListBlock>,      // Pre-parsed list blocks
 }
 
@@ -270,11 +272,11 @@ impl<'a> LintContext<'a> {
         // Pre-compute line information
         let lines = Self::compute_line_info(content, &line_offsets, &code_blocks);
 
-        // Parse links, images, references, code spans, and list blocks
+        // Parse links, images, references, and list blocks
+        // Skip code spans - they'll be computed lazily
         let links = Self::parse_links(content, &lines, &code_blocks);
         let images = Self::parse_images(content, &lines, &code_blocks);
         let reference_defs = Self::parse_reference_defs(content, &lines);
-        let code_spans = Self::parse_code_spans(content, &lines);
         let list_blocks = Self::parse_list_blocks(&lines);
 
         Self {
@@ -285,11 +287,25 @@ impl<'a> LintContext<'a> {
             links,
             images,
             reference_defs,
-            code_spans,
+            code_spans_cache: Mutex::new(None),
             list_blocks,
         }
     }
 
+    /// Get code spans - computed lazily on first access
+    pub fn code_spans(&self) -> Arc<Vec<CodeSpan>> {
+        let mut cache = self.code_spans_cache.lock().unwrap();
+        
+        // Check if we need to compute code spans
+        if cache.is_none() {
+            let code_spans = Self::parse_code_spans(self.content, &self.lines);
+            *cache = Some(Arc::new(code_spans));
+        }
+        
+        // Return a reference to the cached code spans
+        cache.as_ref().unwrap().clone()
+    }
+
     /// Map a byte offset to (line, column)
     pub fn offset_to_line_col(&self, offset: usize) -> (usize, usize) {
         match self.line_offsets.binary_search(&offset) {
@@ -308,8 +324,8 @@ impl<'a> LintContext<'a> {
             return true;
         }
 
-        // Check inline code spans
-        self.code_spans
+        // Check inline code spans (lazy load if needed)
+        self.code_spans()
             .iter()
             .any(|span| pos >= span.byte_offset && pos < span.byte_end)
     }

{rumdl-0.0.93 → rumdl-0.0.94}/src/rules/md009_trailing_spaces.rs

@@ -35,15 +35,7 @@ impl MD009TrailingSpaces {
     }
 
     fn count_trailing_spaces(line: &str) -> usize {
-        let mut count = 0;
-        for c in line.chars().rev() {
-            if c == ' ' {
-                count += 1;
-            } else {
-                break;
-            }
-        }
-        count
+        line.chars().rev().take_while(|&c| c == ' ').count()
     }
 
     fn is_empty_list_item_line(line: &str, prev_line: Option<&str>) -> bool {
@@ -224,6 +216,7 @@ impl Rule for MD009TrailingSpaces {
             }
 
             let trimmed = line.trim_end();
+            let trailing_spaces = Self::count_trailing_spaces(line);
 
             // Handle empty lines - fast regex replacement
             if trimmed.is_empty() {
@@ -256,20 +249,25 @@ impl Rule for MD009TrailingSpaces {
             }
 
             // Handle lines with trailing spaces
-            let trailing_spaces = Self::count_trailing_spaces(line);
             let is_truly_last_line = i == lines.len() - 1 && !content.ends_with('\n');
 
             result.push_str(trimmed);
 
             // In non-strict mode, preserve line breaks by normalizing to br_spaces
             if !self.config.strict && !is_truly_last_line && trailing_spaces > 0 {
-                result.push_str(&" ".repeat(self.config.br_spaces));
+                // Optimize for common case of 2 spaces
+                match self.config.br_spaces {
+                    0 => {},
+                    1 => result.push(' '),
+                    2 => result.push_str("  "),
+                    n => result.push_str(&" ".repeat(n)),
+                }
             }
             result.push('\n');
         }
 
         // Preserve original ending (with or without final newline)
-        if !content.ends_with('\n') {
+        if !content.ends_with('\n') && result.ends_with('\n') {
             result.pop();
         }
 

{rumdl-0.0.93 → rumdl-0.0.94}/src/rules/md013_line_length.rs

@@ -135,8 +135,36 @@ impl Rule for MD013LineLength {
         if content.is_empty() {
             return Ok(Vec::new());
         }
+        
+        // Quick check: if total content is shorter than line limit, definitely no violations
+        if content.len() <= self.config.line_length {
+            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
+        };
+        
+        if !has_long_lines {
+            return Ok(Vec::new());
+        }
 
-        // Fallback path: create structure manually (should rarely be used)
+        // Create structure manually 
         let structure = DocumentStructure::new(content);
         self.check_with_structure(ctx, &structure)
     }
@@ -149,12 +177,15 @@ impl Rule for MD013LineLength {
     ) -> LintResult {
         let content = ctx.content;
         let mut warnings = Vec::new();
-        let lines: Vec<&str> = content.lines().collect();
-
-        // Early return if no lines could possibly exceed the limit
-        if lines.iter().all(|line| line.len() <= self.config.line_length) {
-            return Ok(Vec::new());
-        }
+        
+        // Early return was already done in check(), so we know there are long lines
+        
+        // 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()
+        } else {
+            content.lines().collect()
+        };
 
         // Pre-compute LineIndex for efficient byte range calculations
         let line_index = crate::utils::range_utils::LineIndex::new(content.to_string());
@@ -166,9 +197,18 @@ impl Rule for MD013LineLength {
         let table_lines_set: std::collections::HashSet<usize> = if self.config.tables {
             let mut table_lines = std::collections::HashSet::new();
             let mut in_table = false;
+            
             for (i, line) in lines.iter().enumerate() {
                 let line_number = i + 1;
-                if line.contains('|') && !structure.is_in_code_block(line_number) {
+                
+                // Quick check if in code block using pre-computed blocks from context or structure
+                let in_code = if !ctx.code_blocks.is_empty() {
+                    ctx.code_blocks.iter().any(|(start, end)| *start <= line_number && line_number <= *end)
+                } else {
+                    structure.is_in_code_block(line_number)
+                };
+                
+                if !in_code && line.contains('|') {
                     in_table = true;
                     table_lines.insert(line_number);
                 } else if in_table && line.trim().is_empty() {
@@ -236,18 +276,25 @@ impl Rule for MD013LineLength {
             // Generate simplified fix (avoid expensive sentence splitting for now)
             let fix = if !self.should_skip_line_for_fix(line, line_num, structure) {
                 // First try trimming trailing whitespace
-                let trimmed = line.trim_end();
-                if trimmed.len() <= line_limit && trimmed != *line {
-                    let line_start = line_index.line_col_to_byte_range(line_number, 1).start;
-                    let line_end = if line_number < lines.len() {
-                        line_index.line_col_to_byte_range(line_number + 1, 1).start - 1
+                let last_char = line.chars().last();
+                if last_char == Some(' ') || last_char == Some('\t') {
+                    let trimmed = line.trim_end();
+                    // Calculate trimmed length to avoid re-scanning
+                    let trimmed_len = self.calculate_effective_length(trimmed);
+                    if trimmed_len <= line_limit {
+                        let line_start = line_index.line_col_to_byte_range(line_number, 1).start;
+                        let line_end = if line_number < lines.len() {
+                            line_index.line_col_to_byte_range(line_number + 1, 1).start - 1
+                        } else {
+                            content.len()
+                        };
+                        Some(crate::rule::Fix {
+                            range: line_start..line_end,
+                            replacement: trimmed.to_string(),
+                        })
                     } else {
-                        content.len()
-                    };
-                    Some(crate::rule::Fix {
-                        range: line_start..line_end,
-                        replacement: trimmed.to_string(),
-                    })
+                        None
+                    }
                 } else {
                     None // Skip expensive sentence splitting for performance
                 }
@@ -289,16 +336,35 @@ impl Rule for MD013LineLength {
         // Get all warnings with their fixes
         let warnings = self.check(ctx)?;
 
-        // If no warnings, return original content
+        // If no warnings, return original content without allocation
         if warnings.is_empty() {
             return Ok(ctx.content.to_string());
         }
 
-        // Collect all fixes and sort by range start (descending) to apply from end to beginning
+        // Collect all fixes - check if any exist before allocating
+        let mut has_any_fix = false;
+        for w in &warnings {
+            if w.fix.is_some() {
+                has_any_fix = true;
+                break;
+            }
+        }
+        
+        if !has_any_fix {
+            return Ok(ctx.content.to_string());
+        }
+
+        // Now collect fixes since we know there's at least one
         let mut fixes: Vec<_> = warnings
             .iter()
             .filter_map(|w| w.fix.as_ref().map(|f| (f.range.start, f.range.end, &f.replacement)))
             .collect();
+        
+        // This should not happen given our check above, but just in case
+        if fixes.is_empty() {
+            return Ok(ctx.content.to_string());
+        }
+        
         fixes.sort_by(|a, b| b.0.cmp(&a.0));
 
         // Apply fixes from end to beginning to preserve byte offsets
@@ -325,8 +391,18 @@ impl Rule for MD013LineLength {
     }
 
     fn should_skip(&self, ctx: &crate::lint_context::LintContext) -> bool {
-        // Skip if content is empty or all lines are shorter than the limit
-        ctx.content.is_empty() || ctx.lines.iter().all(|line| line.content.len() <= self.config.line_length)
+        // Skip if content is empty
+        if ctx.content.is_empty() {
+            return true;
+        }
+        
+        // Quick check: if total content is shorter than line limit, definitely skip
+        if ctx.content.len() <= self.config.line_length {
+            return true;
+        }
+        
+        // Use more efficient check - any() with early termination instead of all()
+        !ctx.lines.iter().any(|line| line.content.len() > self.config.line_length)
     }
 
     fn default_config_section(&self) -> Option<(String, toml::Value)> {
@@ -399,29 +475,38 @@ impl MD013LineLength {
             return line.chars().count();
         }
 
+        // Quick check: if line doesn't contain "http" or "[", it can't have URLs or markdown links
+        if !line.contains("http") && !line.contains('[') {
+            return line.chars().count();
+        }
+
         let mut effective_line = line.to_string();
 
         // First handle markdown links to avoid double-counting URLs
         // Pattern: [text](very-long-url) -> [text](url)
-        for cap in MARKDOWN_LINK_PATTERN.captures_iter(&effective_line.clone()) {
-            if let (Some(full_match), Some(text), Some(url)) = (cap.get(0), cap.get(1), cap.get(2)) {
-                if url.as_str().len() > 15 {
-                    let replacement = format!("[{}](url)", text.as_str());
-                    effective_line = effective_line.replacen(full_match.as_str(), &replacement, 1);
+        if line.contains('[') && line.contains("](") {
+            for cap in MARKDOWN_LINK_PATTERN.captures_iter(&effective_line.clone()) {
+                if let (Some(full_match), Some(text), Some(url)) = (cap.get(0), cap.get(1), cap.get(2)) {
+                    if url.as_str().len() > 15 {
+                        let replacement = format!("[{}](url)", text.as_str());
+                        effective_line = effective_line.replacen(full_match.as_str(), &replacement, 1);
+                    }
                 }
             }
         }
 
         // Then replace bare URLs with a placeholder of reasonable length
         // This allows lines with long URLs to pass if the rest of the content is reasonable
-        for url_match in URL_IN_TEXT.find_iter(&effective_line.clone()) {
-            let url = url_match.as_str();
-            // Skip if this URL is already part of a markdown link we handled
-            if !effective_line.contains(&format!("({url})")) {
-                // Replace URL with placeholder that represents a "reasonable" URL length
-                // Using 15 chars as a reasonable URL placeholder (e.g., "https://ex.com")
-                let placeholder = "x".repeat(15.min(url.len()));
-                effective_line = effective_line.replacen(url, &placeholder, 1);
+        if effective_line.contains("http") {
+            for url_match in URL_IN_TEXT.find_iter(&effective_line.clone()) {
+                let url = url_match.as_str();
+                // Skip if this URL is already part of a markdown link we handled
+                if !effective_line.contains(&format!("({url})")) {
+                    // Replace URL with placeholder that represents a "reasonable" URL length
+                    // Using 15 chars as a reasonable URL placeholder (e.g., "https://ex.com")
+                    let placeholder = "x".repeat(15.min(url.len()));
+                    effective_line = effective_line.replacen(url, &placeholder, 1);
+                }
             }
         }