114 lines
3.5 KiB
Rust
114 lines
3.5 KiB
Rust
use anyhow::{Context, Error, Result};
|
|
use serde::{Deserialize, Serialize};
|
|
use std::path::{Path, PathBuf};
|
|
|
|
#[derive(Debug)]
|
|
pub struct Config {
|
|
pub from: PathBuf,
|
|
pub to: PathBuf,
|
|
}
|
|
|
|
#[derive(Debug, Default, Serialize, Deserialize)]
|
|
struct ConfigFile {
|
|
pub from: Option<PathBuf>,
|
|
pub to: Option<PathBuf>,
|
|
}
|
|
|
|
pub fn config() -> Result<Config> {
|
|
use clap::Arg;
|
|
|
|
let matches = clap::App::new("audio-conv")
|
|
.version(clap::crate_version!())
|
|
.about("Converts audio files")
|
|
.arg(
|
|
Arg::with_name("config")
|
|
.short("c")
|
|
.long("config")
|
|
.required(false)
|
|
.takes_value(true)
|
|
.help("path to an audio-conv config file, defaults to \"audio-conv.yaml\""),
|
|
)
|
|
.arg(
|
|
Arg::with_name("from")
|
|
.short("f")
|
|
.long("from")
|
|
.required(false)
|
|
.takes_value(true)
|
|
.help("from directory path"),
|
|
)
|
|
.arg(
|
|
Arg::with_name("to")
|
|
.short("t")
|
|
.long("to")
|
|
.required(false)
|
|
.takes_value(true)
|
|
.help("to directory path"),
|
|
)
|
|
.get_matches();
|
|
|
|
let current_dir = std::env::current_dir().context("could not get current directory")?;
|
|
|
|
let config_path = matches.value_of_os("config");
|
|
let force_load = config_path.is_some();
|
|
let config_path = config_path
|
|
.map(AsRef::<Path>::as_ref)
|
|
.unwrap_or_else(|| AsRef::<Path>::as_ref("audio-conv.yaml"));
|
|
let config_path = current_dir.join(config_path);
|
|
|
|
let config_dir = config_path
|
|
.parent()
|
|
.context("could not get parent directory of the config file")?;
|
|
|
|
let config_file = load_config_file(&config_path)
|
|
.with_context(|| format!("failed loading config file \"{}\"", config_path.display()))?;
|
|
|
|
if force_load && config_file.is_none() {
|
|
return Err(Error::msg(format!(
|
|
"could not find config file \"{}\"",
|
|
config_path.display()
|
|
)));
|
|
}
|
|
|
|
Ok(Config {
|
|
from: {
|
|
matches
|
|
.value_of_os("from")
|
|
.map(|p| current_dir.join(p))
|
|
.or_else(|| {
|
|
config_file
|
|
.as_ref()
|
|
.map(|c| c.from.as_ref())
|
|
.flatten()
|
|
.map(|p| config_dir.join(p))
|
|
})
|
|
.ok_or_else(|| Error::msg("\"from\" not configured"))?
|
|
.canonicalize()
|
|
.context("could not canonicalize \"from\" path")?
|
|
},
|
|
to: matches
|
|
.value_of_os("to")
|
|
.map(|p| current_dir.join(p))
|
|
.or_else(|| {
|
|
config_file
|
|
.as_ref()
|
|
.map(|c| c.to.as_ref())
|
|
.flatten()
|
|
.map(|p| config_dir.join(p))
|
|
})
|
|
.ok_or_else(|| Error::msg("\"to\" not configured"))?
|
|
.canonicalize()
|
|
.context("could not canonicalize \"to\" path")?,
|
|
})
|
|
}
|
|
|
|
fn load_config_file(path: &Path) -> Result<Option<ConfigFile>> {
|
|
let mut file = match std::fs::File::open(path) {
|
|
Ok(file) => file,
|
|
Err(err) if err.kind() == std::io::ErrorKind::NotFound => return Ok(None),
|
|
Err(err) => return Err(Error::new(err)),
|
|
};
|
|
let config: ConfigFile =
|
|
serde_yaml::from_reader(&mut file).context("could not read config file")?;
|
|
Ok(Some(config))
|
|
}
|