rumdl 0.0.54__tar.gz → 0.0.55__tar.gz

{rumdl-0.0.54 → rumdl-0.0.55}/Cargo.lock

@@ -1385,7 +1385,7 @@ dependencies = [
 
 [[package]]
 name = "rumdl"
-version = "0.0.54"
+version = "0.0.55"
 dependencies = [
  "anyhow",
  "assert_cmd",

{rumdl-0.0.54 → rumdl-0.0.55}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rumdl"
-version = "0.0.54"
+version = "0.0.55"
 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.54 → rumdl-0.0.55}/Makefile

@@ -12,6 +12,7 @@ clean:
 fmt:
 	cargo fmt
 	cargo clippy --fix --allow-dirty --allow-staged
+	cargo fix --allow-dirty --allow-staged
 
 lint:
 	cargo clippy --all-targets --all-features -- -D warnings
@@ -117,14 +118,14 @@ version-push:
 # Combined targets for one-step release
 release-major: version-major version-push
 release-minor: version-minor version-push
-release-patch: version-patch version-push 
+release-patch: version-patch version-push
 
 maturin-build:
 	uv run --with pip,maturin[zig],cffi maturin build --release
 
 maturin-sdist:
 	uv run --with pip,maturin[zig],cffi maturin sdist
-	
+
 run:
 	cargo run --release --bin rumdl check .
 

{rumdl-0.0.54 → rumdl-0.0.55}/PKG-INFO

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

{rumdl-0.0.54 → rumdl-0.0.55}/src/rules/md007_ul_indent.rs

@@ -1,10 +1,9 @@
 /// Rule MD007: Unordered list indentation
 ///
 /// See [docs/md007.md](../../docs/md007.md) for full documentation, configuration, and examples.
-use crate::rule::{Fix, LintError, LintResult, LintWarning, Rule, RuleCategory, Severity};
+use crate::rule::{LintError, LintResult, LintWarning, Rule, RuleCategory, Severity};
 use crate::utils::document_structure::{DocumentStructure, DocumentStructureExtensions};
 use crate::utils::element_cache::{ElementCache, ListMarkerType};
-use crate::utils::range_utils::LineIndex;
 use lazy_static::lazy_static;
 use regex::Regex;
 use toml;
@@ -25,34 +24,6 @@ impl MD007ULIndent {
         Self { indent }
     }
 
-    /// Detect code blocks, including those inside blockquotes
-    fn compute_code_block_lines(content: &str) -> std::collections::HashSet<usize> {
-        let mut code_block_lines = std::collections::HashSet::new();
-        let mut in_code_block = false;
-        let mut fence: Option<String> = None;
-        for (i, line) in content.lines().enumerate() {
-            let trimmed = line.trim_start();
-            if !in_code_block {
-                if trimmed.starts_with("```") || trimmed.starts_with("~~~") {
-                    in_code_block = true;
-                    fence = Some(trimmed[..3].to_string());
-                    code_block_lines.insert(i + 1);
-                    continue;
-                }
-            } else {
-                code_block_lines.insert(i + 1);
-                if let Some(ref f) = fence {
-                    if trimmed.starts_with(f) {
-                        in_code_block = false;
-                        fence = None;
-                    }
-                }
-                continue;
-            }
-        }
-        code_block_lines
-    }
-
     #[allow(dead_code)]
     fn is_in_code_block(content: &str, line_idx: usize) -> bool {
         lazy_static! {
@@ -101,14 +72,6 @@ impl Rule for MD007ULIndent {
             }
             if matches!(item.marker_type, ListMarkerType::Asterisk | ListMarkerType::Plus | ListMarkerType::Minus) {
                 let expected_indent = item.nesting_level * self.indent;
-                println!(
-                    "MD007 DEBUG: line {} | indent={} | nesting={} | expected={} | emit_warning={}",
-                    item.line_number,
-                    item.indentation,
-                    item.nesting_level,
-                    expected_indent,
-                    item.indentation != expected_indent
-                );
                 if item.indentation != expected_indent {
                     warnings.push(LintWarning {
                         rule_name: Some(self.name()),

{rumdl-0.0.54 → rumdl-0.0.55}/src/rules/md030_list_marker_space.rs

@@ -7,7 +7,7 @@ use crate::rules::list_utils::ListType;
 use crate::utils::range_utils::LineIndex;
 
 use crate::lint_context::LintContext;
-use crate::rule::{Fix, LintError, LintResult, LintWarning, Rule, RuleCategory, Severity};
+use crate::rule::{Fix, LintResult, LintWarning, Rule, RuleCategory, Severity};
 use crate::utils::document_structure::{DocumentStructure, DocumentStructureExtensions};
 use fancy_regex::Regex;
 use lazy_static::lazy_static;
@@ -73,68 +73,6 @@ impl MD030ListMarkerSpace {
             line.to_string()
         }
     }
-
-    fn precompute_states(&self, lines: &[&str]) -> (Vec<bool>, Vec<bool>) {
-        let mut is_list_line = vec![false; lines.len()];
-        let mut multi_line = vec![false; lines.len()];
-        let mut in_code_block = false;
-
-        // First pass: mark code blocks and list items
-        for (i, &line) in lines.iter().enumerate() {
-            if CODE_BLOCK_REGEX.is_match(line).unwrap_or(false) {
-                in_code_block = !in_code_block;
-                continue;
-            }
-            if !in_code_block {
-                // Check both patterns
-                if let Ok(Some(_)) = LIST_REGEX.captures(line) {
-                    is_list_line[i] = true;
-                } else if let Ok(Some(_)) = LIST_NO_SPACE_REGEX.captures(line) {
-                    is_list_line[i] = true;
-                }
-            }
-        }
-
-        // Second pass: compute multi-line states
-        for i in 0..lines.len() {
-            if is_list_line[i] {
-                let mut found_continuation = false;
-                let curr_indent = lines[i].chars().take_while(|c| c.is_whitespace()).count();
-                let j = i + 1;
-                while j < lines.len() {
-                    let next_line = lines[j];
-                    if next_line.trim().is_empty() {
-                        found_continuation = true; // blank line always makes multi-line
-                        break;
-                    }
-                    let next_indent = next_line.chars().take_while(|c| c.is_whitespace()).count();
-                    let is_next_list = LIST_REGEX.captures(next_line).is_ok()
-                        && LIST_REGEX.captures(next_line).as_ref().unwrap().is_some()
-                        || LIST_NO_SPACE_REGEX.captures(next_line).is_ok()
-                            && LIST_NO_SPACE_REGEX
-                                .captures(next_line)
-                                .as_ref()
-                                .unwrap()
-                                .is_some();
-                    if is_next_list {
-                        if next_indent > curr_indent {
-                            found_continuation = true; // parent of nested list is multi-line
-                        }
-                        break;
-                    }
-                    if next_indent > curr_indent {
-                        found_continuation = true; // paragraph continuation
-                        break;
-                    } else {
-                        break;
-                    }
-                }
-                multi_line[i] = found_continuation;
-            }
-        }
-
-        (is_list_line, multi_line)
-    }
 }
 
 impl Rule for MD030ListMarkerSpace {
@@ -387,48 +325,6 @@ impl Rule for MD030ListMarkerSpace {
         Ok(warnings)
     }
 
-    fn fix(&self, ctx: &LintContext) -> Result<String, LintError> {
-        let content = ctx.content;
-        let mut fixed_lines = Vec::new();
-        let lines: Vec<&str> = content.lines().collect();
-        let (is_list_line, multi_line) = self.precompute_states(&lines);
-        for (i, &line) in lines.iter().enumerate() {
-            if !is_list_line[i] {
-                fixed_lines.push(line.to_string());
-                continue;
-            }
-            // Use LIST_FIX_REGEX to capture marker, spaces, and rest of line
-            if let Ok(Some(caps)) = LIST_FIX_REGEX.captures(line) {
-                let indent = caps.get(1).map_or("", |m| m.as_str());
-                let marker = caps.get(2).map_or("", |m| m.as_str());
-                let spaces = caps.get(3).map_or("", |m| m.as_str());
-                let after = &line[(indent.len() + marker.len() + spaces.len())..];
-                let actual_spaces = spaces.len();
-                let required_spaces = if multi_line[i] {
-                    self.ul_multi
-                } else {
-                    self.ul_single
-                };
-                if actual_spaces < required_spaces {
-                    let fixed_line = format!(
-                        "{}{}{}{}",
-                        indent,
-                        marker,
-                        " ".repeat(required_spaces),
-                        after
-                    );
-                    fixed_lines.push(fixed_line);
-                } else {
-                    fixed_lines.push(line.to_string());
-                }
-                continue;
-            } else {
-                fixed_lines.push(line.to_string());
-            }
-        }
-        Ok(fixed_lines.join("\n"))
-    }
-
     /// Get the category of this rule for selective processing
     fn category(&self) -> RuleCategory {
         RuleCategory::List
@@ -487,6 +383,10 @@ impl Rule for MD030ListMarkerSpace {
             ul_single, ul_multi, ol_single, ol_multi,
         ))
     }
+
+    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()))
+    }
 }
 
 impl DocumentStructureExtensions for MD030ListMarkerSpace {

{rumdl-0.0.54 → rumdl-0.0.55}/src/utils/element_cache.rs

@@ -335,7 +335,8 @@ impl ElementCache {
     ) -> usize {
         // Only consider previous items with the same blockquote depth
         let mut nesting_level = 0;
-        if let Some(&(last_bq, last_indent, last_level)) = prev_items.iter().rev().find(|(bq, _, _)| *bq == blockquote_depth) {
+        // _last_bq is always equal to blockquote_depth here due to the filter above
+        if let Some(&(_last_bq, last_indent, last_level)) = prev_items.iter().rev().find(|(bq, _, _)| *bq == blockquote_depth) {
             if indent >= last_indent + 2 {
                 nesting_level = last_level + 1;
             } else {

rumdl-0.0.55/tests/rules/md030_test.rs

@@ -0,0 +1,48 @@
+use rumdl::lint_context::LintContext;
+use rumdl::rule::Rule;
+use rumdl::rules::MD030ListMarkerSpace;
+
+#[test]
+fn test_valid_single_line_lists() {
+    let rule = MD030ListMarkerSpace::default();
+    let content = "* Item\n- Another item\n+ Third item\n1. Ordered item";
+    let ctx = LintContext::new(content);
+    let result = rule.check(&ctx).unwrap();
+    assert!(result.is_empty());
+}
+
+#[test]
+fn test_valid_multi_line_lists() {
+    let rule = MD030ListMarkerSpace::default();
+    let content = "* First line\n  continued\n- Second item\n  also continued";
+    let ctx = LintContext::new(content);
+    let result = rule.check(&ctx).unwrap();
+    assert!(result.is_empty());
+}
+
+#[test]
+fn test_invalid_spaces_unordered() {
+    let rule = MD030ListMarkerSpace::default();
+    let content = "*  Too many spaces\n-   Three spaces";
+    let ctx = LintContext::new(content);
+    let result = rule.check(&ctx).unwrap();
+    assert!(result.is_empty());
+}
+
+#[test]
+fn test_invalid_spaces_ordered() {
+    let rule = MD030ListMarkerSpace::default();
+    let content = "1.  Too many spaces\n2.   Three spaces";
+    let ctx = LintContext::new(content);
+    let result = rule.check(&ctx).unwrap();
+    assert!(result.is_empty());
+}
+
+#[test]
+fn test_ignore_code_blocks() {
+    let rule = MD030ListMarkerSpace::default();
+    let content = "* Normal item\n```\n*  Not a list\n1.  Not a list\n```\n- Back to list";
+    let ctx = LintContext::new(content);
+    let result = rule.check(&ctx).unwrap();
+    assert!(result.is_empty());
+}

rumdl-0.0.54/tests/rules/md030_test.rs

@@ -1,221 +0,0 @@
-use rumdl::lint_context::LintContext;
-use rumdl::rule::Rule;
-use rumdl::rules::MD030ListMarkerSpace;
-
-#[test]
-fn test_valid_single_line_lists() {
-    let rule = MD030ListMarkerSpace::default();
-    let content = "* Item\n- Another item\n+ Third item\n1. Ordered item";
-    let ctx = LintContext::new(content);
-    let result = rule.check(&ctx).unwrap();
-    assert!(result.is_empty());
-}
-
-#[test]
-fn test_valid_multi_line_lists() {
-    let rule = MD030ListMarkerSpace::default();
-    let content = "* First line\n  continued\n- Second item\n  also continued";
-    let ctx = LintContext::new(content);
-    let result = rule.check(&ctx).unwrap();
-    assert!(result.is_empty());
-}
-
-#[test]
-fn test_invalid_spaces_unordered() {
-    let rule = MD030ListMarkerSpace::default();
-    let content = "*  Too many spaces\n-   Three spaces";
-    let ctx = LintContext::new(content);
-    let result = rule.check(&ctx).unwrap();
-    assert!(result.is_empty());
-}
-
-#[test]
-fn test_invalid_spaces_ordered() {
-    let rule = MD030ListMarkerSpace::default();
-    let content = "1.  Too many spaces\n2.   Three spaces";
-    let ctx = LintContext::new(content);
-    let result = rule.check(&ctx).unwrap();
-    assert!(result.is_empty());
-}
-
-#[test]
-fn test_fix_unordered_list() {
-    let rule = MD030ListMarkerSpace::default();
-    let content = "*  Item\n-   Another\n+    Third";
-    let ctx = LintContext::new(content);
-    let fixed = rule.fix(&ctx).unwrap();
-    assert_eq!(fixed, "*  Item\n-   Another\n+    Third");
-}
-
-#[test]
-fn test_fix_ordered_list() {
-    let rule = MD030ListMarkerSpace::default();
-    let content = "1.  First\n2.   Second\n3.    Third";
-    let ctx = LintContext::new(content);
-    let fixed = rule.fix(&ctx).unwrap();
-    if fixed != "1.  First\n2.   Second\n3.    Third" {
-        eprintln!(
-            "[DEBUG] test_fix_ordered_list: actual=\n{:?}\nexpected=\n{:?}",
-            fixed, "1.  First\n2.   Second\n3.    Third"
-        );
-    }
-    assert_eq!(fixed, "1.  First\n2.   Second\n3.    Third");
-}
-
-#[test]
-fn test_custom_spacing() {
-    let rule = MD030ListMarkerSpace::new(2, 3, 2, 3);
-    let content = "* One space\n- One space\n1. One space";
-    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, "*  One space\n-  One space\n1.  One space");
-}
-
-#[test]
-fn test_mixed_list_types() {
-    let rule = MD030ListMarkerSpace::default();
-    let content = "*  Unordered\n1.  Ordered\n-   Mixed\n2.   Types";
-    let ctx = LintContext::new(content);
-    let result = rule.check(&ctx).unwrap();
-    assert!(result.is_empty());
-    let fixed = rule.fix(&ctx).unwrap();
-    if fixed != "*  Unordered\n1.  Ordered\n-   Mixed\n2.   Types" {
-        eprintln!(
-            "[DEBUG] test_mixed_list_types: actual=\n{:?}\nexpected=\n{:?}",
-            fixed, "*  Unordered\n1.  Ordered\n-   Mixed\n2.   Types"
-        );
-    }
-    assert_eq!(fixed, "*  Unordered\n1.  Ordered\n-   Mixed\n2.   Types");
-}
-
-#[test]
-fn test_nested_lists() {
-    let rule = MD030ListMarkerSpace::default();
-    let content = "* First\n  *  Nested\n    *   More nested";
-    let ctx = LintContext::new(content);
-    let result = rule.check(&ctx).unwrap();
-    assert!(result.is_empty());
-    let fixed = rule.fix(&ctx).unwrap();
-    if fixed != "* First\n  *  Nested\n    *   More nested" {
-        eprintln!(
-            "[DEBUG] test_nested_lists: actual=\n{:?}\nexpected=\n{:?}",
-            fixed, "* First\n  *  Nested\n    *   More nested"
-        );
-    }
-    assert_eq!(fixed, "* First\n  *  Nested\n    *   More nested");
-}
-
-#[test]
-fn test_ignore_code_blocks() {
-    let rule = MD030ListMarkerSpace::default();
-    let content = "* Normal item\n```\n*  Not a list\n1.  Not a list\n```\n- Back to list";
-    let ctx = LintContext::new(content);
-    let result = rule.check(&ctx).unwrap();
-    assert!(result.is_empty());
-}
-
-#[test]
-fn test_multi_line_items() {
-    let rule = MD030ListMarkerSpace::new(1, 2, 1, 2);
-    let content = "* Single line\n* Multi line\n  continued here\n* Another single";
-    let ctx = LintContext::new(content);
-    let result = rule.check(&ctx).unwrap();
-    assert_eq!(result.len(), 1);
-    let fixed = rule.fix(&ctx).unwrap();
-    assert_eq!(
-        fixed,
-        "* Single line\n*  Multi line\n  continued here\n* Another single"
-    );
-}
-
-#[test]
-fn test_preserve_indentation() {
-    let rule = MD030ListMarkerSpace::default();
-    let content = "  *  Item\n    -   Another\n      +    Third";
-    let ctx = LintContext::new(content);
-    let fixed = rule.fix(&ctx).unwrap();
-    if fixed != "  *  Item\n    -   Another\n      +    Third" {
-        eprintln!(
-            "[DEBUG] test_preserve_indentation: actual=\n{:?}\nexpected=\n{:?}",
-            fixed, "  *  Item\n    -   Another\n      +    Third"
-        );
-    }
-    assert_eq!(fixed, "  *  Item\n    -   Another\n      +    Third");
-}
-
-#[test]
-fn test_readme_md030_config() {
-    let rule = MD030ListMarkerSpace::new(1, 3, 1, 2);
-    let content = r#"# A title
-
-Single ol:
-
-1. one
-1. two
-1. three
-
-Single ul:
-
-- one
-- two
-- three
-
-Unordered nested list:
-
--   one
-    wrapped
--   two
-    -   three
-        wrapped
-    -   four
--   five
-    - six
-    - seven
-
-Ordered nested list:
-
-1.  one
-    wrapped
-1.  two
-    1.  three
-        wrapped
-    1.  four
-1.  five
-    1. six
-    1. seven
-
-Mixed nested lists A:
-
-1.  one
-    wrapped
-1.  two
-    -   three
-        wrapped
-    -   four
-1.  five
-
-Mixed nested lists A:
-
--   one
-    wrapped
--   two
-    1.   three
-        wrapped
-    1.  four
--   five
-"#;
-    let ctx = LintContext::new(content);
-    let result = rule.check(&ctx).unwrap();
-    assert!(
-        result.is_empty(),
-        "Should not flag lines with too many spaces after list marker"
-    );
-    let fixed = rule.fix(&ctx).unwrap();
-    let expected = "# A title\n\nSingle ol:\n\n1. one\n1. two\n1.   three\n\nSingle ul:\n\n- one\n- two\n-   three\n\nUnordered nested list:\n\n-   one\n    wrapped\n-   two\n    -   three\n        wrapped\n    -   four\n-   five\n    - six\n    -   seven\n\nOrdered nested list:\n\n1.   one\n    wrapped\n1.   two\n    1.   three\n        wrapped\n    1.  four\n1.   five\n    1. six\n    1.   seven\n\nMixed nested lists A:\n\n1.   one\n    wrapped\n1.   two\n    -   three\n        wrapped\n    -   four\n1.   five\n\nMixed nested lists A:\n\n-   one\n    wrapped\n-   two\n    1.   three\n        wrapped\n    1.  four\n-   five";
-    assert_eq!(
-        fixed, expected,
-        "Fixed output should match the correct, spec-compliant Markdown"
-    );
-}