rumdl 0.0.75__tar.gz → 0.0.76__tar.gz

{rumdl-0.0.75 → rumdl-0.0.76}/Cargo.lock

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

{rumdl-0.0.75 → rumdl-0.0.76}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rumdl"
-version = "0.0.75"
+version = "0.0.76"
 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.75 → rumdl-0.0.76}/PKG-INFO

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

{rumdl-0.0.75 → rumdl-0.0.76}/src/rules/md005_list_indent.rs

@@ -96,6 +96,12 @@ impl MD005ListIndent {
     }
 }
 
+impl Default for MD005ListIndent {
+    fn default() -> Self {
+        Self
+    }
+}
+
 impl Rule for MD005ListIndent {
     fn name(&self) -> &'static str {
         "MD005"

{rumdl-0.0.75 → rumdl-0.0.76}/src/rules/md006_start_bullets.rs

@@ -237,20 +237,21 @@ impl Rule for MD006StartBullets {
                 valid_bullet_lines[line_idx] = is_valid;
 
                 if !is_valid {
-                    let fixed_line = line.trim_start();
-                    let needs_blank_line = line_idx > 0
-                        && !Self::is_blank_line(lines[line_idx - 1])
-                        && Self::is_bullet_list_item(lines[line_idx - 1]).is_none();
-                    let replacement = if needs_blank_line {
-                        format!("\n{}", fixed_line)
+                    // Calculate the precise range for the indentation that needs to be removed
+                    // For "  * Indented bullet", we want to highlight just the indentation and marker "  *" (columns 1-3)
+                    let start_col = 1; // Start from beginning of line
+                    let end_col = indent + 2; // Include the marker (indent + 1 for marker position + 1 for inclusive range)
+
+                    // For the fix, we need to replace the highlighted part ("  *") with just the bullet marker ("* ")
+                    let line = lines[line_idx];
+                    let trimmed = line.trim_start();
+                    // Extract just the bullet marker and normalize to single space
+                    let bullet_part = if let Some(captures) = BULLET_PATTERN.captures(trimmed) {
+                        format!("{} ", captures.get(2).unwrap().as_str()) // Always use single space
                     } else {
-                        fixed_line.to_string()
+                        "* ".to_string() // fallback
                     };
-
-                    // 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
+                    let replacement = bullet_part;
 
                     result.push(LintWarning {
                 rule_name: Some(self.name()),
@@ -261,7 +262,7 @@ impl Rule for MD006StartBullets {
                 end_column: end_col,
                 message: "List item indentation".to_string(),
                 fix: Some(Fix {
-                range: line_index.line_col_to_byte_range(line_num, 1),
+                range: line_index.line_col_to_byte_range(line_num, start_col),
                 replacement,
             }),
                     });

{rumdl-0.0.75 → rumdl-0.0.76}/src/rules/md011_no_reversed_links.rs

@@ -169,6 +169,12 @@ impl MD011NoReversedLinks {
     }
 }
 
+impl Default for MD011NoReversedLinks {
+    fn default() -> Self {
+        Self
+    }
+}
+
 impl Rule for MD011NoReversedLinks {
     fn name(&self) -> &'static str {
         "MD011"

{rumdl-0.0.75 → rumdl-0.0.76}/src/rules/md019_no_multiple_space_atx.rs

@@ -132,11 +132,14 @@ impl Rule for MD019NoMultipleSpaceAtx {
 
                 // Calculate precise range: highlight the extra spaces (all spaces after the first one)
                 let hash_end_col = hashes.end() + 1; // 1-indexed, position after hashes
-                let extra_spaces_start = hash_end_col + 1; // Skip the first (correct) space
-                let extra_spaces_len = spaces - 1; // Number of extra spaces
+                let spaces_start_col = hash_end_col; // Start of all spaces after hashes
+                let spaces_len = spaces; // Length of all spaces
 
                 let (start_line, start_col, end_line, end_col) =
-                    calculate_single_line_range(line_num, extra_spaces_start, extra_spaces_len);
+                    calculate_single_line_range(line_num, spaces_start_col, spaces_len);
+
+                // Generate the correct replacement text (just one space)
+                let correct_spacing = " ";
 
                 warnings.push(LintWarning {
                     rule_name: Some(self.name()),
@@ -151,8 +154,8 @@ impl Rule for MD019NoMultipleSpaceAtx {
                     end_column: end_col,
                     severity: Severity::Warning,
                     fix: Some(Fix {
-                        range: line_index.line_col_to_byte_range(line_num, 1),
-                        replacement: self.fix_atx_heading(line),
+                        range: line_index.line_col_to_byte_range(line_num, start_col),
+                        replacement: correct_spacing.to_string(),
                     }),
                 });
             }

{rumdl-0.0.75 → rumdl-0.0.76}/src/rules/md021_no_multiple_space_closed_atx.rs

@@ -3,7 +3,7 @@
 /// See [docs/md021.md](../../docs/md021.md) for full documentation, configuration, and examples.
 use crate::rule::{Fix, LintError, LintResult, LintWarning, Rule, RuleCategory, Severity};
 use crate::utils::document_structure::{DocumentStructure, DocumentStructureExtensions};
-use crate::utils::range_utils::calculate_single_line_range;
+use crate::utils::range_utils::{calculate_single_line_range, LineIndex};
 use lazy_static::lazy_static;
 use regex::Regex;
 
@@ -69,31 +69,6 @@ impl MD021NoMultipleSpaceClosedAtx {
             (0, 0)
         }
     }
-
-    // Calculate the byte range for a specific line in the content
-    fn get_line_byte_range(&self, content: &str, line_num: usize) -> std::ops::Range<usize> {
-        let mut current_line = 1;
-        let mut start_byte = 0;
-
-        for (i, c) in content.char_indices() {
-            if current_line == line_num && c == '\n' {
-                return start_byte..i;
-            } else if c == '\n' {
-                current_line += 1;
-                if current_line == line_num {
-                    start_byte = i + 1;
-                }
-            }
-        }
-
-        // If we're looking for the last line and it doesn't end with a newline
-        if current_line == line_num {
-            return start_byte..content.len();
-        }
-
-        // Fallback if line not found (shouldn't happen)
-        0..0
-    }
 }
 
 impl Rule for MD021NoMultipleSpaceClosedAtx {
@@ -149,6 +124,7 @@ impl Rule for MD021NoMultipleSpaceClosedAtx {
             return Ok(Vec::new());
         }
 
+        let line_index = LineIndex::new(ctx.content.to_string());
         let mut warnings = Vec::new();
         let lines: Vec<&str> = ctx.content.lines().collect();
 
@@ -191,28 +167,30 @@ impl Rule for MD021NoMultipleSpaceClosedAtx {
                     )
                 };
 
-                let line_range = self.get_line_byte_range(ctx.content, line_num);
-
                 // Calculate precise character range for the extra spaces
                 let start_col;
                 let length;
+                let replacement;
 
                 if start_spaces > 1 && end_spaces > 1 {
-                    // Highlight the extra spaces at the start (after opening hashes)
+                    // Fix the extra spaces at the start (after opening hashes)
                     let opening_hashes = captures.get(2).unwrap();
                     start_col = opening_hashes.end() + 2; // After hash + first space
                     length = start_spaces - 1; // Extra spaces only
+                    replacement = String::new(); // Remove extra spaces
                 } else if start_spaces > 1 {
-                    // Highlight the extra spaces after opening hashes
+                    // Fix the extra spaces after opening hashes
                     let opening_hashes = captures.get(2).unwrap();
                     start_col = opening_hashes.end() + 2; // After hash + first space
                     length = start_spaces - 1; // Extra spaces only
+                    replacement = String::new(); // Remove extra spaces
                 } else {
-                    // Highlight the extra spaces before closing hashes
+                    // Fix the extra spaces before closing hashes
                     let content = captures.get(4).unwrap();
                     start_col = content.end() + 2; // After content + first space
                     length = end_spaces - 1; // Extra spaces only
-                }
+                    replacement = String::new(); // Remove extra spaces
+                };
 
                 let (start_line, start_col_calc, end_line, end_col) =
                     calculate_single_line_range(line_num, start_col, length);
@@ -226,8 +204,8 @@ impl Rule for MD021NoMultipleSpaceClosedAtx {
                     end_column: end_col,
                     severity: Severity::Warning,
                     fix: Some(Fix {
-                        range: line_range,
-                        replacement: self.fix_closed_atx_heading(line),
+                        range: line_index.line_col_to_byte_range(start_line, start_col_calc),
+                        replacement,
                     }),
                 });
             }

{rumdl-0.0.75 → rumdl-0.0.76}/src/rules/md023_heading_start_left.rs

@@ -81,13 +81,12 @@ impl Rule for MD023HeadingStartLeft {
                             end_column: end_col,
                             severity: Severity::Warning,
                             message: format!(
-                                "Setext heading should not be indented by {
-            } spaces",
+                                "Setext heading should not be indented by {} spaces",
                                 indentation
                             ),
                             fix: Some(Fix {
-                                range: line_index.line_col_to_byte_range(start_line + 1, 1),
-                                replacement: heading_text.to_string(),
+                                range: line_index.line_col_to_byte_range(start_line + 1, start_col),
+                                replacement: String::new(), // Remove the indentation
                             }),
                         });
 
