rumdl 0.0.93__tar.gz → 0.0.95__tar.gz

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

@@ -7,6 +7,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.95] - 2025-07-15
+
+## [0.0.94] - 2025-07-04
+
+### Performance Improvements
+- Implemented lazy code span loading - 3.8x speedup for 94% of rules that don't use code spans
+- MD013: 34.5% faster check operations through aggressive early returns
+- MD038: 14% faster by leveraging lazy code span loading  
+- MD044: 93.5% faster with global regex caching
+- MD047: 8.3% faster using pre-computed line data
+- MD053: 39.7% faster by leveraging pre-parsed reference definitions
+- Overall LintContext creation improved by 11.7%
+
+### Fixed
+- MD053: Fixed escaped character handling in reference definitions
+
 ## [0.0.93] - 2025-07-03
 
 ## [0.0.92] - 2025-07-02
@@ -133,7 +149,9 @@ 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.95...HEAD
+[0.0.95]: https://github.com/rvben/rumdl/compare/v0.0.94...v0.0.95
+[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.95}/Cargo.lock

@@ -220,9 +220,9 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
 [[package]]
 name = "cc"
-version = "1.2.27"
+version = "1.2.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d487aa071b5f64da6f19a3e848e3578944b726ee5a4854b82172f02aa876bfdc"
+checksum = "5c1599538de2394445747c8cf7935946e3cc27e9625f889d979bfb2aaf569362"
 dependencies = [
  "shlex",
 ]
