rumdl_lib/config/

validation.rs

use super::flavor::{ConfigLoaded, ConfigValidated};
use super::registry::{RULE_ALIAS_MAP, RuleRegistry, is_valid_rule_name, resolve_rule_name_alias};
use super::source_tracking::{ConfigValidationWarning, SourcedConfig, SourcedRuleConfig};
use std::collections::BTreeMap;
use std::path::Path;

/// Validates rule names from CLI flags against the known rule set.
/// Returns warnings for unknown rules with "did you mean" suggestions.
///
/// This provides consistent validation between config files and CLI flags.
/// Unknown rules are warned about but don't cause failures.
pub fn validate_cli_rule_names(
    enable: Option<&str>,
    disable: Option<&str>,
    extend_enable: Option<&str>,
    extend_disable: Option<&str>,
    fixable: Option<&str>,
    unfixable: Option<&str>,
) -> Vec<ConfigValidationWarning> {
    let mut warnings = Vec::new();
    let all_rule_names: Vec<String> = RULE_ALIAS_MAP.keys().map(std::string::ToString::to_string).collect();

    let validate_list = |input: &str, flag_name: &str, warnings: &mut Vec<ConfigValidationWarning>| {
        for name in input.split(',').map(str::trim).filter(|s| !s.is_empty()) {
            // Check for special "all" value (case-insensitive)
            if name.eq_ignore_ascii_case("all") {
                continue;
            }
            if resolve_rule_name_alias(name).is_none() {
                let message = if let Some(suggestion) = suggest_similar_key(name, &all_rule_names) {
                    let formatted = if suggestion.starts_with("MD") {
                        suggestion
                    } else {
                        suggestion.to_lowercase()
                    };
                    format!("Unknown rule in {flag_name}: {name} (did you mean: {formatted}?)")
                } else {
                    format!("Unknown rule in {flag_name}: {name}")
                };
                warnings.push(ConfigValidationWarning {
                    message,
                    rule: Some(name.to_string()),
                    key: None,
                });
            }
        }
    };

    if let Some(e) = enable {
        validate_list(e, "--enable", &mut warnings);
    }
    if let Some(d) = disable {
        validate_list(d, "--disable", &mut warnings);
    }
    if let Some(ee) = extend_enable {
        validate_list(ee, "--extend-enable", &mut warnings);
    }
    if let Some(ed) = extend_disable {
        validate_list(ed, "--extend-disable", &mut warnings);
    }
    if let Some(f) = fixable {
        validate_list(f, "--fixable", &mut warnings);
    }
    if let Some(u) = unfixable {
        validate_list(u, "--unfixable", &mut warnings);
    }

    warnings
}