@@ -117,8 +116,8 @@ impl Rule for MD023HeadingStartLeft {
                                 message: "Setext heading underline should not be indented"
                                     .to_string(),
                                 fix: Some(Fix {
-                                    range: line_index.line_col_to_byte_range(underline_line + 1, 1),
-                                    replacement: underline_text.to_string(),
+                                    range: line_index.line_col_to_byte_range(underline_line + 1, underline_start_col),
+                                    replacement: String::new(), // Remove the indentation
                                 }),
                             });
                         }
@@ -168,13 +167,12 @@ impl Rule for MD023HeadingStartLeft {
                         end_column: atx_end_col,
                         severity: Severity::Warning,
                         message: format!(
-                            "Heading should not be indented by {
-            } spaces",
+                            "Heading should not be indented by {} spaces",
                             indentation
                         ),
                         fix: Some(Fix {
-                            range: line_index.line_col_to_byte_range(start_line + 1, 1),
-                            replacement: fixed_heading,
+                            range: line_index.line_col_to_byte_range(start_line + 1, atx_start_col),
+                            replacement: String::new(), // Remove the indentation
                         }),
                     });
                 }
@@ -350,13 +348,12 @@ impl Rule for MD023HeadingStartLeft {
                             end_column: setext_end_col,
                             severity: Severity::Warning,
                             message: format!(
-                                "Setext heading should not be indented by {
-            } spaces",
+                                "Setext heading should not be indented by {} spaces",
                                 indentation
                             ),
                             fix: Some(Fix {
-                                range: line_index.line_col_to_byte_range(line_num, 1),
-                                replacement: heading_text.to_string(),
+                                range: line_index.line_col_to_byte_range(line_num, setext_start_col),
+                                replacement: String::new(), // Remove the indentation
                             }),
                         });
 
