rumdl 0.0.54__tar.gz → 0.0.56__tar.gz

{rumdl-0.0.54 → rumdl-0.0.56}/Cargo.lock

@@ -1385,7 +1385,7 @@ dependencies = [
 
 [[package]]
 name = "rumdl"
-version = "0.0.54"
+version = "0.0.56"
 dependencies = [
  "anyhow",
  "assert_cmd",

{rumdl-0.0.54 → rumdl-0.0.56}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rumdl"
-version = "0.0.54"
+version = "0.0.56"
 edition = "2021"
 description = "A fast Markdown linter written in Rust (Ru(st) MarkDown Linter)"
 authors = ["Ruben J. Jongejan <ruben.jongejan@gmail.com>"]

{rumdl-0.0.54 → rumdl-0.0.56}/Makefile

@@ -12,6 +12,7 @@ clean:
 fmt:
 	cargo fmt
 	cargo clippy --fix --allow-dirty --allow-staged
+	cargo fix --allow-dirty --allow-staged
 
 lint:
 	cargo clippy --all-targets --all-features -- -D warnings
@@ -117,14 +118,14 @@ version-push:
 # Combined targets for one-step release
 release-major: version-major version-push
 release-minor: version-minor version-push
-release-patch: version-patch version-push 
+release-patch: version-patch version-push
 
 maturin-build:
 	uv run --with pip,maturin[zig],cffi maturin build --release
 
 maturin-sdist:
 	uv run --with pip,maturin[zig],cffi maturin sdist
-	
+
 run:
 	cargo run --release --bin rumdl check .
 

{rumdl-0.0.54 → rumdl-0.0.56}/PKG-INFO

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

{rumdl-0.0.54 → rumdl-0.0.56}/benches/rule_performance.rs

@@ -1,8 +1,8 @@
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use rumdl::rule::Rule;
 use rumdl::rules::{
-    MD013LineLength, MD015NoMissingSpaceAfterListMarker, MD033NoInlineHtml, MD037NoSpaceInEmphasis,
-    MD044ProperNames, MD051LinkFragments, MD053LinkImageReferenceDefinitions,
+    MD013LineLength, MD033NoInlineHtml, MD037NoSpaceInEmphasis, MD044ProperNames, MD051LinkFragments,
+    MD053LinkImageReferenceDefinitions,
 };
 
 /// Benchmark MD013 rule on a large content with long lines
@@ -16,20 +16,11 @@ fn bench_md013(c: &mut Criterion) {
     let rule = MD013LineLength::default();
 
     c.bench_function("MD013 check 100 long lines", |b| {
-        b.iter(|| rule.check(black_box(&content)))
+        b.iter(|| rule.check(&rumdl::lint_context::LintContext::new(&content)))
     });
 
     c.bench_function("MD013 fix 100 long lines", |b| {
-        b.iter(|| rule.fix(black_box(&content)))
-    });
-}
-
-/// Benchmark MD015 rule on a large content with list items
-fn bench_md015(c: &mut Criterion) {
-    let rule = MD015NoMissingSpaceAfterListMarker::new();
-    let content = "-Item 1\n*Item 2\n+Item 3".repeat(1000);
-    c.bench_function("MD015 fix 1000 items", |b| {
-        b.iter(|| rule.fix(black_box(&content)))
+        b.iter(|| rule.fix(&rumdl::lint_context::LintContext::new(&content)))
     });
 }
 
@@ -44,7 +35,7 @@ fn bench_md033(c: &mut Criterion) {
     let rule = MD033NoInlineHtml::default();
 
     c.bench_function("MD033 check 500 HTML tags", |b| {
-        b.iter(|| rule.check(black_box(&content)))
+        b.iter(|| rule.check(&rumdl::lint_context::LintContext::new(&content)))
     });
 }
 
@@ -68,11 +59,11 @@ fn bench_md037(c: &mut Criterion) {
     let rule = MD037NoSpaceInEmphasis;
 
     c.bench_function("MD037 check 500 emphasis markers", |b| {
-        b.iter(|| rule.check(black_box(&content)))
+        b.iter(|| rule.check(&rumdl::lint_context::LintContext::new(&content)))
     });
 
     c.bench_function("MD037 fix 500 emphasis markers", |b| {
-        b.iter(|| rule.fix(black_box(&content)))
+        b.iter(|| rule.fix(&rumdl::lint_context::LintContext::new(&content)))
     });
 }
 
@@ -117,11 +108,11 @@ fn bench_md044(c: &mut Criterion) {
     let rule = MD044ProperNames::new(proper_names, true); // true = exclude code blocks
 
     c.bench_function("MD044 check 500 proper name occurrences", |b| {
-        b.iter(|| rule.check(black_box(&content)))
+        b.iter(|| rule.check(&rumdl::lint_context::LintContext::new(&content)))
     });
 
     c.bench_function("MD044 fix 500 proper name occurrences", |b| {
-        b.iter(|| rule.fix(black_box(&content)))
+        b.iter(|| rule.fix(&rumdl::lint_context::LintContext::new(&content)))
     });
 }
 
@@ -155,7 +146,7 @@ fn bench_md051(c: &mut Criterion) {
     let rule = MD051LinkFragments::new();
 
     c.bench_function("MD051 check 500 link fragments", |b| {
-        b.iter(|| rule.check(black_box(&content)))
+        b.iter(|| rule.check(&rumdl::lint_context::LintContext::new(&content)))
     });
 }
 
@@ -190,7 +181,7 @@ fn bench_md053(c: &mut Criterion) {
     c.bench_function("MD053 check cold cache", |b| {
         b.iter_with_setup(
             MD053LinkImageReferenceDefinitions::default, // Create a new instance for each iteration
-            |r| r.check(black_box(&content)),
+            |r| r.check(&rumdl::lint_context::LintContext::new(&content)),
         )
     });
 
@@ -198,21 +189,20 @@ fn bench_md053(c: &mut Criterion) {
     c.bench_function("MD053 check warm cache", |b| {
         // First, prime the cache
         let primed_rule = rule.clone();
-        let _ = primed_rule.check(&content);
+        let _ = primed_rule.check(&rumdl::lint_context::LintContext::new(&content));
 
         // Then benchmark with warm cache
-        b.iter(|| primed_rule.check(black_box(&content)))
+        b.iter(|| primed_rule.check(&rumdl::lint_context::LintContext::new(&content)))
     });
 
     c.bench_function("MD053 fix unused references", |b| {
-        b.iter(|| rule.fix(black_box(&content)))
+        b.iter(|| rule.fix(&rumdl::lint_context::LintContext::new(&content)))
     });
 }
 
 criterion_group!(
     benches,
     bench_md013,
-    bench_md015,
     bench_md033,
     bench_md037,
     bench_md044,

{rumdl-0.0.54 → rumdl-0.0.56}/docs/RULES.md

@@ -82,7 +82,7 @@ Each rule has a brief description and a link to its detailed documentation.
 
 | Rule ID | Rule Name | Description |
 |---------|-----------|-------------|
-| [MD014](md014.md) | Commands show output | Dollar signs used before commands without showing output |
+| [MD014](md014.md) | Commands show output | Code blocks should show output when appropriate |
 | [MD040](md040.md) | Fenced code language | Fenced code blocks should have a language specified |
 | [MD046](md046.md) | Code block style | Code block style |
 | [MD048](md048.md) | Code fence style | Code fence style |
@@ -111,7 +111,6 @@ Each rule has a brief description and a link to its detailed documentation.
 
 | Rule ID | Rule Name | Description |
 |---------|-----------|-------------|
-| [MD015](md015.md) | No multiple space list | Multiple spaces after list marker |
 | [MD057](md057.md) | Relative links | Relative links should exist |
 
 ## Using Rules

{rumdl-0.0.54 → rumdl-0.0.56}/docs/md030.md

@@ -2,10 +2,12 @@
 
 ## Description
 
-This rule ensures that there is a consistent number of spaces between list markers and the list content.  
-By default, ordered lists should have one space after the list marker, and unordered lists should have  
+This rule ensures that there is a consistent number of spaces between list markers and the list content.
+By default, ordered lists should have one space after the list marker, and unordered lists should have
 one space after the list marker.
 
+**Note:** This rule covers multiple spaces (e.g., `*  Item`) after list markers, but does **not** warn for missing space (e.g., `*Item`) after the marker. Lines like `*Item` are not considered valid list items per CommonMark and markdownlint, and are ignored.
+
 Consistent spacing improves readability and ensures proper rendering across different Markdown processors.
 
 <!-- markdownlint-disable -->

rumdl-0.0.56/parity_check.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+import subprocess
+import json
+import sys
+from pathlib import Path
+
+PARITY_CORPUS = Path(__file__).parent / "parity_corpus"
+RUMDL_BIN = "cargo run --bin rumdl --"
+MARKDOWNLINT_BIN = "markdownlint-cli2"
+
+
+def run_rumdl(md_file):
+    cmd = f"{RUMDL_BIN} check '{md_file}' --output json --no-config"
+    result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
+    if result.returncode != 0 and not result.stdout.strip():
+        print(f"[rumdl] Error running on {md_file}: {result.stderr}")
+        return []
+    try:
+        return json.loads(result.stdout)
+    except Exception as e:
+        print(f"[rumdl] Failed to parse JSON for {md_file}: {e}")
+        return []
+
+def run_markdownlint(md_file):
+    cmd = ["npx", MARKDOWNLINT_BIN, str(md_file), "--json", "--no-config", "--no-summary", "--quiet"]
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode not in (0, 1):
+        print(f"[markdownlint] Error running on {md_file}: {result.stderr}")
+        return []
+    # Try stdout first
+    if result.stdout.strip():
+        try:
+            return json.loads(result.stdout)
+        except Exception as e:
+            print(f"[markdownlint] Failed to parse JSON from stdout for {md_file}: {e}")
+            print(f"[markdownlint] stdout for {md_file}:")
+            print(result.stdout)
+    # If stdout is empty, try stderr
+    if result.stderr.strip():
+        try:
+            return json.loads(result.stderr)
+        except Exception as e:
+            print(f"[markdownlint] Failed to parse JSON from stderr for {md_file}: {e}")
+            print(f"[markdownlint] stderr for {md_file}:")
+            print(result.stderr)
+    return []
+
+def normalize_rumdl(warning, file):
+    # TODO: Implement normalization logic for rumdl output
+    return {
+        "file": str(file),
+        "line": warning.get("line"),
+        "column": warning.get("column"),
+        "rule": warning.get("rule_name"),
+        "message": warning.get("message"),
+        "fix": warning.get("fix"),
+    }
+
+def normalize_markdownlint(warning):
+    # TODO: Implement normalization logic for markdownlint output
+    return {
+        "file": warning.get("fileName"),
+        "line": warning.get("lineNumber"),
+        "column": (warning.get("errorRange") or [1])[0] if warning.get("errorRange") else 1,
+        "rule": warning.get("ruleNames", [None])[0],
+        "message": warning.get("ruleDescription"),
+        "fix": warning.get("fixInfo"),
+    }
+
+def compare_warnings(rumdl_warnings, markdownlint_warnings):
+    # Sort by (line, column, rule, message)
+    def key(w):
+        return (
+            w.get("line", 0),
+            w.get("column", 0),
+            w.get("rule", ""),
+            w.get("message", "")
+        )
+    r_sorted = sorted(rumdl_warnings, key=key)
+    m_sorted = sorted(markdownlint_warnings, key=key)
+
+    r_set = set(json.dumps(w, sort_keys=True) for w in r_sorted)
+    m_set = set(json.dumps(w, sort_keys=True) for w in m_sorted)
+
+    only_in_rumdl = r_set - m_set
+    only_in_markdownlint = m_set - r_set
+
+    if not only_in_rumdl and not only_in_markdownlint:
+        print("All warnings match!")
+        return True
+
+    if only_in_rumdl:
+        print(f"  Warnings only in rumdl ({len(only_in_rumdl)}):")
+        for w in list(only_in_rumdl)[:10]:
+            print("    ", json.loads(w))
+        if len(only_in_rumdl) > 10:
+            print(f"    ...and {len(only_in_rumdl) - 10} more.")
+    if only_in_markdownlint:
+        print(f"  Warnings only in markdownlint ({len(only_in_markdownlint)}):")
+        for w in list(only_in_markdownlint)[:10]:
+            print("    ", json.loads(w))
+        if len(only_in_markdownlint) > 10:
+            print(f"    ...and {len(only_in_markdownlint) - 10} more.")
+    print(f"  Common warnings: {len(r_set & m_set)}")
+    return False
+
+def main():
+    md_files = sorted(PARITY_CORPUS.glob("*.md"))
+    if not md_files:
+        print("No markdown files found in parity_corpus/")
+        sys.exit(1)
+    all_passed = True
+    for md_file in md_files:
+        print(f"\n=== {md_file} ===")
+        rumdl_raw = run_rumdl(md_file)
+        markdownlint_raw = run_markdownlint(md_file)
+        rumdl_norm = [normalize_rumdl(w, md_file) for w in rumdl_raw]
+        markdownlint_norm = [normalize_markdownlint(w) for w in markdownlint_raw if w.get("fileName") == str(md_file)]
+        if not compare_warnings(rumdl_norm, markdownlint_norm):
+            print(f"Mismatch found in {md_file}")
+            all_passed = False
+    if all_passed:
+        print("\nAll files match between rumdl and markdownlint!")
+        sys.exit(0)
+    else:
+        print("\nSome files have mismatches.")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

{rumdl-0.0.54 → rumdl-0.0.56}/src/config.rs

@@ -12,6 +12,8 @@ use std::fs;
 use std::io;
 use std::path::Path;
 use toml_edit::DocumentMut;
+use std::env;
+use log;
 
 lazy_static! {
     // Map common markdownlint config keys to rumdl rule names
@@ -150,7 +152,7 @@ exclude = [
     "vendor",
     "dist",
     "build",
-    
+
     # Specific files or patterns
     "CHANGELOG.md",
     "LICENSE.md",
@@ -670,6 +672,13 @@ impl SourcedConfig {
         config_path: Option<&str>,
         cli_overrides: Option<&SourcedGlobalConfig>,
     ) -> Result<Self, ConfigError> {
+        use std::env;
+        log::debug!("[rumdl-config] Current working directory: {:?}", env::current_dir());
+        if config_path.is_none() {
+            log::debug!("[rumdl-config] No explicit config_path provided, will search default locations");
+        } else {
+            log::debug!("[rumdl-config] Explicit config_path provided: {:?}", config_path);
+        }
         let mut sourced_config = SourcedConfig::default();
         let mut loaded_toml_or_pyproject = false;
 
@@ -680,6 +689,8 @@ impl SourcedConfig {
                 .file_name()
                 .and_then(|name| name.to_str())
                 .unwrap_or("");
+            log::debug!("[rumdl-config] Trying to load config file: {}", filename);
+            let path_str = path.to_string();
 
             // Known markdownlint config files
             const MARKDOWNLINT_FILENAMES: &[&str] = &[
@@ -692,40 +703,41 @@ impl SourcedConfig {
             {
                 let content = std::fs::read_to_string(path).map_err(|e| ConfigError::IoError {
                     source: e,
-                    path: path.to_string(),
+                    path: path_str.clone(),
                 })?;
                 if filename == "pyproject.toml" {
-                    if let Some(fragment) = parse_pyproject_toml(&content, path)? {
+                    if let Some(fragment) = parse_pyproject_toml(&content, &path_str)? {
                         sourced_config.merge(fragment);
-                        sourced_config.loaded_files.push(path.to_string());
+                        sourced_config.loaded_files.push(path_str.clone());
                         loaded_toml_or_pyproject = true;
                     }
                 } else {
-                    let fragment = parse_rumdl_toml(&content, path)?;
+                    let fragment = parse_rumdl_toml(&content, &path_str)?;
                     sourced_config.merge(fragment);
-                    sourced_config.loaded_files.push(path.to_string());
+                    sourced_config.loaded_files.push(path_str.clone());
                     loaded_toml_or_pyproject = true;
                 }
             } else if MARKDOWNLINT_FILENAMES.contains(&filename) {
                 // Parse as markdownlint config (JSON/YAML)
-                let fragment = load_from_markdownlint(path)?;
+                let fragment = load_from_markdownlint(&path_str)?;
                 sourced_config.merge(fragment);
-                sourced_config.loaded_files.push(path.to_string());
+                sourced_config.loaded_files.push(path_str.clone());
                 // Do NOT set loaded_toml_or_pyproject = true; markdownlint is fallback only
             } else {
                 // Try TOML only
                 let content = std::fs::read_to_string(path).map_err(|e| ConfigError::IoError {
                     source: e,
-                    path: path.to_string(),
+                    path: path_str.clone(),
                 })?;
-                let fragment = parse_rumdl_toml(&content, path)?;
+                let fragment = parse_rumdl_toml(&content, &path_str)?;
                 sourced_config.merge(fragment);
-                sourced_config.loaded_files.push(path.to_string());
+                sourced_config.loaded_files.push(path_str.clone());
                 loaded_toml_or_pyproject = true;
             }
         } else {
             // 2. Discover and load default files: pyproject.toml first
             if std::path::Path::new("pyproject.toml").exists() {
+                log::debug!("[rumdl-config] Found pyproject.toml in current directory");
                 let content = std::fs::read_to_string("pyproject.toml").map_err(|e| {
                     ConfigError::IoError {
                         source: e,
@@ -746,6 +758,7 @@ impl SourcedConfig {
             // 3. Discover and load .rumdl.toml / rumdl.toml (overrides pyproject)
             for filename in [".rumdl.toml", "rumdl.toml"] {
                 if std::path::Path::new(filename).exists() {
+                    log::debug!("[rumdl-config] Found {} in current directory", filename);
                     let content =
                         std::fs::read_to_string(filename).map_err(|e| ConfigError::IoError {
                             source: e,
@@ -756,6 +769,8 @@ impl SourcedConfig {
                     sourced_config.loaded_files.push(filename.to_string());
                     loaded_toml_or_pyproject = true;
                     break; // Load only the first one found
+                } else {
+                    log::debug!("[rumdl-config] {} not found in current directory", filename);
                 }
             }
         }

{rumdl-0.0.54 → rumdl-0.0.56}/src/main.rs

@@ -37,9 +37,13 @@ struct Cli {
     #[arg(long, global = true, help = "Path to configuration file")]
     config: Option<String>,
 
+    /// Ignore all configuration files and use built-in defaults
+    #[arg(long, global = true, help = "Ignore all configuration files and use built-in defaults")]
+    no_config: bool,
+
     /// Fix issues automatically where possible
     #[arg(short, long, default_value = "false", hide = true)]
-    fix: bool,
+    _fix: bool,
 
     /// List all available rules
     #[arg(short, long, default_value = "false", hide = true)]
@@ -127,7 +131,7 @@ struct CheckArgs {
 
     /// Fix issues automatically where possible
     #[arg(short, long, default_value = "false")]
-    fix: bool,
+    _fix: bool,
 
     /// List all available rules
     #[arg(short, long, default_value = "false")]
@@ -168,6 +172,10 @@ struct CheckArgs {
     /// Quiet mode
     #[arg(short, long)]
     quiet: bool,
+
+    /// Output format: text (default) or json
+    #[arg(long, short = 'o', default_value = "text")]
+    output: String,
 }
 
 // Get a complete set of enabled rules based on CLI options and config
@@ -203,11 +211,14 @@ fn get_enabled_rules_from_checkargs(
         config.global.disable.iter().map(|s| s.as_str()).collect();
 
     if let Some(enabled_cli) = &cli_enable_set {
-        // --- Case 1: CLI --enable provided ---
-        // CLI --enable overrides *everything* (config enable/disable are ignored).
+        // Normalize CLI enable values
+        let enabled_cli_normalized: HashSet<String> = enabled_cli.iter()
+            .map(|s| normalize_key(s))
+            .collect();
+        let _all_rule_names: Vec<String> = all_rules.iter().map(|r| normalize_key(r.name())).collect();
         final_rules = all_rules
             .into_iter()
-            .filter(|rule| enabled_cli.contains(rule.name()))
+            .filter(|rule| enabled_cli_normalized.contains(&normalize_key(rule.name())))
             .collect();
         // Note: CLI --disable is IGNORED if CLI --enable is present.
     } else {
@@ -456,7 +467,7 @@ fn print_results_from_checkargs(params: PrintResultsArgs) {
     // Show results summary
     if has_issues {
         // If fix mode is enabled, only show the fixed summary
-        if args.fix && total_issues_fixed > 0 {
+        if args._fix && total_issues_fixed > 0 {
             println!(
                 "\n{} Fixed {}/{} issues in {} {} ({}ms)",
                 "Fixed:".green().bold(),
@@ -485,7 +496,7 @@ fn print_results_from_checkargs(params: PrintResultsArgs) {
                 duration_ms
             );
 
-            if !args.fix && total_fixable_issues > 0 {
+            if !args._fix && total_fixable_issues > 0 {
                 // Display the exact count of fixable issues
                 println!(
                     "Run with `--fix` to automatically fix {} of the {} issues",
@@ -561,7 +572,6 @@ fn print_config_with_provenance(sourced: &rumdl_config::SourcedConfig) {
         Box::new(MD011NoReversedLinks {}),
         Box::new(MD012NoMultipleBlanks::default()),
         Box::new(MD013LineLength::default()),
-        Box::new(MD015NoMissingSpaceAfterListMarker::default()),
         Box::new(MD018NoMissingSpaceAtx {}),
         Box::new(MD019NoMultipleSpaceAtx {}),
         Box::new(MD020NoMissingSpaceClosedAtx {}),
@@ -802,7 +812,12 @@ build-backend = \"setuptools.build_meta\"
                 }
             }
             Some(Commands::Check(args)) => {
-                run_check(args, cli.config.as_deref());
+                // If --no-config is set, skip config loading
+                if cli.no_config {
+                    run_check(args, None);
+                } else {
+                    run_check(args, cli.config.as_deref());
+                }
             }
             Some(Commands::Rule { rule }) => {
                 use rumdl::rules::*;
@@ -820,7 +835,6 @@ build-backend = \"setuptools.build_meta\"
                     Box::new(MD011NoReversedLinks {}),
                     Box::new(MD012NoMultipleBlanks::default()),
                     Box::new(MD013LineLength::default()),
-                    Box::new(MD015NoMissingSpaceAfterListMarker::default()),
                     Box::new(MD018NoMissingSpaceAtx {}),
                     Box::new(MD019NoMultipleSpaceAtx {}),
                     Box::new(MD020NoMissingSpaceClosedAtx {}),
@@ -1104,7 +1118,7 @@ build-backend = \"setuptools.build_meta\"
                 if !cli.paths.is_empty() {
                     let args = CheckArgs {
                         paths: cli.paths.clone(),
-                        fix: cli.fix,
+                        _fix: cli._fix,
                         list_rules: cli.list_rules,
                         disable: cli.disable.clone(),
                         enable: cli.enable.clone(),
@@ -1114,6 +1128,7 @@ build-backend = \"setuptools.build_meta\"
                         verbose: cli.verbose,
                         profile: cli.profile,
                         quiet: cli.quiet,
+                        output: "text".to_string(),
                     };
                     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());
@@ -1182,8 +1197,25 @@ fn run_check(args: &CheckArgs, global_config_path: Option<&str>) {
         return;
     }
 
+    // JSON output mode: collect all warnings and print as JSON
+    if args.output == "json" {
+        let mut all_warnings = Vec::new();
+        for file_path in &file_paths {
+            let warnings = process_file_collect_warnings(
+                file_path,
+                &enabled_rules,
+                args._fix,
+                args.verbose,
+                args.quiet,
+            );
+            all_warnings.extend(warnings);
+        }
+        println!("{}", serde_json::to_string_pretty(&all_warnings).unwrap());
+        return;
+    }
+
     // Confirm with the user if we're fixing a large number of files
-    if args.fix && file_paths.len() > 10 && !args.quiet {
+    if args._fix && file_paths.len() > 10 && !args.quiet {
         println!(
             "You are about to fix {} files. This will modify files in-place.",
             file_paths.len()
@@ -1214,7 +1246,7 @@ fn run_check(args: &CheckArgs, global_config_path: Option<&str>) {
         let (file_has_issues, issues_found, issues_fixed, fixable_issues) = process_file(
             file_path,
             &enabled_rules,
-            args.fix,
+            args._fix,
             args.verbose,
             args.quiet,
         );
@@ -1265,7 +1297,7 @@ fn run_check(args: &CheckArgs, global_config_path: Option<&str>) {
 fn process_file(
     file_path: &str,
     rules: &[Box<dyn Rule>],
-    fix: bool,
+    _fix: bool,
     verbose: bool,
     quiet: bool,
 ) -> (bool, usize, usize, usize) {
@@ -1329,7 +1361,7 @@ fn process_file(
 
             // Add fix indicator if this warning has a fix
             let fix_indicator = if warning.fix.is_some() {
-                if fix {
+                if _fix {
                     " [fixed]"
                 } else {
                     " [*]"
@@ -1353,7 +1385,7 @@ fn process_file(
 
     // Fix issues if requested
     let mut warnings_fixed = 0;
-    if fix {
+    if _fix {
         // Skip rules that don't have fixes
         for rule in rules {
             if all_warnings
@@ -1415,3 +1447,33 @@ fn process_file(
 
     (true, total_warnings, warnings_fixed, fixable_warnings)
 }
+
+fn process_file_collect_warnings(
+    file_path: &str,
+    rules: &[Box<dyn Rule>],
+    _fix: bool,
+    verbose: bool,
+    quiet: bool,
+) -> Vec<rumdl::rule::LintWarning> {
+    use std::time::Instant;
+    let _start_time = Instant::now();
+    if verbose && !quiet {
+        println!("Processing file: {}", file_path);
+    }
+    let content = match std::fs::read_to_string(file_path) {
+        Ok(content) => content,
+        Err(_) => return Vec::new(),
+    };
+    std::env::set_var("RUMDL_FILE_PATH", file_path);
+    let warnings_result = rumdl::lint(&content, rules, verbose);
+    std::env::remove_var("RUMDL_FILE_PATH");
+    let mut all_warnings = warnings_result.unwrap_or_default();
+    all_warnings.sort_by(|a, b| {
+        if a.line == b.line {
+            a.column.cmp(&b.column)
+        } else {
+            a.line.cmp(&b.line)
+        }
+    });
+    all_warnings
+}