/// Internal validation function that works with any SourcedConfig state.
/// This is used by both the public `validate_config_sourced` and the typestate `validate()` method.
pub(super) fn validate_config_sourced_internal<S>(
    sourced: &SourcedConfig<S>,
    registry: &RuleRegistry,
) -> Vec<ConfigValidationWarning> {
    let mut warnings = validate_config_sourced_impl(&sourced.rules, &sourced.unknown_keys, registry);

    // Validate enable/disable arrays in [global] section
    let all_rule_names: Vec<String> = RULE_ALIAS_MAP.keys().map(std::string::ToString::to_string).collect();

    for rule_name in &sourced.global.enable.value {
        if !is_valid_rule_name(rule_name) {
            let message = if let Some(suggestion) = suggest_similar_key(rule_name, &all_rule_names) {
                let formatted = if suggestion.starts_with("MD") {
                    suggestion
                } else {
                    suggestion.to_lowercase()
                };
                format!("Unknown rule in global.enable: {rule_name} (did you mean: {formatted}?)")
            } else {
                format!("Unknown rule in global.enable: {rule_name}")
            };
            warnings.push(ConfigValidationWarning {
                message,
                rule: Some(rule_name.clone()),
                key: None,
            });
        }
    }

    for rule_name in &sourced.global.disable.value {
        if !is_valid_rule_name(rule_name) {
            let message = if let Some(suggestion) = suggest_similar_key(rule_name, &all_rule_names) {
                let formatted = if suggestion.starts_with("MD") {
                    suggestion
                } else {
                    suggestion.to_lowercase()
                };
                format!("Unknown rule in global.disable: {rule_name} (did you mean: {formatted}?)")
            } else {
                format!("Unknown rule in global.disable: {rule_name}")
            };
            warnings.push(ConfigValidationWarning {
                message,
                rule: Some(rule_name.clone()),
                key: None,
            });
        }
    }

    for rule_name in &sourced.global.extend_enable.value {
        if !is_valid_rule_name(rule_name) {
            let message = if let Some(suggestion) = suggest_similar_key(rule_name, &all_rule_names) {
                let formatted = if suggestion.starts_with("MD") {
                    suggestion
                } else {
                    suggestion.to_lowercase()
                };
                format!("Unknown rule in global.extend-enable: {rule_name} (did you mean: {formatted}?)")
            } else {
                format!("Unknown rule in global.extend-enable: {rule_name}")
            };
            warnings.push(ConfigValidationWarning {
                message,
                rule: Some(rule_name.clone()),
                key: None,
            });
        }
    }

    for rule_name in &sourced.global.extend_disable.value {
        if !is_valid_rule_name(rule_name) {
            let message = if let Some(suggestion) = suggest_similar_key(rule_name, &all_rule_names) {
                let formatted = if suggestion.starts_with("MD") {
                    suggestion
                } else {
                    suggestion.to_lowercase()
                };
                format!("Unknown rule in global.extend-disable: {rule_name} (did you mean: {formatted}?)")
            } else {
                format!("Unknown rule in global.extend-disable: {rule_name}")
            };
            warnings.push(ConfigValidationWarning {
                message,
                rule: Some(rule_name.clone()),
                key: None,
            });
        }
    }

    for rule_name in &sourced.global.fixable.value {
        if !is_valid_rule_name(rule_name) {
            let message = if let Some(suggestion) = suggest_similar_key(rule_name, &all_rule_names) {
                let formatted = if suggestion.starts_with("MD") {
                    suggestion
                } else {
                    suggestion.to_lowercase()
                };
                format!("Unknown rule in global.fixable: {rule_name} (did you mean: {formatted}?)")
            } else {
                format!("Unknown rule in global.fixable: {rule_name}")
            };
            warnings.push(ConfigValidationWarning {
                message,
                rule: Some(rule_name.clone()),
                key: None,
            });
        }
    }

    for rule_name in &sourced.global.unfixable.value {
        if !is_valid_rule_name(rule_name) {
            let message = if let Some(suggestion) = suggest_similar_key(rule_name, &all_rule_names) {
                let formatted = if suggestion.starts_with("MD") {
                    suggestion
                } else {
                    suggestion.to_lowercase()
                };
                format!("Unknown rule in global.unfixable: {rule_name} (did you mean: {formatted}?)")
            } else {
                format!("Unknown rule in global.unfixable: {rule_name}")
            };
            warnings.push(ConfigValidationWarning {
                message,
                rule: Some(rule_name.clone()),
                key: None,
            });
        }
    }

    warnings.extend(validate_code_block_tools(&sourced.code_block_tools.value));

    warnings
}

