rumdl 0.0.128__tar.gz → 0.0.130__tar.gz

{rumdl-0.0.128 → rumdl-0.0.130}/CHANGELOG.md

@@ -7,8 +7,35 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.130] - 2025-08-27
+
+### Fixed
+- **MD052**: Fixed false positives with IPv6 URLs containing brackets (e.g., `http://[::1]:8080/path[0]`)
+- **MD053**: Made rule warning-only, removed automatic fixes to prevent accidental removal of intentionally kept references (fixes #69)
+- **MD009/MD028**: Resolved formatting loop between trailing spaces and blank blockquote lines
+- **MD002/MD041**: Fixed interaction where MD002 incorrectly flagged documents starting with level-1 heading
+- **MD011**: Prevented false positives with math-like expressions (e.g., `[0,1]`) outside code blocks
+- **MD034**: Improved bare URL detection to avoid false positives with bracketed paths in URLs
+
+## [0.0.129] - 2025-08-26
+
+### Added
+- **MkDocs Extended Support**: Enhanced MkDocs compatibility with PyMdown Extensions
+  - Snippets syntax (`--8<--`) support (fixes #62)
+  - Admonitions (`!!!`, `???`, `???+`) for collapsible note blocks
+  - Tabs (`=== "Tab Name"`) for content organization
+  - Footnotes (`[^ref]`) for reference-style citations
+  - Cross-references and auto-doc blocks
+
+### Fixed
+- **MkDocs Validation**: Made validation more lenient to detect malformed syntax
+- **Configuration Migration**: Fixed migration of multiple disabled rules from markdownlint config
+
 ## [0.0.128] - 2025-08-25
 
+### Fixed
+- **MD042/MD052**: Added support for simple identifiers in MkDocs auto-references
+
 ## [0.0.127] - 2025-08-25
 
 ### Added
@@ -481,7 +508,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.128...HEAD
+[Unreleased]: https://github.com/rvben/rumdl/compare/v0.0.130...HEAD
+[0.0.130]: https://github.com/rvben/rumdl/compare/v0.0.129...v0.0.130
+[0.0.129]: https://github.com/rvben/rumdl/compare/v0.0.128...v0.0.129
 [0.0.128]: https://github.com/rvben/rumdl/compare/v0.0.127...v0.0.128
 [0.0.127]: https://github.com/rvben/rumdl/compare/v0.0.126...v0.0.127
 [0.0.126]: https://github.com/rvben/rumdl/compare/v0.0.125...v0.0.126

{rumdl-0.0.128 → rumdl-0.0.130}/Cargo.lock

@@ -277,9 +277,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.45"
+version = "4.5.46"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fc0e74a703892159f5ae7d3aac52c8e6c392f5ae5f359c70b5881d60aaac318"
+checksum = "2c5e4fcf9c21d2e544ca1ee9d8552de13019a42aa7dbf32747fa7aaf1df76e57"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -287,9 +287,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.44"
+version = "4.5.46"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b3e7f4214277f3c7aa526a59dd3fbe306a370daee1f8b7b8c987069cd8e888a8"
+checksum = "fecb53a0e6fcfb055f686001bc2e2592fa527efaf38dbe81a6a9563562e57d41"
 dependencies = [
  "anstream",
  "anstyle",
@@ -1605,7 +1605,7 @@ checksum = "caf4aa5b0f434c91fe5c7f1ecb6a5ece2130b02ad2a590589dda5146df959001"
 
 [[package]]
 name = "rumdl"
-version = "0.0.128"
+version = "0.0.130"
 dependencies = [
  "anyhow",
  "assert_cmd",

{rumdl-0.0.128 → rumdl-0.0.130}/Cargo.toml

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

{rumdl-0.0.128 → rumdl-0.0.130}/PKG-INFO

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

{rumdl-0.0.128 → rumdl-0.0.130}/src/lint_context.rs

@@ -390,11 +390,11 @@ impl<'a> LintContext<'a> {
         let code_blocks = CodeBlockUtils::detect_code_blocks(content);
 
         // Pre-compute line information
-        let lines = Self::compute_line_info(content, &line_offsets, &code_blocks);
+        let lines = Self::compute_line_info(content, &line_offsets, &code_blocks, flavor);
 
         // Parse links, images, references, and list blocks
         // Skip code spans - they'll be computed lazily
-        let links = Self::parse_links(content, &lines, &code_blocks);
+        let links = Self::parse_links(content, &lines, &code_blocks, flavor);
         let images = Self::parse_images(content, &lines, &code_blocks);
         let reference_defs = Self::parse_reference_defs(content, &lines);
         let list_blocks = Self::parse_list_blocks(&lines);
@@ -671,7 +671,14 @@ impl<'a> LintContext<'a> {
     }
 
     /// Parse all links in the content
-    fn parse_links(content: &str, lines: &[LineInfo], code_blocks: &[(usize, usize)]) -> Vec<ParsedLink> {
+    fn parse_links(
+        content: &str,
+        lines: &[LineInfo],
+        code_blocks: &[(usize, usize)],
+        flavor: MarkdownFlavor,
+    ) -> Vec<ParsedLink> {
+        use crate::utils::skip_context::is_mkdocs_snippet_line;
+
         // Pre-size based on a heuristic: most markdown files have relatively few links
         let mut links = Vec::with_capacity(content.len() / 500); // ~1 link per 500 chars
 
@@ -696,6 +703,19 @@ impl<'a> LintContext<'a> {
                 continue;
             }
 
+            // Skip if this link is on a MkDocs snippet line
+            // Find which line this link is on
+            let line_idx = lines
+                .iter()
+                .position(|line| {
+                    match_start >= line.byte_offset && (match_start < line.byte_offset + line.content.len() + 1)
+                })
+                .unwrap_or(0);
+
+            if is_mkdocs_snippet_line(&lines[line_idx].content, flavor) {
+                continue;
+            }
+
             // Find which line this link starts on
             let mut line_num = 1;
             let mut col_start = match_start;
@@ -895,7 +915,12 @@ impl<'a> LintContext<'a> {
     }
 
     /// Pre-compute line information
-    fn compute_line_info(content: &str, line_offsets: &[usize], code_blocks: &[(usize, usize)]) -> Vec<LineInfo> {
+    fn compute_line_info(
+        content: &str,
+        line_offsets: &[usize],
+        code_blocks: &[(usize, usize)],
+        flavor: MarkdownFlavor,
+    ) -> Vec<LineInfo> {
         lazy_static! {
             // Regex for list detection - allow any whitespace including no space (to catch malformed lists)
             static ref UNORDERED_REGEX: regex::Regex = regex::Regex::new(r"^(\s*)([-*+])([ \t]*)(.*)").unwrap();
@@ -1065,8 +1090,10 @@ impl<'a> LintContext<'a> {
                 // Consider tabs as multiple spaces, or actual multiple spaces
                 let has_multiple_spaces = spaces_after.len() > 1 || spaces_after.contains('\t');
 
-                // Check if needs MD028 fix (empty blockquote without proper spacing)
-                let needs_md028_fix = content.trim().is_empty() && spaces_after.is_empty();
+                // Check if needs MD028 fix (empty blockquote line without proper spacing)
+                // MD028 flags empty blockquote lines that don't have a single space after the marker
+                // Lines like "> " or ">> " are already correct and don't need fixing
+                let needs_md028_fix = content.is_empty() && spaces_after.is_empty();
 
                 lines[i].blockquote = Some(BlockquoteInfo {
                     nesting_level,
@@ -1085,8 +1112,16 @@ impl<'a> LintContext<'a> {
                 continue;
             }
 
-            // Check for ATX headings
-            if let Some(caps) = ATX_HEADING_REGEX.captures(line) {
+            // Check for ATX headings (but skip MkDocs snippet lines)
+            // In MkDocs flavor, lines like "# -8<- [start:name]" are snippet markers, not headings
+            let is_snippet_line = if flavor == MarkdownFlavor::MkDocs {
+                crate::utils::mkdocs_snippets::is_snippet_section_start(line)
+                    || crate::utils::mkdocs_snippets::is_snippet_section_end(line)
+            } else {
+                false
+            };
+
+            if !is_snippet_line && let Some(caps) = ATX_HEADING_REGEX.captures(line) {
                 let leading_spaces = caps.get(1).map_or("", |m| m.as_str());
                 let hashes = caps.get(2).map_or("", |m| m.as_str());
                 let spaces_after = caps.get(3).map_or("", |m| m.as_str());

{rumdl-0.0.128 → rumdl-0.0.130}/src/markdownlint_config.rs

@@ -191,6 +191,11 @@ impl MarkdownlintConfig {
     ) -> crate::config::SourcedConfigFragment {
         let mut fragment = crate::config::SourcedConfigFragment::default();
         let file = file_path.map(|s| s.to_string());
+
+        // Accumulate disabled and enabled rules
+        let mut disabled_rules = Vec::new();
+        let mut enabled_rules = Vec::new();
+
         for (key, value) in &self.0 {
             // Special handling for line-length as a global setting
             if key.eq_ignore_ascii_case("line-length") || key.eq_ignore_ascii_case("line_length") {
@@ -211,21 +216,11 @@ impl MarkdownlintConfig {
                 // Special handling for boolean values (true/false)
                 if value.is_bool() {
                     if !value.as_bool().unwrap_or(false) {
-                        // Add to global.disable
-                        fragment.global.disable.push_override(
-                            vec![norm_rule_key.clone()],
-                            crate::config::ConfigSource::Markdownlint,
-                            file.clone(),
-                            None,
-                        );
+                        // Accumulate disabled rules
+                        disabled_rules.push(norm_rule_key.clone());
                     } else {
-                        // Add to global.enable (if true)
-                        fragment.global.enable.push_override(
-                            vec![norm_rule_key.clone()],
-                            crate::config::ConfigSource::Markdownlint,
-                            file.clone(),
-                            None,
-                        );
+                        // Accumulate enabled rules
+                        enabled_rules.push(norm_rule_key.clone());
                     }
                     continue;
                 }
@@ -269,6 +264,27 @@ impl MarkdownlintConfig {
                 }
             }
         }
+
+        // Set all disabled rules at once
+        if !disabled_rules.is_empty() {
+            fragment.global.disable.push_override(
+                disabled_rules,
+                crate::config::ConfigSource::Markdownlint,
+                file.clone(),
+                None,
+            );
+        }
+
+        // Set all enabled rules at once
+        if !enabled_rules.is_empty() {
+            fragment.global.enable.push_override(
+                enabled_rules,
+                crate::config::ConfigSource::Markdownlint,
+                file.clone(),
+                None,
+            );
+        }
+
         if let Some(_f) = file {
             // SourcedConfigFragment does not have loaded_files, so skip
         }

{rumdl-0.0.128 → rumdl-0.0.130}/src/rules/md009_trailing_spaces.rs

@@ -28,11 +28,6 @@ impl MD009TrailingSpaces {
         Self { config }
     }
 
-    fn is_empty_blockquote_line(line: &str) -> bool {
-        let trimmed = line.trim_start();
-        trimmed.starts_with('>') && trimmed.trim_end() == ">"
-    }
-
     fn count_trailing_spaces(line: &str) -> usize {
         line.chars().rev().take_while(|&c| c == ' ').count()
     }
@@ -88,6 +83,17 @@ impl Rule for MD009TrailingSpaces {
                         continue;
                     }
 
+                    // Check if this is an empty blockquote line (like "> " or ">> ")
+                    // These are allowed to have a single trailing space by MD028
+                    let trimmed_line = line.trim_end();
+                    if trimmed_line.chars().all(|c| c == '>' || c == ' ' || c == '\t')
+                        && trimmed_line.contains('>')
+                        && trailing_spaces == 1
+                    {
+                        // This is an empty blockquote line with single trailing space - allowed
+                        continue;
+                    }
+
                     // Calculate precise character range for all trailing spaces on empty line
                     let (start_line, start_col, end_line, end_col) = calculate_trailing_range(line_num + 1, line, 0);
 
@@ -126,34 +132,16 @@ impl Rule for MD009TrailingSpaces {
                 continue;
             }
 
-            // Special handling for empty blockquote lines
-            if Self::is_empty_blockquote_line(line) {
-                let trimmed = line.trim_end();
-                // Calculate precise character range for trailing spaces after blockquote marker
-                let (start_line, start_col, end_line, end_col) =
-                    calculate_trailing_range(line_num + 1, line, trimmed.len());
-
-                warnings.push(LintWarning {
-                    rule_name: Some(self.name()),
-                    line: start_line,
-                    column: start_col,
-                    end_line,
-                    end_column: end_col,
-                    message: "Empty blockquote line needs a space after >".to_string(),
-                    severity: Severity::Warning,
-                    fix: Some(Fix {
-                        range: _line_index.line_col_to_byte_range_with_length(
-                            line_num + 1,
-                            trimmed.len() + 1,
-                            line.len() - trimmed.len(),
-                        ),
-                        replacement: " ".to_string(),
-                    }),
-                });
-                continue;
-            }
-
+            // Check if this is an empty blockquote line ("> " or ">> " etc)
+            // These are allowed by MD028 to have a single trailing space
             let trimmed = line.trim_end();
+            let is_empty_blockquote_with_space = trimmed.chars().all(|c| c == '>' || c == ' ' || c == '\t')
+                && trimmed.contains('>')
+                && trailing_spaces == 1;
+
+            if is_empty_blockquote_with_space {
+                continue; // Allow single trailing space for empty blockquote lines
+            }
             // Calculate precise character range for all trailing spaces
             let (start_line, start_col, end_line, end_col) =
                 calculate_trailing_range(line_num + 1, line, trimmed.len());
@@ -222,7 +210,7 @@ impl Rule for MD009TrailingSpaces {
                 if self.config.list_item_empty_lines && Self::is_empty_list_item_line(line, prev_line) {
                     result.push_str(line);
                 } else {
-                    // Remove all trailing spaces
+                    // Remove all trailing spaces - line is empty so don't add anything
                 }
                 result.push('\n');
                 continue;
@@ -237,13 +225,7 @@ impl Rule for MD009TrailingSpaces {
                 continue;
             }
 
-            // Special handling for empty blockquote lines
-            if Self::is_empty_blockquote_line(line) {
-                result.push_str(trimmed);
-                result.push(' '); // Add a space after the blockquote marker
-                result.push('\n');
-                continue;
-            }
+            // No special handling for empty blockquote lines - treat them like regular lines
 
             // Handle lines with trailing spaces
             let is_truly_last_line = i == lines.len() - 1 && !content.ends_with('\n');
@@ -258,9 +240,17 @@ impl Rule for MD009TrailingSpaces {
                 trimmed.starts_with('#')
             };
 
+            // Check if this is an empty blockquote line (just ">")
+            let is_empty_blockquote = if let Some(line_info) = ctx.line_info(i + 1) {
+                line_info.blockquote.as_ref().is_some_and(|bq| bq.content.is_empty())
+            } else {
+                false
+            };
+
             // In non-strict mode, preserve line breaks by normalizing to br_spaces
-            // BUT: Never preserve trailing spaces in headings as they serve no purpose
-            if !self.config.strict && !is_truly_last_line && trailing_spaces > 0 && !is_heading {
+            // BUT: Never preserve trailing spaces in headings or empty blockquotes as they serve no purpose
+            if !self.config.strict && !is_truly_last_line && trailing_spaces > 0 && !is_heading && !is_empty_blockquote
+            {
                 // Optimize for common case of 2 spaces
                 match self.config.br_spaces {
                     0 => {}
@@ -425,10 +415,10 @@ mod tests {
         let result = rule.check(&ctx).unwrap();
         assert_eq!(result.len(), 1);
         assert_eq!(result[0].line, 2);
-        assert_eq!(result[0].message, "Empty blockquote line needs a space after >");
+        assert_eq!(result[0].message, "3 trailing spaces found");
 
         let fixed = rule.fix(&ctx).unwrap();
-        assert_eq!(fixed, "> Quote\n> \n> More quote");
+        assert_eq!(fixed, "> Quote\n>\n> More quote"); // All trailing spaces removed
     }
 
     #[test]

{rumdl-0.0.128 → rumdl-0.0.130}/src/rules/md011_no_reversed_links.rs

@@ -19,6 +19,16 @@ lazy_static! {
     // Pattern to detect escaped brackets and parentheses
     static ref ESCAPED_CHARS: Regex = Regex::new(r"\\[\[\]()]").unwrap();
 
+    // Pattern to detect mathematical context indicators
+    static ref MATH_CONTEXT: Regex = Regex::new(
+        r"(?:f|g|h|sin|cos|tan|log|ln|exp|matrix|vector|det|lim|sum|prod|int)\s*\([^)]+\)|[∈∉⊆⊂⊃⊇∩∪∧∨¬∀∃∅∞∫∑∏√±×÷≠≤≥≈≡]|\b(?:where|such that|for all|exists|if and only if)\b"
+    ).unwrap();
+
+    // Pattern to detect function/array notation that shouldn't be flagged
+    static ref FUNCTION_ARRAY_NOTATION: Regex = Regex::new(
+        r"(?:[a-zA-Z_]\w*\([^)]*\)\[[^\]]+\])|(?:\([^)]+\)\[(?:element|index|derivative|integral|component|row|column|entry|coefficient|term)\])"
+    ).unwrap();
+
     // New patterns for detecting malformed link attempts where user intent is clear
     static ref MALFORMED_LINK_PATTERNS: Vec<(Regex, &'static str)> = vec![
         // Missing closing bracket: (URL)[text  or  [text](URL
@@ -77,11 +87,45 @@ impl MD011NoReversedLinks {
                 continue;
             }
 
+            // Skip if line contains mathematical context
+            if MATH_CONTEXT.is_match(line) {
+                line_start += line.len() + 1;
+                current_line += 1;
+                continue;
+            }
+
+            // Skip if line contains function/array notation
+            if FUNCTION_ARRAY_NOTATION.is_match(line) {
+                line_start += line.len() + 1;
+                current_line += 1;
+                continue;
+            }
+
             for cap in REVERSED_LINK_CHECK_REGEX.captures_iter(line) {
                 // Extract URL and text
                 let url = &cap[1];
                 let text = &cap[2];
 
+                // Additional check: Skip if this looks like mathematical notation
+                // e.g., (0,1)[inclusive], (a,b)[intersection]
+                if text.len() < 20
+                    && (text.contains("inclusive")
+                        || text.contains("exclusive")
+                        || text.contains("intersection")
+                        || text.contains("union")
+                        || text.contains("element")
+                        || text.contains("derivative")
+                        || text.contains("component")
+                        || text.contains("index"))
+                {
+                    continue;
+                }
+
+                // Skip if URL part looks like coordinates or intervals
+                if url.contains(',') && !url.contains("://") && !url.contains('.') {
+                    continue;
+                }
+
                 let start = line_start + cap.get(0).unwrap().start();
                 results.push((current_line, start - line_start + 1, text.to_string(), url.to_string()));
             }

{rumdl-0.0.128 → rumdl-0.0.130}/src/rules/md024_no_duplicate_heading.rs

@@ -51,8 +51,28 @@ impl Rule for MD024NoDuplicateHeading {
         let mut current_section_path: Vec<(u8, String)> = Vec::new(); // Stack of (level, heading_text)
         let mut seen_siblings: HashMap<String, HashSet<String>> = HashMap::new(); // parent_path -> set of child headings
 
+        // Track if we're in a snippet section (MkDocs flavor)
+        let is_mkdocs = ctx.flavor == crate::config::MarkdownFlavor::MkDocs;
+        let mut in_snippet_section = false;
+
         // Process headings using cached heading information
         for (line_num, line_info) in ctx.lines.iter().enumerate() {
+            // Check for MkDocs snippet markers if using MkDocs flavor
+            if is_mkdocs {
+                if crate::utils::mkdocs_snippets::is_snippet_section_start(&line_info.content) {
+                    in_snippet_section = true;
+                    continue; // Skip this line
+                } else if crate::utils::mkdocs_snippets::is_snippet_section_end(&line_info.content) {
+                    in_snippet_section = false;
+                    continue; // Skip this line
+                }
+            }
+
+            // Skip lines within snippet sections (for MkDocs)
+            if is_mkdocs && in_snippet_section {
+                continue;
+            }
+
             if let Some(heading) = &line_info.heading {
                 // Skip empty headings
                 if heading.text.is_empty() {

{rumdl-0.0.128 → rumdl-0.0.130}/src/rules/md027_multiple_spaces_blockquote.rs

@@ -144,12 +144,17 @@ impl Rule for MD027MultipleSpacesBlockquote {
                 // Fix blockquotes with multiple spaces after the marker
                 if blockquote.has_multiple_spaces_after_marker {
                     // Rebuild the line with exactly one space after the markers
-                    let fixed_line = format!(
-                        "{}{} {}",
-                        blockquote.indent,
-                        ">".repeat(blockquote.nesting_level),
-                        blockquote.content
-                    );
+                    // But don't add a space if the content is empty to avoid MD009 conflicts
+                    let fixed_line = if blockquote.content.is_empty() {
+                        format!("{}{}", blockquote.indent, ">".repeat(blockquote.nesting_level))
+                    } else {
+                        format!(
+                            "{}{} {}",
+                            blockquote.indent,
+                            ">".repeat(blockquote.nesting_level),
+                            blockquote.content
+                        )
+                    };
                     result.push(fixed_line);
                 } else {
                     result.push(line_info.content.clone());

{rumdl-0.0.128 → rumdl-0.0.130}/src/rules/md028_no_blanks_blockquote.rs

@@ -17,7 +17,7 @@ impl MD028NoBlanksBlockquote {
         for _ in 0..level {
             result.push('>');
         }
-        // Add a single space after the last '>'
+        // Add a single space after the marker for proper blockquote formatting
         result.push(' ');
 
         result

{rumdl-0.0.128 → rumdl-0.0.130}/src/rules/md031_blanks_around_fences.rs

@@ -5,6 +5,7 @@ use crate::rule::{Fix, LintError, LintResult, LintWarning, Rule, RuleCategory, S
 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::mkdocs_admonitions;
 use crate::utils::range_utils::{LineIndex, calculate_line_range};
 use serde::{Deserialize, Serialize};
 
@@ -126,12 +127,76 @@ impl Rule for MD031BlanksAroundFences {
 
         let mut in_code_block = false;
         let mut current_fence_marker: Option<String> = None;
+        let mut in_admonition = false;
+        let mut admonition_indent = 0;
+        let is_mkdocs = ctx.flavor == crate::config::MarkdownFlavor::MkDocs;
         let mut i = 0;
 
         while i < lines.len() {
             let line = lines[i];
             let trimmed = line.trim_start();
 
+            // Check for MkDocs admonition start
+            if is_mkdocs && mkdocs_admonitions::is_admonition_start(line) {
+                // Check for blank line before admonition (similar to code blocks)
+                if i > 0 && !Self::is_empty_line(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]);
+
+                    warnings.push(LintWarning {
+                        rule_name: Some(self.name()),
+                        line: start_line,
+                        column: start_col,
+                        end_line,
+                        end_column: end_col,
+                        message: "No blank line before admonition block".to_string(),
+                        severity: Severity::Warning,
+                        fix: Some(Fix {
+                            range: line_index.line_col_to_byte_range_with_length(i + 1, 1, 0),
+                            replacement: "\n".to_string(),
+                        }),
+                    });
+                }
+
+                in_admonition = true;
+                admonition_indent = mkdocs_admonitions::get_admonition_indent(line).unwrap_or(0);
+                i += 1;
+                continue;
+            }
+
+            // Check if we're exiting an admonition
+            if in_admonition {
+                if !line.trim().is_empty() && !mkdocs_admonitions::is_admonition_content(line, admonition_indent) {
+                    // We've exited the admonition
+                    in_admonition = false;
+
+                    // Check for blank line after admonition (current line should be blank)
+                    if !Self::is_empty_line(line) && self.should_require_blank_line(i - 1, &lines) {
+                        let (start_line, start_col, end_line, end_col) = calculate_line_range(i + 1, lines[i]);
+
+                        warnings.push(LintWarning {
+                            rule_name: Some(self.name()),
+                            line: start_line,
+                            column: start_col,
+                            end_line,
+                            end_column: end_col,
+                            message: "No blank line after admonition block".to_string(),
+                            severity: Severity::Warning,
+                            fix: Some(Fix {
+                                range: line_index.line_col_to_byte_range_with_length(i, 0, 0),
+                                replacement: "\n".to_string(),
+                            }),
+                        });
+                    }
+
+                    admonition_indent = 0;
+                    // Don't continue - process this line normally
+                } else {
+                    // Still in admonition
+                    i += 1;
+                    continue;
+                }
+            }
+
             // Determine fence marker if this is a fence line
             let fence_marker = if trimmed.starts_with("```") {
                 let backtick_count = trimmed.chars().take_while(|&c| c == '`').count();

{rumdl-0.0.128 → rumdl-0.0.130}/src/rules/md033_no_inline_html.rs

@@ -145,6 +145,14 @@ impl MD033NoInlineHtml {
             && content.split('@').all(|part| !part.is_empty())
     }
 
+    // Check if a tag has the markdown attribute (MkDocs/Material for MkDocs)
+    #[inline]
+    fn has_markdown_attribute(&self, tag: &str) -> bool {
+        // Check for various forms of markdown attribute
+        // Examples: <div markdown>, <div markdown="1">, <div class="result" markdown>
+        tag.contains(" markdown>") || tag.contains(" markdown=") || tag.contains(" markdown ")
+    }
+
     // Check if a tag is actually a URL in angle brackets
     #[inline]
     fn is_url_in_angle_brackets(&self, tag: &str) -> bool {
@@ -160,6 +168,7 @@ impl MD033NoInlineHtml {
     /// Find HTML tags that span multiple lines
     fn find_multiline_html_tags(
         &self,
+        ctx: &crate::lint_context::LintContext,
         content: &str,
         structure: &DocumentStructure,
         nomarkdown_ranges: &[(usize, usize)],
@@ -230,11 +239,15 @@ impl MD033NoInlineHtml {
                         let final_tag = &complete_tag[0..=end_pos];
 
                         // Apply the same filters as single-line tags
+                        let skip_mkdocs_markdown = ctx.flavor == crate::config::MarkdownFlavor::MkDocs
+                            && self.has_markdown_attribute(final_tag);
+
                         if !self.is_html_comment(final_tag)
                             && !self.is_likely_type_annotation(final_tag)
                             && !self.is_email_address(final_tag)
                             && !self.is_url_in_angle_brackets(final_tag)
                             && !self.is_tag_allowed(final_tag)
+                            && !skip_mkdocs_markdown
                             && HTML_TAG_FINDER.is_match(final_tag)
                         {
                             // Check for duplicates (avoid flagging the same position twice)
@@ -398,6 +411,11 @@ impl Rule for MD033NoInlineHtml {
                     continue;
                 }
 
+                // Skip tags with markdown attribute in MkDocs mode
+                if ctx.flavor == crate::config::MarkdownFlavor::MkDocs && self.has_markdown_attribute(tag) {
+                    continue;
+                }
+
                 // Report each HTML tag individually (true markdownlint compatibility)
                 let (start_line, start_col, end_line, end_col) =
                     calculate_html_tag_range(line_num, line, tag_match.start(), tag_match.len());
@@ -415,7 +433,7 @@ impl Rule for MD033NoInlineHtml {
         }
 
         // Third pass: find multi-line HTML tags
-        self.find_multiline_html_tags(ctx.content, structure, &nomarkdown_ranges, &mut warnings);
+        self.find_multiline_html_tags(ctx, ctx.content, structure, &nomarkdown_ranges, &mut warnings);
 
         Ok(warnings)
     }