rumdl 0.0.67__tar.gz → 0.0.68__tar.gz

{rumdl-0.0.67 → rumdl-0.0.68}/Cargo.lock

@@ -1704,7 +1704,7 @@ dependencies = [
 
 [[package]]
 name = "rumdl"
-version = "0.0.67"
+version = "0.0.68"
 dependencies = [
  "anyhow",
  "assert_cmd",
@@ -1748,7 +1748,11 @@ dependencies = [
  "tower 0.5.2",
  "tower-lsp",
  "tower-service",
+ "unicode-bidi",
+ "unicode-blocks",
  "unicode-normalization",
+ "unicode-segmentation",
+ "unicode-width",
  "url",
  "walkdir",
 ]
@@ -2295,6 +2299,18 @@ version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94"
 
+[[package]]
+name = "unicode-bidi"
+version = "0.3.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c1cb5db39152898a79168971543b1cb5020dff7fe43c8dc468b0885f5e29df5"
+
+[[package]]
+name = "unicode-blocks"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b12e05d9e06373163a9bb6bb8c263c261b396643a99445fe6b9811fd376581b"
+
 [[package]]
 name = "unicode-id"
 version = "0.3.5"

{rumdl-0.0.67 → rumdl-0.0.68}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rumdl"
-version = "0.0.67"
+version = "0.0.68"
 edition = "2021"
 description = "A fast Markdown linter written in Rust (Ru(st) MarkDown Linter)"
 authors = ["Ruben J. Jongejan <ruben.jongejan@gmail.com>"]
@@ -81,6 +81,10 @@ proptest = "1.6.0"
 criterion = { version = "0.5", features = ["html_reports"] }
 rand = "0.9.1"
 pretty_assertions = "1.4"
+unicode-segmentation = "1.12"
+unicode-width = "0.2"
+unicode-blocks = "0.1"
+unicode-bidi = "0.3"
 
 [[bench]]
 name = "rule_performance"

{rumdl-0.0.67 → rumdl-0.0.68}/PKG-INFO

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

{rumdl-0.0.67 → rumdl-0.0.68}/docs/md033.md

@@ -2,7 +2,7 @@
 
 ## Description
 
-This rule disallows the use of inline HTML in Markdown documents. Using inline HTML can reduce the  
+This rule disallows the use of inline HTML in Markdown documents. Using inline HTML can reduce the
 portability and compatibility of Markdown content, as some platforms may restrict or sanitize HTML.
 
 Pure Markdown is more portable and can be safely rendered in a variety of environments.
@@ -26,6 +26,12 @@ This is a paragraph with **bold** and *italic* text.
 [Link text](https://example.com)
 
 ![Image alt text](image.png)
+
+Visit <https://example.com> for more information.
+
+Contact us at <mailto:support@example.com>
+
+Download from <ftp://files.example.com/archive.zip>
 ```
 
 ### Invalid
@@ -87,6 +93,8 @@ Example configuration:
 - This rule checks for any HTML tags in the Markdown content
 - It does not apply to code blocks or HTML comments
 - HTML comments (e.g., `<!-- rumdl-disable MD033 -->`, `<!-- rumdl-enable MD033 -->`, or any `<!-- comment -->`) are specifically excluded from this rule
+- URLs in angle brackets (e.g., `<https://example.com>`, `<ftp://files.example.com>`, `<mailto:user@example.com>`) are excluded as they are valid Markdown autolinks, not HTML
+- Email addresses in angle brackets (e.g., `<user@example.com>`) are excluded as they are valid Markdown autolinks
 - The rule can be configured to allow specific HTML tags when necessary
 - Some platforms may still sanitize allowed HTML tags
 

{rumdl-0.0.67 → rumdl-0.0.68}/docs/md036.md

@@ -20,6 +20,14 @@ generation of tables of contents.
 ## This is another proper heading
 
 This is a paragraph with **bold** and *italic* text within it.
+
+**Table of Contents**
+
+*Contents*
+
+__TOC__
+
+_Index_
 ```
 
 ### Invalid
@@ -89,6 +97,9 @@ punctuation = ".!?"  # Only remove periods, exclamation marks, and question mark
 - Both single emphasis (*italic*) and double emphasis (**bold**) are checked
 - Triple emphasis (***bold italic***) is also checked
 - Trailing punctuation (`.`, `:`, `;`, `!`, `?`) is automatically removed when converting to headings
+- Common Table of Contents labels are excluded and will not be flagged:
+  - `**Table of Contents**`, `*Contents*`, `__TOC__`, `_Index_`
+  - These are considered legitimate uses of emphasis for document structure
 
 ## Related Rules
 

{rumdl-0.0.67 → rumdl-0.0.68}/src/lsp/types.rs

@@ -37,10 +37,10 @@ pub fn warning_to_diagnostic(warning: &crate::rule::LintWarning) -> Diagnostic {
         character: (warning.column.saturating_sub(1)) as u32,
     };
 
-    // For now, assume single character range - we can improve this later
+    // Use proper range from warning
     let end_position = Position {
-        line: start_position.line,
-        character: start_position.character + 1,
+        line: (warning.end_line.saturating_sub(1)) as u32,
+        character: (warning.end_column.saturating_sub(1)) as u32,
     };
 
     let severity = match warning.severity {
@@ -48,6 +48,15 @@ pub fn warning_to_diagnostic(warning: &crate::rule::LintWarning) -> Diagnostic {
         crate::rule::Severity::Warning => DiagnosticSeverity::WARNING,
     };
 
+    // Create clickable link to rule documentation
+    let code_description = warning.rule_name.as_ref().and_then(|rule_name| {
+        // Create a link to the rule documentation
+        Url::parse(&format!(
+            "https://github.com/rvben/rumdl/blob/main/docs/{}.md",
+            rule_name.to_lowercase()
+        )).ok().map(|href| CodeDescription { href })
+    });
+
     Diagnostic {
         range: Range {
             start: start_position,
@@ -59,7 +68,7 @@ pub fn warning_to_diagnostic(warning: &crate::rule::LintWarning) -> Diagnostic {
         message: warning.message.clone(),
         related_information: None,
         tags: None,
-        code_description: None,
+        code_description,
         data: None,
     }
 }

{rumdl-0.0.67 → rumdl-0.0.68}/src/main.rs

@@ -6,7 +6,7 @@ use rayon::prelude::*;
 use std::collections::HashSet;
 use std::error::Error;
 use std::fs;
-use std::io::{self, Write};
+use std::io::{self, Write, Read};
 use std::path::Path;
 use std::process;
 use std::sync::Arc;
@@ -220,6 +220,10 @@ struct CheckArgs {
     /// Output format: text (default) or json
     #[arg(long, short = 'o', default_value = "text")]
     output: String,
+
+    /// Read from stdin instead of files
+    #[arg(long, help = "Read from stdin instead of files")]
+    stdin: bool,
 }
 
 // Get a complete set of enabled rules based on CLI options and config
@@ -1204,6 +1208,7 @@ build-backend = \"setuptools.build_meta\"
                         profile: cli.profile,
                         quiet: cli.quiet,
                         output: "text".to_string(),
+                        stdin: false,
                     };
                     eprintln!("{}: Deprecation warning: Running 'rumdl .' or 'rumdl [PATHS...]' without a subcommand is deprecated and will be removed in a future release. Please use 'rumdl check .' instead.", "[rumdl]".yellow().bold());
                     run_check(&args, cli.config.as_deref(), cli.no_config);
@@ -1225,6 +1230,85 @@ build-backend = \"setuptools.build_meta\"
     }
 }
 
+/// Process markdown content from stdin
+fn process_stdin(rules: &[Box<dyn Rule>], args: &CheckArgs) {
+    // Read all content from stdin
+    let mut content = String::new();
+    if let Err(e) = io::stdin().read_to_string(&mut content) {
+        if !args.quiet {
+            eprintln!("Error reading from stdin: {}", e);
+        }
+        process::exit(1);
+    }
+
+    // Create a lint context for the stdin content
+    let ctx = LintContext::new(&content);
+    let mut all_warnings = Vec::new();
+
+    // Run all enabled rules on the content
+    for rule in rules {
+        match rule.check(&ctx) {
+            Ok(mut warnings) => {
+                // Set file path to "<stdin>" for all warnings
+                for warning in &mut warnings {
+                    // The warnings already have the correct character ranges
+                }
+                all_warnings.extend(warnings);
+            }
+            Err(e) => {
+                if !args.quiet {
+                    eprintln!("Error running rule {}: {}", rule.name(), e);
+                }
+            }
+        }
+    }
+
+    // Output results
+    if args.output == "json" {
+        // For JSON output, modify warnings to show "<stdin>" as filename
+        let mut json_warnings = Vec::new();
+        for warning in all_warnings {
+            let mut json_warning = serde_json::to_value(&warning).unwrap();
+            if let Some(obj) = json_warning.as_object_mut() {
+                obj.insert("file".to_string(), serde_json::Value::String("<stdin>".to_string()));
+            }
+            json_warnings.push(json_warning);
+        }
+        println!("{}", serde_json::to_string_pretty(&json_warnings).unwrap());
+    } else {
+        // Text output
+        let has_issues = !all_warnings.is_empty();
+        if has_issues {
+            for warning in &all_warnings {
+                println!(
+                    "<stdin>:{}:{}: {}: {} [{}]",
+                    warning.line,
+                    warning.column,
+                    match warning.severity {
+                        rumdl::rule::Severity::Error => "error".red(),
+                        rumdl::rule::Severity::Warning => "warning".yellow(),
+                    },
+                    warning.message,
+                    warning.rule_name.as_deref().unwrap_or("unknown")
+                );
+            }
+        }
+
+        if !args.quiet {
+            if has_issues {
+                println!("\nFound {} issue(s) in stdin", all_warnings.len());
+            } else {
+                println!("No issues found in stdin");
+            }
+        }
+
+        // Exit with error code if issues found
+        if has_issues {
+            process::exit(1);
+        }
+    }
+}
+
 fn run_check(args: &CheckArgs, global_config_path: Option<&str>, no_config: bool) {
     // 1. Load sourced config (for provenance and validation)
     let sourced = match rumdl_config::SourcedConfig::load_with_discovery(
@@ -1257,6 +1341,12 @@ fn run_check(args: &CheckArgs, global_config_path: Option<&str>, no_config: bool
     // Initialize rules with configuration
     let enabled_rules = get_enabled_rules_from_checkargs(args, &config);
 
+    // Handle stdin input
+    if args.stdin {
+        process_stdin(&enabled_rules, args);
+        return;
+    }
+
     // Find all markdown files to check
     let file_paths = match find_markdown_files(&args.paths, args, &config) {
         Ok(paths) => paths,

{rumdl-0.0.67 → rumdl-0.0.68}/src/rule.rs

@@ -43,8 +43,10 @@ pub type LintResult = Result<Vec<LintWarning>, LintError>;
 #[derive(Debug, PartialEq, Clone, Serialize)]
 pub struct LintWarning {
     pub message: String,
-    pub line: usize,
-    pub column: usize,
+    pub line: usize,           // 1-indexed start line
+    pub column: usize,         // 1-indexed start column
+    pub end_line: usize,       // 1-indexed end line
+    pub end_column: usize,     // 1-indexed end column
     pub severity: Severity,
     pub fix: Option<Fix>,
     pub rule_name: Option<&'static str>,

{rumdl-0.0.67 → rumdl-0.0.68}/src/rules/md001_heading_increment.rs

@@ -1,7 +1,7 @@
 use crate::rule::{Fix, LintError, LintResult, LintWarning, Rule, RuleCategory, Severity};
 use crate::rules::heading_utils::HeadingUtils;
 use crate::utils::document_structure::DocumentStructure;
-use crate::utils::range_utils::LineIndex;
+use crate::utils::range_utils::{LineIndex, calculate_heading_range};
 use crate::HeadingStyle;
 
 /// Rule MD001: Heading levels should only increment by one level at a time
@@ -147,10 +147,23 @@ impl Rule for MD001HeadingIncrement {
                 let replacement =
                     HeadingUtils::convert_heading_style(&heading_text, fixed_level as u32, style);
 
+                // Calculate precise range: highlight the entire heading
+                let line_content = if adjusted_line_num < lines.len() {
+                    lines[adjusted_line_num]
+                } else {
+                    ""
+                };
+                let (start_line, start_col, end_line, end_col) = calculate_heading_range(
+                    line_num,
+                    line_content
+                );
+
                 warnings.push(LintWarning {
                     rule_name: Some(self.name()),
-                    line: line_num,
-                    column: indentation + 1,
+                    line: start_line,
+                    column: start_col,
+                    end_line: end_line,
+                    end_column: end_col,
                     message: format!("Heading level should be {} for this level", prev_level + 1),
                     severity: Severity::Warning,
                     fix: Some(Fix {

{rumdl-0.0.67 → rumdl-0.0.68}/src/rules/md002_first_heading_h1.rs

@@ -2,6 +2,7 @@ use crate::rule::Rule;
 use crate::rule::{Fix, LintError, LintResult, LintWarning, RuleCategory, Severity};
 use crate::rules::heading_utils::HeadingStyle;
 use crate::utils::document_structure::DocumentStructure;
+use crate::utils::range_utils::calculate_heading_range;
 use lazy_static::lazy_static;
 use regex::Regex;
 use toml;
@@ -238,10 +239,25 @@ impl Rule for MD002FirstHeadingH1 {
                     }
                 },
             );
+
+            // Calculate precise range: highlight the entire first heading
+            let lines: Vec<&str> = content.lines().collect();
+            let line_content = if first_heading_line > 0 && first_heading_line <= lines.len() {
+                lines[first_heading_line - 1]
+            } else {
+                ""
+            };
+            let (start_line, start_col, end_line, end_col) = calculate_heading_range(
+                first_heading_line,
+                line_content
+            );
+
             result.push(LintWarning {
                 message,
-                line: first_heading_line,
-                column: 1,
+                line: start_line,
+                column: start_col,
+                end_line: end_line,
+                end_column: end_col,
                 severity: Severity::Warning,
                 fix,
                 rule_name: Some(self.name()),

{rumdl-0.0.67 → rumdl-0.0.68}/src/rules/md003_heading_style.rs

@@ -6,6 +6,7 @@
 use crate::rule::{LintError, LintResult, LintWarning, Rule, RuleCategory, Severity};
 use crate::rules::heading_utils::HeadingStyle;
 use crate::utils::document_structure::DocumentStructure;
+use crate::utils::range_utils::calculate_heading_range;
 use lazy_static::lazy_static;
 use regex::Regex;
 use std::str::FromStr;
@@ -325,12 +326,27 @@ impl Rule for MD003HeadingStyle {
                     })
                 };
 
+                // Calculate precise character range for the heading marker
+                let (start_line, start_col, end_line, end_col) = if style == HeadingStyle::Setext1 || style == HeadingStyle::Setext2 {
+                    // For Setext headings, highlight the underline
+                    if next_line_idx < lines.len() {
+                        calculate_heading_range(line_num + 1, lines[next_line_idx])
+                    } else {
+                        calculate_heading_range(line_num, current_line)
+                    }
+                } else {
+                    // For ATX headings, highlight the hash markers
+                    calculate_heading_range(line_num, current_line)
+                };
+
                 result.push(LintWarning {
-                    rule_name: Some(self.name()),
-                    line: line_num, // Already 1-indexed
-                    column: 1,
-                    message: format!(
-                        "Heading style should be {:?}, found {:?}",
+                rule_name: Some(self.name()),
+                line: start_line,
+                column: start_col,
+                end_line: end_line,
+                end_column: end_col,
+                message: format!(
+                "Heading style should be {:?}, found {:?}",
                         expected_style, style
                     ),
                     severity: Severity::Warning,

{rumdl-0.0.67 → rumdl-0.0.68}/src/rules/md004_unordered_list_style.rs

@@ -168,9 +168,11 @@ impl Rule for MD004UnorderedListStyle {
                             if marker != first {
                                 let (line, col) = ctx.offset_to_line_col(offset);
                                 warnings.push(LintWarning {
-                                    line,
-                                    column: col,
-                                    message: format!("marker '{}' does not match expected style '{}'", marker, first),
+                line,
+                column: col,
+                end_line: line,
+                end_column: col + 1,
+                message: format!("marker '{}' does not match expected style '{}'", marker, first),
                                     severity: Severity::Warning,
                                     rule_name: Some(self.name()),
                                     fix: Some(Fix {
@@ -195,9 +197,11 @@ impl Rule for MD004UnorderedListStyle {
                         if marker != target_marker {
                             let (line, col) = ctx.offset_to_line_col(offset);
                             warnings.push(LintWarning {
-                                line,
-                                column: col,
-                                message: format!("marker '{}' does not match expected style '{}'", marker, target_marker),
+                line,
+                column: col,
+                end_line: line,
+                end_column: col + 1,
+                message: format!("marker '{}' does not match expected style '{}'", marker, target_marker),
                                 severity: Severity::Warning,
                                 rule_name: Some(self.name()),
                                 fix: Some(Fix {

{rumdl-0.0.67 → rumdl-0.0.68}/src/rules/md005_list_indent.rs

@@ -3,7 +3,7 @@
 //!
 //! See [docs/md005.md](../../docs/md005.md) for full documentation, configuration, and examples.
 
-use crate::utils::range_utils::LineIndex;
+use crate::utils::range_utils::{LineIndex, calculate_match_range};
 
 use crate::rule::{Fix, LintError, LintResult, LintWarning, Rule, RuleCategory, Severity};
 use crate::utils::document_structure::DocumentStructure;
@@ -257,16 +257,27 @@ impl Rule for MD005ListIndent {
                 let trimmed = line.trim_start();
                 let replacement = format!("{}{}", " ".repeat(expected_indent), trimmed);
 
+                // Calculate precise character range for the incorrect indentation
+                let (start_line, start_col, end_line, end_col) = if *indent > 0 {
+                    // Highlight the incorrect indentation spaces
+                    calculate_match_range(*line_num + 1, line, 1, *indent + 1)
+                } else {
+                    // No indentation, highlight position where indentation should be
+                    calculate_match_range(*line_num + 1, line, 1, 1)
+                };
+
                 warnings.push(LintWarning {
-                    rule_name: Some(self.name()),
-                    line: line_num + 1,
-                    column: 1,
-                    message: inconsistent_message,
-                    severity: Severity::Warning,
-                    fix: Some(Fix {
-                        range: line_index.line_col_to_byte_range(line_num + 1, 1),
-                        replacement,
-                    }),
+                rule_name: Some(self.name()),
+                line: start_line,
+                column: start_col,
+                end_line: end_line,
+                end_column: end_col,
+                message: inconsistent_message,
+                severity: Severity::Warning,
+                fix: Some(Fix {
+                range: line_index.line_col_to_byte_range(line_num + 1, 1),
+                replacement,
+            }),
                 });
             }
         }
@@ -313,16 +324,27 @@ impl Rule for MD005ListIndent {
 
                     // Only add if we don't already have a warning for this line
                     if !warnings.iter().any(|w| w.line == line_num + 1) {
+                        // Calculate precise character range for the incorrect indentation
+                        let (start_line, start_col, end_line, end_col) = if indent > 0 {
+                            // Highlight the incorrect indentation spaces
+                            calculate_match_range(line_num + 1, line, 1, indent + 1)
+                        } else {
+                            // No indentation, highlight position where indentation should be
+                            calculate_match_range(line_num + 1, line, 1, 1)
+                        };
+
                         warnings.push(LintWarning {
-                            rule_name: Some(self.name()),
-                            line: line_num + 1,
-                            column: 1,
-                            message: inconsistent_message,
-                            severity: Severity::Warning,
-                            fix: Some(Fix {
-                                range: line_index.line_col_to_byte_range(line_num + 1, 1),
-                                replacement,
-                            }),
+                rule_name: Some(self.name()),
+                line: start_line,
+                column: start_col,
+                end_line: end_line,
+                end_column: end_col,
+                message: inconsistent_message,
+                severity: Severity::Warning,
+                fix: Some(Fix {
+                range: line_index.line_col_to_byte_range(line_num + 1, 1),
+                replacement,
+            }),
                         });
                     }
                 }
@@ -368,16 +390,27 @@ impl Rule for MD005ListIndent {
 
                     // Only add if we don't already have a warning
                     if !warnings.iter().any(|w| w.line == line_num + 1) {
+                        // Calculate precise character range for the incorrect indentation
+                        let (start_line, start_col, end_line, end_col) = if *indent > 0 {
+                            // Highlight the incorrect indentation spaces
+                            calculate_match_range(*line_num + 1, line, 1, *indent + 1)
+                        } else {
+                            // No indentation, highlight position where indentation should be
+                            calculate_match_range(*line_num + 1, line, 1, 1)
+                        };
+
                         warnings.push(LintWarning {
-                            rule_name: Some(self.name()),
-                            line: line_num + 1,
-                            column: 1,
-                            message,
-                            severity: Severity::Warning,
-                            fix: Some(Fix {
-                                range: line_index.line_col_to_byte_range(line_num + 1, 1),
-                                replacement,
-                            }),
+                rule_name: Some(self.name()),
+                line: start_line,
+                column: start_col,
+                end_line: end_line,
+                end_column: end_col,
+                message,
+                severity: Severity::Warning,
+                fix: Some(Fix {
+                range: line_index.line_col_to_byte_range(line_num + 1, 1),
+                replacement,
+            }),
                         });
                     }
                 }
@@ -610,15 +643,17 @@ impl Rule for MD005ListIndent {
                 let replacement = format!("{}{}", " ".repeat(expected_indent), trimmed);
 
                 warnings.push(LintWarning {
-                    rule_name: Some(self.name()),
-                    line: line_num + 1,
-                    column: 1,
-                    message: inconsistent_message,
-                    severity: Severity::Warning,
-                    fix: Some(Fix {
-                        range: line_index.line_col_to_byte_range(line_num + 1, 1),
-                        replacement,
-                    }),
+                rule_name: Some(self.name()),
+                line: line_num + 1,
+                column: 1,
+                end_line: line_num + 1,
+                end_column: 1 + 1,
+                message: inconsistent_message,
+                severity: Severity::Warning,
+                fix: Some(Fix {
+                range: line_index.line_col_to_byte_range(line_num + 1, 1),
+                replacement,
+            }),
                 });
             }
         }
@@ -666,15 +701,17 @@ impl Rule for MD005ListIndent {
                     // Only add if we don't already have a warning for this line
                     if !warnings.iter().any(|w| w.line == line_num + 1) {
                         warnings.push(LintWarning {
-                            rule_name: Some(self.name()),
-                            line: line_num + 1,
-                            column: 1,
-                            message: inconsistent_message,
-                            severity: Severity::Warning,
-                            fix: Some(Fix {
-                                range: line_index.line_col_to_byte_range(line_num + 1, 1),
-                                replacement,
-                            }),
+                rule_name: Some(self.name()),
+                line: line_num + 1,
+                column: 1,
+                end_line: line_num + 1,
+                end_column: 1 + 1,
+                message: inconsistent_message,
+                severity: Severity::Warning,
+                fix: Some(Fix {
+                range: line_index.line_col_to_byte_range(line_num + 1, 1),
+                replacement,
+            }),
                         });
                     }
                 }
@@ -721,15 +758,17 @@ impl Rule for MD005ListIndent {
                     // Only add if we don't already have a warning
                     if !warnings.iter().any(|w| w.line == line_num + 1) {
                         warnings.push(LintWarning {
-                            rule_name: Some(self.name()),
-                            line: line_num + 1,
-                            column: 1,
-                            message,
-                            severity: Severity::Warning,
-                            fix: Some(Fix {
-                                range: line_index.line_col_to_byte_range(line_num + 1, 1),
-                                replacement,
-                            }),
+                rule_name: Some(self.name()),
+                line: line_num + 1,
+                column: 1,
+                end_line: line_num + 1,
+                end_column: 1 + 1,
+                message,
+                severity: Severity::Warning,
+                fix: Some(Fix {
+                range: line_index.line_col_to_byte_range(line_num + 1, 1),
+                replacement,
+            }),
                         });
                     }
                 }