/// Warnings for `[code-block-tools.languages.*]` tool ids that name nothing rumdl can
/// run, or a tool the slot asks for something it cannot do.
///
/// A tool id that resolves to nothing is otherwise reported only by a `log::warn!`,
/// invisible at default verbosity: the run skips the tool, finds no issues and exits 0,
/// which is indistinguishable from the tool having run and been happy. That silence is
/// what makes a typo here cost an afternoon rather than a second.
///
/// Runs whether or not `enabled` is set, so a typo is caught before the switch is
/// flipped; a config with no `languages` section produces nothing either way.
fn validate_code_block_tools(config: &crate::code_block_tools::CodeBlockToolsConfig) -> Vec<ConfigValidationWarning> {
    use crate::code_block_tools::{ToolRegistry, ToolSlot, is_rumdl_builtin};

    let mut warnings = Vec::new();

    // `warn` says a tool is missing once for the whole run, beside the config that
    // named it. Which languages a run meets is only known from the documents, so
    // there is no such place for this setting and it would behave as `ignore`
    // without saying so.
    if config.on_missing_language_definition == crate::code_block_tools::OnMissing::Warn {
        warnings.push(ConfigValidationWarning {
            message: "code-block-tools.on-missing-language-definition: \"warn\" behaves as \"ignore\"; \
                      use \"fail\" to report a language with no tools"
                .to_string(),
            rule: None,
            key: None,
        });
    }

    if config.languages.is_empty() {
        return warnings;
    }

    let registry = ToolRegistry::new(config.tools.clone());
    // Suggestions come from the registry itself, so a tool added to it is suggestible
    // without a second list to keep in step.
    let known_tools: Vec<String> = registry.list_tools().into_iter().map(str::to_string).collect();

    for (lang, lang_config) in &config.languages {
        for (slot, slot_name, tool_ids) in [
            (ToolSlot::Lint, "lint", &lang_config.lint),
            (ToolSlot::Format, "format", &lang_config.format),
        ] {
            for tool_id in tool_ids {
                // rumdl's own markdown linting, short-circuited before tool resolution.
                if is_rumdl_builtin(tool_id) && !(slot == ToolSlot::Format && tool_id == "rumdl:lint") {
                    continue;
                }

                // A tool id and a language key are both text out of whichever file
                // supplied the section, so a section reached through `extends` is
                // described rather than quoted - the suggestion too, which would
                // otherwise say how close the withheld text came to a real id.
                let message = if !is_rumdl_builtin(tool_id) && registry.resolve_id(tool_id, slot).is_none() {
                    if config.values_withheld {
                        let withheld = crate::config::WITHHELD;
                        format!("Unknown tool in code-block-tools.languages.{withheld}.{slot_name}: {withheld}")
                    } else if let Some(suggestion) = suggest_similar_key(tool_id, &known_tools) {
                        format!(
                            "Unknown tool in code-block-tools.languages.{lang}.{slot_name}: {tool_id} (did you mean: {suggestion}?)"
                        )
                    } else {
                        format!("Unknown tool in code-block-tools.languages.{lang}.{slot_name}: {tool_id}")
                    }
                } else if slot == ToolSlot::Format
                    && (tool_id == "rumdl:lint" || registry.fills_format_slot(tool_id) == Some(false))
                {
                    // A linter in a format slot writes diagnostics where the formatted
                    // code should go, so rumdl declines the output and the block is
                    // never formatted.
                    if config.values_withheld {
                        let withheld = crate::config::WITHHELD;
                        format!("Tool in code-block-tools.languages.{withheld}.format cannot format: {withheld}")
                    } else {
                        format!(
                            "Tool in code-block-tools.languages.{lang}.format cannot format: {tool_id} is a linter (move it to lint)"
                        )
                    }
                } else {
                    continue;
                };

                warnings.push(ConfigValidationWarning {
                    message,
                    rule: None,
                    key: None,
                });
            }
        }
    }

    warnings
}

