rumdl 0.0.107__tar.gz → 0.0.108__tar.gz

{rumdl-0.0.107 → rumdl-0.0.108}/.config/nextest.toml

@@ -43,4 +43,24 @@ default-filter = 'not test(/memory/) and not test(/stress/) and not test(/large/
 test-threads = "num-cpus"
 
 # Less verbose output
-status-level = "fail"
+status-level = "fail"
+
+# Ultra-fast profile for pre-commit hooks
+[profile.pre-commit]
+
+# Only run unit tests in lib, skip all integration tests and binaries
+default-filter = 'package(rumdl) and kind(lib) and not test(/slow|stress|large|integration|comprehensive|cli|config|advanced|commonmark|consistency|performance|benchmark|parity/)'
+
+# Maximum parallelism for speed
+test-threads = "num-cpus"
+
+# Minimal output for speed
+status-level = "fail"
+failure-output = "immediate"
+success-output = "never"
+
+# No retries to save time
+retries = 0
+
+# Fail fast on first failure
+fail-fast = true

{rumdl-0.0.107 → rumdl-0.0.108}/.pre-commit-config.yaml

@@ -1,6 +1,10 @@
 # Pre-commit hooks for rumdl
-# Install with: pre-commit install
-# Run manually: pre-commit run --all-files
+# Install with: 
+#   pre-commit install                    # Install commit hooks
+#   pre-commit install --hook-type pre-push  # Install push hooks
+# Run manually: 
+#   pre-commit run --all-files           # Run commit hooks
+#   pre-commit run --hook-stage push --all-files  # Run push hooks
 
 repos:
   # Rust formatting and linting
@@ -15,26 +19,19 @@ repos:
 
       - id: cargo-clippy
         name: cargo clippy
-        entry: make lint
+        entry: make lint-fast
         language: system
         types: [rust]
         pass_filenames: false
 
       - id: cargo-test-quick
         name: cargo test (quick)
-        entry: make test-quick
+        entry: make test-pre-commit
         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
@@ -57,3 +54,33 @@ repos:
     hooks:
       - id: rumdl
         exclude: ^(test_tmp|benchmark/test-data|docs/temp|CHANGELOG\.md)
+
+  # Pre-push hooks for comprehensive validation
+  - repo: local
+    hooks:
+      - id: cargo-test-full
+        name: cargo test (full suite)
+        entry: make test-push
+        language: system
+        types: [rust]
+        pass_filenames: false
+        stages: [push]
+        verbose: true
+
+      - id: cargo-lint-full
+        name: cargo clippy (all targets)
+        entry: make lint
+        language: system
+        types: [rust]
+        pass_filenames: false
+        stages: [push]
+        verbose: true
+
+      - id: cargo-doc-check
+        name: cargo doc (check)
+        entry: cargo doc --no-deps --all-features
+        language: system
+        types: [rust]
+        pass_filenames: false
+        stages: [push]
+        verbose: true

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

@@ -9,6 +9,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [0.0.107] - 2025-08-06
 
