98 lines
2.9 KiB
Rust
98 lines
2.9 KiB
Rust
use std::path::PathBuf;
|
|
|
|
use clap::Parser;
|
|
|
|
use self::{
|
|
cli::Args,
|
|
config_file::{find_config_file, Configs},
|
|
};
|
|
|
|
mod cli;
|
|
mod config_file;
|
|
|
|
/// this struct may hold all configuration
|
|
pub struct Config {
|
|
pub source: PathBuf,
|
|
pub evaluator: eval::Available,
|
|
|
|
pub startup_msg: bool,
|
|
}
|
|
|
|
impl Config {
|
|
/// Get the configs from all possible places (args, file, env...)
|
|
pub fn read() -> Self {
|
|
let args = Args::parse();
|
|
let config = if let Some(config) = args.config_path {
|
|
Ok(config)
|
|
} else {
|
|
find_config_file()
|
|
};
|
|
|
|
// try to read a maybe existing config file
|
|
let config = config.ok().and_then(|path| {
|
|
Configs::read(path).map_or_else(
|
|
|e| {
|
|
eprintln!("Config error: {e:?}");
|
|
eprintln!("Proceeding with defaults or cli args...");
|
|
None
|
|
},
|
|
Some,
|
|
)
|
|
});
|
|
|
|
if let Some(file) = config {
|
|
Self {
|
|
source: args.source,
|
|
evaluator: args.evaluator.and(file.evaluator).unwrap_or_default(),
|
|
// this is negated because to an outward api, the negative is more intuitive,
|
|
// while in the source the other way around is more intuitive
|
|
startup_msg: !(args.no_startup_message || file.no_startup_message),
|
|
}
|
|
} else {
|
|
Self {
|
|
source: args.source,
|
|
startup_msg: !args.no_startup_message,
|
|
evaluator: args.evaluator.unwrap_or_default(),
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub mod error {
|
|
/// Errors that can occur when reading configs
|
|
#[derive(Debug)]
|
|
pub enum Config {
|
|
/// The config dir doesn't exist
|
|
NoConfigDir,
|
|
/// We didn't find a config file in the config dir
|
|
NoConfigFileFound,
|
|
/// An io error happened while reading/opening it!
|
|
IoError(std::io::Error),
|
|
/// The given extension (via an argument) isn't known.
|
|
///
|
|
/// Occurs if the extension is neither `.json` nor `.ron` (including if there is no extension, in which case this will be `None`).
|
|
UnknownExtension(Option<String>),
|
|
/// Wrapper around an `Error` from `serde_json`
|
|
SerdeJsonError(serde_json::Error),
|
|
/// Wrapper around a `SpannedError` from `ron`
|
|
SerdeRonError(ron::error::SpannedError),
|
|
}
|
|
|
|
impl From<std::io::Error> for Config {
|
|
fn from(value: std::io::Error) -> Self {
|
|
Self::IoError(value)
|
|
}
|
|
}
|
|
|
|
impl From<serde_json::Error> for Config {
|
|
fn from(value: serde_json::Error) -> Self {
|
|
Self::SerdeJsonError(value)
|
|
}
|
|
}
|
|
|
|
impl From<ron::error::SpannedError> for Config {
|
|
fn from(value: ron::error::SpannedError) -> Self {
|
|
Self::SerdeRonError(value)
|
|
}
|
|
}
|
|
}
|