rumdl 0.0.71__tar.gz → 0.0.73__tar.gz

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

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

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

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

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

{rumdl-0.0.71 → rumdl-0.0.73}/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.71 → rumdl-0.0.73}/src/main.rs

@@ -1297,16 +1297,13 @@ fn process_stdin(rules: &[Box<dyn Rule>], args: &CheckArgs) {
         let has_issues = !all_warnings.is_empty();
         if has_issues {
             for warning in &all_warnings {
+                let rule_name = warning.rule_name.unwrap_or("unknown");
                 println!(
-                    "<stdin>:{}:{}: {}: {} [{}]",
-                    warning.line,
-                    warning.column,
-                    match warning.severity {
-                        rumdl::rule::Severity::Error => "error".red(),
-                        rumdl::rule::Severity::Warning => "warning".yellow(),
-                    },
-                    warning.message,
-                    warning.rule_name.unwrap_or("unknown")
+                    "<stdin>:{}:{}: {} {}",
+                    warning.line.to_string().cyan(),
+                    warning.column.to_string().cyan(),
+                    format!("[{:5}]", rule_name).yellow(), // Align rule names consistently
+                    warning.message
                 );
             }
         }
@@ -1611,7 +1608,7 @@ fn process_file(
                 file_path.blue().underline(),
                 warning.line.to_string().cyan(),
                 warning.column.to_string().cyan(),
-                format!("[{}]", rule_name).yellow(),
+                format!("[{:5}]", rule_name).yellow(), // Pad rule name to 5 characters for alignment
                 warning.message,
                 fix_indicator.green()
             );

{rumdl-0.0.71 → rumdl-0.0.73}/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.71 → rumdl-0.0.73}/src/rules/md006_start_bullets.rs

@@ -66,9 +66,15 @@ impl MD006StartBullets {
                         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 {
+
+                            // Content is acceptable if:
+                            // 1. It's indented at least as much as the current item (continuation of parent)
+                            // 2. OR it's indented more than the previous bullet (continuation of previous item)
+                            // 3. AND we have a true parent relationship (prev_indent < current_indent)
+                            let is_continuation = content_indent >= prev_indent.max(2); // At least 2 spaces for continuation
+                            let is_valid_nesting = prev_indent < current_indent;
+
+                            if !is_continuation || !is_valid_nesting {
                                 has_breaking_content = true;
                                 break;
                             }
@@ -78,13 +84,19 @@ impl MD006StartBullets {
                     if !has_breaking_content {
                         return Some((i, prev_indent));
                     } else {
-                        // Content breaks the list structure
-                        return None;
+                        // Content breaks the list structure, but continue searching for an earlier valid parent
+                        continue;
                     }
                 }
                 // If prev_indent > current_indent, it's a child of a sibling, ignore it and keep searching.
             } else {
-                // Found non-list content - this breaks the search
+                // Found non-list content - check if it's a continuation line
+                let content_indent = lines[i].len() - lines[i].trim_start().len();
+                // If it's indented enough to be a continuation, don't break the search
+                if content_indent >= 2 {
+                    continue;
+                }
+                // Otherwise, this breaks the search
                 return None;
             }
         }
@@ -247,8 +259,7 @@ impl Rule for MD006StartBullets {
                 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(),
+                message: "List item indentation".to_string(),
                 fix: Some(Fix {
                 range: line_index.line_col_to_byte_range(line_num, 1),
                 replacement,

{rumdl-0.0.71 → rumdl-0.0.73}/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.71 → rumdl-0.0.73}/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.71 → rumdl-0.0.73}/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.71 → rumdl-0.0.73}/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.71 → rumdl-0.0.73}/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.71 → rumdl-0.0.73}/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.71 → rumdl-0.0.73}/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.71 → rumdl-0.0.73}/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.71 → rumdl-0.0.73}/src/rules/md032_blanks_around_lists.rs

@@ -254,7 +254,7 @@ impl MD032BlanksAroundLists {
                         end_column: end_col,
                         severity: Severity::Error,
                         rule_name: Some(self.name()),
-                        message: "Lists should be preceded by a blank line".to_string(),
+                        message: "List should be preceded by blank line".to_string(),
                         fix: Some(Fix {
                             range: line_index.line_col_to_byte_range(start_line, 1),
                             replacement: format!("{}\n{}", prefix, lines[start_line - 1]),
@@ -288,7 +288,7 @@ impl MD032BlanksAroundLists {
                         end_column: end_col_last,
                         severity: Severity::Error,
                         rule_name: Some(self.name()),
-                        message: "Lists should be followed by a blank line".to_string(),
+                        message: "List should be followed by blank line".to_string(),
                         fix: Some(Fix {
                             range: line_index.line_col_to_byte_range(end_line + 1, 1),
                             replacement: format!("{}\n{}", prefix, lines[end_line]),
@@ -577,7 +577,7 @@ mod tests {
             warnings[0].line, 2,
             "Warning should be on the last line of the list (line 2)"
         );
-        assert!(warnings[0].message.contains("followed by a blank line"));
+        assert!(warnings[0].message.contains("followed by blank line"));
 
         // Test that warning has fix
         check_warnings_have_fixes(content);
@@ -607,7 +607,7 @@ mod tests {
             warnings[0].line, 2,
             "Warning should be on the first line of the list (line 2)"
         );
-        assert!(warnings[0].message.contains("preceded by a blank line"));
+        assert!(warnings[0].message.contains("preceded by blank line"));
 
         // Test that warning has fix
         check_warnings_have_fixes(content);
@@ -634,9 +634,9 @@ mod tests {
             "Expected 2 warnings for list in middle without surrounding blank lines"
         );
         assert_eq!(warnings[0].line, 2, "First warning on line 2 (start)");
-        assert!(warnings[0].message.contains("preceded by a blank line"));
+        assert!(warnings[0].message.contains("preceded by blank line"));
         assert_eq!(warnings[1].line, 3, "Second warning on line 3 (end)");
-        assert!(warnings[1].message.contains("followed by a blank line"));
+        assert!(warnings[1].message.contains("followed by blank line"));
 
         // Test that warnings have fixes
         check_warnings_have_fixes(content);
@@ -682,9 +682,9 @@ mod tests {
         );
         if warnings.len() == 2 {
             assert_eq!(warnings[0].line, 2, "Warning 1 should be on line 2 (start)");
-            assert!(warnings[0].message.contains("preceded by a blank line"));
+            assert!(warnings[0].message.contains("preceded by blank line"));
             assert_eq!(warnings[1].line, 5, "Warning 2 should be on line 5 (end)");
-            assert!(warnings[1].message.contains("followed by a blank line"));
+            assert!(warnings[1].message.contains("followed by blank line"));
         }
 
         // Test that warnings have fixes
@@ -794,7 +794,7 @@ mod tests {
         );
         if !warnings.is_empty() {
             assert_eq!(warnings[0].line, 4); // Warning on last line of list
-            assert!(warnings[0].message.contains("followed by a blank line"));
+            assert!(warnings[0].message.contains("followed by blank line"));
         }
 
         // Test that warnings have fixes