rumdl 0.0.106__tar.gz → 0.0.107__tar.gz

{rumdl-0.0.106 → rumdl-0.0.107}/CHANGELOG.md

@@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.107] - 2025-08-06
+
 ## [0.0.106] - 2025-08-05
 
 ### Changed
@@ -289,7 +291,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.105...HEAD
+[Unreleased]: https://github.com/rvben/rumdl/compare/v0.0.107...HEAD
+[0.0.107]: https://github.com/rvben/rumdl/compare/v0.0.106...v0.0.107
 [0.0.105]: https://github.com/rvben/rumdl/compare/v0.0.104...v0.0.105
 [0.0.105]: https://github.com/rvben/rumdl/compare/v0.0.104...v0.0.105
 [0.0.104]: https://github.com/rvben/rumdl/compare/v0.0.103...v0.0.104

{rumdl-0.0.106 → rumdl-0.0.107}/Cargo.lock

@@ -49,9 +49,9 @@ checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
 
 [[package]]
 name = "anstream"
-version = "0.6.19"
+version = "0.6.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "301af1932e46185686725e0fad2f8f2aa7da69dd70bf6ecc44d6b703844a3933"
+checksum = "3ae563653d1938f79b1ab1b5e668c87c76a9930414574a6583a7b7e11a8e6192"
 dependencies = [
  "anstyle",
  "anstyle-parse",
@@ -79,22 +79,22 @@ dependencies = [
 
 [[package]]
 name = "anstyle-query"
-version = "1.1.3"
+version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c8bdeb6047d8983be085bab0ba1472e6dc604e7041dbf6fcd5e71523014fae9"
+checksum = "9e231f6134f61b71076a3eab506c379d4f36122f2af15a9ff04415ea4c3339e2"
 dependencies = [
- "windows-sys 0.59.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
 name = "anstyle-wincon"
-version = "3.0.9"
+version = "3.0.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "403f75924867bb1033c59fbf0797484329750cfbe3c4325cd33127941fabc882"
+checksum = "3e0633414522a32ffaac8ac6cc8f748e090c5717661fddeea04219e2344f5f2a"
 dependencies = [
  "anstyle",
  "once_cell_polyfill",
- "windows-sys 0.59.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -1493,7 +1493,7 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "rumdl"
-version = "0.0.106"
+version = "0.0.107"
 dependencies = [
  "anyhow",
  "assert_cmd",
@@ -2527,9 +2527,9 @@ dependencies = [
 
 [[package]]
 name = "zerovec"
-version = "0.11.3"
+version = "0.11.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bdbb9122ea75b11bf96e7492afb723e8a7fbe12c67417aa95e7e3d18144d37cd"
+checksum = "e7aa2bd55086f1ab526693ecbe444205da57e25f4489879da80635a46d90e73b"
 dependencies = [
  "yoke",
  "zerofrom",

{rumdl-0.0.106 → rumdl-0.0.107}/Cargo.toml

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

{rumdl-0.0.106 → rumdl-0.0.107}/PKG-INFO

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

{rumdl-0.0.106 → rumdl-0.0.107}/docs/md036.md

@@ -1,8 +1,10 @@
 # MD036 - Use real headings, not just bold text
 
+> **Note:** This rule does not provide automatic fixes because it cannot reliably determine user intent. Bold text on its own line has many legitimate uses (image captions, labels, warnings, etc.).
+
 ## What this rule does
 
-Detects when bold or italic text is used as a standalone heading and converts it to proper heading syntax.
+Detects when bold or italic text is used as a standalone heading.
 
 ## Why this matters
 
@@ -43,9 +45,9 @@ Using emphasis as headings:
 **Configuration:**
 ```
 
-### 🔧 Fixed
+### 🔧 Manual Fix Required
 
-Converted to proper headings:
+These should be manually converted to proper headings:
 
 ```markdown
 ## This looks like a heading
@@ -57,28 +59,29 @@ Converted to proper headings:
 ## Configuration
 ```
 
+**Note:** rumdl will detect these issues but won't automatically fix them. You need to manually decide if the emphasized text should be a heading.
+
 <!-- rumdl-enable MD036 -->
 
 ## Configuration
 
-```yaml
-MD036:
-  punctuation: ".,;:!?"  # Characters to remove from heading ends
+```toml
+# .rumdl.toml
+[MD036]
+punctuation = ".,;:!?"  # Configure punctuation checking
 ```
 
 ### Options
 
-- `punctuation`: String of punctuation marks to remove when converting (default: `".,;:!?"`)
-  - Set to `""` to keep all punctuation
+- `punctuation`: String of punctuation marks that, when found at the end of emphasized text, prevent it from being flagged (default: `".,;:!?"`)
+  - Set to `""` to flag all emphasized lines regardless of punctuation
   - Customize to remove only specific marks
 
 ## Automatic fixes
 
-This rule will:
-- Convert standalone bold/italic lines to proper headings
-- Remove trailing punctuation based on your configuration
-- Choose appropriate heading level (## for bold, # for italic)
-- Preserve common labels like "Table of Contents" as-is
+This rule does **not** provide automatic fixes. Converting bold or italic text to headings is too risky as it can corrupt documents. For example, bold text is often used for image captions, labels, or other legitimate emphasis that should not be converted to headings.
+
+Users should manually review each warning and decide whether the emphasized text should be converted to a heading.
 
 ## Learn more
 

{rumdl-0.0.106 → rumdl-0.0.107}/src/config.rs

@@ -862,6 +862,46 @@ local_time = 07:32:00
             // Note: local_date and local_time might not be parsed by the current implementation
         }
     }
+
+    #[test]
+    fn test_default_config_passes_validation() {
+        use crate::rules;
+
+        let temp_dir = tempdir().unwrap();
+        let config_path = temp_dir.path().join(".rumdl.toml");
+        let config_path_str = config_path.to_str().unwrap();
+
+        // Create the default config using the same function that `rumdl init` uses
+        create_default_config(config_path_str).unwrap();
+
+        // Load it back as a SourcedConfig
+        let sourced =
+            SourcedConfig::load(Some(config_path_str), None).expect("Default config should load successfully");
+
+        // Create the rule registry
+        let all_rules = rules::all_rules(&Config::default());
+        let registry = RuleRegistry::from_rules(&all_rules);
+
+        // Validate the config
+        let warnings = validate_config_sourced(&sourced, &registry);
+
+        // The default config should have no warnings
+        if !warnings.is_empty() {
+            for warning in &warnings {
+                eprintln!("Config validation warning: {}", warning.message);
+                if let Some(rule) = &warning.rule {
+                    eprintln!("  Rule: {rule}");
+                }
+                if let Some(key) = &warning.key {
+                    eprintln!("  Key: {key}");
+                }
+            }
+        }
+        assert!(
+            warnings.is_empty(),
+            "Default config from rumdl init should pass validation without warnings"
+        );
+    }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]

{rumdl-0.0.106 → rumdl-0.0.107}/src/lib.rs

@@ -1,6 +1,5 @@
 pub mod config;
 pub mod exit_codes;
-pub mod init;
 pub mod inline_config;
 pub mod lint_context;
 pub mod lsp;
@@ -190,8 +189,18 @@ pub fn lint(content: &str, rules: &[Box<dyn Rule>], _verbose: bool) -> LintResul
                 let filtered_warnings: Vec<_> = rule_warnings
                     .into_iter()
                     .filter(|warning| {
+                        // Use the warning's rule_name if available, otherwise use the rule's name
+                        let rule_name_to_check = warning.rule_name.unwrap_or(rule.name());
+
+                        // Extract the base rule name for sub-rules like "MD029-style" -> "MD029"
+                        let base_rule_name = if let Some(dash_pos) = rule_name_to_check.find('-') {
+                            &rule_name_to_check[..dash_pos]
+                        } else {
+                            rule_name_to_check
+                        };
+
                         !inline_config.is_rule_disabled(
-                            rule.name(),
+                            base_rule_name,
                             warning.line, // Already 1-indexed
                         )
                     })

{rumdl-0.0.106 → rumdl-0.0.107}/src/rules/md011_no_reversed_links.rs

@@ -204,18 +204,18 @@ impl Rule for MD011NoReversedLinks {
         let mut byte_pos = 0;
 
         for (line_num, line) in content.lines().enumerate() {
-            // Skip if this line is in a code block
-            if ctx.is_in_code_block_or_span(byte_pos) {
-                byte_pos += line.len() + 1;
-                continue;
-            }
-
             // Part 1: Check for existing perfectly formed reversed links
             for cap in REVERSED_LINK_CHECK_REGEX.captures_iter(line) {
                 let match_obj = cap.get(0).unwrap();
                 let match_start = match_obj.start();
                 let match_end = match_obj.end();
 
+                // Check if this specific match is within a code block or inline code span
+                let match_byte_pos = byte_pos + match_start;
+                if ctx.is_in_code_block_or_span(match_byte_pos) {
+                    continue;
+                }
+
                 // Check if the match contains escaped brackets or parentheses
                 let match_text = match_obj.as_str();
 
@@ -277,6 +277,12 @@ impl Rule for MD011NoReversedLinks {
             // Part 2: Check for malformed link attempts where user intent is clear
             let malformed_attempts = self.detect_malformed_link_attempts(line);
             for (start, len, url, text) in malformed_attempts {
+                // Check if this specific match is within a code block or inline code span
+                let match_byte_pos = byte_pos + start;
+                if ctx.is_in_code_block_or_span(match_byte_pos) {
+                    continue;
+                }
+
                 // Calculate precise character range for the malformed syntax
                 let (start_line, start_col, end_line, end_col) = calculate_match_range(line_num + 1, line, start, len);
 
@@ -593,4 +599,45 @@ But this (https://example.com)[reversed link] should be flagged."#;
         let result = rule.check(&ctx).unwrap();
         assert_eq!(result.len(), 1, "Should still flag URLs with nested parentheses");
     }
+
+    #[test]
+    fn test_inline_code_patterns() {
+        // Test for issue #19 - MD011 should not flag patterns inside inline code
+        let rule = MD011NoReversedLinks;
+
+        // Test the exact case from issue #19
+        let content = "I find `inspect.stack()[1].frame` a lot easier to understand (or at least guess about) at a glance than `inspect.stack()[1][0]`.";
+        let ctx = LintContext::new(content);
+        let result = rule.check(&ctx).unwrap();
+        assert_eq!(result.len(), 0, "Should not flag ()[1] patterns inside inline code");
+
+        // Test other patterns that might look like reversed links in code
+        let content = "Use `array()[0]` or `func()[1]` to access elements.";
+        let ctx = LintContext::new(content);
+        let result = rule.check(&ctx).unwrap();
+        assert_eq!(result.len(), 0, "Should not flag array access patterns in inline code");
+
+        // Test that actual reversed links outside code are still caught
+        let content = "Check out (https://example.com)[this link] and use `array()[1]`.";
+        let ctx = LintContext::new(content);
+        let result = rule.check(&ctx).unwrap();
+        assert_eq!(result.len(), 1, "Should flag actual reversed link but not code pattern");
+        assert!(result[0].message.contains("Reversed link syntax"));
+
+        // Test mixed scenario with code blocks
+        let content = r#"
+Here's some code: `func()[1]` and `other()[2]`.
+
+But this is wrong: (https://example.com)[Click here]
+
+```python
+# This should not be flagged
+result = inspect.stack()[1]
+```
+"#;
+        let ctx = LintContext::new(content);
+        let result = rule.check(&ctx).unwrap();
+        assert_eq!(result.len(), 1, "Should only flag the actual reversed link");
+        assert_eq!(result[0].line, 4, "Should flag the reversed link on line 4");
+    }
 }

{rumdl-0.0.106 → rumdl-0.0.107}/src/rules/md029_ordered_list_prefix.rs

@@ -4,7 +4,6 @@
 use crate::rule::{Fix, LintError, LintResult, LintWarning, Rule, RuleCategory, Severity};
 use crate::rule_config_serde::RuleConfig;
 use crate::utils::document_structure::{DocumentStructure, DocumentStructureExtensions};
-use crate::utils::range_utils::LineIndex;
 use crate::utils::regex_cache::ORDERED_LIST_MARKER_REGEX;
 use lazy_static::lazy_static;
 use regex::Regex;
@@ -136,10 +135,22 @@ impl Rule for MD029OrderedListPrefix {
         let mut indent_stack: Vec<(usize, usize)> = Vec::new(); // (indent, index)
         let lines: Vec<&str> = content.lines().collect();
         let mut byte_pos = 0;
+        let mut in_code_fence = false;
 
         for line in lines.iter() {
-            // Skip if in code block
-            if ctx.is_in_code_block_or_span(byte_pos) {
+            let trimmed = line.trim();
+
+            // Track code fences
+            if trimmed.starts_with("```") || trimmed.starts_with("~~~") {
+                in_code_fence = !in_code_fence;
+                result.push_str(line);
+                result.push('\n');
+                byte_pos += line.len() + 1;
+                continue;
+            }
+
+            // Skip if in code block or fence
+            if in_code_fence || ctx.is_in_code_block_or_span(byte_pos) {
                 result.push_str(line);
                 result.push('\n');
                 byte_pos += line.len() + 1;
@@ -177,30 +188,50 @@ impl Rule for MD029OrderedListPrefix {
                     *idx += 1;
                 }
             } else if !line.trim().is_empty() {
-                // Check if this is a code fence line - don't break the list for these
-                let trimmed = line.trim();
-                if trimmed.starts_with("```") || trimmed.starts_with("~~~") {
-                    // Code fence lines don't break the list
-                    result.push_str(line);
-                    result.push('\n');
-                } else {
-                    // Check if the line is indented enough to be part of a list item
-                    let line_indent = line.chars().take_while(|c| c.is_whitespace()).count();
-                    let is_continuation = indent_stack
-                        .last()
-                        .map(|&(list_indent, _)| line_indent >= list_indent + 3)
-                        .unwrap_or(false);
-
-                    if is_continuation {
-                        // This line is part of the list item (indented continuation)
-                        result.push_str(line);
-                        result.push('\n');
+                // Check if the line is indented enough to be part of a list item
+                let line_indent = line.chars().take_while(|c| c.is_whitespace()).count();
+                let is_continuation = indent_stack
+                    .last()
+                    .map(|&(list_indent, _)| {
+                        // Allow lazy continuation (0-2 spaces) or proper continuation (3+ spaces)
+                        line_indent <= 2 || line_indent >= list_indent + 3
+                    })
+                    .unwrap_or(false);
+
+                if is_continuation {
+                    if line_indent <= 2 && !indent_stack.is_empty() {
+                        // Check if this line is itself a list item
+                        let trimmed = line.trim();
+                        let is_list_item = trimmed.starts_with("* ")
+                            || trimmed.starts_with("- ")
+                            || trimmed.starts_with("+ ")
+                            || (trimmed.len() > 2
+                                && trimmed.chars().next().unwrap().is_ascii_digit()
+                                && trimmed.contains(". "));
+
+                        if !is_list_item {
+                            // This is a lazy continuation - fix it by adding proper indentation
+                            let (list_indent, _) = indent_stack.last().unwrap();
+                            let proper_indent = " ".repeat(list_indent + 3);
+                            result.push_str(&proper_indent);
+                            result.push_str(line.trim_start());
+                            result.push('\n');
+                        } else {
+                            // This is a list item, not a continuation - it breaks the list
+                            indent_stack.clear();
+                            result.push_str(line);
+                            result.push('\n');
+                        }
                     } else {
-                        // Non-list, non-blank line breaks the list
-                        indent_stack.clear();
+                        // This line is properly indented
                         result.push_str(line);
                         result.push('\n');
                     }
+                } else {
+                    // Non-list, non-blank line breaks the list
+                    indent_stack.clear();
+                    result.push_str(line);
+                    result.push('\n');
                 }
             } else {
                 // Blank line - don't clear the stack, as lists can have blank lines within them
@@ -221,74 +252,11 @@ impl Rule for MD029OrderedListPrefix {
     fn check_with_structure(
         &self,
         ctx: &crate::lint_context::LintContext,
-        structure: &crate::utils::document_structure::DocumentStructure,
+        _structure: &crate::utils::document_structure::DocumentStructure,
     ) -> LintResult {
-        let content = ctx.content;
-
-        // Early return if no lists
-        if structure.list_lines.is_empty() {
-            return Ok(Vec::new());
-        }
-
-        // Quick check if there are no ordered lists
-        if !content.contains('1') || (!content.contains("1.") && !content.contains("2.") && !content.contains("0.")) {
-            return Ok(Vec::new());
-        }
-
-        let mut warnings = Vec::new();
-        let mut list_items = Vec::new();
-        let lines: Vec<&str> = content.lines().collect();
-
-        // Create a set of list line indices for faster lookup
-        let mut list_line_set = std::collections::HashSet::new();
-        for &line_num in &structure.list_lines {
-            list_line_set.insert(line_num); // Keep as 1-indexed for easier comparison
-        }
-
-        // Group ordered list items into sections
-        let mut in_list = false;
-
-        for (line_idx, line) in lines.iter().enumerate() {
-            let line_num = line_idx + 1; // Convert to 1-indexed
-
-            // Skip lines in code blocks
-            if structure.is_in_code_block(line_num) {
-                // Code blocks don't break the list - just skip them
-                continue;
-            }
-
-            if list_line_set.contains(&line_num) {
-                if Self::get_list_number(line).is_some() {
-                    // If this is the first item of a new list, record the list start
-                    if !in_list {
-                        in_list = true;
-                    }
-
-                    list_items.push((line_idx, line.to_string()));
-                }
-            } else if !line.trim().is_empty() {
-                // Check if this is a code fence line - don't break the list for these
-                let trimmed = line.trim();
-                if trimmed.starts_with("```") || trimmed.starts_with("~~~") {
-                    // Code fence lines don't break the list - just skip them
-                    continue;
-                }
-
-                // Non-empty, non-list line breaks the list
-                if in_list && !list_items.is_empty() {
-                    self.check_list_section(&list_items, &mut warnings, content);
-                    list_items.clear();
-                    in_list = false;
-                }
-            }
-        }
-
-        // Check last section if it exists
-        if !list_items.is_empty() {
-            self.check_list_section(&list_items, &mut warnings, content);
-        }
-
-        Ok(warnings)
+        // For MD029, we need to use the regular check method to get lazy continuation detection
+        // The document structure optimization doesn't provide enough context for proper lazy continuation checking
+        self.check(ctx)
     }
 
     /// Get the category of this rule for selective processing
@@ -337,15 +305,74 @@ impl Rule for MD029OrderedListPrefix {
 }
 
 impl DocumentStructureExtensions for MD029OrderedListPrefix {
-    fn has_relevant_elements(&self, ctx: &crate::lint_context::LintContext, doc_structure: &DocumentStructure) -> bool {
-        let content = ctx.content;
-        // This rule is only relevant if there are list items AND they might be ordered lists
-        !doc_structure.list_lines.is_empty()
-            && (content.contains("1.") || content.contains("2.") || content.contains("0."))
+    fn has_relevant_elements(
+        &self,
+        ctx: &crate::lint_context::LintContext,
+        _doc_structure: &DocumentStructure,
+    ) -> bool {
+        // This rule is relevant if there are any ordered list items
+        // We need to check even lists with all "1." items for:
+        // 1. Incorrect numbering according to configured style
+        // 2. Lazy continuation issues
+        ctx.list_blocks.iter().any(|block| block.is_ordered)
     }
 }
 
 impl MD029OrderedListPrefix {
+    /// Check for lazy continuation lines in a list block
+    fn check_for_lazy_continuation(
+        &self,
+        ctx: &crate::lint_context::LintContext,
+        list_block: &crate::lint_context::ListBlock,
+        warnings: &mut Vec<LintWarning>,
+    ) {
+        // Check all lines in the block for lazy continuation
+        for line_num in list_block.start_line..=list_block.end_line {
+            if let Some(line_info) = ctx.line_info(line_num) {
+                // Skip list item lines themselves
+                if list_block.item_lines.contains(&line_num) {
+                    continue;
+                }
+
+                // Skip blank lines
+                if line_info.is_blank {
+                    continue;
+                }
+
+                // Skip lines that are in code blocks
+                if line_info.in_code_block {
+                    continue;
+                }
+
+                // Skip code fence lines
+                let trimmed = line_info.content.trim();
+                if trimmed.starts_with("```") || trimmed.starts_with("~~~") {
+                    continue;
+                }
+
+                // Check if this is a lazy continuation (0-2 spaces)
+                if line_info.indent <= 2 && !line_info.content.trim().is_empty() {
+                    // This is a lazy continuation - add a style warning
+                    let col = line_info.indent + 1;
+
+                    warnings.push(LintWarning {
+                        rule_name: Some("MD029-style"),
+                        message: "List continuation should be indented (lazy continuation detected)".to_string(),
+                        line: line_num,
+                        column: col,
+                        end_line: line_num,
+                        end_column: col,
+                        severity: Severity::Warning,
+                        fix: Some(Fix {
+                            range: line_info.byte_offset..line_info.byte_offset,
+                            replacement: "   ".to_string(), // Add 3 spaces
+                        }),
+                    });
+                }
+            }
+        }
+    }
+
     /// Check if there's only code blocks/fences between two list blocks
     fn is_only_code_between_blocks(
         &self,
@@ -395,6 +422,9 @@ impl MD029OrderedListPrefix {
         let mut all_items = Vec::new();
 
         for list_block in group {
+            // First, check for lazy continuation in this block
+            self.check_for_lazy_continuation(ctx, list_block, warnings);
+
             for &item_line in &list_block.item_lines {
                 if let Some(line_info) = ctx.line_info(item_line) {
                     if let Some(list_item) = &line_info.list_item {
@@ -465,58 +495,6 @@ impl MD029OrderedListPrefix {
             }
         }
     }
-
-    fn check_list_section(&self, items: &[(usize, String)], warnings: &mut Vec<LintWarning>, content: &str) {
-        // Group items by indentation level and process each level independently
-        let mut level_groups: std::collections::HashMap<usize, Vec<(usize, String)>> = std::collections::HashMap::new();
-
-        for (line_num, line) in items {
-            let indent = line.chars().take_while(|c| c.is_whitespace()).count();
-            level_groups.entry(indent).or_default().push((*line_num, line.clone()));
-        }
-
-        // Process each indentation level separately
-        for (_indent, mut group) in level_groups {
-            // Sort by line number to ensure correct order
-            group.sort_by_key(|(line_num, _)| *line_num);
-
-            // Check each item in the group for correct sequence
-            for (idx, (line_num, line)) in group.iter().enumerate() {
-                if let Some(actual_num) = Self::get_list_number(line) {
-                    let expected_num = self.get_expected_number(idx);
-
-                    if actual_num != expected_num {
-                        // Create a LineIndex for the actual content
-                        let line_index = LineIndex::new(content.to_string());
-
-                        // Find the number position in the line for precise replacement
-                        let number_start = line.find(char::is_numeric).unwrap_or(0);
-                        let number_len = actual_num.to_string().len();
-
-                        warnings.push(LintWarning {
-                            rule_name: Some(self.name()),
-                            message: format!(
-                                "Ordered list item number {actual_num} does not match style (expected {expected_num})"
-                            ),
-                            line: line_num + 1,
-                            column: number_start + 1,
-                            end_line: line_num + 1,
-                            end_column: number_start + number_len + 1,
-                            severity: Severity::Warning,
-                            fix: Some(Fix {
-                                range: line_index.line_col_to_byte_range_with_length(
-                                    line_num + 1,
-                                    number_start + 1,
-                                    number_len,
-                                ),
-                                replacement: expected_num.to_string(),
-                            }),
-                        });
-                    }
-                }
-            }
-        }
-    }
 }
 
 #[cfg(test)]