rumdl 0.0.115__tar.gz → 0.0.117__tar.gz

{rumdl-0.0.115 → rumdl-0.0.117}/CHANGELOG.md

@@ -7,6 +7,31 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.117] - 2025-08-14
+
+### Fixed
+- MD037: Fixed false positive with asterisks in inline code spans (issue #49)
+  - Inline code content is now properly masked before emphasis detection
+- MD011: Fixed false positive with array access patterns in link titles (issue #50)
+  - Context detection now properly skips patterns inside code spans
+- MD052: Fixed false positive with square brackets in HTML attributes (issue #51)
+  - HTML tag detection prevents reference checking within HTML elements
+- Added centralized skip context detection for improved accuracy across rules
+
+## [0.0.116] - 2025-08-13
+
+### Added
+- Kramdown-style custom header IDs support (#44)
+  - Headers can now have custom IDs using the `{#custom-id}` syntax
+  - Custom IDs are preserved when fixing MD051 (link fragments)
+  - MD026 (trailing punctuation) now ignores headers with custom IDs
+  - Safe character validation: accepts Unicode letters/numbers, hyphens, underscores, and colons
+  - Rejects problematic characters like spaces, quotes, brackets, and HTML/CSS special chars
+
+### Fixed
+- Pre-release script now correctly handles dynamic versioning in pyproject.toml
+- Added Cargo.lock validation and `cargo publish --dry-run` checks to prevent release failures
+
 ## [0.0.115] - 2025-08-12
 
 ## [0.0.114] - 2025-08-09
@@ -310,7 +335,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.115...HEAD
+[Unreleased]: https://github.com/rvben/rumdl/compare/v0.0.117...HEAD
+[0.0.117]: https://github.com/rvben/rumdl/compare/v0.0.116...v0.0.117
+[0.0.116]: https://github.com/rvben/rumdl/compare/v0.0.115...v0.0.116
 [0.0.115]: https://github.com/rvben/rumdl/compare/v0.0.114...v0.0.115
 [0.0.114]: https://github.com/rvben/rumdl/compare/v0.0.113...v0.0.114
 [0.0.113]: https://github.com/rvben/rumdl/compare/v0.0.112...v0.0.113

{rumdl-0.0.115 → rumdl-0.0.117}/Cargo.lock

@@ -1435,9 +1435,9 @@ dependencies = [
 
 [[package]]
 name = "rayon"
-version = "1.10.0"
+version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa"
+checksum = "368f01d005bf8fd9b1206fb6fa653e6c4a81ceb1466406b81792d87c5677a58f"
 dependencies = [
  "either",
  "rayon-core",
@@ -1445,9 +1445,9 @@ dependencies = [
 
 [[package]]
 name = "rayon-core"
-version = "1.12.1"
+version = "1.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2"
+checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
 dependencies = [
  "crossbeam-deque",
  "crossbeam-utils",
@@ -1493,7 +1493,7 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "rumdl"
-version = "0.0.115"
+version = "0.0.117"
 dependencies = [
  "anyhow",
  "assert_cmd",
@@ -1723,9 +1723,9 @@ checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 
 [[package]]
 name = "syn"
-version = "2.0.104"
+version = "2.0.105"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "17b6f705963418cdb9927482fa304bc562ece2fdd4f616084c50b7023b435a40"
+checksum = "7bc3fcb250e53458e712715cf74285c1f889686520d79294a9ef3bd7aa1fc619"
 dependencies = [
  "proc-macro2",
  "quote",

{rumdl-0.0.115 → rumdl-0.0.117}/Cargo.toml

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

{rumdl-0.0.115 → rumdl-0.0.117}/PKG-INFO

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

{rumdl-0.0.115 → rumdl-0.0.117}/scripts/pre-release.sh

@@ -73,15 +73,24 @@ run_check "Release build" "cargo build --release"
 echo "6. Checking documentation..."
 run_check "Documentation" "cargo doc --no-deps"
 
-# 7. Verify Cargo.toml version
+# 7. Verify Cargo.toml version (pyproject.toml uses dynamic versioning from Cargo.toml)
 echo "7. Checking version consistency..."
 CARGO_VERSION=$(grep '^version' Cargo.toml | head -1 | cut -d'"' -f2)
-PY_VERSION=$(grep '^version' pyproject.toml | head -1 | cut -d'"' -f2)
-if [ "$CARGO_VERSION" != "$PY_VERSION" ]; then
-    echo -e "${RED}Version mismatch: Cargo.toml ($CARGO_VERSION) vs pyproject.toml ($PY_VERSION)${NC}"
-    FAILED=1
+# pyproject.toml uses dynamic = ["version"] to read from Cargo.toml
+if grep -q 'dynamic = \["version"\]' pyproject.toml; then
+    echo -e "${GREEN}✓${NC} Version $CARGO_VERSION (pyproject.toml uses dynamic versioning)"
 else
-    echo -e "${GREEN}✓${NC} Version $CARGO_VERSION is consistent"
+    # Fallback: check if there's a static version in pyproject.toml
+    PY_VERSION=$(grep '^version' pyproject.toml | head -1 | cut -d'"' -f2)
+    if [ -z "$PY_VERSION" ]; then
+        echo -e "${YELLOW}⚠${NC} pyproject.toml should use dynamic = [\"version\"] for version"
+        # Not a failure, just a warning
+    elif [ "$CARGO_VERSION" != "$PY_VERSION" ]; then
+        echo -e "${RED}Version mismatch: Cargo.toml ($CARGO_VERSION) vs pyproject.toml ($PY_VERSION)${NC}"
+        FAILED=1
+    else
+        echo -e "${GREEN}✓${NC} Version $CARGO_VERSION is consistent"
+    fi
 fi
 
 # 8. Check for uncommitted changes
@@ -111,6 +120,20 @@ else
     echo -e "${GREEN}✓${NC} Tag $TAG_VERSION is available"
 fi
 
+# 11. Verify Cargo.lock is up to date
+echo "11. Verifying Cargo.lock is up to date..."
+if cargo update --workspace --dry-run 2>&1 | grep -q "Updating"; then
+    echo -e "${RED}✗ Cargo.lock needs updating${NC}"
+    echo "   Run: cargo update --workspace"
+    FAILED=1
+else
+    echo -e "${GREEN}✓${NC} Cargo.lock is up to date"
+fi
+
+# 12. Test cargo publish with --dry-run
+echo "12. Testing cargo publish (dry run)..."
+run_check "Cargo publish dry-run" "cargo publish --dry-run --locked"
+
 echo ""
 echo "====================================="
 if [ $FAILED -eq 0 ]; then

{rumdl-0.0.115 → rumdl-0.0.117}/src/lint_context.rs

@@ -197,8 +197,12 @@ pub struct HeadingInfo {
     pub marker_column: usize,
     /// Column where heading text starts
     pub content_column: usize,
-    /// The heading text (without markers)
+    /// The heading text (without markers and without custom ID syntax)
     pub text: String,
+    /// Custom header ID if present (e.g., from {#custom-id} syntax)
+    pub custom_id: Option<String>,
+    /// Original heading text including custom ID syntax
+    pub raw_text: String,
     /// Whether it has a closing sequence (for ATX)
     pub has_closing_sequence: bool,
     /// The closing sequence if present
@@ -1088,10 +1092,23 @@ impl<'a> LintContext<'a> {
                 let level = hashes.len() as u8;
                 let marker_column = leading_spaces.len();
 
-                // Check for closing sequence
+                // Check for closing sequence, but handle custom IDs that might come after
                 let (text, has_closing, closing_seq) = {
-                    // Find the start of a potential closing sequence
-                    let trimmed_rest = rest.trim_end();
+                    // First check if there's a custom ID at the end
+                    let (rest_without_id, custom_id_part) = if let Some(id_start) = rest.rfind(" {#") {
+                        // Check if this looks like a valid custom ID (ends with })
+                        if rest[id_start..].trim_end().ends_with('}') {
+                            // Split off the custom ID
+                            (&rest[..id_start], &rest[id_start..])
+                        } else {
+                            (rest, "")
+                        }
+                    } else {
+                        (rest, "")
+                    };
+
+                    // Now look for closing hashes in the part before the custom ID
+                    let trimmed_rest = rest_without_id.trim_end();
                     if let Some(last_hash_pos) = trimmed_rest.rfind('#') {
                         // Look for the start of the hash sequence
                         let mut start_of_hashes = last_hash_pos;
@@ -1099,32 +1116,55 @@ impl<'a> LintContext<'a> {
                             start_of_hashes -= 1;
                         }
 
-                        // Check if this is a valid closing sequence (all hashes to end of line)
+                        // Check if there's at least one space before the closing hashes
+                        let has_space_before = start_of_hashes == 0
+                            || trimmed_rest
+                                .chars()
+                                .nth(start_of_hashes - 1)
+                                .is_some_and(|c| c.is_whitespace());
+
+                        // Check if this is a valid closing sequence (all hashes to end of trimmed part)
                         let potential_closing = &trimmed_rest[start_of_hashes..];
                         let is_all_hashes = potential_closing.chars().all(|c| c == '#');
 
-                        if is_all_hashes {
-                            // This is a closing sequence, regardless of spacing
+                        if is_all_hashes && has_space_before {
+                            // This is a closing sequence
                             let closing_hashes = potential_closing.to_string();
-                            let text_part = rest[..start_of_hashes].trim_end();
-                            (text_part.to_string(), true, closing_hashes)
+                            // The text is everything before the closing hashes
+                            // Don't include the custom ID here - it will be extracted later
+                            let text_part = if !custom_id_part.is_empty() {
+                                // If we have a custom ID, append it back to get the full rest
+                                // This allows the extract_header_id function to handle it properly
+                                format!("{}{}", rest_without_id[..start_of_hashes].trim_end(), custom_id_part)
+                            } else {
+                                rest_without_id[..start_of_hashes].trim_end().to_string()
+                            };
+                            (text_part, true, closing_hashes)
                         } else {
+                            // Not a valid closing sequence, return the full content
                             (rest.to_string(), false, String::new())
                         }
                     } else {
+                        // No hashes found, return the full content
                         (rest.to_string(), false, String::new())
                     }
                 };
 
                 let content_column = marker_column + hashes.len() + spaces_after.len();
 
+                // Extract custom header ID if present
+                let raw_text = text.trim().to_string();
+                let (clean_text, custom_id) = crate::utils::kramdown_utils::extract_header_id(&raw_text);
+
                 lines[i].heading = Some(HeadingInfo {
                     level,
                     style: HeadingStyle::ATX,
                     marker: hashes.to_string(),
                     marker_column,
                     content_column,
-                    text: text.trim().to_string(),
+                    text: clean_text,
+                    custom_id,
+                    raw_text,
                     has_closing_sequence: has_closing,
                     closing_sequence: closing_seq,
                 });
@@ -1146,13 +1186,19 @@ impl<'a> LintContext<'a> {
                         HeadingStyle::Setext2
                     };
 
+                    // Extract custom header ID if present
+                    let raw_text = line.trim().to_string();
+                    let (clean_text, custom_id) = crate::utils::kramdown_utils::extract_header_id(&raw_text);
+
                     lines[i].heading = Some(HeadingInfo {
                         level,
                         style,
                         marker: underline.to_string(),
                         marker_column: next_line.len() - next_line.trim_start().len(),
                         content_column: lines[i].indent,
-                        text: line.trim().to_string(),
+                        text: clean_text,
+                        custom_id,
+                        raw_text,
                         has_closing_sequence: false,
                         closing_sequence: String::new(),
                     });

{rumdl-0.0.115 → rumdl-0.0.117}/src/rules/md011_no_reversed_links.rs

@@ -3,6 +3,7 @@
 /// See [docs/md011.md](../../docs/md011.md) for full documentation, configuration, and examples.
 use crate::rule::{Fix, LintError, LintResult, LintWarning, Rule, Severity};
 use crate::utils::range_utils::calculate_match_range;
+use crate::utils::skip_context::{is_in_front_matter, is_in_html_comment, is_in_math_context};
 use lazy_static::lazy_static;
 use regex::Regex;
 
@@ -216,6 +217,21 @@ impl Rule for MD011NoReversedLinks {
                     continue;
                 }
 
+                // Skip if in HTML comment
+                if is_in_html_comment(content, match_byte_pos) {
+                    continue;
+                }
+
+                // Skip if in math context
+                if is_in_math_context(ctx, match_byte_pos) {
+                    continue;
+                }
+
+                // Skip if in front matter (line_num is 0-based)
+                if is_in_front_matter(content, line_num) {
+                    continue;
+                }
+
                 // Check if the match contains escaped brackets or parentheses
                 let match_text = match_obj.as_str();
 
@@ -283,6 +299,21 @@ impl Rule for MD011NoReversedLinks {
                     continue;
                 }
 
+                // Skip if in HTML comment
+                if is_in_html_comment(content, match_byte_pos) {
+                    continue;
+                }
+
+                // Skip if in math context
+                if is_in_math_context(ctx, match_byte_pos) {
+                    continue;
+                }
+
+                // Skip if in front matter (line_num is 0-based)
+                if is_in_front_matter(content, line_num) {
+                    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);
 
@@ -367,6 +398,7 @@ impl Rule for MD011NoReversedLinks {
 mod tests {
     use super::*;
     use crate::lint_context::LintContext;
+    use crate::utils::skip_context::is_in_front_matter;
 
     #[test]
     fn test_capture_group_order_fix() {
@@ -453,6 +485,68 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_front_matter_detection() {
+        let content = r#"---
+title: "My Post"
+tags: ["test", "example"]
+description: "Pattern (like)[this] in frontmatter"
+---
+
+# Content
+
+Regular (https://example.com)[reversed link] that should be flagged.
+
++++
+title = "TOML frontmatter"
+tags = ["more", "tags"]
+pattern = "(toml)[pattern]"
++++
+
+# More Content
+
+Another (https://test.com)[reversed] link should be flagged."#;
+
+        // Test line by line
+        for (idx, line) in content.lines().enumerate() {
+            let line_num = idx; // 0-based
+            let in_fm = is_in_front_matter(content, line_num);
+
+            println!("Line {:2} (0-idx: {:2}): in_fm={:5} | {:?}", idx + 1, idx, in_fm, line);
+
+            // Lines 0-4 should be in YAML front matter
+            if idx <= 4 {
+                assert!(
+                    in_fm,
+                    "Line {} (0-idx: {}) should be in YAML front matter but got false. Content: {:?}",
+                    idx + 1,
+                    idx,
+                    line
+                );
+            }
+            // Lines 10-14 are NOT front matter (TOML block not at beginning)
+            else if (10..=14).contains(&idx) {
+                assert!(
+                    !in_fm,
+                    "Line {} (0-idx: {}) should NOT be in front matter (TOML block not at beginning). Content: {:?}",
+                    idx + 1,
+                    idx,
+                    line
+                );
+            }
+            // Everything else should NOT be in front matter
+            else {
+                assert!(
+                    !in_fm,
+                    "Line {} (0-idx: {}) should NOT be in front matter but got true. Content: {:?}",
+                    idx + 1,
+                    idx,
+                    line
+                );
+            }
+        }
+    }
+
     #[test]
     fn test_malformed_link_detection() {
         let rule = MD011NoReversedLinks;

{rumdl-0.0.115 → rumdl-0.0.117}/src/rules/md020_no_missing_space_closed_atx.rs

@@ -7,9 +7,10 @@ use lazy_static::lazy_static;
 use regex::Regex;
 
 lazy_static! {
-    static ref CLOSED_ATX_NO_SPACE_PATTERN: Regex = Regex::new(r"^(\s*)(#+)([^#\s].*?)([^#\s])(#+)\s*$").unwrap();
-    static ref CLOSED_ATX_NO_SPACE_START_PATTERN: Regex = Regex::new(r"^(\s*)(#+)([^#\s].*?)\s(#+)\s*$").unwrap();
-    static ref CLOSED_ATX_NO_SPACE_END_PATTERN: Regex = Regex::new(r"^(\s*)(#+)\s(.*?)([^#\s])(#+)\s*$").unwrap();
+    // Updated patterns to handle optional custom IDs like {#custom-id} after closing hashes
+    static ref CLOSED_ATX_NO_SPACE_PATTERN: Regex = Regex::new(r"^(\s*)(#+)([^#\s].*?)([^#\s])(#+)(\s*(?:\{#[^}]+\})?\s*)$").unwrap();
+    static ref CLOSED_ATX_NO_SPACE_START_PATTERN: Regex = Regex::new(r"^(\s*)(#+)([^#\s].*?)\s(#+)(\s*(?:\{#[^}]+\})?\s*)$").unwrap();
+    static ref CLOSED_ATX_NO_SPACE_END_PATTERN: Regex = Regex::new(r"^(\s*)(#+)\s(.*?)([^#\s])(#+)(\s*(?:\{#[^}]+\})?\s*)$").unwrap();
 }
 
 #[derive(Clone)]
@@ -39,20 +40,23 @@ impl MD020NoMissingSpaceClosedAtx {
             let content = &captures[3];
             let last_char = &captures[4];
             let closing_hashes = &captures[5];
-            format!("{indentation}{opening_hashes} {content}{last_char} {closing_hashes}")
+            let custom_id = &captures[6];
+            format!("{indentation}{opening_hashes} {content}{last_char} {closing_hashes}{custom_id}")
         } else if let Some(captures) = CLOSED_ATX_NO_SPACE_START_PATTERN.captures(line) {
             let indentation = &captures[1];
             let opening_hashes = &captures[2];
             let content = &captures[3];
             let closing_hashes = &captures[4];
-            format!("{indentation}{opening_hashes} {content} {closing_hashes}")
+            let custom_id = &captures[5];
+            format!("{indentation}{opening_hashes} {content} {closing_hashes}{custom_id}")
         } else if let Some(captures) = CLOSED_ATX_NO_SPACE_END_PATTERN.captures(line) {
             let indentation = &captures[1];
             let opening_hashes = &captures[2];
             let content = &captures[3];
             let last_char = &captures[4];
             let closing_hashes = &captures[5];
-            format!("{indentation}{opening_hashes} {content}{last_char} {closing_hashes}")
+            let custom_id = &captures[6];
+            format!("{indentation}{opening_hashes} {content}{last_char} {closing_hashes}{custom_id}")
         } else {
             line.to_string()
         }
@@ -79,11 +83,13 @@ impl Rule for MD020NoMissingSpaceClosedAtx {
                     continue;
                 }
 
-                // Only check closed ATX headings
-                if matches!(heading.style, crate::lint_context::HeadingStyle::ATX) && heading.has_closing_sequence {
+                // Check all ATX headings (both properly closed and malformed)
+                if matches!(heading.style, crate::lint_context::HeadingStyle::ATX) {
                     let line = &line_info.content;
 
                     // Check if line matches closed ATX pattern without space
+                    // This will detect both properly closed headings with missing space
+                    // and malformed attempts at closed headings like "# Heading#"
                     if self.is_closed_atx_heading_without_space(line) {
                         let line_index = LineIndex::new(ctx.content.to_string());
                         let line_range = line_index.line_content_range(line_num + 1);
@@ -162,9 +168,8 @@ impl Rule for MD020NoMissingSpaceClosedAtx {
                     continue;
                 }
 
-                // Fix closed ATX headings without space
+                // Fix ATX headings without space (both properly closed and malformed)
                 if matches!(heading.style, crate::lint_context::HeadingStyle::ATX)
-                    && heading.has_closing_sequence
                     && self.is_closed_atx_heading_without_space(&line_info.content)
                 {
                     lines.push(self.fix_closed_atx_heading(&line_info.content));

{rumdl-0.0.115 → rumdl-0.0.117}/src/rules/md026_no_trailing_punctuation/md026_config.rs

@@ -1,6 +1,11 @@
 use crate::rule_config_serde::RuleConfig;
 use serde::{Deserialize, Serialize};
 
+/// Default punctuation to check for MD026
+/// Matches markdownlint's default: ".,;:!。，；：！"
+/// We only include ASCII punctuation for now
+pub const DEFAULT_PUNCTUATION: &str = ".,;:!";
+
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct MD026Config {
     #[serde(default = "default_punctuation")]
@@ -16,7 +21,7 @@ impl Default for MD026Config {
 }
 
 fn default_punctuation() -> String {
-    ".,;".to_string()
+    DEFAULT_PUNCTUATION.to_string()
 }
 
 impl RuleConfig for MD026Config {