rumdl 0.0.69__tar.gz → 0.0.71__tar.gz

{rumdl-0.0.69 → rumdl-0.0.71}/Cargo.lock

@@ -1789,7 +1789,7 @@ dependencies = [
 
 [[package]]
 name = "rumdl"
-version = "0.0.69"
+version = "0.0.71"
 dependencies = [
  "anyhow",
  "assert_cmd",

{rumdl-0.0.69 → rumdl-0.0.71}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rumdl"
-version = "0.0.69"
+version = "0.0.71"
 edition = "2021"
 description = "A fast Markdown linter written in Rust (Ru(st) MarkDown Linter)"
 authors = ["Ruben J. Jongejan <ruben.jongejan@gmail.com>"]

{rumdl-0.0.69 → rumdl-0.0.71}/PKG-INFO

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

{rumdl-0.0.69 → rumdl-0.0.71}/src/rules/md006_start_bullets.rs

@@ -25,14 +25,14 @@ lazy_static! {
 }
 
 impl MD006StartBullets {
-    /// Check if a line is a bullet list item and return the indentation level
+    /// Checks if a line is a bullet list item and returns its indentation level
     fn is_bullet_list_item(line: &str) -> Option<usize> {
-        if let Some(caps) = BULLET_PATTERN.captures(line) {
-            let indent = caps.get(1).unwrap().as_str().len();
-            Some(indent)
-        } else {
-            None
+        if let Some(captures) = BULLET_PATTERN.captures(line) {
+            if let Some(indent) = captures.get(1) {
+                return Some(indent.as_str().len());
+            }
         }
+        None
     }
 
     /// Checks if a line is blank (empty or whitespace only)
@@ -46,7 +46,9 @@ impl MD006StartBullets {
             Some(indent) => indent,
             None => return None, // Should not happen if called on a bullet item
         };
+
         let mut i = line_idx;
+
         while i > 0 {
             i -= 1;
             if Self::is_blank_line(lines[i]) {
@@ -54,13 +56,36 @@ impl MD006StartBullets {
             }
             if let Some(prev_indent) = Self::is_bullet_list_item(lines[i]) {
                 if prev_indent <= current_indent {
-                    return Some((i, prev_indent));
+                    // Found a potential parent or sibling
+                    // Check if there's any non-list content between this potential parent and current item
+                    let mut has_breaking_content = false;
+                    for check_idx in (i + 1)..line_idx {
+                        if Self::is_blank_line(lines[check_idx]) {
+                            continue;
+                        }
+                        if Self::is_bullet_list_item(lines[check_idx]).is_none() {
+                            // Found non-list content - check if it breaks the list structure
+                            let content_indent = lines[check_idx].len() - lines[check_idx].trim_start().len();
+                            // Content is only acceptable if it's indented at least as much as current item
+                            // AND we have a true parent relationship (prev_indent < current_indent)
+                            if content_indent < current_indent || prev_indent >= current_indent {
+                                has_breaking_content = true;
+                                break;
+                            }
+                        }
+                    }
+
+                    if !has_breaking_content {
+                        return Some((i, prev_indent));
+                    } else {
+                        // Content breaks the list structure
+                        return None;
+                    }
                 }
                 // If prev_indent > current_indent, it's a child of a sibling, ignore it and keep searching.
-            }
-            // If we hit non-list content, stop searching
-            if Self::is_bullet_list_item(lines[i]).is_none() {
-                break;
+            } else {
+                // Found non-list content - this breaks the search
+                return None;
             }
         }
         None
@@ -156,36 +181,25 @@ impl Rule for MD006StartBullets {
         doc_structure: &DocumentStructure,
     ) -> LintResult {
         let content = _ctx.content;
-
-        // Early returns for performance
-        if content.is_empty() || doc_structure.list_lines.is_empty() {
+        if doc_structure.list_lines.is_empty() {
             return Ok(Vec::new());
         }
-
-        // Quick check for any list markers before processing
         if !content.contains('*') && !content.contains('-') && !content.contains('+') {
             return Ok(Vec::new());
         }
-
-        // Pre-compute LineIndex once for all operations
         let line_index = LineIndex::new(content.to_string());
         let mut result = Vec::new();
         let lines: Vec<&str> = content.lines().collect();
         let mut valid_bullet_lines = vec![false; lines.len()];
-
-        // Process list lines in order for better cache locality
         for &line_num in &doc_structure.list_lines {
             let line_idx = line_num - 1;
             if line_idx >= lines.len() {
                 continue;
             }
             let line = lines[line_idx];
-
-            // Skip lines in code blocks
             if doc_structure.is_in_code_block(line_num) {
                 continue;
             }
-
             if let Some(indent) = Self::is_bullet_list_item(line) {
                 let mut is_valid = false; // Assume invalid initially
                 if indent == 0 {
@@ -220,19 +234,25 @@ impl Rule for MD006StartBullets {
                     } else {
                         fixed_line.to_string()
                     };
+
+                    // Calculate the range to highlight: from first indentation character to end of list marker
+                    let start_col = if indent > 0 { 2 } else { 1 }; // Start from first indentation space if indented
+                    let marker_pos = line.find(|c: char| c == '*' || c == '-' || c == '+').unwrap_or(0);
+                    let end_col = marker_pos + 3; // +1 for the marker itself, +1 for 1-based indexing, +1 for space after marker
+
                     result.push(LintWarning {
-                        rule_name: Some(self.name()),
-                        severity: Severity::Warning,
-                        line: line_num,
-                        column: indent,
-                        end_line: line_num,
-                        end_column: indent + 3,
-                        message: "Consider starting bulleted lists at the beginning of the line"
-                            .to_string(),
-                        fix: Some(Fix {
-                            range: line_index.line_col_to_byte_range(line_num, 1),
-                            replacement,
-                        }),
+                rule_name: Some(self.name()),
+                severity: Severity::Warning,
+                line: line_num,
+                column: start_col,
+                end_line: line_num,
+                end_column: end_col,
+                message: "List item should start at the beginning of the line (remove indentation)"
+                .to_string(),
+                fix: Some(Fix {
+                range: line_index.line_col_to_byte_range(line_num, 1),
+                replacement,
+            }),
                     });
                 }
             }

{rumdl-0.0.69 → rumdl-0.0.71}/src/rules/md012_no_multiple_blanks.rs

@@ -23,6 +23,19 @@ impl MD012NoMultipleBlanks {
         Self { maximum }
     }
 
+    #[cfg(test)]
+    pub fn debug_regions(lines: &[&str]) -> (Vec<(usize, usize)>, Vec<(usize, usize)>) {
+        let code_regions = Self::compute_code_block_regions(lines);
+        let front_matter_regions = Self::compute_front_matter_regions(lines);
+        println!("Lines:");
+        for (i, line) in lines.iter().enumerate() {
+            println!("  {}: {:?}", i, line);
+        }
+        println!("Code block regions: {:?}", code_regions);
+        println!("Front matter regions: {:?}", front_matter_regions);
+        (code_regions, front_matter_regions)
+    }
+
     /// Pre-compute code block regions for efficient lookup
     fn compute_code_block_regions(lines: &[&str]) -> Vec<(usize, usize)> {
         let mut regions = Vec::new();
@@ -48,6 +61,43 @@ impl MD012NoMultipleBlanks {
             regions.push((start_line, lines.len() - 1));
         }
 
+        // Second pass: detect indented code blocks (4+ spaces)
+        let mut in_indented_block = false;
+        let mut indented_start = 0;
+
+        for (i, line) in lines.iter().enumerate() {
+            // Skip lines that are already in fenced code blocks
+            if Self::is_in_regions(i, &regions) {
+                continue;
+            }
+
+            let is_indented_code = line.len() >= 4 && line.starts_with("    ") && !line.trim().is_empty();
+            let is_blank = line.trim().is_empty();
+
+            if is_indented_code {
+                if !in_indented_block {
+                    // Start of indented code block
+                    indented_start = i;
+                    in_indented_block = true;
+                }
+            } else if !is_blank {
+                // Non-blank, non-indented line ends the indented code block
+                if in_indented_block {
+                    regions.push((indented_start, i - 1));
+                    in_indented_block = false;
+                }
+            }
+            // Blank lines don't end indented code blocks, they're part of them
+        }
+
+        // Handle indented code block at end of file
+        if in_indented_block {
+            regions.push((indented_start, lines.len() - 1));
+        }
+
+        // Sort regions by start position
+        regions.sort_by(|a, b| a.0.cmp(&b.0));
+
         regions
     }
 
@@ -130,6 +180,11 @@ impl Rule for MD012NoMultipleBlanks {
             if Self::is_in_regions(line_num, &code_block_regions)
                 || Self::is_in_regions(line_num, &front_matter_regions)
             {
+                // Reset blank line counting when entering a code block or front matter
+                // to prevent counting blank lines across block boundaries
+                if blank_count > 0 {
+                    blank_count = 0;
+                }
                 continue;
             }
 

{rumdl-0.0.69 → rumdl-0.0.71}/src/rules/md030_list_marker_space.rs

@@ -149,7 +149,11 @@ impl Rule for MD030ListMarkerSpace {
                         column: start_col,
                         end_line,
                         end_column: end_col,
-                        message: "Spaces after list markers".to_string(),
+                        message: format!(
+                            "Spaces after list markers (Expected: {}; Actual: {})",
+                            expected_spaces,
+                            whitespace.len()
+                        ),
                         fix,
                     });
                 }
@@ -420,7 +424,11 @@ mod tests {
             "Should flag lines with too many spaces after list marker"
         );
         for warning in result {
-            assert_eq!(warning.message, "Spaces after list markers");
+            assert!(
+                warning.message.starts_with("Spaces after list markers (Expected:") && warning.message.contains("Actual:"),
+                "Warning message should include expected and actual values, got: '{}'",
+                warning.message
+            );
         }
     }
 }

{rumdl-0.0.69 → rumdl-0.0.71}/tests/rules/md012_test.rs

@@ -131,3 +131,95 @@ fn test_md012_whitespace_lines() {
         "Multiple consecutive blank lines between content (Expected: 1; Actual: 2)"
     );
 }
+
+#[test]
+fn test_md012_indented_code_blocks() {
+    let rule = MD012NoMultipleBlanks::default();
+    let content = "Line 1\n\n    code block\n\n    more code\n\nLine 2\n";
+    let ctx = LintContext::new(content);
+    let result = rule.check(&ctx).unwrap();
+    assert!(result.is_empty()); // Multiple blank lines in indented code blocks are allowed
+}
+
+#[test]
+fn test_md012_indented_fenced_code_blocks() {
+    let rule = MD012NoMultipleBlanks::default();
+    let content = "Text\n\n    ```bash\n    code\n    ```\n\nMore text\n";
+    let ctx = LintContext::new(content);
+    let result = rule.check(&ctx).unwrap();
+    assert!(result.is_empty()); // Should not flag blank lines around indented fenced code blocks
+}
+
+#[test]
+fn test_md012_debug_indented_fenced() {
+    let content = "Text\n\n    ```bash\n    code\n    ```\n\nMore text\n";
+    let lines: Vec<&str> = content.lines().collect();
+
+    // Debug the regions
+    println!("Lines:");
+    for (i, line) in lines.iter().enumerate() {
+        println!("  {}: {:?}", i, line);
+    }
+
+    // Test the rule
+    let rule = MD012NoMultipleBlanks::default();
+    let ctx = LintContext::new(content);
+    let result = rule.check(&ctx).unwrap();
+
+    println!("Warnings: {:?}", result);
+    for warning in &result {
+        println!("  Line {}: {}", warning.line, warning.message);
+    }
+
+    // This should pass but currently fails
+    assert!(result.is_empty(), "Expected no warnings, got: {:?}", result);
+}
+
+#[test]
+fn test_md012_contributing_pattern() {
+    // This reproduces the exact pattern from the CONTRIBUTING file that's causing false positives
+    let content = "To set up the MLflow repository, run the following commands:\n\n    ```bash\n    # Clone the repository\n    git clone --recurse-submodules git@github.com:<username>/mlflow.git\n    # The alternative way of cloning through https may cause permission error during branch push\n";
+
+    let rule = MD012NoMultipleBlanks::default();
+    let ctx = LintContext::new(content);
+    let result = rule.check(&ctx).unwrap();
+
+    println!("Content lines:");
+    for (i, line) in content.lines().enumerate() {
+        println!("  {}: {:?}", i, line);
+    }
+
+    println!("Warnings: {:?}", result);
+    for warning in &result {
+        println!("  Line {}: {}", warning.line, warning.message);
+    }
+
+    // This should pass - there's only 1 blank line before the indented fenced code block
+    assert!(result.is_empty(), "Expected no warnings, got: {:?}", result);
+}
+
+#[test]
+fn test_md012_region_calculation() {
+    // Test with a simple fenced code block to debug region calculation
+    let content = "Text\n\n```bash\ncode\n```\n\nMore text\n";
+    let lines: Vec<&str> = content.lines().collect();
+
+    println!("Lines:");
+    for (i, line) in lines.iter().enumerate() {
+        println!("  {}: {:?}", i, line);
+    }
+
+    // We need to access the compute_code_block_regions function somehow
+    // For now, let's just test the rule behavior
+    let rule = MD012NoMultipleBlanks::default();
+    let ctx = LintContext::new(content);
+    let result = rule.check(&ctx).unwrap();
+
+    println!("Warnings: {:?}", result);
+    for warning in &result {
+        println!("  Line {}: {}", warning.line, warning.message);
+    }
+
+    // This should pass - there's only 1 blank line before and after the code block
+    assert!(result.is_empty(), "Expected no warnings, got: {:?}", result);
+}

{rumdl-0.0.69 → rumdl-0.0.71}/tests/rules/md030_test.rs

@@ -29,7 +29,11 @@ mod tests {
         let result = rule.check(&ctx).unwrap();
         assert_eq!(result.len(), 2);
         for warning in result {
-            assert_eq!(warning.message, "Spaces after list markers");
+            assert!(
+                warning.message.starts_with("Spaces after list markers (Expected:") && warning.message.contains("Actual:"),
+                "Warning message should include expected and actual values, got: '{}'",
+                warning.message
+            );
         }
     }
 
@@ -41,7 +45,11 @@ mod tests {
         let result = rule.check(&ctx).unwrap();
         assert_eq!(result.len(), 2);
         for warning in result {
-            assert_eq!(warning.message, "Spaces after list markers");
+            assert!(
+                warning.message.starts_with("Spaces after list markers (Expected:") && warning.message.contains("Actual:"),
+                "Warning message should include expected and actual values, got: '{}'",
+                warning.message
+            );
         }
     }
 
@@ -139,7 +147,11 @@ mod tests {
         let ctx = LintContext::new(content);
         let result = rule.check(&ctx).unwrap();
         assert_eq!(result.len(), 1);
-        assert_eq!(result[0].message, "Spaces after list markers");
+        assert!(
+            result[0].message.starts_with("Spaces after list markers (Expected:") && result[0].message.contains("Actual:"),
+            "Warning message should include expected and actual values, got: '{}'",
+            result[0].message
+        );
     }
 
     #[test]
@@ -149,7 +161,11 @@ mod tests {
         let ctx = LintContext::new(content);
         let result = rule.check(&ctx).unwrap();
         assert_eq!(result.len(), 1);
-        assert_eq!(result[0].message, "Spaces after list markers");
+        assert!(
+            result[0].message.starts_with("Spaces after list markers (Expected:") && result[0].message.contains("Actual:"),
+            "Warning message should include expected and actual values, got: '{}'",
+            result[0].message
+        );
     }
 
     #[test]
@@ -159,7 +175,11 @@ mod tests {
         let ctx = LintContext::new(content);
         let result = rule.check(&ctx).unwrap();
         assert_eq!(result.len(), 1);
-        assert_eq!(result[0].message, "Spaces after list markers");
+        assert!(
+            result[0].message.starts_with("Spaces after list markers (Expected:") && result[0].message.contains("Actual:"),
+            "Warning message should include expected and actual values, got: '{}'",
+            result[0].message
+        );
     }
 
     #[test]
@@ -169,7 +189,11 @@ mod tests {
         let ctx = LintContext::new(content);
         let result = rule.check(&ctx).unwrap();
         assert_eq!(result.len(), 1);
-        assert_eq!(result[0].message, "Spaces after list markers");
+        assert!(
+            result[0].message.starts_with("Spaces after list markers (Expected:") && result[0].message.contains("Actual:"),
+            "Warning message should include expected and actual values, got: '{}'",
+            result[0].message
+        );
     }
 
     #[test]
@@ -179,7 +203,11 @@ mod tests {
         let ctx = LintContext::new(content);
         let result = rule.check(&ctx).unwrap();
         assert_eq!(result.len(), 1);
-        assert_eq!(result[0].message, "Spaces after list markers");
+        assert!(
+            result[0].message.starts_with("Spaces after list markers (Expected:") && result[0].message.contains("Actual:"),
+            "Warning message should include expected and actual values, got: '{}'",
+            result[0].message
+        );
     }
 
     #[test]