/// Core validation implementation that doesn't depend on SourcedConfig type parameter.
fn validate_config_sourced_impl(
    rules: &BTreeMap<String, SourcedRuleConfig>,
    unknown_keys: &[(String, String, Option<String>)],
    registry: &RuleRegistry,
) -> Vec<ConfigValidationWarning> {
    let mut warnings = Vec::new();
    let known_rules = registry.rule_names();
    // 1. Unknown rules
    for rule in rules.keys() {
        if !known_rules.contains(rule) {
            // Include both canonical names AND aliases for fuzzy matching
            let all_rule_names: Vec<String> = RULE_ALIAS_MAP.keys().map(std::string::ToString::to_string).collect();
            let message = if let Some(suggestion) = suggest_similar_key(rule, &all_rule_names) {
                // Convert alias suggestions to lowercase for better UX (MD001 stays uppercase, ul-style becomes lowercase)
                let formatted_suggestion = if suggestion.starts_with("MD") {
                    suggestion
                } else {
                    suggestion.to_lowercase()
                };
                format!("Unknown rule in config: {rule} (did you mean: {formatted_suggestion}?)")
            } else {
                format!("Unknown rule in config: {rule}")
            };
            warnings.push(ConfigValidationWarning {
                message,
                rule: Some(rule.clone()),
                key: None,
            });
        }
    }
    // 2. Unknown options and type mismatches
    for (rule, rule_cfg) in rules {
        if let Some(valid_keys) = registry.config_keys_for(rule) {
            for key in rule_cfg.values.keys() {
                if !valid_keys.contains(key) {
                    let valid_keys_vec: Vec<String> = valid_keys.iter().cloned().collect();
                    let message = if let Some(suggestion) = suggest_similar_key(key, &valid_keys_vec) {
                        format!("Unknown option for rule {rule}: {key} (did you mean: {suggestion}?)")
                    } else {
                        format!("Unknown option for rule {rule}: {key}")
                    };
                    warnings.push(ConfigValidationWarning {
                        message,
                        rule: Some(rule.clone()),
                        key: Some(key.clone()),
                    });
                } else {
                    // Type check: compare type of value to type of default
                    if let Some(expected) = registry.expected_value_for(rule, key) {
                        let actual = &rule_cfg.values[key].value;
                        if !toml_value_type_matches(expected, actual) {
                            warnings.push(ConfigValidationWarning {
                                message: format!(
                                    "Type mismatch for {}.{}: expected {}, got {}",
                                    rule,
                                    key,
                                    toml_type_name(expected),
                                    toml_type_name(actual)
                                ),
                                rule: Some(rule.clone()),
                                key: Some(key.clone()),
                            });
                        }
                    }
                }
            }
        }
    }
    // 3. Unknown global options (from unknown_keys). Suggestions come from the
    // dispatch table itself, so a newly added global key is suggestible without a
    // second list to keep in step, plus the keys holding a table or a path rather
    // than a plain value.
    let known_global_keys: Vec<String> = super::global_keys::GLOBAL_VALUE_KEYS
        .iter()
        .map(|k| (*k).to_string())
        .chain(
            ["per-file-ignores", "per-file-flavor", "extends"]
                .into_iter()
                .map(str::to_string),
        )
        .collect();

    for (section, key, display_name) in unknown_keys {
        // Already display-ready: the parser decided how this file may be named.
        let display_path = display_name.as_ref();

        if section.contains("[global]") || section.contains("[tool.rumdl]") {
            let message = if let Some(suggestion) = suggest_similar_key(key, &known_global_keys) {
                if let Some(path) = display_path {
                    format!("Unknown global option in {path}: {key} (did you mean: {suggestion}?)")
                } else {
                    format!("Unknown global option: {key} (did you mean: {suggestion}?)")
                }
            } else if let Some(path) = display_path {
                format!("Unknown global option in {path}: {key}")
            } else {
                format!("Unknown global option: {key}")
            };
            warnings.push(ConfigValidationWarning {
                message,
                rule: None,
                key: Some(key.clone()),
            });
        } else if !key.is_empty() {
            // An option of a rule rumdl knows, recorded here instead of in the
            // config map because it came from a file whose text may not be
            // shown. Naming that file is what makes the warning actionable.
            let rule_name = section.trim_matches(|c| c == '[' || c == ']');
            let message = if let Some(path) = display_path {
                format!("Unknown option for rule {rule_name} in {path}: {key}")
            } else {
                format!("Unknown option for rule {rule_name}: {key}")
            };
            warnings.push(ConfigValidationWarning {
                message,
                rule: Some(rule_name.to_string()),
                key: Some(key.clone()),
            });
        } else {
            // Unknown rule section - suggest similar rule names
            let rule_name = section.trim_matches(|c| c == '[' || c == ']');
            let all_rule_names: Vec<String> = RULE_ALIAS_MAP.keys().map(std::string::ToString::to_string).collect();
            let message = if let Some(suggestion) = suggest_similar_key(rule_name, &all_rule_names) {
                // Convert alias suggestions to lowercase for better UX (MD001 stays uppercase, ul-style becomes lowercase)
                let formatted_suggestion = if suggestion.starts_with("MD") {
                    suggestion
                } else {
                    suggestion.to_lowercase()
                };
                if let Some(path) = display_path {
                    format!("Unknown rule in {path}: {rule_name} (did you mean: {formatted_suggestion}?)")
                } else {
                    format!("Unknown rule in config: {rule_name} (did you mean: {formatted_suggestion}?)")
                }
            } else if let Some(path) = display_path {
                format!("Unknown rule in {path}: {rule_name}")
            } else {
                format!("Unknown rule in config: {rule_name}")
            };
            warnings.push(ConfigValidationWarning {
                message,
                rule: None,
                key: None,
            });
        }
    }
    warnings
}

