rumdl 0.0.101__tar.gz → 0.0.102__tar.gz

{rumdl-0.0.101 → rumdl-0.0.102}/CHANGELOG.md

@@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.102] - 2025-07-24
+
 ## [0.0.101] - 2025-07-23
 
 ## [0.0.100] - 2025-07-22
@@ -245,7 +247,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Initial implementation of remaining rules for markdownlint parity
 
-[Unreleased]: https://github.com/rvben/rumdl/compare/v0.0.101...HEAD
+[Unreleased]: https://github.com/rvben/rumdl/compare/v0.0.102...HEAD
+[0.0.102]: https://github.com/rvben/rumdl/compare/v0.0.101...v0.0.102
 [0.0.101]: https://github.com/rvben/rumdl/compare/v0.0.100...v0.0.101
 [0.0.100]: https://github.com/rvben/rumdl/compare/v0.0.99...v0.0.100
 [0.0.99]: https://github.com/rvben/rumdl/compare/v0.0.98...v0.0.99

{rumdl-0.0.101 → rumdl-0.0.102}/Cargo.lock

@@ -1493,7 +1493,7 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "rumdl"
-version = "0.0.101"
+version = "0.0.102"
 dependencies = [
  "anyhow",
  "assert_cmd",

{rumdl-0.0.101 → rumdl-0.0.102}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rumdl"
-version = "0.0.101"
+version = "0.0.102"
 edition = "2024"
 rust-version = "1.88.0"
 description = "A fast Markdown linter written in Rust (Ru(st) MarkDown Linter)"

{rumdl-0.0.101 → rumdl-0.0.102}/PKG-INFO

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

{rumdl-0.0.101 → rumdl-0.0.102}/src/rules/md005_list_indent.rs

@@ -16,16 +16,56 @@ use toml;
 pub struct MD005ListIndent;
 
 impl MD005ListIndent {
-    // Determine the expected indentation for a list item at a specific level
+    // Determine the expected indentation for a list item
+    // Each nested item should align with the text content of its parent
     #[inline]
-    fn get_expected_indent(level: usize) -> usize {
+    fn get_expected_indent(level: usize, parent_text_position: Option<usize>) -> usize {
         if level == 1 {
             0 // Top level items should be at the start of the line
+        } else if let Some(pos) = parent_text_position {
+            // Align with parent's text content
+            pos
         } else {
-            2 * (level - 1) // Nested items should be indented by 2 spaces per level
+            // Fallback to standard nested indentation: 2 spaces per level
+            2 * (level - 1)
         }
     }
 
+    /// Get parent info for any list item to determine proper text alignment
+    /// Returns parent_text_position where the child should align
+    fn get_parent_text_position(
+        &self,
+        ctx: &crate::lint_context::LintContext,
+        current_line: usize,
+        current_indent: usize,
+    ) -> Option<usize> {
+        // Look backward from current line to find parent item
+        for line_idx in (1..current_line).rev() {
+            if let Some(line_info) = ctx.line_info(line_idx) {
+                if let Some(list_item) = &line_info.list_item {
+                    // Found a list item - check if it's at a lower indentation (parent level)
+                    if list_item.marker_column < current_indent {
+                        // This is a parent item - calculate where child should align
+                        if list_item.is_ordered {
+                            // For ordered lists, align with text start
+                            let text_start_pos = list_item.marker_column + list_item.marker.len() + 1; // +1 for space after marker
+                            return Some(text_start_pos);
+                        } else {
+                            // For unordered lists, align with text start
+                            let text_start_pos = list_item.marker_column + 2; // "* " or "- " or "+ "
+                            return Some(text_start_pos);
+                        }
+                    }
+                }
+                // If we encounter non-blank, non-list content at column 0, stop looking
+                else if !line_info.is_blank && line_info.indent == 0 {
+                    break;
+                }
+            }
+        }
+        None
+    }
+
     /// Group related list blocks that should be treated as one logical list structure
     fn group_related_list_blocks<'a>(
         &self,
@@ -138,7 +178,19 @@ impl MD005ListIndent {
             // Sort by line number to process in order
             group.sort_by_key(|(line_num, _, _)| *line_num);
 
-            let expected_indent = Self::get_expected_indent(level);
+            // Get parent text position for proper alignment
+            let parent_text_position = if level > 1 {
+                // Get parent info from the first item in the group
+                if let Some((line_num, indent, _)) = group.first() {
+                    self.get_parent_text_position(ctx, *line_num, *indent)
+                } else {
+                    None
+                }
+            } else {
+                None
+            };
+
+            let expected_indent = Self::get_expected_indent(level, parent_text_position);
 
             // Check if items in this level have consistent indentation
             let indents: std::collections::HashSet<usize> = group.iter().map(|(_, indent, _)| *indent).collect();
@@ -395,11 +447,13 @@ mod tests {
         let content = "\
 1. Item 1
 2. Item 2
-  1. Nested 1
-  2. Nested 2
+   1. Nested 1
+   2. Nested 2
 3. Item 3";
         let ctx = LintContext::new(content);
         let result = rule.check(&ctx).unwrap();
+        // With dynamic alignment, nested items should align with parent's text content
+        // Ordered items starting with "1. " have text at column 3, so nested items need 3 spaces
         assert!(result.is_empty());
     }
 
@@ -412,9 +466,11 @@ mod tests {
    * Nested 1";
         let ctx = LintContext::new(content);
         let result = rule.check(&ctx).unwrap();
-        assert_eq!(result.len(), 2);
+        // With dynamic alignment, line 3 correctly aligns with line 2's text position
+        // Only line 2 is incorrectly indented
+        assert_eq!(result.len(), 1);
         let fixed = rule.fix(&ctx).unwrap();
-        assert_eq!(fixed, "* Item 1\n  * Item 2\n    * Nested 1");
+        assert_eq!(fixed, "* Item 1\n  * Item 2\n   * Nested 1");
     }
 
     #[test]
@@ -428,7 +484,10 @@ mod tests {
         let result = rule.check(&ctx).unwrap();
         assert_eq!(result.len(), 1);
         let fixed = rule.fix(&ctx).unwrap();
-        assert_eq!(fixed, "1. Item 1\n  2. Item 2\n    1. Nested 1");
+        // With dynamic alignment, ordered items align with parent's text content
+        // Line 1 text starts at col 3, so line 2 should have 3 spaces
+        // Line 3 already correctly aligns with line 2's text position
+        assert_eq!(fixed, "1. Item 1\n   2. Item 2\n    1. Nested 1");
     }
 
     #[test]
@@ -455,12 +514,15 @@ mod tests {
         let result = rule.check(&ctx).unwrap();
         assert_eq!(result.len(), 2);
         let fixed = rule.fix(&ctx).unwrap();
+        // With dynamic alignment:
+        // Level 2 aligns with Level 1's text (2 spaces)
+        // Level 3 aligns with Level 2's text (5 spaces: 2 + "* " + 1)
         assert_eq!(
             fixed,
             "\
 * Level 1
   * Level 2
-    * Level 3"
+     * Level 3"
         );
     }
 
@@ -519,11 +581,14 @@ Even more text";
 * Back to 1";
         let ctx = LintContext::new(content);
         let result = rule.check(&ctx).unwrap();
-        assert_eq!(result.len(), 4);
+        // With dynamic alignment, fewer items need correction
+        // Lines 2,4: should align with Level 1's text (2 spaces)
+        // Line 5: should align with "Back to 2"'s text (5 spaces)
+        assert_eq!(result.len(), 3);
         let fixed = rule.fix(&ctx).unwrap();
         assert_eq!(
             fixed,
-            "* Level 1\n  * Level 2\n    * Level 3\n  * Back to 2\n      1. Ordered 3\n    2. Still 3\n* Back to 1"
+            "* Level 1\n  * Level 2\n     * Level 3\n  * Back to 2\n     1. Ordered 3\n     2. Still 3\n* Back to 1"
         );
     }
 
@@ -686,16 +751,14 @@ Even more text";
    * Wrong 4";
         let ctx = LintContext::new(content);
         let fixed = rule.fix(&ctx).unwrap();
-        // Verify all items are correctly indented
+        // With dynamic alignment, items align with their parent's text content
         let lines: Vec<&str> = fixed.lines().collect();
         assert_eq!(lines[0], "* Item 1");
         assert_eq!(lines[1], "  * Wrong 1");
-        assert_eq!(lines[2], "    * Wrong 2");
-        assert_eq!(lines[3], "      * Wrong 3");
-        // The "Correct" item with 2 spaces is treated as level 3 after the 4-space item
-        // This is because MD005 tracks consistency within the current list context
-        assert_eq!(lines[4], "    * Correct");
-        assert_eq!(lines[5], "    * Wrong 4");
+        assert_eq!(lines[2], "   * Wrong 2"); // Aligns with line 2's text
+        assert_eq!(lines[3], "     * Wrong 3"); // Aligns with line 3's text
+        assert_eq!(lines[4], "   * Correct"); // Back to level 2, aligns with line 1's text
+        assert_eq!(lines[5], "   * Wrong 4"); // Same level as "Correct"
     }
 
     #[test]
@@ -785,6 +848,56 @@ Even more text";
         assert!(result.iter().any(|w| w.line == 2 && w.message.contains("found 3")));
     }
 
+    #[test]
+    fn test_nested_bullets_under_numbered_items() {
+        let rule = MD005ListIndent;
+        let content = "\
+1. **Active Directory/LDAP**
+   - User authentication and directory services
+   - LDAP for user information and validation
+
+2. **Oracle Unified Directory (OUD)**
+   - Extended user directory services
+   - Verification of project account presence and changes";
+        let ctx = LintContext::new(content);
+        let result = rule.check(&ctx).unwrap();
+        // Should have no warnings - 3 spaces is correct for bullets under numbered items
+        assert!(
+            result.is_empty(),
+            "Expected no warnings for bullets with 3 spaces under numbered items, got: {result:?}"
+        );
+    }
+
+    #[test]
+    fn test_nested_bullets_under_numbered_items_wrong_indent() {
+        let rule = MD005ListIndent;
+        let content = "\
+1. **Active Directory/LDAP**
+  - Wrong: only 2 spaces
+   - Correct: 3 spaces";
+        let ctx = LintContext::new(content);
+        let result = rule.check(&ctx).unwrap();
+        // Should flag the 2-space indentation as wrong
+        assert_eq!(result.len(), 2); // Both items flagged due to inconsistency
+        assert!(result.iter().any(|w| w.line == 2 && w.message.contains("found 2")));
+    }
+
+    #[test]
+    fn test_regular_nested_bullets_still_work() {
+        let rule = MD005ListIndent;
+        let content = "\
+* Top level
+  * Second level (2 spaces is correct for bullets under bullets)
+    * Third level (4 spaces)";
+        let ctx = LintContext::new(content);
+        let result = rule.check(&ctx).unwrap();
+        // Should have no warnings - regular bullet nesting still uses 2-space increments
+        assert!(
+            result.is_empty(),
+            "Expected no warnings for regular bullet nesting, got: {result:?}"
+        );
+    }
+
     #[test]
     fn test_fix_range_accuracy() {
         let rule = MD005ListIndent;

{rumdl-0.0.101 → rumdl-0.0.102}/src/rules/md006_start_bullets.rs

@@ -16,6 +16,32 @@ use crate::utils::regex_cache::UNORDERED_LIST_MARKER_REGEX;
 pub struct MD006StartBullets;
 
 impl MD006StartBullets {
+    /// Check if a bullet is nested under an ordered list item
+    fn is_nested_under_ordered_item(
+        &self,
+        ctx: &crate::lint_context::LintContext,
+        current_line: usize,
+        current_indent: usize,
+    ) -> bool {
+        // Look backward from current line to find parent item
+        for line_idx in (1..current_line).rev() {
+            if let Some(line_info) = ctx.line_info(line_idx) {
+                if let Some(list_item) = &line_info.list_item {
+                    // Found a list item - check if it's at a lower indentation (parent level)
+                    if list_item.marker_column < current_indent {
+                        // This is a parent item - check if it's ordered
+                        return list_item.is_ordered;
+                    }
+                }
+                // If we encounter non-blank, non-list content at column 0, stop looking
+                else if !line_info.is_blank && line_info.indent == 0 {
+                    break;
+                }
+            }
+        }
+        false
+    }
+
     /// Optimized check using centralized list blocks
     fn check_optimized(&self, ctx: &crate::lint_context::LintContext) -> LintResult {
         let content = ctx.content;
@@ -47,21 +73,26 @@ impl MD006StartBullets {
                             // Top-level items are always valid
                             is_valid = true;
                         } else {
-                            // Check if this is a valid nested item
-                            match Self::find_relevant_previous_bullet(&lines, line_idx) {
-                                Some((prev_idx, prev_indent)) => {
-                                    match prev_indent.cmp(&indent) {
-                                        std::cmp::Ordering::Less | std::cmp::Ordering::Equal => {
-                                            // Valid nesting or sibling if previous item was valid
-                                            is_valid = valid_bullet_lines[prev_idx];
-                                        }
-                                        std::cmp::Ordering::Greater => {
-                                            // remains invalid
+                            // Check if this is nested under an ordered item with correct indentation (3 spaces)
+                            if indent == 3 && self.is_nested_under_ordered_item(ctx, item_line, indent) {
+                                is_valid = true;
+                            } else {
+                                // Check if this is a valid nested item under another bullet
+                                match Self::find_relevant_previous_bullet(&lines, line_idx) {
+                                    Some((prev_idx, prev_indent)) => {
+                                        match prev_indent.cmp(&indent) {
+                                            std::cmp::Ordering::Less | std::cmp::Ordering::Equal => {
+                                                // Valid nesting or sibling if previous item was valid
+                                                is_valid = valid_bullet_lines[prev_idx];
+                                            }
+                                            std::cmp::Ordering::Greater => {
+                                                // remains invalid
+                                            }
                                         }
                                     }
-                                }
-                                None => {
-                                    // Indented item with no previous bullet remains invalid
+                                    None => {
+                                        // Indented item with no previous bullet remains invalid
+                                    }
                                 }
                             }
                         }
@@ -444,4 +475,58 @@ mod tests {
             "Standard nesting (* Item ->   * Item) should NOT generate warnings, found: {result:?}"
         );
     }
+
+    #[test]
+    fn test_bullets_nested_under_numbered_items() {
+        let rule = MD006StartBullets;
+        let content = "\
+1. **Active Directory/LDAP**
+   - User authentication and directory services
+   - LDAP for user information and validation
+
+2. **Oracle Unified Directory (OUD)**
+   - Extended user directory services";
+        let ctx = crate::lint_context::LintContext::new(content);
+        let result = rule.check(&ctx).unwrap();
+        // Should have no warnings - 3 spaces is valid for bullets under numbered items
+        assert!(
+            result.is_empty(),
+            "Expected no warnings for bullets with 3 spaces under numbered items, got: {result:?}"
+        );
+    }
+
+    #[test]
+    fn test_bullets_nested_under_numbered_items_wrong_indent() {
+        let rule = MD006StartBullets;
+        let content = "\
+1. **Active Directory/LDAP**
+  - Wrong: only 2 spaces
+    - Also wrong: 4 spaces";
+        let ctx = crate::lint_context::LintContext::new(content);
+        let result = rule.check(&ctx).unwrap();
+        // Should flag the incorrect indentations
+        assert_eq!(
+            result.len(),
+            2,
+            "Expected warnings for bullets with incorrect spacing under numbered items"
+        );
+        assert!(result.iter().any(|w| w.line == 2));
+        assert!(result.iter().any(|w| w.line == 3));
+    }
+
+    #[test]
+    fn test_regular_bullet_nesting_still_works() {
+        let rule = MD006StartBullets;
+        let content = "\
+* Top level
+  * Nested bullet (2 spaces is correct)
+    * Deeply nested (4 spaces)";
+        let ctx = crate::lint_context::LintContext::new(content);
+        let result = rule.check(&ctx).unwrap();
+        // Should have no warnings - standard bullet nesting still works
+        assert!(
+            result.is_empty(),
+            "Expected no warnings for standard bullet nesting, got: {result:?}"
+        );
+    }
 }