Function render

atomic-cli/src/agent_error.rs:579–715

Render a clap parse failure as `key: value` lines. A pure function returning a `String`, so the whole failure surface is unit-testable without spawning a process.

(err: &clap::Error, root: &clap::Command, argv: &[OsString])

/// A pure function returning a `String`, so the whole failure surface is
/// unit-testable without spawning a process.
pub fn render(err: &clap::Error, root: &clap::Command, argv: &[OsString]) -> String {
    // Scope first, everything else from it. clap's usage line is authoritative
    // about WHICH command the error is about; argv is only a fallback for the
    // kinds that attach no usage context. Deriving `cmd`/`verb`/`help` from a
    // different source than `usage` is what lets them contradict.
    let ctx_usage = ctx_str(err, ContextKind::Usage)
        .map(|u| {
            u.trim_start_matches("Usage:")
                .trim_start_matches("usage:")
                .trim()
                .to_string()
        })
        .filter(|u| !u.is_empty());

    let (key, display) = match ctx_usage.as_deref().and_then(|u| path_from_usage(root, u)) {
        Some(k) => {
            let d = display_path(root, &k);
            (k, d)
        }
        None => resolve_invoked(root, argv),
    };

    let mut kv: Vec<(&str, String)> = vec![
        ("error", kind_slug(err.kind()).to_string()),
        ("cmd", display.clone()),
    ];

    // Keep the rejected value and the argument it belonged to separate. The
    // old renderer selected only one context entry, which turned
    // `--count nope` into a bare `got: nope` and dropped both `--count` and the
    // parser's "invalid digit" cause.
    match err.kind() {
        ErrorKind::InvalidSubcommand => {
            if let Some(value) = ctx_str(err, ContextKind::InvalidSubcommand) {
                kv.push(("got", value));
            }
        }
        ErrorKind::UnknownArgument => {
            if let Some(arg) = ctx_str(err, ContextKind::InvalidArg) {
                kv.push(("got", arg));
            }
        }
        ErrorKind::MissingRequiredArgument => {
            let missing = ctx_list(err, ContextKind::InvalidArg);
            for required in missing {
                kv.push(("required", required));
            }
        }
        ErrorKind::MissingSubcommand => {}
        ErrorKind::InvalidUtf8 => {
            if let Some(value) = rejected_non_utf8_arg(root, argv).and_then(encode_invalid_units) {
                kv.push(("got-raw", value));
            }
        }
        _ => {
            let invalid_arg = ctx_str(err, ContextKind::InvalidArg);
            if let Some(arg) = invalid_arg.clone() {
                kv.push(("arg", arg));