rumdl 0.0.56__tar.gz → 0.0.57__tar.gz

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

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

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

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

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

rumdl-0.0.57/parity_check.py

@@ -0,0 +1,211 @@
+#!/usr/bin/env python3
+import subprocess
+import json
+import sys
+from pathlib import Path
+import os
+
+PARITY_CORPUS = Path(__file__).parent / "parity_corpus"
+RUMDL_BIN = "cargo run --bin rumdl --"
+MARKDOWNLINT_BIN = "markdownlint"
+
+
+def run_rumdl(md_file):
+    # Use --no-config to ensure no config is loaded (use built-in defaults only)
+    cmd = f"{RUMDL_BIN} check '{md_file}' -o 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"]
+    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 []
+
+    # markdownlint outputs JSON to stderr when using --json flag
+    output = result.stderr.strip() if result.stderr.strip() else result.stdout.strip()
+    if output:
+        try:
+            return json.loads(output)
+        except Exception as e:
+            print(f"[markdownlint] Failed to parse JSON for {md_file}: {e}")
+            print(f"[markdownlint] output for {md_file}:")
+            print(output)
+    return []
+
+def normalize_rumdl(warning, file):
+    """Normalize rumdl warning to common format"""
+    return {
+        "file": str(file.relative_to(Path.cwd())),  # Convert to relative path
+        "line": warning.get("line"),
+        "column": warning.get("column", 1),
+        "rule": warning.get("rule_name"),
+        "message": warning.get("message"),
+        "fix": warning.get("fix"),
+    }
+
+def normalize_markdownlint(warning):
+    """Normalize markdownlint warning to common format"""
+    file_path = warning.get("fileName")
+    # Convert absolute paths to relative if possible
+    if file_path and file_path.startswith('/'):
+        try:
+            file_path = str(Path(file_path).relative_to(Path.cwd()))
+        except ValueError:
+            # If the path is not relative to cwd, keep it as is
+            pass
+
+    return {
+        "file": file_path,
+        "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, rule) for comparison - ignore column and message differences
+    def key(w):
+        return (
+            w.get("line", 0),
+            w.get("rule", "")
+        )
+    r_sorted = sorted(rumdl_warnings, key=key)
+    m_sorted = sorted(markdownlint_warnings, key=key)
+
+    # Compare based on file, line, and rule only
+    def warning_key(w):
+        return (w.get("file"), w.get("line"), w.get("rule"))
+
+    r_set = set(warning_key(w) for w in r_sorted)
+    m_set = set(warning_key(w) for w in m_sorted)
+
+    only_in_rumdl = r_set - m_set
+    only_in_markdownlint = m_set - r_set
+    common = r_set & m_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 key in list(only_in_rumdl)[:3]:  # Show fewer to reduce noise
+            file, line, rule = key
+            # Find the actual warning for context
+            warning = next((w for w in rumdl_warnings if w.get('file') == file and w.get('line') == line and w.get('rule') == rule), None)
+            message = warning.get('message', 'No message') if warning else 'No message'
+            print(f"    Line {line}: {rule} - {message}")
+        if len(only_in_rumdl) > 3:
+            print(f"    ...and {len(only_in_rumdl) - 3} more.")
+    if only_in_markdownlint:
+        print(f"  Warnings only in markdownlint ({len(only_in_markdownlint)}):")
+        for key in list(only_in_markdownlint)[:3]:  # Show fewer to reduce noise
+            file, line, rule = key
+            # Find the actual warning for context
+            warning = next((w for w in markdownlint_warnings if w.get('file') == file and w.get('line') == line and w.get('rule') == rule), None)
+            message = warning.get('message', 'No message') if warning else 'No message'
+            print(f"    Line {line}: {rule} - {message}")
+        if len(only_in_markdownlint) > 3:
+            print(f"    ...and {len(only_in_markdownlint) - 3} 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
+    total_common = 0
+    total_rumdl_only = 0
+    total_markdownlint_only = 0
+
+    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]
+
+        # Filter markdownlint warnings to only include the current file
+        file_relative = str(md_file.relative_to(Path.cwd()))
+        file_absolute = str(md_file.absolute())
+        markdownlint_norm = [w for w in markdownlint_norm if w.get("file") in (file_relative, file_absolute)]
+
+        # Sort by (line, rule) for comparison - ignore column and message differences
+        def key(w):
+            return (
+                w.get("line", 0),
+                w.get("rule", "")
+            )
+        r_sorted = sorted(rumdl_norm, key=key)
+        m_sorted = sorted(markdownlint_norm, key=key)
+
+        # Compare based on file, line, and rule only
+        def warning_key(w):
+            return (w.get("file"), w.get("line"), w.get("rule"))
+
+        r_set = set(warning_key(w) for w in r_sorted)
+        m_set = set(warning_key(w) for w in m_sorted)
+
+        only_in_rumdl = r_set - m_set
+        only_in_markdownlint = m_set - r_set
+        common = r_set & m_set
+
+        total_common += len(common)
+        total_rumdl_only += len(only_in_rumdl)
+        total_markdownlint_only += len(only_in_markdownlint)
+
+        if not only_in_rumdl and not only_in_markdownlint:
+            print("✓ All warnings match!")
+        else:
+            print("✗ Mismatches found:")
+            if only_in_rumdl:
+                print(f"  Warnings only in rumdl ({len(only_in_rumdl)}):")
+                for key in list(only_in_rumdl)[:3]:  # Show fewer to reduce noise
+                    file, line, rule = key
+                    # Find the actual warning for context
+                    warning = next((w for w in rumdl_norm if w.get('file') == file and w.get('line') == line and w.get('rule') == rule), None)
+                    message = warning.get('message', 'No message') if warning else 'No message'
+                    print(f"    Line {line}: {rule} - {message}")
+                if len(only_in_rumdl) > 3:
+                    print(f"    ...and {len(only_in_rumdl) - 3} more.")
+            if only_in_markdownlint:
+                print(f"  Warnings only in markdownlint ({len(only_in_markdownlint)}):")
+                for key in list(only_in_markdownlint)[:3]:  # Show fewer to reduce noise
+                    file, line, rule = key
+                    # Find the actual warning for context
+                    warning = next((w for w in markdownlint_norm if w.get('file') == file and w.get('line') == line and w.get('rule') == rule), None)
+                    message = warning.get('message', 'No message') if warning else 'No message'
+                    print(f"    Line {line}: {rule} - {message}")
+                if len(only_in_markdownlint) > 3:
+                    print(f"    ...and {len(only_in_markdownlint) - 3} more.")
+            print(f"  Common warnings: {len(common)}")
+            all_passed = False
+
+    print(f"\n=== SUMMARY ===")
+    print(f"Total common warnings: {total_common}")
+    print(f"Total rumdl-only warnings: {total_rumdl_only}")
+    print(f"Total markdownlint-only warnings: {total_markdownlint_only}")
+
+    if all_passed:
+        print("✓ All files match between rumdl and markdownlint!")
+        sys.exit(0)
+    else:
+        print("✗ Some files have mismatches.")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

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

@@ -294,8 +294,8 @@ respect-gitignore = true
 
         fs::write(&config_path, content).unwrap();
 
-        // Load the config using the new sourced loader
-        let sourced = SourcedConfig::load(Some(config_path.to_str().unwrap()), None).unwrap();
+        // Load the config with skip_auto_discovery to avoid environment config files
+        let sourced = SourcedConfig::load_with_discovery(Some(config_path.to_str().unwrap()), None, true).unwrap();
         let config: Config = sourced.into(); // Convert to plain config for assertions
 
         // Check global settings
@@ -304,6 +304,7 @@ respect-gitignore = true
             config.global.enable,
             vec!["MD001".to_string(), "MD004".to_string()]
         );
