rumdl 0.0.116__tar.gz → 0.0.118__tar.gz

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

@@ -7,6 +7,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.118] - 2025-08-14
+
+## [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
@@ -324,7 +337,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.116...HEAD
+[Unreleased]: https://github.com/rvben/rumdl/compare/v0.0.118...HEAD
+[0.0.118]: https://github.com/rvben/rumdl/compare/v0.0.117...v0.0.118
+[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

{rumdl-0.0.116 → rumdl-0.0.118}/Cargo.lock

@@ -121,9 +121,9 @@ dependencies = [
 
 [[package]]
 name = "async-trait"
-version = "0.1.88"
+version = "0.1.89"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e539d3fca749fcee5236ab05e93a52867dd549cc157c8cb7f99595f3cedffdb5"
+checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -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.116"
+version = "0.0.118"
 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.116 → rumdl-0.0.118}/Cargo.toml

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

{rumdl-0.0.116 → rumdl-0.0.118}/PKG-INFO

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

{rumdl-0.0.116 → rumdl-0.0.118}/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.116 → rumdl-0.0.118}/src/rules/md037_spaces_around_emphasis.rs

@@ -3,9 +3,12 @@
 /// See [docs/md037.md](../../docs/md037.md) for full documentation, configuration, and examples.
 use crate::rule::{Fix, LintError, LintResult, LintWarning, Rule, RuleCategory, Severity};
 use crate::utils::document_structure::{DocumentStructure, DocumentStructureExtensions};
-use crate::utils::emphasis_utils::{EmphasisSpan, find_emphasis_markers, find_emphasis_spans, has_doc_patterns};
+use crate::utils::emphasis_utils::{
+    EmphasisSpan, find_emphasis_markers, find_emphasis_spans, has_doc_patterns, replace_inline_code,
+};
 use crate::utils::kramdown_utils::has_span_ial;
 use crate::utils::regex_cache::UNORDERED_LIST_MARKER_REGEX;
+use crate::utils::skip_context::{is_in_html_comment, is_in_math_context, is_in_table_cell};
 use lazy_static::lazy_static;
 use regex::Regex;
 
@@ -116,7 +119,7 @@ impl Rule for MD037NoSpaceInEmphasis {
             self.check_line_for_emphasis_issues_fast(line, line_num + 1, &mut warnings);
         }
 
-        // Filter out warnings for emphasis markers that are inside links
+        // Filter out warnings for emphasis markers that are inside links, HTML comments, or math
         let mut filtered_warnings = Vec::new();
         let mut line_start_pos = 0;
 
@@ -129,8 +132,12 @@ impl Rule for MD037NoSpaceInEmphasis {
                     // 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) {
+                    // Skip if inside links, HTML comments, math contexts, or tables
+                    if !self.is_in_link(ctx, byte_pos)
+                        && !is_in_html_comment(content, byte_pos)
+                        && !is_in_math_context(ctx, byte_pos)
+                        && !is_in_table_cell(ctx, line_num, warning.column)
+                    {
                         filtered_warnings.push(warning.clone());
                     }
                 }
