rumdl 0.0.97__tar.gz → 0.0.99__tar.gz

rumdl-0.0.99/.pre-commit-config.yaml

@@ -0,0 +1,59 @@
+# Pre-commit hooks for rumdl
+# Install with: pre-commit install
+# Run manually: pre-commit run --all-files
+
+repos:
+  # Rust formatting and linting
+  - repo: local
+    hooks:
+      - id: cargo-fmt
+        name: cargo fmt
+        entry: cargo fmt --all --
+        language: system
+        types: [rust]
+        pass_filenames: false
+
+      - id: cargo-clippy
+        name: cargo clippy
+        entry: make lint
+        language: system
+        types: [rust]
+        pass_filenames: false
+
+      - id: cargo-test-quick
+        name: cargo test (quick)
+        entry: make test-quick
+        language: system
+        types: [rust]
+        pass_filenames: false
+        stages: [pre-commit]
+
+      - id: cargo-check
+        name: cargo check
+        entry: cargo check --all-targets --all-features
+        language: system
+        types: [rust]
+        pass_filenames: false
+
+  # General file quality checks
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.6.0
+    hooks:
+      - id: trailing-whitespace
+        exclude: \.md$
+      - id: end-of-file-fixer
+        exclude: \.md$
+      - id: check-yaml
+      - id: check-toml
+      - id: check-json
+      - id: check-merge-conflict
+      - id: check-case-conflict
+      - id: mixed-line-ending
+        args: [--fix=lf]
+
+  # Markdown linting using rumdl itself
+  - repo: https://github.com/rvben/rumdl-pre-commit
+    rev: v0.0.45
+    hooks:
+      - id: rumdl
+        exclude: ^(test_tmp|benchmark/test-data|docs/temp|CHANGELOG\.md)

{rumdl-0.0.97 → rumdl-0.0.99}/CHANGELOG.md

@@ -7,6 +7,31 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.99] - 2025-07-22
+
+### Fixed
+- MD034: Added support for `ftps://` URLs 
+- MD034: Fixed detection of URLs in HTML comments (now properly ignored)
+- MD039: Fixed escaped character handling in link text
+- MD044: Fixed clippy warnings and improved pattern matching for proper names
+- MD052: Enhanced nested bracket handling in reference links and images
+- Fixed flaky performance tests by increasing timeout threshold for CI environments
+- Improved test stability for Unicode list indentation tests
+
+## [0.0.98] - 2025-07-18
+
+### Added
+- Homebrew tap support for easy installation on macOS and Linux
+  - Created `homebrew-rumdl` tap repository
+  - Added automatic archive creation for macOS builds in release workflow
+  - Included SHA256 checksum generation for each platform
+  - Set up automated formula updates on new releases
+- Homebrew installation instructions in README
+
+### Changed
+- Enhanced release workflow to create platform-specific tar.gz archives
+- Added repository dispatch to notify homebrew-rumdl on new releases
+
 ## [0.0.97] - 2025-07-17
 
 ### Changed
@@ -198,7 +223,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.97...HEAD
+[Unreleased]: https://github.com/rvben/rumdl/compare/v0.0.99...HEAD
+[0.0.99]: https://github.com/rvben/rumdl/compare/v0.0.98...v0.0.99
+[0.0.98]: https://github.com/rvben/rumdl/compare/v0.0.97...v0.0.98
 [0.0.97]: https://github.com/rvben/rumdl/compare/v0.0.96...v0.0.97
 [0.0.96]: https://github.com/rvben/rumdl/compare/v0.0.95...v0.0.96
 [0.0.95]: https://github.com/rvben/rumdl/compare/v0.0.94...v0.0.95

{rumdl-0.0.97 → rumdl-0.0.99}/Cargo.lock

@@ -220,9 +220,9 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
 [[package]]
 name = "cc"
-version = "1.2.29"
+version = "1.2.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c1599538de2394445747c8cf7935946e3cc27e9625f889d979bfb2aaf569362"
+checksum = "deec109607ca693028562ed836a5f1c4b8bd77755c4e132fc5ce11b0b6211ae7"
 dependencies = [
  "shlex",
 ]
