rumdl 0.0.65__tar.gz → 0.0.66__tar.gz

{rumdl-0.0.65 → rumdl-0.0.66}/Cargo.lock

@@ -1704,7 +1704,7 @@ dependencies = [
 
 [[package]]
 name = "rumdl"
-version = "0.0.65"
+version = "0.0.66"
 dependencies = [
  "anyhow",
  "assert_cmd",
@@ -1745,7 +1745,7 @@ dependencies = [
  "tokio-util",
  "toml",
  "toml_edit",
- "tower",
+ "tower 0.5.2",
  "tower-lsp",
  "tower-service",
  "unicode-normalization",
@@ -2182,7 +2182,16 @@ dependencies = [
  "pin-project-lite",
  "tower-layer",
  "tower-service",
- "tracing",
+]
+
+[[package]]
+name = "tower"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d039ad9159c98b70ecfd540b2573b97f7f52c3e8d9f8ad57a24b916a536975f9"
+dependencies = [
+ "tower-layer",
+ "tower-service",
 ]
 
 [[package]]
@@ -2209,7 +2218,7 @@ dependencies = [
  "serde_json",
  "tokio",
  "tokio-util",
- "tower",
+ "tower 0.4.13",
  "tower-lsp-macros",
  "tracing",
 ]
@@ -2237,7 +2246,6 @@ version = "0.1.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "784e0ac535deb450455cbfa28a6f0df145ea1bb7ae51b821cf5e7927fdcfbdd0"
 dependencies = [
- "log",
  "pin-project-lite",
  "tracing-attributes",
  "tracing-core",

{rumdl-0.0.65 → rumdl-0.0.66}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rumdl"
-version = "0.0.65"
+version = "0.0.66"
 edition = "2021"
 description = "A fast Markdown linter written in Rust (Ru(st) MarkDown Linter)"
 authors = ["Ruben J. Jongejan <ruben.jongejan@gmail.com>"]
@@ -60,7 +60,7 @@ seahash = "4.1"
 tower-lsp = "0.20"
 tokio = { version = "1.0", features = ["full"] }
 tokio-util = "0.7"
-tower = "0.4"
+tower = "0.5.2"
 tower-service = "0.3"
 env_logger = "0.11"
 

{rumdl-0.0.65 → rumdl-0.0.66}/PKG-INFO

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

{rumdl-0.0.65 → rumdl-0.0.66}/src/rules/md006_start_bullets.rs

@@ -67,6 +67,34 @@ impl MD006StartBullets {
         }
         None
     }
+
+    /// Check if a list item is nested under a parent list item
+    fn is_nested_list_item(lines: &[&str], line_idx: usize) -> bool {
+        if let Some(current_indent) = Self::is_bullet_list_item(lines[line_idx]) {
+            // Look backwards for a parent list item with less indentation
+            for i in (0..line_idx).rev() {
+                let line = lines[i];
+
+                // Skip blank lines
+                if Self::is_blank_line(line) {
+                    continue;
+                }
+
+                // If we find a list item with less indentation, this is nested
+                if let Some(parent_indent) = Self::is_bullet_list_item(line) {
+                    if parent_indent < current_indent {
+                        return true;
+                    }
+                }
+
+                // If we hit non-list content, stop looking
+                if Self::is_bullet_list_item(line).is_none() {
+                    break;
+                }
+            }
+        }
+        false
+    }
 }
 
 impl Rule for MD006StartBullets {
@@ -116,6 +144,8 @@ impl Rule for MD006StartBullets {
                 Node::ListItem(ListItem {
                     position, children, ..
                 }) => {
+                    // Only flag top-level list items (depth == 1) that are indented
+                    // but make sure they're actually top-level and not nested sub-lists
                     if depth == 1 && !in_blockquote {
                         if let Some(pos) = position {
                             let line_idx = pos.start.line.saturating_sub(1);
@@ -123,17 +153,23 @@ impl Rule for MD006StartBullets {
                                 if let Some(cap) = BULLET_PATTERN.captures(line) {
                                     let indent = cap[1].len();
                                     if indent > 0 {
-                                        result.push(LintWarning {
-                                            rule_name: Some("MD006"),
-                                            severity: Severity::Warning,
-                                            line: line_idx + 1,
-                                            column: 1,
-                                            message: "Consider starting bulleted lists at the beginning of the line".to_string(),
-                                            fix: Some(Fix {
-                                                range: 0..indent,
-                                                replacement: "".to_string(),
-                                            }),
-                                        });
+                                        // Check if this is actually a nested list item
+                                        // by looking for a parent list item above it
+                                        let is_nested = MD006StartBullets::is_nested_list_item(lines, line_idx);
+
+                                        if !is_nested {
+                                            result.push(LintWarning {
+                                                rule_name: Some("MD006"),
+                                                severity: Severity::Warning,
+                                                line: line_idx + 1,
+                                                column: 1,
+                                                message: "Consider starting bulleted lists at the beginning of the line".to_string(),
+                                                fix: Some(Fix {
+                                                    range: 0..indent,
+                                                    replacement: "".to_string(),
+                                                }),
+                                            });
+                                        }
                                     }
                                 }
                             }
@@ -310,7 +346,7 @@ impl Rule for MD006StartBullets {
     }
 
     fn as_maybe_document_structure(&self) -> Option<&dyn crate::rule::MaybeDocumentStructure> {
-        Some(self)
+        None
     }
 
     fn from_config(_config: &crate::config::Config) -> Box<dyn Rule>

{rumdl-0.0.65 → rumdl-0.0.66}/src/rules/md007_ul_indent.rs

@@ -99,104 +99,84 @@ impl Rule for MD007ULIndent {
         self.check(ctx)
     }
 
-    fn fix(&self, ctx: &crate::lint_context::LintContext) -> Result<String, LintError> {
+            fn fix(&self, ctx: &crate::lint_context::LintContext) -> Result<String, LintError> {
         let content = ctx.content;
-        let tab_str = " ".repeat(self.indent);
-        let mut lines: Vec<String> = content
-            .lines()
-            .map(|l| {
-                // Normalize leading tabs to spaces
-                let mut norm = String::new();
-                let mut chars = l.chars().peekable();
-                while let Some(&c) = chars.peek() {
-                    if c == '\t' {
-                        norm.push_str(&tab_str);
-                        chars.next();
-                    } else if c == ' ' {
-                        norm.push(' ');
-                        chars.next();
-                    } else {
-                        break;
-                    }
-                }
-                norm.extend(chars);
-                norm
-            })
-            .collect();
-
-        // Recompute logical nesting for each unordered list item
-        let mut prev_items: Vec<(usize, usize, usize)> = Vec::new(); // (blockquote_depth, indent, nesting_level)
-        for (_, line) in lines.iter_mut().enumerate() {
-            let orig_line = line.clone();
-            // Inline blockquote prefix parsing (since parse_blockquote_prefix is private)
-            let mut rest = orig_line.as_str();
-            let mut blockquote_prefix = String::new();
-            let mut blockquote_depth = 0;
-            loop {
-                let trimmed = rest.trim_start();
-                if trimmed.starts_with('>') {
-                    // Find the '>' and a single optional space
-                    let after = &trimmed[1..];
-                    let mut chars = after.chars();
-                    let mut space_count = 0;
-                    if let Some(' ') = chars.next() {
-                        space_count = 1;
-                    }
-                    let (spaces, after_marker) = after.split_at(space_count);
-                    blockquote_prefix.push('>');
-                    blockquote_prefix.push_str(spaces);
-                    rest = after_marker;
-                    blockquote_depth += 1;
-                } else {
-                    break;
-                }
-            }
-            // Only process unordered list items outside code blocks
-            if rest.trim().is_empty() || rest.starts_with("```") || rest.starts_with("~~~") {
-                // Do NOT clear prev_items on blank lines; only skip processing
-                continue;
+
+        // Get the warnings to know which lines need indentation fixing
+        let warnings = self.check(ctx)?;
+        let mut lines_to_fix: std::collections::HashSet<usize> = std::collections::HashSet::new();
+        for warning in &warnings {
+            lines_to_fix.insert(warning.line);
+        }
+
+        let element_cache = ElementCache::new(content);
+        let lines: Vec<&str> = content.lines().collect();
+        let mut result_lines: Vec<String> = Vec::new();
+
+        // Check if any list items have tabs that need normalization
+        let mut has_tabs = false;
+        for &line in &lines {
+            if line.contains('\t') && element_cache.get_list_items().iter().any(|item| item.line_number == lines.iter().position(|&l| l == line).unwrap_or(0) + 1) {
+                has_tabs = true;
+                break;
             }
-            // Use the same regex as element_cache
-            let re = regex::Regex::new(r"^(?P<indent>[ ]*)(?P<marker>[*+-])(?P<after>[ ]+)(?P<content>.*)$").unwrap();
-            if let Some(caps) = re.captures(rest) {
-                let indent_str = caps.name("indent").map_or("", |m| m.as_str());
-                let marker = caps.name("marker").unwrap().as_str();
-                let after = caps.name("after").map_or(" ", |m| m.as_str());
-                let content = caps.name("content").map_or("", |m| m.as_str());
-                let indent = indent_str.len();
-                // Compute logical nesting level
-                let mut nesting_level = 0;
-                if let Some(&(_last_bq, last_indent, last_level)) = prev_items.iter().rev().find(|(bq, _, _)| *bq == blockquote_depth) {
-                    if indent > last_indent {
-                        nesting_level = last_level + 1;
-                    } else {
-                        for &(prev_bq, prev_indent, prev_level) in prev_items.iter().rev() {
-                            if prev_bq == blockquote_depth && prev_indent <= indent {
-                                nesting_level = prev_level;
-                                break;
-                            }
+        }
+
+        // If no warnings and no tabs to normalize, return original content
+        if warnings.is_empty() && !has_tabs {
+            return Ok(content.to_string());
+        }
+
+        for (line_idx, &line) in lines.iter().enumerate() {
+            let line_number = line_idx + 1;
+
+            // Check if this line is a list item
+            if let Some(item) = element_cache.get_list_items().iter().find(|item| item.line_number == line_number) {
+                if matches!(item.marker_type, ListMarkerType::Asterisk | ListMarkerType::Plus | ListMarkerType::Minus) {
+                    // Determine if we need to fix this line
+                    let needs_indentation_fix = lines_to_fix.contains(&line_number);
+                    let needs_tab_normalization = line.contains('\t');
+
+                    if needs_indentation_fix || needs_tab_normalization {
+                        let expected_indent = item.nesting_level * self.indent;
+
+                        // Reconstruct the line with correct indentation
+                        let marker_char = match item.marker_type {
+                            ListMarkerType::Asterisk => '*',
+                            ListMarkerType::Plus => '+',
+                            ListMarkerType::Minus => '-',
+                            _ => unreachable!(),
+                        };
+
+                        // Extract the content after the marker and space
+                        let re = regex::Regex::new(r"^(\s*)([*+-])(\s+)(.*)$").unwrap();
+                        if let Some(caps) = re.captures(line) {
+                            let content_part = caps.get(4).map_or("", |m| m.as_str());
+                            let space_after_marker = caps.get(3).map_or(" ", |m| m.as_str());
+                            let correct_indent = " ".repeat(expected_indent);
+                            let fixed_line = format!("{}{}{}{}{}", item.blockquote_prefix, correct_indent, marker_char, space_after_marker, content_part);
+                            result_lines.push(fixed_line);
+                        } else {
+                            // Fallback: just use the original line
+                            result_lines.push(line.to_string());
                         }
+                    } else {
+                        result_lines.push(line.to_string());
                     }
+                } else {
+                    result_lines.push(line.to_string());
                 }
-                // Remove stack entries with indent >= current indent and same blockquote depth
-                while let Some(&(prev_bq, prev_indent, _)) = prev_items.last() {
-                    if prev_bq != blockquote_depth || prev_indent < indent {
-                        break;
-                    }
-                    prev_items.pop();
-                }
-                prev_items.push((blockquote_depth, indent, nesting_level));
-                // Reconstruct line with correct indentation
-                let correct_indent = " ".repeat(nesting_level * self.indent);
-                *line = format!("{}{}{}{}{}", blockquote_prefix, correct_indent, marker, after, content);
             } else {
-                // Only clear prev_items if the line is not blank and not a list item
-                if !rest.trim().is_empty() {
-                    prev_items.clear();
-                }
+                result_lines.push(line.to_string());
             }
         }
-        Ok(lines.join("\n"))
+
+        let result = result_lines.join("\n");
+        if content.ends_with('\n') {
+            Ok(result + "\n")
+        } else {
+            Ok(result)
+        }
     }
 
     /// Get the category of this rule for selective processing

{rumdl-0.0.65 → rumdl-0.0.66}/src/rules/md030_list_marker_space.rs

@@ -185,8 +185,9 @@ impl Rule for MD030ListMarkerSpace {
         ))
     }
 
-    fn fix(&self, _ctx: &crate::lint_context::LintContext) -> Result<String, crate::rule::LintError> {
-        Err(crate::rule::LintError::FixFailed("Automatic fixing is not supported for MD030. See todos/md030_fix_strategy.md for details.".to_string()))
+    fn fix(&self, ctx: &crate::lint_context::LintContext) -> Result<String, crate::rule::LintError> {
+        // MD030 is not fixable - return content unchanged
+        Ok(ctx.content.to_string())
     }
 }
 

{rumdl-0.0.65 → rumdl-0.0.66}/src/rules/md034_no_bare_urls.rs

@@ -284,13 +284,17 @@ impl MD034NoBareUrls {
                     if let Some(pos) = &text.position {
                         let offset = pos.start.offset + url_start;
                         let (line, column) = ctx.offset_to_line_col(offset);
+                        let url_text = &text_str[url_start..url_end];
                         warnings.push(LintWarning {
                             rule_name: Some(self.name()),
                             line,
                             column,
-                            message: format!("Bare URL found: {}", &text_str[url_start..url_end]),
+                            message: format!("Bare URL found: {}", url_text),
                             severity: Severity::Warning,
-                            fix: None, // Fix not implemented yet
+                            fix: Some(Fix {
+                                range: offset..(offset + url_text.len()),
+                                replacement: format!("<{}>", url_text),
+                            }),
                         });
                     }
                 }
@@ -401,45 +405,30 @@ impl Rule for MD034NoBareUrls {
         }
 
         // Get all warnings first - only fix URLs that are actually flagged
-        let warnings = self.check(ctx)?;
+        // Use AST-based detection to match the main linting path (since uses_ast() returns true)
+        let ast = crate::utils::ast_utils::get_cached_ast(content);
+        let warnings = self.check_with_ast(ctx, &ast)?;
         if warnings.is_empty() {
             return Ok(content.to_string());
         }
 
-        // Group warnings by line number for easier processing
-        let mut lines: Vec<String> = content.lines().map(|s| s.to_string()).collect();
+        // Sort warnings by byte offset in reverse order (rightmost first) to avoid offset issues
+        let mut sorted_warnings = warnings.clone();
+        sorted_warnings.sort_by_key(|w| std::cmp::Reverse(w.fix.as_ref().map(|f| f.range.start).unwrap_or(0)));
 
-        // Process warnings line by line (in reverse order to avoid offset issues)
-        let mut warnings_by_line: std::collections::BTreeMap<usize, Vec<&crate::rule::LintWarning>> = std::collections::BTreeMap::new();
-        for warning in &warnings {
-            warnings_by_line.entry(warning.line).or_insert_with(Vec::new).push(warning);
-        }
-
-        // Process lines in reverse order to avoid affecting line indices
-        for (line_num, line_warnings) in warnings_by_line.iter().rev() {
-            let line_idx = line_num - 1;
-            if line_idx >= lines.len() {
-                continue;
-            }
+        let mut result = content.to_string();
+        for warning in sorted_warnings {
+            if let Some(fix) = &warning.fix {
+                let start = fix.range.start;
+                let end = fix.range.end;
 
-            // Sort warnings by column in reverse order (rightmost first)
-            let mut sorted_warnings = line_warnings.clone();
-            sorted_warnings.sort_by_key(|w| std::cmp::Reverse(w.column));
-
-            for warning in sorted_warnings {
-                if let Some(fix) = &warning.fix {
-                    let line = &mut lines[line_idx];
-                    let start = fix.range.start;
-                    let end = fix.range.end;
-
-                    if start <= line.len() && end <= line.len() && start < end {
-                        line.replace_range(start..end, &fix.replacement);
-                    }
+                if start <= result.len() && end <= result.len() && start < end {
+                    result.replace_range(start..end, &fix.replacement);
                 }
             }
         }
 
-        Ok(lines.join("\n"))
+        Ok(result)
     }
 
     /// Get the category of this rule for selective processing

{rumdl-0.0.65 → rumdl-0.0.66}/src/rules/md046_code_block_style.rs

@@ -50,15 +50,148 @@ impl MD046CodeBlockStyle {
             return false;
         }
 
-        // Not a list item
-        let prev_line_is_list = i > 0 && self.is_list_item(lines[i - 1]);
-        if prev_line_is_list {
+        // Check if this is part of a list structure
+        if self.is_part_of_list_structure(lines, i) {
+            return false;
+        }
+
+        // Check if this is part of a formatted text block (not a code block)
+        if self.is_part_of_formatted_text_block(lines, i) {
+            return false;
+        }
+
+        // Check if preceded by a blank line (typical for code blocks)
+        let has_blank_line_before = i == 0 || lines[i - 1].trim().is_empty();
+
+        // If no blank line before, it's likely list continuation, not a code block
+        if !has_blank_line_before {
             return false;
         }
 
         true
     }
 
+    /// Check if an indented line is part of a formatted text block (like license text)
+    /// rather than a code block
+    fn is_part_of_formatted_text_block(&self, lines: &[&str], i: usize) -> bool {
+        let line = lines[i];
+        let trimmed = line.trim();
+
+        // Look for patterns that suggest this is formatted text, not code:
+
+        // 1. License/legal text patterns
+        if trimmed.contains("Copyright") ||
+           trimmed.contains("License") ||
+           trimmed.contains("Foundation") ||
+           trimmed.contains("Certificate") ||
+           trimmed.contains("Origin") ||
+           trimmed.starts_with("Version ") ||
+           trimmed.contains("permitted") ||
+           trimmed.contains("contribution") ||
+           trimmed.contains("certify") {
+            return true;
+        }
+
+        // 2. Address/contact information patterns
+        if trimmed.contains("Drive") ||
+           trimmed.contains("Suite") ||
+           trimmed.contains("CA,") ||
+           trimmed.contains("San Francisco") {
+            return true;
+        }
+
+        // 3. Email signature patterns
+        if trimmed.contains("Signed-off-by:") ||
+           trimmed.contains("@") && trimmed.contains(".com") {
+            return true;
+        }
+
+        // 4. Check if this is part of a larger block of indented text
+        // that looks like formatted prose rather than code
+        let mut consecutive_indented_lines = 0;
+        let mut has_prose_content = false;
+
+        // Look at surrounding lines to see if this is part of a prose block
+        let start = if i >= 5 { i - 5 } else { 0 };
+        let end = if i + 5 < lines.len() { i + 5 } else { lines.len() };
+
+        for j in start..end {
+            let check_line = lines[j];
+            if check_line.starts_with("    ") || check_line.starts_with("\t") {
+                consecutive_indented_lines += 1;
+                let check_trimmed = check_line.trim();
+                // Look for prose indicators
+                if check_trimmed.len() > 20 &&
+                   (check_trimmed.contains(" the ") ||
+                    check_trimmed.contains(" and ") ||
+                    check_trimmed.contains(" or ") ||
+                    check_trimmed.contains(" to ") ||
+                    check_trimmed.contains(" of ") ||
+                    check_trimmed.contains(" in ") ||
+                    check_trimmed.contains(" is ") ||
+                    check_trimmed.contains(" that ")) {
+                    has_prose_content = true;
+                }
+            }
+        }
+
+        // If we have many consecutive indented lines with prose content,
+        // it's likely formatted text, not code
+        if consecutive_indented_lines >= 5 && has_prose_content {
+            return true;
+        }
+
+        false
+    }
+
+        /// Check if an indented line is part of a list structure
+    fn is_part_of_list_structure(&self, lines: &[&str], i: usize) -> bool {
+        // Look backwards to find if we're in a list context
+        // We need to be more aggressive about detecting list contexts
+
+        for j in (0..i).rev() {
+            let line = lines[j];
+
+            // Skip empty lines - they don't break list context
+            if line.trim().is_empty() {
+                continue;
+            }
+
+            // If we find a list item, we're definitely in a list context
+            if self.is_list_item(line) {
+                return true;
+            }
+
+            // Check if this line looks like it's part of a list item
+            // (indented content that's not a code block)
+            let trimmed = line.trim_start();
+            let indent_len = line.len() - trimmed.len();
+
+            // If we find a line that starts at column 0 and is not a list item,
+            // check if it's a structural element that would end list context
+            if indent_len == 0 && !trimmed.is_empty() {
+                // Headings definitely end list context
+                if trimmed.starts_with('#') {
+                    break;
+                }
+                // Horizontal rules end list context
+                if trimmed.starts_with("---") || trimmed.starts_with("***") {
+                    break;
+                }
+                // If it's a paragraph that doesn't look like it's part of a list,
+                // we might not be in a list anymore, but let's be conservative
+                // and keep looking a bit more
+                if j > 0 && j < i - 5 { // Only break if we've looked back a reasonable distance
+                    break;
+                }
+            }
+
+            // Continue looking backwards through indented content
+        }
+
+        false
+    }
+
     /// Helper function to check if a line is part of a list
     fn is_in_list(&self, lines: &[&str], i: usize) -> bool {
         // Check if current line is a list item