rumdl 0.0.72__tar.gz → 0.0.74__tar.gz

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

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

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

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

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

{rumdl-0.0.72 → rumdl-0.0.74}/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.74}/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.74}/src/rules/md032_blanks_around_lists.rs

@@ -103,8 +103,42 @@ impl MD032BlanksAroundLists {
             if structure.is_in_code_block(current_line_idx_1)
                 || structure.is_in_front_matter(current_line_idx_1)
             {
-                current_line_idx_0 += 1;
-                continue;
+                // Special case: Even if a line is in a code block (e.g., tab-indented),
+                // if it looks like a list item, the user probably intended it as such.
+                // We should warn about spacing issues rather than silently ignore it.
+                // But only apply this to INDENTED code blocks, not FENCED code blocks.
+                if structure.is_in_code_block(current_line_idx_1) {
+                    // Check if this is an indented code block (starts with tab or 4+ spaces)
+                    // vs a fenced code block (enclosed in ``` or ~~~)
+                    let line_trimmed = line_str.trim_start();
+                    let leading_whitespace = &line_str[..line_str.len() - line_trimmed.len()];
+                    let is_indented_code = leading_whitespace.contains('\t') ||
+                                          leading_whitespace.chars().filter(|&c| c == ' ').count() >= 4;
+
+                    if is_indented_code {
+                        // Check if this "indented code block" line actually looks like a list item
+                        let blockquote_prefix = BLOCKQUOTE_PREFIX_RE
+                            .find(line_str)
+                            .map_or(String::new(), |m| m.as_str().to_string());
+                        let line_content = line_str.trim_start_matches(&blockquote_prefix);
+
+                        // If it matches our list item pattern, treat it as a list item for linting purposes
+                        if LIST_ITEM_START_REGEX.is_match(line_content) {
+                            // Don't skip - process it as a potential list item
+                        } else {
+                            current_line_idx_0 += 1;
+                            continue;
+                        }
+                    } else {
+                        // Fenced code block - always skip
+                        current_line_idx_0 += 1;
+                        continue;
+                    }
+                } else {
+                    // Front matter - always skip
+                    current_line_idx_0 += 1;
+                    continue;
+                }
             }
 
             // Determine blockquote prefix and content *before* checking for list item

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

@@ -35,57 +35,15 @@ impl Rule for MD042NoEmptyLinks {
 
     fn check(&self, ctx: &crate::lint_context::LintContext) -> LintResult {
         let content = ctx.content;
-        let line_index = LineIndex::new(content.to_string());
-        let mut warnings = Vec::new();
-
-        lazy_static! {
-            static ref EMPTY_LINK_REGEX: Regex =
-                Regex::new(r"(?<!\!)\[([^\]]*)\]\(([^\)]*)\)").unwrap();
-        }
 
-        for (line_num, line) in content.lines().enumerate() {
-            for cap_result in EMPTY_LINK_REGEX.captures_iter(line) {
-                let cap = match cap_result {
-                    Ok(cap) => cap,
-                    Err(_) => continue,
-                };
-
-                let full_match = cap.get(0).unwrap();
-                let text = cap.get(1).map_or("", |m| m.as_str());
-                let url = cap.get(2).map_or("", |m| m.as_str());
-
-                if text.trim().is_empty() || url.trim().is_empty() {
-                    let replacement = if text.trim().is_empty() && url.trim().is_empty() {
-                        "[Link text](https://example.com)".to_string()
-                    } else if text.trim().is_empty() {
-                        format!("[Link text]({})", url)
-                    } else {
-                        format!("[{}](https://example.com)", text)
-                    };
-
-                    warnings.push(LintWarning {
-                        rule_name: Some(self.name()),
-                        message: format!(
-                            "Empty link found: [{
-            }]({})",
-                            text, url
-                        ),
-                        line: line_num + 1,
-                        column: full_match.start() + 1,
-                        end_line: line_num + 1,
-                        end_column: full_match.end() + 1,
-                        severity: Severity::Warning,
-                        fix: Some(Fix {
-                            range: line_index
-                                .line_col_to_byte_range(line_num + 1, full_match.start() + 1),
-                            replacement,
-                        }),
-                    });
-                }
-            }
+        // Early return for empty content or content without links
+        if content.is_empty() || !content.contains('[') {
+            return Ok(Vec::new());
         }
 
-        Ok(warnings)
+        // Use document structure for proper code block and code span detection
+        let structure = DocumentStructure::new(content);
+        self.check_with_structure(ctx, &structure)
     }
 
     /// Optimized check using document structure
@@ -125,7 +83,7 @@ impl Rule for MD042NoEmptyLinks {
                 line: link.line,
                 column: link.start_col,
                 end_line: link.line,
-                end_column: link.end_col,
+                end_column: link.end_col + 1,
                 severity: Severity::Warning,
                 fix: Some(Fix {
                     range: line_index.line_col_to_byte_range(link.line, link.start_col),