zarlib-cli 0.15.0

Command-line interface for managing ZAR archives
use crate::args::{Cli, command_with_version_banner};
use clap::{ArgAction, FromArgMatches};
use serde_json::Value;
use std::ffi::OsString;
use std::path::{Path, PathBuf};

pub(crate) fn parse(
    arguments: impl IntoIterator<Item = OsString>,
    search_paths: impl FnOnce() -> std::io::Result<Vec<PathBuf>>,
) -> Result<Cli, clap::Error> {
    let arguments: Vec<_> = arguments.into_iter().collect();
    let mut command = command_with_version_banner();
    let matches = command.clone().try_get_matches_from(&arguments)?;
    if matches.get_flag("no_config") {
        return Cli::from_arg_matches(&matches);
    }
    let paths = search_paths()
        .map_err(|error| clap::Error::raw(clap::error::ErrorKind::Io, error.to_string()))?;
    for path in paths {
        let text = match std::fs::read_to_string(&path) {
            Ok(text) => text,
            Err(error) if error.kind() == std::io::ErrorKind::NotFound => continue,
            Err(error) => return Err(config_error(&path, error)),
        };
        let config: Value =
            serde_json::from_str(&text).map_err(|error| config_error(&path, error))?;
        apply_defaults(&mut command, &config).map_err(|error| config_error(&path, error))?;
        let matches = command.try_get_matches_from(&arguments)?;
        return Cli::from_arg_matches(&matches);
    }
    Cli::from_arg_matches(&matches)
}

fn config_error(path: &Path, error: impl std::fmt::Display) -> clap::Error {
    clap::Error::raw(
        clap::error::ErrorKind::ValueValidation,
        format!("cannot read configuration {}: {error}", path.display()),
    )
}

fn apply_defaults(command: &mut clap::Command, config: &Value) -> Result<(), String> {
    let sections = config
        .as_object()
        .ok_or("expected an object of command sections")?;
    for (name, settings) in sections {
        let subcommand = command
            .find_subcommand_mut(name)
            .filter(|subcommand| subcommand.get_name() == name)
            .ok_or_else(|| format!("unknown command section '{name}'"))?;
        let settings = settings
            .as_object()
            .ok_or_else(|| format!("section '{name}' must be an object"))?;
        for (key, value) in settings {
            let argument = subcommand
                .get_arguments()
                .find(|argument| {
                    argument.get_long() == Some(key.as_str()) && !argument.is_global_set()
                })
                .ok_or_else(|| format!("unknown option '{name}.{key}'"))?;
            let values = match argument.get_action() {
                ArgAction::SetTrue | ArgAction::SetFalse => vec![
                    value
                        .as_bool()
                        .ok_or_else(|| format!("'{name}.{key}' must be a boolean"))?
                        .to_string(),
                ],
                ArgAction::Count => vec![
                    value
                        .as_u64()
                        .filter(|count| *count <= u8::MAX.into())
                        .ok_or_else(|| format!("'{name}.{key}' must be an integer from 0 to 255"))?
                        .to_string(),
                ],
                ArgAction::Set => vec![
                    scalar(value)
                        .ok_or_else(|| format!("'{name}.{key}' must be a string or number"))?,
                ],
                ArgAction::Append => value
                    .as_array()
                    .ok_or_else(|| format!("'{name}.{key}' must be an array"))?
                    .iter()
                    .map(|value| {
                        scalar(value).ok_or_else(|| {
                            format!("'{name}.{key}' entries must be strings or numbers")
                        })
                    })
                    .collect::<Result<Vec<_>, _>>()?,
                _ => return Err(format!("option '{name}.{key}' cannot be configured")),
            };
            let id = argument.get_id().clone();
            *subcommand = subcommand
                .clone()
                .mut_arg(id, |argument| argument.default_values(values));
        }
    }
    Ok(())
}

