rumdl 0.0.108__tar.gz → 0.0.109__tar.gz

{rumdl-0.0.108 → rumdl-0.0.109}/.config/nextest.toml

@@ -36,8 +36,8 @@ retries = 0
 # Quick profile for development
 [profile.quick]
 
-# Skip slow tests
-default-filter = 'not test(/memory/) and not test(/stress/) and not test(/large/)'
+# Skip slow tests and performance tests
+default-filter = 'not test(/memory/) and not test(/stress/) and not test(/large/) and not test(/error_propagation/) and not test(/performance/) and not test(/comprehensive/) and not test(/deeply_nested/)'
 
 # Even more parallel execution locally
 test-threads = "num-cpus"
@@ -45,11 +45,27 @@ test-threads = "num-cpus"
 # Less verbose output
 status-level = "fail"
 
+# Development profile - balance between speed and coverage
+[profile.dev]
+
+# Skip the slowest tests but include integration tests
+default-filter = 'not test(/error_propagation/) and not test(/deeply_nested/) and not test(/memory/) and not test(/stress/) and not test(/large/) and not test(/performance/) and not test(/perf_check/)'
+
+# Good parallelization for dev machines
+test-threads = "num-cpus"
+
+# Show failures immediately
+failure-output = "immediate"
+status-level = "fail"
+
+# No retries for faster feedback
+retries = 0
+
 # Ultra-fast profile for pre-commit hooks
 [profile.pre-commit]
 
 # Only run unit tests in lib, skip all integration tests and binaries
-default-filter = 'package(rumdl) and kind(lib) and not test(/slow|stress|large|integration|comprehensive|cli|config|advanced|commonmark|consistency|performance|benchmark|parity/)'
+default-filter = 'package(rumdl) and kind(lib) and not test(/slow|stress|large|integration|comprehensive|cli|config|advanced|commonmark|consistency|performance|benchmark|parity|error_propagation|deeply_nested|memory/)'
 
 # Maximum parallelism for speed
 test-threads = "num-cpus"
@@ -63,4 +79,4 @@ success-output = "never"
 retries = 0
 
 # Fail fast on first failure
-fail-fast = true
+fail-fast = true

{rumdl-0.0.108 → rumdl-0.0.109}/.pre-commit-config.yaml

@@ -1,8 +1,8 @@
 # Pre-commit hooks for rumdl
-# Install with: 
+# Install with:
 #   pre-commit install                    # Install commit hooks
 #   pre-commit install --hook-type pre-push  # Install push hooks
-# Run manually: 
+# Run manually:
 #   pre-commit run --all-files           # Run commit hooks
 #   pre-commit run --hook-stage push --all-files  # Run push hooks
 
@@ -64,7 +64,7 @@ repos:
         language: system
         types: [rust]
         pass_filenames: false
-        stages: [push]
+        stages: [pre-push]
         verbose: true
 
       - id: cargo-lint-full
@@ -73,7 +73,7 @@ repos:
         language: system
         types: [rust]
         pass_filenames: false
-        stages: [push]
+        stages: [pre-push]
         verbose: true
 
       - id: cargo-doc-check
@@ -82,5 +82,5 @@ repos:
         language: system
         types: [rust]
         pass_filenames: false
-        stages: [push]
+        stages: [pre-push]
         verbose: true

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

@@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.110] - 2025-08-08
+
 ## [0.0.107] - 2025-08-06
 
 ## [0.0.107] - 2025-08-06
@@ -298,7 +300,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.107...HEAD
+[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.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.108 → rumdl-0.0.109}/Cargo.lock

@@ -672,9 +672,9 @@ checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
 
 [[package]]
 name = "hashbrown"
-version = "0.15.4"
+version = "0.15.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5971ac85611da7067dbfcabef3c70ebb5606018acd9e2a3903a0da507521e0d5"
+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
 
 [[package]]
 name = "heck"
@@ -848,7 +848,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fe4cd85333e22411419a0bcae1297d25e58c9443848b11dc6a86fefe8c78a661"
 dependencies = [
  "equivalent",
- "hashbrown 0.15.4",
+ "hashbrown 0.15.5",
 ]
 
 [[package]]