/// Convert a file path to a display-friendly relative path.
///
/// Tries to make the path relative to the current working directory.
/// If that fails, returns the original path unchanged. The result uses `/`
/// separators for consistent output across platforms.
pub(super) fn to_relative_display_path(path: &str) -> String {
    let file_path = Path::new(path);

    // Try to make relative to CWD
    if let Ok(cwd) = std::env::current_dir() {
        // Try with canonicalized paths first (handles symlinks)
        if let (Ok(canonical_file), Ok(canonical_cwd)) = (file_path.canonicalize(), cwd.canonicalize())
            && let Ok(relative) = canonical_file.strip_prefix(&canonical_cwd)
        {
            return normalize_for_display(relative.to_string_lossy().to_string());
        }

        // Fall back to non-canonicalized comparison
        if let Ok(relative) = file_path.strip_prefix(&cwd) {
            return normalize_for_display(relative.to_string_lossy().to_string());
        }
    }

    // Return original if we can't make it relative
    normalize_for_display(path.to_string())
}

/// Normalize a path for output: `/` separators on every platform, and no Win32
/// verbatim prefix.
///
/// Only the platform's native separator is converted: on Windows `\` becomes `/`.
/// On Unix this is a no-op, where `\` is a legal filename character that must be
/// preserved. A config path resolved through `canonicalize` also sheds the `\\?\`
/// prefix that form carries, the same way the CLI displays linted files.
fn normalize_for_display(path: String) -> String {
    if cfg!(windows) {
        windows_display_path(&path)
    } else {
        path
    }
}

/// The Windows half of [`normalize_for_display`]: pure string logic, so it is
/// tested on every platform.
pub(super) fn windows_display_path(path: &str) -> String {
    crate::discovery::strip_verbatim_prefix(path).replace('\\', "/")
}

/// Validate a loaded config against the rule registry, using SourcedConfig for unknown key tracking.
///
/// This is the legacy API that works with `SourcedConfig<ConfigLoaded>`.
/// For new code, prefer using `sourced.validate(&registry)` which returns a
/// `SourcedConfig<ConfigValidated>` that can be converted to `Config`.
pub fn validate_config_sourced(
    sourced: &SourcedConfig<ConfigLoaded>,
    registry: &RuleRegistry,
) -> Vec<ConfigValidationWarning> {
    validate_config_sourced_internal(sourced, registry)
}

/// Validate a config that has already been validated (no-op, returns stored warnings).
///
/// This exists for API consistency - validated configs already have their warnings stored.
pub fn validate_config_sourced_validated(
    sourced: &SourcedConfig<ConfigValidated>,
    _registry: &RuleRegistry,
) -> Vec<ConfigValidationWarning> {
    sourced.validation_warnings.clone()
}

fn toml_type_name(val: &toml::Value) -> &'static str {
    match val {
        toml::Value::String(_) => "string",
        toml::Value::Integer(_) => "integer",
        toml::Value::Float(_) => "float",
        toml::Value::Boolean(_) => "boolean",
        toml::Value::Array(_) => "array",
        toml::Value::Table(_) => "table",
        toml::Value::Datetime(_) => "datetime",
    }
}

