rumdl 0.0.109__tar.gz → 0.0.111__tar.gz

{rumdl-0.0.109 → rumdl-0.0.111}/.mise.toml

@@ -20,6 +20,7 @@ uv = "latest"
 "cargo:cargo-watch" = "latest"
 "cargo:maturin" = "latest"
 "cargo:cargo-binstall" = "latest"
+"cargo:cargo-zigbuild" = "latest"  # For building static Linux binaries
 
 # Zig for cross-compilation (used by maturin)
 zig = "0.13"
@@ -104,4 +105,4 @@ make test-quick
 # rust = "1.87.0"
 #
 # [tools.windows]
-# rust = "1.87.0"
+# rust = "1.87.0"

{rumdl-0.0.109 → rumdl-0.0.111}/CHANGELOG.md

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

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

@@ -220,9 +220,9 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
 [[package]]
 name = "cc"
-version = "1.2.31"
+version = "1.2.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3a42d84bb6b69d3a8b3eaacf0d88f179e1929695e1ad012b6cf64d9caaa5fd2"
+checksum = "2352e5597e9c544d5e6d9c95190d5d27738ade584fa8db0a16e130e5c2b5296e"
 dependencies = [
  "shlex",
 ]
@@ -1493,7 +1493,7 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "rumdl"
-version = "0.0.109"
+version = "0.0.111"
 dependencies = [
  "anyhow",
  "assert_cmd",

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

@@ -1,6 +1,6 @@
 [package]
 name = "rumdl"
-version = "0.0.109"
+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.109 → rumdl-0.0.111}/Makefile

@@ -1,4 +1,4 @@
-.PHONY: build test clean fmt check doc version-major version-minor version-patch build-python build-wheel dev-install setup-mise dev-setup dev-verify update-dependencies update-rust-version pre-release
+.PHONY: build test clean fmt check doc version-major version-minor version-patch build-python build-wheel dev-install setup-mise dev-setup dev-verify update-dependencies update-rust-version pre-release build-static-linux-x64 build-static-linux-arm64 build-static-all
 
 # Development environment setup
 setup-mise:
@@ -60,6 +60,22 @@ ci-install-mise:
 build:
 	cargo build --release
 
+# Static binary builds for Linux (musl)
+build-static-linux-x64:
+	@echo "Building static Linux x86_64 binary..."
+	rustup target add x86_64-unknown-linux-musl 2>/dev/null || true
+	mise exec -- cargo zigbuild --release --target x86_64-unknown-linux-musl
+	@echo "Static binary built at: target/x86_64-unknown-linux-musl/release/rumdl"
+
+build-static-linux-arm64:
+	@echo "Building static Linux ARM64 binary..."
+	rustup target add aarch64-unknown-linux-musl 2>/dev/null || true
+	mise exec -- cargo zigbuild --release --target aarch64-unknown-linux-musl
+	@echo "Static binary built at: target/aarch64-unknown-linux-musl/release/rumdl"
+
+build-static-all: build-static-linux-x64 build-static-linux-arm64
+	@echo "All static Linux binaries built successfully"
+
 test:
 	cargo nextest run --profile dev
 

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

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

{rumdl-0.0.109 → 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.109 → 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.109 → rumdl-0.0.111}/src/rules/md032_blanks_around_lists.rs