fn scalar(value: &Value) -> Option<String> {
    match value {
        Value::String(value) => Some(value.clone()),
        Value::Number(value) => Some(value.to_string()),
        _ => None,
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::args::Command;

    fn parse_at(arguments: &[&str], paths: &[PathBuf]) -> Result<Cli, clap::Error> {
        parse(arguments.iter().map(OsString::from), || Ok(paths.to_vec()))
    }

    #[test]
    fn config_defaults_are_overridden_by_cli_and_work_with_command_aliases() {
        let directory = tempfile::tempdir().unwrap();
        let path = directory.path().join("zarc.json");
        std::fs::write(&path, r#"{"create":{"compression-level":7,"metadata":true,"include-file":["*.rs","*.txt"]},"info":{"verbose":2}}"#).unwrap();
        let cli = parse_at(
            &["zarc", "c", "a.zar", "input"],
            std::slice::from_ref(&path),
        )
        .unwrap();
        assert!(
            matches!(cli.command, Command::Create { compression_level: Some(level), metadata: true, include_files, .. } if level == "7" && include_files == ["*.rs", "*.txt"])
        );
        let cli = parse_at(
            &[
                "zarc",
                "create",
                "a.zar",
                "input",
                "--compression-level",
                "3",
                "--include-file",
                "*.c",
            ],
            std::slice::from_ref(&path),
        )
        .unwrap();
        assert!(
            matches!(cli.command, Command::Create { compression_level: Some(level), include_files, .. } if level == "3" && include_files == ["*.c"])
        );
        let cli = parse_at(&["zarc", "info", "a.zar"], std::slice::from_ref(&path)).unwrap();
        assert!(matches!(cli.command, Command::Info { verbose: 2, .. }));
        let cli = parse_at(&["zarc", "info", "a.zar", "-v"], &[path]).unwrap();
        assert!(matches!(cli.command, Command::Info { verbose: 1, .. }));
    }

    #[test]
    fn extraction_checksum_default_can_be_configured_and_overridden() {
        use crate::args::ChecksumRecheck;
        let directory = tempfile::tempdir().unwrap();
        let path = directory.path().join("zarc.json");
        std::fs::write(&path, r#"{"extract":{"recheck-block-checksums":"never"}}"#).unwrap();
        let cli = parse_at(&["zarc", "extract", "a.zar"], std::slice::from_ref(&path)).unwrap();
        assert!(matches!(
            cli.command,
            Command::Extract {
                recheck_block_checksums: ChecksumRecheck::Never,
                ..
            }
        ));
        let cli = parse_at(
            &[
                "zarc",
                "extract",
                "a.zar",
                "--recheck-block-checksums",
                "always",
            ],
            &[path],
        )
        .unwrap();
        assert!(matches!(
            cli.command,
            Command::Extract {
                recheck_block_checksums: ChecksumRecheck::Always,
                ..
            }
        ));
    }

    #[test]
    fn search_uses_first_file_and_falls_back_to_user_config_only_if_missing() {
        let directory = tempfile::tempdir().unwrap();
        let local = directory.path().join("local.json");
        let user = directory.path().join("user.json");
        std::fs::write(&user, r#"{"create":{"metadata":true}}"#).unwrap();
        let paths = [local.clone(), user];
        let cli = parse_at(&["zarc", "create", "a.zar", "input"], &paths).unwrap();
        assert!(matches!(
            cli.command,
            Command::Create { metadata: true, .. }
        ));
        std::fs::write(&local, "{}").unwrap();
        let cli = parse_at(&["zarc", "create", "a.zar", "input"], &paths).unwrap();
        assert!(matches!(
            cli.command,
            Command::Create {
                metadata: false,
                ..
            }
        ));
        std::fs::write(&local, "invalid").unwrap();
        assert!(parse_at(&["zarc", "create", "a.zar", "input"], &paths).is_err());
    }

    #[test]
    fn no_config_and_help_skip_configuration_discovery() {
        for arguments in [
            vec!["zarc", "--no-config", "create", "a.zar", "input"],
            vec!["zarc", "create", "a.zar", "input", "--no-config"],
        ] {
            let cli = parse(arguments.iter().map(OsString::from), || {
                panic!("must not search")
            })
            .unwrap();
            assert!(matches!(
                cli.command,
                Command::Create {
                    metadata: false,
                    ..
                }
            ));
        }
        let error = parse(["zarc", "--help"].map(OsString::from), || {
            panic!("must not search")
        })
        .unwrap_err();
        assert_eq!(error.kind(), clap::error::ErrorKind::DisplayHelp);
    }

    #[test]
    fn rejects_invalid_configuration() {
        let directory = tempfile::tempdir().unwrap();
        let path = directory.path().join("zarc.json");
        for text in [
            "[]",
            r#"{"unknown":{}}"#,
            r#"{"create":[]}"#,
            r#"{"create":{"unknown":true}}"#,
            r#"{"create":{"metadata":"yes"}}"#,
            r#"{"create":{"include-file":"*.rs"}}"#,
            r#"{"create":{"archive":"a.zar"}}"#,
            r#"{"create":{"aead":"invalid"}}"#,
            r#"{"info":{"verbose":256}}"#,
        ] {
            std::fs::write(&path, text).unwrap();
            assert!(
                parse_at(
                    &["zarc", "create", "a.zar", "input"],
                    std::slice::from_ref(&path)
                )
                .is_err(),
                "{text}"
            );
        }
    }
}