rumdl 0.0.99__tar.gz → 0.0.100__tar.gz

{rumdl-0.0.99 → rumdl-0.0.100}/CHANGELOG.md

@@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.100] - 2025-07-22
+
 ## [0.0.99] - 2025-07-22
 
 ### Fixed
@@ -223,7 +225,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.99...HEAD
+[Unreleased]: https://github.com/rvben/rumdl/compare/v0.0.100...HEAD
+[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
 [0.0.98]: https://github.com/rvben/rumdl/compare/v0.0.97...v0.0.98
 [0.0.97]: https://github.com/rvben/rumdl/compare/v0.0.96...v0.0.97

{rumdl-0.0.99 → rumdl-0.0.100}/Cargo.lock

@@ -859,9 +859,9 @@ checksum = "f4c7245a08504955605670dbf141fceab975f15ca21570696aebe9d2e71576bd"
 
 [[package]]
 name = "io-uring"
-version = "0.7.8"
+version = "0.7.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b86e202f00093dcba4275d4636b93ef9dd75d025ae560d2521b45ea28ab49013"
+checksum = "d93587f37623a1a17d94ef2bc9ada592f5465fe7732084ab7beefabe5c77c0c4"
 dependencies = [
  "bitflags 2.9.1",
  "cfg-if",
@@ -1397,9 +1397,9 @@ checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
 
 [[package]]
 name = "rand"
-version = "0.9.1"
+version = "0.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fbfd9d094a40bf3ae768db9361049ace4c0e04a4fd6b359518bd7b73a73dd97"
+checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
 dependencies = [
  "rand_chacha",
  "rand_core",
@@ -1455,9 +1455,9 @@ dependencies = [
 
 [[package]]
 name = "redox_syscall"
-version = "0.5.13"
+version = "0.5.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d04b7d0ee6b4a0207a0a7adb104d23ecb0b47d6beae7152d0fa34b692b29fd6"
+checksum = "7e8af0dde094006011e6a740d4879319439489813bd0bcdc7d821beaeeff48ec"
 dependencies = [
  "bitflags 2.9.1",
 ]
@@ -1493,7 +1493,7 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "rumdl"
-version = "0.0.99"
+version = "0.0.100"
 dependencies = [
  "anyhow",
  "assert_cmd",

{rumdl-0.0.99 → rumdl-0.0.100}/Cargo.toml

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

{rumdl-0.0.99 → rumdl-0.0.100}/Makefile

@@ -124,6 +124,12 @@ update-readme-version:
 	@rm -f README.md.bak
 	@echo "README.md updated to rev $(NEW_TAG)"
 
+update-all-docs-version:
+	@echo "Updating all documentation to use $(NEW_TAG)..."
+	@perl -i.bak -E 's/rev: v[0-9]+\.[0-9]+\.[0-9]+/rev: $(NEW_TAG)/g' README.md docs/global-settings.md ../rumdl-pre-commit/README.md 2>/dev/null || true
+	@rm -f README.md.bak docs/global-settings.md.bak ../rumdl-pre-commit/README.md.bak 2>/dev/null || true
+	@echo "All documentation updated to rev $(NEW_TAG)"
+
 update-changelog:
 	@echo "Updating CHANGELOG.md for $(NEW_TAG)..."
 	@if [ -f CHANGELOG.md ]; then \
@@ -145,9 +151,9 @@ version-major:
 	$(eval VERSION_NO_V := $(NEW_MAJOR).0.0)
 	@echo "Current: $(CURRENT) -> New: $(NEW_TAG)"
 	@$(MAKE) update-cargo-version VERSION_NO_V=$(VERSION_NO_V)
-	@$(MAKE) update-readme-version NEW_TAG=$(NEW_TAG)
+	@$(MAKE) update-all-docs-version NEW_TAG=$(NEW_TAG)
 	@$(MAKE) update-changelog NEW_TAG=$(NEW_TAG) VERSION_NO_V=$(VERSION_NO_V) CURRENT=$(CURRENT)
-	@git add Cargo.toml Cargo.lock README.md CHANGELOG.md
+	@git add Cargo.toml Cargo.lock README.md docs/global-settings.md CHANGELOG.md
 	@git commit -m "Bump version to $(NEW_TAG)"
 	@git tag -a $(NEW_TAG) -m "Release $(NEW_TAG)"
 	@echo "Version $(NEW_TAG) created and committed. Run 'git push && git push origin $(NEW_TAG)' to trigger release workflow."
@@ -162,9 +168,9 @@ version-minor:
 	$(eval VERSION_NO_V := $(MAJOR).$(NEW_MINOR).0)
 	@echo "Current: $(CURRENT) -> New: $(NEW_TAG)"
 	@$(MAKE) update-cargo-version VERSION_NO_V=$(VERSION_NO_V)
-	@$(MAKE) update-readme-version NEW_TAG=$(NEW_TAG)
+	@$(MAKE) update-all-docs-version NEW_TAG=$(NEW_TAG)
 	@$(MAKE) update-changelog NEW_TAG=$(NEW_TAG) VERSION_NO_V=$(VERSION_NO_V) CURRENT=$(CURRENT)
-	@git add Cargo.toml Cargo.lock README.md CHANGELOG.md
+	@git add Cargo.toml Cargo.lock README.md docs/global-settings.md CHANGELOG.md
 	@git commit -m "Bump version to $(NEW_TAG)"
 	@git tag -a $(NEW_TAG) -m "Release $(NEW_TAG)"
 	@echo "Version $(NEW_TAG) created and committed. Run 'git push && git push origin $(NEW_TAG)' to trigger release workflow."
@@ -180,9 +186,9 @@ version-patch:
 	$(eval VERSION_NO_V := $(MAJOR).$(MINOR).$(NEW_PATCH))
 	@echo "Current: $(CURRENT) -> New: $(NEW_TAG)"
 	@$(MAKE) update-cargo-version VERSION_NO_V=$(VERSION_NO_V)
-	@$(MAKE) update-readme-version NEW_TAG=$(NEW_TAG)
+	@$(MAKE) update-all-docs-version NEW_TAG=$(NEW_TAG)
 	@$(MAKE) update-changelog NEW_TAG=$(NEW_TAG) VERSION_NO_V=$(VERSION_NO_V) CURRENT=$(CURRENT)
-	@git add Cargo.toml Cargo.lock README.md CHANGELOG.md
+	@git add Cargo.toml Cargo.lock README.md docs/global-settings.md CHANGELOG.md
 	@git commit -m "Bump version to $(NEW_TAG)"
 	@git tag -a $(NEW_TAG) -m "Release $(NEW_TAG)"
 	@echo "Version $(NEW_TAG) created and committed. Run 'git push && git push origin $(NEW_TAG)' to trigger release workflow."

{rumdl-0.0.99 → rumdl-0.0.100}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rumdl
-Version: 0.0.99
+Version: 0.0.100
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -242,7 +242,7 @@ Add the following to your `.pre-commit-config.yaml`:
 ```yaml
 repos:
   - repo: https://github.com/rvben/rumdl-pre-commit
-    rev: v0.0.45  # Use the latest release tag
+    rev: v0.0.99  # Use the latest release tag
     hooks:
       - id: rumdl
         # To only check (default):

{rumdl-0.0.99 → rumdl-0.0.100}/README.md

@@ -211,7 +211,7 @@ Add the following to your `.pre-commit-config.yaml`:
 ```yaml
 repos:
   - repo: https://github.com/rvben/rumdl-pre-commit
-    rev: v0.0.45  # Use the latest release tag
+    rev: v0.0.99  # Use the latest release tag
     hooks:
       - id: rumdl
         # To only check (default):

{rumdl-0.0.99 → rumdl-0.0.100}/docs/global-settings.md

@@ -492,7 +492,7 @@ find . -name "*.md" -o -name "*.markdown" | head -10
 
 ```yaml
 - repo: https://github.com/rvben/rumdl-pre-commit
-  rev: v0.0.45
+  rev: v0.0.99
   hooks:
     - id: rumdl
       args: [--config=.rumdl.toml]

rumdl-0.0.100/scripts/update-pre-commit-docs.sh

@@ -0,0 +1,35 @@
+#!/bin/bash
+# Script to update rumdl-pre-commit version references in documentation
+
+set -e
+
+# Get the latest release version
+LATEST_VERSION=$(gh release list --repo rvben/rumdl --limit 1 | awk '{print $1}')
+
+if [ -z "$LATEST_VERSION" ]; then
+    echo "Error: Could not determine latest version"
+    exit 1
+fi
+
+echo "Latest rumdl version: $LATEST_VERSION"
+
+# Update version in all documentation files
+FILES=(
+    "README.md"
+    "docs/global-settings.md"
+    "../rumdl-pre-commit/README.md"
+)
+
+for file in "${FILES[@]}"; do
+    if [ -f "$file" ]; then
+        echo "Updating $file..."
+        # Update rev: vX.X.X patterns
+        sed -i.bak -E "s/rev: v[0-9]+\.[0-9]+\.[0-9]+/rev: $LATEST_VERSION/g" "$file"
+        # Clean up backup files
+        rm -f "${file}.bak"
+    else
+        echo "Warning: $file not found"
+    fi
+done
+
+echo "Documentation updated to use $LATEST_VERSION"

{rumdl-0.0.99 → rumdl-0.0.100}/src/lint_context.rs

@@ -1263,52 +1263,130 @@ fn merge_adjacent_list_blocks(list_blocks: &mut Vec<ListBlock>, lines: &[LineInf
         return;
     }
 
-    let mut merged = Vec::new();
-    let mut current = list_blocks[0].clone();
-
-    for next in list_blocks.iter().skip(1) {
-        // Check if blocks should be merged
-        // For MD032 purposes, consecutive unordered lists with different markers
-        // should be treated as one list block only if truly consecutive
-        let consecutive = next.start_line == current.end_line + 1;
-        let only_blank_between = next.start_line == current.end_line + 2;
-
-        // For ordered lists, we need to be more careful about merging
-        let should_merge_condition = if current.is_ordered && next.is_ordered {
-            // Only merge ordered lists if there's meaningful content between them
-            // (like code blocks, continuation paragraphs) not just blank lines
-            consecutive || has_meaningful_content_between(&current, next, lines)
-        } else {
-            // For unordered lists, use original logic
-            consecutive || (only_blank_between && current.marker == next.marker)
-        };
-
-        let should_merge = next.is_ordered == current.is_ordered
-            && next.blockquote_prefix == current.blockquote_prefix
-            && next.nesting_level == current.nesting_level
-            && should_merge_condition;
-
-        if should_merge {
-            // Merge blocks
-            current.end_line = next.end_line;
-            current.item_lines.extend_from_slice(&next.item_lines);
-
-            // Update marker consistency
-            if !current.is_ordered && current.marker.is_some() && next.marker.is_some() && current.marker != next.marker
-            {
-                current.marker = None; // Mixed markers
+    let mut merger = ListBlockMerger::new(lines);
+    *list_blocks = merger.merge(list_blocks);
+}
+
+/// Helper struct to manage the complex logic of merging list blocks
+struct ListBlockMerger<'a> {
+    lines: &'a [LineInfo],
+}
+
+impl<'a> ListBlockMerger<'a> {
+    fn new(lines: &'a [LineInfo]) -> Self {
+        Self { lines }
+    }
+
+    fn merge(&mut self, list_blocks: &[ListBlock]) -> Vec<ListBlock> {
+        let mut merged = Vec::with_capacity(list_blocks.len());
+        let mut current = list_blocks[0].clone();
+
+        for next in list_blocks.iter().skip(1) {
+            if self.should_merge_blocks(&current, next) {
+                current = self.merge_two_blocks(current, next);
+            } else {
+                merged.push(current);
+                current = next.clone();
             }
-        } else {
-            // Save current and start new
-            merged.push(current);
-            current = next.clone();
         }
+
+        merged.push(current);
+        merged
+    }
+
+    /// Determine if two adjacent list blocks should be merged
+    fn should_merge_blocks(&self, current: &ListBlock, next: &ListBlock) -> bool {
+        // Basic compatibility checks
+        if !self.blocks_are_compatible(current, next) {
+            return false;
+        }
+
+        // Check spacing and content between blocks
+        let spacing = self.analyze_spacing_between(current, next);
+        match spacing {
+            BlockSpacing::Consecutive => true,
+            BlockSpacing::SingleBlank => self.can_merge_with_blank_between(current, next),
+            BlockSpacing::MultipleBlanks | BlockSpacing::ContentBetween => {
+                self.can_merge_with_content_between(current, next)
+            }
+        }
+    }
+
+    /// Check if blocks have compatible structure for merging
+    fn blocks_are_compatible(&self, current: &ListBlock, next: &ListBlock) -> bool {
+        current.is_ordered == next.is_ordered
+            && current.blockquote_prefix == next.blockquote_prefix
+            && current.nesting_level == next.nesting_level
     }
 
-    // Don't forget the last block
-    merged.push(current);
+    /// Analyze the spacing between two list blocks
+    fn analyze_spacing_between(&self, current: &ListBlock, next: &ListBlock) -> BlockSpacing {
+        let gap = next.start_line - current.end_line;
+
+        match gap {
+            1 => BlockSpacing::Consecutive,
+            2 => BlockSpacing::SingleBlank,
+            _ if gap > 2 => {
+                if self.has_only_blank_lines_between(current, next) {
+                    BlockSpacing::MultipleBlanks
+                } else {
+                    BlockSpacing::ContentBetween
+                }
+            }
+            _ => BlockSpacing::Consecutive, // gap == 0, overlapping (shouldn't happen)
+        }
+    }
+
+    /// Check if unordered lists can be merged with a single blank line between
+    fn can_merge_with_blank_between(&self, current: &ListBlock, next: &ListBlock) -> bool {
+        // Only merge unordered lists with same marker across single blank
+        !current.is_ordered && current.marker == next.marker
+    }
+
+    /// Check if ordered lists can be merged when there's content between them
+    fn can_merge_with_content_between(&self, current: &ListBlock, next: &ListBlock) -> bool {
+        // Only consider merging ordered lists with meaningful content between
+        current.is_ordered && next.is_ordered && has_meaningful_content_between(current, next, self.lines)
+    }
+
+    /// Check if there are only blank lines between blocks
+    fn has_only_blank_lines_between(&self, current: &ListBlock, next: &ListBlock) -> bool {
+        for line_num in (current.end_line + 1)..next.start_line {
+            if let Some(line_info) = self.lines.get(line_num - 1) {
+                if !line_info.content.trim().is_empty() {
+                    return false;
+                }
+            }
+        }
+        true
+    }
+
+    /// Merge two compatible list blocks into one
+    fn merge_two_blocks(&self, mut current: ListBlock, next: &ListBlock) -> ListBlock {
+        current.end_line = next.end_line;
+        current.item_lines.extend_from_slice(&next.item_lines);
+
+        // Handle marker consistency for unordered lists
+        if !current.is_ordered && self.markers_differ(&current, next) {
+            current.marker = None; // Mixed markers
+        }
+
+        current
+    }
+
+    /// Check if two blocks have different markers
+    fn markers_differ(&self, current: &ListBlock, next: &ListBlock) -> bool {
+        current.marker.is_some() && next.marker.is_some() && current.marker != next.marker
+    }
+}
 
-    *list_blocks = merged;
+/// Types of spacing between list blocks
+#[derive(Debug, PartialEq)]
+enum BlockSpacing {
+    Consecutive,    // No gap between blocks
+    SingleBlank,    // One blank line between blocks
+    MultipleBlanks, // Multiple blank lines but no content
+    ContentBetween, // Content exists between blocks
 }
 
 /// Check if there's meaningful content (not just blank lines) between two list blocks

{rumdl-0.0.99 → rumdl-0.0.100}/src/rules/md032_blanks_around_lists.rs

@@ -369,33 +369,10 @@ impl Rule for MD032BlanksAroundLists {
     }
 
     fn check(&self, ctx: &crate::lint_context::LintContext) -> LintResult {
-        let content = ctx.content;
-
-        // Early return for empty content
-        if content.is_empty() {
-            return Ok(Vec::new());
-        }
-
-        // Quick check for list markers
-        if !content.contains('-')
-            && !content.contains('*')
-            && !content.contains('+')
-            && !content.chars().any(|c| c.is_numeric())
-        {
-            return Ok(Vec::new());
-        }
-
-        let structure = document_structure_from_str(content);
-        let lines: Vec<&str> = content.lines().collect();
-        let line_index = LineIndex::new(content.to_string());
-
-        let list_blocks = self.convert_list_blocks(ctx);
-
-        if list_blocks.is_empty() {
-            return Ok(Vec::new());
-        }
-
-        self.perform_checks(ctx, &structure, &lines, &list_blocks, &line_index)
+        // Delegate to optimized check_with_structure by creating a temporary DocumentStructure
+        // This fallback path should rarely be used since the main lint engine calls check_with_structure
+        let structure = document_structure_from_str(ctx.content);
+        self.check_with_structure(ctx, &structure)
     }
 
     /// Optimized check using pre-computed document structure
@@ -423,7 +400,64 @@ impl Rule for MD032BlanksAroundLists {
     }
 
     fn fix(&self, ctx: &crate::lint_context::LintContext) -> Result<String, LintError> {
+        // Delegate to helper method with temporary DocumentStructure
         let structure = document_structure_from_str(ctx.content);
+        self.fix_with_structure(ctx, &structure)
+    }
+
+    fn should_skip(&self, ctx: &crate::lint_context::LintContext) -> bool {
+        ctx.content.is_empty() || ctx.list_blocks.is_empty()
+    }
+
+    fn category(&self) -> RuleCategory {
+        RuleCategory::List
+    }
+
+    fn as_any(&self) -> &dyn std::any::Any {
+        self
+    }
+
+    fn default_config_section(&self) -> Option<(String, toml::Value)> {
+        let mut map = toml::map::Map::new();
+        map.insert(
+            "allow_after_headings".to_string(),
+            toml::Value::Boolean(self.allow_after_headings),
+        );
+        map.insert(
+            "allow_after_colons".to_string(),
+            toml::Value::Boolean(self.allow_after_colons),
+        );
+        Some((self.name().to_string(), toml::Value::Table(map)))
+    }
+
+    fn from_config(config: &crate::config::Config) -> Box<dyn Rule>
+    where
+        Self: Sized,
+    {
+        let allow_after_headings =
+            crate::config::get_rule_config_value::<bool>(config, "MD032", "allow_after_headings").unwrap_or(true); // Default to true for better UX
+
+        let allow_after_colons =
+            crate::config::get_rule_config_value::<bool>(config, "MD032", "allow_after_colons").unwrap_or(true);
+
+        Box::new(MD032BlanksAroundLists {
+            allow_after_headings,
+            allow_after_colons,
+        })
+    }
+
+    fn as_maybe_document_structure(&self) -> Option<&dyn crate::rule::MaybeDocumentStructure> {
+        Some(self)
+    }
+}
+
+impl MD032BlanksAroundLists {
+    /// Helper method for fixing with a pre-computed DocumentStructure
+    fn fix_with_structure(
+        &self,
+        ctx: &crate::lint_context::LintContext,
+        structure: &DocumentStructure,
+    ) -> Result<String, LintError> {
         let lines: Vec<&str> = ctx.content.lines().collect();
         let num_lines = lines.len();
         if num_lines == 0 {
@@ -452,7 +486,7 @@ impl Rule for MD032BlanksAroundLists {
                 let should_require = self.should_require_blank_line_before(
                     lines[prev_line_actual_idx_0],
                     ctx,
-                    &structure,
+                    structure,
                     prev_line_actual_idx_1,
                 );
                 if !is_prev_excluded
@@ -510,51 +544,6 @@ impl Rule for MD032BlanksAroundLists {
         }
         Ok(result)
     }
-
-    fn should_skip(&self, ctx: &crate::lint_context::LintContext) -> bool {
-        ctx.content.is_empty() || ctx.list_blocks.is_empty()
-    }
-
-    fn category(&self) -> RuleCategory {
-        RuleCategory::List
-    }
-
-    fn as_any(&self) -> &dyn std::any::Any {
-        self
-    }
-
-    fn default_config_section(&self) -> Option<(String, toml::Value)> {
-        let mut map = toml::map::Map::new();
-        map.insert(
-            "allow_after_headings".to_string(),
-            toml::Value::Boolean(self.allow_after_headings),
-        );
-        map.insert(
-            "allow_after_colons".to_string(),
-            toml::Value::Boolean(self.allow_after_colons),
-        );
-        Some((self.name().to_string(), toml::Value::Table(map)))
-    }
-
-    fn from_config(config: &crate::config::Config) -> Box<dyn Rule>
-    where
-        Self: Sized,
-    {
-        let allow_after_headings =
-            crate::config::get_rule_config_value::<bool>(config, "MD032", "allow_after_headings").unwrap_or(true); // Default to true for better UX
-
-        let allow_after_colons =
-            crate::config::get_rule_config_value::<bool>(config, "MD032", "allow_after_colons").unwrap_or(true);
-
-        Box::new(MD032BlanksAroundLists {
-            allow_after_headings,
-            allow_after_colons,
-        })
-    }
-
-    fn as_maybe_document_structure(&self) -> Option<&dyn crate::rule::MaybeDocumentStructure> {
-        Some(self)
-    }
 }
 
 impl DocumentStructureExtensions for MD032BlanksAroundLists {