rumdl 0.0.135__tar.gz → 0.0.136__tar.gz

{rumdl-0.0.135 → rumdl-0.0.136}/CHANGELOG.md

@@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.136] - 2025-09-03
+
 ## [0.0.135] - 2025-09-03
 
 ## [0.0.134] - 2025-09-02
@@ -560,7 +562,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.135...HEAD
+[Unreleased]: https://github.com/rvben/rumdl/compare/v0.0.136...HEAD
+[0.0.136]: https://github.com/rvben/rumdl/compare/v0.0.135...v0.0.136
 [0.0.135]: https://github.com/rvben/rumdl/compare/v0.0.134...v0.0.135
 [0.0.134]: https://github.com/rvben/rumdl/compare/v0.0.133...v0.0.134
 [0.0.133]: https://github.com/rvben/rumdl/compare/v0.0.132...v0.0.133

{rumdl-0.0.135 → rumdl-0.0.136}/Cargo.lock

@@ -1632,7 +1632,7 @@ checksum = "caf4aa5b0f434c91fe5c7f1ecb6a5ece2130b02ad2a590589dda5146df959001"
 
 [[package]]
 name = "rumdl"
-version = "0.0.135"
+version = "0.0.136"
 dependencies = [
  "anyhow",
  "assert_cmd",

{rumdl-0.0.135 → rumdl-0.0.136}/Cargo.toml

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

{rumdl-0.0.135 → rumdl-0.0.136}/PKG-INFO

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

{rumdl-0.0.135 → rumdl-0.0.136}/src/rules/md009_trailing_spaces.rs

@@ -153,7 +153,10 @@ impl Rule for MD009TrailingSpaces {
                         trimmed.len() + 1,
                         trailing_spaces,
                     ),
-                    replacement: if !self.config.strict && !is_truly_last_line && trailing_spaces > 0 {
+                    replacement: if !self.config.strict
+                        && !is_truly_last_line
+                        && trailing_spaces == self.config.br_spaces
+                    {
                         " ".repeat(self.config.br_spaces)
                     } else {
                         String::new()
@@ -236,11 +239,15 @@ impl Rule for MD009TrailingSpaces {
                 false
             };
 
-            // In non-strict mode, preserve line breaks by normalizing to br_spaces
+            // In non-strict mode, preserve line breaks ONLY if they have exactly br_spaces
             // BUT: Never preserve trailing spaces in headings or empty blockquotes as they serve no purpose
-            if !self.config.strict && !is_truly_last_line && trailing_spaces > 0 && !is_heading && !is_empty_blockquote
+            if !self.config.strict
+                && !is_truly_last_line
+                && trailing_spaces == self.config.br_spaces
+                && !is_heading
+                && !is_empty_blockquote
             {
-                // Optimize for common case of 2 spaces
+                // Preserve the exact number of spaces for hard line breaks
                 match self.config.br_spaces {
                     0 => {}
                     1 => result.push(' '),
@@ -330,7 +337,10 @@ mod tests {
         let content = "Line with spaces   \nAnother line  \nClean line";
         let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Standard);
         let fixed = rule.fix(&ctx).unwrap();
-        assert_eq!(fixed, "Line with spaces  \nAnother line  \nClean line");
+        // Line 1: 3 spaces -> removed (doesn't match br_spaces=2)
+        // Line 2: 2 spaces -> kept (matches br_spaces=2)
+        // Line 3: no spaces -> unchanged
+        assert_eq!(fixed, "Line with spaces\nAnother line  \nClean line");
     }
 
     #[test]
@@ -366,19 +376,19 @@ mod tests {
         let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Standard);
         let result = rule.check(&ctx).unwrap();
         // br_spaces=2, so lines with exactly 2 spaces are OK
-        // Line 2 has 3 spaces (will be normalized to 2)
+        // Line 2 has 3 spaces (should be removed, not normalized)
         // Line 3 has 1 space and is last line without newline (will be removed)
         assert_eq!(result.len(), 2);
         assert_eq!(result[0].line, 2);
         assert_eq!(result[1].line, 3);
 
         let fixed = rule.fix(&ctx).unwrap();
-        // Line 1: keeps 2 spaces
-        // Line 2: normalized from 3 to 2 spaces
+        // Line 1: keeps 2 spaces (exact match with br_spaces)
+        // Line 2: removes all 3 spaces (doesn't match br_spaces)
         // Line 3: last line without newline, spaces removed
         assert_eq!(
             fixed,
-            "Line with two spaces  \nLine with three spaces  \nLine with one space"
+            "Line with two spaces  \nLine with three spaces\nLine with one space"
         );
     }
 
@@ -586,14 +596,16 @@ mod tests {
         let content = "> > Nested  \n> >   \n> Normal  ";
         let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Standard);
         let result = rule.check(&ctx).unwrap();
-        // Line 2 has empty blockquote, line 3 is last line without newline
+        // Line 2 has empty blockquote with 3 spaces, line 3 is last line without newline
         assert_eq!(result.len(), 2);
         assert_eq!(result[0].line, 2);
         assert_eq!(result[1].line, 3);
 
         let fixed = rule.fix(&ctx).unwrap();
-        // The fix adds a single space after empty blockquote markers
-        assert_eq!(fixed, "> > Nested  \n> >  \n> Normal");
+        // Line 1: Keeps 2 spaces (exact match with br_spaces)
+        // Line 2: Empty blockquote with 3 spaces -> removes all (doesn't match br_spaces)
+        // Line 3: Last line without newline -> removes all spaces
+        assert_eq!(fixed, "> > Nested  \n> >\n> Normal");
     }
 
     #[test]
@@ -608,4 +620,65 @@ mod tests {
         assert_eq!(result.len(), 1);
         assert_eq!(result[0].line, 2);
     }
+
+    #[test]
+    fn test_issue_80_no_space_normalization() {
+        // Test for GitHub issue #80 - MD009 should not add spaces when removing trailing spaces
+        let rule = MD009TrailingSpaces::new(2, false); // br_spaces=2
+
+        // Test that 1 trailing space is removed, not normalized to 2
+        let content = "Line with one space \nNext line";
+        let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Standard);
+        let result = rule.check(&ctx).unwrap();
+        assert_eq!(result.len(), 1);
+        assert_eq!(result[0].line, 1);
+        assert_eq!(result[0].message, "Trailing space found");
+
+        let fixed = rule.fix(&ctx).unwrap();
+        assert_eq!(fixed, "Line with one space\nNext line");
+
+        // Test that 3 trailing spaces are removed, not normalized to 2
+        let content = "Line with three spaces   \nNext line";
+        let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Standard);
+        let result = rule.check(&ctx).unwrap();
+        assert_eq!(result.len(), 1);
+        assert_eq!(result[0].line, 1);
+        assert_eq!(result[0].message, "3 trailing spaces found");
+
+        let fixed = rule.fix(&ctx).unwrap();
+        assert_eq!(fixed, "Line with three spaces\nNext line");
+
+        // Test that exactly 2 trailing spaces are preserved
+        let content = "Line with two spaces  \nNext line";
+        let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Standard);
+        let result = rule.check(&ctx).unwrap();
+        assert_eq!(result.len(), 0); // Should not flag lines with exact br_spaces
+
+        let fixed = rule.fix(&ctx).unwrap();
+        assert_eq!(fixed, "Line with two spaces  \nNext line");
+    }
+
+    #[test]
+    fn test_different_br_spaces_values() {
+        // Test with br_spaces=0 (no trailing spaces allowed)
+        let rule = MD009TrailingSpaces::new(0, false);
+        let content = "Line with one space \nLine with two spaces  ";
+        let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Standard);
+        let result = rule.check(&ctx).unwrap();
+        assert_eq!(result.len(), 2); // Both lines should be flagged
+
+        let fixed = rule.fix(&ctx).unwrap();
+        assert_eq!(fixed, "Line with one space\nLine with two spaces");
+
+        // Test with br_spaces=1 (exactly 1 trailing space for line breaks)
+        let rule = MD009TrailingSpaces::new(1, false);
+        let content = "Line with one space \nLine with two spaces  ";
+        let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Standard);
+        let result = rule.check(&ctx).unwrap();
+        assert_eq!(result.len(), 1); // Only line 2 should be flagged
+        assert_eq!(result[0].line, 2);
+
+        let fixed = rule.fix(&ctx).unwrap();
+        assert_eq!(fixed, "Line with one space \nLine with two spaces");
+    }
 }