/// Calculate Levenshtein distance between two strings (simple implementation)
///
/// The distance counts character edits, so every length here is a character
/// count. Measuring in bytes instead makes the two disagree for any non-ASCII
/// input: the row is indexed past what the loops filled, and the untouched
/// cell returns a distance of 0, reporting an unrelated key as an exact match.
fn levenshtein_distance(s1: &str, s2: &str) -> usize {
    let s1_chars: Vec<char> = s1.chars().collect();
    let s2_chars: Vec<char> = s2.chars().collect();

    let len1 = s1_chars.len();
    let len2 = s2_chars.len();

    if len1 == 0 {
        return len2;
    }
    if len2 == 0 {
        return len1;
    }

    let mut prev_row: Vec<usize> = (0..=len2).collect();
    let mut curr_row = vec![0; len2 + 1];

    for i in 1..=len1 {
        curr_row[0] = i;
        for j in 1..=len2 {
            let cost = usize::from(s1_chars[i - 1] != s2_chars[j - 1]);
            curr_row[j] = (prev_row[j] + 1)          // deletion
                .min(curr_row[j - 1] + 1)            // insertion
                .min(prev_row[j - 1] + cost); // substitution
        }
        std::mem::swap(&mut prev_row, &mut curr_row);
    }

    prev_row[len2]
}

/// Suggest a similar key from a list of valid keys using fuzzy matching
///
/// Several keys are routinely the same distance from a typo, so the closest one
/// alone does not name a single answer. Ties go to the smaller key, which makes
/// the suggestion depend on the key set rather than on the order the caller
/// happens to hold it in.
pub fn suggest_similar_key(unknown: &str, valid_keys: &[String]) -> Option<String> {
    let unknown_lower = unknown.to_lowercase();
    // Allow up to 2 edits or 30% of the key's length. Counted in characters, to
    // match the distance being compared against it: a byte count would hand a
    // non-ASCII key a budget several times the one an ASCII key of the same
    // length gets, and suggest a key it has nothing in common with.
    let max_distance = 2.max(unknown.chars().count() / 3);

    let mut best_match: Option<(&String, usize)> = None;

    for valid in valid_keys {
        let valid_lower = valid.to_lowercase();
        let distance = levenshtein_distance(&unknown_lower, &valid_lower);

        if distance > max_distance {
            continue;
        }
        let is_better = match &best_match {
            Some((best_key, best_dist)) => distance < *best_dist || (distance == *best_dist && valid < *best_key),
            None => true,
        };
        if is_better {
            best_match = Some((valid, distance));
        }
    }

    best_match.map(|(key, _)| key.clone())
}

fn toml_value_type_matches(expected: &toml::Value, actual: &toml::Value) -> bool {
    use toml::Value::{Array, Boolean, Datetime, Float, Integer, String, Table};
    match (expected, actual) {
        (String(_), String(_)) => true,
        (Integer(_), Integer(_)) => true,
        (Float(_), Float(_)) => true,
        (Boolean(_), Boolean(_)) => true,
        (Array(_), Array(_)) => true,
        (Table(_), Table(_)) => true,
        (Datetime(_), Datetime(_)) => true,
        // Allow integer for float
        (Float(_), Integer(_)) => true,
        _ => false,
    }
}

#[cfg(test)]
mod suggestion_tests {
    use super::*;

    fn keys(names: &[&str]) -> Vec<String> {
        names.iter().map(|s| (*s).to_string()).collect()
    }

    #[test]
    fn a_closer_key_wins_over_an_earlier_one() {
        let candidates = keys(&["MD049", "MD013"]);
        assert_eq!(suggest_similar_key("MD01", &candidates), Some("MD013".to_string()));
    }

    #[test]
    fn equally_close_keys_resolve_to_the_smaller_name() {
        // Both are two substitutions away from MD999, so only the tie-break
        // decides which one the user is shown.
        for order in [["MD049", "MD009"], ["MD009", "MD049"]] {
            assert_eq!(
                suggest_similar_key("MD999", &keys(&order)),
                Some("MD009".to_string()),
                "suggestion changed with the caller's key order: {order:?}"
            );
        }
    }

    #[test]
    fn a_key_beyond_the_edit_budget_is_no_suggestion() {
        assert_eq!(suggest_similar_key("MD999", &keys(&["line-length"])), None);
    }

