rumdl 0.0.72__tar.gz → 0.0.73__tar.gz

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

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

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

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

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

{rumdl-0.0.72 → 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.72 → 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.72 → rumdl-0.0.73}/src/rules/md034_no_bare_urls.rs

@@ -96,61 +96,53 @@ impl MD034NoBareUrls {
         &url[..end]
     }
 
-    // Find all bare URLs in a line, using DocumentStructure for code span detection
-    fn find_bare_urls_with_structure(
+    // Uses DocumentStructure for code block and code span detection in check_with_structure.
+    pub fn check_with_structure(
         &self,
-        line: &str,
-        line_idx: usize,
+        ctx: &crate::lint_context::LintContext,
         structure: &crate::utils::document_structure::DocumentStructure,
-    ) -> Vec<LintWarning> {
-        let mut warnings = Vec::new();
-
-        // Early return: empty lines
-        if line.trim().is_empty() {
-            return warnings;
-        }
-
-        // Fast path - check if line potentially contains a URL
-        if !URL_QUICK_CHECK.is_match(line) {
-            return warnings;
-        }
+    ) -> LintResult {
+        let content = ctx.content;
 
-        // Skip lines that consist only of a badge link
-        if BADGE_LINK_LINE.is_match(line) {
-            return warnings;
+        // Early return: skip if no URLs or emails
+        if self.should_skip(content) {
+            return Ok(vec![]);
         }
 
-        // Early return: skip reference definitions
-        if REFERENCE_DEF_RE.is_match(line) {
-            return warnings;
-        }
+        // Process the entire content to handle multi-line markdown links
+        let mut warnings = Vec::new();
 
-        // --- NEW: Collect all link/image destination ranges using regex ---
+        // First, find all markdown link ranges across the entire content
         let mut excluded_ranges: Vec<(usize, usize)> = Vec::new();
-        // Markdown links: [text](url)
-        for cap in MARKDOWN_LINK_PATTERN.captures_iter(line) {
+
+        // Markdown links: [text](url) - handle multi-line
+        for cap in MARKDOWN_LINK_PATTERN.captures_iter(content) {
             if let Some(dest) = cap.get(1) {
                 excluded_ranges.push((dest.start(), dest.end()));
             }
         }
-        // Markdown images: ![alt](url)
-        for cap in MARKDOWN_IMAGE_PATTERN.captures_iter(line) {
+
+        // Markdown images: ![alt](url) - handle multi-line
+        for cap in MARKDOWN_IMAGE_PATTERN.captures_iter(content) {
             if let Some(dest) = cap.get(2) {
                 excluded_ranges.push((dest.start(), dest.end()));
             }
         }
+
         // Angle-bracket links: <url>
-        for cap in ANGLE_LINK_PATTERN.captures_iter(line) {
+        for cap in ANGLE_LINK_PATTERN.captures_iter(content) {
             if let Some(m) = cap.get(1) {
                 excluded_ranges.push((m.start(), m.end()));
             }
         }
+
         // HTML attribute URLs: src="url", href="url", etc.
-        for cap in HTML_ATTRIBUTE_URL.captures_iter(line) {
+        for cap in HTML_ATTRIBUTE_URL.captures_iter(content) {
             if let Some(url_attr) = cap.get(1) {
                 excluded_ranges.push((url_attr.start(), url_attr.end()));
             }
         }
+
         // Sort and merge overlapping ranges
         excluded_ranges.sort_by_key(|r| r.0);
         let mut merged: Vec<(usize, usize)> = Vec::new();
@@ -164,12 +156,13 @@ impl MD034NoBareUrls {
             merged.push((start, end));
         }
 
-        for url_match in SIMPLE_URL_REGEX.find_iter(line) {
+        // Now find all URLs in the content and check if they're excluded
+        for url_match in SIMPLE_URL_REGEX.find_iter(content) {
             let url_start = url_match.start();
             let mut url_end = url_match.end();
 
             // Trim trailing punctuation that's likely sentence punctuation
-            let raw_url = &line[url_start..url_end];
+            let raw_url = &content[url_start..url_end];
             let trimmed_url = self.trim_trailing_punctuation(raw_url);
             url_end = url_start + trimmed_url.len();
 
@@ -182,9 +175,9 @@ impl MD034NoBareUrls {
             let before = if url_start == 0 {
                 None
             } else {
-                line.get(url_start - 1..url_start)
+                content.get(url_start - 1..url_start)
             };
-            let after = line.get(url_end..url_end + 1);
+            let after = content.get(url_end..url_end + 1);
             let is_valid_boundary = before.map_or(true, |c| {
                 !c.chars().next().unwrap().is_alphanumeric() && c != "_"
             }) && after.map_or(true, |c| {
@@ -193,45 +186,67 @@ impl MD034NoBareUrls {
             if !is_valid_boundary {
                 continue;
             }
-            // Skip if this URL is within a code span (using DocumentStructure)
-            if structure.is_in_code_span(line_idx + 1, url_start + 1) {
+
+            // Convert byte offset to line/column
+            let (line_num, col_num) = ctx.offset_to_line_col(url_start);
+
+            // Skip if this URL is within a code span
+            if structure.is_in_code_span(line_num, col_num) {
                 continue;
             }
-            // --- NEW: Skip if URL is within any excluded range (link/image dest) ---
+
+            // Skip if this URL is within a code block
+            if structure.is_in_code_block(line_num) {
+                continue;
+            }
+
+            // Skip if URL is within any excluded range (link/image dest)
             let in_any_range = merged
                 .iter()
                 .any(|(start, end)| url_start >= *start && url_end <= *end);
             if in_any_range {
                 continue;
             }
+
+            // Skip reference definitions
+            let line_start = content[..url_start].rfind('\n').map(|i| i + 1).unwrap_or(0);
+            let line_end = content[url_start..].find('\n').map(|i| url_start + i).unwrap_or(content.len());
+            let line = &content[line_start..line_end];
+            if REFERENCE_DEF_RE.is_match(line) {
+                continue;
+            }
+
+            let url_text = &content[url_start..url_end];
             let (start_line, start_col, end_line, end_col) =
-                calculate_url_range(line_idx + 1, line, url_start, url_end - url_start);
+                calculate_url_range(line_num, line, col_num - 1, url_text.len());
+
             warnings.push(LintWarning {
                 rule_name: Some(self.name()),
                 line: start_line,
                 column: start_col,
                 end_line,
                 end_column: end_col,
-                message: format!("Bare URL found (wrap in angle brackets: <URL> or use link syntax: [text](URL))"),
+                message: format!("Bare URL found"),
                 severity: Severity::Warning,
                 fix: Some(Fix {
                     range: url_start..url_end,
-                    replacement: format!("<{}>", &line[url_start..url_end]),
+                    replacement: format!("<{}>", url_text),
                 }),
             });
         }
 
         // Check for email addresses - similar logic to URLs
-        for email_match in EMAIL_REGEX.find_iter(line) {
+        for email_match in EMAIL_REGEX.find_iter(content) {
             let email_start = email_match.start();
             let email_end = email_match.end();
+
             // Manual boundary check: not part of a larger word
             let before = if email_start == 0 {
                 None
             } else {
-                line.get(email_start - 1..email_start)
+                content.get(email_start - 1..email_start)
             };
-            let after = line.get(email_end..email_end + 1);
+            let after = content.get(email_end..email_end + 1);
             let is_valid_boundary = before.map_or(true, |c| {
                 !c.chars().next().unwrap().is_alphanumeric() && c != "_" && c != "."
             }) && after.map_or(true, |c| {
@@ -240,10 +255,20 @@ impl MD034NoBareUrls {
             if !is_valid_boundary {
                 continue;
             }
-            // Skip if this email is within a code span (using DocumentStructure)
-            if structure.is_in_code_span(line_idx + 1, email_start + 1) {
+
+            // Convert byte offset to line/column
+            let (line_num, col_num) = ctx.offset_to_line_col(email_start);
+
+            // Skip if this email is within a code span
+            if structure.is_in_code_span(line_num, col_num) {
+                continue;
+            }
+
+            // Skip if this email is within a code block
+            if structure.is_in_code_block(line_num) {
                 continue;
             }
+
             // Skip if email is within any excluded range (link/image dest)
             let in_any_range = merged
                 .iter()
@@ -251,65 +276,29 @@ impl MD034NoBareUrls {
             if in_any_range {
                 continue;
             }
+
+            let email_text = &content[email_start..email_end];
+            let line_start = content[..email_start].rfind('\n').map(|i| i + 1).unwrap_or(0);
+            let line_end = content[email_start..].find('\n').map(|i| email_start + i).unwrap_or(content.len());
+            let line = &content[line_start..line_end];
             let (start_line, start_col, end_line, end_col) =
-                calculate_url_range(line_idx + 1, line, email_start, email_end - email_start);
+                calculate_url_range(line_num, line, col_num - 1, email_text.len());
+
             warnings.push(LintWarning {
                 rule_name: Some(self.name()),
                 line: start_line,
                 column: start_col,
                 end_line,
                 end_column: end_col,
-                message: format!(
-                    "Bare email address found: {}",
-                    &line[email_start..email_end]
-                ),
+                message: format!("Bare email address found"),
                 severity: Severity::Warning,
                 fix: Some(Fix {
                     range: email_start..email_end,
-                    replacement: format!("<{}>", &line[email_start..email_end]),
+                    replacement: format!("<{}>", email_text),
                 }),
             });
         }
-        warnings
-    }
-
-    // Uses DocumentStructure for code block and code span detection in check_with_structure.
-    pub fn check_with_structure(
-        &self,
-        ctx: &crate::lint_context::LintContext,
-        structure: &crate::utils::document_structure::DocumentStructure,
-    ) -> LintResult {
-        let content = ctx.content;
 
-        // Early return: skip if no URLs or emails
-        if self.should_skip(content) {
-            return Ok(vec![]);
-        }
-
-        let mut warnings = Vec::new();
-        for (i, line) in content.lines().enumerate() {
-            // Fast path: Skip empty lines
-            if line.trim().is_empty() {
-                continue;
-            }
-
-            // Fast path: Skip lines without potential URLs or emails
-            if !line.contains("http") && !line.contains("ftp") && !line.contains('@') {
-                continue;
-            }
-
-            // Skip lines in code blocks
-            if structure.is_in_code_block(i + 1) {
-                continue;
-            }
-
-            // Fast path: Skip reference link definitions
-            if REFERENCE_DEF_RE.is_match(line) {
-                continue;
-            }
-
-            warnings.extend(self.find_bare_urls_with_structure(line, i, structure));
-        }
         Ok(warnings)
     }
 
@@ -368,7 +357,7 @@ impl MD034NoBareUrls {
                             column: start_col,
                             end_line,
                             end_column: end_col,
-                            message: format!("Bare URL found (wrap in angle brackets: <URL> or use link syntax: [text](URL))"),
+                            message: format!("Bare URL found"),
                             severity: Severity::Warning,
                             fix: Some(Fix {
                                 range: offset..(offset + url_text.len()),
@@ -466,7 +455,7 @@ impl MD034NoBareUrls {
                             column: start_col,
                             end_line,
                             end_column: end_col,
-                            message: format!("Bare URL found (wrap in angle brackets: <URL> or use link syntax: [text](URL))"),
+                            message: format!("Bare URL found"),
                             severity: Severity::Warning,
                             fix: Some(Fix {
                                 range: offset..(offset + url_text.len()),

rumdl-0.0.73/tests/rules/md006_test.rs

@@ -0,0 +1,243 @@
+use rumdl::lint_context::LintContext;
+use rumdl::rule::Rule;
+use rumdl::rules::MD006StartBullets;
+
+#[test]
+fn test_valid_unordered_list() {
+    let rule = MD006StartBullets;
+    let content = "\
+* Item 1
+* Item 2
+  * Nested item
+  * Another nested item
+* Item 3";
+    let ctx = LintContext::new(content);
+    let result = rule.check(&ctx).unwrap();
+    assert!(result.is_empty());
+}
+
+#[test]
+fn test_valid_nested_list() {
+    let rule = MD006StartBullets;
+    let content = "\
+* Item 1
+  * Item 2
+    * Deeply nested item
+  * Item 3";
+    let ctx = LintContext::new(content);
+    let result = rule.check(&ctx).unwrap();
+    assert!(
+        result.is_empty(),
+        "Valid nested lists should not generate warnings, found: {:?}",
+        result
+    );
+}
+
+#[test]
+fn test_invalid_indented_list() {
+    let rule = MD006StartBullets;
+    let content = "\
+Some text here.
+
+  * First item should not be indented
+  * Second item should not be indented
+  * Third item should not be indented";
+    let ctx = LintContext::new(content);
+    let result = rule.check(&ctx).unwrap();
+    assert_eq!(result.len(), 3);
+    let fixed = rule.fix(&ctx).unwrap();
+    assert_eq!(
+        fixed,
+        "\
+Some text here.
+
+* First item should not be indented
+* Second item should not be indented
+* Third item should not be indented"
+    );
+}
+
+#[test]
+fn test_mixed_list_styles() {
+    let rule = MD006StartBullets;
+    let content = "\
+* Item 1
+  * Nested item
+* Item 2
+
+- Another item
+  - Nested item
+- Final item";
+    let ctx = LintContext::new(content);
+    let result = rule.check(&ctx).unwrap();
+    assert!(result.is_empty());
+}
+
+#[test]
+fn test_multiple_lists() {
+    let rule = MD006StartBullets;
+    let content = "\
+* First list item
+* Second list item
+
+Some text here
+
+  * Indented list 1
+  * Indented list 2";
+    let ctx = LintContext::new(content);
+    let result = rule.check(&ctx).unwrap();
+    assert_eq!(result.len(), 2);
+    let fixed = rule.fix(&ctx).unwrap();
+    assert_eq!(
+        fixed,
+        "\
+* First list item
+* Second list item
+
+Some text here
+
+* Indented list 1
+* Indented list 2"
+    );
+}
+
+#[test]
+fn test_empty_lines() {
+    let rule = MD006StartBullets;
+    let content = "\
+* Item 1
+
+  * Nested item
+
+* Item 2";
+    let ctx = LintContext::new(content);
+    let result = rule.check(&ctx).unwrap();
+    assert!(result.is_empty());
+}
+
+#[test]
+fn test_no_lists() {
+    let rule = MD006StartBullets;
+    let content = "\
+Just some text
+More text
+Even more text";
+    let ctx = LintContext::new(content);
+    let result = rule.check(&ctx).unwrap();
+    assert!(result.is_empty());
+}
+
+#[test]
+fn test_code_blocks_ignored() {
+    let rule = MD006StartBullets;
+    let content = "\
+```markdown
+  * This indented item is inside a code block
+  * These should be ignored
+```
+
+* Regular item outside code block";
+    let ctx = LintContext::new(content);
+    let result = rule.check(&ctx).unwrap();
+    assert!(result.is_empty());
+}
+
+// REGRESSION TESTS: Prevent false positives that were previously fixed
+
+#[test]
+fn test_nested_list_with_multiline_content_not_flagged() {
+    let rule = MD006StartBullets;
+    // This is the exact pattern that was causing false positives before the fix
+    let content = "\
+- Introduces changes or additions to the [MLflow REST
+  API](https://mlflow.org/docs/latest/rest-api.html)
+  - The MLflow REST API is implemented by a variety of open source
+    and proprietary platforms. Changes to the REST API impact all of
+    these platforms. Accordingly, we encourage developers to
+    thoroughly explore alternatives before attempting to introduce
+    REST API changes.
+- Introduces new user-facing MLflow APIs
+  - MLflow's API surface is carefully designed to generalize across
+    a variety of common ML operations. It is important to ensure
+    that new APIs are broadly useful to ML developers, easy to work
+    with, and simple yet powerful.";
+
+    let ctx = LintContext::new(content);
+    let result = rule.check(&ctx).unwrap();
+
+    // Should not flag any list items since they are properly nested
+    assert!(
+        result.is_empty(),
+        "Properly nested list items with multi-line content should not be flagged. Found {} warnings: {:#?}",
+        result.len(),
+        result
+    );
+
+    // Fix should not change anything since the list structure is correct
+    let fixed = rule.fix(&ctx).unwrap();
+    assert_eq!(
+        fixed, content,
+        "Fix should not change content with properly nested list items"
+    );
+}
+
+#[test]
+fn test_nested_list_with_markdown_link_continuation() {
+    let rule = MD006StartBullets;
+    // Test that markdown link continuations don't break list nesting validation
+    let content = "\
+* First item with [a link that spans
+  multiple lines](https://example.com/very/long/url)
+  * This nested item should be valid
+  * Another nested item
+* Second top-level item";
+
+    let ctx = LintContext::new(content);
+    let result = rule.check(&ctx).unwrap();
+
+    // Should not flag any list items since the nesting is correct
+    assert!(
+        result.is_empty(),
+        "List items with markdown link continuations should not break nesting validation. Found {} warnings: {:#?}",
+        result.len(),
+        result
+    );
+}
+
+#[test]
+fn test_mixed_valid_and_invalid_nesting() {
+    let rule = MD006StartBullets;
+    // Test that we correctly identify invalid nesting while preserving valid nesting
+    let content = "\
+* Valid top-level item
+  * Valid nested item
+    * Valid deeply nested item
+
+Some breaking content
+
+  * This should be flagged as invalid (indented without parent)
+  * This should also be flagged
+
+* Valid top-level item after break
+  * Valid nested item after break";
+
+    let ctx = LintContext::new(content);
+    let result = rule.check(&ctx).unwrap();
+
+    // Should only flag the 2 items that are improperly indented after the break
+    assert_eq!(
+        result.len(),
+        2,
+        "Should only flag improperly indented items, not valid nested items. Found {} warnings: {:#?}",
+        result.len(),
+        result
+    );
+
+    // Verify the correct lines are flagged
+    let flagged_lines: Vec<usize> = result.iter().map(|w| w.line).collect();
+    assert!(
+        flagged_lines.contains(&7) && flagged_lines.contains(&8),
+        "Should flag lines 7 and 8 (the improperly indented items), but flagged: {:?}",
+        flagged_lines
+    );
+}