rumdl 0.0.110__tar.gz → 0.0.111__tar.gz

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

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

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

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

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

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

{rumdl-0.0.110 → rumdl-0.0.111}/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.111}/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.111}/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)),
+                            }),
+                        });
+                    }
                 }
             }
         }

rumdl-0.0.111/src/utils/kramdown_utils.rs

@@ -0,0 +1,94 @@
+//! Utilities for handling Kramdown-specific syntax
+//!
+//! Kramdown is a superset of Markdown that adds additional features like
+//! Inline Attribute Lists (IAL) for adding attributes to elements.
+
+/// Check if a line is a Kramdown block attribute (IAL - Inline Attribute List)
+///
+/// Kramdown IAL syntax allows adding attributes to block elements:
+/// - `{:.class}` - CSS class
+/// - `{:#id}` - Element ID
+/// - `{:attribute="value"}` - Generic attributes
+/// - `{:.class #id attribute="value"}` - Combinations
+///
+/// # Examples
+///
+/// ```
+/// use rumdl::utils::kramdown_utils::is_kramdown_block_attribute;
+///
+/// assert!(is_kramdown_block_attribute("{:.wrap}"));
+/// assert!(is_kramdown_block_attribute("{:#my-id}"));
+/// assert!(is_kramdown_block_attribute("{:.class #id}"));
+/// assert!(is_kramdown_block_attribute("{:style=\"color: red\"}"));
+///
+/// assert!(!is_kramdown_block_attribute("{just text}"));
+/// assert!(!is_kramdown_block_attribute("{}"));
+/// assert!(!is_kramdown_block_attribute("{"));
+/// ```
+pub fn is_kramdown_block_attribute(line: &str) -> bool {
+    let trimmed = line.trim();
+
+    // Must start with { and end with }
+    if !trimmed.starts_with('{') || !trimmed.ends_with('}') || trimmed.len() < 3 {
+        return false;
+    }
+
+    // Check if it matches Kramdown IAL patterns
+    // Valid patterns start with {: or {# or {.
+    let second_char = trimmed.chars().nth(1);
+    matches!(second_char, Some(':') | Some('#') | Some('.'))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_kramdown_class_attributes() {
+        assert!(is_kramdown_block_attribute("{:.wrap}"));
+        assert!(is_kramdown_block_attribute("{:.class-name}"));
+        assert!(is_kramdown_block_attribute("{:.multiple .classes}"));
+    }
+
+    #[test]
+    fn test_kramdown_id_attributes() {
+        assert!(is_kramdown_block_attribute("{:#my-id}"));
+        assert!(is_kramdown_block_attribute("{:#section-1}"));
+    }
+
+    #[test]
+    fn test_kramdown_generic_attributes() {
+        assert!(is_kramdown_block_attribute("{:style=\"color: red\"}"));
+        assert!(is_kramdown_block_attribute("{:data-value=\"123\"}"));
+    }
+
+    #[test]
+    fn test_kramdown_combined_attributes() {
+        assert!(is_kramdown_block_attribute("{:.class #id}"));
+        assert!(is_kramdown_block_attribute("{:#id .class style=\"color: blue\"}"));
+        assert!(is_kramdown_block_attribute("{:.wrap #my-code .highlight}"));
+    }
+
+    #[test]
+    fn test_non_kramdown_braces() {
+        assert!(!is_kramdown_block_attribute("{just some text}"));
+        assert!(!is_kramdown_block_attribute("{not kramdown}"));
+        assert!(!is_kramdown_block_attribute("{ spaces }"));
+    }
+
+    #[test]
+    fn test_edge_cases() {
+        assert!(!is_kramdown_block_attribute("{}"));
+        assert!(!is_kramdown_block_attribute("{"));
+        assert!(!is_kramdown_block_attribute("}"));
+        assert!(!is_kramdown_block_attribute(""));
+        assert!(!is_kramdown_block_attribute("not braces"));
+    }
+
+    #[test]
+    fn test_whitespace_handling() {
+        assert!(is_kramdown_block_attribute("  {:.wrap}  "));
+        assert!(is_kramdown_block_attribute("\t{:#id}\t"));
+        assert!(is_kramdown_block_attribute(" {:.class #id} "));
+    }
+}

{rumdl-0.0.110 → rumdl-0.0.111}/src/utils/mod.rs

@@ -9,6 +9,7 @@ pub mod early_returns;
 pub mod element_cache;
 pub mod emphasis_utils;
 pub mod fix_utils;
+pub mod kramdown_utils;
 pub mod markdown_elements;
 pub mod range_utils;
 pub mod regex_cache;

{rumdl-0.0.110 → rumdl-0.0.111}/tests/rules/md005_test.rs

@@ -32,6 +32,39 @@ fn test_valid_ordered_list() {
     assert!(result.is_empty());
 }
 
