use crate::{LayeredError, SourceLayer};
use serde::de::{DeserializeOwned, IntoDeserializer};
use std::collections::BTreeMap;
use std::path::PathBuf;
use toml::{Spanned, Value};
#[derive(Debug)]
pub struct ConfigFile {
path: PathBuf,
content: String,
values: BTreeMap<String, Spanned<Value>>,
}
impl ConfigFile {
pub fn load(path: impl Into<PathBuf>) -> Result<Option<Self>, LayeredError> {
let path = path.into();
let content = match std::fs::read_to_string(&path) {
Ok(content) => content,
Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(None),
Err(source) => return Err(LayeredError::Io { path, source }),
};
let values: BTreeMap<String, Spanned<Value>> = toml::from_str(&content).map_err(|e| {
let (line, column) = position_of(&content, e.span().map_or(0, |span| span.start));
LayeredError::Parse {
path: path.clone(),
line,
column,
message: e.message().to_string(),
}
})?;
Ok(Some(Self {
path,
content,
values,
}))
}
#[must_use]
pub fn get<T: DeserializeOwned>(&self, field: &str) -> Option<Result<T, LayeredError>> {
let spanned = self.values.get(field)?;
let value = spanned.get_ref();
Some(
T::deserialize(value.clone().into_deserializer()).map_err(|e| {
let (line, _) = position_of(&self.content, spanned.span().start);
LayeredError::Invalid {
field: field.to_string(),
value: display_value(value),
layer: SourceLayer::ConfigFile {
path: self.path.clone(),
line,
},
message: e.message().to_string(),
}
}),
)
}
}
pub(crate) fn from_env<T: DeserializeOwned>(
var: &str,
field: &str,
raw: &str,
) -> Result<T, LayeredError> {
if let Ok(deserializer) = toml::de::ValueDeserializer::parse(raw) {
if let Ok(value) = T::deserialize(deserializer) {
return Ok(value);
}
}
T::deserialize(Value::String(raw.to_string()).into_deserializer()).map_err(
|e: toml::de::Error| LayeredError::Invalid {
field: field.to_string(),
value: raw.to_string(),
layer: SourceLayer::EnvVar(var.to_string()),
message: e.message().to_string(),
},
)
}
fn display_value(value: &Value) -> String {
match value {
Value::String(s) => s.clone(),
other => other.to_string(),
}
}
fn position_of(content: &str, offset: usize) -> (usize, usize) {
let mut offset = offset.min(content.len());
while offset > 0 && !content.is_char_boundary(offset) {
offset -= 1;
}
let prefix = &content[..offset];
let line_start = prefix.rfind('\n').map_or(0, |i| i + 1);
let line = prefix.matches('\n').count() + 1;
let column = content[line_start..offset].chars().count() + 1;
(line, column)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn position_maps_offsets_to_lines_and_columns() {
let content = "a = 1\nbb = 2\n\nccc = 3\n";
assert_eq!(position_of(content, 0), (1, 1));
assert_eq!(position_of(content, 4), (1, 5));
assert_eq!(position_of(content, 6), (2, 1));
assert_eq!(position_of(content, 13), (3, 1));
assert_eq!(position_of(content, 14), (4, 1));
}
#[test]
fn position_handles_empty_content() {
assert_eq!(position_of("", 0), (1, 1));
}
#[test]
fn position_counts_columns_in_characters_not_bytes() {
let content = "x = 1\n\"kéy_ø\" = 2\n";
let offset = content.find("= 2").unwrap();
let (line, column) = position_of(content, offset);
assert_eq!(line, 2);
assert_eq!(column, 9, "column must count characters, not bytes");
}
#[test]
fn position_agrees_with_tomls_own_diagnostics() {
let content = "x = 1\n\"kéy_ünïcödé_ø\" = = 2\n";
let err = toml::from_str::<toml::Table>(content).unwrap_err();
let (line, column) = position_of(content, err.span().unwrap().start);
let rendered = err.to_string();
let first = rendered.lines().next().unwrap();
assert!(
first.contains(&format!("line {line}, column {column}")),
"ours: line {line}, column {column}; toml: {first}"
);
}
#[test]
fn position_does_not_panic_on_out_of_range_or_split_offsets() {
let content = "a = \"é\"\n";
assert_eq!(position_of(content, 9_999), (2, 1));
let inside = content.find('é').unwrap() + 1;
assert!(!content.is_char_boundary(inside));
assert_eq!(position_of(content, inside), (1, 6));
}
#[test]
fn env_decodes_toml_value_expressions() {
assert_eq!(from_env::<u16>("V", "port", "8080").unwrap(), 8080);
assert!(from_env::<bool>("V", "verbose", "true").unwrap());
assert_eq!(
from_env::<Vec<String>>("V", "tags", r#"["a", "b"]"#).unwrap(),
vec!["a".to_string(), "b".to_string()]
);
assert_eq!(
from_env::<Option<u16>>("V", "port", "8080").unwrap(),
Some(8080)
);
}
#[test]
fn env_falls_back_to_bare_strings() {
assert_eq!(from_env::<String>("V", "name", "hello").unwrap(), "hello");
assert_eq!(
from_env::<String>("V", "name", "hello world").unwrap(),
"hello world"
);
assert_eq!(from_env::<String>("V", "name", "true").unwrap(), "true");
assert_eq!(from_env::<String>("V", "name", "8080").unwrap(), "8080");
}
#[test]
fn env_reports_undecodable_values_against_the_variable() {
let err = from_env::<u16>("MYAPP_PORT", "port", "banana").unwrap_err();
let msg = err.to_string();
assert!(msg.contains("invalid value 'banana' for 'port'"), "{msg}");
assert!(msg.contains("environment variable MYAPP_PORT"), "{msg}");
}
}