@@ -314,14 +321,17 @@ impl MD037NoSpaceInEmphasis {
         offset: usize,
         warnings: &mut Vec<LintWarning>,
     ) {
+        // Replace inline code to avoid false positives with emphasis markers inside backticks
+        let processed_content = replace_inline_code(content);
+
         // Find all emphasis markers using optimized parsing
-        let markers = find_emphasis_markers(content);
+        let markers = find_emphasis_markers(&processed_content);
         if markers.is_empty() {
             return;
         }
 
         // Find valid emphasis spans
-        let spans = find_emphasis_spans(content, markers);
+        let spans = find_emphasis_spans(&processed_content, markers);
 
         // Check each span for spacing issues
         for span in spans {
@@ -473,6 +483,21 @@ This has * real spaced emphasis * that should be flagged."#;
         assert!(result[0].line == 1);
     }
 
+    #[test]
+    fn test_issue_49_asterisk_in_inline_code() {
+        // Test for issue #49 - Asterisk within backticks identified as for emphasis
+        let rule = MD037NoSpaceInEmphasis;
+
+        // Test case from issue #49
+        let content = "The `__mul__` method is needed for left-hand multiplication (`vector * 3`) and `__rmul__` is needed for right-hand multiplication (`3 * vector`).";
+        let ctx = LintContext::new(content);
+        let result = rule.check(&ctx).unwrap();
+        assert!(
+            result.is_empty(),
+            "Should not flag asterisks inside inline code as emphasis (issue #49). Got: {result:?}"
+        );
+    }
+
     #[test]
     fn test_issue_28_inline_code_in_emphasis() {
         // Test for issue #28 - MD037 should not flag inline code inside emphasis as spaces

{rumdl-0.0.116 → rumdl-0.0.118}/src/rules/md052_reference_links_images.rs

@@ -1,7 +1,7 @@
 use crate::rule::{LintError, LintResult, LintWarning, Rule, Severity};
-use crate::rules::front_matter_utils::FrontMatterUtils;
 use crate::utils::range_utils::calculate_match_range;
 use crate::utils::regex_cache::HTML_COMMENT_PATTERN;
+use crate::utils::skip_context::{is_in_front_matter, is_in_math_context, is_in_table_cell};
 use fancy_regex::Regex as FancyRegex;
 use lazy_static::lazy_static;
 use regex::Regex;
@@ -19,9 +19,9 @@ lazy_static! {
     static ref REF_IMAGE_REGEX: FancyRegex = FancyRegex::new(r"(?<!\\)!\[((?:[^\[\]\\]|\\.|\[[^\]]*\])*)\]\[([^\]]*)\]").unwrap();
 
     // Pattern for shortcut reference links [reference]
-    // Must not be preceded by ] (to avoid matching second part of [text][ref])
+    // Must not be preceded by ] or ) (to avoid matching second part of [text][ref] or reversed links (url)[text])
     // Must not be followed by [ or ( (to avoid matching first part of [text][ref] or [text](url))
-    static ref SHORTCUT_REF_REGEX: FancyRegex = FancyRegex::new(r"(?<![\\])\[([^\]]+)\](?!\s*[\[\(])").unwrap();
+    static ref SHORTCUT_REF_REGEX: FancyRegex = FancyRegex::new(r"(?<![\\)\]])\[([^\]]+)\](?!\s*[\[\(])").unwrap();
 
     // Pattern to match inline links and images (to exclude them)
     static ref INLINE_LINK_REGEX: FancyRegex = FancyRegex::new(r"(?<!\\)\[([^\]]+)\]\(([^)]+)\)").unwrap();
@@ -73,6 +73,17 @@ impl MD052ReferenceLinkImages {
         false
     }
 
+    /// Check if a byte position is within an HTML tag
+    fn is_in_html_tag(ctx: &crate::lint_context::LintContext, byte_pos: usize) -> bool {
+        // Check HTML tags
+        for html_tag in ctx.html_tags().iter() {
+            if html_tag.byte_offset <= byte_pos && byte_pos < html_tag.byte_end {
+                return true;
+            }
+        }
+        false
+    }
+
     fn extract_references(&self, content: &str) -> HashSet<String> {
         let mut references = HashSet::new();
         let mut in_code_block = false;
@@ -141,8 +152,18 @@ impl MD052ReferenceLinkImages {
                 continue;
             }
 
+            // Skip links inside math contexts
+            if is_in_math_context(ctx, link.byte_offset) {
+                continue;
+            }
+
+            // Skip links inside table cells
+            if is_in_table_cell(ctx, link.line, link.start_col) {
+                continue;
+            }
+
             // Skip links inside frontmatter (convert from 1-based to 0-based line numbers)
-            if FrontMatterUtils::is_in_front_matter(content, link.line.saturating_sub(1)) {
+            if is_in_front_matter(content, link.line.saturating_sub(1)) {
                 continue;
             }
 
@@ -191,8 +212,18 @@ impl MD052ReferenceLinkImages {
                 continue;
             }
 
+            // Skip images inside math contexts
+            if is_in_math_context(ctx, image.byte_offset) {
+                continue;
+            }
+
+            // Skip images inside table cells
+            if is_in_table_cell(ctx, image.line, image.start_col) {
+                continue;
+            }
+
             // Skip images inside frontmatter (convert from 1-based to 0-based line numbers)
-            if FrontMatterUtils::is_in_front_matter(content, image.line.saturating_sub(1)) {
+            if is_in_front_matter(content, image.line.saturating_sub(1)) {
                 continue;
             }
 
@@ -248,7 +279,7 @@ impl MD052ReferenceLinkImages {
 
         for (line_num, line) in lines.iter().enumerate() {
             // Skip lines in frontmatter (line_num is already 0-based)
-            if FrontMatterUtils::is_in_front_matter(content, line_num) {
+            if is_in_front_matter(content, line_num) {
                 continue;
             }
 
@@ -316,6 +347,22 @@ impl MD052ReferenceLinkImages {
                             if Self::is_in_html_comment(content, byte_pos) {
                                 continue;
                             }
+
+                            // Skip if inside HTML tag
+                            if Self::is_in_html_tag(ctx, byte_pos) {
+                                continue;
+                            }
+
+                            // Skip if inside math context
+                            if is_in_math_context(ctx, byte_pos) {
+                                continue;
+                            }
+
+                            // Skip if inside table cell
+                            if is_in_table_cell(ctx, line_num + 1, col) {
+                                continue;
+                            }
+
                             let byte_end = byte_pos + (full_match.end() - full_match.start());
 
                             // Check if this shortcut ref overlaps with any parsed link/image
@@ -723,6 +770,29 @@ Multiple `[one]` and `[two]` in code ignored, but [three] is not.
         assert_eq!(result.len(), 0);
     }
 
+    #[test]
+    fn test_issue_51_html_attribute_not_reference() {
+        // Test for issue #51 - HTML attributes with square brackets shouldn't be treated as references
+        let rule = MD052ReferenceLinkImages::new();
+        let content = r#"# Example
+
+## Test
+
+Want to fill out this form?
+
+<form method="post">
+    <input type="email" name="fields[email]" id="drip-email" placeholder="email@domain.com">
+</form>"#;
+        let ctx = LintContext::new(content);
+        let result = rule.check(&ctx).unwrap();
+
+        assert_eq!(
+            result.len(),
+            0,
+            "HTML attributes with square brackets should not be flagged as undefined references"
+        );
+    }
+
     #[test]
     fn test_extract_references() {
         let rule = MD052ReferenceLinkImages::new();

{rumdl-0.0.116 → rumdl-0.0.118}/src/utils/emphasis_utils.rs

@@ -56,6 +56,7 @@ pub struct EmphasisSpan {
 }
 
 /// Enhanced inline code replacement with optimized performance
+/// Replaces inline code with 'X' characters to prevent false positives in emphasis detection
 #[inline]
 pub fn replace_inline_code(line: &str) -> String {
     // Quick check: if no backticks, return original
@@ -72,7 +73,8 @@ pub fn replace_inline_code(line: &str) -> String {
         {
             let match_start = full_match.start();
             let match_end = full_match.end();
-            let placeholder = " ".repeat(match_end - match_start);
+            // Use 'X' instead of spaces to avoid false positives for "spaces in emphasis"
+            let placeholder = "X".repeat(match_end - match_start);
 
             result.replace_range(match_start + offset..match_end + offset, &placeholder);
             offset += placeholder.len() - (match_end - match_start);

{rumdl-0.0.116 → rumdl-0.0.118}/src/utils/kramdown_utils.rs

@@ -10,10 +10,11 @@ lazy_static! {
     /// Pattern for Kramdown span IAL: text{:.class #id key="value"}
     static ref SPAN_IAL_PATTERN: Regex = Regex::new(r"\{[:\.#][^}]*\}$").unwrap();
 
-    /// Pattern for Kramdown header IDs: # Header {#custom-id}
+    /// Pattern for custom header IDs supporting both kramdown and python-markdown attr-list formats
+    /// Supports: {#id}, { #id }, {:#id}, {: #id } (all variations with optional colon and spaces)
     /// Permissive but safe: Unicode letters/numbers, hyphens, underscores, colons (Kramdown allows)
-    /// Rejects: spaces, quotes, brackets, HTML/CSS special chars
-    static ref HEADER_ID_PATTERN: Regex = Regex::new(r"\s*\{#[\w\-:]+\}\s*$").unwrap();
+    /// Rejects: spaces in ID, quotes, brackets, HTML/CSS special chars
+    static ref HEADER_ID_PATTERN: Regex = Regex::new(r"\s*\{\s*:?\s*#\s*[\w\-:]+\s*\}\s*$").unwrap();
 
     /// Pattern for Kramdown extensions opening: {::comment}, {::nomarkdown}, etc.
     static ref EXTENSION_OPEN_PATTERN: Regex = Regex::new(r"^\s*\{::([a-z]+)(?:\s+[^}]*)?\}\s*$").unwrap();
@@ -119,6 +120,12 @@ pub fn remove_header_id(line: &str) -> String {
 /// Extract custom header ID from a heading line
 /// Returns a tuple of (clean_text, Option<custom_id>)
 ///
+/// Supports both kramdown and python-markdown attr-list formats:
+/// - `{#custom-id}` (kramdown style)
+/// - `{ #custom-id }` (attr-list with spaces)
+/// - `{:#custom-id}` (attr-list with colon)
+/// - `{: #custom-id }` (attr-list with colon and spaces)
+///
 /// # Examples
 /// ```
 /// use rumdl::utils::kramdown_utils::extract_header_id;
@@ -127,6 +134,14 @@ pub fn remove_header_id(line: &str) -> String {
 /// assert_eq!(text, "## Header");
 /// assert_eq!(id, Some("custom-id".to_string()));
 ///
+/// let (text, id) = extract_header_id("## Header { #spaced-id }");
+/// assert_eq!(text, "## Header");
+/// assert_eq!(id, Some("spaced-id".to_string()));
+///
+/// let (text, id) = extract_header_id("## Header {: #colon-id }");
+/// assert_eq!(text, "## Header");
+/// assert_eq!(id, Some("colon-id".to_string()));
+///
 /// let (text, id) = extract_header_id("## Normal Header");
 /// assert_eq!(text, "## Normal Header");
 /// assert_eq!(id, None);
@@ -138,13 +153,21 @@ pub fn extract_header_id(line: &str) -> (String, Option<String>) {
         // Extract the clean text without the ID
         let clean_text = line[..id_match.start()].trim_end().to_string();
 
-        // Extract the ID from {#custom-id} format
+        // Extract the ID from various formats: {#id}, { #id }, {:#id}, {: #id }
         let id_str = id_match.as_str().trim();
-        let id = id_str
-            .trim_start_matches('{')
-            .trim_end_matches('}')
-            .trim_start_matches('#')
-            .to_string();
+
+        // Remove braces and extract content
+        let inner = id_str.trim_start_matches('{').trim_end_matches('}').trim();
+
+        // Handle optional colon and find the hash
+        let after_colon = if inner.starts_with(':') {
+            inner.trim_start_matches(':').trim()
+        } else {
+            inner
+        };
+
+        // Extract ID after hash
+        let id = after_colon.trim_start_matches('#').trim().to_string();
 
         return (clean_text, Some(id));
     }
@@ -286,4 +309,77 @@ mod tests {
         assert!(is_kramdown_block_attribute("\t{:#id}\t"));
         assert!(is_kramdown_block_attribute(" {:.class #id} "));
     }
+
+    #[test]
+    fn test_header_id_detection() {
+        // Kramdown style (original format)
+        assert!(has_header_id("# Header {#custom-id}"));
+        assert!(has_header_id("## Section {#section-1}"));
+
+        // Python-markdown attr-list with spaces
+        assert!(has_header_id("# Header { #spaced-id }"));
+        assert!(has_header_id("## Section { #section-with-spaces }"));
+
+        // Python-markdown attr-list with colon
+        assert!(has_header_id("# Header {:#colon-id}"));
+        assert!(has_header_id("## Section {: #colon-with-spaces }"));
+
+        // Combined colon and spaces
+        assert!(has_header_id("# Header {: #full-format }"));
+
+        // Should not match
+        assert!(!has_header_id("# Regular Header"));
+        assert!(!has_header_id("# Header { no hash }"));
+        assert!(!has_header_id("# Header {#}")); // Empty ID
+    }
+
+    #[test]
+    fn test_header_id_extraction() {
+        // Kramdown style (original format)
+        let (text, id) = extract_header_id("## Header {#test-id}");
+        assert_eq!(text, "## Header");
+        assert_eq!(id, Some("test-id".to_string()));
+
+        // Python-markdown attr-list with spaces
+        let (text, id) = extract_header_id("# Title { #spaced-id }");
+        assert_eq!(text, "# Title");
+        assert_eq!(id, Some("spaced-id".to_string()));
+
+        // Python-markdown attr-list with colon (no spaces)
+        let (text, id) = extract_header_id("### Subsection {:#compact-colon}");
+        assert_eq!(text, "### Subsection");
+        assert_eq!(id, Some("compact-colon".to_string()));
+
+        // Python-markdown attr-list with colon and spaces
+        let (text, id) = extract_header_id("#### Deep Section {: #colon-spaces }");
+        assert_eq!(text, "#### Deep Section");
+        assert_eq!(id, Some("colon-spaces".to_string()));
+
+        // No header ID
+        let (text, id) = extract_header_id("## Normal Header");
+        assert_eq!(text, "## Normal Header");
+        assert_eq!(id, None);
+
+        // Complex ID with allowed characters
+        let (text, id) = extract_header_id("# Header {#complex-id_with:colons}");
+        assert_eq!(text, "# Header");
+        assert_eq!(id, Some("complex-id_with:colons".to_string()));
+    }
+
+    #[test]
+    fn test_header_id_edge_cases() {
+        // Test that extra spaces are handled correctly
+        let (text, id) = extract_header_id("# Header {  :   #   extra-spaces   }");
+        assert_eq!(text, "# Header");
+        assert_eq!(id, Some("extra-spaces".to_string()));
+
+        // Test minimal format variations
+        let (text, id) = extract_header_id("# Header {#a}");
+        assert_eq!(text, "# Header");
+        assert_eq!(id, Some("a".to_string()));
+
+        let (text, id) = extract_header_id("# Header {:# b}");
+        assert_eq!(text, "# Header");
+        assert_eq!(id, Some("b".to_string()));
+    }
 }

{rumdl-0.0.116 → rumdl-0.0.118}/src/utils/mod.rs

@@ -13,6 +13,7 @@ pub mod kramdown_utils;
 pub mod markdown_elements;
 pub mod range_utils;
 pub mod regex_cache;
+pub mod skip_context;
 pub mod string_interner;
 pub mod table_utils;
 pub mod text_reflow;