rumdl 0.0.69__tar.gz → 0.0.70__tar.gz

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

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

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

@@ -1,6 +1,6 @@
 [package]
 name = "rumdl"
-version = "0.0.69"
+version = "0.0.70"
 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.70}/PKG-INFO

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

{rumdl-0.0.69 → rumdl-0.0.70}/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.70}/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);
+}