pub mod doctor;
pub mod keys;
pub mod paths;
pub mod secret;
pub mod store;
pub mod vault;
pub use keys::{Domain, Fallback, KeySpec, Value};
pub use secret::Secret;
use crate::error::Result;
use std::collections::BTreeMap;
use std::path::{Path, PathBuf};
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize)]
#[serde(rename_all = "snake_case")]
pub enum Origin {
Flag,
Stored,
Default,
}
impl Origin {
#[must_use]
pub const fn as_str(self) -> &'static str {
match self {
Self::Flag => "flag",
Self::Stored => "stored",
Self::Default => "default",
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Resolved {
pub value: Option<Value>,
pub origin: Origin,
}
#[derive(Debug)]
pub struct Config {
file: PathBuf,
stored: store::Stored,
flags: BTreeMap<&'static str, Value>,
}
impl Config {
pub fn load(override_dir: Option<&Path>) -> Result<Self> {
let file = paths::config_file(override_dir)?;
let stored = store::load(&file)?;
Ok(Self {
file,
stored,
flags: BTreeMap::new(),
})
}
pub fn with_nothing_stored(override_dir: Option<&Path>) -> Result<Self> {
Ok(Self {
file: paths::config_file(override_dir)?,
stored: store::Stored::new(),
flags: BTreeMap::new(),
})
}
pub fn with_flag(mut self, name: &str, raw: &str) -> Result<Self> {
let value = keys::validate(name, raw)?;
let entry = keys::spec(name).ok_or_else(|| keys::unknown_key(name))?;
self.flags.insert(entry.name, value);
Ok(self)
}
#[must_use]
pub fn file(&self) -> &Path {
&self.file
}
#[must_use]
pub fn is_stored(&self, name: &str) -> bool {
self.stored.contains_key(name)
}
pub fn resolve(&self, name: &str) -> Result<Resolved> {
let entry = keys::spec(name).ok_or_else(|| keys::unknown_key(name))?;
if let Some(value) = self.flags.get(entry.name) {
return Ok(Resolved {
value: Some(value.clone()),
origin: Origin::Flag,
});
}
if let Some(raw) = self.stored.get(entry.name) {
return Ok(Resolved {
value: Some(keys::validate(entry.name, raw)?),
origin: Origin::Stored,
});
}
Ok(Resolved {
value: entry.default_value()?,
origin: Origin::Default,
})
}
pub fn resolve_all(&self) -> impl Iterator<Item = (&'static KeySpec, Result<Resolved>)> + '_ {
keys::all()
.iter()
.map(|entry| (entry, self.resolve(entry.name)))
}
}
#[cfg(test)]
mod tests {
use super::*;
fn scratch() -> tempfile::TempDir {
tempfile::tempdir().expect("scratch directory")
}
#[test]
fn nothing_stored_means_the_builtin_value_is_in_force() {
let dir = scratch();
let config = Config::load(Some(dir.path())).expect("loads");
let resolved = config.resolve("output.format").expect("published");
assert_eq!(resolved.origin, Origin::Default);
assert_eq!(resolved.value, Some(Value::Enumeration("json")));
}
#[test]
fn a_stored_value_beats_the_builtin_one() {
let dir = scratch();
let file = paths::config_file(Some(dir.path())).expect("location");
store::store(&file, "output.format", "tsv").expect("writes");
let config = Config::load(Some(dir.path())).expect("loads");
let resolved = config.resolve("output.format").expect("published");
assert_eq!(resolved.origin, Origin::Stored);
assert_eq!(resolved.value, Some(Value::Enumeration("tsv")));
}
#[test]
fn a_flag_beats_a_stored_value() {
let dir = scratch();
let file = paths::config_file(Some(dir.path())).expect("location");
store::store(&file, "output.format", "tsv").expect("writes");
let config = Config::load(Some(dir.path()))
.expect("loads")
.with_flag("output.format", "ndjson")
.expect("accepted");
let resolved = config.resolve("output.format").expect("published");
assert_eq!(resolved.origin, Origin::Flag);
assert_eq!(resolved.value, Some(Value::Enumeration("ndjson")));
}
#[test]
fn a_flag_outside_the_domain_is_refused_before_anything_is_decided() {
let dir = scratch();
let failure = Config::load(Some(dir.path()))
.expect("loads")
.with_flag("limits.retries", "many")
.expect_err("must refuse");
assert_eq!(failure.code(), "config.value_outside_domain");
}
#[test]
fn a_stored_value_outside_its_domain_is_reported_rather_than_ignored() {
let dir = scratch();
let file = paths::config_file(Some(dir.path())).expect("location");
std::fs::create_dir_all(dir.path()).expect("directory");
std::fs::write(&file, "\"output.format\" = \"yaml\"\n").expect("writes");
let config = Config::load(Some(dir.path())).expect("loads");
let failure = config.resolve("output.format").expect_err("must report");
assert_eq!(failure.code(), "config.value_outside_domain");
}
#[test]
fn a_setting_decided_by_the_server_carries_no_value_and_says_so() {
let dir = scratch();
let config = Config::load(Some(dir.path())).expect("loads");
let resolved = config.resolve("conn.timezone").expect("published");
assert_eq!(resolved.origin, Origin::Default);
assert_eq!(resolved.value, None);
}
#[test]
fn an_unknown_name_is_refused_at_every_entry_point() {
let dir = scratch();
let config = Config::load(Some(dir.path())).expect("loads");
assert_eq!(
config
.resolve("output.nonsense")
.expect_err("must refuse")
.code(),
"config.unknown_key"
);
}
#[test]
fn every_published_setting_is_listed_once() {
let dir = scratch();
let config = Config::load(Some(dir.path())).expect("loads");
assert_eq!(config.resolve_all().count(), keys::all().len());
}
}