{rumdl-0.0.135 → rumdl-0.0.136}/src/rules/md013_line_length.rs

@@ -8,6 +8,7 @@ use crate::utils::range_utils::calculate_excess_range;
 use crate::utils::regex_cache::{
     IMAGE_REF_PATTERN, INLINE_LINK_REGEX as MARKDOWN_LINK_PATTERN, LINK_REF_PATTERN, URL_IN_TEXT, URL_PATTERN,
 };
+use crate::utils::table_utils::TableUtils;
 use toml;
 
 pub mod md013_config;
@@ -36,24 +37,6 @@ impl MD013LineLength {
         Self { config }
     }
 
-    fn is_in_table(lines: &[&str], current_line: usize) -> bool {
-        // Check if current line is part of a table
-        let current = lines[current_line].trim();
-        if current.starts_with('|') || current.starts_with("|-") {
-            return true;
-        }
-
-        // Check if line is between table markers
-        if current_line > 0 && current_line + 1 < lines.len() {
-            let prev = lines[current_line - 1].trim();
-            let next = lines[current_line + 1].trim();
-            if (prev.starts_with('|') || prev.starts_with("|-")) && (next.starts_with('|') || next.starts_with("|-")) {
-                return true;
-            }
-        }
-        false
-    }
-
     fn should_ignore_line(
         &self,
         line: &str,
@@ -203,24 +186,21 @@ impl Rule for MD013LineLength {
         // Create a quick lookup set for heading lines
         let heading_lines_set: std::collections::HashSet<usize> = structure.heading_lines.iter().cloned().collect();
 
-        // Pre-compute table lines using the same logic as is_in_table function
+        // Use TableUtils to find all table blocks in the document
+        let table_blocks = TableUtils::find_table_blocks(content, ctx);
+
+        // Pre-compute table lines from the table blocks
         let table_lines_set: std::collections::HashSet<usize> = {
             let mut table_lines = std::collections::HashSet::new();
 
-            for (i, _line) in lines.iter().enumerate() {
-                let line_number = i + 1;
-
-                // Quick check if in code block using pre-computed blocks from context or structure
-                let in_code = if !ctx.code_blocks.is_empty() {
-                    ctx.code_blocks
-                        .iter()
-                        .any(|(start, end)| *start <= line_number && line_number <= *end)
-                } else {
-                    structure.is_in_code_block(line_number)
-                };
-
-                if !in_code && Self::is_in_table(&lines, i) {
-                    table_lines.insert(line_number);
+            for table in &table_blocks {
+                // Add header line
+                table_lines.insert(table.header_line + 1); // Convert 0-indexed to 1-indexed
+                // Add delimiter line
+                table_lines.insert(table.delimiter_line + 1);
+                // Add all content lines
+                for &line in &table.content_lines {
+                    table_lines.insert(line + 1); // Convert 0-indexed to 1-indexed
                 }
             }
             table_lines
@@ -393,7 +373,8 @@ impl MD013LineLength {
         }
 
         // Skip tables (they have complex formatting)
-        if Self::is_in_table(&[line], 0) {
+        // Check if line looks like a table row
+        if TableUtils::is_potential_table_row(line) {
             return true;
         }
 
@@ -568,19 +549,6 @@ mod tests {
         assert_eq!(result.len(), 0);
     }
 
-    #[test]
-    fn test_table_detection() {
-        let lines = vec![
-            "| Column 1 | Column 2 |",
-            "|----------|----------|",
-            "| Value 1  | Value 2  |",
-        ];
-
-        assert!(MD013LineLength::is_in_table(&lines, 0));
-        assert!(MD013LineLength::is_in_table(&lines, 1));
-        assert!(MD013LineLength::is_in_table(&lines, 2));
-    }
-
     #[test]
     fn test_table_checked_when_enabled() {
         let rule = MD013LineLength::new(30, false, true, false, false);
@@ -591,6 +559,74 @@ mod tests {
         assert_eq!(result.len(), 2); // Both table lines exceed limit
     }
 
+    #[test]
+    fn test_issue_78_tables_after_fenced_code_blocks() {
+        // Test for GitHub issue #78 - tables with tables=false after fenced code blocks
+        let rule = MD013LineLength::new(20, false, false, false, false); // tables=false
+        let content = r#"# heading
+
+```plain
+some code block longer than 20 chars length
+```
+
+this is a very long line
+
+| column A | column B |
+| -------- | -------- |
+| `var` | `val` |
+| value 1 | value 2 |
+
+correct length line"#;
+        let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Standard);
+        let result = rule.check(&ctx).unwrap();
+
+        // Should only flag line 7 ("this is a very long line"), not the table lines
+        assert_eq!(result.len(), 1, "Should only flag 1 line (the non-table long line)");
+        assert_eq!(result[0].line, 7, "Should flag line 7");
+        assert!(result[0].message.contains("24 exceeds 20"));
+    }
+
+    #[test]
+    fn test_issue_78_tables_with_inline_code() {
+        // Test that tables with inline code (backticks) are properly detected as tables
+        let rule = MD013LineLength::new(20, false, false, false, false); // tables=false
+        let content = r#"| column A | column B |
+| -------- | -------- |
+| `var with very long name` | `val exceeding limit` |
+| value 1 | value 2 |
+
+This line exceeds limit"#;
+        let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Standard);
+        let result = rule.check(&ctx).unwrap();
+
+        // Should only flag the last line, not the table lines
+        assert_eq!(result.len(), 1, "Should only flag the non-table line");
+        assert_eq!(result[0].line, 6, "Should flag line 6");
+    }
+
+    #[test]
+    fn test_issue_78_indented_code_blocks() {
+        // Test with indented code blocks instead of fenced
+        let rule = MD013LineLength::new(20, false, false, false, false); // tables=false
+        let content = r#"# heading
+
+    some code block longer than 20 chars length
+
+this is a very long line
+
+| column A | column B |
+| -------- | -------- |
+| value 1 | value 2 |
+
+correct length line"#;
+        let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Standard);
+        let result = rule.check(&ctx).unwrap();
+
+        // Should only flag line 5 ("this is a very long line"), not the table lines
+        assert_eq!(result.len(), 1, "Should only flag 1 line (the non-table long line)");
+        assert_eq!(result[0].line, 5, "Should flag line 5");
+    }
+
     #[test]
     fn test_url_exemption() {
         let rule = MD013LineLength::new(30, false, false, false, false);

{rumdl-0.0.135 → rumdl-0.0.136}/src/rules/md034_no_bare_urls.rs

@@ -769,9 +769,12 @@ mod tests {
         );
 
         // Performance assertion - should complete reasonably fast
+        // Note: In debug builds this may take longer, so we use a higher threshold
+        let max_duration_ms = if cfg!(debug_assertions) { 1000 } else { 100 };
         assert!(
-            avg_check_duration.as_millis() < 100,
-            "MD034 check should complete in under 100ms, took {}ms",
+            avg_check_duration.as_millis() < max_duration_ms,
+            "MD034 check should complete in under {}ms, took {}ms",
+            max_duration_ms,
             avg_check_duration.as_millis()
         );
 

{rumdl-0.0.135 → rumdl-0.0.136}/tests/comprehensive_output_format_tests.rs

@@ -250,11 +250,9 @@ fn test_output_format_with_fix_mode() {
 
     // Verify the file was actually fixed
     let fixed_content = fs::read_to_string(&test_file).unwrap();
-    // In non-strict mode, MD009 normalizes trailing spaces to 2 spaces (for line breaks)
-    assert!(
-        fixed_content.contains("  \n"),
-        "Trailing spaces should be normalized to 2 spaces"
-    );
+    // MD009 removes trailing spaces that don't match br_spaces (default 2)
+    // Since the content had 3 spaces, they should be removed
+    assert!(!fixed_content.contains("   "), "Trailing spaces (3) should be removed");
     assert!(
         fixed_content.contains("\n\n"),
         "Blank line should be added after heading"

{rumdl-0.0.135 → rumdl-0.0.136}/tests/rules/md009_test.rs

@@ -77,9 +77,13 @@ fn test_md009_fix() {
     let content = "Line with spaces   \nAnother line  \nNo spaces\n  \n```\nCode   \n```\n";
     let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard);
     let result = rule.fix(&ctx).unwrap();
+    // Default br_spaces=2, so only lines with exactly 2 spaces are preserved
+    // Line 1: 3 spaces -> removed
+    // Line 2: 2 spaces -> preserved
+    // Line 4: 2 spaces (empty line) -> removed
     assert_eq!(
         result,
-        "Line with spaces  \nAnother line  \nNo spaces\n\n```\nCode   \n```\n"
+        "Line with spaces\nAnother line  \nNo spaces\n\n```\nCode   \n```\n"
     );
 }
 
@@ -157,9 +161,11 @@ fn test_md009_fix_preserves_line_breaks() {
     let content = "Line with one space \nLine with two  \nLine with three   \nLine with four    \n";
     let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard);
     let result = rule.fix(&ctx).unwrap();
+    // Only lines with exactly 2 spaces (br_spaces) are preserved
+    // Lines with 1, 3, or 4 spaces have them removed
     assert_eq!(
         result,
-        "Line with one space  \nLine with two  \nLine with three  \nLine with four  \n"
+        "Line with one space\nLine with two  \nLine with three\nLine with four\n"
     );
 }
 
@@ -297,7 +303,9 @@ fn test_md009_fix_with_crlf() {
     let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard);
     let result = rule.fix(&ctx).unwrap();
     // The fix normalizes to \n line endings
-    assert_eq!(result, "Line one  \nLine two  \n");
+    // Line 1: 2 spaces -> preserved (matches br_spaces=2)
+    // Line 2: 3 spaces -> removed (doesn't match br_spaces=2)
+    assert_eq!(result, "Line one  \nLine two\n");
 }
 
 #[test]
@@ -317,10 +325,12 @@ fn test_md009_fix_complex_document() {
         "# Title   \n\nParagraph  \n\n- List   \n  - Nested  \n\n```\ncode   \n```\n\n> Quote   \n>    \n\nEnd  ";
     let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard);
     let result = rule.fix(&ctx).unwrap();
-    // Headings should have all trailing spaces removed, regular text preserves 2 spaces for line breaks
+    // Headings should have all trailing spaces removed
+    // Lines with exactly 2 spaces are preserved
+    // Lines with 3 spaces are removed
     assert_eq!(
         result,
-        "# Title\n\nParagraph  \n\n- List  \n  - Nested  \n\n```\ncode   \n```\n\n> Quote  \n>\n\nEnd" // Empty blockquote line trailing spaces removed
+        "# Title\n\nParagraph  \n\n- List\n  - Nested  \n\n```\ncode   \n```\n\n> Quote\n>\n\nEnd" // Empty blockquote line trailing spaces removed
     );
 }
 

{rumdl-0.0.135 → rumdl-0.0.136}/tests/rules/md013_test.rs

@@ -346,13 +346,15 @@ fn test_code_blocks_configurable() {
 
 #[test]
 fn test_tables_configurable() {
-    let content = "| This is a very long table cell | Another very long table cell that exceeds limit |";
+    // Use a proper table with header and delimiter
+    let content = "| This is a very long table cell | Another very long table cell that exceeds limit |\n|----------------------------------|---------------------------------------------------|";
     let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard);
 
     // With tables = true (check tables - include in line length checking)
     let rule_check = MD013LineLength::new(50, true, true, true, false);
     let result_check = rule_check.check(&ctx).unwrap();
-    assert_eq!(result_check.len(), 1);
+    // Both lines exceed 50 characters
+    assert_eq!(result_check.len(), 2);
 
     // With tables = false (skip tables - exclude from line length checking)
     let rule_skip = MD013LineLength::new(50, true, false, true, false);