rumdl 0.0.95__tar.gz → 0.0.96__tar.gz

{rumdl-0.0.95 → rumdl-0.0.96}/CHANGELOG.md

@@ -7,8 +7,44 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.96] - 2025-07-16
+
+## [0.0.96] - 2025-07-16
+
+### Added
+- MD013: Text reflow/wrapping functionality for automatic line breaking (fixes #13)
+  - New `enable_reflow` configuration option (disabled by default)
+  - Intelligently wraps long lines while preserving Markdown formatting
+  - Preserves bold, italic, links, code spans, and other Markdown elements
+  - Proper list continuation indentation that aligns with the text after markers
+  - Preserves hard line breaks (two trailing spaces)
+  - Does not wrap code blocks, tables, headings, or reference definitions
+- Added `pulldown-cmark` dependency (v0.12.2) for improved Markdown parsing
+- Comprehensive test coverage for text reflow functionality
+
+### Changed
+- MD013: Enhanced fix functionality with optional text reflow (opt-in feature)
+
+### Fixed
+- MD013: Fixed list indentation to properly align continuation lines with the text content
+
 ## [0.0.95] - 2025-07-15
 
+### Added
+- Implemented 3-tier exit code system following Ruff's convention:
+  - Exit code 0: Success (no issues found)
+  - Exit code 1: Linting violations found
+  - Exit code 2: Tool error (config error, file access error, etc.)
+- Added exit_codes module for cleaner exit code management
+
+### Changed
+- Updated all error handlers to use appropriate exit codes
+- CI/CD systems can now distinguish between markdown issues (exit 1) and tool failures (exit 2)
+
+### Documentation
+- Updated README with exit code documentation
+- Added exit codes section to CLI reference
+
 ## [0.0.94] - 2025-07-04
 
 ### Performance Improvements
@@ -149,7 +185,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.95...HEAD
+[Unreleased]: https://github.com/rvben/rumdl/compare/v0.0.96...HEAD
+[0.0.96]: https://github.com/rvben/rumdl/compare/v0.0.95...v0.0.96
 [0.0.95]: https://github.com/rvben/rumdl/compare/v0.0.94...v0.0.95
 [0.0.94]: https://github.com/rvben/rumdl/compare/v0.0.93...v0.0.94
 [0.0.93]: https://github.com/rvben/rumdl/compare/v0.0.92...v0.0.93

{rumdl-0.0.95 → rumdl-0.0.96}/Cargo.lock

@@ -614,6 +614,15 @@ dependencies = [
  "slab",
 ]
 
+[[package]]
+name = "getopts"
+version = "0.2.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cba6ae63eb948698e300f645f87c70f76630d505f23b8907cf1e193ee85048c1"
+dependencies = [
+ "unicode-width",
+]
+
 [[package]]
 name = "getrandom"
 version = "0.3.3"
@@ -1283,6 +1292,25 @@ dependencies = [
  "unarray",
 ]
 
+[[package]]
+name = "pulldown-cmark"
+version = "0.12.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f86ba2052aebccc42cbbb3ed234b8b13ce76f75c3551a303cb2bcffcff12bb14"
+dependencies = [
+ "bitflags 2.9.1",
+ "getopts",
+ "memchr",
+ "pulldown-cmark-escape",
+ "unicase",
+]
+
+[[package]]
+name = "pulldown-cmark-escape"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "007d8adb5ddab6f8e3f491ac63566a7d5002cc7ed73901f72057943fa71ae1ae"
+
 [[package]]
 name = "pyo3"
 version = "0.24.2"
@@ -1465,7 +1493,7 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "rumdl"
-version = "0.0.95"
+version = "0.0.96"
 dependencies = [
  "anyhow",
  "assert_cmd",
@@ -1488,6 +1516,7 @@ dependencies = [
  "predicates",
  "pretty_assertions",
  "proptest",
+ "pulldown-cmark",
  "pyo3",
  "rand",
  "rayon",
@@ -1986,6 +2015,12 @@ version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94"
 
+[[package]]
+name = "unicase"
+version = "2.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75b844d17643ee918803943289730bec8aac480150456169e647ed0b576ba539"
+
 [[package]]
 name = "unicode-bidi"
 version = "0.3.18"

{rumdl-0.0.95 → rumdl-0.0.96}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rumdl"
-version = "0.0.95"
+version = "0.0.96"
 edition = "2024"
 rust-version = "1.88.0"
 description = "A fast Markdown linter written in Rust (Ru(st) MarkDown Linter)"
@@ -68,6 +68,7 @@ globset = "0.4.16"
 anyhow = "1.0"
 log = "0.4.27"
 markdown = "1.0"
+pulldown-cmark = "0.12.2"
 regex = "1.11"
 toml_edit = "0.22"
 dyn-clone = "1"

{rumdl-0.0.95 → rumdl-0.0.96}/PKG-INFO

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

{rumdl-0.0.95 → rumdl-0.0.96}/src/rules/md013_line_length/md013_config.rs

@@ -36,6 +36,10 @@ pub struct MD013Config {
     /// Stern mode - stricter checking without exceptions (default: false)
     #[serde(default)]
     pub stern: bool,
+
+    /// Enable text reflow to wrap long lines (default: false)
+    #[serde(default)]
+    pub enable_reflow: bool,
 }
 
 fn default_line_length() -> usize {
@@ -65,6 +69,7 @@ impl Default for MD013Config {
             heading_line_length: None,
             code_block_line_length: None,
             stern: false,
+            enable_reflow: false,
         }
     }
 }

{rumdl-0.0.95 → rumdl-0.0.96}/src/rules/md013_line_length.rs

@@ -51,6 +51,7 @@ impl MD013LineLength {
                 heading_line_length: None,
                 code_block_line_length: None,
                 stern: false,
+                enable_reflow: false,
             },
         }
     }
