rumdl 0.0.117__tar.gz → 0.0.118__tar.gz

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

@@ -7,6 +7,8 @@ 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
@@ -335,7 +337,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.117...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

{rumdl-0.0.117 → 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",
@@ -1493,7 +1493,7 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "rumdl"
-version = "0.0.117"
+version = "0.0.118"
 dependencies = [
  "anyhow",
  "assert_cmd",

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

@@ -1,6 +1,6 @@
 [package]
 name = "rumdl"
-version = "0.0.117"
+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.117 → rumdl-0.0.118}/PKG-INFO

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

{rumdl-0.0.117 → 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.117 → rumdl-0.0.118}/tests/rules/md051_test.rs

@@ -1146,3 +1146,57 @@ fn test_performance_with_many_links() {
         ctx.links.len()
     );
 }
+
+#[test]
+fn test_custom_header_id_formats() {
+    // Test all supported custom header ID formats
+    let content = r#"# Kramdown Style {#kramdown-id}
+
+Some content here.
+
+## Python-markdown with spaces { #spaced-id }
+
+More content.
+
+### Python-markdown with colon {:#colon-id}
+
+Even more content.
+
+#### Python-markdown full format {: #full-format }
+
+Final content.
+
+Links to test all formats:
+- [Link to kramdown](#kramdown-id)
+- [Link to spaced](#spaced-id)
+- [Link to colon](#colon-id)
+- [Link to full format](#full-format)
+
+Links that should fail:
+- [Link to nonexistent](#nonexistent-id)
+"#;
+
+    let ctx = LintContext::new(content);
+    let rule = MD051LinkFragments::new();
+    let result = rule.check(&ctx).unwrap();
+
+    // Should only flag the nonexistent fragment
+    assert_eq!(result.len(), 1, "Expected 1 warning for nonexistent fragment");
+    assert!(
+        result[0].message.contains("nonexistent-id"),
+        "Warning should be about nonexistent fragment, got: {}",
+        result[0].message
+    );
+
+    // All valid custom ID formats should be recognized
+    for warning in &result {
+        assert!(
+            !warning.message.contains("kramdown-id")
+                && !warning.message.contains("spaced-id")
+                && !warning.message.contains("colon-id")
+                && !warning.message.contains("full-format"),
+            "Valid custom ID format should not be flagged as missing: {}",
+            warning.message
+        );
+    }
+}