@@ -111,6 +111,7 @@ impl MD032BlanksAroundLists {
         ctx: &crate::lint_context::LintContext,
         structure: &DocumentStructure,
         prev_line_num: usize,
+        current_line_num: usize,
     ) -> bool {
         let trimmed_prev = prev_line.trim();
 
@@ -119,6 +120,11 @@ impl MD032BlanksAroundLists {
             return true;
         }
 
+        // Always allow nested lists (lists indented within other list items)
+        if self.is_nested_list(ctx, prev_line_num, current_line_num) {
+            return false;
+        }
+
         // Allow lists after headings if configured
         if self.allow_after_headings && self.is_heading_line_from_context(ctx, prev_line_num - 1) {
             return false;
@@ -142,6 +148,30 @@ impl MD032BlanksAroundLists {
         }
     }
 
+    /// Check if the current list is nested within another list item
+    fn is_nested_list(
+        &self,
+        ctx: &crate::lint_context::LintContext,
+        prev_line_num: usize,    // 1-indexed
+        current_line_num: usize, // 1-indexed
+    ) -> bool {
+        // Check if current line is indented (typical for nested lists)
+        if current_line_num > 0 && current_line_num - 1 < ctx.lines.len() {
+            let current_line = &ctx.lines[current_line_num - 1];
+            if current_line.indent >= 2 {
+                // Check if previous line is a list item or list content
+                if prev_line_num > 0 && prev_line_num - 1 < ctx.lines.len() {
+                    let prev_line = &ctx.lines[prev_line_num - 1];
+                    // Previous line is a list item or indented content
+                    if prev_line.list_item.is_some() || prev_line.indent >= 2 {
+                        return true;
+                    }
+                }
+            }
+        }
+        false
+    }
+
     // Convert centralized list blocks to the format expected by perform_checks
     fn convert_list_blocks(&self, ctx: &crate::lint_context::LintContext) -> Vec<(usize, usize, String)> {
         let mut blocks: Vec<(usize, usize, String)> = Vec::new();
@@ -291,8 +321,13 @@ impl MD032BlanksAroundLists {
 
                 // Only require blank lines for content in the same context (same blockquote level)
                 // and when the context actually requires it
-                let should_require =
-                    self.should_require_blank_line_before(prev_line_str, ctx, structure, prev_line_actual_idx_1);
+                let should_require = self.should_require_blank_line_before(
+                    prev_line_str,
+                    ctx,
+                    structure,
+                    prev_line_actual_idx_1,
+                    start_line,
+                );
                 if !is_prev_excluded && !prev_is_blank && prefixes_match && should_require {
                     // Calculate precise character range for the entire list line that needs a blank line before it
                     let (start_line, start_col, end_line, end_col) =
@@ -488,6 +523,7 @@ impl MD032BlanksAroundLists {
                     ctx,
                     structure,
                     prev_line_actual_idx_1,
+                    start_line,
                 );
                 if !is_prev_excluded
                     && !is_blank_in_context(lines[prev_line_actual_idx_0])

{rumdl-0.0.109 → 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.109 → 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.109 → 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.109 → rumdl-0.0.111}/tests/rules/md032_test.rs

@@ -171,16 +171,67 @@ fn test_multiple_lists() {
 
 #[test]
 fn test_nested_lists() {
+    // Nested lists should not require blank lines between parent and child items
     let rule = MD032BlanksAroundLists::default();
     let content = "Text\n* Item 1\n  * Nested 1\n  * Nested 2\n* Item 2\nText";
     let ctx = LintContext::new(content);
     let result = rule.check(&ctx).unwrap();
-    assert_eq!(result.len(), 2);
+    // Should only warn about missing blank lines around the outer list, not the nested items
+    assert_eq!(
+        result.len(),
+        2,
+        "Should only warn about outer list boundaries, not nested items"
+    );
     let fixed = rule.fix(&ctx).unwrap();
     let _ctx_fixed = LintContext::new(&fixed);
     assert_eq!(fixed, "Text\n\n* Item 1\n  * Nested 1\n  * Nested 2\n* Item 2\n\nText");
 }
 
+#[test]
+fn test_nested_lists_with_strict_mode() {
+    // Even in strict mode, nested lists are a standard Markdown pattern and shouldn't require blank lines
+    let rule = MD032BlanksAroundLists::strict();
+    let content = "Text\n\n* Item 1\n  * Nested 1\n  * Nested 2\n* Item 2\n\nText";
+    let ctx = LintContext::new(content);
+    let result = rule.check(&ctx).unwrap();
+    // Even strict mode should not warn about nested lists - this is standard Markdown
+    assert!(
+        result.is_empty(),
+        "Nested lists are standard Markdown and shouldn't trigger warnings even in strict mode"
+    );
+}
+
+#[test]
+fn test_deeply_nested_lists() {
+    // Test multiple levels of nesting
+    let rule = MD032BlanksAroundLists::default();
+    let content = "## Section\n\n* Level 1\n  * Level 2\n    * Level 3\n      * Level 4\n  * Back to Level 2\n* Back to Level 1\n\nText";
+    let ctx = LintContext::new(content);
+    let result = rule.check(&ctx).unwrap();
+    // Should not warn about nested list transitions
+    assert!(result.is_empty(), "Should not warn about deeply nested lists");
+}
+
+#[test]
+fn test_nested_ordered_lists() {
+    // Test nested ordered lists
+    let rule = MD032BlanksAroundLists::default();
+    let content = "## Section\n\n1. First item\n   1. Sub item 1.1\n   2. Sub item 1.2\n2. Second item\n   1. Sub item 2.1\n\nText";
+    let ctx = LintContext::new(content);
+    let result = rule.check(&ctx).unwrap();
+    assert!(result.is_empty(), "Should not warn about nested ordered lists");
+}
+
+#[test]
+fn test_mixed_nested_list_types() {
+    // Test mixing ordered and unordered lists in nesting
+    let rule = MD032BlanksAroundLists::default();
+    let content = "## Section\n\n1. Ordered item\n   - Unordered sub-item\n   - Another unordered sub-item\n2. Another ordered item\n   * Different unordered marker\n\nText";
+    let ctx = LintContext::new(content);
+    let result = rule.check(&ctx).unwrap();
+    assert!(result.is_empty(), "Should not warn about mixed nested list types");
+}
+
 #[test]
 fn test_mixed_list_types() {
     let rule = MD032BlanksAroundLists::default();