@@ -387,8 +384,8 @@ impl Rule for MD023HeadingStartLeft {
                                     .to_string(),
                                 fix: Some(Fix {
                                     range: line_index
-                                        .line_col_to_byte_range(underline_line_idx + 1, 1),
-                                    replacement: underline_text.to_string(),
+                                        .line_col_to_byte_range(underline_line_idx + 1, underline_start_col_struct),
+                                    replacement: String::new(), // Remove the indentation
                                 }),
                             });
                         }
@@ -450,13 +447,12 @@ impl Rule for MD023HeadingStartLeft {
                         end_column: atx_end_col_struct,
                         severity: Severity::Warning,
                         message: format!(
-                            "Heading should not be indented by {
-            } spaces",
+                            "Heading should not be indented by {} spaces",
                             indentation
                         ),
                         fix: Some(Fix {
-                            range: line_index.line_col_to_byte_range(line_num, 1),
-                            replacement: fixed_heading,
+                            range: line_index.line_col_to_byte_range(line_num, atx_start_col_struct),
+                            replacement: String::new(), // Remove the indentation
                         }),
                     });
                 }

{rumdl-0.0.75 → rumdl-0.0.76}/src/rules/md027_multiple_spaces_blockquote.rs

@@ -83,8 +83,8 @@ impl Rule for MD027MultipleSpacesBlockquote {
                         message: "Multiple spaces after blockquote symbol".to_string(),
                         severity: Severity::Warning,
                         fix: Some(Fix {
-                            range: _line_index.line_col_to_byte_range(i + 1, indentation.len() + 1),
-                            replacement: format!("> {}", actual_content.trim_start()),
+                            range: _line_index.line_col_to_byte_range(i + 1, start_col),
+                            replacement: " ".to_string(), // Just one space
                         }),
                     });
                     line_processed = true;

{rumdl-0.0.75 → rumdl-0.0.76}/src/rules/md028_no_blanks_blockquote.rs

@@ -25,6 +25,12 @@ impl MD028NoBlanksBlockquote {
     }
 }
 
