rumdl 0.0.66__tar.gz → 0.0.68__tar.gz

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

@@ -1704,7 +1704,7 @@ dependencies = [
 
 [[package]]
 name = "rumdl"
-version = "0.0.66"
+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.66 → rumdl-0.0.68}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rumdl"
-version = "0.0.66"
+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.66 → rumdl-0.0.68}/PKG-INFO

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

{rumdl-0.0.66 → 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.66 → 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.66 → 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.66 → 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.66 → 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.66 → 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.66 → 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.66 → rumdl-0.0.68}/src/rules/md003_heading_style.rs

@@ -4,9 +4,9 @@
 //! See [docs/md003.md](../../docs/md003.md) for full documentation, configuration, and examples.
 
 use crate::rule::{LintError, LintResult, LintWarning, Rule, RuleCategory, Severity};
-use crate::rules::heading_utils::{HeadingStyle, HeadingUtils};
+use crate::rules::heading_utils::HeadingStyle;
 use crate::utils::document_structure::DocumentStructure;
-use crate::utils::markdown_elements::{ElementQuality, ElementType, MarkdownElements};
+use crate::utils::range_utils::calculate_heading_range;
 use lazy_static::lazy_static;
 use regex::Regex;
 use std::str::FromStr;
@@ -166,143 +166,29 @@ impl Rule for MD003HeadingStyle {
     }
 
     fn fix(&self, ctx: &crate::lint_context::LintContext) -> Result<String, LintError> {
-        let content = ctx.content;
-        // Early return for empty content
-        if content.is_empty() {
-            return Ok(String::new());
-        }
-
-        // Quick check if there are any headings at all
-        if !QUICK_HEADING_CHECK.is_match(content) {
-            return Ok(content.to_string());
-        }
-
-        let mut fixed_content = String::new();
-        let mut last_processed_line = 0;
-        let lines: Vec<&str> = content.lines().collect();
-
-        // Get the target style - use the fallback method since no structure is available
-        let target_style = self.get_target_style(content, None);
-
-        // Get all headings using the MarkdownElements utility
-        let headings = MarkdownElements::detect_headings(content);
-
-        for heading in headings {
-            if heading.element_type != ElementType::Heading
-                || heading.quality != ElementQuality::Valid
-            {
-                continue; // Skip non-headings or invalid headings
-            }
-
-            // Add any lines before this heading
-            for i in last_processed_line..heading.start_line {
-                if !fixed_content.is_empty() {
-                    fixed_content.push('\n');
-                }
-                fixed_content.push_str(lines.get(i).unwrap_or(&""));
-            }
-
-            // Get the heading level
-            if let Some(level_str) = &heading.metadata {
-                if let Ok(level) = level_str.parse::<u32>() {
-                    // Determine the current style of the heading
-                    let style = if heading.end_line > heading.start_line {
-                        // Setext heading (has an underline)
-                        if level == 1 {
-                            HeadingStyle::Setext1
-                        } else {
-                            HeadingStyle::Setext2
-                        }
-                    } else {
-                        // ATX heading
-                        let line = lines.get(heading.start_line).map_or("", |v| *v);
-                        if line.trim().ends_with('#') {
-                            HeadingStyle::AtxClosed
-                        } else {
-                            HeadingStyle::Atx
-                        }
-                    };
-
-                    // For markdownlint parity: when target style is Setext, all headings are expected to be Setext
-                    // For level 3+, we can't actually convert to Setext, so leave as ATX but flag as violation
-                    let expected_style = if target_style == HeadingStyle::Setext1
-                        || target_style == HeadingStyle::Setext2
-                    {
-                        if level > 2 {
-                            // Level 3+ can't be Setext, so keep as ATX but this will be flagged as violation
-                            HeadingStyle::Atx
-                        } else if level == 1 {
-                            HeadingStyle::Setext1
-                        } else {
-                            HeadingStyle::Setext2
-                        }
-                    } else {
-                        target_style
-                    };
-
-                    // If this heading's style doesn't match the target, convert it
-                    if style != expected_style {
-                        // Get the text content from the heading
-                        let text_content = if heading.end_line > heading.start_line {
-                            // Setext heading
-                            lines.get(heading.start_line).unwrap_or(&"").to_string()
-                        } else {
-                            // ATX heading
-                            let line = lines.get(heading.start_line).map_or("", |v| *v);
-                            HeadingUtils::get_heading_text(line).unwrap_or_default()
-                        };
-
-                        // Get indentation
-                        let indentation = if let Some(line) = lines.get(heading.start_line) {
-                            line.chars()
-                                .take_while(|c| c.is_whitespace())
-                                .collect::<String>()
-                        } else {
-                            String::new()
-                        };
-
-                        // Convert heading to target style
-                        let converted_heading = HeadingUtils::convert_heading_style(
-                            &format!("{}{}", indentation, text_content),
-                            level,
-                            expected_style,
-                        );
-
-                        // Add converted heading
-                        if !fixed_content.is_empty() {
-                            fixed_content.push('\n');
-                        }
-                        fixed_content.push_str(&converted_heading);
-                    } else {
-                        // Add original heading lines
-                        for i in heading.start_line..=heading.end_line {
-                            if !fixed_content.is_empty() {
-                                fixed_content.push('\n');
-                            }
-                            fixed_content.push_str(lines.get(i).unwrap_or(&""));
-                        }
-                    }
+        // Get all warnings with their fixes
+        let warnings = self.check(ctx)?;
 
-                    // Update last processed line
-                    last_processed_line = heading.end_line + 1;
-                }
-            }
+        // If no warnings, return original content
+        if warnings.is_empty() {
+            return Ok(ctx.content.to_string());
         }
 
-        // Add any remaining lines
-        for i in last_processed_line..lines.len() {
-            if !fixed_content.is_empty() {
-                fixed_content.push('\n');
+        // Collect all fixes and sort by range start (descending) to apply from end to beginning
+        let mut fixes: Vec<_> = warnings.iter()
+            .filter_map(|w| w.fix.as_ref().map(|f| (f.range.start, f.range.end, &f.replacement)))
+            .collect();
+        fixes.sort_by(|a, b| b.0.cmp(&a.0));
+
+        // Apply fixes from end to beginning to preserve byte offsets
+        let mut result = ctx.content.to_string();
+        for (start, end, replacement) in fixes {
+            if start < result.len() && end <= result.len() && start <= end {
+                result.replace_range(start..end, replacement);
             }
-            fixed_content.push_str(lines.get(i).unwrap_or(&""));
-        }
-
-        // Preserve trailing newline
-        if content.ends_with('\n') && !fixed_content.ends_with('\n') {
-            fixed_content.push('\n');
         }
 
-        Ok(fixed_content)
+        Ok(result)
     }
 
     fn check_with_structure(
@@ -383,16 +269,88 @@ impl Rule for MD003HeadingStyle {
             };
 
             if style != expected_style {
+                // Generate fix for this heading
+                let fix = {
+                    use crate::rules::heading_utils::HeadingUtils;
+
+                    // Get the text content from the heading
+                    let text_content = if next_line_idx < lines.len() &&
+                        (lines[next_line_idx].trim_start().starts_with('=') ||
+                         lines[next_line_idx].trim_start().starts_with('-')) {
+                        // Setext heading
+                        current_line.to_string()
+                    } else {
+                        // ATX heading
+                        HeadingUtils::get_heading_text(current_line).unwrap_or_default()
+                    };
+
+                    // Get indentation
+                    let indentation = current_line.chars()
+                        .take_while(|c| c.is_whitespace())
+                        .collect::<String>();
+
+                    // Convert heading to target style
+                    let converted_heading = HeadingUtils::convert_heading_style(
+                        &format!("{}{}", indentation, text_content.trim()),
+                        level as u32,
+                        expected_style,
+                    );
+
+                    // Calculate the correct range for the heading
+                    let line_index = crate::utils::range_utils::LineIndex::new(ctx.content.to_string());
+                    let range = if next_line_idx < lines.len() &&
+                        (lines[next_line_idx].trim_start().starts_with('=') ||
+                         lines[next_line_idx].trim_start().starts_with('-')) {
+                        // Setext heading spans two lines
+                        let start_byte = line_index.line_col_to_byte_range(line_num, 1).start;
+                        let end_byte = if line_num + 1 < lines.len() {
+                            line_index.line_col_to_byte_range(line_num + 2, 1).start - 1
+                        } else {
+                            ctx.content.len()
+                        };
+                        start_byte..end_byte
+                    } else {
+                        // ATX heading is single line
+                        let start_byte = line_index.line_col_to_byte_range(line_num, 1).start;
+                        let end_byte = if line_num < lines.len() {
+                            line_index.line_col_to_byte_range(line_num + 1, 1).start - 1
+                        } else {
+                            ctx.content.len()
+                        };
+                        start_byte..end_byte
+                    };
+
+                    Some(crate::rule::Fix {
+                        range,
+                        replacement: converted_heading,
+                    })
+                };
+
+                // 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,
-                    fix: None,
+                    fix,
                 });
             }
         }

{rumdl-0.0.66 → 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 {