cli.rs

use std::path::PathBuf;

use clap::{Clap, IntoApp};
use log::LevelFilter;
use serde::de::DeserializeOwned;
use thiserror::Error;

use crate::config;

#[derive(Error, Debug)]
pub enum CliError {
    #[error(transparent)]
    ArgParse(#[from] clap::Error),
    #[error(transparent)]
    Config(#[from] config::ConfigError),
}

pub trait AppOpts: Clap {
    fn try_init() -> Result<Self, CliError> {
        let result = Self::try_parse().map_err(CliError::ArgParse);

        match &result {
            Ok(result) => {
                try_init_pretty_logger(
                    result.get_log_environment_variable_name(),
                    result.get_log_level_filter(),
                )
                .unwrap();
            }
            Err(_) => {
                // Initialize the logger with defaults.
                pretty_env_logger::init();
            }
        }

        result
    }

    fn get_log_level_filter(&self) -> Option<LevelFilter> {
        None
    }

    fn get_log_environment_variable_name(&self) -> Option<&str> {
        None
    }
}

pub trait ConfigurableAppOpts<C: DeserializeOwned>: AppOpts {
    fn try_init_with_config() -> Result<(Self, C), CliError> {
        let opts = Self::try_init()?;

        let app = <Self as IntoApp>::into_app();

        let conf = config::from_default_paths(app.get_name(), &opts.get_additional_config_paths())
            .map_err(CliError::Config)?;

        Ok((opts, conf))
    }

    fn get_additional_config_paths(&self) -> Vec<PathBuf>;
}

fn try_init_pretty_logger(
    environment_variable_name: Option<&str>,
    level_filter_override: Option<LevelFilter>,
) -> Result<(), log::SetLoggerError> {
    let mut builder = pretty_env_logger::formatted_builder();

    if let Some(level_filter_override) = level_filter_override {
        builder.filter(None, level_filter_override);
    }

    if let Ok(s) = ::std::env::var(environment_variable_name.unwrap_or("RUST_LOG")) {
        builder.parse_filters(&s);
    }

    builder.try_init()
}