    #[test]
    fn multibyte_character_no_panic() {
        assert_eq!(suggest_similar_key("—", &keys(&["MD049", "MD009"])), None);
    }

    /// Not panicking is only half the requirement: the distance has to be right.
    /// Measuring the row index in bytes reads a cell the loops never filled, and
    /// its initial 0 says "these strings are identical".
    #[test]
    fn distance_to_a_multibyte_key_is_not_zero() {
        assert_eq!(levenshtein_distance("md013", "—"), 5);
        assert_eq!(levenshtein_distance("md013", "🎉🎉"), 5);
        assert_eq!(levenshtein_distance("", "—"), 1);
    }

    /// Edit distance is symmetric. A byte-indexed row breaks that, which is the
    /// cheapest way to see the two operands being measured on different scales.
    #[test]
    fn distance_is_symmetric_across_encodings() {
        for (a, b) in [("md013", "—"), ("café", "cafe"), ("—", "MD049"), ("日本語", "md013")] {
            assert_eq!(
                levenshtein_distance(a, b),
                levenshtein_distance(b, a),
                "distance between {a:?} and {b:?} depends on argument order"
            );
        }
    }

    /// A character's byte width must not buy it a wider edit budget. Five em
    /// dashes are 15 bytes, enough for a budget of 5 to reach `MD001`.
    #[test]
    fn a_multibyte_key_gets_no_wider_edit_budget() {
        assert_eq!(suggest_similar_key("—————", &keys(&["MD001", "MD049"])), None);
        assert_eq!(suggest_similar_key("🎉🎉🎉", &keys(&["MD001", "MD049"])), None);
    }

    /// The ASCII behaviour is the control: it must be untouched by all of the above.
    #[test]
    fn ascii_suggestions_are_unchanged() {
        assert_eq!(
            suggest_similar_key("line-lenght", &keys(&["line-length"])),
            Some("line-length".to_string())
        );
        assert_eq!(levenshtein_distance("md013", "md009"), 2);
        assert_eq!(levenshtein_distance("kitten", "sitting"), 3);
    }

    /// A near-miss of a real key still resolves when the typo itself is non-ASCII,
    /// so the character-counted budget is not merely stricter, it is correct.
    #[test]
    fn a_non_ascii_typo_of_a_real_key_still_resolves() {
        assert_eq!(
            suggest_similar_key("line—length", &keys(&["line-length"])),
            Some("line-length".to_string()),
            "one em dash for one hyphen is a single substitution"
        );
    }
}

#[cfg(test)]
mod code_block_tool_tests {
    use crate::code_block_tools::{CodeBlockToolsConfig, LanguageToolConfig, ToolDefinition};

    fn config_with(lang: &str, lint: &[&str], format: &[&str]) -> CodeBlockToolsConfig {
        let mut config = CodeBlockToolsConfig {
            enabled: true,
            ..Default::default()
        };
        config.languages.insert(
            lang.to_string(),
            LanguageToolConfig {
                lint: lint.iter().map(|s| (*s).to_string()).collect(),
                format: format.iter().map(|s| (*s).to_string()).collect(),
                ..Default::default()
            },
        );
        config
    }

    fn messages(config: &CodeBlockToolsConfig) -> Vec<String> {
        super::validate_code_block_tools(config)
            .into_iter()
            .map(|w| w.message)
            .collect()
    }

    #[test]
    fn an_unknown_tool_id_is_reported_with_a_suggestion() {
        let messages = messages(&config_with("python", &[], &["blackk"]));
        assert_eq!(
            messages,
            vec!["Unknown tool in code-block-tools.languages.python.format: blackk (did you mean: black?)"]
        );
    }

    #[test]
    fn a_resolvable_tool_id_is_not_reported() {
        // The control for the test above: same shape, one letter apart, silent.
        assert!(messages(&config_with("python", &["ruff:check"], &["black"])).is_empty());
    }