@@ -1493,7 +1493,7 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "rumdl"
-version = "0.0.108"
+version = "0.0.109"
 dependencies = [
  "anyhow",
  "assert_cmd",
@@ -1689,9 +1689,9 @@ dependencies = [
 
 [[package]]
 name = "slab"
-version = "0.4.10"
+version = "0.4.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04dc19736151f35336d325007ac991178d504a119863a2fcb3758cdb5e52c50d"
+checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589"
 
 [[package]]
 name = "smallvec"

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

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

{rumdl-0.0.108 → rumdl-0.0.109}/Makefile

@@ -61,11 +61,17 @@ build:
 	cargo build --release
 
 test:
+	cargo nextest run --profile dev
+
+test-legacy:
 	cargo test
 
 test-nextest:
 	cargo nextest run
 
+test-dev:
+	cargo nextest run --profile dev
+
 test-quick:
 	cargo nextest run --profile quick
 
@@ -100,7 +106,7 @@ doc:
 	cargo doc --no-deps
 
 watch-test:
-	cargo watch -x test
+	cargo watch -x "nextest run --profile quick"
 
 all: fmt check test build
 

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

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

{rumdl-0.0.108 → rumdl-0.0.109}/src/lint_context.rs

@@ -948,39 +948,18 @@ impl<'a> LintContext<'a> {
                     let leading_spaces = caps.get(1).map_or("", |m| m.as_str());
                     let marker = caps.get(2).map_or("", |m| m.as_str());
                     let spacing = caps.get(3).map_or("", |m| m.as_str());
-                    let content = caps.get(4).map_or("", |m| m.as_str());
+                    let _content = caps.get(4).map_or("", |m| m.as_str());
                     let marker_column = blockquote_prefix_len + leading_spaces.len();
                     let content_column = marker_column + marker.len() + spacing.len();
 
-                    // Check if this is likely emphasis or not a list item
+                    // According to CommonMark spec, unordered list items MUST have at least one space
+                    // after the marker (-, *, or +). Without a space, it's not a list item.
+                    // This also naturally handles cases like:
+                    // - *emphasis* (not a list)
+                    // - **bold** (not a list)
+                    // - --- (horizontal rule, not a list)
                     if spacing.is_empty() {
-                        // No space after marker - check if it's likely emphasis or just text
-                        if marker == "*" && content.ends_with('*') && !content[..content.len() - 1].contains('*') {
-                            // Likely emphasis like *text*
-                            None
-                        } else if marker == "*" && content.starts_with('*') {
-                            // Likely bold emphasis like **text** or horizontal rule like ***
-                            None
-                        } else if (marker == "*" || marker == "-")
-                            && content.chars().all(|c| c == marker.chars().next().unwrap())
-                            && content.len() >= 2
-                        {
-                            // Likely horizontal rule like *** or ---
-                            None
-                        } else if !content.is_empty() && content.chars().next().unwrap().is_alphabetic() {
-                            // Single word starting with marker, likely not intended as list
-                            // This matches markdownlint behavior
-                            None
-                        } else {
-                            // Other cases with no space - treat as malformed list item
-                            Some(ListItemInfo {
-                                marker: marker.to_string(),
-                                is_ordered: false,
-                                number: None,
-                                marker_column,
-                                content_column,
-                            })
-                        }
+                        None
                     } else {
                         Some(ListItemInfo {
                             marker: marker.to_string(),
@@ -995,15 +974,14 @@ impl<'a> LintContext<'a> {
                     let number_str = caps.get(2).map_or("", |m| m.as_str());
                     let delimiter = caps.get(3).map_or("", |m| m.as_str());
                     let spacing = caps.get(4).map_or("", |m| m.as_str());
-                    let content = caps.get(5).map_or("", |m| m.as_str());
+                    let _content = caps.get(5).map_or("", |m| m.as_str());
                     let marker = format!("{number_str}{delimiter}");
                     let marker_column = blockquote_prefix_len + leading_spaces.len();
                     let content_column = marker_column + marker.len() + spacing.len();
 
-                    // Check if this is likely not a list item
-                    if spacing.is_empty() && !content.is_empty() && content.chars().next().unwrap().is_alphabetic() {
-                        // No space after marker and starts with alphabetic, likely not intended as list
-                        // This matches markdownlint behavior
+                    // According to CommonMark spec, ordered list items MUST have at least one space
+                    // after the marker (period or parenthesis). Without a space, it's not a list item.
+                    if spacing.is_empty() {
                         None
                     } else {
                         Some(ListItemInfo {
@@ -1343,6 +1321,9 @@ impl<'a> LintContext<'a> {
 
                 if let Some(ref mut block) = current_block {
                     // Check if this continues the current block
+                    // For nested lists, we need to check if this is a nested item (higher nesting level)
+                    // or a continuation at the same or lower level
+                    let is_nested = nesting > block.nesting_level;
                     let same_type =
                         (block.is_ordered && list_item.is_ordered) || (!block.is_ordered && !list_item.is_ordered);
                     let same_context = block.blockquote_prefix == blockquote_prefix;
@@ -1392,7 +1373,18 @@ impl<'a> LintContext<'a> {
                         found_non_list
                     };
 
-                    if same_type && same_context && reasonable_distance && marker_compatible && !has_non_list_content {
+                    // A list continues if:
+                    // 1. It's a nested item (indented more than the parent), OR
+                    // 2. It's the same type at the same level with reasonable distance
+                    let continues_list = if is_nested {
+                        // Nested items always continue the list if they're in the same context
+                        same_context && reasonable_distance && !has_non_list_content
+                    } else {
+                        // Same-level items need to match type and markers
+                        same_type && same_context && reasonable_distance && marker_compatible && !has_non_list_content
+                    };
+
+                    if continues_list {
                         // Extend current block
                         block.end_line = line_num;
                         block.item_lines.push(line_num);

{rumdl-0.0.108 → rumdl-0.0.109}/src/rules/md004_unordered_list_style.rs

@@ -118,16 +118,12 @@ impl Rule for MD004UnorderedListStyle {
 
         // Use centralized list blocks for better performance and accuracy
         for list_block in &ctx.list_blocks {
-            // Skip ordered lists
-            if list_block.is_ordered {
-                continue;
-            }
-
             // Check each list item in this block
+            // We need to check individual items even in mixed lists (ordered with nested unordered)
             for &item_line in &list_block.item_lines {
                 if let Some(line_info) = ctx.line_info(item_line) {
                     if let Some(list_item) = &line_info.list_item {
-                        // Skip ordered lists (safety check)
+                        // Skip ordered list items - we only care about unordered ones
                         if list_item.is_ordered {
                             continue;
                         }
@@ -245,16 +241,12 @@ impl Rule for MD004UnorderedListStyle {
 
         // Use centralized list blocks
         for list_block in &ctx.list_blocks {
-            // Skip ordered lists
-            if list_block.is_ordered {
-                continue;
-            }
-
             // Process each list item in this block
+            // We need to check individual items even in mixed lists
             for &item_line in &list_block.item_lines {
                 if let Some(line_info) = ctx.line_info(item_line) {
                     if let Some(list_item) = &line_info.list_item {
-                        // Skip ordered lists (safety check)
+                        // Skip ordered list items - we only care about unordered ones
                         if list_item.is_ordered {
                             continue;
                         }
@@ -615,12 +607,13 @@ mod tests {
     #[test]
     fn test_edge_case_marker_at_end() {
         let rule = MD004UnorderedListStyle::new(UnorderedListStyle::Asterisk);
-        let content = "*\n-\n+";
+        // These are valid list items with minimal content (just a space)
+        let content = "* \n- \n+ ";
         let ctx = LintContext::new(content);
         let result = rule.check(&ctx).unwrap();
-        assert_eq!(result.len(), 2);
+        assert_eq!(result.len(), 2); // Should flag - and + as wrong markers
         let fixed = rule.fix(&ctx).unwrap();
-        assert_eq!(fixed, "*\n*\n*");
+        assert_eq!(fixed, "* \n* \n* ");
     }
 
     #[test]

{rumdl-0.0.108 → rumdl-0.0.109}/src/rules/md006_start_bullets.rs

@@ -16,21 +16,28 @@ use crate::utils::regex_cache::UNORDERED_LIST_MARKER_REGEX;
 pub struct MD006StartBullets;
 
 impl MD006StartBullets {
-    /// Check if a bullet is nested under an ordered list item
+    /// Check if a bullet is nested under an ordered list item (anywhere in the hierarchy)
     fn is_nested_under_ordered_item(
         &self,
         ctx: &crate::lint_context::LintContext,
         current_line: usize,
         current_indent: usize,
     ) -> bool {
-        // Look backward from current line to find parent item
+        // Look backward from current line to find any ordered ancestor
+        let mut check_indent = current_indent;
+
         for line_idx in (1..current_line).rev() {
             if let Some(line_info) = ctx.line_info(line_idx) {
                 if let Some(list_item) = &line_info.list_item {
-                    // Found a list item - check if it's at a lower indentation (parent level)
-                    if list_item.marker_column < current_indent {
-                        // This is a parent item - check if it's ordered
-                        return list_item.is_ordered;
+                    // Found a list item - check if it's at a lower indentation (ancestor level)
+                    if list_item.marker_column < check_indent {
+                        // This is an ancestor item
+                        if list_item.is_ordered {
+                            // Found an ordered ancestor
+                            return true;
+                        }
+                        // Continue looking for higher-level ancestors
+                        check_indent = list_item.marker_column;
                     }
                 }
                 // If we encounter non-blank, non-list content at column 0, stop looking
@@ -52,17 +59,17 @@ impl MD006StartBullets {
         // Track which lines contain valid bullet items
         let mut valid_bullet_lines = vec![false; lines.len()];
 
-        // Process each unordered list block
+        // Process each list block
         for list_block in &ctx.list_blocks {
-            // Skip ordered lists
-            if list_block.is_ordered {
-                continue;
-            }
-
             // Check each list item in this block
+            // We need to check unordered items even in mixed lists
             for &item_line in &list_block.item_lines {
                 if let Some(line_info) = ctx.line_info(item_line) {
                     if let Some(list_item) = &line_info.list_item {
+                        // Skip ordered list items - we only care about unordered ones
+                        if list_item.is_ordered {
+                            continue;
+                        }
                         let line_idx = item_line - 1;
                         let indent = list_item.marker_column;
                         let line = &lines[line_idx];
@@ -73,9 +80,16 @@ impl MD006StartBullets {
                             // Top-level items are always valid
                             is_valid = true;
                         } else {
-                            // Check if this is nested under an ordered item with correct indentation (3 spaces)
-                            if indent == 3 && self.is_nested_under_ordered_item(ctx, item_line, indent) {
-                                is_valid = true;
+                            // Check if this is nested under an ordered item with correct indentation
+                            // For single-digit ordered lists (1.), need at least 3 spaces for proper nesting
+                            // For double-digit (10.), need at least 4 spaces, etc.
+                            // But MD006's purpose is to flag top-level indented lists, not validate nesting depth
+                            if self.is_nested_under_ordered_item(ctx, item_line, indent) {
+                                // It's nested under an ordered item
+                                // Only flag if indentation is less than 3 (won't nest properly in CommonMark)
+                                if indent >= 3 {
+                                    is_valid = true;
+                                }
                             } else {
                                 // Check if this is a valid nested item under another bullet
                                 match Self::find_relevant_previous_bullet(&lines, line_idx) {
@@ -120,14 +134,28 @@ impl MD006StartBullets {
                                 end_col - start_col,
                             );
 
+                            // Generate appropriate message based on context
+                            let message = if self.is_nested_under_ordered_item(ctx, item_line, indent) {
+                                // It's trying to nest under an ordered item but has insufficient indentation
+                                format!(
+                                    "Nested list needs at least 3 spaces of indentation under ordered item (found {indent})"
+                                )
+                            } else if indent > 0 {
+                                // It's indented but not nested under anything - should start at column 0
+                                format!(
+                                    "Consider starting bulleted lists at the beginning of the line (found {indent} leading spaces)"
+                                )
+                            } else {
+                                // Shouldn't happen, but just in case
+                                format!("List indentation issue (found {indent} leading spaces)")
+                            };
+
                             result.push(LintWarning {
                                 line: item_line,
                                 column: start_col,
                                 end_line: item_line,
                                 end_column: end_col,
-                                message: format!(
-                                    "Consider starting bulleted lists at the beginning of the line (found {indent} leading spaces)"
-                                ),
+                                message,
                                 severity: Severity::Warning,
                                 rule_name: Some(self.name()),
                                 fix: Some(Fix {
@@ -501,14 +529,14 @@ mod tests {
         let content = "\
 1. **Active Directory/LDAP**
   - Wrong: only 2 spaces
-    - Also wrong: 4 spaces";
+ - Wrong: only 1 space";
         let ctx = crate::lint_context::LintContext::new(content);
         let result = rule.check(&ctx).unwrap();
-        // Should flag the incorrect indentations
+        // Should flag the incorrect indentations (less than 3 spaces)
         assert_eq!(
             result.len(),
             2,
-            "Expected warnings for bullets with incorrect spacing under numbered items"
+            "Expected warnings for bullets with insufficient spacing under numbered items"
         );
         assert!(result.iter().any(|w| w.line == 2));
         assert!(result.iter().any(|w| w.line == 3));

{rumdl-0.0.108 → rumdl-0.0.109}/src/rules/md011_no_reversed_links.rs

@@ -640,4 +640,19 @@ result = inspect.stack()[1]
         assert_eq!(result.len(), 1, "Should only flag the actual reversed link");
         assert_eq!(result[0].line, 4, "Should flag the reversed link on line 4");
     }
+
+    #[test]
+    fn test_issue_26_specific_case() {
+        // Test for issue #26 - specific case reported
+        let rule = MD011NoReversedLinks;
+
+        let content = r#"The first thing I need to find is the name of the redacted key name, `doc.<key_name_omitted>`. I'll use `SUBSTRING(ATTRIBUTES(doc)[0], 0, 1) == '<c>'` as that test, where `<c>` is different characters. This gets the first attribute from `doc` and uses `SUBSTRING` to get the first character."#;
+        let ctx = LintContext::new(content);
+        let result = rule.check(&ctx).unwrap();
+        assert_eq!(
+            result.len(),
+            0,
+            "Should not flag ATTRIBUTES(doc)[0] inside inline code (issue #26)"
+        );
+    }
 }

{rumdl-0.0.108 → rumdl-0.0.109}/src/rules/md029_ordered_list_prefix.rs

@@ -90,21 +90,33 @@ impl Rule for MD029OrderedListPrefix {
 
         let mut warnings = Vec::new();
 
-        // Group ordered list blocks that are only separated by code blocks
-        // This handles cases where the centralized system splits lists that should be continuous
-        let ordered_blocks: Vec<_> = ctx.list_blocks.iter().filter(|block| block.is_ordered).collect();
-
-        if ordered_blocks.is_empty() {
+        // Collect all list blocks that contain ordered items (not just purely ordered blocks)
+        // This handles mixed lists where ordered items are nested within unordered lists
+        let blocks_with_ordered: Vec<_> = ctx
+            .list_blocks
+            .iter()
+            .filter(|block| {
+                // Check if this block contains any ordered items
+                block.item_lines.iter().any(|&line| {
+                    ctx.line_info(line)
+                        .and_then(|info| info.list_item.as_ref())
+                        .map(|item| item.is_ordered)
+                        .unwrap_or(false)
+                })
+            })
+            .collect();
+
+        if blocks_with_ordered.is_empty() {
             return Ok(Vec::new());
         }
 
         // Group consecutive list blocks that should be treated as continuous
         let mut block_groups = Vec::new();
-        let mut current_group = vec![ordered_blocks[0]];
+        let mut current_group = vec![blocks_with_ordered[0]];
 
-        for i in 1..ordered_blocks.len() {
-            let prev_block = ordered_blocks[i - 1];
-            let current_block = ordered_blocks[i];
+        for i in 1..blocks_with_ordered.len() {
+            let prev_block = blocks_with_ordered[i - 1];
+            let current_block = blocks_with_ordered[i];
 
             // Check if there are only code blocks/fences between these list blocks
             let between_content_is_code_only =
@@ -411,6 +423,33 @@ impl MD029OrderedListPrefix {
         true
     }
 
+    /// Find the parent unordered item for an ordered item
+    /// Returns the line number of the parent, or 0 if no parent found
+    fn find_parent_unordered_item(
+        &self,
+        ctx: &crate::lint_context::LintContext,
+        ordered_line: usize,
+        ordered_indent: usize,
+    ) -> usize {
+        // Look backward from the ordered item to find its unordered parent
+        for line_num in (1..ordered_line).rev() {
+            if let Some(line_info) = ctx.line_info(line_num) {
+                if let Some(list_item) = &line_info.list_item {
+                    // Found a list item - check if it could be the parent
+                    if list_item.marker_column < ordered_indent && !list_item.is_ordered {
+                        // This unordered item is at a lower indentation, so it's the parent
+                        return line_num;
+                    }
+                }
+                // If we encounter non-blank, non-list content at column 0, stop looking
+                else if !line_info.is_blank && line_info.indent == 0 {
+                    break;
+                }
+            }
+        }
+        0 // No parent found
+    }
+
     /// Check a group of ordered list blocks that should be treated as continuous
     fn check_ordered_list_group(
         &self,
@@ -441,26 +480,31 @@ impl MD029OrderedListPrefix {
         // Sort by line number to ensure correct order
         all_items.sort_by_key(|(line_num, _, _)| *line_num);
 
-        // Group items by indentation level and process each level independently
-        let mut level_groups: std::collections::HashMap<
-            usize,
+        // Group items by indentation level AND parent context
+        // Use (indent_level, parent_line) as the key to separate sequences under different parents
+        type LevelGroups<'a> = std::collections::HashMap<
+            (usize, usize),
             Vec<(
                 usize,
-                &crate::lint_context::LineInfo,
-                &crate::lint_context::ListItemInfo,
+                &'a crate::lint_context::LineInfo,
+                &'a crate::lint_context::ListItemInfo,
             )>,
-        > = std::collections::HashMap::new();
+        >;
+        let mut level_groups: LevelGroups = std::collections::HashMap::new();
 
         for (line_num, line_info, list_item) in all_items {
-            // Group by marker column (indentation level)
+            // Find the parent unordered item for this ordered item
+            let parent_line = self.find_parent_unordered_item(ctx, line_num, list_item.marker_column);
+
+            // Group by both marker column (indentation level) and parent context
             level_groups
-                .entry(list_item.marker_column)
+                .entry((list_item.marker_column, parent_line))
                 .or_default()
                 .push((line_num, line_info, list_item));
         }
 
-        // Process each indentation level separately
-        for (_indent, mut group) in level_groups {
+        // Process each indentation level and parent context separately
+        for ((_indent, _parent), mut group) in level_groups {
             // Sort by line number to ensure correct order
             group.sort_by_key(|(line_num, _, _)| *line_num);
 

{rumdl-0.0.108 → rumdl-0.0.109}/src/rules/md033_no_inline_html.rs

@@ -299,6 +299,11 @@ impl Rule for MD033NoInlineHtml {
             if structure.is_in_code_block(line_num) {
                 continue;
             }
+            // Skip lines that are indented code blocks (4+ spaces or tab) per CommonMark spec
+            // Even if they're not in the structure's code blocks (e.g., HTML blocks)
+            if line.starts_with("    ") || line.starts_with('\t') {
+                continue;
+            }
 
             // Find all HTML tags in the line using regex
             for tag_match in HTML_TAG_FINDER.find_iter(line) {