+        // Should now contain only the configured pattern since auto-discovery is disabled
         assert_eq!(config.global.include, vec!["docs/*.md".to_string()]);
         assert_eq!(config.global.exclude, vec!["node_modules".to_string()]);
         assert!(config.global.respect_gitignore);
@@ -327,8 +328,8 @@ respect_gitignore = true
 
         fs::write(&config_path, content).unwrap();
 
-        // Load the config using the new sourced loader
-        let sourced = SourcedConfig::load(Some(config_path.to_str().unwrap()), None).unwrap();
+        // Load the config with skip_auto_discovery to avoid environment config files
+        let sourced = SourcedConfig::load_with_discovery(Some(config_path.to_str().unwrap()), None, true).unwrap();
         let config: Config = sourced.into(); // Convert to plain config for assertions
 
         // Check settings were correctly loaded
@@ -347,14 +348,15 @@ line_length = 111
 line-length = 222
 "#;
         fs::write(&config_path, config_content).unwrap();
-        let sourced = SourcedConfig::load(Some(config_path.to_str().unwrap()), None).unwrap();
+        // Load the config with skip_auto_discovery to avoid environment config files
+        let sourced = SourcedConfig::load_with_discovery(Some(config_path.to_str().unwrap()), None, true).unwrap();
         // DEBUG: Print all rule keys and their value keys