+## [0.0.107] - 2025-08-06
+
+### Fixed
+- MD036: Remove automatic fix to prevent document corruption when bold/italic text is used as image captions, labels, or warnings (#23)
+- MD011: No longer flags patterns like `()[1]` inside inline code as reversed links (#19)
+- MD052: No longer flags reference patterns inside HTML comments as undefined references (#20)
+
 ## [0.0.106] - 2025-08-05
 
 ### Changed
@@ -293,6 +300,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 [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.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

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

@@ -277,9 +277,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.42"
+version = "4.5.43"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed87a9d530bb41a67537289bafcac159cb3ee28460e0a4571123d2a778a6a882"
+checksum = "50fd97c9dc2399518aa331917ac6f274280ec5eb34e555dd291899745c48ec6f"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -287,9 +287,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.42"
+version = "4.5.43"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64f4f3f3c77c94aff3c7e9aac9a2ca1974a5adf392a8bb751e827d6d127ab966"
+checksum = "c35b5830294e1fa0462034af85cc95225a4cb07092c088c55bda3147cfcd8f65"
 dependencies = [
  "anstream",
  "anstyle",
@@ -1493,7 +1493,7 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "rumdl"
-version = "0.0.107"
+version = "0.0.108"
 dependencies = [
  "anyhow",
  "assert_cmd",

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

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

{rumdl-0.0.107 → rumdl-0.0.108}/Makefile

@@ -69,6 +69,13 @@ test-nextest:
 test-quick:
 	cargo nextest run --profile quick
 
+test-pre-commit:
+	cargo nextest run --profile pre-commit
+
+test-push:
+	@echo "Running full test suite (this may take a few minutes)..."
+	cargo nextest run
+
 test-ci:
 	cargo nextest run --profile ci
 
@@ -81,7 +88,10 @@ fmt:
 	cargo fix --allow-dirty --allow-staged
 
 lint:
-	cargo clippy --all-targets --all-features -- -D warnings
+	CARGO_INCREMENTAL=1 cargo clippy --all-targets --all-features -- -D warnings
+
+lint-fast:
+	CARGO_INCREMENTAL=1 cargo clippy --workspace --lib --bins -- -D warnings
 
 check:
 	cargo check --all-targets --all-features

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

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

rumdl-0.0.108/src/bin/debug_frontmatter.rs

@@ -0,0 +1,42 @@
+use rumdl::rules::front_matter_utils::FrontMatterUtils;
+use std::env;
+use std::fs;
+
+fn main() {
+    let args: Vec<String> = env::args().collect();
+    let content = if args.len() > 1 {
+        fs::read_to_string(&args[1]).expect("Failed to read file")
+    } else {
+        r#"+++
+title = "My Post"
+tags = ["example", "test"]
++++
+
+# Content
+
+[missing] reference should be flagged."#
+            .to_string()
+    };
+
+    println!("Content:");
+    for (i, line) in content.lines().enumerate() {
+        println!("Line {}: {}", i + 1, line);
+    }
+    println!();
+
+    let line_count = content.lines().count();
+
+    // Test with 0-based indexing (what the function actually uses)
+    println!("Testing is_in_front_matter with 0-based indexing:");
+    for i in 0..line_count {
+        let in_frontmatter = FrontMatterUtils::is_in_front_matter(&content, i);
+        println!("Line {} (0-based={}): in_frontmatter={}", i + 1, i, in_frontmatter);
+    }
+
+    // Test also with 1-based indexing (what we pass from MD052)
+    println!("\nTesting is_in_front_matter with 1-based indexing:");
+    for i in 1..=line_count {
+        let in_frontmatter = FrontMatterUtils::is_in_front_matter(&content, i);
+        println!("Line {i}: in_frontmatter={in_frontmatter}");
+    }
+}

{rumdl-0.0.107 → rumdl-0.0.108}/src/rules/md037_spaces_around_emphasis.rs

@@ -7,6 +7,15 @@ use crate::utils::emphasis_utils::{
     EmphasisSpan, find_emphasis_markers, find_emphasis_spans, has_doc_patterns, replace_inline_code,
 };
 use crate::utils::regex_cache::UNORDERED_LIST_MARKER_REGEX;
+use lazy_static::lazy_static;
+use regex::Regex;
+
+lazy_static! {
+    // Reference definition pattern - matches [ref]: url "title"
+    static ref REF_DEF_REGEX: Regex = Regex::new(
+        r#"(?m)^[ ]{0,3}\[([^\]]+)\]:\s*([^\s]+)(?:\s+(?:"([^"]*)"|'([^']*)'))?$"#
+    ).unwrap();
+}
 
 /// Check if an emphasis span has spacing issues that should be flagged
 #[inline]
@@ -24,6 +33,34 @@ impl Default for MD037NoSpaceInEmphasis {
     }
 }
 
+impl MD037NoSpaceInEmphasis {
+    /// Check if a byte position is within a link (inline links, reference links, or reference definitions)
+    fn is_in_link(&self, ctx: &crate::lint_context::LintContext, byte_pos: usize) -> bool {
+        // Check inline and reference links
+        for link in &ctx.links {
+            if link.byte_offset <= byte_pos && byte_pos < link.byte_end {
+                return true;
+            }
+        }
+
+        // Check images (which use similar syntax)
+        for image in &ctx.images {
+            if image.byte_offset <= byte_pos && byte_pos < image.byte_end {
+                return true;
+            }
+        }
+
+        // Check reference definitions [ref]: url "title" using regex pattern
+        for m in REF_DEF_REGEX.find_iter(ctx.content) {
+            if m.start() <= byte_pos && byte_pos < m.end() {
+                return true;
+            }
+        }
+
+        false
+    }
+}
+
 impl Rule for MD037NoSpaceInEmphasis {
     fn name(&self) -> &'static str {
         "MD037"
@@ -83,7 +120,30 @@ impl Rule for MD037NoSpaceInEmphasis {
             self.check_line_for_emphasis_issues_fast(&line_no_code, line_num + 1, &mut warnings);
         }
 
-        Ok(warnings)
+        // Filter out warnings for emphasis markers that are inside links
+        let mut filtered_warnings = Vec::new();
+        let mut line_start_pos = 0;
+
+        for (line_idx, line) in content.lines().enumerate() {
+            let line_num = line_idx + 1;
+
+            // Find warnings for this line
+            for warning in &warnings {
+                if warning.line == line_num {
+                    // Calculate byte position of the warning
+                    let byte_pos = line_start_pos + (warning.column - 1);
+
+                    // Only keep warnings that are not inside links
+                    if !self.is_in_link(ctx, byte_pos) {
+                        filtered_warnings.push(warning.clone());
+                    }
+                }
+            }
+
+            line_start_pos += line.len() + 1; // +1 for newline
+        }
+
+        Ok(filtered_warnings)
     }
 
     fn fix(&self, ctx: &crate::lint_context::LintContext) -> Result<String, LintError> {
@@ -367,4 +427,43 @@ mod tests {
             "Expected warnings for spaces in emphasis outside code block"
         );
     }
+
+    #[test]
+    fn test_emphasis_in_links_not_flagged() {
+        let rule = MD037NoSpaceInEmphasis;
+        let content = r#"Check this [* spaced asterisk *](https://example.com/*test*) link.
+
+This has * real spaced emphasis * that should be flagged."#;
+        let ctx = crate::lint_context::LintContext::new(content);
+        let result = rule.check(&ctx).unwrap();
+
+        // Test passed - emphasis inside links are filtered out correctly
+
+        // Only the real emphasis outside links should be flagged
+        assert_eq!(
+            result.len(),
+            1,
+            "Expected exactly 1 warning, but got: {:?}",
+            result.len()
+        );
+        assert!(result[0].message.contains("Spaces inside emphasis markers"));
+        // Should flag "* real spaced emphasis *" but not emphasis patterns inside links
+        assert!(result[0].line == 3); // Line with "* real spaced emphasis *"
+    }
+
+    #[test]
+    fn test_emphasis_in_links_vs_outside_links() {
+        let rule = MD037NoSpaceInEmphasis;
+        let content = r#"Check [* spaced *](https://example.com/*test*) and inline * real spaced * text.
+
+[* link *]: https://example.com/*path*"#;
+        let ctx = crate::lint_context::LintContext::new(content);
+        let result = rule.check(&ctx).unwrap();
+
+        // Only the actual emphasis outside links should be flagged
+        assert_eq!(result.len(), 1);
+        assert!(result[0].message.contains("Spaces inside emphasis markers"));
+        // Should be the "* real spaced *" text on line 1
+        assert!(result[0].line == 1);
+    }
 }

{rumdl-0.0.107 → rumdl-0.0.108}/src/rules/md044_proper_names.rs

@@ -13,6 +13,10 @@ use md044_config::MD044Config;
 
 lazy_static! {
     static ref HTML_COMMENT_REGEX: Regex = Regex::new(r"<!--([\s\S]*?)-->").unwrap();
+    // Reference definition pattern - matches [ref]: url "title"
+    static ref REF_DEF_REGEX: regex::Regex = regex::Regex::new(
+        r#"(?m)^[ ]{0,3}\[([^\]]+)\]:\s*([^\s]+)(?:\s+(?:"([^"]*)"|'([^']*)'))?$"#
+    ).unwrap();
 }
 
 type WarningPosition = (usize, usize, String); // (line, column, found_name)
@@ -304,6 +308,12 @@ impl MD044ProperNames {
                             }
                         }
 
+                        // Skip if in link (inline links, reference links, or reference definitions)
+                        let byte_pos = line_info.byte_offset + cap.start();
+                        if self.is_in_link(ctx, byte_pos) {
+                            continue;
+                        }
+
                         // Find which proper name this matches
                         if let Some(proper_name) = self.get_proper_name_for(found_name) {
                             // Only flag if it's not already correct
@@ -334,6 +344,32 @@ impl MD044ProperNames {
         false
     }
 
+    /// Check if a byte position is within a link (inline links, reference links, or reference definitions)
+    fn is_in_link(&self, ctx: &crate::lint_context::LintContext, byte_pos: usize) -> bool {
+        // Check inline and reference links
+        for link in &ctx.links {
+            if link.byte_offset <= byte_pos && byte_pos < link.byte_end {
+                return true;
+            }
+        }
+
+        // Check images (which use similar syntax)
+        for image in &ctx.images {
+            if image.byte_offset <= byte_pos && byte_pos < image.byte_end {
+                return true;
+            }
+        }
+
+        // Check reference definitions [ref]: url "title" using regex pattern
+        for m in REF_DEF_REGEX.find_iter(ctx.content) {
+            if m.start() <= byte_pos && byte_pos < m.end() {
+                return true;
+            }
+        }
+
+        false
+    }
+
     // Check if a character is a word boundary (handles Unicode)
     fn is_word_boundary_char(c: char) -> bool {
         !c.is_alphanumeric()
@@ -1003,4 +1039,75 @@ More JavaScript."#;
             "Should not fix names inside HTML comments when disabled"
         );
     }
+
+    #[test]
+    fn test_proper_names_in_links_not_flagged() {
+        let rule = MD044ProperNames::new(
+            vec!["JavaScript".to_string(), "Node.js".to_string(), "Python".to_string()],
+            true,
+        );
+
+        let content = r#"Check this [javascript documentation](https://javascript.info) for info.
+
+Visit [node.js homepage](https://nodejs.org) and [python tutorial](https://python.org).
+
+Real javascript should be flagged.
+
+Also see the [typescript guide][ts-ref] for more.
+
+Real python should be flagged too.
+
+[ts-ref]: https://typescript.org/handbook"#;
+
+        let ctx = create_context(content);
+        let result = rule.check(&ctx).unwrap();
+
+        // Only the real standalone proper names should be flagged
+        assert_eq!(
+            result.len(),
+            2,
+            "Expected exactly 2 warnings for standalone proper names"
+        );
+        assert!(result[0].message.contains("'javascript' should be 'JavaScript'"));
+        assert!(result[1].message.contains("'python' should be 'Python'"));
+        // Should be on lines with standalone instances
+        assert!(result[0].line == 5); // "Real javascript should be flagged."
+        assert!(result[1].line == 9); // "Real python should be flagged too."
+    }
+
+    #[test]
+    fn test_proper_names_in_images_not_flagged() {
+        let rule = MD044ProperNames::new(vec!["JavaScript".to_string()], true);
+
+        let content = r#"Here is a ![javascript logo](javascript.png "javascript icon") image.
+
+Real javascript should be flagged."#;
+
+        let ctx = create_context(content);
+        let result = rule.check(&ctx).unwrap();
+
+        // Only the standalone proper name should be flagged
+        assert_eq!(result.len(), 1, "Expected exactly 1 warning for standalone proper name");
+        assert!(result[0].message.contains("'javascript' should be 'JavaScript'"));
+        assert!(result[0].line == 3); // "Real javascript should be flagged."
+    }
+
+    #[test]
+    fn test_proper_names_in_reference_definitions_not_flagged() {
+        let rule = MD044ProperNames::new(vec!["JavaScript".to_string(), "TypeScript".to_string()], true);
+
+        let content = r#"Check the [javascript guide][js-ref] for details.
+
+Real javascript should be flagged.
+
+[js-ref]: https://javascript.info/typescript/guide"#;
+
+        let ctx = create_context(content);
+        let result = rule.check(&ctx).unwrap();
+
+        // Only the standalone proper name should be flagged
+        assert_eq!(result.len(), 1, "Expected exactly 1 warning for standalone proper name");
+        assert!(result[0].message.contains("'javascript' should be 'JavaScript'"));
+        assert!(result[0].line == 3); // "Real javascript should be flagged."
+    }
 }

{rumdl-0.0.107 → rumdl-0.0.108}/src/rules/md049_emphasis_style.rs

@@ -2,6 +2,15 @@ use crate::rule::{Fix, LintError, LintResult, LintWarning, Rule, Severity};
 use crate::rules::emphasis_style::EmphasisStyle;
 use crate::utils::document_structure::DocumentStructure;
 use crate::utils::emphasis_utils::{find_emphasis_markers, find_single_emphasis_spans, replace_inline_code};
+use lazy_static::lazy_static;
+use regex::Regex;
+
+lazy_static! {
+    // Reference definition pattern - matches [ref]: url "title"
+    static ref REF_DEF_REGEX: Regex = Regex::new(
+        r#"(?m)^[ ]{0,3}\[([^\]]+)\]:\s*([^\s]+)(?:\s+(?:"([^"]*)"|'([^']*)'))?$"#
+    ).unwrap();
+}
 
 mod md049_config;
 use md049_config::MD049Config;
@@ -32,6 +41,32 @@ impl MD049EmphasisStyle {
         Self { config }
     }
 
+    /// Check if a byte position is within a link (inline links, reference links, or reference definitions)
+    fn is_in_link(&self, ctx: &crate::lint_context::LintContext, byte_pos: usize) -> bool {
+        // Check inline and reference links
+        for link in &ctx.links {
+            if link.byte_offset <= byte_pos && byte_pos < link.byte_end {
+                return true;
+            }
+        }
+
+        // Check images (which use similar syntax)
+        for image in &ctx.images {
+            if image.byte_offset <= byte_pos && byte_pos < image.byte_end {
+                return true;
+            }
+        }
+
+        // Check reference definitions [ref]: url "title" using regex pattern
+        for m in REF_DEF_REGEX.find_iter(ctx.content) {
+            if m.start() <= byte_pos && byte_pos < m.end() {
+                return true;
+            }
+        }
+
+        false
+    }
+
     // Collect emphasis from a single line
     fn collect_emphasis_from_line(
         &self,
@@ -121,6 +156,9 @@ impl Rule for MD049EmphasisStyle {
             abs_pos += line.len() + 1;
         }
 
+        // Filter out emphasis markers that are inside links
+        emphasis_info.retain(|(_, abs_col, _, _)| !self.is_in_link(ctx, *abs_col));
+
         match self.config.style {
             EmphasisStyle::Consistent => {
                 // If we have less than 2 emphasis nodes, no need to check consistency
@@ -271,4 +309,40 @@ mod tests {
         assert_eq!(EmphasisStyle::from("underscore"), EmphasisStyle::Underscore);
         assert_eq!(EmphasisStyle::from("other"), EmphasisStyle::Consistent);
     }
+
+    #[test]
+    fn test_emphasis_in_links_not_flagged() {
+        let rule = MD049EmphasisStyle::new(EmphasisStyle::Asterisk);
+        let content = r#"Check this [*asterisk*](https://example.com/*pattern*) link and [_underscore_](https://example.com/_private_).
+
+Also see the [`__init__`][__init__] reference.
+
+This should be _flagged_ since we're using asterisk style.
+
+[__init__]: https://example.com/__init__.py"#;
+        let ctx = crate::lint_context::LintContext::new(content);
+        let result = rule.check(&ctx).unwrap();
+
+        // Only the real emphasis outside links should be flagged
+        assert_eq!(result.len(), 1);
+        assert!(result[0].message.contains("Emphasis should use * instead of _"));
+        // Should flag "_flagged_" but not emphasis patterns inside links
+        assert!(result[0].line == 5); // Line with "_flagged_"
+    }
+
+    #[test]
+    fn test_emphasis_in_links_vs_outside_links() {
+        let rule = MD049EmphasisStyle::new(EmphasisStyle::Underscore);
+        let content = r#"Check [*emphasis*](https://example.com/*test*) and inline *real emphasis* text.
+
+[*link*]: https://example.com/*path*"#;
+        let ctx = crate::lint_context::LintContext::new(content);
+        let result = rule.check(&ctx).unwrap();
+
+        // Only the actual emphasis outside links should be flagged
+        assert_eq!(result.len(), 1);
+        assert!(result[0].message.contains("Emphasis should use _ instead of *"));
+        // Should be the "real emphasis" text on line 1
+        assert!(result[0].line == 1);
+    }
 }