@@ -333,6 +334,18 @@ impl Rule for MD013LineLength {
     }
 
     fn fix(&self, ctx: &crate::lint_context::LintContext) -> Result<String, LintError> {
+        // If reflow is enabled, use the new text reflow functionality
+        if self.config.enable_reflow {
+            let reflow_options = crate::utils::text_reflow::ReflowOptions {
+                line_length: self.config.line_length,
+                break_on_sentences: true,
+                preserve_breaks: false,
+            };
+            
+            return Ok(crate::utils::text_reflow::reflow_markdown(ctx.content, &reflow_options));
+        }
+        
+        // Otherwise, use the existing fix logic (trimming whitespace)
         // Get all warnings with their fixes
         let warnings = self.check(ctx)?;
 
@@ -907,4 +920,132 @@ Another long line that should trigger a warning."#;
         // Should not flag because the URL is in a markdown link
         assert_eq!(result.len(), 0);
     }
+    
+    #[test]
+    fn test_text_reflow_simple() {
+        let mut config = MD013Config::default();
+        config.line_length = 30;
+        config.enable_reflow = true;
+        let rule = MD013LineLength::from_config_struct(config);
+        
+        let content = "This is a very long line that definitely exceeds thirty characters and needs to be wrapped.";
+        let ctx = LintContext::new(content);
+        
+        let fixed = rule.fix(&ctx).unwrap();
+        
+        // Verify all lines are under 30 chars
+        for line in fixed.lines() {
+            assert!(line.chars().count() <= 30, "Line too long: {} (len={})", line, line.chars().count());
+        }
+        
+        // Verify content is preserved
+        let fixed_words: Vec<&str> = fixed.split_whitespace().collect();
+        let original_words: Vec<&str> = content.split_whitespace().collect();
+        assert_eq!(fixed_words, original_words);
+    }
+    
+    #[test]
+    fn test_text_reflow_preserves_markdown_elements() {
+        let mut config = MD013Config::default();
+        config.line_length = 40;
+        config.enable_reflow = true;
+        let rule = MD013LineLength::from_config_struct(config);
+        
+        let content = "This paragraph has **bold text** and *italic text* and [a link](https://example.com) that should be preserved.";
+        let ctx = LintContext::new(content);
+        
+        let fixed = rule.fix(&ctx).unwrap();
+        
+        // Verify markdown elements are preserved
+        assert!(fixed.contains("**bold text**"), "Bold text not preserved in: {}", fixed);
+        assert!(fixed.contains("*italic text*"), "Italic text not preserved in: {}", fixed);
+        assert!(fixed.contains("[a link](https://example.com)"), "Link not preserved in: {}", fixed);
+        
+        // Verify all lines are under 40 chars
+        for line in fixed.lines() {
+            assert!(line.len() <= 40, "Line too long: {}", line);
+        }
+    }
+    
+    #[test]
+    fn test_text_reflow_preserves_code_blocks() {
+        let mut config = MD013Config::default();
+        config.line_length = 30;
+        config.enable_reflow = true;
+        let rule = MD013LineLength::from_config_struct(config);
+        
+        let content = r#"Here is some text.
+
+```python
+def very_long_function_name_that_exceeds_limit():
+    return "This should not be wrapped"
+```
+
+More text after code block."#;
+        let ctx = LintContext::new(content);
+        
+        let fixed = rule.fix(&ctx).unwrap();
+        
+        // Verify code block is preserved
+        assert!(fixed.contains("def very_long_function_name_that_exceeds_limit():"));
+        assert!(fixed.contains("```python"));
+        assert!(fixed.contains("```"));
+    }
+    
+    #[test]
+    fn test_text_reflow_preserves_lists() {
+        let mut config = MD013Config::default();
+        config.line_length = 30;
+        config.enable_reflow = true;
+        let rule = MD013LineLength::from_config_struct(config);
+        
+        let content = r#"Here is a list:
+
+1. First item with a very long line that needs wrapping
+2. Second item is short
+3. Third item also has a long line that exceeds the limit
+
+And a bullet list:
+
+- Bullet item with very long content that needs wrapping
+- Short bullet"#;
+        let ctx = LintContext::new(content);
+        
+        let fixed = rule.fix(&ctx).unwrap();
+        
+        // Verify list structure is preserved
+        assert!(fixed.contains("1. "));
+        assert!(fixed.contains("2. "));
+        assert!(fixed.contains("3. "));
+        assert!(fixed.contains("- "));
+        
+        // Verify proper indentation for wrapped lines
+        let lines: Vec<&str> = fixed.lines().collect();
+        for (i, line) in lines.iter().enumerate() {
+            if line.trim().starts_with("1.") || line.trim().starts_with("2.") || 
+               line.trim().starts_with("3.") || line.trim().starts_with("-") {
+                // Check if next line is a continuation (should be indented)
+                if i + 1 < lines.len() && !lines[i + 1].trim().is_empty() &&
+                   !lines[i + 1].trim().starts_with(char::is_numeric) &&
+                   !lines[i + 1].trim().starts_with("-") {
+                    // Continuation lines should have proper indentation
+                    assert!(lines[i + 1].starts_with("   ") || lines[i + 1].trim().is_empty());
+                }
+            }
+        }
+    }
+    
+    #[test]
+    fn test_text_reflow_disabled_by_default() {
+        let rule = MD013LineLength::new(30, false, false, false, false);
+        
+        let content = "This is a very long line that definitely exceeds thirty characters.";
+        let ctx = LintContext::new(content);
+        
+        let fixed = rule.fix(&ctx).unwrap();
+        
+        // Without reflow enabled, it should only trim whitespace (if any)
+        // Since there's no trailing whitespace, content should be unchanged
+        assert_eq!(fixed, content);
+    }
 }

{rumdl-0.0.95 → rumdl-0.0.96}/src/utils/mod.rs

@@ -14,6 +14,7 @@ pub mod range_utils;
 pub mod regex_cache;
 pub mod string_interner;
 pub mod table_utils;
+pub mod text_reflow;
 
 pub use ast_utils::AstCache;
 pub use code_block_utils::CodeBlockUtils;