rumdl 0.0.105__tar.gz → 0.0.107__tar.gz

{rumdl-0.0.105 → rumdl-0.0.107}/CHANGELOG.md

@@ -7,8 +7,38 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.107] - 2025-08-06
+
+## [0.0.106] - 2025-08-05
+
+### Changed
+- Moved benchmark binaries from Python package distribution
+  - Benchmark tools are now in `benchmark/bin/` directory
+  - Added `build-benchmarks` feature flag to explicitly build benchmarks
+  - Python package now only includes the main `rumdl` binary
+  - Significantly reduced installed package size
+
 ## [0.0.105] - 2025-08-05
 
+## [0.0.105] - 2025-08-05
+
+### Fixed
+- MD029: Fixed list continuation detection to properly handle variable marker widths (fixes #16)
+  - List items with double-digit markers (e.g., "10. ") now correctly require 4+ spaces for continuation
+  - List items with triple-digit markers (e.g., "100. ") now correctly require 5+ spaces for continuation
+  - List items with any number of digits now correctly calculate required continuation indentation
+- MD027: Improved tab handling and added bounds checking for range calculations
+- Installation: Improved update experience for Cursor/Windsurf editors
+
+### Added
+- `--update` flag to check for newer versions and update if available
+- Version checking with update notifications
+- Marketplace-aware installation for VS Code forks
+- Comprehensive tests for MD029 with large number markers (triple and quadruple digits)
+
+### Changed
+- Clarified `--force` flag behavior in help text
+
 ## [0.0.104] - 2025-08-02
 
 ### Added
@@ -261,7 +291,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.105...HEAD
+[Unreleased]: https://github.com/rvben/rumdl/compare/v0.0.107...HEAD
+[0.0.107]: https://github.com/rvben/rumdl/compare/v0.0.106...v0.0.107
+[0.0.105]: https://github.com/rvben/rumdl/compare/v0.0.104...v0.0.105
 [0.0.105]: https://github.com/rvben/rumdl/compare/v0.0.104...v0.0.105
 [0.0.104]: https://github.com/rvben/rumdl/compare/v0.0.103...v0.0.104
 [0.0.102]: https://github.com/rvben/rumdl/compare/v0.0.101...v0.0.102

{rumdl-0.0.105 → rumdl-0.0.107}/Cargo.lock

@@ -49,9 +49,9 @@ checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
 
 [[package]]
 name = "anstream"
-version = "0.6.19"
+version = "0.6.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "301af1932e46185686725e0fad2f8f2aa7da69dd70bf6ecc44d6b703844a3933"
+checksum = "3ae563653d1938f79b1ab1b5e668c87c76a9930414574a6583a7b7e11a8e6192"
 dependencies = [
  "anstyle",
  "anstyle-parse",
@@ -79,22 +79,22 @@ dependencies = [
 
 [[package]]
 name = "anstyle-query"
-version = "1.1.3"
+version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c8bdeb6047d8983be085bab0ba1472e6dc604e7041dbf6fcd5e71523014fae9"
+checksum = "9e231f6134f61b71076a3eab506c379d4f36122f2af15a9ff04415ea4c3339e2"
 dependencies = [
- "windows-sys 0.59.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
 name = "anstyle-wincon"
-version = "3.0.9"
+version = "3.0.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "403f75924867bb1033c59fbf0797484329750cfbe3c4325cd33127941fabc882"
+checksum = "3e0633414522a32ffaac8ac6cc8f748e090c5717661fddeea04219e2344f5f2a"
 dependencies = [
  "anstyle",
  "once_cell_polyfill",
- "windows-sys 0.59.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -1493,7 +1493,7 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "rumdl"
-version = "0.0.105"
+version = "0.0.107"
 dependencies = [
  "anyhow",
  "assert_cmd",
@@ -2527,9 +2527,9 @@ dependencies = [
 
 [[package]]
 name = "zerovec"
-version = "0.11.3"
+version = "0.11.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bdbb9122ea75b11bf96e7492afb723e8a7fbe12c67417aa95e7e3d18144d37cd"
+checksum = "e7aa2bd55086f1ab526693ecbe444205da57e25f4489879da80635a46d90e73b"
 dependencies = [
  "yoke",
  "zerofrom",

{rumdl-0.0.105 → rumdl-0.0.107}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rumdl"
-version = "0.0.105"
+version = "0.0.107"
 edition = "2024"
 rust-version = "1.88.0"
 description = "A fast Markdown linter written in Rust (Ru(st) MarkDown Linter)"
@@ -22,6 +22,32 @@ crate-type = ["cdylib", "rlib"]
 name = "rumdl"
 path = "src/main.rs"
 
+# Benchmark binaries - only built when explicitly requested
+[[bin]]
+name = "benchmark"
+path = "benchmark/bin/benchmark.rs"
+required-features = ["build-benchmarks"]
+
+[[bin]]
+name = "bench_lint_context"
+path = "benchmark/bin/bench_lint_context.rs"
+required-features = ["build-benchmarks"]
+
+[[bin]]
+name = "benchmark_rule"
+path = "benchmark/bin/benchmark_rule.rs"
+required-features = ["build-benchmarks"]
+
+[[bin]]
+name = "file_parallel_benchmark"
+path = "benchmark/bin/file_parallel_benchmark.rs"
+required-features = ["build-benchmarks"]
+
+[[bin]]
+name = "measure_code_span_performance"
+path = "benchmark/bin/measure_code_span_performance.rs"
+required-features = ["build-benchmarks"]
+
 [[bench]]
 name = "rule_performance"
 harness = false
@@ -93,6 +119,7 @@ parallel = ["rayon"]
 profiling = []
 python = ["pyo3"]
 structure_preprocessing = []
+build-benchmarks = []
 
 [dev-dependencies]
 assert_cmd = "2.0.17"

{rumdl-0.0.105 → rumdl-0.0.107}/PKG-INFO

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

{rumdl-0.0.105 → rumdl-0.0.107}/docs/md036.md

@@ -1,8 +1,10 @@
 # MD036 - Use real headings, not just bold text
 
+> **Note:** This rule does not provide automatic fixes because it cannot reliably determine user intent. Bold text on its own line has many legitimate uses (image captions, labels, warnings, etc.).
+
 ## What this rule does
 
-Detects when bold or italic text is used as a standalone heading and converts it to proper heading syntax.
+Detects when bold or italic text is used as a standalone heading.
 
 ## Why this matters
 
@@ -43,9 +45,9 @@ Using emphasis as headings:
 **Configuration:**
 ```
 
-### 🔧 Fixed
+### 🔧 Manual Fix Required
 
-Converted to proper headings:
+These should be manually converted to proper headings:
 
 ```markdown
 ## This looks like a heading
@@ -57,28 +59,29 @@ Converted to proper headings:
 ## Configuration
 ```
 
+**Note:** rumdl will detect these issues but won't automatically fix them. You need to manually decide if the emphasized text should be a heading.
+
 <!-- rumdl-enable MD036 -->
 
 ## Configuration
 
-```yaml
-MD036:
-  punctuation: ".,;:!?"  # Characters to remove from heading ends
+```toml
+# .rumdl.toml
+[MD036]
+punctuation = ".,;:!?"  # Configure punctuation checking
 ```
 
 ### Options
 
-- `punctuation`: String of punctuation marks to remove when converting (default: `".,;:!?"`)
-  - Set to `""` to keep all punctuation
+- `punctuation`: String of punctuation marks that, when found at the end of emphasized text, prevent it from being flagged (default: `".,;:!?"`)
+  - Set to `""` to flag all emphasized lines regardless of punctuation
   - Customize to remove only specific marks
 
 ## Automatic fixes
 
-This rule will:
-- Convert standalone bold/italic lines to proper headings
-- Remove trailing punctuation based on your configuration
-- Choose appropriate heading level (## for bold, # for italic)
-- Preserve common labels like "Table of Contents" as-is
+This rule does **not** provide automatic fixes. Converting bold or italic text to headings is too risky as it can corrupt documents. For example, bold text is often used for image captions, labels, or other legitimate emphasis that should not be converted to headings.
+
+Users should manually review each warning and decide whether the emphasized text should be converted to a heading.
 
 ## Learn more
 

{rumdl-0.0.105 → rumdl-0.0.107}/src/config.rs

@@ -862,6 +862,46 @@ local_time = 07:32:00
             // Note: local_date and local_time might not be parsed by the current implementation
         }
     }
+
+    #[test]
+    fn test_default_config_passes_validation() {
+        use crate::rules;
+
+        let temp_dir = tempdir().unwrap();
+        let config_path = temp_dir.path().join(".rumdl.toml");
+        let config_path_str = config_path.to_str().unwrap();
+
+        // Create the default config using the same function that `rumdl init` uses
+        create_default_config(config_path_str).unwrap();
+
+        // Load it back as a SourcedConfig
+        let sourced =
+            SourcedConfig::load(Some(config_path_str), None).expect("Default config should load successfully");
+
+        // Create the rule registry
+        let all_rules = rules::all_rules(&Config::default());
+        let registry = RuleRegistry::from_rules(&all_rules);
+
+        // Validate the config
+        let warnings = validate_config_sourced(&sourced, &registry);
+
+        // The default config should have no warnings
+        if !warnings.is_empty() {
+            for warning in &warnings {
+                eprintln!("Config validation warning: {}", warning.message);
+                if let Some(rule) = &warning.rule {
+                    eprintln!("  Rule: {rule}");
+                }
+                if let Some(key) = &warning.key {
+                    eprintln!("  Key: {key}");
+                }
+            }
+        }
+        assert!(
+            warnings.is_empty(),
+            "Default config from rumdl init should pass validation without warnings"
+        );
+    }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]

{rumdl-0.0.105 → rumdl-0.0.107}/src/lib.rs

@@ -1,6 +1,5 @@
 pub mod config;
 pub mod exit_codes;
-pub mod init;
 pub mod inline_config;
 pub mod lint_context;
 pub mod lsp;
@@ -190,8 +189,18 @@ pub fn lint(content: &str, rules: &[Box<dyn Rule>], _verbose: bool) -> LintResul
                 let filtered_warnings: Vec<_> = rule_warnings
                     .into_iter()
                     .filter(|warning| {
+                        // Use the warning's rule_name if available, otherwise use the rule's name
+                        let rule_name_to_check = warning.rule_name.unwrap_or(rule.name());
+
+                        // Extract the base rule name for sub-rules like "MD029-style" -> "MD029"
+                        let base_rule_name = if let Some(dash_pos) = rule_name_to_check.find('-') {
+                            &rule_name_to_check[..dash_pos]
+                        } else {
+                            rule_name_to_check
+                        };
+
                         !inline_config.is_rule_disabled(
-                            rule.name(),
+                            base_rule_name,
                             warning.line, // Already 1-indexed
                         )
                     })

{rumdl-0.0.105 → rumdl-0.0.107}/src/rules/md011_no_reversed_links.rs

@@ -204,18 +204,18 @@ impl Rule for MD011NoReversedLinks {
         let mut byte_pos = 0;
 
         for (line_num, line) in content.lines().enumerate() {
-            // Skip if this line is in a code block
-            if ctx.is_in_code_block_or_span(byte_pos) {
-                byte_pos += line.len() + 1;
-                continue;
-            }
-
             // Part 1: Check for existing perfectly formed reversed links
             for cap in REVERSED_LINK_CHECK_REGEX.captures_iter(line) {
                 let match_obj = cap.get(0).unwrap();
                 let match_start = match_obj.start();
                 let match_end = match_obj.end();
 
+                // Check if this specific match is within a code block or inline code span
+                let match_byte_pos = byte_pos + match_start;
+                if ctx.is_in_code_block_or_span(match_byte_pos) {
+                    continue;
+                }
+
                 // Check if the match contains escaped brackets or parentheses
                 let match_text = match_obj.as_str();
 
@@ -277,6 +277,12 @@ impl Rule for MD011NoReversedLinks {
             // Part 2: Check for malformed link attempts where user intent is clear
             let malformed_attempts = self.detect_malformed_link_attempts(line);
             for (start, len, url, text) in malformed_attempts {
+                // Check if this specific match is within a code block or inline code span
+                let match_byte_pos = byte_pos + start;
+                if ctx.is_in_code_block_or_span(match_byte_pos) {
+                    continue;
+                }
+
                 // Calculate precise character range for the malformed syntax
                 let (start_line, start_col, end_line, end_col) = calculate_match_range(line_num + 1, line, start, len);
 
@@ -593,4 +599,45 @@ But this (https://example.com)[reversed link] should be flagged."#;
         let result = rule.check(&ctx).unwrap();
         assert_eq!(result.len(), 1, "Should still flag URLs with nested parentheses");
     }
+
+    #[test]
+    fn test_inline_code_patterns() {
+        // Test for issue #19 - MD011 should not flag patterns inside inline code
+        let rule = MD011NoReversedLinks;
+
+        // Test the exact case from issue #19
+        let content = "I find `inspect.stack()[1].frame` a lot easier to understand (or at least guess about) at a glance than `inspect.stack()[1][0]`.";
+        let ctx = LintContext::new(content);
+        let result = rule.check(&ctx).unwrap();
+        assert_eq!(result.len(), 0, "Should not flag ()[1] patterns inside inline code");
+
+        // Test other patterns that might look like reversed links in code
+        let content = "Use `array()[0]` or `func()[1]` to access elements.";
+        let ctx = LintContext::new(content);
+        let result = rule.check(&ctx).unwrap();
+        assert_eq!(result.len(), 0, "Should not flag array access patterns in inline code");
+
+        // Test that actual reversed links outside code are still caught
+        let content = "Check out (https://example.com)[this link] and use `array()[1]`.";
+        let ctx = LintContext::new(content);
+        let result = rule.check(&ctx).unwrap();
+        assert_eq!(result.len(), 1, "Should flag actual reversed link but not code pattern");
+        assert!(result[0].message.contains("Reversed link syntax"));
+
+        // Test mixed scenario with code blocks
+        let content = r#"
+Here's some code: `func()[1]` and `other()[2]`.
+
+But this is wrong: (https://example.com)[Click here]
+
+```python
+# This should not be flagged
+result = inspect.stack()[1]
+```
+"#;
+        let ctx = LintContext::new(content);
+        let result = rule.check(&ctx).unwrap();
+        assert_eq!(result.len(), 1, "Should only flag the actual reversed link");
+        assert_eq!(result[0].line, 4, "Should flag the reversed link on line 4");
+    }
 }