rumdl 0.0.110__tar.gz → 0.0.112__tar.gz

{rumdl-0.0.110 → rumdl-0.0.112}/CHANGELOG.md

@@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.112] - 2025-08-08
+
 ## [0.0.110] - 2025-08-08
 
 ## [0.0.110] - 2025-08-08
@@ -302,7 +304,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.110...HEAD
+[Unreleased]: https://github.com/rvben/rumdl/compare/v0.0.112...HEAD
+[0.0.112]: https://github.com/rvben/rumdl/compare/v0.0.111...v0.0.112
 [0.0.110]: https://github.com/rvben/rumdl/compare/v0.0.109...v0.0.110
 [0.0.110]: https://github.com/rvben/rumdl/compare/v0.0.109...v0.0.110
 [0.0.107]: https://github.com/rvben/rumdl/compare/v0.0.106...v0.0.107

{rumdl-0.0.110 → rumdl-0.0.112}/Cargo.lock

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

{rumdl-0.0.110 → rumdl-0.0.112}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rumdl"
-version = "0.0.110"
+version = "0.0.112"
 edition = "2024"
 rust-version = "1.88.0"
 description = "A fast Markdown linter written in Rust (Ru(st) MarkDown Linter)"
@@ -13,6 +13,8 @@ readme = "README.md"
 keywords = ["markdown", "linter", "markdown-linter", "static-analysis", "documentation"]
 categories = ["command-line-utilities", "development-tools", "text-processing"]
 exclude = [".github/", ".gitignore", "*.bak"]
+autobins = false  # Prevent automatic binary discovery in src/bin/
+default-run = "rumdl"  # Default binary for cargo run
 
 [lib]
 name = "rumdl"

{rumdl-0.0.110 → rumdl-0.0.112}/PKG-INFO

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

rumdl-0.0.112/scripts/generate-downloads-table.sh

@@ -0,0 +1,70 @@
+#!/bin/bash
+# Generate a markdown table for release downloads
+
+VERSION="${1:-}"
+if [ -z "$VERSION" ]; then
+    echo "Usage: $0 <version>"
+    echo "Example: $0 v0.0.111"
+    exit 1
+fi
+
+# Start the markdown table
+cat << 'EOF'
+## Downloads
+
+| File | Platform | Checksum |
+|------|----------|----------|
+EOF
+
+# Generate table rows for each platform
+generate_row() {
+    local target="$1"
+    local platform="$2"
+    
+    # Determine file extension based on platform
+    if [[ "$target" == *"windows"* ]]; then
+        ext="zip"
+    else
+        ext="tar.gz"
+    fi
+    
+    filename="rumdl-${VERSION}-${target}.${ext}"
+    checksum_file="${filename}.sha256"
+    
+    # Generate download URLs
+    download_url="https://github.com/rvben/rumdl/releases/download/${VERSION}/${filename}"
+    checksum_url="https://github.com/rvben/rumdl/releases/download/${VERSION}/${checksum_file}"
+    
+    # Output table row
+    echo "| [${filename}](${download_url}) | ${platform} | [checksum](${checksum_url}) |"
+}
+
+# Generate rows for each platform
+generate_row "x86_64-unknown-linux-gnu" "Linux x86_64" 
+generate_row "x86_64-unknown-linux-musl" "Linux x86_64 (musl)"
+generate_row "aarch64-unknown-linux-gnu" "Linux ARM64"
+generate_row "aarch64-unknown-linux-musl" "Linux ARM64 (musl)"
+generate_row "x86_64-apple-darwin" "macOS x86_64"
+generate_row "aarch64-apple-darwin" "macOS ARM64 (Apple Silicon)"
+generate_row "x86_64-pc-windows-msvc" "Windows x86_64"
+
+echo ""
+echo "## Installation"
+echo ""
+echo "### Using uv (Recommended)"
+echo '```bash'
+echo 'uv tool install rumdl'
+echo '```'
+echo ""
+echo "### Using pip"
+echo '```bash'
+echo 'pip install rumdl'
+echo '```'
+echo ""
+echo "### Using pipx"
+echo '```bash'
+echo 'pipx install rumdl'
+echo '```'
+echo ""
+echo "### Direct Download"
+echo "Download the appropriate binary for your platform from the table above, extract it, and add it to your PATH."

{rumdl-0.0.110 → rumdl-0.0.112}/src/lint_context.rs