    #[test]
    fn a_bare_name_resolving_through_a_variant_is_not_reported() {
        // `terraform` is registered as `terraform:format`, and a lint slot answers
        // through the same entry by comparing the formatter's output.
        assert!(messages(&config_with("terraform", &["terraform"], &["terraform"])).is_empty());
    }

    #[test]
    fn a_linter_in_a_format_slot_is_reported() {
        let messages = messages(&config_with("python", &[], &["ruff:check"]));
        assert_eq!(
            messages,
            vec![
                "Tool in code-block-tools.languages.python.format cannot format: ruff:check is a linter (move it to lint)"
            ]
        );
    }

    #[test]
    fn a_linter_in_a_lint_slot_is_not_reported() {
        assert!(messages(&config_with("python", &["ruff:check"], &[])).is_empty());
    }

    #[test]
    fn a_user_tool_shadowing_a_builtin_linter_may_format() {
        // The user wrote this command, so rumdl has no opinion about what it does -
        // and must not answer from the built-in `ruff:check` it shadows.
        let mut config = config_with("python", &[], &["ruff:check"]);
        config.tools.insert(
            "ruff:check".to_string(),
            ToolDefinition {
                command: vec!["my-formatter".to_string(), "-".to_string()],
                stdin: true,
                stdout: true,
                lint_args: vec![],
                format_args: vec![],
            },
        );
        assert!(messages(&config).is_empty());
    }

    #[test]
    fn a_user_tool_is_a_suggestion_candidate() {
        let mut config = config_with("python", &[], &["my-formater"]);
        config.tools.insert(
            "my-formatter".to_string(),
            ToolDefinition {
                command: vec!["my-formatter".to_string(), "-".to_string()],
                stdin: true,
                stdout: true,
                lint_args: vec![],
                format_args: vec![],
            },
        );
        assert_eq!(
            messages(&config),
            vec!["Unknown tool in code-block-tools.languages.python.format: my-formater (did you mean: my-formatter?)"]
        );
    }

    #[test]
    fn rumdls_own_markdown_linting_is_not_an_unknown_tool() {
        assert!(messages(&config_with("markdown", &["rumdl"], &["rumdl"])).is_empty());
    }

    #[test]
    fn explicit_tool_variants_are_validated_in_their_slots() {
        for (language, lint, format) in [
            ("markdown", vec!["rumdl:lint"], vec!["rumdl:format"]),
            ("javascript", vec!["oxfmt:lint"], vec!["oxfmt:format"]),
            (
                "html",
                vec!["djlint:html:lint", "djlint:html:format-check"],
                vec!["djlint:html:format"],
            ),
            (
                "jinja",
                vec!["djlint:jinja:lint", "djlint:jinja:format-check"],
                vec!["djlint:jinja:format"],
            ),
            (
                "shell",
                vec!["shuck:lint", "shuck:format-check"],
                vec!["shuck:lint-fix", "shuck:format"],
            ),
        ] {
            assert!(messages(&config_with(language, &lint, &format)).is_empty());
        }
        for id in [
            "rumdl:lint",
            "oxfmt:lint",
            "djlint:html:format-check",
            "djlint:jinja:format-check",
            "shuck:format-check",
        ] {
            let warnings = messages(&config_with("markdown", &[], &[id]));
            assert_eq!(warnings.len(), 1);
            assert!(warnings[0].contains("cannot format"), "{warnings:?}");
        }
    }

    #[test]
    fn a_withheld_section_names_neither_the_tool_nor_the_language() {
        let mut config = config_with("python", &["blackk"], &["ruff:check"]);
        config.values_withheld = true;
        let messages = messages(&config);
        assert_eq!(
            messages,
            vec![
                "Unknown tool in code-block-tools.languages.<withheld>.lint: <withheld>",
                "Tool in code-block-tools.languages.<withheld>.format cannot format: <withheld>",
            ]
        );
        // A suggestion would say how close the withheld text came to a real id.
        for message in &messages {
            assert!(!message.contains("black"), "withheld text is inferable from: {message}");
            assert!(!message.contains("ruff"), "withheld text is inferable from: {message}");
            assert!(
                !message.contains("python"),
                "withheld text is inferable from: {message}"
            );
        }
    }
}