rumdl 0.0.107__tar.gz → 0.0.109__tar.gz

rumdl-0.0.109/.config/nextest.toml

@@ -0,0 +1,82 @@
+# Nextest configuration
+# https://nexte.st/book/configuration
+
+[profile.default]
+# Detect flaky tests and retry them
+retries = { backoff = "exponential", count = 2, delay = "1s", max-delay = "10s" }
+
+# Run tests with 2x the number of CPUs
+test-threads = "num-cpus"
+
+# Fail fast on first failure in CI
+fail-fast = false
+
+# Show failed tests immediately
+failure-output = "immediate"
+
+# Show successful tests at the end
+success-output = "final"
+
+# Status output level
+status-level = "pass"
+
+[profile.ci]
+
+# More conservative in CI
+test-threads = "num-cpus"
+
+# Always show all output in CI
+failure-output = "immediate"
+success-output = "immediate"
+status-level = "all"
+
+# No retries in CI to catch flaky tests
+retries = 0
+
+# Quick profile for development
+[profile.quick]
+
+# Skip slow tests and performance tests
+default-filter = 'not test(/memory/) and not test(/stress/) and not test(/large/) and not test(/error_propagation/) and not test(/performance/) and not test(/comprehensive/) and not test(/deeply_nested/)'
+
+# Even more parallel execution locally
+test-threads = "num-cpus"
+
+# Less verbose output
+status-level = "fail"
+
+# Development profile - balance between speed and coverage
+[profile.dev]
+
+# Skip the slowest tests but include integration tests
+default-filter = 'not test(/error_propagation/) and not test(/deeply_nested/) and not test(/memory/) and not test(/stress/) and not test(/large/) and not test(/performance/) and not test(/perf_check/)'
+
+# Good parallelization for dev machines
+test-threads = "num-cpus"
+
+# Show failures immediately
+failure-output = "immediate"
+status-level = "fail"
+
+# No retries for faster feedback
+retries = 0
+
+# Ultra-fast profile for pre-commit hooks
+[profile.pre-commit]
+
+# Only run unit tests in lib, skip all integration tests and binaries
+default-filter = 'package(rumdl) and kind(lib) and not test(/slow|stress|large|integration|comprehensive|cli|config|advanced|commonmark|consistency|performance|benchmark|parity|error_propagation|deeply_nested|memory/)'
+
+# Maximum parallelism for speed
+test-threads = "num-cpus"
+
+# Minimal output for speed
+status-level = "fail"
+failure-output = "immediate"
+success-output = "never"
+
+# No retries to save time
+retries = 0
+
+# Fail fast on first failure
+fail-fast = true

{rumdl-0.0.107 → rumdl-0.0.109}/.pre-commit-config.yaml

@@ -1,6 +1,10 @@
 # Pre-commit hooks for rumdl
-# Install with: pre-commit install
-# Run manually: pre-commit run --all-files
+# Install with:
+#   pre-commit install                    # Install commit hooks
+#   pre-commit install --hook-type pre-push  # Install push hooks
+# Run manually:
+#   pre-commit run --all-files           # Run commit hooks
+#   pre-commit run --hook-stage push --all-files  # Run push hooks
 
 repos:
   # Rust formatting and linting
@@ -15,26 +19,19 @@ repos:
 
       - id: cargo-clippy
         name: cargo clippy
-        entry: make lint
+        entry: make lint-fast
         language: system
         types: [rust]
         pass_filenames: false
 
       - id: cargo-test-quick
         name: cargo test (quick)
-        entry: make test-quick
+        entry: make test-pre-commit
         language: system
         types: [rust]
         pass_filenames: false
         stages: [pre-commit]
 
-      - id: cargo-check
-        name: cargo check
-        entry: cargo check --all-targets --all-features
-        language: system
-        types: [rust]
-        pass_filenames: false
-
   # General file quality checks
   - repo: https://github.com/pre-commit/pre-commit-hooks
     rev: v4.6.0