@@ -906,6 +906,19 @@ impl<'a> LintContext<'a> {
         let content_lines: Vec<&str> = content.lines().collect();
         let mut lines = Vec::with_capacity(content_lines.len());
 
+        // Detect front matter boundaries FIRST, before any other parsing
+        let mut in_front_matter = false;
+        let mut front_matter_end = 0;
+        if content_lines.first().map(|l| l.trim()) == Some("---") {
+            in_front_matter = true;
+            for (idx, line) in content_lines.iter().enumerate().skip(1) {
+                if line.trim() == "---" {
+                    front_matter_end = idx;
+                    break;
+                }
+            }
+        }
+
         for (i, line) in content_lines.iter().enumerate() {
             let byte_offset = line_offsets.get(i).copied().unwrap_or(0);
             let indent = line.len() - line.trim_start().len();
@@ -933,8 +946,8 @@ impl<'a> LintContext<'a> {
                 byte_offset >= start && byte_offset < end && (is_multiline || is_fenced || is_indented)
             });
 
-            // Detect list items
-            let list_item = if !in_code_block && !is_blank {
+            // Detect list items (skip if in frontmatter)
+            let list_item = if !(in_code_block || is_blank || in_front_matter && i <= front_matter_end) {
                 // Strip blockquote prefix if present for list detection
                 let (line_for_list_check, blockquote_prefix_len) = if let Some(caps) = BLOCKQUOTE_REGEX.captures(line) {
                     let prefix = caps.get(1).unwrap().as_str();
@@ -1011,19 +1024,6 @@ impl<'a> LintContext<'a> {
             });
         }
 
-        // Detect front matter boundaries
-        let mut in_front_matter = false;
-        let mut front_matter_end = 0;
-        if content_lines.first().map(|l| l.trim()) == Some("---") {
-            in_front_matter = true;
-            for (idx, line) in content_lines.iter().enumerate().skip(1) {
-                if line.trim() == "---" {
-                    front_matter_end = idx;
-                    break;
-                }
-            }
-        }
-
         // Second pass: detect headings (including Setext which needs look-ahead) and blockquotes
         for i in 0..content_lines.len() {
             if lines[i].in_code_block {

{rumdl-0.0.110 → rumdl-0.0.112}/src/rules/md026_no_trailing_punctuation.rs

@@ -2,6 +2,7 @@
 ///
 /// 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;
@@ -195,6 +196,16 @@ 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);
 
             // Preserve any trailing hashes if present
@@ -297,10 +308,26 @@ impl Rule for MD026NoTrailingPunctuation {
                     continue;
                 }
 
-                // Check for trailing punctuation
-                if self.has_trailing_punctuation(&heading.text, &re) {
+                // 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()
+                };
+
+                if self.has_trailing_punctuation(&text_to_check, &re) {
                     // Find the trailing punctuation
-                    if let Some(punctuation_match) = re.find(&heading.text) {
+                    if let Some(punctuation_match) = re.find(&text_to_check) {
                         let line = &line_info.content;
 
                         // For ATX headings, find the punctuation position in the line
@@ -316,14 +343,14 @@ impl Rule for MD026NoTrailingPunctuation {
                             punctuation_len,
                         );
 
-                        let last_char = heading.text.chars().last().unwrap_or(' ');
+                        let last_char = text_to_check.chars().last().unwrap_or(' ');
                         warnings.push(LintWarning {
                             rule_name: Some(self.name()),
                             line: start_line,
                             column: start_col,
                             end_line,
                             end_column: end_col,
-                            message: format!("Heading '{}' ends with punctuation '{}'", heading.text, last_char),
+                            message: format!("Heading '{text_to_check}' ends with punctuation '{last_char}'"),
                             severity: Severity::Warning,
                             fix: Some(Fix {
                                 range: self.get_line_byte_range(content, line_num + 1),
@@ -386,8 +413,25 @@ 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()
+                };
+
                 // Check and fix trailing punctuation
-                if self.has_trailing_punctuation(&heading.text, &re) {
+                if self.has_trailing_punctuation(&text_to_check, &re) {
                     fixed_lines[line_num] = if matches!(heading.style, crate::lint_context::HeadingStyle::ATX) {
                         self.fix_atx_heading(&line_info.content, &re)
                     } else {

{rumdl-0.0.110 → rumdl-0.0.112}/src/rules/md031_blanks_around_fences.rs

@@ -4,6 +4,7 @@
 use crate::rule::{Fix, LintError, LintResult, LintWarning, Rule, RuleCategory, Severity};
 use crate::rule_config_serde::RuleConfig;
 use crate::utils::document_structure::{DocumentStructure, DocumentStructureExtensions};
+use crate::utils::kramdown_utils::is_kramdown_block_attribute;
 use crate::utils::range_utils::{LineIndex, calculate_line_range};
 use serde::{Deserialize, Serialize};
 
@@ -169,8 +170,10 @@ impl Rule for MD031BlanksAroundFences {
                             current_fence_marker = None;
 
                             // Check for blank line after closing fence
+                            // Allow Kramdown block attributes if configured
                             if i + 1 < lines.len()
                                 && !Self::is_empty_line(lines[i + 1])
+                                && !is_kramdown_block_attribute(lines[i + 1])
                                 && self.should_require_blank_line(i, &lines)
                             {
                                 let (start_line, start_col, end_line, end_col) = calculate_line_range(i + 1, lines[i]);
@@ -277,8 +280,10 @@ impl Rule for MD031BlanksAroundFences {
                             current_fence_marker = None;
 
                             // Add blank line after closing fence if needed
+                            // Don't add if next line is a Kramdown block attribute
                             if i + 1 < lines.len()
                                 && !Self::is_empty_line(lines[i + 1])
+                                && !is_kramdown_block_attribute(lines[i + 1])
                                 && self.should_require_blank_line(i, &lines)
                             {
                                 result.push(String::new());

{rumdl-0.0.110 → rumdl-0.0.112}/src/rules/md033_no_inline_html.rs

@@ -5,6 +5,7 @@
 
 use crate::rule::{LintError, LintResult, LintWarning, Rule, RuleCategory, Severity};
 use crate::utils::document_structure::{DocumentStructure, DocumentStructureExtensions};
+use crate::utils::kramdown_utils::{is_kramdown_block_attribute, is_kramdown_extension};
 use crate::utils::range_utils::calculate_html_tag_range;
 use crate::utils::regex_cache::*;
 use lazy_static::lazy_static;
@@ -157,7 +158,13 @@ impl MD033NoInlineHtml {
     }
 
     /// Find HTML tags that span multiple lines
-    fn find_multiline_html_tags(&self, content: &str, structure: &DocumentStructure, warnings: &mut Vec<LintWarning>) {
+    fn find_multiline_html_tags(
+        &self,
+        content: &str,
+        structure: &DocumentStructure,
+        nomarkdown_ranges: &[(usize, usize)],
+        warnings: &mut Vec<LintWarning>,
+    ) {
         // Early return: if content has no incomplete tags at line ends, skip processing
         if !content.contains('<') || !content.lines().any(|line| line.trim_end().ends_with('<')) {
             return;
@@ -178,6 +185,14 @@ impl MD033NoInlineHtml {
                 continue;
             }
 
+            // Skip lines inside nomarkdown blocks
+            if nomarkdown_ranges
+                .iter()
+                .any(|(start, end)| line_num >= *start && line_num <= *end)
+            {
+                continue;
+            }
+
             // Early return: skip lines that don't end with incomplete tags
             if !line.contains('<') {
                 continue;
@@ -288,7 +303,37 @@ impl Rule for MD033NoInlineHtml {
         let mut warnings = Vec::new();
         let lines: Vec<&str> = content.lines().collect();
 
-        // First pass: find single-line HTML tags
+        // Track nomarkdown and comment blocks
+        let mut in_nomarkdown = false;
+        let mut in_comment = false;
+        let mut nomarkdown_ranges: Vec<(usize, usize)> = Vec::new();
+        let mut nomarkdown_start = 0;
+        let mut comment_start = 0;
+
+        // First pass: identify nomarkdown and comment blocks
+        for (i, line) in lines.iter().enumerate() {
+            let line_num = i + 1;
+
+            // Check for nomarkdown start
+            if line.trim() == "{::nomarkdown}" {
+                in_nomarkdown = true;
+                nomarkdown_start = line_num;
+            } else if line.trim() == "{:/nomarkdown}" && in_nomarkdown {
+                in_nomarkdown = false;
+                nomarkdown_ranges.push((nomarkdown_start, line_num));
+            }
+
+            // Check for comment blocks
+            if line.trim() == "{::comment}" {
+                in_comment = true;
+                comment_start = line_num;
+            } else if line.trim() == "{:/comment}" && in_comment {
+                in_comment = false;
+                nomarkdown_ranges.push((comment_start, line_num));
+            }
+        }
+
+        // Second pass: find single-line HTML tags
         // To match markdownlint behavior, report one warning per HTML tag
         for (i, line) in lines.iter().enumerate() {
             let line_num = i + 1;
@@ -305,6 +350,19 @@ impl Rule for MD033NoInlineHtml {
                 continue;
             }
 
+            // Skip lines inside nomarkdown blocks
+            if nomarkdown_ranges
+                .iter()
+                .any(|(start, end)| line_num >= *start && line_num <= *end)
+            {
+                continue;
+            }
+
+            // Skip Kramdown extensions and block attributes
+            if is_kramdown_extension(line) || is_kramdown_block_attribute(line) {
+                continue;
+            }
+
             // Find all HTML tags in the line using regex
             for tag_match in HTML_TAG_FINDER.find_iter(line) {
                 let tag = tag_match.as_str();
@@ -356,8 +414,8 @@ impl Rule for MD033NoInlineHtml {
             }
         }
 
-        // Second pass: find multi-line HTML tags
-        self.find_multiline_html_tags(ctx.content, structure, &mut warnings);
+        // Third pass: find multi-line HTML tags
+        self.find_multiline_html_tags(ctx.content, structure, &nomarkdown_ranges, &mut warnings);
 
         Ok(warnings)
     }

{rumdl-0.0.110 → rumdl-0.0.112}/src/rules/md037_spaces_around_emphasis.rs

@@ -4,6 +4,7 @@
 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::kramdown_utils::has_span_ial;
 use crate::utils::regex_cache::UNORDERED_LIST_MARKER_REGEX;
 use lazy_static::lazy_static;
 use regex::Regex;
@@ -330,6 +331,16 @@ impl MD037NoSpaceInEmphasis {
                 let full_end = span.closing.end_pos();
                 let full_text = &content[full_start..full_end];
 
+                // Skip if this emphasis has a Kramdown span IAL immediately after it
+                // (no space between emphasis and IAL)
+                if full_end < content.len() {
+                    let remaining = &content[full_end..];
+                    // Check if IAL starts immediately after the emphasis (no whitespace)
+                    if remaining.starts_with('{') && has_span_ial(remaining.split_whitespace().next().unwrap_or("")) {
+                        continue;
+                    }
+                }
+
                 // Create the marker string efficiently
                 let marker_char = span.opening.as_char();
                 let marker_str = if span.opening.count == 1 {

{rumdl-0.0.110 → rumdl-0.0.112}/src/rules/md058_blanks_around_tables.rs

@@ -1,5 +1,6 @@
 use crate::rule::{Fix, LintError, LintResult, LintWarning, Rule, Severity};
 use crate::rule_config_serde::RuleConfig;
+use crate::utils::kramdown_utils::is_kramdown_block_attribute;
 use crate::utils::range_utils::LineIndex;
 use crate::utils::table_utils::TableUtils;
 use serde::{Deserialize, Serialize};
@@ -149,31 +150,41 @@ impl Rule for MD058BlanksAroundTables {
 
             // Check for sufficient blank lines after table
             if table_block.end_line < lines.len() - 1 {
-                let blank_lines_after = self.count_blank_lines_after(&lines, table_block.end_line);
-                if blank_lines_after < self.config.minimum_after {
-                    let needed = self.config.minimum_after - blank_lines_after;
-                    let message = if self.config.minimum_after == 1 {
-                        "Missing blank line after table".to_string()
-                    } else {
-                        format!("Missing {needed} blank lines after table")
-                    };
+                // Check if the next line is a Kramdown block attribute
+                let next_line_is_attribute = if table_block.end_line + 1 < lines.len() {
+                    is_kramdown_block_attribute(lines[table_block.end_line + 1])
+                } else {
+                    false
+                };
 
-                    warnings.push(LintWarning {
-                        rule_name: Some(self.name()),
-                        message,
-                        line: table_block.end_line + 1,
-                        column: lines[table_block.end_line].len() + 1,
-                        end_line: table_block.end_line + 1,
-                        end_column: lines[table_block.end_line].len() + 2,
-                        severity: Severity::Warning,
-                        fix: Some(Fix {
-                            range: _line_index.line_col_to_byte_range(
-                                table_block.end_line + 1,
-                                lines[table_block.end_line].len() + 1,
-                            ),
-                            replacement: format!("{}{}", lines[table_block.end_line], "\n".repeat(needed)),
-                        }),
-                    });
+                // Skip check if next line is a block attribute
+                if !next_line_is_attribute {
+                    let blank_lines_after = self.count_blank_lines_after(&lines, table_block.end_line);
+                    if blank_lines_after < self.config.minimum_after {
+                        let needed = self.config.minimum_after - blank_lines_after;
+                        let message = if self.config.minimum_after == 1 {
+                            "Missing blank line after table".to_string()
+                        } else {
+                            format!("Missing {needed} blank lines after table")
+                        };
+
+                        warnings.push(LintWarning {
+                            rule_name: Some(self.name()),
+                            message,
+                            line: table_block.end_line + 1,
+                            column: lines[table_block.end_line].len() + 1,
+                            end_line: table_block.end_line + 1,
+                            end_column: lines[table_block.end_line].len() + 2,
+                            severity: Severity::Warning,
+                            fix: Some(Fix {
+                                range: _line_index.line_col_to_byte_range(
+                                    table_block.end_line + 1,
+                                    lines[table_block.end_line].len() + 1,
+                                ),
+                                replacement: format!("{}{}", lines[table_block.end_line], "\n".repeat(needed)),
+                            }),
+                        });
+                    }
                 }
             }
         }