rumdl 0.0.119__tar.gz → 0.0.120__tar.gz

{rumdl-0.0.119 → rumdl-0.0.120}/CHANGELOG.md

@@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.120] - 2025-08-16
+
 ## [0.0.119] - 2025-08-15
 
 ### Fixed
@@ -351,7 +353,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.119...HEAD
+[Unreleased]: https://github.com/rvben/rumdl/compare/v0.0.120...HEAD
+[0.0.120]: https://github.com/rvben/rumdl/compare/v0.0.119...v0.0.120
 [0.0.119]: https://github.com/rvben/rumdl/compare/v0.0.118...v0.0.119
 [0.0.118]: https://github.com/rvben/rumdl/compare/v0.0.117...v0.0.118
 [0.0.117]: https://github.com/rvben/rumdl/compare/v0.0.116...v0.0.117

{rumdl-0.0.119 → rumdl-0.0.120}/Cargo.lock

@@ -185,9 +185,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bitflags"
-version = "2.9.1"
+version = "2.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b8e56985ec62d17e9c1001dc89c88ecd7dc08e47eba5ec7c29c7b5eeecde967"
+checksum = "6a65b545ab31d687cff52899d4890855fec459eb6afe0da6417b8a18da87aa29"
 
 [[package]]
 name = "bstr"
@@ -220,9 +220,9 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
 [[package]]
 name = "cc"
-version = "1.2.32"
+version = "1.2.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2352e5597e9c544d5e6d9c95190d5d27738ade584fa8db0a16e130e5c2b5296e"
+checksum = "3ee0f8803222ba5a7e2777dd72ca451868909b1ac410621b676adf07280e9b5f"
 dependencies = [
  "shlex",
 ]
@@ -863,7 +863,7 @@ version = "0.7.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d93587f37623a1a17d94ef2bc9ada592f5465fe7732084ab7beefabe5c77c0c4"
 dependencies = [
- "bitflags 2.9.1",
+ "bitflags 2.9.2",
  "cfg-if",
  "libc",
 ]
