rumdl 0.0.70__tar.gz → 0.0.72__tar.gz

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

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

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

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

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

{rumdl-0.0.70 → rumdl-0.0.72}/src/lib.rs

@@ -70,7 +70,7 @@ impl ContentCharacteristics {
             {
                 chars.has_lists = true;
             }
-            if !chars.has_links && line.contains('[') {
+            if !chars.has_links && (line.contains('[') || line.contains("http://") || line.contains("https://") || line.contains("ftp://")) {
                 chars.has_links = true;
             }
             if !chars.has_images && line.contains("![") {

{rumdl-0.0.70 → rumdl-0.0.72}/src/rules/md001_heading_increment.rs

@@ -162,7 +162,7 @@ impl Rule for MD001HeadingIncrement {
                     column: start_col,
                     end_line,
                     end_column: end_col,
-                    message: format!("Heading level should be {} for this level", prev_level + 1),
+                    message: format!("Expected heading level {}", prev_level + 1),
                     severity: Severity::Warning,
                     fix: Some(Fix {
                         range: line_index.line_col_to_byte_range(line_num, indentation + 1),

{rumdl-0.0.70 → rumdl-0.0.72}/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.70 → rumdl-0.0.72}/src/rules/md009_trailing_spaces.rs

@@ -100,7 +100,7 @@ impl Rule for MD009TrailingSpaces {
                         column: start_col,
                         end_line,
                         end_column: end_col,
-                        message: "Empty line should not have trailing spaces".to_string(),
+                        message: "Empty line has trailing spaces".to_string(),
                         severity: Severity::Warning,
                         fix: Some(Fix {
                             range: _line_index.line_col_to_byte_range(line_num + 1, 1),
@@ -134,7 +134,7 @@ impl Rule for MD009TrailingSpaces {
                     column: start_col,
                     end_line,
                     end_column: end_col,
-                    message: "Empty blockquote line should have a space after >".to_string(),
+                    message: "Empty blockquote line needs a space after >".to_string(),
                     severity: Severity::Warning,
                     fix: Some(Fix {
                         range: _line_index.line_col_to_byte_range(line_num + 1, trimmed.len() + 1),

{rumdl-0.0.70 → rumdl-0.0.72}/src/rules/md011_no_reversed_links.rs

@@ -146,3 +146,88 @@ impl Rule for MD011NoReversedLinks {
         Box::new(MD011NoReversedLinks)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::lint_context::LintContext;
+
+    #[test]
+    fn test_capture_group_order_fix() {
+        // This test confirms that the capture group order bug is fixed
+        // The regex pattern \(([^)]+)\)\[([^\]]+)\] captures:
+        // cap[1] = URL (inside parentheses)
+        // cap[2] = text (inside brackets)
+        // So (URL)[text] should become [text](URL)
+
+        let rule = MD011NoReversedLinks;
+
+        // Test with reversed link syntax
+        let content = "Check out (https://example.com)[this link] for more info.";
+        let ctx = LintContext::new(content);
+
+        // This should detect the reversed syntax
+        let result = rule.check(&ctx).unwrap();
+        assert_eq!(result.len(), 1);
+        assert!(result[0].message.contains("Reversed link syntax"));
+
+        // Verify the fix produces correct output
+        let fix = result[0].fix.as_ref().unwrap();
+        assert_eq!(fix.replacement, "[this link](https://example.com)");
+    }
+
+    #[test]
+    fn test_multiple_reversed_links() {
+        // Test multiple reversed links in the same content
+        let rule = MD011NoReversedLinks;
+
+        let content = "Visit (https://example.com)[Example] and (https://test.com)[Test Site].";
+        let ctx = LintContext::new(content);
+
+        let result = rule.check(&ctx).unwrap();
+        assert_eq!(result.len(), 2);
+
+        // Verify both fixes are correct
+        assert_eq!(result[0].fix.as_ref().unwrap().replacement, "[Example](https://example.com)");
+        assert_eq!(result[1].fix.as_ref().unwrap().replacement, "[Test Site](https://test.com)");
+    }
+
+    #[test]
+    fn test_normal_links_not_flagged() {
+        // Test that normal link syntax is not flagged
+        let rule = MD011NoReversedLinks;
+
+        let content = "This is a normal [link](https://example.com) and another [link](https://test.com).";
+        let ctx = LintContext::new(content);
+
+        let result = rule.check(&ctx).unwrap();
+        assert_eq!(result.len(), 0);
+    }
+
+    #[test]
+    fn debug_capture_groups() {
+        // Debug test to understand capture group behavior
+        let pattern = r"\(([^)]+)\)\[([^\]]+)\]";
+        let regex = Regex::new(pattern).unwrap();
+
+        let test_text = "(https://example.com)[Click here]";
+
+        if let Some(cap) = regex.captures(test_text) {
+            println!("Full match: {}", &cap[0]);
+            println!("cap[1] (first group): {}", &cap[1]);
+            println!("cap[2] (second group): {}", &cap[2]);
+
+            // Current fix format
+            let current_fix = format!("[{}]({})", &cap[2], &cap[1]);
+            println!("Current fix produces: {}", current_fix);
+
+            // Test what the actual rule produces
+            let rule = MD011NoReversedLinks;
+            let ctx = LintContext::new(test_text);
+            let result = rule.check(&ctx).unwrap();
+            if !result.is_empty() {
+                println!("Rule fix produces: {}", result[0].fix.as_ref().unwrap().replacement);
+            }
+        }
+    }
+}

{rumdl-0.0.70 → rumdl-0.0.72}/src/rules/md014_commands_show_output.rs

@@ -70,9 +70,7 @@ impl MD014CommandsShowOutput {
         }
 
         let mut has_command = false;
-
         let mut has_output = false;
-
         let mut last_command = String::new();
 
         for line in block {
@@ -88,6 +86,16 @@ impl MD014CommandsShowOutput {
         has_command && !has_output && !self.is_no_output_command(&last_command)
     }
 
+    fn get_command_from_block(&self, block: &[&str]) -> String {
+        for line in block {
+            let trimmed = line.trim();
+            if self.is_command_line(line) {
+                return trimmed[1..].trim().to_string();
+            }
+        }
+        String::new()
+    }
+
     fn fix_command_block(&self, block: &[&str]) -> String {
         block
             .iter()
@@ -175,14 +183,21 @@ impl Rule for MD014CommandsShowOutput {
                                         match_obj.len(),
                                     );
 
+                                // Get the command for a more helpful message
+                                let command = self.get_command_from_block(&current_block);
+                                let message = if command.is_empty() {
+                                    "Command should show output (add example output or remove $ prompt)".to_string()
+                                } else {
+                                    format!("Command '{}' should show output (add example output or remove $ prompt)", command)
+                                };
+
                                 warnings.push(LintWarning {
                                     rule_name: Some(self.name()),
                                     line: start_line,
                                     column: start_col,
                                     end_line,
                                     end_column: end_col,
-                                    message: "Commands in code blocks should show output"
-                                        .to_string(),
+                                    message,
                                     severity: Severity::Warning,
                                     fix: Some(Fix {
                                         range: _line_index

{rumdl-0.0.70 → rumdl-0.0.72}/src/rules/md022_blanks_around_headings.rs

@@ -582,7 +582,7 @@ impl Rule for MD022BlanksAroundHeadings {
                         } else {
                             "lines"
                         };
-                        issues.push(format!("Headings should be surrounded by blank lines. Expected at least {} blank {} between headings.", required_blanks, line_word));
+                        issues.push(format!("Expected {} blank {} between headings", required_blanks, line_word));
                     }
                 }
 
@@ -604,7 +604,7 @@ impl Rule for MD022BlanksAroundHeadings {
                             "lines"
                         };
                         issues.push(format!(
-                            "Heading should have at least {} blank {} above.",
+                            "Expected {} blank {} above heading",
                             self.lines_above, line_word
                         ));
                     }
@@ -663,7 +663,7 @@ impl Rule for MD022BlanksAroundHeadings {
                                 "lines"
                             };
                             issues.push(format!(
-                                "Heading should have at least {} blank {} below.",
+                                "Expected {} blank {} below heading",
                                 self.lines_below, line_word
                             ));
                         }
@@ -784,7 +784,7 @@ impl Rule for MD022BlanksAroundHeadings {
                     } else {
                         "lines"
                     };
-                    issues.push(format!("Headings should be surrounded by blank lines. Expected at least {} blank {} between headings.", required_blanks, line_word));
+                    issues.push(format!("Expected {} blank {} between headings", required_blanks, line_word));
                 }
             }
 
@@ -806,7 +806,7 @@ impl Rule for MD022BlanksAroundHeadings {
                         "lines"
                     };
                     issues.push(format!(
-                        "Heading should have at least {} blank {} above.",
+                        "Expected {} blank {} above heading",
                         self.lines_above, line_word
                     ));
                 }
@@ -865,7 +865,7 @@ impl Rule for MD022BlanksAroundHeadings {
                             "lines"
                         };
                         issues.push(format!(
-                            "Heading should have at least {} blank {} below.",
+                            "Expected {} blank {} below heading",
                             self.lines_below, line_word
                         ));
                     }

{rumdl-0.0.70 → rumdl-0.0.72}/src/rules/md025_single_title.rs

@@ -253,7 +253,13 @@ impl Rule for MD025SingleTitle {
                             "{} {}",
                             "#".repeat(self.level + 1),
                             if line_content.trim_start().starts_with('#') {
-                                &line_content[(col + self.level)..]
+                                // Add bounds checking to prevent panic
+                                let slice_start = col + self.level;
+                                if slice_start < line_content.len() {
+                                    &line_content[slice_start..]
+                                } else {
+                                    "" // If bounds exceeded, use empty string
+                                }
                             } else {
                                 line_content.trim() // For Setext, use the whole line
                             }
@@ -357,4 +363,55 @@ mod tests {
             "Should not flag a single title after front matter"
         );
     }
+
+    #[test]
+    fn test_bounds_checking_bug() {
+        // Test case that could trigger bounds error in fix generation
+        // When col + self.level exceeds line_content.len()
+        let rule = MD025SingleTitle::default();
+
+        // Create content with very short second heading
+        let content = "# First\n#";
+        let ctx = crate::lint_context::LintContext::new(content);
+
+        // This should not panic
+        let result = rule.check(&ctx);
+        assert!(result.is_ok());
+
+        // Test the fix as well
+        let fix_result = rule.fix(&ctx);
+        assert!(fix_result.is_ok());
+    }
+
+    #[test]
+    fn test_bounds_checking_edge_case() {
+        // Test case that specifically targets the bounds checking fix
+        // Create a heading where col + self.level would exceed line length
+        let rule = MD025SingleTitle::default();
+
+        // Create content where the second heading is just "#" (length 1)
+        // col will be 0, self.level is 1, so col + self.level = 1
+        // This should not exceed bounds for "#" but tests the edge case
+        let content = "# First Title\n#";
+        let ctx = crate::lint_context::LintContext::new(content);
+
+        // This should not panic and should handle the edge case gracefully
+        let result = rule.check(&ctx);
+        assert!(result.is_ok());
+
+        if let Ok(warnings) = result {
+            if !warnings.is_empty() {
+                // Check that the fix doesn't cause a panic
+                let fix_result = rule.fix(&ctx);
+                assert!(fix_result.is_ok());
+
+                // The fix should produce valid content
+                if let Ok(fixed_content) = fix_result {
+                    assert!(!fixed_content.is_empty());
+                    // Should convert the second "#" to "##" (or "## " if there's content)
+                    assert!(fixed_content.contains("##"));
+                }
+            }
+        }
+    }
 }

{rumdl-0.0.70 → rumdl-0.0.72}/src/rules/md026_no_trailing_punctuation.rs

@@ -292,7 +292,7 @@ impl MD026NoTrailingPunctuation {
                                 end_line,
                                 end_column: end_col,
                                 message: format!(
-                                    "Heading '{}' should not end with punctuation '{}'",
+                                    "Heading '{}' ends with punctuation '{}'",
                                     heading_text.trim(),
                                     last_char
                                 ),
@@ -337,7 +337,7 @@ impl MD026NoTrailingPunctuation {
                             end_column: end_col,
                             message: format!(
                                 "Heading '{
-                }' should not end with punctuation '{}'",
+                }' ends with punctuation '{}'",
                                 lines[heading_line - 1].trim(),
                                 last_char
                             ),

{rumdl-0.0.70 → rumdl-0.0.72}/src/rules/md028_no_blanks_blockquote.rs

@@ -73,7 +73,7 @@ impl Rule for MD028NoBlanksBlockquote {
 
                 warnings.push(LintWarning {
                     rule_name: Some(self.name()),
-                    message: "Blank line inside blockquote".to_string(),
+                    message: "Empty blockquote line should contain '>' marker".to_string(),
                     line: start_line,
                     column: start_col,
                     end_line,

{rumdl-0.0.70 → rumdl-0.0.72}/src/rules/md029_ordered_list_prefix.rs

@@ -307,9 +307,8 @@ impl MD029OrderedListPrefix {
 
             // Check each item in the group for correct sequence
             for (idx, (line_num, line)) in group.iter().enumerate() {
-                if Self::get_list_number(line).is_some() {
+                if let Some(actual_num) = Self::get_list_number(line) {
                     let expected_num = self.get_expected_number(idx);
-                    let actual_num = Self::get_list_number(line).unwrap();
 
                     if actual_num != expected_num {
                         warnings.push(LintWarning {
@@ -378,4 +377,49 @@ mod tests {
         let result = rule.check_with_structure(&ctx, &structure).unwrap();
         assert!(result.is_empty());
     }
+
+    #[test]
+    fn test_redundant_computation_fix() {
+        // This test confirms that the redundant computation bug is fixed
+        // Previously: get_list_number() was called twice (once for is_some(), once for unwrap())
+        // Now: get_list_number() is called once with if let pattern
+
+        let rule = MD029OrderedListPrefix::default();
+
+        // Test with mixed valid and edge case content
+        let content = "1. First item\n3. Wrong number\n2. Another wrong number";
+        let structure = DocumentStructure::new(content);
+        let ctx = crate::lint_context::LintContext::new(content);
+
+        // This should not panic and should produce warnings for incorrect numbering
+        let result = rule.check_with_structure(&ctx, &structure).unwrap();
+        assert_eq!(result.len(), 2); // Should have warnings for items 3 and 2
+
+        // Verify the warnings have correct content
+        assert!(result[0].message.contains("3 does not match style (expected 2)"));
+        assert!(result[1].message.contains("2 does not match style (expected 3)"));
+    }
+
+    #[test]
+    fn test_performance_improvement() {
+        // This test verifies that the fix improves performance by avoiding redundant calls
+        let rule = MD029OrderedListPrefix::default();
+
+        // Create a larger list to test performance
+        let mut content = String::new();
+        for i in 1..=100 {
+            content.push_str(&format!("{}. Item {}\n", i + 1, i)); // All wrong numbers
+        }
+
+        let structure = DocumentStructure::new(&content);
+        let ctx = crate::lint_context::LintContext::new(&content);
+
+        // This should complete without issues and produce warnings for all items
+        let result = rule.check_with_structure(&ctx, &structure).unwrap();
+        assert_eq!(result.len(), 100); // Should have warnings for all 100 items
+
+        // Verify first and last warnings
+        assert!(result[0].message.contains("2 does not match style (expected 1)"));
+        assert!(result[99].message.contains("101 does not match style (expected 100)"));
+    }
 }

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