+#[test]
+fn test_frontmatter_yaml_lists_not_detected() {
+    // Test for issue #35 - YAML lists in frontmatter should not be detected as Markdown lists
+    let rule = MD005ListIndent;
+    let content = "\
+---
+layout: post
+title: \"title\"
+creator:
+  - 'user1'
+  - 'user2'
+creator_num:
+  - 1253217
+  - 1615089
+tags: [tag1, tag2, tag3]
+---
+
+# TITLE
+
+## Heading
+
+Whatever
+
+And a list:
+
+- Item1
+- Item2";
+    let ctx = LintContext::new(content);
+    let result = rule.check(&ctx).unwrap();
+    // Should not flag YAML lists in frontmatter
+    assert!(result.is_empty(), "MD005 should not check lists in frontmatter");
+}
+
 #[test]
 fn test_invalid_unordered_indent() {
     let rule = MD005ListIndent;

rumdl-0.0.111/tests/rules/md031_kramdown_test.rs

@@ -0,0 +1,125 @@
+use rumdl::lint_context::LintContext;
+use rumdl::rule::Rule;
+use rumdl::rules::MD031BlanksAroundFences;
+
+#[test]
+fn test_kramdown_block_attributes_auto_detected() {
+    // Kramdown attributes should be auto-detected without configuration
+    let rule = MD031BlanksAroundFences::default();
+    let content = r#"# Title
+
+```bash
+echo hello
+```
+{:.wrap}
+
+Some text"#;
+    let ctx = LintContext::new(content);
+    let result = rule.check(&ctx).unwrap();
+    assert!(result.is_empty(), "Should auto-detect Kramdown block attributes");
+}
+
+#[test]
+fn test_non_kramdown_braces_still_flagged() {
+    // Lines with braces that don't match Kramdown IAL syntax should still be flagged
+    let rule = MD031BlanksAroundFences::default();
+    let content = r#"# Title
+
+```bash
+echo hello
+```
+{not kramdown}
+
+Some text"#;
+    let ctx = LintContext::new(content);
+    let result = rule.check(&ctx).unwrap();
+    assert_eq!(result.len(), 1, "Should flag non-Kramdown brace lines");
+    assert!(result[0].message.contains("No blank line after"));
+}
+
+#[test]
+fn test_kramdown_css_class_variants() {
+    // Test various Kramdown attribute syntax variations
+    let rule = MD031BlanksAroundFences::default();
+
+    // Class attribute
+    let content1 = r#"```bash
+echo hello
+```
+{:.wrap}"#;
+    let ctx = LintContext::new(content1);
+    assert!(rule.check(&ctx).unwrap().is_empty());
+
+    // ID attribute
+    let content2 = r#"```bash
+echo hello
+```
+{:#my-code}"#;
+    let ctx = LintContext::new(content2);
+    assert!(rule.check(&ctx).unwrap().is_empty());
+
+    // Multiple attributes
+    let content3 = r#"```bash
+echo hello
+```
+{:.wrap #my-code .highlight}"#;
+    let ctx = LintContext::new(content3);
+    assert!(rule.check(&ctx).unwrap().is_empty());
+}
+
+#[test]
+fn test_kramdown_no_blank_after_attribute() {
+    // Kramdown attributes don't need blank lines after them
+    let rule = MD031BlanksAroundFences::default();
+    let content = r#"```bash
+echo hello
+```
+{:.wrap}
+Some text immediately after"#;
+    let ctx = LintContext::new(content);
+    let result = rule.check(&ctx).unwrap();
+    // This should not flag since the Kramdown attribute is auto-detected
+    assert!(result.is_empty(), "Should auto-detect Kramdown attributes");
+}
+
+#[test]
+fn test_normal_code_blocks_still_checked() {
+    // Normal code blocks without attributes should still be checked
+    let rule = MD031BlanksAroundFences::default();
+    let content = r#"# Title
+
+```bash
+echo hello
+```
+Some text immediately after"#;
+    let ctx = LintContext::new(content);
+    let result = rule.check(&ctx).unwrap();
+    assert_eq!(
+        result.len(),
+        1,
+        "Should still flag missing blank line for normal code blocks"
+    );
+}
+
+#[test]
+fn test_fix_preserves_kramdown_attributes() {
+    let rule = MD031BlanksAroundFences::default();
+    let content = r#"Text before
+```bash
+echo hello
+```
+{:.wrap}
+Text after"#;
+    let ctx = LintContext::new(content);
+    let fixed = rule.fix(&ctx).unwrap();
+
+    // Should add blank line before the code block but not after (due to attribute)
+    let expected = r#"Text before
+
+```bash
+echo hello
+```
+{:.wrap}
+Text after"#;
+    assert_eq!(fixed, expected);
+}

rumdl-0.0.111/tests/rules/md058_kramdown_test.rs

@@ -0,0 +1,139 @@
+use rumdl::lint_context::LintContext;
+use rumdl::rule::Rule;
+use rumdl::rules::MD058BlanksAroundTables;
+
+#[test]
+fn test_kramdown_block_attributes_auto_detected() {
+    // Kramdown attributes should be auto-detected without configuration
+    let rule = MD058BlanksAroundTables::default();
+    let content = r#"# Title
+
+| Header 1 | Header 2 |
+|----------|----------|
+| Cell 1   | Cell 2   |
+{:.striped}
+
+Some text"#;
+    let ctx = LintContext::new(content);
+    let result = rule.check(&ctx).unwrap();
+    assert!(result.is_empty(), "Should auto-detect Kramdown block attributes");
+}
+
+#[test]
+fn test_non_kramdown_braces_still_flagged() {
+    // Lines with braces that don't match Kramdown IAL syntax should still be flagged
+    let rule = MD058BlanksAroundTables::default();
+    let content = r#"# Title
+
+| Header 1 | Header 2 |
+|----------|----------|
+| Cell 1   | Cell 2   |
+{not kramdown}
+
+Some text"#;
+    let ctx = LintContext::new(content);
+    let result = rule.check(&ctx).unwrap();
+    assert_eq!(result.len(), 1, "Should flag non-Kramdown brace lines");
+    assert!(result[0].message.contains("Missing blank line after"));
+}
+
+#[test]
+fn test_kramdown_table_css_class_variants() {
+    // Test various Kramdown attribute syntax variations
+    let rule = MD058BlanksAroundTables::default();
+
+    // Class attribute
+    let content1 = r#"Text
+
+| Col1 | Col2 |
+|------|------|
+| A    | B    |
+{:.striped}
+
+Text"#;
+    let ctx = LintContext::new(content1);
+    assert!(rule.check(&ctx).unwrap().is_empty());
+
+    // ID attribute
+    let content2 = r#"Text
+
+| Col1 | Col2 |
+|------|------|
+| A    | B    |
+{:#my-table}
+
+Text"#;
+    let ctx = LintContext::new(content2);
+    assert!(rule.check(&ctx).unwrap().is_empty());
+
+    // Multiple attributes
+    let content3 = r#"Text
+
+| Col1 | Col2 |
+|------|------|
+| A    | B    |
+{:.striped #my-table .responsive}
+
+Text"#;
+    let ctx = LintContext::new(content3);
+    assert!(rule.check(&ctx).unwrap().is_empty());
+}
+
+#[test]
+fn test_normal_tables_still_checked() {
+    // Normal tables without attributes should still be checked
+    let rule = MD058BlanksAroundTables::default();
+    let content = r#"# Title
+
+| Header 1 | Header 2 |
+|----------|----------|
+| Cell 1   | Cell 2   |
+Some text immediately after"#;
+    let ctx = LintContext::new(content);
+    let result = rule.check(&ctx).unwrap();
+    assert_eq!(
+        result.len(),
+        1,
+        "Should still flag missing blank line for normal tables"
+    );
+}
+
+#[test]
+fn test_table_before_still_checked() {
+    // Should still check for blank lines before table
+    let rule = MD058BlanksAroundTables::default();
+    let content = r#"# Title
+| Header 1 | Header 2 |
+|----------|----------|
+| Cell 1   | Cell 2   |
+{:.striped}
+
+Text"#;
+    let ctx = LintContext::new(content);
+    let result = rule.check(&ctx).unwrap();
+    assert_eq!(result.len(), 1, "Should flag missing blank line before table");
+    assert!(result[0].message.contains("Missing blank line before"));
+}
+
+#[test]
+fn test_fix_preserves_kramdown_attributes() {
+    let rule = MD058BlanksAroundTables::default();
+    let content = r#"Text before
+| Col1 | Col2 |
+|------|------|
+| A    | B    |
+{:.striped}
+Text after"#;
+    let ctx = LintContext::new(content);
+    let fixed = rule.fix(&ctx).unwrap();
+
+    // Should add blank line before the table but not after (due to attribute)
+    let expected = r#"Text before
+
+| Col1 | Col2 |
+|------|------|
+| A    | B    |
+{:.striped}
+Text after"#;
+    assert_eq!(fixed, expected);
+}

{rumdl-0.0.110 → rumdl-0.0.111}/tests/rules/mod.rs

@@ -25,6 +25,7 @@ mod md027_test;
 mod md028_test;
 mod md029_test;
 mod md030_test;
+mod md031_kramdown_test;
 mod md031_test;
 mod md032_test;
 mod md033_test;
@@ -56,6 +57,7 @@ mod md054_test;
 mod md055_test;
 mod md056_test;
 mod md057_test;
+mod md058_kramdown_test;
 mod md058_test;
 
 // Unicode-specific test modules