+impl Default for MD028NoBlanksBlockquote {
+    fn default() -> Self {
+        Self
+    }
+}
+
 impl Rule for MD028NoBlanksBlockquote {
     fn name(&self) -> &'static str {
         "MD028"

{rumdl-0.0.75 → rumdl-0.0.76}/src/rules/md030_list_marker_space.rs

@@ -114,33 +114,21 @@ impl Rule for MD030ListMarkerSpace {
                     // Calculate precise character range for the problematic spacing
                     let marker_end_pos = cap.get(2).map_or(0, |m| m.end());
                     let whitespace_start_pos = marker_end_pos;
-                    let _whitespace_len = whitespace.len();
-
-                    // If we have expected spaces, highlight only the extra ones
-                    let extra_spaces_start = if whitespace.len() > expected_spaces {
-                        whitespace_start_pos + expected_spaces
-                    } else {
-                        whitespace_start_pos
-                    };
-                    let extra_spaces_len = if whitespace.len() > expected_spaces {
-                        whitespace.len() - expected_spaces
-                    } else {
-                        whitespace.len()
-                    };
+                    let whitespace_len = whitespace.len();
 
+                    // Calculate the range that needs to be replaced (the entire whitespace after marker)
                     let (start_line, start_col, end_line, end_col) =
-                        calculate_match_range(line_num, line, extra_spaces_start, extra_spaces_len);
-
-                    // Generate the fix text
-                    let fix =
-                        self.try_fix_list_marker_spacing(line)
-                            .map(|fixed_line| crate::rule::Fix {
-                                range: crate::utils::range_utils::LineIndex::new(
-                                    ctx.content.to_string(),
-                                )
-                                .line_col_to_byte_range(line_num, 1),
-                                replacement: fixed_line,
-                            });
+                        calculate_match_range(line_num, line, whitespace_start_pos, whitespace_len);
+
+                    // Generate the correct replacement text (just the correct spacing)
+                    let correct_spaces = " ".repeat(expected_spaces);
+                    let fix = Some(crate::rule::Fix {
+                        range: crate::utils::range_utils::LineIndex::new(
+                            ctx.content.to_string(),
+                        )
+                        .line_col_to_byte_range(line_num, start_col),
+                        replacement: correct_spaces,
+                    });
 
                     warnings.push(LintWarning {
                         rule_name: Some(self.name()),

{rumdl-0.0.75 → rumdl-0.0.76}/src/rules/md031_blanks_around_fences.rs

@@ -25,6 +25,12 @@ impl MD031BlanksAroundFences {
     }
 }
 
+impl Default for MD031BlanksAroundFences {
+    fn default() -> Self {
+        Self
+    }
+}
+
 impl Rule for MD031BlanksAroundFences {
     fn name(&self) -> &'static str {
         "MD031"

{rumdl-0.0.75 → rumdl-0.0.76}/src/rules/md037_spaces_around_emphasis.rs

@@ -231,6 +231,12 @@ fn has_spacing_issues(span: &EmphasisSpan) -> bool {
 #[derive(Clone)]
 pub struct MD037NoSpaceInEmphasis;
 
+impl Default for MD037NoSpaceInEmphasis {
+    fn default() -> Self {
+        Self
+    }
+}
+
 impl Rule for MD037NoSpaceInEmphasis {
     fn name(&self) -> &'static str {
         "MD037"

{rumdl-0.0.75 → rumdl-0.0.76}/tests/character_ranges/basic_tests.rs

@@ -40,7 +40,7 @@ fn test_md019_multiple_spaces_atx() {
     let test = simple_test(
         "MD019",
         "##  Heading with multiple spaces",
-        ExpectedWarning::new(1, 4, 1, 5, " "),
+        ExpectedWarning::new(1, 3, 1, 5, "  "),
     );
     test_character_ranges(test);
 }

{rumdl-0.0.75 → rumdl-0.0.76}/tests/character_ranges/extended_tests.rs

@@ -11,7 +11,7 @@ fn test_md006_start_bullets() {
     let test = simple_test(
         "MD006",
         "  - Indented bullet",
-        ExpectedWarning::new(1, 2, 1, 5, " - "),
+        ExpectedWarning::new(1, 1, 1, 4, "  -"),
     );
     test_character_ranges(test);
 }
@@ -121,7 +121,7 @@ fn test_md030_list_marker_space() {
     let test = simple_test(
         "MD030",
         "-  Two spaces",
-        ExpectedWarning::new(1, 3, 1, 4, " "),
+        ExpectedWarning::new(1, 2, 1, 4, "  "),
     );
     test_character_ranges(test);
 }

{rumdl-0.0.75 → rumdl-0.0.76}/tests/rules/md019_test.rs

@@ -19,7 +19,7 @@ fn test_invalid_atx_headings() {
     let result = rule.check(&ctx).unwrap();
     assert_eq!(result.len(), 3);
     assert_eq!(result[0].line, 1);
-    assert_eq!(result[0].column, 3);
+    assert_eq!(result[0].column, 2);
     assert_eq!(
         result[0].message,
         "Multiple spaces (2) after # in ATX style heading"