rumdl 0.0.165__tar.gz → 0.0.166__tar.gz

{rumdl-0.0.165 → rumdl-0.0.166}/CHANGELOG.md

@@ -7,6 +7,25 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.166] - 2025-10-22
+
+### Added
+
+- **MD013: `paragraphs` field to control paragraph line length checks** (resolves #121)
+  - New boolean config field `paragraphs` (defaults to `true`) allows disabling line length warnings for paragraph text
+  - Enables sentence-per-line formatting workflows without line length validation noise
+  - Still checks headings, tables, code blocks, blockquotes, and HTML when `paragraphs: false`
+  - Useful for semantic line breaks where sentence length is determined by content, not arbitrary limits
+  - Example configuration:
+    ```yaml
+    MD013:
+      paragraphs: false  # Don't warn about long paragraphs
+      code-blocks: true  # Still check code blocks
+      tables: true       # Still check tables
+      reflow: true
+      reflow-mode: "sentence-per-line"
+    ```
+
 ## [0.0.165] - 2025-10-21
 
 ### Fixed

{rumdl-0.0.165 → rumdl-0.0.166}/Cargo.lock

@@ -1983,7 +1983,7 @@ dependencies = [
 
 [[package]]
 name = "rumdl"
-version = "0.0.165"
+version = "0.0.166"
 dependencies = [
  "anyhow",
  "assert_cmd",

{rumdl-0.0.165 → rumdl-0.0.166}/Cargo.toml

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

{rumdl-0.0.165 → rumdl-0.0.166}/PKG-INFO

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

{rumdl-0.0.165 → rumdl-0.0.166}/docs/md013.md

@@ -51,6 +51,7 @@ MD013:
   code-blocks: false            # Don't check code blocks (default: true)
   tables: false                 # Don't check tables (default: true)
   headings: true                # Check headings (default: true)
+  paragraphs: true              # Check paragraph/regular text (default: true)
   heading-line-length: 120      # Different limit for headings (default: uses line_length)
   code-block-line-length: 150   # Different limit for code blocks (default: uses line_length)
   stern: false                  # Stricter checking without exceptions (default: false)
@@ -65,6 +66,7 @@ MD013:
 - `code_blocks`: Whether to check line length in code blocks
 - `tables`: Whether to check line length in tables
 - `headings`: Whether to check line length in headings
+- `paragraphs`: Whether to check line length in regular text/paragraphs (when false, line_length is still used for reflow but no warnings are reported)
 - `heading_line_length`: Optional separate limit for headings (useful since headings often need to be longer)
 - `code_block_line_length`: Optional separate limit for code blocks
 - `stern`: When true, applies stricter checking without common exceptions
@@ -173,6 +175,26 @@ This mode is particularly useful for:
 - Documents maintained in version control where sentence-level diffs are clearer
 - Collaborative writing where different authors work on different sentences
 
+#### Sentence-per-line without line length warnings
+
+If you want to use sentence-per-line mode for formatting but don't want warnings about long sentences, you can disable paragraph checking while keeping code blocks and tables checked:
+
+```yaml
+MD013:
+  line-length: 80
+  paragraphs: false  # Don't warn about long paragraphs
+  code-blocks: true  # Still check code blocks
+  tables: true       # Still check tables
+  reflow: true
+  reflow-mode: "sentence-per-line"
+```
+
+This configuration is useful when:
+
+- You want automatic sentence-per-line formatting without validation noise
+- You care about line length in code blocks and tables but not in regular text
+- You're using semantic line breaks where sentence length is determined by content, not arbitrary limits
+
 ### Example with automatic reflow
 
 ```yaml

{rumdl-0.0.165 → rumdl-0.0.166}/src/rules/md013_line_length/md013_config.rs

@@ -35,6 +35,12 @@ pub struct MD013Config {
     #[serde(default = "default_headings")]
     pub headings: bool,
 
+    /// Check paragraph/text line length (default: true)
+    /// When false, line length violations in regular text are not reported,
+    /// but reflow can still be used to format paragraphs.
+    #[serde(default = "default_paragraphs")]
+    pub paragraphs: bool,
+
     /// Strict mode - disables exceptions for URLs, etc. (default: false)
     #[serde(default)]
     pub strict: bool,
@@ -64,6 +70,10 @@ fn default_headings() -> bool {
     true
 }
 
+fn default_paragraphs() -> bool {
+    true
+}
+
 impl Default for MD013Config {
     fn default() -> Self {
         Self {
@@ -71,6 +81,7 @@ impl Default for MD013Config {
             code_blocks: default_code_blocks(),
             tables: default_tables(),
             headings: default_headings(),
+            paragraphs: default_paragraphs(),
             strict: false,
             reflow: false,
             reflow_mode: ReflowMode::default(),
@@ -154,6 +165,7 @@ mod tests {
             code_blocks: true,
             tables: true,
             headings: true,
+            paragraphs: true,
             strict: false,
             reflow: true,
             reflow_mode: ReflowMode::SentencePerLine,
@@ -194,4 +206,43 @@ mod tests {
         assert!(config.reflow);
         assert_eq!(config.reflow_mode, ReflowMode::SentencePerLine);
     }
+
+    #[test]
+    fn test_paragraphs_default_true() {
+        // Test that paragraphs defaults to true
+        let config = MD013Config::default();
+        assert!(config.paragraphs, "paragraphs should default to true");
+    }
+
+    #[test]
+    fn test_paragraphs_deserialization_kebab_case() {
+        // Test kebab-case (canonical format)
+        let toml_str = r#"
+            paragraphs = false
+        "#;
+        let config: MD013Config = toml::from_str(toml_str).unwrap();
+        assert!(!config.paragraphs);
+    }
+
+    #[test]
+    fn test_paragraphs_full_config() {
+        // Test paragraphs in a full configuration with issue #121 use case
+        let toml_str = r#"
+            line-length = 80
+            code-blocks = true
+            tables = true
+            headings = false
+            paragraphs = false
+            reflow = true
+            reflow-mode = "sentence-per-line"
+        "#;
+        let config: MD013Config = toml::from_str(toml_str).unwrap();
+        assert_eq!(config.line_length, 80);
+        assert!(config.code_blocks, "code-blocks should be true");
+        assert!(config.tables, "tables should be true");
+        assert!(!config.headings, "headings should be false");
+        assert!(!config.paragraphs, "paragraphs should be false");
+        assert!(config.reflow, "reflow should be true");
+        assert_eq!(config.reflow_mode, ReflowMode::SentencePerLine);
+    }
 }

{rumdl-0.0.165 → rumdl-0.0.166}/src/rules/md013_line_length.rs

@@ -28,6 +28,7 @@ impl MD013LineLength {
                 code_blocks,
                 tables,
                 headings,
+                paragraphs: true, // Default to true for backwards compatibility
                 strict,
                 reflow: false,
                 reflow_mode: ReflowMode::default(),
@@ -173,33 +174,27 @@ impl Rule for MD013LineLength {
             content.lines().collect()
         };
 
-        // Create a quick lookup set for heading lines (only if needed)
-        let heading_lines_set: std::collections::HashSet<usize> = if !effective_config.headings {
-            ctx.lines
-                .iter()
-                .enumerate()
-                .filter(|(_, line)| line.heading.is_some())
-                .map(|(idx, _)| idx + 1)
-                .collect()
-        } else {
-            std::collections::HashSet::new()
-        };
-
-        // Use TableUtils to find all table blocks (only if needed)
-        let table_lines_set: std::collections::HashSet<usize> = if !effective_config.tables {
-            let table_blocks = TableUtils::find_table_blocks(content, ctx);
-            let mut table_lines = std::collections::HashSet::new();
-            for table in &table_blocks {
-                table_lines.insert(table.header_line + 1);
-                table_lines.insert(table.delimiter_line + 1);
-                for &line in &table.content_lines {
-                    table_lines.insert(line + 1);
-                }
+        // Create a quick lookup set for heading lines
+        // We need this for both the heading skip check AND the paragraphs check
+        let heading_lines_set: std::collections::HashSet<usize> = ctx
+            .lines
+            .iter()
+            .enumerate()
+            .filter(|(_, line)| line.heading.is_some())
+            .map(|(idx, _)| idx + 1)
+            .collect();
+
+        // Use TableUtils to find all table blocks
+        // We need this for both the table skip check AND the paragraphs check
+        let table_blocks = TableUtils::find_table_blocks(content, ctx);
+        let mut table_lines_set = std::collections::HashSet::new();
+        for table in &table_blocks {
+            table_lines_set.insert(table.header_line + 1);
+            table_lines_set.insert(table.delimiter_line + 1);
+            for &line in &table.content_lines {
+                table_lines_set.insert(line + 1);
             }
-            table_lines
-        } else {
-            std::collections::HashSet::new()
-        };
+        }
 
         // Process candidate lines for line length checks
         for &line_idx in &candidate_lines {
@@ -243,6 +238,22 @@ impl Rule for MD013LineLength {
                     continue;
                 }
 
+                // Check if this is a paragraph/regular text line
+                // If paragraphs = false, skip lines that are NOT in special blocks
+                if !effective_config.paragraphs {
+                    let is_special_block = heading_lines_set.contains(&line_number)
+                        || ctx.line_info(line_number).is_some_and(|info| info.in_code_block)
+                        || table_lines_set.contains(&line_number)
+                        || ctx.lines[line_number - 1].blockquote.is_some()
+                        || ctx.line_info(line_number).is_some_and(|info| info.in_html_block)
+                        || ctx.line_info(line_number).is_some_and(|info| info.in_html_comment);
+
+                    // Skip regular paragraph text when paragraphs = false
+                    if !is_special_block {
+                        continue;
+                    }
+                }
+
                 // Skip lines that are only a URL, image ref, or link ref
                 if self.should_ignore_line(line, &lines, line_idx, ctx) {
                     continue;
@@ -3370,4 +3381,142 @@ with multiple lines."#;
             );
         }
     }
+
+    #[test]
+    fn test_paragraphs_false_skips_regular_text() {
+        // Test that paragraphs=false skips checking regular text
+        let config = MD013Config {
+            line_length: 50,
+            paragraphs: false, // Don't check paragraphs
+            code_blocks: true,
+            tables: true,
+            headings: true,
+            strict: false,
+            reflow: false,
+            reflow_mode: ReflowMode::default(),
+        };
+        let rule = MD013LineLength::from_config_struct(config);
+
+        let content =
+            "This is a very long line of regular text that exceeds fifty characters and should not trigger a warning.";
+        let ctx = crate::lint_context::LintContext::new(content, crate::config::MarkdownFlavor::Standard);
+        let result = rule.check(&ctx).unwrap();
+
+        // Should not report any warnings when paragraphs=false
+        assert_eq!(
+            result.len(),
+            0,
+            "Should not warn about long paragraph text when paragraphs=false"
+        );
+    }
+
+    #[test]
+    fn test_paragraphs_false_still_checks_code_blocks() {
+        // Test that paragraphs=false still checks code blocks
+        let config = MD013Config {
+            line_length: 50,
+            paragraphs: false, // Don't check paragraphs
+            code_blocks: true, // But DO check code blocks
+            tables: true,
+            headings: true,
+            strict: false,
+            reflow: false,
+            reflow_mode: ReflowMode::default(),
+        };
+        let rule = MD013LineLength::from_config_struct(config);
+
+        let content = r#"```
+This is a very long line in a code block that exceeds fifty characters.
+```"#;
+        let ctx = crate::lint_context::LintContext::new(content, crate::config::MarkdownFlavor::Standard);
+        let result = rule.check(&ctx).unwrap();
+
+        // SHOULD report warnings for code blocks even when paragraphs=false
+        assert_eq!(
+            result.len(),
+            1,
+            "Should warn about long lines in code blocks even when paragraphs=false"
+        );
+    }
+
+    #[test]
+    fn test_paragraphs_false_still_checks_headings() {
+        // Test that paragraphs=false still checks headings
+        let config = MD013Config {
+            line_length: 50,
+            paragraphs: false, // Don't check paragraphs
+            code_blocks: true,
+            tables: true,
+            headings: true, // But DO check headings
+            strict: false,
+            reflow: false,
+            reflow_mode: ReflowMode::default(),
+        };
+        let rule = MD013LineLength::from_config_struct(config);
+
+        let content = "# This is a very long heading that exceeds fifty characters and should trigger a warning";
+        let ctx = crate::lint_context::LintContext::new(content, crate::config::MarkdownFlavor::Standard);
+        let result = rule.check(&ctx).unwrap();
+
+        // SHOULD report warnings for headings even when paragraphs=false
+        assert_eq!(
+            result.len(),
+            1,
+            "Should warn about long headings even when paragraphs=false"
+        );
+    }
+
+    #[test]
+    fn test_paragraphs_false_with_reflow_sentence_per_line() {
+        // Test issue #121 use case: paragraphs=false with sentence-per-line reflow
+        let config = MD013Config {
+            line_length: 80,
+            paragraphs: false,
+            code_blocks: true,
+            tables: true,
+            headings: false,
+            strict: false,
+            reflow: true,
+            reflow_mode: ReflowMode::SentencePerLine,
+        };
+        let rule = MD013LineLength::from_config_struct(config);
+
+        let content = "This is a very long sentence that exceeds eighty characters and contains important information that should not be flagged.";
+        let ctx = crate::lint_context::LintContext::new(content, crate::config::MarkdownFlavor::Standard);
+        let result = rule.check(&ctx).unwrap();
+
+        // Should NOT warn when paragraphs=false
+        assert_eq!(
+            result.len(),
+            0,
+            "Should not warn about long sentences when paragraphs=false"
+        );
+    }
+
+    #[test]
+    fn test_paragraphs_true_checks_regular_text() {
+        // Test that paragraphs=true (default) checks regular text
+        let config = MD013Config {
+            line_length: 50,
+            paragraphs: true, // Default: DO check paragraphs
+            code_blocks: true,
+            tables: true,
+            headings: true,
+            strict: false,
+            reflow: false,
+            reflow_mode: ReflowMode::default(),
+        };
+        let rule = MD013LineLength::from_config_struct(config);
+
+        let content = "This is a very long line of regular text that exceeds fifty characters.";
+        let ctx = crate::lint_context::LintContext::new(content, crate::config::MarkdownFlavor::Standard);
+        let result = rule.check(&ctx).unwrap();
+
+        // SHOULD report warnings when paragraphs=true
+        assert_eq!(
+            result.len(),
+            1,
+            "Should warn about long paragraph text when paragraphs=true"
+        );
+    }
 }

{rumdl-0.0.165 → rumdl-0.0.166}/tests/fix_counting_test.rs

@@ -31,6 +31,7 @@ Another very very very very very very very very very very very very very very ve
         code_blocks: true,
         tables: true, // Check tables for line length
         headings: true,
+        paragraphs: true,
         strict: false,
         reflow: true, // Enable reflow
         ..Default::default()
@@ -95,6 +96,7 @@ fn test_mixed_rules_fix_counting() {
         code_blocks: true,
         tables: true, // Check tables for line length
         headings: true,
+        paragraphs: true,
         strict: false,
         reflow: true,
         ..Default::default()

{rumdl-0.0.165 → rumdl-0.0.166}/tests/rules/md013_test.rs

@@ -449,6 +449,7 @@ fn test_heading_line_length_config() {
         code_blocks: false, // false = skip code blocks
         tables: false,      // false = skip tables
         headings: false,    // false = skip headings (don't check them)
+        paragraphs: true,
         strict: false,
         reflow: false,
         ..Default::default()
@@ -474,6 +475,7 @@ fn test_code_block_line_length_config() {
         code_blocks: false, // false = skip code blocks (don't check them)
         tables: true,       // true = check tables
         headings: true,     // true = check headings
+        paragraphs: true,
         strict: false,
         reflow: false,
         ..Default::default()
@@ -499,7 +501,8 @@ fn test_stern_mode() {
         code_blocks: false, // Don't skip code blocks
         tables: false,      // Don't skip tables
         headings: false,    // Don't skip headings
-        strict: true,       // Strict mode: no URL exceptions
+        paragraphs: true,
+        strict: true, // Strict mode: no URL exceptions
         reflow: false,
         ..Default::default()
     };
@@ -523,6 +526,7 @@ fn test_combined_heading_and_code_block_limits() {
         code_blocks: false, // false = skip code blocks
         tables: true,       // true = check tables
         headings: false,    // false = skip headings
+        paragraphs: true,
         strict: false,
         reflow: false,
         ..Default::default()

{rumdl-0.0.165 → rumdl-0.0.166}/tests/sentence_per_line_test.rs

@@ -9,6 +9,7 @@ fn create_sentence_per_line_rule() -> MD013LineLength {
         code_blocks: false,
         tables: false,
         headings: false,
+        paragraphs: true, // Default: check paragraphs
         strict: false,
         reflow: true,
         reflow_mode: ReflowMode::SentencePerLine,