rumdl 0.0.115__tar.gz → 0.0.116__tar.gz

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

@@ -7,6 +7,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [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 +324,8 @@ 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.116...HEAD
+[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.116}/Cargo.lock

@@ -1493,7 +1493,7 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "rumdl"
-version = "0.0.115"
+version = "0.0.116"
 dependencies = [
  "anyhow",
  "assert_cmd",

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

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

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

{rumdl-0.0.115 → rumdl-0.0.116}/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.116}/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.116}/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.116}/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 {

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

@@ -2,7 +2,6 @@
 ///
 /// See [docs/md026.md](../../docs/md026.md) for full documentation, configuration, and examples.
 use crate::rule::{Fix, LintError, LintResult, LintWarning, Rule, Severity};
-use crate::utils::kramdown_utils::has_header_id;
 use crate::utils::range_utils::calculate_match_range;
 use lazy_static::lazy_static;
 use regex::Regex;
@@ -11,14 +10,14 @@ use std::ops::Range;
 use std::sync::RwLock;
 
 mod md026_config;
-use md026_config::MD026Config;
+use md026_config::{DEFAULT_PUNCTUATION, MD026Config};
 
 lazy_static! {
     // Optimized single regex for all ATX heading types (normal, closed, indented 1-3 spaces)
     static ref ATX_HEADING_UNIFIED: Regex = Regex::new(r"^( {0,3})(#{1,6})(\s+)(.+?)(\s+#{1,6})?$").unwrap();
 
-    // Fast check patterns for early returns - more restrictive
-    static ref QUICK_PUNCTUATION_CHECK: Regex = Regex::new(r"[.,;]").unwrap();
+    // Fast check patterns for early returns - match defaults
+    static ref QUICK_PUNCTUATION_CHECK: Regex = Regex::new(&format!(r"[{}]", regex::escape(DEFAULT_PUNCTUATION))).unwrap();
 
     // Regex cache for punctuation patterns
     static ref PUNCTUATION_REGEX_CACHE: RwLock<HashMap<String, Regex>> = RwLock::new(HashMap::new());
@@ -34,7 +33,7 @@ impl MD026NoTrailingPunctuation {
     pub fn new(punctuation: Option<String>) -> Self {
         Self {
             config: MD026Config {
-                punctuation: punctuation.unwrap_or_else(|| ".,;".to_string()), // More restrictive by default
+                punctuation: punctuation.unwrap_or_else(|| DEFAULT_PUNCTUATION.to_string()),
             },
         }
     }
@@ -68,16 +67,6 @@ impl MD026NoTrailingPunctuation {
     #[inline]
     fn has_trailing_punctuation(&self, text: &str, re: &Regex) -> bool {
         let trimmed = text.trim();
-
-        // Only apply lenient rules for the default punctuation setting
-        // When users specify custom punctuation, they want strict behavior
-        if self.config.punctuation == ".,;" {
-            // Check for common legitimate punctuation patterns before applying the rule
-            if self.is_legitimate_punctuation(trimmed) {
-                return false;
-            }
-        }
-
         re.is_match(trimmed)
     }
 
@@ -102,85 +91,6 @@ impl MD026NoTrailingPunctuation {
         }
     }
 
-    /// Check if punctuation in a heading is legitimate and should be allowed
-    #[inline]
-    fn is_legitimate_punctuation(&self, text: &str) -> bool {
-        let text = text.trim();
-
-        // Allow question marks in question headings
-        if text.ends_with('?') {
-            // Check if it's likely a genuine question
-            let question_words = [
-                "what", "why", "how", "when", "where", "who", "which", "can", "should", "would", "could", "is", "are",
-                "do", "does", "did",
-            ];
-            let lower_text = text.to_lowercase();
-            if question_words.iter().any(|&word| lower_text.starts_with(word)) {
-                return true;
-            }
-        }
-
-        // Allow colons in common categorical/labeling patterns
-        if text.ends_with(':') {
-            // Common patterns that legitimately use colons
-            let colon_patterns = [
-                "faq",
-                "api",
-                "note",
-                "warning",
-                "error",
-                "info",
-                "tip",
-                "chapter",
-                "step",
-                "version",
-                "part",
-                "section",
-                "method",
-                "function",
-                "class",
-                "module",
-                "reference",
-                "guide",
-                "tutorial",
-                "example",
-                "demo",
-                "usage",
-                "syntax",
-            ];
-
-            let lower_text = text.to_lowercase();
-
-            // Check if it starts with any of these patterns
-            if colon_patterns.iter().any(|&pattern| lower_text.starts_with(pattern)) {
-                return true;
-            }
-
-            // Check for numbered items like "Step 1:", "Chapter 2:", "Version 1.0:"
-            if regex::Regex::new(r"^(step|chapter|part|section|version)\s*\d")
-                .unwrap()
-                .is_match(&lower_text)
-            {
-                return true;
-            }
-        }
-
-        // Allow exclamation marks in specific contexts (less common, but sometimes legitimate)
-        if text.ends_with('!') {
-            // Only allow for very specific patterns like "Important!", "New!", "Warning!"
-            let exclamation_patterns = ["important", "new", "warning", "alert", "notice", "attention"];
-            let lower_text = text.to_lowercase();
-            if exclamation_patterns
-                .iter()
-                .any(|&pattern| lower_text.starts_with(pattern))
-            {
-                return true;
-            }
-        }
-
-        false
-    }
-
     // Remove trailing punctuation from text
     #[inline]
     fn remove_trailing_punctuation(&self, text: &str, re: &Regex) -> String {
@@ -196,17 +106,18 @@ impl MD026NoTrailingPunctuation {
             let space = captures.get(3).unwrap().as_str();
             let content = captures.get(4).unwrap().as_str();
 
-            // If content has a valid Kramdown header ID, don't fix it
-            if has_header_id(content) {
-                // Return the line unchanged
-                if let Some(trailing) = captures.get(5) {
-                    return format!("{}{}{}{}{}", indentation, hashes, space, content, trailing.as_str());
-                }
-                return format!("{indentation}{hashes}{space}{content}");
-            }
-
-            // Otherwise, remove trailing punctuation
-            let fixed_content = self.remove_trailing_punctuation(content, re);
+            // Check if content ends with a custom header ID like {#my-id}
+            // If so, we need to fix punctuation before the ID
+            let fixed_content = if let Some(id_pos) = content.rfind(" {#") {
+                // Has a custom ID - fix punctuation before it
+                let before_id = &content[..id_pos];
+                let id_part = &content[id_pos..];
+                let fixed_before = self.remove_trailing_punctuation(before_id, re);
+                format!("{fixed_before}{id_part}")
+            } else {
+                // No custom ID - just remove trailing punctuation
+                self.remove_trailing_punctuation(content, re)
+            };
 
             // Preserve any trailing hashes if present
             if let Some(trailing) = captures.get(5) {
@@ -276,7 +187,7 @@ impl Rule for MD026NoTrailingPunctuation {
 
         // Quick check for any punctuation we care about
         // For custom punctuation, we need to check differently
-        if self.config.punctuation == ".,;" {
+        if self.config.punctuation == DEFAULT_PUNCTUATION {
             if !QUICK_PUNCTUATION_CHECK.is_match(content) {
                 return Ok(Vec::new());
             }
@@ -308,22 +219,10 @@ impl Rule for MD026NoTrailingPunctuation {
                     continue;
                 }
 
-                // For headers with potential Kramdown syntax, we need to be more careful
-                let text_to_check = if has_header_id(&heading.text) {
-                    // Valid Kramdown ID - skip this header entirely
-                    continue;
-                } else if heading.text.contains("{") && heading.text.trim().ends_with("}") {
-                    // Has curly braces but not a valid Kramdown ID
-                    // Check for punctuation before the opening brace
-                    if let Some(brace_pos) = heading.text.rfind('{') {
-                        heading.text[..brace_pos].trim().to_string()
-                    } else {
-                        heading.text.clone()
-                    }
-                } else {
-                    // Regular header without Kramdown syntax
-                    heading.text.clone()
-                };
+                // LintContext already strips Kramdown IDs from heading.text
+                // So we just check the heading text directly for trailing punctuation
+                // This correctly flags "# Heading." even if it has {#id}
+                let text_to_check = heading.text.clone();
 
                 if self.has_trailing_punctuation(&text_to_check, &re) {
                     // Find the trailing punctuation
@@ -379,7 +278,7 @@ impl Rule for MD026NoTrailingPunctuation {
 
         // Quick check for punctuation
         // For custom punctuation, we need to check differently
-        if self.config.punctuation == ".,;" {
+        if self.config.punctuation == DEFAULT_PUNCTUATION {
             if !QUICK_PUNCTUATION_CHECK.is_match(content) {
                 return Ok(content.to_string());
             }
@@ -413,22 +312,9 @@ impl Rule for MD026NoTrailingPunctuation {
                     continue;
                 }
 
-                // Handle headers with potential Kramdown syntax
-                let text_to_check = if has_header_id(&heading.text) {
-                    // Valid Kramdown ID - skip this header entirely
-                    continue;
-                } else if heading.text.contains("{") && heading.text.trim().ends_with("}") {
-                    // Has curly braces but not a valid Kramdown ID
-                    // Check for punctuation before the opening brace
-                    if let Some(brace_pos) = heading.text.rfind('{') {
-                        heading.text[..brace_pos].trim().to_string()
-                    } else {
-                        heading.text.clone()
-                    }
-                } else {
-                    // Regular header without Kramdown syntax
-                    heading.text.clone()
-                };
+                // LintContext already strips custom header IDs from heading.text
+                // So we just check the heading text directly for trailing punctuation
+                let text_to_check = heading.text.clone();
 
                 // Check and fix trailing punctuation
                 if self.has_trailing_punctuation(&text_to_check, &re) {
@@ -544,26 +430,24 @@ mod tests {
     }
 
     #[test]
-    fn test_default_legitimate_question() {
+    fn test_question_marks_not_in_default() {
         let rule = MD026NoTrailingPunctuation::new(None);
         let content = "# What is Rust?\n# How does it work?\n# Is it fast?";
         let ctx = LintContext::new(content);
         let result = rule.check(&ctx).unwrap();
-        assert!(
-            result.is_empty(),
-            "Question marks in questions should be allowed by default"
-        );
+        assert!(result.is_empty(), "Question marks are not in default punctuation list");
     }
 
     #[test]
-    fn test_legitimate_colons() {
+    fn test_colons_in_default() {
         let rule = MD026NoTrailingPunctuation::new(None);
         let content = "# FAQ:\n# API Reference:\n# Step 1:\n# Version 2.0:";
         let ctx = LintContext::new(content);
         let result = rule.check(&ctx).unwrap();
-        assert!(
-            result.is_empty(),
-            "Colons in categorical headings should be allowed by default"
+        assert_eq!(
+            result.len(),
+            4,
+            "Colons are in default punctuation list and should be flagged"
         );
     }
 

{rumdl-0.0.115 → rumdl-0.0.116}/src/rules/md034_no_bare_urls.rs

@@ -57,9 +57,6 @@ lazy_static! {
     // Updated to support IPv6 addresses
     static ref REFERENCE_DEF_RE: Regex = Regex::new(r"^\s*\[[^\]]+\]:\s*(?:https?|ftps?)://\S+$").unwrap();
 
-    // Pattern to match URLs inside HTML attributes (src, href, srcset, etc.)
-    static ref HTML_ATTRIBUTE_URL: Regex = Regex::new(r#"(?:src|href|srcset|content|data-\w+)\s*=\s*["']([^"']*)["']"#).unwrap();
-
     // Pattern to match HTML comments
     static ref HTML_COMMENT_PATTERN: Regex = Regex::new(r#"<!--[\s\S]*?-->"#).unwrap();
 }
@@ -114,14 +111,18 @@ impl MD034NoBareUrls {
         // First, find all markdown link ranges across the entire content
         let mut excluded_ranges: Vec<(usize, usize)> = Vec::new();
 
-        // Markdown links: [text](url) - handle multi-line
+        // Markdown links: [text](url) - exclude both destination and entire link text
         for cap in MARKDOWN_LINK_PATTERN.captures_iter(content) {
             if let Some(dest) = cap.get(1) {
                 excluded_ranges.push((dest.start(), dest.end()));
             }
+            // Also exclude the entire link to handle URLs in link text
+            if let Some(full_match) = cap.get(0) {
+                excluded_ranges.push((full_match.start(), full_match.end()));
+            }
         }
 
-        // Markdown images: ![alt](url) - handle multi-line
+        // Markdown images: ![alt](url)
         for cap in MARKDOWN_IMAGE_PATTERN.captures_iter(content) {
             if let Some(dest) = cap.get(2) {
                 excluded_ranges.push((dest.start(), dest.end()));
@@ -135,11 +136,9 @@ impl MD034NoBareUrls {
             }
         }
 
-        // HTML attribute URLs: src="url", href="url", etc.
-        for cap in HTML_ATTRIBUTE_URL.captures_iter(content) {
-            if let Some(url_attr) = cap.get(1) {
-                excluded_ranges.push((url_attr.start(), url_attr.end()));
-            }
+        // HTML tags: exclude everything inside them
+        for html_tag in ctx.html_tags().iter() {
+            excluded_ranges.push((html_tag.byte_offset, html_tag.byte_end));
         }
 
         // HTML comments: <!-- url -->