-        eprintln!(
+        log::debug!(
             "[DEBUG] All rules loaded: {:?}",
             sourced.rules.keys().collect::<Vec<_>>()
         );
         for (rule, cfg) in &sourced.rules {
-            eprintln!(
+            log::debug!(
                 "[DEBUG] Rule '{}' value keys: {:?}",
                 rule,
                 cfg.values.keys().collect::<Vec<_>>()
@@ -364,7 +366,7 @@ line-length = 222
             .rules
             .get("MD013")
             .expect("MD013 rule config should exist");
-        // Both keys should be normalized to 'line-length', with the last one winning
+        // Now we should only get the explicitly configured key
         let keys: Vec<_> = rule_cfg.values.keys().cloned().collect();
         assert_eq!(keys, vec!["line-length"]);
         let val = &rule_cfg.values["line-length"].value;
@@ -392,7 +394,8 @@ line-length = 102
 line-length = 103
 "#;
         fs::write(&config_path, config_content).unwrap();
-        let sourced = SourcedConfig::load(Some(config_path.to_str().unwrap()), None).unwrap();
+        // Load the config with skip_auto_discovery to avoid environment config files
+        let sourced = SourcedConfig::load_with_discovery(Some(config_path.to_str().unwrap()), None, true).unwrap();
         let config: Config = sourced.clone().into();
         // Only the last section should win, and be present
         let rule_cfg = sourced
@@ -417,7 +420,8 @@ line_length = 201
 line-length = 202
 "#;
         fs::write(&config_path, config_content).unwrap();
-        let sourced = SourcedConfig::load(Some(config_path.to_str().unwrap()), None).unwrap();
+        // Load the config with skip_auto_discovery to avoid environment config files
+        let sourced = SourcedConfig::load_with_discovery(Some(config_path.to_str().unwrap()), None, true).unwrap();
         let config: Config = sourced.clone().into();
         let rule_cfg = sourced
             .rules
@@ -445,7 +449,8 @@ bar = 2
 line-length = 303
 "#;
         fs::write(&config_path, config_content).unwrap();
-        let sourced = SourcedConfig::load(Some(config_path.to_str().unwrap()), None).unwrap();
+        // Load the config with skip_auto_discovery to avoid environment config files
+        let sourced = SourcedConfig::load_with_discovery(Some(config_path.to_str().unwrap()), None, true).unwrap();
         let config: Config = sourced.clone().into();
         // MD999 should not be present
         assert!(!sourced.rules.contains_key("MD999"));
@@ -671,11 +676,25 @@ impl SourcedConfig {
     pub fn load(
         config_path: Option<&str>,
         cli_overrides: Option<&SourcedGlobalConfig>,
+    ) -> Result<Self, ConfigError> {
+        Self::load_with_discovery(config_path, cli_overrides, false)
+    }
+
+    /// Load and merge configurations from files and CLI overrides.
+    /// If skip_auto_discovery is true, only explicit config paths are loaded.
+    pub fn load_with_discovery(
+        config_path: Option<&str>,
+        cli_overrides: Option<&SourcedGlobalConfig>,
+        skip_auto_discovery: bool,
     ) -> 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");
+            if skip_auto_discovery {
+                log::debug!("[rumdl-config] Skipping auto-discovery due to --no-config flag");
+            } else {
+                log::debug!("[rumdl-config] No explicit config_path provided, will search default locations");
+            }
         } else {
             log::debug!("[rumdl-config] Explicit config_path provided: {:?}", config_path);
         }
@@ -717,7 +736,11 @@ impl SourcedConfig {
                     sourced_config.loaded_files.push(path_str.clone());
                     loaded_toml_or_pyproject = true;
                 }
-            } else if MARKDOWNLINT_FILENAMES.contains(&filename) {
+            } else if MARKDOWNLINT_FILENAMES.contains(&filename)
+                || path_str.ends_with(".json")
+                || path_str.ends_with(".jsonc")
+                || path_str.ends_with(".yaml")
+                || path_str.ends_with(".yml") {
                 // Parse as markdownlint config (JSON/YAML)
                 let fragment = load_from_markdownlint(&path_str)?;
                 sourced_config.merge(fragment);
@@ -734,7 +757,10 @@ impl SourcedConfig {
                 sourced_config.loaded_files.push(path_str.clone());
                 loaded_toml_or_pyproject = true;
             }
-        } else {
+        }
+
+        // Only perform auto-discovery if not skipped AND no explicit config path provided
+        if !skip_auto_discovery && config_path.is_none() {
             // 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");
@@ -773,20 +799,20 @@ impl SourcedConfig {
                     log::debug!("[rumdl-config] {} not found in current directory", filename);
                 }
             }
-        }
 
-        // 4. Markdownlint config fallback if no TOML/pyproject config was loaded
-        if !loaded_toml_or_pyproject {
-            for filename in MARKDOWNLINT_CONFIG_FILES {
-                if std::path::Path::new(filename).exists() {
-                    match load_from_markdownlint(filename) {
-                        Ok(fragment) => {
-                            sourced_config.merge(fragment);
-                            sourced_config.loaded_files.push(filename.to_string());
-                            break; // Load only the first one found
-                        }
-                        Err(_e) => {
-                            // Log error but continue (it's just a fallback)
+            // 4. Markdownlint config fallback if no TOML/pyproject config was loaded
+            if !loaded_toml_or_pyproject {
+                for filename in MARKDOWNLINT_CONFIG_FILES {
+                    if std::path::Path::new(filename).exists() {
+                        match load_from_markdownlint(filename) {
+                            Ok(fragment) => {
+                                sourced_config.merge(fragment);
+                                sourced_config.loaded_files.push(filename.to_string());
+                                break; // Load only the first one found
+                            }
+                            Err(_e) => {
+                                // Log error but continue (it's just a fallback)
+                            }
                         }
                     }
                 }
@@ -1281,7 +1307,7 @@ fn parse_rumdl_toml(content: &str, path: &str) -> Result<SourcedConfigFragment,
                                 _ => unreachable!(), // Should not happen due to outer match
                             }
                         } else {
-                            eprintln!(
+                            log::warn!(
                                 "[WARN] Expected array for global key '{}' in {}, found {}",
                                 key,
                                 path,
@@ -1302,7 +1328,7 @@ fn parse_rumdl_toml(content: &str, path: &str) -> Result<SourcedConfigFragment,
                                 None,
                             );
                         } else {
-                            eprintln!(
+                            log::warn!(
                                 "[WARN] Expected boolean for global key '{}' in {}, found {}",
                                 key,
                                 path,
@@ -1313,7 +1339,7 @@ fn parse_rumdl_toml(content: &str, path: &str) -> Result<SourcedConfigFragment,
                     _ => {
                         // Add to unknown_keys for potential validation later
                         // fragment.unknown_keys.push(("[global]".to_string(), key.to_string()));
-                        eprintln!(
+                        log::warn!(
                             "[WARN] Unknown key in [global] section of {}: {}",
                             path, key
                         );
@@ -1350,21 +1376,21 @@ fn parse_rumdl_toml(content: &str, path: &str) -> Result<SourcedConfigFragment,
                         Some(toml::Value::Datetime(*formatted.value()))
                     }
                     Some(toml_edit::Value::Array(_)) => {
-                        eprintln!(
+                        log::warn!(
                                 "[WARN] Skipping array value for key '{}.{}' in {}. Array conversion not yet fully implemented in parser.",
                                 norm_rule_name, norm_rk, path
                             );
                         None
                     }
                     Some(toml_edit::Value::InlineTable(_)) => {
-                        eprintln!(
+                        log::warn!(
                                 "[WARN] Skipping inline table value for key '{}.{}' in {}. Table conversion not yet fully implemented in parser.",
                                 norm_rule_name, norm_rk, path
                             );
                         None
                     }
                     None => {
-                        eprintln!(
+                        log::warn!(
                                 "[WARN] Skipping non-value item for key '{}.{}' in {}. Expected simple value.",
                                 norm_rule_name, norm_rk, path
                             );
@@ -1379,7 +1405,7 @@ fn parse_rumdl_toml(content: &str, path: &str) -> Result<SourcedConfigFragment,
                 }
             }
         } else if item.is_value() {
-            eprintln!(
+            log::warn!(
                 "[WARN] Ignoring top-level value key in {}: '{}'. Expected a table like [{}].",
                 path, key, key
             );

{rumdl-0.0.56 → rumdl-0.0.57}/src/lib.rs

@@ -46,8 +46,7 @@ pub fn lint(content: &str, rules: &[Box<dyn Rule>], _verbose: bool) -> LintResul
                 warnings.extend(rule_warnings);
             }
             Err(e) => {
-                #[cfg(not(test))]
-                eprintln!("Error checking rule {}: {}", rule.name(), e);
+                log::error!("Error checking rule {}: {}", rule.name(), e);
                 return Err(e);
             }
         }
@@ -56,7 +55,7 @@ pub fn lint(content: &str, rules: &[Box<dyn Rule>], _verbose: bool) -> LintResul
         if _verbose {
             let rule_duration = _rule_start.elapsed();
             if rule_duration.as_millis() > 500 {
-                eprintln!("Rule {} took {:?}", rule.name(), rule_duration);
+                log::debug!("Rule {} took {:?}", rule.name(), rule_duration);
             }
         }
     }
@@ -64,12 +63,12 @@ pub fn lint(content: &str, rules: &[Box<dyn Rule>], _verbose: bool) -> LintResul
     #[cfg(not(test))]
     if _verbose {
         let total_duration = _overall_start.elapsed();
-        eprintln!("Total lint time: {:?}", total_duration);
+        log::debug!("Total lint time: {:?}", total_duration);
     }
 
     #[cfg(all(debug_assertions, not(test)))]
     if !warnings.is_empty() {
-        eprintln!("Found {} warnings", warnings.len());
+        log::info!("Found {} warnings", warnings.len());
     }
 
     Ok(warnings)

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

@@ -566,7 +566,6 @@ fn print_config_with_provenance(sourced: &rumdl_config::SourcedConfig) {
         Box::new(MD005ListIndent),
         Box::new(MD006StartBullets),
         Box::new(MD007ULIndent::default()),
-        Box::new(MD008ULStyle::default()),
         Box::new(MD009TrailingSpaces::default()),
         Box::new(MD010NoHardTabs::default()),
         Box::new(MD011NoReversedLinks {}),
@@ -814,9 +813,9 @@ build-backend = \"setuptools.build_meta\"
             Some(Commands::Check(args)) => {
                 // If --no-config is set, skip config loading
                 if cli.no_config {
-                    run_check(args, None);
+                    run_check(args, None, cli.no_config);
                 } else {
-                    run_check(args, cli.config.as_deref());
+                    run_check(args, cli.config.as_deref(), cli.no_config);
                 }
             }
             Some(Commands::Rule { rule }) => {
@@ -829,7 +828,6 @@ build-backend = \"setuptools.build_meta\"
                     Box::new(MD005ListIndent),
                     Box::new(MD006StartBullets),
                     Box::new(MD007ULIndent::default()),
-                    Box::new(MD008ULStyle::default()),
                     Box::new(MD009TrailingSpaces::default()),
                     Box::new(MD010NoHardTabs::default()),
                     Box::new(MD011NoReversedLinks {}),
@@ -910,7 +908,7 @@ build-backend = \"setuptools.build_meta\"
                     if let Some((section_part, field_part)) = key.split_once('.') {
                         // 1. Load the full SourcedConfig once
                         let sourced =
-                            match rumdl_config::SourcedConfig::load(cli.config.as_deref(), None) {
+                            match rumdl_config::SourcedConfig::load_with_discovery(cli.config.as_deref(), None, cli.no_config) {
                                 Ok(s) => s,
                                 Err(e) => {
                                     eprintln!("{}: {}", "Config error".red().bold(), e);
@@ -1056,7 +1054,7 @@ build-backend = \"setuptools.build_meta\"
                     let sourced_reg = if *defaults {
                         rumdl_config::SourcedConfig::default()
                     } else {
-                        match rumdl_config::SourcedConfig::load(cli.config.as_deref(), None) {
+                        match rumdl_config::SourcedConfig::load_with_discovery(cli.config.as_deref(), None, cli.no_config) {
                             Ok(s) => s,
                             Err(e) => {
                                 eprintln!("{}: {}", "Config error".red().bold(), e);
@@ -1080,7 +1078,7 @@ build-backend = \"setuptools.build_meta\"
                         rumdl_config::SourcedConfig::default()
                     } else {
                         // Reload config if not defaults (necessary because we exited early in 'get' case)
-                        match rumdl_config::SourcedConfig::load(cli.config.as_deref(), None) {
+                        match rumdl_config::SourcedConfig::load_with_discovery(cli.config.as_deref(), None, cli.no_config) {
                             Ok(s) => s,
                             Err(e) => {
                                 eprintln!("{}: {}", "Config error".red().bold(), e);
@@ -1131,7 +1129,7 @@ build-backend = \"setuptools.build_meta\"
                         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());
+                    run_check(&args, cli.config.as_deref(), cli.no_config);
                 } else {
                     eprintln!(
                 "{}: No files or directories specified. Please provide at least one path to lint.",
@@ -1150,9 +1148,13 @@ build-backend = \"setuptools.build_meta\"
     }
 }
 
-fn run_check(args: &CheckArgs, global_config_path: Option<&str>) {
+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(global_config_path, None) {
+    let sourced = match rumdl_config::SourcedConfig::load_with_discovery(
+        global_config_path,
+        None,
+        no_config
+    ) {
         Ok(sourced) => sourced,
         Err(e) => {
             // Syntax error or type mismatch: fail and exit

{rumdl-0.0.56 → rumdl-0.0.57}/src/markdownlint_config.rs

@@ -24,10 +24,6 @@ pub fn load_markdownlint_config(path: &str) -> Result<MarkdownlintConfig, String
             .or_else(|_| serde_yaml::from_str(&content))
             .map_err(|e| format!("Failed to parse config as JSON or YAML: {}", e))
     };
-    if let Err(ref err) = parse_result {
-        eprintln!("\x1b[31mError: Failed to parse configuration file '{}':\n  {}\n\nPlease ensure your JSON is valid. All keys and string values must be double-quoted.\x1b[0m", path, err);
-        std::process::exit(1);
-    }
     parse_result
 }
 
@@ -182,7 +178,7 @@ impl MarkdownlintConfig {
                             });
                     }
                 } else {
-                    eprintln!("\x1b[31mError: Could not convert value for rule key {:?} to rumdl's internal config format. This likely means the configuration value is invalid or not supported for this rule. Please check your markdownlint config.\x1b[0m", key);
+                    log::error!("Could not convert value for rule key {:?} to rumdl's internal config format. This likely means the configuration value is invalid or not supported for this rule. Please check your markdownlint config.", key);
                     std::process::exit(1);
                 }
             }

{rumdl-0.0.56 → rumdl-0.0.57}/src/rules/emphasis_style.rs

@@ -5,7 +5,7 @@ use std::fmt;
 /// The style for emphasis (MD049)
 #[derive(Debug, PartialEq, Eq, Clone, Copy, Default, Hash)]
 pub enum EmphasisStyle {
-    /// Consistent with the first emphasis style found
+    /// Consistent with the most prevalent emphasis style found (or first found if tied)
     #[default]
     Consistent,
     /// Asterisk style (*)