@@ -1493,7 +1493,7 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "rumdl"
-version = "0.0.97"
+version = "0.0.99"
 dependencies = [
  "anyhow",
  "assert_cmd",
@@ -1629,9 +1629,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.140"
+version = "1.0.141"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "20068b6e96dc6c9bd23e01df8827e6c7e1f2fddd43c21810382803c136b99373"
+checksum = "30b9eff21ebe718216c6ec64e1d9ac57087aad11efc64e32002bce4a0d4c03d3"
 dependencies = [
  "itoa",
  "memchr",

{rumdl-0.0.97 → rumdl-0.0.99}/Cargo.toml

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

{rumdl-0.0.97 → rumdl-0.0.99}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rumdl
-Version: 0.0.97
+Version: 0.0.99
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -87,6 +87,7 @@ It offers:
 - [Quick Start](#quick-start)
 - [Overview](#overview)
 - [Installation](#installation)
+  - [Using Homebrew (macOS/Linux)](#using-homebrew-macoslinux)
   - [Using Cargo (Rust)](#using-cargo-rust)
   - [Using pip (Python)](#using-pip-python)
   - [Using uv](#using-uv)
@@ -118,6 +119,13 @@ It offers:
 
 Choose the installation method that works best for you:
 
+### Using Homebrew (macOS/Linux)
+
+```bash
+brew tap rvben/rumdl
+brew install rumdl
+```
+
 ### Using Cargo (Rust)
 
 ```bash

{rumdl-0.0.97 → rumdl-0.0.99}/README.md

@@ -56,6 +56,7 @@ It offers:
 - [Quick Start](#quick-start)
 - [Overview](#overview)
 - [Installation](#installation)
+  - [Using Homebrew (macOS/Linux)](#using-homebrew-macoslinux)
   - [Using Cargo (Rust)](#using-cargo-rust)
   - [Using pip (Python)](#using-pip-python)
   - [Using uv](#using-uv)
@@ -87,6 +88,13 @@ It offers:
 
 Choose the installation method that works best for you:
 
+### Using Homebrew (macOS/Linux)
+
+```bash
+brew tap rvben/rumdl
+brew install rumdl
+```
+
 ### Using Cargo (Rust)
 
 ```bash

rumdl-0.0.99/scripts/setup-pre-commit.sh

@@ -0,0 +1,49 @@
+#!/bin/bash
+
+# Setup pre-commit hooks for rumdl development
+# This script installs pre-commit and sets up the hooks
+
+set -e
+
+echo "Setting up pre-commit hooks for rumdl..."
+
+# Check if pre-commit is installed
+if ! command -v pre-commit &> /dev/null; then
+    echo "Installing pre-commit..."
+    if command -v uv &> /dev/null; then
+        uv tool install pre-commit
+    elif command -v pip &> /dev/null; then
+        pip install pre-commit
+    else
+        echo "Error: Neither uv nor pip found. Please install one of them first."
+        exit 1
+    fi
+else
+    echo "pre-commit is already installed"
+fi
+
+# Install the hooks
+echo "Installing pre-commit hooks..."
+pre-commit install
+
+# Run hooks on all files to ensure everything is set up correctly
+echo "Running pre-commit hooks on all files..."
+pre-commit run --all-files || {
+    echo "Some hooks failed, but that's normal for first run."
+    echo "The hooks will automatically fix formatting issues."
+    echo "You may need to stage and commit the changes."
+}
+
+echo ""
+echo "✅ Pre-commit hooks are now set up!"
+echo ""
+echo "The following hooks will run on every commit:"
+echo "  - cargo fmt (automatic formatting)"
+echo "  - make lint (clippy linting)"
+echo "  - make test-quick (fast tests)"
+echo "  - cargo check (compilation check)"
+echo "  - File quality checks (trailing whitespace, etc.)"
+echo "  - rumdl markdown linting"
+echo ""
+echo "To manually run all hooks: pre-commit run --all-files"
+echo "To skip hooks for emergency commits: git commit --no-verify"

{rumdl-0.0.97 → rumdl-0.0.99}/src/bin/benchmark_rule.rs

@@ -7,7 +7,7 @@ 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 {
@@ -15,7 +15,7 @@ fn benchmark_rule(rule: &dyn Rule, test_cases: &[(&str, &str)], iterations: u32)
             let _ = rule.check(&ctx);
             let _ = rule.fix(&ctx);
         }
-        
+
         // Benchmark check
         let start = Instant::now();
         for _ in 0..iterations {
@@ -23,7 +23,7 @@ fn benchmark_rule(rule: &dyn Rule, test_cases: &[(&str, &str)], iterations: u32)
             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 {
@@ -31,10 +31,10 @@ fn benchmark_rule(rule: &dyn Rule, test_cases: &[(&str, &str)], iterations: u32)
             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
 }
 
@@ -83,7 +83,7 @@ fn generate_test_content(rule_name: &str) -> Vec<(&'static str, String)> {
             ("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.push_str(&format!("URL {i}: http://example{i}.com/path/{i}/file?id={i}\n"));
                 }
                 content
             }),
@@ -96,11 +96,11 @@ fn generate_test_content(rule_name: &str) -> Vec<(&'static str, String)> {
             ("Many references", {
                 let mut content = String::new();
                 for i in 0..100 {
-                    content.push_str(&format!("[link{}][ref{}]\n", i, i));
+                    content.push_str(&format!("[link{i}][ref{i}]\n"));
                 }
-                content.push_str("\n");
+                content.push('\n');
                 for i in 0..200 {
-                    content.push_str(&format!("[ref{}]: http://example{}.com\n", i, i));
+                    content.push_str(&format!("[ref{i}]: http://example{i}.com\n"));
                 }
                 content
             }),
@@ -117,40 +117,39 @@ fn main() {
         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 rule = rules.into_iter().find(|r| r.name() == rule_name).unwrap_or_else(|| {
+        eprintln!("Rule {rule_name} not found");
+        std::process::exit(1);
+    });
+
     let test_cases_vec = generate_test_content(rule_name);
-    let test_cases: Vec<(&str, &str)> = test_cases_vec.iter()
+    let test_cases: Vec<(&str, &str)> = test_cases_vec
+        .iter()
         .map(|(name, content)| (*name, content.as_str()))
         .collect();
-    
-    println!("Benchmarking {} Rule", rule_name);
+
+    println!("Benchmarking {rule_name} Rule");
     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);
+        println!("{test_name:<30} Check: {check_time:>6} μs  Fix: {fix_time:>6} μs");
         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.97 → rumdl-0.0.99}/src/config.rs

@@ -1035,12 +1035,7 @@ impl SourcedConfig {
                 .overrides
                 .first()
                 .and_then(|o| o.file.clone()),
-            fragment
-                .global
-                .respect_gitignore
-                .overrides
-                .first()
-                .and_then(|o| o.line),
+            fragment.global.respect_gitignore.overrides.first().and_then(|o| o.line),
         );
 
         // Merge output_format if present
@@ -1441,8 +1436,8 @@ fn toml_value_type_matches(expected: &toml::Value, actual: &toml::Value) -> bool
 
 /// Parses pyproject.toml content and extracts the [tool.rumdl] section if present.
 fn parse_pyproject_toml(content: &str, path: &str) -> Result<Option<SourcedConfigFragment>, ConfigError> {
-    let doc: toml::Value = toml::from_str(content)
-        .map_err(|e| ConfigError::ParseError(format!("{path}: Failed to parse TOML: {e}")))?;
+    let doc: toml::Value =
+        toml::from_str(content).map_err(|e| ConfigError::ParseError(format!("{path}: Failed to parse TOML: {e}")))?;
     let mut fragment = SourcedConfigFragment::default();
     let source = ConfigSource::PyprojectToml;
     let file = Some(path.to_string());
@@ -1867,9 +1862,7 @@ fn parse_rumdl_toml(content: &str, path: &str) -> Result<SourcedConfigFragment,
                 }
             }
         } else if item.is_value() {
-            log::warn!(
-                "[WARN] Ignoring top-level value key in {path}: '{key}'. Expected a table like [{key}]."
-            );
+            log::warn!("[WARN] Ignoring top-level value key in {path}: '{key}'. Expected a table like [{key}].");
         }
     }
 

rumdl-0.0.99/src/exit_codes.rs

@@ -0,0 +1,32 @@
+/// Exit codes for rumdl, following Ruff's convention
+///
+/// These exit codes allow users and CI/CD systems to distinguish between
+/// different types of failures.
+/// 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::{SUCCESS, TOOL_ERROR, VIOLATIONS_FOUND};
+
+    /// Exit with success code (0)
+    pub fn success() -> ! {
+        std::process::exit(SUCCESS);
+    }
+
+    /// Exit with violations found code (1)
+    pub fn violations_found() -> ! {
+        std::process::exit(VIOLATIONS_FOUND);
+    }
+
+    /// Exit with tool error code (2)
+    pub fn tool_error() -> ! {
+        std::process::exit(TOOL_ERROR);
+    }
+}

{rumdl-0.0.97 → rumdl-0.0.99}/src/lib.rs

@@ -217,9 +217,7 @@ pub fn lint(content: &str, rules: &[Box<dyn Rule>], _verbose: bool) -> LintResul
     if _verbose {
         let skipped_rules = _total_rules - _applicable_count;
         if skipped_rules > 0 {
-            log::debug!(
-                "Skipped {skipped_rules} of {_total_rules} rules based on content analysis"
-            );
+            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");

{rumdl-0.0.97 → rumdl-0.0.99}/src/lint_context.rs

@@ -7,7 +7,7 @@ lazy_static! {
     // Use (?s) flag to make . match newlines
     static ref LINK_PATTERN: Regex = Regex::new(
         r"(?sx)
-        \[([^\]]*)\]          # Link text in group 1
+        \[((?:[^\[\]\\]|\\.|\[[^\]]*\])*)\]          # Link text in group 1 (handles nested brackets)
         (?:
             \(([^)]*)\)       # Inline URL in group 2 (can be empty)
             |
@@ -19,7 +19,7 @@ lazy_static! {
     // Use (?s) flag to make . match newlines
     static ref IMAGE_PATTERN: Regex = Regex::new(
         r"(?sx)
-        !\[([^\]]*)\]         # Alt text in group 1
+        !\[((?:[^\[\]\\]|\\.|\[[^\]]*\])*)\]         # Alt text in group 1 (handles nested brackets)
         (?:
             \(([^)]*)\)       # Inline URL in group 2 (can be empty)
             |
@@ -295,13 +295,13 @@ impl<'a> LintContext<'a> {
     /// 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()
     }
@@ -388,6 +388,11 @@ impl<'a> LintContext<'a> {
             let match_start = full_match.start();
             let match_end = full_match.end();
 
+            // Skip if the opening bracket is escaped (preceded by \)
+            if match_start > 0 && content.as_bytes().get(match_start - 1) == Some(&b'\\') {
+                continue;
+            }
+
             // Skip if this is actually an image (preceded by !)
             if match_start > 0 && content.as_bytes().get(match_start - 1) == Some(&b'!') {
                 continue;
@@ -482,6 +487,11 @@ impl<'a> LintContext<'a> {
             let match_start = full_match.start();
             let match_end = full_match.end();
 
+            // Skip if the ! is escaped (preceded by \)
+            if match_start > 0 && content.as_bytes().get(match_start - 1) == Some(&b'\\') {
+                continue;
+            }
+
             // Skip if in code block or span
             if CodeBlockUtils::is_in_code_block_or_span(code_blocks, match_start) {
                 continue;
@@ -1155,7 +1165,33 @@ impl<'a> LintContext<'a> {
                                     && item.is_ordered == block.is_ordered
                                     && block.blockquote_prefix.trim() == next_blockquote_prefix.trim()
                                 {
-                                    found_continuation = true;
+                                    // Check if there was meaningful content between the list items
+                                    let has_meaningful_content = (line_idx + 1..check_idx).any(|idx| {
+                                        if let Some(between_line) = lines.get(idx) {
+                                            let trimmed = between_line.content.trim();
+                                            // Skip empty lines
+                                            if trimmed.is_empty() {
+                                                return false;
+                                            }
+                                            // Check for meaningful content
+                                            let line_indent =
+                                                between_line.content.len() - between_line.content.trim_start().len();
+                                            // Code fences or properly indented content
+                                            trimmed.starts_with("```")
+                                                || trimmed.starts_with("~~~")
+                                                || line_indent >= current_indent_level + 2
+                                        } else {
+                                            false
+                                        }
+                                    });
+
+                                    if block.is_ordered {
+                                        // For ordered lists: only continue if there's meaningful content
+                                        found_continuation = has_meaningful_content;
+                                    } else {
+                                        // For unordered lists: continue regardless
+                                        found_continuation = true;
+                                    }
                                 }
                             }
                         }
@@ -1215,14 +1251,14 @@ impl<'a> LintContext<'a> {
         }
 
         // Merge adjacent blocks that should be one
-        merge_adjacent_list_blocks(&mut list_blocks);
+        merge_adjacent_list_blocks(&mut list_blocks, lines);
 
         list_blocks
     }
 }
 
 /// Merge adjacent list blocks that should be treated as one
-fn merge_adjacent_list_blocks(list_blocks: &mut Vec<ListBlock>) {
+fn merge_adjacent_list_blocks(list_blocks: &mut Vec<ListBlock>, lines: &[LineInfo]) {
     if list_blocks.len() < 2 {
         return;
     }
@@ -1237,10 +1273,20 @@ fn merge_adjacent_list_blocks(list_blocks: &mut Vec<ListBlock>) {
         let consecutive = next.start_line == current.end_line + 1;
         let only_blank_between = next.start_line == current.end_line + 2;
 
+        // For ordered lists, we need to be more careful about merging
+        let should_merge_condition = if current.is_ordered && next.is_ordered {
+            // Only merge ordered lists if there's meaningful content between them
+            // (like code blocks, continuation paragraphs) not just blank lines
+            consecutive || has_meaningful_content_between(&current, next, lines)
+        } else {
+            // For unordered lists, use original logic
+            consecutive || (only_blank_between && current.marker == next.marker)
+        };
+
         let should_merge = next.is_ordered == current.is_ordered
             && next.blockquote_prefix == current.blockquote_prefix
             && next.nesting_level == current.nesting_level
-            && (consecutive || (only_blank_between && current.marker == next.marker));
+            && should_merge_condition;
 
         if should_merge {
             // Merge blocks
@@ -1265,6 +1311,42 @@ fn merge_adjacent_list_blocks(list_blocks: &mut Vec<ListBlock>) {
     *list_blocks = merged;
 }
 
+/// Check if there's meaningful content (not just blank lines) between two list blocks
+fn has_meaningful_content_between(current: &ListBlock, next: &ListBlock, lines: &[LineInfo]) -> bool {
+    // Check lines between current.end_line and next.start_line
+    for line_num in (current.end_line + 1)..next.start_line {
+        if let Some(line_info) = lines.get(line_num - 1) {
+            // Convert to 0-indexed
+            let trimmed = line_info.content.trim();
+
+            // Skip empty lines
+            if trimmed.is_empty() {
+                continue;
+            }
+
+            // Check if this line has proper indentation for list continuation
+            let line_indent = line_info.content.len() - line_info.content.trim_start().len();
+
+            // If the line is indented enough to be list continuation content, it's meaningful
+            // List content should be indented at least 2 spaces beyond the marker
+            if line_indent >= current.nesting_level + 2 {
+                return true;
+            }
+
+            // Code fences are meaningful content
+            if trimmed.starts_with("```") || trimmed.starts_with("~~~") {
+                return true;
+            }
+
+            // Any other non-blank content at this level breaks the sequence
+            return false;
+        }
+    }
+
+    // Only blank lines between blocks - should not merge
+    false
+}
+
 /// Check if content contains patterns that cause the markdown crate to panic
 #[cfg(test)]
 mod tests {