@@ -57,3 +54,33 @@ repos:
     hooks:
       - id: rumdl
         exclude: ^(test_tmp|benchmark/test-data|docs/temp|CHANGELOG\.md)
+
+  # Pre-push hooks for comprehensive validation
+  - repo: local
+    hooks:
+      - id: cargo-test-full
+        name: cargo test (full suite)
+        entry: make test-push
+        language: system
+        types: [rust]
+        pass_filenames: false
+        stages: [pre-push]
+        verbose: true
+
+      - id: cargo-lint-full
+        name: cargo clippy (all targets)
+        entry: make lint
+        language: system
+        types: [rust]
+        pass_filenames: false
+        stages: [pre-push]
+        verbose: true
+
+      - id: cargo-doc-check
+        name: cargo doc (check)
+        entry: cargo doc --no-deps --all-features
+        language: system
+        types: [rust]
+        pass_filenames: false
+        stages: [pre-push]
+        verbose: true

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

@@ -7,8 +7,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.110] - 2025-08-08
+
+## [0.0.107] - 2025-08-06
+
 ## [0.0.107] - 2025-08-06
 
+### Fixed
+- MD036: Remove automatic fix to prevent document corruption when bold/italic text is used as image captions, labels, or warnings (#23)
+- MD011: No longer flags patterns like `()[1]` inside inline code as reversed links (#19)
+- MD052: No longer flags reference patterns inside HTML comments as undefined references (#20)
+
 ## [0.0.106] - 2025-08-05
 
 ### Changed
@@ -291,7 +300,9 @@ 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.107...HEAD
+[Unreleased]: https://github.com/rvben/rumdl/compare/v0.0.110...HEAD
+[0.0.110]: https://github.com/rvben/rumdl/compare/v0.0.109...v0.0.110
+[0.0.107]: https://github.com/rvben/rumdl/compare/v0.0.106...v0.0.107
 [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

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

@@ -277,9 +277,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.42"
+version = "4.5.43"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed87a9d530bb41a67537289bafcac159cb3ee28460e0a4571123d2a778a6a882"
+checksum = "50fd97c9dc2399518aa331917ac6f274280ec5eb34e555dd291899745c48ec6f"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -287,9 +287,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.42"
+version = "4.5.43"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64f4f3f3c77c94aff3c7e9aac9a2ca1974a5adf392a8bb751e827d6d127ab966"
+checksum = "c35b5830294e1fa0462034af85cc95225a4cb07092c088c55bda3147cfcd8f65"
 dependencies = [
  "anstream",
  "anstyle",
@@ -672,9 +672,9 @@ checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
 
 [[package]]
 name = "hashbrown"
-version = "0.15.4"
+version = "0.15.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5971ac85611da7067dbfcabef3c70ebb5606018acd9e2a3903a0da507521e0d5"
+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
 
 [[package]]
 name = "heck"
@@ -848,7 +848,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fe4cd85333e22411419a0bcae1297d25e58c9443848b11dc6a86fefe8c78a661"
 dependencies = [
  "equivalent",
- "hashbrown 0.15.4",
+ "hashbrown 0.15.5",
 ]
 
 [[package]]
@@ -1493,7 +1493,7 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "rumdl"
-version = "0.0.107"
+version = "0.0.109"
 dependencies = [
  "anyhow",
  "assert_cmd",
@@ -1689,9 +1689,9 @@ dependencies = [
 
 [[package]]
 name = "slab"
-version = "0.4.10"
+version = "0.4.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04dc19736151f35336d325007ac991178d504a119863a2fcb3758cdb5e52c50d"
+checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589"
 
 [[package]]
 name = "smallvec"

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

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

{rumdl-0.0.107 → rumdl-0.0.109}/Makefile

@@ -61,14 +61,27 @@ build:
 	cargo build --release
 
 test:
+	cargo nextest run --profile dev
+
+test-legacy:
 	cargo test
 
 test-nextest:
 	cargo nextest run
 
+test-dev:
+	cargo nextest run --profile dev
+
 test-quick:
 	cargo nextest run --profile quick
 
+test-pre-commit:
+	cargo nextest run --profile pre-commit
+
+test-push:
+	@echo "Running full test suite (this may take a few minutes)..."
+	cargo nextest run
+
 test-ci:
 	cargo nextest run --profile ci
 
@@ -81,7 +94,10 @@ fmt:
 	cargo fix --allow-dirty --allow-staged
 
 lint:
-	cargo clippy --all-targets --all-features -- -D warnings
+	CARGO_INCREMENTAL=1 cargo clippy --all-targets --all-features -- -D warnings
+
+lint-fast:
+	CARGO_INCREMENTAL=1 cargo clippy --workspace --lib --bins -- -D warnings
 
 check:
 	cargo check --all-targets --all-features
@@ -90,7 +106,7 @@ doc:
 	cargo doc --no-deps
 
 watch-test:
-	cargo watch -x test
+	cargo watch -x "nextest run --profile quick"
 
 all: fmt check test build
 

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

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

rumdl-0.0.109/src/bin/debug_frontmatter.rs

@@ -0,0 +1,42 @@
+use rumdl::rules::front_matter_utils::FrontMatterUtils;
+use std::env;
+use std::fs;
+
+fn main() {
+    let args: Vec<String> = env::args().collect();
+    let content = if args.len() > 1 {
+        fs::read_to_string(&args[1]).expect("Failed to read file")
+    } else {
+        r#"+++
+title = "My Post"
+tags = ["example", "test"]
++++
+
+# Content
+
+[missing] reference should be flagged."#
+            .to_string()
+    };
+
+    println!("Content:");
+    for (i, line) in content.lines().enumerate() {
+        println!("Line {}: {}", i + 1, line);
+    }
+    println!();
+
+    let line_count = content.lines().count();
+
+    // Test with 0-based indexing (what the function actually uses)
+    println!("Testing is_in_front_matter with 0-based indexing:");
+    for i in 0..line_count {
+        let in_frontmatter = FrontMatterUtils::is_in_front_matter(&content, i);
+        println!("Line {} (0-based={}): in_frontmatter={}", i + 1, i, in_frontmatter);
+    }
+
+    // Test also with 1-based indexing (what we pass from MD052)
+    println!("\nTesting is_in_front_matter with 1-based indexing:");
+    for i in 1..=line_count {
+        let in_frontmatter = FrontMatterUtils::is_in_front_matter(&content, i);
+        println!("Line {i}: in_frontmatter={in_frontmatter}");
+    }
+}

{rumdl-0.0.107 → rumdl-0.0.109}/src/lint_context.rs

@@ -948,39 +948,18 @@ impl<'a> LintContext<'a> {
                     let leading_spaces = caps.get(1).map_or("", |m| m.as_str());
                     let marker = caps.get(2).map_or("", |m| m.as_str());
                     let spacing = caps.get(3).map_or("", |m| m.as_str());
-                    let content = caps.get(4).map_or("", |m| m.as_str());
+                    let _content = caps.get(4).map_or("", |m| m.as_str());
                     let marker_column = blockquote_prefix_len + leading_spaces.len();
                     let content_column = marker_column + marker.len() + spacing.len();
 
-                    // Check if this is likely emphasis or not a list item
+                    // According to CommonMark spec, unordered list items MUST have at least one space
+                    // after the marker (-, *, or +). Without a space, it's not a list item.
+                    // This also naturally handles cases like:
+                    // - *emphasis* (not a list)
+                    // - **bold** (not a list)
+                    // - --- (horizontal rule, not a list)
                     if spacing.is_empty() {
-                        // No space after marker - check if it's likely emphasis or just text
-                        if marker == "*" && content.ends_with('*') && !content[..content.len() - 1].contains('*') {
-                            // Likely emphasis like *text*
-                            None
-                        } else if marker == "*" && content.starts_with('*') {
-                            // Likely bold emphasis like **text** or horizontal rule like ***
-                            None
-                        } else if (marker == "*" || marker == "-")
-                            && content.chars().all(|c| c == marker.chars().next().unwrap())
-                            && content.len() >= 2
-                        {
-                            // Likely horizontal rule like *** or ---
-                            None
-                        } else if !content.is_empty() && content.chars().next().unwrap().is_alphabetic() {
-                            // Single word starting with marker, likely not intended as list
-                            // This matches markdownlint behavior
-                            None
-                        } else {
-                            // Other cases with no space - treat as malformed list item
-                            Some(ListItemInfo {
-                                marker: marker.to_string(),
-                                is_ordered: false,
-                                number: None,
-                                marker_column,
-                                content_column,
-                            })
-                        }
+                        None
                     } else {
                         Some(ListItemInfo {
                             marker: marker.to_string(),
@@ -995,15 +974,14 @@ impl<'a> LintContext<'a> {
                     let number_str = caps.get(2).map_or("", |m| m.as_str());
                     let delimiter = caps.get(3).map_or("", |m| m.as_str());
                     let spacing = caps.get(4).map_or("", |m| m.as_str());
-                    let content = caps.get(5).map_or("", |m| m.as_str());
+                    let _content = caps.get(5).map_or("", |m| m.as_str());
                     let marker = format!("{number_str}{delimiter}");
                     let marker_column = blockquote_prefix_len + leading_spaces.len();
                     let content_column = marker_column + marker.len() + spacing.len();
 
-                    // Check if this is likely not a list item
-                    if spacing.is_empty() && !content.is_empty() && content.chars().next().unwrap().is_alphabetic() {
-                        // No space after marker and starts with alphabetic, likely not intended as list
-                        // This matches markdownlint behavior
+                    // According to CommonMark spec, ordered list items MUST have at least one space
+                    // after the marker (period or parenthesis). Without a space, it's not a list item.
+                    if spacing.is_empty() {
                         None
                     } else {
                         Some(ListItemInfo {
@@ -1343,6 +1321,9 @@ impl<'a> LintContext<'a> {
 
                 if let Some(ref mut block) = current_block {
                     // Check if this continues the current block
+                    // For nested lists, we need to check if this is a nested item (higher nesting level)
+                    // or a continuation at the same or lower level
+                    let is_nested = nesting > block.nesting_level;
                     let same_type =
                         (block.is_ordered && list_item.is_ordered) || (!block.is_ordered && !list_item.is_ordered);
                     let same_context = block.blockquote_prefix == blockquote_prefix;
@@ -1392,7 +1373,18 @@ impl<'a> LintContext<'a> {
                         found_non_list
                     };
 
-                    if same_type && same_context && reasonable_distance && marker_compatible && !has_non_list_content {
+                    // A list continues if:
+                    // 1. It's a nested item (indented more than the parent), OR
+                    // 2. It's the same type at the same level with reasonable distance
+                    let continues_list = if is_nested {
+                        // Nested items always continue the list if they're in the same context
+                        same_context && reasonable_distance && !has_non_list_content
+                    } else {
+                        // Same-level items need to match type and markers
+                        same_type && same_context && reasonable_distance && marker_compatible && !has_non_list_content
+                    };
+
+                    if continues_list {
                         // Extend current block
                         block.end_line = line_num;
                         block.item_lines.push(line_num);

{rumdl-0.0.107 → rumdl-0.0.109}/src/rules/md004_unordered_list_style.rs

@@ -118,16 +118,12 @@ impl Rule for MD004UnorderedListStyle {
 
         // Use centralized list blocks for better performance and accuracy
         for list_block in &ctx.list_blocks {
-            // Skip ordered lists
-            if list_block.is_ordered {
-                continue;
-            }
-
             // Check each list item in this block
+            // We need to check individual items even in mixed lists (ordered with nested unordered)
             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 {
-                        // Skip ordered lists (safety check)
+                        // Skip ordered list items - we only care about unordered ones
                         if list_item.is_ordered {
                             continue;
                         }
@@ -245,16 +241,12 @@ impl Rule for MD004UnorderedListStyle {
 
         // Use centralized list blocks
         for list_block in &ctx.list_blocks {
-            // Skip ordered lists
-            if list_block.is_ordered {
-                continue;
-            }
-
             // Process each list item in this block
+            // We need to check individual items even in mixed lists
             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 {
-                        // Skip ordered lists (safety check)
+                        // Skip ordered list items - we only care about unordered ones
                         if list_item.is_ordered {
                             continue;
                         }
@@ -615,12 +607,13 @@ mod tests {
     #[test]
     fn test_edge_case_marker_at_end() {
         let rule = MD004UnorderedListStyle::new(UnorderedListStyle::Asterisk);
-        let content = "*\n-\n+";
+        // These are valid list items with minimal content (just a space)
+        let content = "* \n- \n+ ";
         let ctx = LintContext::new(content);
         let result = rule.check(&ctx).unwrap();
-        assert_eq!(result.len(), 2);
+        assert_eq!(result.len(), 2); // Should flag - and + as wrong markers
         let fixed = rule.fix(&ctx).unwrap();
-        assert_eq!(fixed, "*\n*\n*");
+        assert_eq!(fixed, "* \n* \n* ");
     }
 
     #[test]

{rumdl-0.0.107 → rumdl-0.0.109}/src/rules/md006_start_bullets.rs

@@ -16,21 +16,28 @@ use crate::utils::regex_cache::UNORDERED_LIST_MARKER_REGEX;
 pub struct MD006StartBullets;
 
 impl MD006StartBullets {
-    /// Check if a bullet is nested under an ordered list item
+    /// Check if a bullet is nested under an ordered list item (anywhere in the hierarchy)
     fn is_nested_under_ordered_item(
         &self,
         ctx: &crate::lint_context::LintContext,
         current_line: usize,
         current_indent: usize,
     ) -> bool {
-        // Look backward from current line to find parent item
+        // Look backward from current line to find any ordered ancestor
+        let mut check_indent = current_indent;
+
         for line_idx in (1..current_line).rev() {
             if let Some(line_info) = ctx.line_info(line_idx) {
                 if let Some(list_item) = &line_info.list_item {
-                    // Found a list item - check if it's at a lower indentation (parent level)
-                    if list_item.marker_column < current_indent {
-                        // This is a parent item - check if it's ordered
-                        return list_item.is_ordered;
+                    // Found a list item - check if it's at a lower indentation (ancestor level)
+                    if list_item.marker_column < check_indent {
+                        // This is an ancestor item
+                        if list_item.is_ordered {
+                            // Found an ordered ancestor
+                            return true;
+                        }
+                        // Continue looking for higher-level ancestors
+                        check_indent = list_item.marker_column;
                     }
                 }
                 // If we encounter non-blank, non-list content at column 0, stop looking
@@ -52,17 +59,17 @@ impl MD006StartBullets {
         // Track which lines contain valid bullet items
         let mut valid_bullet_lines = vec![false; lines.len()];
 
-        // Process each unordered list block
+        // Process each list block
         for list_block in &ctx.list_blocks {
-            // Skip ordered lists
-            if list_block.is_ordered {
-                continue;
-            }
-
             // Check each list item in this block
+            // We need to check unordered items even in mixed lists
             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 {
+                        // Skip ordered list items - we only care about unordered ones
+                        if list_item.is_ordered {
+                            continue;
+                        }
                         let line_idx = item_line - 1;
                         let indent = list_item.marker_column;
                         let line = &lines[line_idx];
@@ -73,9 +80,16 @@ impl MD006StartBullets {
                             // Top-level items are always valid
                             is_valid = true;
                         } else {
-                            // Check if this is nested under an ordered item with correct indentation (3 spaces)
-                            if indent == 3 && self.is_nested_under_ordered_item(ctx, item_line, indent) {
-                                is_valid = true;
+                            // Check if this is nested under an ordered item with correct indentation
+                            // For single-digit ordered lists (1.), need at least 3 spaces for proper nesting
+                            // For double-digit (10.), need at least 4 spaces, etc.
+                            // But MD006's purpose is to flag top-level indented lists, not validate nesting depth
+                            if self.is_nested_under_ordered_item(ctx, item_line, indent) {
+                                // It's nested under an ordered item
+                                // Only flag if indentation is less than 3 (won't nest properly in CommonMark)
+                                if indent >= 3 {
+                                    is_valid = true;
+                                }
                             } else {
                                 // Check if this is a valid nested item under another bullet
                                 match Self::find_relevant_previous_bullet(&lines, line_idx) {
@@ -120,14 +134,28 @@ impl MD006StartBullets {
                                 end_col - start_col,
                             );
 
+                            // Generate appropriate message based on context
+                            let message = if self.is_nested_under_ordered_item(ctx, item_line, indent) {
+                                // It's trying to nest under an ordered item but has insufficient indentation
+                                format!(
+                                    "Nested list needs at least 3 spaces of indentation under ordered item (found {indent})"
+                                )
+                            } else if indent > 0 {
+                                // It's indented but not nested under anything - should start at column 0
+                                format!(
+                                    "Consider starting bulleted lists at the beginning of the line (found {indent} leading spaces)"
+                                )
+                            } else {
+                                // Shouldn't happen, but just in case
+                                format!("List indentation issue (found {indent} leading spaces)")
+                            };
+
                             result.push(LintWarning {
                                 line: item_line,
                                 column: start_col,
                                 end_line: item_line,
                                 end_column: end_col,
-                                message: format!(
-                                    "Consider starting bulleted lists at the beginning of the line (found {indent} leading spaces)"
-                                ),
+                                message,
                                 severity: Severity::Warning,
                                 rule_name: Some(self.name()),
                                 fix: Some(Fix {
@@ -501,14 +529,14 @@ mod tests {
         let content = "\
 1. **Active Directory/LDAP**
   - Wrong: only 2 spaces
-    - Also wrong: 4 spaces";
+ - Wrong: only 1 space";
         let ctx = crate::lint_context::LintContext::new(content);
         let result = rule.check(&ctx).unwrap();
-        // Should flag the incorrect indentations
+        // Should flag the incorrect indentations (less than 3 spaces)
         assert_eq!(
             result.len(),
             2,
-            "Expected warnings for bullets with incorrect spacing under numbered items"
+            "Expected warnings for bullets with insufficient spacing under numbered items"
         );
         assert!(result.iter().any(|w| w.line == 2));
         assert!(result.iter().any(|w| w.line == 3));

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

@@ -640,4 +640,19 @@ result = inspect.stack()[1]
         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");
     }
+
+    #[test]
+    fn test_issue_26_specific_case() {
+        // Test for issue #26 - specific case reported
+        let rule = MD011NoReversedLinks;
+
+        let content = r#"The first thing I need to find is the name of the redacted key name, `doc.<key_name_omitted>`. I'll use `SUBSTRING(ATTRIBUTES(doc)[0], 0, 1) == '<c>'` as that test, where `<c>` is different characters. This gets the first attribute from `doc` and uses `SUBSTRING` to get the first character."#;
+        let ctx = LintContext::new(content);
+        let result = rule.check(&ctx).unwrap();
+        assert_eq!(
+            result.len(),
+            0,
+            "Should not flag ATTRIBUTES(doc)[0] inside inline code (issue #26)"
+        );
+    }
 }