rumdl 0.0.73__tar.gz → 0.0.74__tar.gz

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

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

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

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

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

{rumdl-0.0.73 → 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.73 → 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),

{rumdl-0.0.73 → rumdl-0.0.74}/src/rules/md051_link_fragments.rs

@@ -98,43 +98,73 @@ impl MD051LinkFragments {
     /// Convert a heading to a fragment identifier following GitHub's algorithm:
     /// 1. Strip all formatting (code, emphasis, links, etc.)
     /// 2. Convert to lowercase
-    /// 3. Replace spaces and non-alphanumeric chars with hyphens
-    /// 4. Remove consecutive hyphens
+    /// 3. Replace spaces with hyphens, & with double hyphens, other special chars with hyphens
+    /// 4. Collapse multiple consecutive hyphens to single hyphens (except preserve & -> --)
+    /// 5. Remove leading and trailing hyphens
     fn heading_to_fragment(&self, heading: &str) -> String {
-        let mut stripped = heading.to_string();
+        // Step 1: Strip markdown formatting
+        let mut result = self.strip_markdown_formatting(heading);
+
+        // Step 2: Convert to lowercase
+        result = result.to_lowercase();
+
+        // Step 3 & 4: Process character by character with GitHub's rules
+        let mut fragment = String::new();
+
+        for c in result.chars() {
+            match c {
+                // Keep alphanumeric characters
+                'a'..='z' | '0'..='9' => {
+                    fragment.push(c);
+                }
+                // Ampersand becomes double hyphen (special case)
+                '&' => {
+                    // Only add hyphens if the last character isn't already a hyphen
+                    if !fragment.ends_with('-') {
+                        fragment.push_str("--");
+                    } else {
+                        // If we already have a hyphen, just add one more to make it double
+                        fragment.push('-');
+                    }
+                }
+                // Spaces and other characters become single hyphen (but avoid consecutive hyphens)
+                _ => {
+                    if !fragment.ends_with('-') {
+                        fragment.push('-');
+                    }
+                    // If fragment already ends with hyphen, skip adding another
+                }
+            }
+        }
+
+        // Step 5: Remove leading and trailing hyphens
+        fragment.trim_matches('-').to_string()
+    }
+
+    /// Strip markdown formatting from text, keeping only the content
+    fn strip_markdown_formatting(&self, text: &str) -> String {
+        let mut result = text.to_string();
 
         // Remove links but keep the link text: [text](url) -> text
-        stripped = INLINE_LINK_REGEX.replace_all(&stripped, "$1").to_string();
+        result = INLINE_LINK_REGEX.replace_all(&result, "$1").to_string();
 
         // Remove emphasis and bold formatting more comprehensively
-        stripped = BOLD_ASTERISK_REGEX.replace_all(&stripped, "$1").to_string();
-        stripped = BOLD_UNDERSCORE_REGEX
-            .replace_all(&stripped, "$1")
+        result = BOLD_ASTERISK_REGEX.replace_all(&result, "$1").to_string();
+        result = BOLD_UNDERSCORE_REGEX
+            .replace_all(&result, "$1")
             .to_string();
-        stripped = ITALIC_ASTERISK_REGEX
-            .replace_all(&stripped, "$1")
+        result = ITALIC_ASTERISK_REGEX
+            .replace_all(&result, "$1")
             .to_string();
-        stripped = ITALIC_UNDERSCORE_REGEX
-            .replace_all(&stripped, "$1")
+        result = ITALIC_UNDERSCORE_REGEX
+            .replace_all(&result, "$1")
             .to_string();
-        stripped = STRIKETHROUGH_REGEX.replace_all(&stripped, "$1").to_string();
+        result = STRIKETHROUGH_REGEX.replace_all(&result, "$1").to_string();
 
         // Remove code spans by replacing with their content (simplified)
-        stripped = stripped.replace("`", "");
-
-        // Convert to lowercase and replace spaces/non-alphanumeric chars with hyphens
-        let fragment = stripped
-            .to_lowercase()
-            .chars()
-            .map(|c| match c {
-                ' ' => '-',
-                c if c.is_alphanumeric() => c,
-                _ => '-',
-            })
-            .collect::<String>();
+        result = result.replace("`", "");
 
-        // Replace multiple consecutive hyphens with a single one
-        MULTIPLE_HYPHENS.replace_all(&fragment, "-").to_string()
+        result
     }
 
     /// Generate multiple possible fragment variations for a heading to handle
@@ -144,25 +174,13 @@ impl MD051LinkFragments {
 
         // Primary fragment (GitHub's algorithm)
         let primary = self.heading_to_fragment(heading);
-        variations.push(primary.clone());
-
-        // Alternative: preserve some consecutive hyphens (for manually created TOCs)
-        let mut stripped = heading.to_string();
-        stripped = INLINE_LINK_REGEX.replace_all(&stripped, "$1").to_string();
-        stripped = BOLD_ASTERISK_REGEX.replace_all(&stripped, "$1").to_string();
-        stripped = BOLD_UNDERSCORE_REGEX
-            .replace_all(&stripped, "$1")
-            .to_string();
-        stripped = ITALIC_ASTERISK_REGEX
-            .replace_all(&stripped, "$1")
-            .to_string();
-        stripped = ITALIC_UNDERSCORE_REGEX
-            .replace_all(&stripped, "$1")
-            .to_string();
-        stripped = STRIKETHROUGH_REGEX.replace_all(&stripped, "$1").to_string();
-        stripped = stripped.replace("`", "");
+        if !primary.is_empty() {
+            variations.push(primary.clone());
+        }
 
-        // Alternative algorithm that preserves some patterns
+        // Alternative: preserve double hyphens (for manually created TOCs)
+        // Some tools or manual creation might use double hyphens for certain symbols
+        let stripped = self.strip_markdown_formatting(heading);
         let alt_fragment = stripped
             .to_lowercase()
             .chars()
@@ -173,15 +191,20 @@ impl MD051LinkFragments {
             })
             .collect::<String>();
 
-        // Only reduce to double hyphens (not single) for some tools
-        let alt_with_double = alt_fragment.replace("---", "--");
-        if alt_with_double != primary {
-            variations.push(alt_with_double);
+        // Create variation with double hyphens preserved for & symbols
+        let double_hyphen_variant = alt_fragment
+            .replace("---", "--")  // Collapse triple+ to double
+            .trim_matches('-')     // Remove leading/trailing hyphens
+            .to_string();
+
+        if !double_hyphen_variant.is_empty() && double_hyphen_variant != primary {
+            variations.push(double_hyphen_variant);
         }
 
-        // Keep the original with triple hyphens for some manual TOCs
-        if alt_fragment != primary {
-            variations.push(alt_fragment);
+        // Create variation with all consecutive hyphens preserved (for some manual TOCs)
+        let preserved_hyphens = alt_fragment.trim_matches('-').to_string();
+        if !preserved_hyphens.is_empty() && preserved_hyphens != primary && !variations.contains(&preserved_hyphens) {
+            variations.push(preserved_hyphens);
         }
 
         variations

{rumdl-0.0.73 → rumdl-0.0.74}/src/utils/document_structure.rs

@@ -492,81 +492,59 @@ impl DocumentStructure {
                     let lang = captures.get(3).map(|m| m.as_str().to_string());
                     current_language = lang.filter(|l| !l.is_empty());
                 }
-                // Check for indented code block (simplified)
-                else if line.starts_with("    ") && !line.trim().is_empty() {
-                    // Don't treat indented HTML tags as code blocks
-                    let trimmed = line.trim_start();
-                    if trimmed.starts_with('<') && trimmed.len() > 1 {
-                        let second_char = trimmed.chars().nth(1).unwrap();
-                        if second_char.is_ascii_alphabetic()
-                            || (second_char == '/'
-                                && trimmed.len() > 2
-                                && trimmed.chars().nth(2).unwrap().is_ascii_alphabetic())
-                        {
-                            // This looks like an HTML tag, don't treat as code block
-                            // Skip this line and continue
-                        } else {
-                            // Not an HTML tag, process as potential code block
-                            let mut end_line = i;
-                            while end_line + 1 < lines.len()
-                                && (lines[end_line + 1].starts_with("    ")
-                                    || lines[end_line + 1].trim().is_empty())
-                            {
-                                // Check if the next indented line is also an HTML tag
-                                if lines[end_line + 1].starts_with("    ") {
-                                    let next_trimmed = lines[end_line + 1].trim_start();
-                                    if next_trimmed.starts_with('<') && next_trimmed.len() > 1 {
-                                        let next_second_char = next_trimmed.chars().nth(1).unwrap();
-                                        if next_second_char.is_ascii_alphabetic()
-                                            || (next_second_char == '/'
-                                                && next_trimmed.len() > 2
-                                                && next_trimmed
-                                                    .chars()
-                                                    .nth(2)
-                                                    .unwrap()
-                                                    .is_ascii_alphabetic())
-                                        {
-                                            // Next line is also HTML, break the code block here
-                                            break;
-                                        }
-                                    }
+                // Check for indented code block (CommonMark compliant)
+                else if Self::is_indented_code_line(line) && !line.trim().is_empty() {
+                    // According to CommonMark, any content indented by 4+ spaces OR a tab is a code block
+                    // regardless of what the content is (including HTML)
+                    let mut end_line = i;
+
+                    // Find the end of this indented code block
+                    // Continue while we have indented lines OR blank lines that are followed by more indented lines
+                    while end_line + 1 < lines.len() {
+                        let next_line = lines[end_line + 1];
+
+                        if Self::is_indented_code_line(next_line) && !next_line.trim().is_empty() {
+                            // Found another indented line, continue the block
+                            end_line += 1;
+                        } else if next_line.trim().is_empty() {
+                            // Found a blank line, check if there are more indented lines after it
+                            let mut lookahead = end_line + 2;
+                            let mut found_indented = false;
+
+                            while lookahead < lines.len() {
+                                let lookahead_line = lines[lookahead];
+                                if Self::is_indented_code_line(lookahead_line) && !lookahead_line.trim().is_empty() {
+                                    found_indented = true;
+                                    break;
+                                } else if !lookahead_line.trim().is_empty() {
+                                    // Found non-empty, non-indented line, stop looking
+                                    break;
                                 }
-                                end_line += 1;
+                                lookahead += 1;
                             }
 
-                            // Only create code block if we found non-HTML content
-                            if end_line > i {
-                                code_blocks.push(CodeBlock {
-                                    start_line: i + 1,
-                                    end_line: end_line + 1,
-                                    language: None,
-                                    block_type: CodeBlockType::Indented,
-                                });
-
-                                // Skip to end of block
-                                i = end_line;
+                            if found_indented {
+                                // Include this blank line as part of the code block
+                                end_line += 1;
+                            } else {
+                                // No more indented lines, end the block here
+                                break;
                             }
+                        } else {
+                            // Found non-empty, non-indented line, end the block
+                            break;
                         }
-                    } else {
-                        // Not an HTML tag, process as normal indented code block
-                        let mut end_line = i;
-                        while end_line + 1 < lines.len()
-                            && (lines[end_line + 1].starts_with("    ")
-                                || lines[end_line + 1].trim().is_empty())
-                        {
-                            end_line += 1;
-                        }
+                    }
 
-                        code_blocks.push(CodeBlock {
-                            start_line: i + 1,
-                            end_line: end_line + 1,
-                            language: None,
-                            block_type: CodeBlockType::Indented,
-                        });
+                    code_blocks.push(CodeBlock {
+                        start_line: i + 1,
+                        end_line: end_line + 1,
+                        language: None,
+                        block_type: CodeBlockType::Indented,
+                    });
 
-                        // Skip to end of block
-                        i = end_line;
-                    }
+                    // Skip to end of block
+                    i = end_line;
                 }
             } else {
                 // Check for fenced code block end - must start with the same fence character
@@ -653,6 +631,30 @@ impl DocumentStructure {
         Self::count_trailing_spaces(line) > 0
     }
 
+    /// Check if a line is indented code according to CommonMark specification
+    ///
+    /// According to CommonMark, a line is considered indented code if it starts with:
+    /// - 4 or more spaces, OR
+    /// - A tab character
+    #[inline]
+    fn is_indented_code_line(line: &str) -> bool {
+        if line.starts_with('\t') {
+            return true;
+        }
+
+        // Count leading spaces
+        let mut space_count = 0;
+        for c in line.chars() {
+            if c == ' ' {
+                space_count += 1;
+            } else {
+                break;
+            }
+        }
+
+        space_count >= 4
+    }
+
     /// Get a list of list start indices
     /// This method analyzes the list_lines to find where lists begin
     pub fn get_list_start_indices(&self) -> Vec<usize> {