@@ -277,9 +277,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.40"
+version = "4.5.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40b6887a1d8685cebccf115538db5c0efe625ccac9696ad45c409d96566e910f"
+checksum = "be92d32e80243a54711e5d7ce823c35c41c9d929dc4ab58e1276f625841aadf9"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -287,9 +287,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.40"
+version = "4.5.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0c66c08ce9f0c698cbce5c0279d0bb6ac936d8674174fe48f736533b964f59e"
+checksum = "707eab41e9622f9139419d573eca0900137718000c517d47da73045f54331c3d"
 dependencies = [
  "anstream",
  "anstyle",
@@ -299,9 +299,9 @@ dependencies = [
 
 [[package]]
 name = "clap_derive"
-version = "4.5.40"
+version = "4.5.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2c7947ae4cc3d851207c1adb5b5e260ff0cca11446b1d6d1423788e442257ce"
+checksum = "ef4f52386a59ca4c860f7393bcf8abd8dfd91ecccc0f774635ff68e92eeef491"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -1004,9 +1004,9 @@ checksum = "32a282da65faaf38286cf3be983213fcf1d2e2a58700e808f83f4ea9a4804bc0"
 
 [[package]]
 name = "memmap2"
-version = "0.9.5"
+version = "0.9.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd3f7eed9d3848f8b98834af67102b720745c4ec028fcd0aa0239277e7de374f"
+checksum = "483758ad303d734cec05e5c12b41d7e93e6a6390c5e9dae6bdeb7c1259012d28"
 dependencies = [
  "libc",
 ]
@@ -1465,7 +1465,7 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "rumdl"
-version = "0.0.93"
+version = "0.0.95"
 dependencies = [
  "anyhow",
  "assert_cmd",
@@ -1522,15 +1522,15 @@ checksum = "989e6739f80c4ad5b13e0fd7fe89531180375b18520cc8c82080e4dc4035b84f"
 
 [[package]]
 name = "rustix"
-version = "1.0.7"
+version = "1.0.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c71e83d6afe7ff64890ec6b71d6a69bb8a610ab78ce364b3352876bb4c801266"
+checksum = "11181fbabf243db407ef8df94a6ce0b2f9a733bd8be4ad02b4eda9602296cac8"
 dependencies = [
  "bitflags 2.9.1",
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.59.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -1796,9 +1796,9 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
 name = "tokio"
-version = "1.46.0"
+version = "1.46.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1140bb80481756a8cbe10541f37433b459c5aa1e727b4c020fbfebdc25bf3ec4"
+checksum = "0cc3a2344dafbe23a245241fe8b09735b521110d30fcefbbd5feb1797ca35d17"
 dependencies = [
  "backtrace",
  "bytes",
@@ -2394,9 +2394,9 @@ checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486"
 
 [[package]]
 name = "winnow"
-version = "0.7.11"
+version = "0.7.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74c7b26e3480b707944fc872477815d29a8e429d2f93a1ce000f5fa84a15cbcd"
+checksum = "f3edebf492c8125044983378ecb5766203ad3b4c2f7a922bd7dd207f6d443e95"
 dependencies = [
  "memchr",
 ]

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

@@ -1,6 +1,6 @@
 [package]
 name = "rumdl"
-version = "0.0.93"
+version = "0.0.95"
 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.95}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rumdl
-Version: 0.0.93
+Version: 0.0.95
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -375,6 +375,16 @@ These options are available for all commands:
 - `--config <file>`: Path to configuration file
 - `--no-config`: Ignore all configuration files and use built-in defaults
 
+### Exit Codes
+
+rumdl uses exit codes following Ruff's convention for easy CI/CD integration:
+
+- `0`: Success - no issues found
+- `1`: Linting violations found
+- `2`: Tool error (configuration error, file access error, invalid arguments, etc.)
+
+This allows scripts and CI/CD systems to distinguish between "the tool found problems in your files" (exit 1) and "the tool couldn't run properly" (exit 2).
+
 ### Usage Examples
 
 ```bash

{rumdl-0.0.93 → rumdl-0.0.95}/README.md

@@ -344,6 +344,16 @@ These options are available for all commands:
 - `--config <file>`: Path to configuration file
 - `--no-config`: Ignore all configuration files and use built-in defaults
 
+### Exit Codes
+
+rumdl uses exit codes following Ruff's convention for easy CI/CD integration:
+
+- `0`: Success - no issues found
+- `1`: Linting violations found
+- `2`: Tool error (configuration error, file access error, invalid arguments, etc.)
+
+This allows scripts and CI/CD systems to distinguish between "the tool found problems in your files" (exit 1) and "the tool couldn't run properly" (exit 2).
+
 ### Usage Examples
 
 ```bash

rumdl-0.0.95/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.95}/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.95/src/exit_codes.rs

@@ -0,0 +1,34 @@
+/// Exit codes for rumdl, following Ruff's convention
+/// 
+/// These exit codes allow users and CI/CD systems to distinguish between
+/// different types of failures.
+pub mod exit_codes {
+    /// Success - No issues found or all issues were fixed
+    pub const SUCCESS: i32 = 0;
+    
+    /// Linting issues found - One or more Markdown violations detected
+    pub const VIOLATIONS_FOUND: i32 = 1;
+    
+    /// Tool error - Configuration error, file access error, or internal error
+    pub const TOOL_ERROR: i32 = 2;
+}
+
+/// Helper functions for consistent exit behavior
+pub mod exit {
+    use super::exit_codes;
+    
+    /// Exit with success code (0)
+    pub fn success() -> ! {
+        std::process::exit(exit_codes::SUCCESS);
+    }
+    
+    /// Exit with violations found code (1)
+    pub fn violations_found() -> ! {
+        std::process::exit(exit_codes::VIOLATIONS_FOUND);
+    }
+    
+    /// Exit with tool error code (2)
+    pub fn tool_error() -> ! {
+        std::process::exit(exit_codes::TOOL_ERROR);
+    }
+}

{rumdl-0.0.93 → rumdl-0.0.95}/src/lib.rs

@@ -1,4 +1,5 @@
 pub mod config;
+pub mod exit_codes;
 pub mod init;
 pub mod inline_config;
 pub mod lint_context;

{rumdl-0.0.93 → rumdl-0.0.95}/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)
     }