@@ -1280,7 +1280,7 @@ checksum = "6fcdab19deb5195a31cf7726a210015ff1496ba1464fd42cb4f537b8b01b471f"
 dependencies = [
  "bit-set",
  "bit-vec",
- "bitflags 2.9.1",
+ "bitflags 2.9.2",
  "lazy_static",
  "num-traits",
  "rand",
@@ -1298,7 +1298,7 @@ version = "0.12.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f86ba2052aebccc42cbbb3ed234b8b13ce76f75c3551a303cb2bcffcff12bb14"
 dependencies = [
- "bitflags 2.9.1",
+ "bitflags 2.9.2",
  "getopts",
  "memchr",
  "pulldown-cmark-escape",
@@ -1459,7 +1459,7 @@ version = "0.5.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5407465600fb0548f1442edf71dd20683c6ed326200ace4b1ef0763521bb3b77"
 dependencies = [
- "bitflags 2.9.1",
+ "bitflags 2.9.2",
 ]
 
 [[package]]
@@ -1493,7 +1493,7 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "rumdl"
-version = "0.0.119"
+version = "0.0.120"
 dependencies = [
  "anyhow",
  "assert_cmd",
@@ -1555,7 +1555,7 @@ version = "1.0.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "11181fbabf243db407ef8df94a6ce0b2f9a733bd8be4ad02b4eda9602296cac8"
 dependencies = [
- "bitflags 2.9.1",
+ "bitflags 2.9.2",
  "errno",
  "libc",
  "linux-raw-sys",
@@ -1723,9 +1723,9 @@ checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 
 [[package]]
 name = "syn"
-version = "2.0.105"
+version = "2.0.106"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7bc3fcb250e53458e712715cf74285c1f889686520d79294a9ef3bd7aa1fc619"
+checksum = "ede7c438028d4436d71104916910f5bb611972c5cfd7f89b8300a8186e6fada6"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2434,7 +2434,7 @@ version = "0.39.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1"
 dependencies = [
- "bitflags 2.9.1",
+ "bitflags 2.9.2",
 ]
 
 [[package]]

{rumdl-0.0.119 → rumdl-0.0.120}/Cargo.toml

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

{rumdl-0.0.119 → rumdl-0.0.120}/PKG-INFO

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

{rumdl-0.0.119 → rumdl-0.0.120}/src/lint_context.rs

@@ -1,4 +1,4 @@
-use crate::utils::code_block_utils::CodeBlockUtils;
+use crate::utils::code_block_utils::{CodeBlockContext, CodeBlockUtils};
 use lazy_static::lazy_static;
 use regex::Regex;
 
@@ -1352,31 +1352,37 @@ impl<'a> LintContext<'a> {
         for (line_idx, line_info) in lines.iter().enumerate() {
             let line_num = line_idx + 1;
 
-            // Handle code blocks - they should continue the list if properly indented
+            // Enhanced code block handling using Design #3's context analysis
             if line_info.in_code_block {
                 if let Some(ref mut block) = current_block {
-                    // For code blocks to continue a list, they need to be indented
-                    // at least 2 spaces beyond the list marker
                     // Calculate minimum indentation for list continuation
-                    // For ordered lists, use the last marker width (e.g., 3 for "1. ", 4 for "10. ")
-                    // For unordered lists like "- ", content starts at column 2, so continuations need at least 2 spaces
-                    let min_continuation_indent = if block.is_ordered {
-                        current_indent_level + last_marker_width
-                    } else {
-                        current_indent_level + 2 // Unordered lists need at least 2 spaces (e.g., "- " = 2 chars)
-                    };
+                    let min_continuation_indent = CodeBlockUtils::calculate_min_continuation_indent(lines, line_idx);
 
-                    if line_info.indent >= min_continuation_indent {
-                        // Code blocks at list continuation level should continue the list
-                        block.end_line = line_num;
-                        continue;
+                    // Analyze code block context using the three-tier classification
+                    let context = CodeBlockUtils::analyze_code_block_context(lines, line_idx, min_continuation_indent);
+
+                    match context {
+                        CodeBlockContext::Indented => {
+                            // Code block is properly indented - continues the list
+                            block.end_line = line_num;
+                            continue;
+                        }
+                        CodeBlockContext::Standalone => {
+                            // Code block separates lists - end current block
+                            let completed_block = current_block.take().unwrap();
+                            list_blocks.push(completed_block);
+                            continue;
+                        }
+                        CodeBlockContext::Adjacent => {
+                            // Edge case - use conservative behavior (continue list)
+                            block.end_line = line_num;
+                            continue;
+                        }
                     }
+                } else {
+                    // No current list block - skip code block lines
+                    continue;
                 }
-                // If we have a current block and hit a non-indented code block, end it
-                if let Some(block) = current_block.take() {
-                    list_blocks.push(block);
-                }
-                continue;
             }
 
             // Extract blockquote prefix if any
@@ -1409,17 +1415,18 @@ impl<'a> LintContext<'a> {
                     // Check if there's non-list content between the last item and this one
                     let has_non_list_content = {
                         let mut found_non_list = false;
-                        for check_line in (last_list_item_line + 1)..line_num {
+                        // Use the last item from the current block, not the global last_list_item_line
+                        let block_last_item_line = block.item_lines.last().copied().unwrap_or(block.end_line);
+                        for check_line in (block_last_item_line + 1)..line_num {
                             let check_idx = check_line - 1;
                             if check_idx < lines.len() {
                                 let check_info = &lines[check_idx];
-                                if !check_info.is_blank && !check_info.in_code_block && check_info.list_item.is_none() {
-                                    // Found non-blank, non-list content
-                                    // Check if it's indented enough to be a continuation
-                                    // Get the marker width of the last list item
+                                // Check for content that breaks the list
+                                let is_list_breaking_content = if check_info.in_code_block {
+                                    // Use enhanced code block classification for list separation
                                     let last_item_marker_width =
-                                        if last_list_item_line > 0 && last_list_item_line <= lines.len() {
-                                            lines[last_list_item_line - 1]
+                                        if block_last_item_line > 0 && block_last_item_line <= lines.len() {
+                                            lines[block_last_item_line - 1]
                                                 .list_item
                                                 .as_ref()
                                                 .map(|li| {
@@ -1435,11 +1442,61 @@ impl<'a> LintContext<'a> {
                                         };
 
                                     let min_continuation = if block.is_ordered { last_item_marker_width } else { 2 };
-                                    if check_info.indent < min_continuation {
-                                        // Not indented enough, so it breaks the list
-                                        found_non_list = true;
-                                        break;
+
+                                    // Analyze code block context using our enhanced classification
+                                    let context = CodeBlockUtils::analyze_code_block_context(
+                                        lines,
+                                        check_line - 1,
+                                        min_continuation,
+                                    );
+
+                                    // Standalone code blocks break lists, indented ones continue them
+                                    matches!(context, CodeBlockContext::Standalone)
+                                } else if !check_info.is_blank && check_info.list_item.is_none() {
+                                    // Check for structural separators that should break lists (from issue #42)
+                                    let line_content = check_info.content.trim();
+
+                                    // Any of these structural separators break lists
+                                    if check_info.heading.is_some()
+                                        || line_content.starts_with("---")
+                                        || line_content.starts_with("***")
+                                        || line_content.starts_with("___")
+                                        || line_content.contains('|')
+                                        || line_content.starts_with(">")
+                                    {
+                                        true
+                                    }
+                                    // Other non-list content - check if properly indented
+                                    else {
+                                        let last_item_marker_width =
+                                            if block_last_item_line > 0 && block_last_item_line <= lines.len() {
+                                                lines[block_last_item_line - 1]
+                                                    .list_item
+                                                    .as_ref()
+                                                    .map(|li| {
+                                                        if li.is_ordered {
+                                                            li.marker.len() + 1 // Add 1 for the space after ordered list markers
+                                                        } else {
+                                                            li.marker.len()
+                                                        }
+                                                    })
+                                                    .unwrap_or(3) // fallback to 3 if no list item found
+                                            } else {
+                                                3 // fallback
+                                            };
+
+                                        let min_continuation =
+                                            if block.is_ordered { last_item_marker_width } else { 2 };
+                                        check_info.indent < min_continuation
                                     }
+                                } else {
+                                    false
+                                };
+
+                                if is_list_breaking_content {
+                                    // Not indented enough, so it breaks the list
+                                    found_non_list = true;
+                                    break;
                                 }
                             }
                         }
@@ -1574,8 +1631,9 @@ impl<'a> LintContext<'a> {
                                 && item.is_ordered == block.is_ordered
                                 && block.blockquote_prefix.trim() == next_blockquote_prefix.trim()
                             {
-                                // Check if there was meaningful content between the list items
-                                let has_meaningful_content = (line_idx + 1..check_idx).any(|idx| {
+                                // Check if there was meaningful content between the list items (unused now)
+                                // This variable is kept for potential future use but is currently replaced by has_structural_separators
+                                let _has_meaningful_content = (line_idx + 1..check_idx).any(|idx| {
                                     if let Some(between_line) = lines.get(idx) {
                                         let trimmed = between_line.content.trim();
                                         // Skip empty lines
@@ -1585,21 +1643,72 @@ impl<'a> LintContext<'a> {
                                         // Check for meaningful content
                                         let line_indent =
                                             between_line.content.len() - between_line.content.trim_start().len();
-                                        // Code fences or properly indented content
-                                        trimmed.starts_with("```")
+
+                                        // Structural separators (code fences, headings, etc.) are meaningful and should BREAK lists
+                                        if trimmed.starts_with("```")
                                             || trimmed.starts_with("~~~")
-                                            || line_indent >= min_continuation_indent
+                                            || trimmed.starts_with("---")
+                                            || trimmed.starts_with("***")
+                                            || trimmed.starts_with("___")
+                                            || trimmed.starts_with(">")
+                                            || trimmed.contains('|') // Tables
+                                            || between_line.heading.is_some()
+                                        {
+                                            return true; // These are structural separators - meaningful content that breaks lists
+                                        }
+
+                                        // Only properly indented content continues the list
+                                        line_indent >= min_continuation_indent
                                     } else {
                                         false
                                     }
                                 });
 
                                 if block.is_ordered {
-                                    // For ordered lists: only continue if there's meaningful content
-                                    found_continuation = has_meaningful_content;
+                                    // For ordered lists: don't continue if there are structural separators
+                                    // Check if there are structural separators between the list items
+                                    let has_structural_separators = (line_idx + 1..check_idx).any(|idx| {
+                                        if let Some(between_line) = lines.get(idx) {
+                                            let trimmed = between_line.content.trim();
+                                            if trimmed.is_empty() {
+                                                return false;
+                                            }
+                                            // Check for structural separators that break lists
+                                            trimmed.starts_with("```")
+                                                || trimmed.starts_with("~~~")
+                                                || trimmed.starts_with("---")
+                                                || trimmed.starts_with("***")
+                                                || trimmed.starts_with("___")
+                                                || trimmed.starts_with(">")
+                                                || trimmed.contains('|') // Tables
+                                                || between_line.heading.is_some()
+                                        } else {
+                                            false
+                                        }
+                                    });
+                                    found_continuation = !has_structural_separators;
                                 } else {
-                                    // For unordered lists: continue regardless
-                                    found_continuation = true;
+                                    // For unordered lists: also check for structural separators
+                                    let has_structural_separators = (line_idx + 1..check_idx).any(|idx| {
+                                        if let Some(between_line) = lines.get(idx) {
+                                            let trimmed = between_line.content.trim();
+                                            if trimmed.is_empty() {
+                                                return false;
+                                            }
+                                            // Check for structural separators that break lists
+                                            trimmed.starts_with("```")
+                                                || trimmed.starts_with("~~~")
+                                                || trimmed.starts_with("---")
+                                                || trimmed.starts_with("***")
+                                                || trimmed.starts_with("___")
+                                                || trimmed.starts_with(">")
+                                                || trimmed.contains('|') // Tables
+                                                || between_line.heading.is_some()
+                                        } else {
+                                            false
+                                        }
+                                    });
+                                    found_continuation = !has_structural_separators;
                                 }
                             }
                         }
@@ -1625,8 +1734,19 @@ impl<'a> LintContext<'a> {
                     // For lazy continuation to apply, the line must either:
                     // 1. Have no indentation (true lazy continuation)
                     // 2. Have sufficient indentation for the list type
+                    // BUT structural separators (headings, code blocks, etc.) should never be lazy continuations
+                    let line_content = line_info.content.trim();
+                    let is_structural_separator = line_info.heading.is_some()
+                        || line_content.starts_with("```")
+                        || line_content.starts_with("~~~")
+                        || line_content.starts_with("---")
+                        || line_content.starts_with("***")
+                        || line_content.starts_with("___")
+                        || line_content.starts_with(">")
+                        || line_content.contains('|'); // Tables
+
                     let is_lazy_continuation = last_list_item_line == line_num - 1
-                        && line_info.heading.is_none()
+                        && !is_structural_separator
                         && !line_info.is_blank
                         && (line_info.indent == 0 || line_info.indent >= min_required_indent);
 
@@ -2075,14 +2195,25 @@ impl<'a> ListBlockMerger<'a> {
 
     /// Check if unordered lists can be merged with a single blank line between
     fn can_merge_with_blank_between(&self, current: &ListBlock, next: &ListBlock) -> bool {
+        // Check if there are structural separators between the blocks
+        // If has_meaningful_content_between returns true, it means there are structural separators
+        if has_meaningful_content_between(current, next, self.lines) {
+            return false; // Structural separators prevent merging
+        }
+
         // Only merge unordered lists with same marker across single blank
         !current.is_ordered && current.marker == next.marker
     }
 
     /// Check if ordered lists can be merged when there's content between them
     fn can_merge_with_content_between(&self, current: &ListBlock, next: &ListBlock) -> bool {
-        // Only consider merging ordered lists with meaningful content between
-        current.is_ordered && next.is_ordered && has_meaningful_content_between(current, next, self.lines)
+        // Do not merge lists if there are structural separators between them
+        if has_meaningful_content_between(current, next, self.lines) {
+            return false; // Structural separators prevent merging
+        }
+
+        // Only consider merging ordered lists if there's no structural content between
+        current.is_ordered && next.is_ordered
     }
 
     /// Check if there are only blank lines between blocks
@@ -2141,33 +2272,90 @@ fn has_meaningful_content_between(current: &ListBlock, next: &ListBlock, lines:
                 continue;
             }
 
+            // Check for structural separators that should separate lists (CommonMark compliant)
+
+            // Headings separate lists
+            if line_info.heading.is_some() {
+                return true; // Has meaningful content - headings separate lists
+            }
+
+            // Horizontal rules separate lists (---, ***, ___)
+            if is_horizontal_rule(trimmed) {
+                return true; // Has meaningful content - horizontal rules separate lists
+            }
+
+            // Tables separate lists (lines containing |)
+            if trimmed.contains('|') && trimmed.len() > 1 {
+                return true; // Has meaningful content - tables separate lists
+            }
+
+            // Blockquotes separate lists
+            if trimmed.starts_with('>') {
+                return true; // Has meaningful content - blockquotes separate lists
+            }
+
+            // Code block fences separate lists (unless properly indented as list content)
+            if trimmed.starts_with("```") || trimmed.starts_with("~~~") {
+                let line_indent = line_info.content.len() - line_info.content.trim_start().len();
+
+                // Check if this code block is properly indented as list continuation
+                let min_continuation_indent = if current.is_ordered {
+                    current.nesting_level + current.max_marker_width
+                } else {
+                    current.nesting_level + 2
+                };
+
+                if line_indent < min_continuation_indent {
+                    // This is a standalone code block that separates lists
+                    return true; // Has meaningful content - standalone code blocks separate lists
+                }
+            }
+
             // Check if this line has proper indentation for list continuation
             let line_indent = line_info.content.len() - line_info.content.trim_start().len();
 
-            // If the line is indented enough to be list continuation content, it's meaningful
-            // For ordered lists, use actual marker width; for unordered, 2 spaces
+            // Calculate minimum indentation needed to be list continuation
             let min_indent = if current.is_ordered {
                 current.nesting_level + current.max_marker_width
             } else {
                 current.nesting_level + 2
             };
 
-            // Check if the line has sufficient indentation to be a continuation
-            if line_indent >= min_indent {
-                return true;
-            }
-
-            // Code fences are meaningful content
-            if trimmed.starts_with("```") || trimmed.starts_with("~~~") {
-                return true;
+            // If the line is not indented enough to be list continuation, it's meaningful content
+            if line_indent < min_indent {
+                return true; // Has meaningful content - content not indented as list continuation
             }
 
-            // Any other non-blank content at this level breaks the sequence
-            return false;
+            // If we reach here, the line is properly indented as list continuation
+            // Continue checking other lines
         }
     }
 
-    // Only blank lines between blocks - should not merge
+    // Only blank lines or properly indented list continuation content between blocks
+    false
+}
+
+/// Check if a line is a horizontal rule (---, ***, ___)
+fn is_horizontal_rule(trimmed: &str) -> bool {
+    if trimmed.len() < 3 {
+        return false;
+    }
+
+    // Check for three or more consecutive -, *, or _ characters (with optional spaces)
+    let chars: Vec<char> = trimmed.chars().collect();
+    if let Some(&first_char) = chars.first()
+        && (first_char == '-' || first_char == '*' || first_char == '_')
+    {
+        let mut count = 0;
+        for &ch in &chars {
+            if ch == first_char {
+                count += 1;
+            } else if ch != ' ' && ch != '\t' {
+                return false; // Non-matching, non-whitespace character
+            }
+        }
+        return count >= 3;
+    }
     false
 }