taler-rust

config.rs (43799B)

---

 /*
   This file is part of TALER
   Copyright (C) 2025, 2026 Taler Systems SA
 
   TALER is free software; you can redistribute it and/or modify it under the
   terms of the GNU Affero General Public License as published by the Free Software
   Foundation; either version 3, or (at your option) any later version.
 
   TALER is distributed in the hope that it will be useful, but WITHOUT ANY
   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
   A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more details.
 
   You should have received a copy of the GNU Affero General Public License along with
   TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
 */
 
 use std::{
     fmt::{Debug, Display},
     fs::Permissions,
     os::unix::fs::PermissionsExt,
     path::PathBuf,
     str::FromStr,
     time::Duration,
 };
 
 use compact_str::CompactString;
 use indexmap::IndexMap;
 use jiff::{SignedDuration, Span};
 use url::Url;
 
 use crate::types::{
     amount::{Amount, Currency},
     payto::PaytoURI,
     validate_base_url,
 };
 
 pub mod parser {
     use std::{
         borrow::Cow,
         fmt::Display,
         io::{BufRead, BufReader},
         path::PathBuf,
         str::FromStr,
     };
 
     use indexmap::IndexMap;
     use tracing::{trace, warn};
 
     use super::{Config, ValueErr};
     use crate::config::{Line, Location};
 
     #[derive(Debug, thiserror::Error)]
     pub enum ConfigErr {
         #[error("config error, {0}")]
         Parser(#[from] ParserErr),
         #[error("invalid config, {0}")]
         Value(#[from] ValueErr),
     }
 
     #[derive(Debug)]
 
     pub enum ParserErr {
         IO(Cow<'static, str>, PathBuf, std::io::Error),
         Line(Cow<'static, str>, PathBuf, usize, Option<String>),
     }
 
     impl Display for ParserErr {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ParserErr::IO(action, path, err) => write!(
                     f,
                     "Could not {action} at '{}': {}",
                     path.to_string_lossy(),
                     err.kind()
                 ),
                 ParserErr::Line(msg, path, line, cause) => {
                     if let Some(cause) = cause {
                         write!(f, "{msg} at '{}:{line}': {cause}", path.to_string_lossy())
                     } else {
                         write!(f, "{msg} at '{}:{line}'", path.to_string_lossy())
                     }
                 }
             }
         }
     }
 
     impl std::error::Error for ParserErr {
         fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
             None
         }
 
         fn description(&self) -> &str {
             "description() is deprecated; use Display"
         }
 
         fn cause(&self) -> Option<&dyn std::error::Error> {
             self.source()
         }
     }
 
     fn io_err(
         action: impl Into<Cow<'static, str>>,
         path: impl Into<PathBuf>,
         err: std::io::Error,
     ) -> ParserErr {
         ParserErr::IO(action.into(), path.into(), err)
     }
     fn line_err(
         msg: impl Into<Cow<'static, str>>,
         path: impl Into<PathBuf>,
         line: usize,
     ) -> ParserErr {
         ParserErr::Line(msg.into(), path.into(), line, None)
     }
     fn line_cause_err(
         msg: impl Into<Cow<'static, str>>,
         cause: impl Display,
         path: impl Into<PathBuf>,
         line: usize,
     ) -> ParserErr {
         ParserErr::Line(msg.into(), path.into(), line, Some(cause.to_string()))
     }
     struct Parser {
         sections: IndexMap<String, IndexMap<String, Line>>,
         files: Vec<PathBuf>,
         install_path: PathBuf,
         buf: String,
     }
 
     impl Parser {
         fn empty() -> Self {
             Self {
                 sections: IndexMap::new(),
                 files: Vec::new(),
                 install_path: PathBuf::new(),
                 buf: String::new(),
             }
         }
 
         fn load_env(&mut self, src: ConfigSource) -> Result<(), ParserErr> {
             let ConfigSource { project_name, .. } = src;
 
             // Load default path
             let dir = src
                 .install_path()
                 .map_err(|(p, e)| io_err("find installation path", p, e))?;
             self.install_path = dir.clone();
 
             let paths = IndexMap::from_iter(
                 [
                     ("PREFIX", dir.join("")),
                     ("BINDIR", dir.join("bin")),
                     ("LIBEXECDIR", dir.join(project_name).join("libexec")),
                     ("DOCDIR", dir.join("share").join("doc").join(project_name)),
                     ("ICONDIR", dir.join("bin").join("share").join("icons")),
                     ("LOCALEDIR", dir.join("share").join("locale")),
                     ("LIBDIR", dir.join("lib").join(project_name)),
                     ("DATADIR", dir.join("share").join(project_name)),
                 ]
                 .map(|(a, b)| {
                     (
                         a.to_owned(),
                         Line {
                             content: b.to_string_lossy().into_owned(),
                             loc: None,
                         },
                     )
                 }),
             );
             self.sections.insert("PATHS".to_owned(), paths);
 
             // Load default configs
             let cfg_dir = dir.join("share").join(project_name).join("config.d");
             match std::fs::read_dir(&cfg_dir) {
                 Ok(entries) => {
                     for entry in entries {
                         match entry {
                             Ok(entry) => self.parse_file(entry.path(), 0)?,
                             Err(err) => {
                                 warn!(target: "config", "{}", io_err("read base config directory", &cfg_dir, err));
                             }
                         }
                     }
                 }
                 Err(err) => {
                     warn!(target: "config", "{}", io_err("read base config directory", &cfg_dir, err))
                 }
             }
 
             Ok(())
         }
 
         fn parse_file(&mut self, src: PathBuf, depth: u8) -> Result<(), ParserErr> {
             trace!(target: "config", "load file at '{}'", src.to_string_lossy());
             match std::fs::File::open(&src) {
                 Ok(file) => self.parse(BufReader::new(file), src, depth + 1),
                 Err(e) => Err(io_err("read config", src, e)),
             }
         }
 
         fn parse<B: BufRead>(
             &mut self,
             mut reader: B,
             src: PathBuf,
             depth: u8,
         ) -> Result<(), ParserErr> {
             let file = self.files.len();
             self.files.push(src.clone());
             let src = &src;
 
             let mut current_section: Option<&mut IndexMap<String, Line>> = None;
             let mut line = 0;
 
             loop {
                 // Read a new line
                 line += 1;
                 self.buf.clear();
                 match reader.read_line(&mut self.buf) {
                     Ok(0) => break,
                     Ok(_) => {}
                     Err(e) => return Err(io_err("read config", src, e)),
                 }
                 // Trim whitespace
                 let l = self.buf.trim_ascii();
 
                 if l.is_empty() || l.starts_with(['#', '%']) {
                     // Skip empty lines and comments
                     continue;
                 } else if let Some(directive) = l.strip_prefix("@") {
                     // Parse directive
                     let Some((name, arg)) = directive.split_once('@') else {
                         return Err(line_err(format!("Invalid directive line '{l}'"), src, line));
                     };
                     let arg = arg.trim_ascii_start();
                     // Exit current section
                     current_section = None;
                     // Check current file has a parent
                     let Some(parent) = src.parent() else {
                         return Err(line_err("no parent", src, line));
                     };
                     // Check recursion depth
                     if depth > 128 {
                         return Err(line_err("Recursion limit in config inlining", src, line));
                     }
 
                     match name.to_lowercase().as_str() {
                         "inline" => self.parse_file(parent.join(arg), depth)?,
                         "inline-matching" => {
                             let paths =
                                 glob::glob(&parent.join(arg).to_string_lossy()).map_err(|e| {
                                     line_cause_err("Malformed glob regex", e, src, line)
                                 })?;
                             for path in paths {
                                 let path =
                                     path.map_err(|e| line_cause_err("Glob error", e, src, line))?;
                                 self.parse_file(path, depth)?;
                             }
                         }
                         "inline-secret" => {
                             let (section, secret_file) = arg.split_once(" ").ok_or_else(||
                                 line_err(
                                     "Invalid configuration, @inline-secret@ directive requires exactly two arguments",
                                     src,
                                     line
                                 )
                             )?;
 
                             let section_up = section.to_uppercase();
                             let mut secret_cfg = Parser::empty();
 
                             if let Err(e) = secret_cfg.parse_file(parent.join(secret_file), depth) {
                                 if let ParserErr::IO(_, path, err) = e {
                                     warn!(target: "config", "{}", io_err(format!("read secret section [{section}]"), &path, err))
                                 } else {
                                     return Err(e);
                                 }
                             } else if let Some(secret_section) =
                                 secret_cfg.sections.swap_remove(&section_up)
                             {
                                 self.sections
                                     .entry(section_up)
                                     .or_default()
                                     .extend(secret_section);
                             } else {
                                 warn!(target: "config", "{}", line_err(format!("Configuration file at '{secret_file}' loaded with @inline-secret@ does not contain section '{section_up}'"), src, line));
                             }
                         }
                         unknown => {
                             return Err(line_err(
                                 format!("Invalid directive '{unknown}'"),
                                 src,
                                 line,
                             ));
                         }
                     }
                 } else if let Some(section) = l.strip_prefix('[').and_then(|l| l.strip_suffix(']'))
                 {
                     current_section =
                         Some(self.sections.entry(section.to_uppercase()).or_default());
                 } else if let Some((name, value)) = l.split_once('=') {
                     if let Some(current_section) = &mut current_section {
                         // Trim whitespace
                         let name = name.trim_ascii_end().to_uppercase();
                         let value = value.trim_ascii_start();
                         // Escape value
                         let value =
                             if value.len() > 1 && value.starts_with('"') && value.ends_with('"') {
                                 &value[1..value.len() - 1]
                             } else {
                                 value
                             };
                         current_section.insert(
                             name,
                             Line {
                                 content: value.to_owned(),
                                 loc: Some(Location { file, line }),
                             },
                         );
                     } else {
                         return Err(line_err("Expected section header or directive", src, line));
                     }
                 } else {
                     return Err(line_err(
                         "Expected section header, option assignment or directive",
                         src,
                         line,
                     ));
                 }
             }
             Ok(())
         }
 
         pub fn finish(self) -> Config {
             // Convert to a readonly config struct without location info
             Config {
                 sections: self.sections,
                 files: self.files,
                 install_path: self.install_path,
             }
         }
     }
 
     /** Information about how the configuration is loaded */
     #[derive(Debug, Clone, Copy)]
     pub struct ConfigSource {
         /** Name of the high-level project */
         pub project_name: &'static str,
         /** Name of the component within the package */
         pub component_name: &'static str,
         /**
          * Executable name that will be located on $PATH to
          * find the installation path of the package
          */
         pub exec_name: &'static str,
     }
 
     impl ConfigSource {
         /// Create a new config source
         pub const fn new(
             project_name: &'static str,
             component_name: &'static str,
             exec_name: &'static str,
         ) -> Self {
             Self {
                 project_name,
                 component_name,
                 exec_name,
             }
         }
 
         /// Create a config source where the project, component and exec names are the same
         pub const fn simple(name: &'static str) -> Self {
             Self::new(name, name, name)
         }
 
         /**
          * Search the default configuration file path
          *
          * I will be the first existing file from this list:
          * - $XDG_CONFIG_HOME/$componentName.conf
          * - $HOME/.config/$componentName.conf
          * - /etc/$componentName.conf
          * - /etc/$projectName/$componentName.conf
          * */
         fn default_config_path(&self) -> Result<Option<PathBuf>, (PathBuf, std::io::Error)> {
             // TODO use a generator
             let conf_name = format!("{}.conf", self.component_name);
 
             if let Some(xdg) = std::env::var_os("XDG_CONFIG_HOME") {
                 let path = PathBuf::from(xdg).join(&conf_name);
                 match path.try_exists() {
                     Ok(false) => {}
                     Ok(true) => return Ok(Some(path)),
                     Err(e) => return Err((path, e)),
                 }
             }
 
             if let Some(home) = std::env::var_os("HOME") {
                 let path = PathBuf::from(home).join(".config").join(&conf_name);
                 match path.try_exists() {
                     Ok(false) => {}
                     Ok(true) => return Ok(Some(path)),
                     Err(e) => return Err((path, e)),
                 }
             }
 
             let path = PathBuf::from("/etc").join(&conf_name);
             match path.try_exists() {
                 Ok(false) => {}
                 Ok(true) => return Ok(Some(path)),
                 Err(e) => return Err((path, e)),
             }
 
             let path = PathBuf::from("/etc")
                 .join(self.project_name)
                 .join(&conf_name);
             match path.try_exists() {
                 Ok(false) => {}
                 Ok(true) => return Ok(Some(path)),
                 Err(e) => return Err((path, e)),
             }
 
             Ok(None)
         }
 
         /** Search for the binary installation path in PATH */
         fn install_path(&self) -> Result<PathBuf, (PathBuf, std::io::Error)> {
             let path_env = std::env::var("PATH").unwrap();
             for path_dir in path_env.split(':') {
                 let path_dir = PathBuf::from(path_dir);
                 let bin_path = path_dir.join(self.exec_name);
                 if bin_path.exists()
                     && let Some(parent) = path_dir.parent()
                 {
                     return parent.canonicalize().map_err(|e| (parent.to_path_buf(), e));
                 }
             }
             Ok(PathBuf::from("/usr"))
         }
     }
 
     impl Config {
         pub fn from_file(
             src: ConfigSource,
             path: Option<impl Into<PathBuf>>,
         ) -> Result<Config, ParserErr> {
             let mut parser = Parser::empty();
             parser.load_env(src)?;
             match path {
                 Some(path) => parser.parse_file(path.into(), 0)?,
                 None => {
                     if let Some(default) = src
                         .default_config_path()
                         .map_err(|(p, e)| io_err("find default config path", p, e))?
                     {
                         parser.parse_file(default, 0)?;
                     }
                 }
             }
             Ok(parser.finish())
         }
 
         pub fn from_mem(str: &str) -> Result<Config, ParserErr> {
             let mut parser = Parser::empty();
             parser.parse(
                 std::io::Cursor::new(str),
                 PathBuf::from_str("mem").unwrap(),
                 0,
             )?;
             Ok(parser.finish())
         }
 
         pub fn from_mem_with_env(src: ConfigSource, str: &str) -> Result<Config, ParserErr> {
             let mut parser = Parser::empty();
             parser.load_env(src)?;
             parser.parse(
                 std::io::Cursor::new(str),
                 PathBuf::from_str("mem").unwrap(),
                 0,
             )?;
             Ok(parser.finish())
         }
     }
 }
 
 #[derive(Debug, thiserror::Error)]
 pub enum ValueErr {
     #[error("Missing {ty} option '{option}' in section '{section}'")]
     Missing {
         ty: String,
         section: String,
         option: String,
     },
     #[error("Invalid {ty} option '{option}' in section '{section}': {err}")]
     Invalid {
         ty: String,
         section: String,
         option: String,
         err: String,
     },
 }
 
 #[derive(Debug, thiserror::Error)]
 
 pub enum PathsubErr {
     #[error("recursion limit in path substitution exceeded for '{0}'")]
     Recursion(String),
     #[error("unbalanced variable expression '{0}'")]
     Unbalanced(String),
     #[error("bad substitution '{0}'")]
     Substitution(String),
     #[error("unbound variable '{0}'")]
     Unbound(String),
 }
 
 #[derive(Debug, Clone)]
 struct Location {
     file: usize,
     line: usize,
 }
 
 #[derive(Debug, Clone)]
 struct Line {
     content: String,
     loc: Option<Location>,
 }
 
 #[derive(Debug, Clone)]
 pub struct Config {
     sections: IndexMap<String, IndexMap<String, Line>>,
     files: Vec<PathBuf>,
     install_path: PathBuf,
 }
 
 impl Config {
     pub fn section<'cfg, 'arg>(&'cfg self, section: &'arg str) -> Section<'cfg, 'arg> {
         Section {
             name: section,
             config: self,
             values: self.sections.get(&section.to_uppercase()),
         }
     }
 
     pub fn sections<'cfg>(&'cfg self) -> impl Iterator<Item = Section<'cfg, 'cfg>> {
         self.sections.iter().map(|(section, values)| Section {
             name: section,
             config: self,
             values: Some(values),
         })
     }
 
     /**
      * Substitute ${...} and $... placeholders in a string
      * with values from the PATHS section in the
      * configuration and environment variables
      *
      * This substitution is typically only done for paths.
      */
     pub fn pathsub(&self, str: &str, depth: u8) -> Result<String, PathsubErr> {
         if depth > 128 {
             return Err(PathsubErr::Recursion(str.to_owned()));
         } else if !str.contains('$') {
             return Ok(str.to_owned());
         }
 
         /** Lookup for variable value from PATHS section in the configuration and environment variables */
         fn lookup(cfg: &Config, name: &str, depth: u8) -> Option<Result<String, PathsubErr>> {
             if let Some(path_res) = cfg
                 .sections
                 .get("PATHS")
                 .and_then(|section| section.get(name))
             {
                 return Some(cfg.pathsub(&path_res.content, depth + 1));
             }
 
             if let Ok(val) = std::env::var(name) {
                 return Some(Ok(val));
             }
             None
         }
 
         let mut result = String::new();
         let mut remaining = str;
         loop {
             // Look for the next variable
             let Some((normal, value)) = remaining.split_once('$') else {
                 result.push_str(remaining);
                 return Ok(result);
             };
 
             // Append normal character
             result.push_str(normal);
             remaining = value;
 
             // Check if variable is enclosed
             let is_enclosed = if let Some(enclosed) = remaining.strip_prefix('{') {
                 // ${var
                 remaining = enclosed;
                 true
             } else {
                 false // $var
             };
 
             // Extract variable name
             let name_end = remaining
                 .find(|c: char| !c.is_alphanumeric() && c != '_')
                 .unwrap_or(remaining.len());
             let (name, after_name) = remaining.split_at(name_end);
 
             // Extract variable default if enclosed
             let default = if !is_enclosed {
                 remaining = after_name;
                 None
             } else if let Some(after_enclosed) = after_name.strip_prefix('}') {
                 // ${var}
                 remaining = after_enclosed;
                 None
             } else if let Some(default) = after_name.strip_prefix(":-") {
                 // ${var:-default}
                 let mut depth = 1;
                 let Some((default, after_default)) = default.split_once(|c| {
                     if c == '{' {
                         depth += 1;
                         false
                     } else if c == '}' {
                         depth -= 1;
                         depth == 0
                     } else {
                         false
                     }
                 }) else {
                     return Err(PathsubErr::Unbalanced(default.to_owned()));
                 };
                 remaining = after_default;
                 Some(default)
             } else {
                 return Err(PathsubErr::Substitution(after_name.to_owned()));
             };
             if let Some(resolved) = lookup(self, name, depth + 1) {
                 result.push_str(&resolved?);
                 continue;
             } else if let Some(default) = default {
                 let resolved = self.pathsub(default, depth + 1)?;
                 result.push_str(&resolved);
                 continue;
             }
             return Err(PathsubErr::Unbound(name.to_owned()));
         }
     }
 
     pub fn print(&self, mut f: impl std::io::Write, diagnostics: bool) -> std::io::Result<()> {
         if diagnostics {
             writeln!(f, "#")?;
             writeln!(f, "# Configuration file diagnostics")?;
             writeln!(f, "#")?;
             writeln!(f, "# File Loaded:")?;
             for path in &self.files {
                 writeln!(f, "# {}", path.to_string_lossy())?;
             }
             writeln!(f, "#")?;
             writeln!(
                 f,
                 "# Installation path: {}",
                 self.install_path.to_string_lossy()
             )?;
             writeln!(f, "#")?;
             writeln!(f)?;
         }
         for (sect, values) in &self.sections {
             writeln!(f, "[{sect}]")?;
             if diagnostics {
                 writeln!(f)?;
             }
             for (key, Line { content, loc }) in values {
                 if diagnostics {
                     match loc {
                         Some(Location { file, line }) => {
                             let path = &self.files[*file];
                             writeln!(f, "# {}:{line}", path.to_string_lossy())?;
                         }
                         None => writeln!(f, "# default")?,
                     }
                 }
                 writeln!(f, "{key} = {content}")?;
                 if diagnostics {
                     writeln!(f)?;
                 }
             }
             writeln!(f)?;
         }
         Ok(())
     }
 }
 
 /** Accessor/Converter for Taler-like configuration sections */
 pub struct Section<'cfg, 'arg> {
     pub name: &'arg str,
     config: &'cfg Config,
     values: Option<&'cfg IndexMap<String, Line>>,
 }
 
 #[macro_export]
 macro_rules! map_config {
     ($self:expr, $ty:expr, $option:expr, $($key:expr => $parse:block),*$(,)?) => {
         {
             let keys = &[$($key,)*];
             $self.map($ty, $option, |value| {
                 match value {
                     $($key => {
                         (||Ok($parse))().map_err(|e| ::taler_common::config::MapErr::Err(e))
                     })*,
                     _ => Err(::taler_common::config::MapErr::Invalid(keys))
                 }
             })
         }
     }
 }
 
 pub use map_config;
 
 #[doc(hidden)]
 pub enum MapErr {
     Invalid(&'static [&'static str]),
     Err(ValueErr),
 }
 
 impl<'cfg, 'arg> Section<'cfg, 'arg> {
     #[doc(hidden)]
     fn inner<T>(
         &self,
         ty: &'arg str,
         option: &'arg str,
         transform: impl FnOnce(&'cfg str) -> Result<T, ValueErr>,
     ) -> Value<'arg, T> {
         let value = self
             .values
             .and_then(|m| m.get(&option.to_uppercase()))
             .filter(|it| !it.content.is_empty())
             .map(|raw| transform(&raw.content))
             .transpose();
         Value {
             value,
             option,
             ty,
             section: self.name,
         }
     }
 
     #[doc(hidden)]
     pub fn map<T>(
         &self,
         ty: &'arg str,
         option: &'arg str,
         transform: impl FnOnce(&'cfg str) -> Result<T, MapErr>,
     ) -> Value<'arg, T> {
         self.value(ty, option, |v| {
             transform(v).map_err(|e| match e {
                 MapErr::Invalid(keys) => {
                     let mut buf = "expected '".to_owned();
                     match keys {
                         [] => unreachable!("you must provide at least one mapping"),
                         [unique] => buf.push_str(unique),
                         [first, other @ .., last] => {
                             buf.push_str(first);
                             for k in other {
                                 buf.push_str("', '");
                                 buf.push_str(k);
                             }
                             buf.push_str("' or '");
                             buf.push_str(last);
                         }
                     }
                     buf.push_str("' got '");
                     buf.push_str(v);
                     buf.push('\'');
                     ValueErr::Invalid {
                         ty: ty.to_owned(),
                         section: self.name.to_owned(),
                         option: option.to_owned(),
                         err: buf,
                     }
                 }
                 MapErr::Err(e) => e,
             })
         })
     }
 
     /** Setup an accessor/converted for a [type] at [option] using [transform] */
     pub fn value<T, E: Display>(
         &self,
         ty: &'arg str,
         option: &'arg str,
         transform: impl FnOnce(&'cfg str) -> Result<T, E>,
     ) -> Value<'arg, T> {
         self.inner(ty, option, |v| {
             transform(v).map_err(|e| ValueErr::Invalid {
                 ty: ty.to_owned(),
                 section: self.name.to_owned(),
                 option: option.to_owned(),
                 err: e.to_string(),
             })
         })
     }
 
     /** Access [option] as a parsable type */
     pub fn parse<E: std::fmt::Display, T: FromStr<Err = E>>(
         &self,
         ty: &'arg str,
         option: &'arg str,
     ) -> Value<'arg, T> {
         self.value(ty, option, |it| it.parse::<T>().map_err(|e| e.to_string()))
     }
 
     /** Access [option] as str */
     pub fn str(&self, option: &'arg str) -> Value<'arg, String> {
         self.value("string", option, |it| Ok::<_, &str>(it.to_owned()))
     }
 
     /** Access [option] as compact str */
     pub fn cstr(&self, option: &'arg str) -> Value<'arg, CompactString> {
         self.value("string", option, |it| Ok::<_, CompactString>(it.into()))
     }
 
     /** Access [option] as hex encode bytes */
     pub fn hex(&self, option: &'arg str) -> Value<'arg, Vec<u8>> {
         self.value("hex", option, |it| {
             crate::encoding::hex::decode(it.as_bytes())
         })
     }
 
     /** Access [option] as base32 encode bytes */
     pub fn b32(&self, option: &'arg str) -> Value<'arg, Vec<u8>> {
         self.value("hex", option, |it| {
             crate::encoding::base32::decode(it.as_bytes())
         })
     }
 
     /** Access [option] as base64 encode bytes */
     pub fn b64(&self, option: &'arg str) -> Value<'arg, Vec<u8>> {
         self.value("hex", option, |it| {
             crate::encoding::base64::decode(it.as_bytes())
         })
     }
 
     /** Access [option] as path */
     pub fn path(&self, option: &'arg str) -> Value<'arg, String> {
         self.value("path", option, |it| self.config.pathsub(it, 0))
     }
 
     /** Access [option] as UNIX permissions */
     pub fn unix_mode(&self, option: &'arg str) -> Value<'arg, Permissions> {
         self.value("unix mode", option, |it| {
             u32::from_str_radix(it, 8)
                 .map(Permissions::from_mode)
                 .map_err(|_| format!("'{it}' not a valid number"))
         })
     }
 
     /** Access [option] as a number */
     pub fn number<T: FromStr>(&self, option: &'arg str) -> Value<'arg, T> {
         self.value("number", option, |it| {
             it.parse::<T>()
                 .map_err(|_| format!("'{it}' not a valid number"))
         })
     }
 
     /** Access [option] as Boolean */
     pub fn boolean(&self, option: &'arg str) -> Value<'arg, bool> {
         self.value("boolean", option, |it| match it.to_uppercase().as_str() {
             "YES" => Ok(true),
             "NO" => Ok(false),
             _ => Err(format!("expected 'YES' or 'NO' got '{it}'")),
         })
     }
 
     /** Access [option] as a Currency */
     pub fn currency(&self, option: &'arg str) -> Value<'arg, Currency> {
         self.parse("currency", option)
     }
 
     /** Access [option] as an Amount */
     pub fn amount(&self, option: &'arg str, currency: &Currency) -> Value<'arg, Amount> {
         self.value("amount", option, |it| {
             let amount = it.parse::<Amount>().map_err(|e| e.to_string())?;
             if amount.currency != *currency {
                 return Err(format!(
                     "expected currency {currency} got {}",
                     amount.currency
                 ));
             }
             Ok(amount)
         })
     }
 
     /** Access [option] as url */
     pub fn url(&self, option: &'arg str) -> Value<'arg, Url> {
         self.parse("url", option)
     }
 
     /** Access [option] as base url */
     pub fn base_url(&self, option: &'arg str) -> Value<'arg, Url> {
         self.value("url", option, |s| {
             let url = Url::from_str(s).map_err(|e| e.to_string())?;
             validate_base_url(&url)?;
             Ok::<_, String>(url)
         })
     }
 
     /** Access [option] as payto */
     pub fn payto(&self, option: &'arg str) -> Value<'arg, PaytoURI> {
         self.parse("payto", option)
     }
 
     /** Access [option] as Postgres URI */
     pub fn postgres(&self, option: &'arg str) -> Value<'arg, sqlx::postgres::PgConnectOptions> {
         self.parse("Postgres URI", option)
     }
 
     /** Access [option] as a timestamp */
     pub fn timestamp(&self, option: &'arg str) -> Value<'arg, jiff::Timestamp> {
         self.parse("Timestamp", option)
     }
 
     /** Access [option] as a time */
     pub fn time(&self, option: &'arg str) -> Value<'arg, jiff::civil::Time> {
         self.parse("Time", option)
     }
 
     /** Access [option] as a date */
     pub fn date(&self, option: &'arg str) -> Value<'arg, jiff::civil::Date> {
         self.parse("Date", option)
     }
 
     /** Access [option] as a duration */
     pub fn duration(&self, option: &'arg str) -> Value<'arg, Duration> {
         self.value("temporal", option, |it| {
             let tmp = SignedDuration::from_str(it).map_err(|e| e.to_string())?;
             Ok::<_, String>(Duration::from_millis(tmp.as_millis() as u64))
         })
     }
 
     /** Access [option] as a duration */
     pub fn span(&self, option: &'arg str) -> Value<'arg, Span> {
         self.parse("temporal", option)
     }
 
     /** Access [option] as a regex */
     pub fn regex(&self, option: &'arg str) -> Value<'arg, regex::Regex> {
         self.parse("Pattern", option)
     }
 
     /** Access option as json object */
     pub fn json<'de, T: serde::Deserialize<'de>>(&'de self, option: &'arg str) -> Value<'arg, T> {
         self.value("json", option, |it| serde_json::from_str(it))
     }
 }
 
 pub struct Value<'arg, T> {
     value: Result<Option<T>, ValueErr>,
     option: &'arg str,
     ty: &'arg str,
     section: &'arg str,
 }
 
 impl<T> Value<'_, T> {
     pub fn opt(self) -> Result<Option<T>, ValueErr> {
         self.value
     }
 
     /** Converted value of default if missing */
     pub fn default(self, default: T) -> Result<T, ValueErr> {
         Ok(self.value?.unwrap_or(default))
     }
 
     /** Converted value or throw if missing */
     pub fn require(self) -> Result<T, ValueErr> {
         self.value?.ok_or_else(|| ValueErr::Missing {
             ty: self.ty.to_owned(),
             section: self.section.to_owned(),
             option: self.option.to_owned(),
         })
     }
 }
 
 #[cfg(test)]
 mod test {
     use std::{
         fmt::{Debug, Display},
         fs::{File, Permissions},
         os::unix::fs::PermissionsExt,
     };
 
     use tracing::error;
 
     use super::{Config, Section, Value};
     use crate::{
         config::parser::ConfigSource,
         types::amount::{self, Currency},
     };
 
     const SOURCE: ConfigSource = ConfigSource::new("test", "test", "test");
 
     #[track_caller]
     fn check_err<T: Debug, E: Display>(err: impl AsRef<str>, lambda: Result<T, E>) {
         let failure = lambda.unwrap_err();
         let fmt = failure.to_string();
         assert_eq!(err.as_ref(), fmt);
     }
 
     #[test]
     fn fs() {
         let dir = tempfile::tempdir().unwrap();
         let config_path = dir.path().join("test-conf.conf");
         let second_path = dir.path().join("test-second-conf.conf");
 
         let config_path_fmt = config_path.to_string_lossy();
         let second_path_fmt = second_path.to_string_lossy();
 
         let check_err = |err: String| check_err(err, Config::from_file(SOURCE, Some(&config_path)));
         let check_ok = || Config::from_file(SOURCE, Some(&config_path)).unwrap();
 
         check_err(format!(
             "Could not read config at '{config_path_fmt}': entity not found"
         ));
 
         let config_file = std::fs::File::create_new(&config_path).unwrap();
         config_file
             .set_permissions(Permissions::from_mode(0o222))
             .unwrap();
         if File::open(&config_path).is_ok() {
             error!("Cannot finish this test if root");
             return;
         }
         check_err(format!(
             "Could not read config at '{config_path_fmt}': permission denied"
         ));
 
         config_file
             .set_permissions(Permissions::from_mode(0o666))
             .unwrap();
         check_ok();
         std::fs::write(&config_path, "@inline@ test-second-conf.conf").unwrap();
         check_err(format!(
             "Could not read config at '{second_path_fmt}': entity not found"
         ));
 
         let second_file = std::fs::File::create_new(&second_path).unwrap();
         second_file
             .set_permissions(Permissions::from_mode(0o222))
             .unwrap();
         check_err(format!(
             "Could not read config at '{second_path_fmt}': permission denied"
         ));
 
         std::fs::write(&config_path, "@inline-matching@[*").unwrap();
         check_err(format!(
             "Malformed glob regex at '{config_path_fmt}:1': Pattern syntax error near position 16: invalid range pattern"
         ));
 
         std::fs::write(&config_path, "@inline-matching@*second-conf.conf").unwrap();
         check_err(format!(
             "Could not read config at '{second_path_fmt}': permission denied"
         ));
 
         std::fs::write(&config_path, "\n@inline-matching@*.conf").unwrap();
         check_err(format!(
             "Recursion limit in config inlining at '{config_path_fmt}:2'"
         ));
         std::fs::write(&config_path, "\n\n@inline-matching@ *.conf").unwrap();
         check_err(format!(
             "Recursion limit in config inlining at '{config_path_fmt}:3'"
         ));
 
         std::fs::write(&config_path, "@inline-secret@ secret test-second-conf.conf").unwrap();
         check_ok();
     }
 
     #[test]
     fn parsing() {
         let check = |err: &str, content: &str| check_err(err, Config::from_mem(content));
 
         check(
             "Expected section header, option assignment or directive at 'mem:1'",
             "syntax error",
         );
         check(
             "Expected section header or directive at 'mem:1'",
             "key=value",
         );
         check(
             "Expected section header, option assignment or directive at 'mem:2'",
             "[section]\nbad-line",
         );
 
         let cfg = Config::from_mem(
             r#"
 
         [section-a]
 
         bar = baz
 
         [section-b]
 
         first_value = 1
         second_value = "test"
 
         "#,
         )
         .unwrap();
 
         // Missing section
         check_err(
             "Missing string option 'value' in section 'unknown'",
             cfg.section("unknown").str("value").require(),
         );
 
         // Missing value
         check_err(
             "Missing string option 'value' in section 'section-a'",
             cfg.section("section-a").str("value").require(),
         );
     }
 
     const DEFAULT_CONF: &str = "[PATHS]\nDATADIR=mydir\nRECURSIVE=$RECURSIVE";
 
     #[allow(clippy::type_complexity)]
     fn routine<T: Debug + Eq>(
         ty: &str,
         mut lambda: impl for<'cfg, 'arg> FnMut(&Section<'cfg, 'arg>, &'arg str) -> Value<'arg, T>,
         wellformed: &[(&[&str], T)],
         malformed: &[(&[&str], fn(&str) -> String)],
     ) {
         let conf = |content: &str| Config::from_mem(&format!("{DEFAULT_CONF}\n{content}")).unwrap();
 
         // Check missing msg
         let cfg = conf("");
         check_err(
             format!("Missing {ty} option 'value' in section 'section'"),
             lambda(&cfg.section("section"), "value").require(),
         );
 
         // Check wellformed options are properly parsed
         for (raws, expected) in wellformed {
             for raw in *raws {
                 let cfg = conf(&format!("[section]\nvalue={raw}"));
                 dbg!(&cfg);
                 assert_eq!(
                     *expected,
                     lambda(&cfg.section("section"), "value").require().unwrap()
                 );
             }
         }
 
         // Check malformed options have proper error message
         for (raws, error_fmt) in malformed {
             for raw in *raws {
                 let cfg = conf(&format!("[section]\nvalue={raw}"));
                 check_err(
                     format!(
                         "Invalid {ty} option 'value' in section 'section': {}",
                         error_fmt(raw)
                     ),
                     lambda(&cfg.section("section"), "value").require(),
                 )
             }
         }
     }
 
     #[test]
     fn string() {
         routine(
             "string",
             |sect, value| sect.str(value),
             &[
                 (&["1", "\"1\""], "1".to_owned()),
                 (&["test", "\"test\""], "test".to_owned()),
                 (&["\""], "\"".to_owned()),
             ],
             &[],
         );
     }
 
     #[test]
     fn path() {
         routine(
             "path",
             |sect, value| sect.path(value),
             &[
                 (&["path"], "path".to_owned()),
                 (
                     &["foo/$DATADIR/bar", "foo/${DATADIR}/bar"],
                     "foo/mydir/bar".to_owned(),
                 ),
                 (
                     &["foo/$DATADIR$DATADIR/bar"],
                     "foo/mydirmydir/bar".to_owned(),
                 ),
                 (
                     &["foo/pre_$DATADIR/bar", "foo/pre_${DATADIR}/bar"],
                     "foo/pre_mydir/bar".to_owned(),
                 ),
                 (
                     &[
                         "foo/${DATADIR}_next/bar",
                         "foo/${UNKNOWN:-$DATADIR}_next/bar",
                     ],
                     "foo/mydir_next/bar".to_owned(),
                 ),
                 (
                     &[
                         "foo/${UNKNOWN:-default}_next/bar",
                         "foo/${UNKNOWN:-${UNKNOWN:-default}}_next/bar",
                     ],
                     "foo/default_next/bar".to_owned(),
                 ),
                 (
                     &["foo/${UNKNOWN:-pre_${UNKNOWN:-default}_next}_next/bar"],
                     "foo/pre_default_next_next/bar".to_owned(),
                 ),
             ],
             &[
                 (&["foo/${A/bar"], |_| "bad substitution '/bar'".to_owned()),
                 (&["foo/${A:-pre_${B}/bar"], |_| {
                     "unbalanced variable expression 'pre_${B}/bar'".to_owned()
                 }),
                 (&["foo/${A:-${B${C}/bar"], |_| {
                     "unbalanced variable expression '${B${C}/bar'".to_owned()
                 }),
                 (&["foo/$UNKNOWN/bar", "foo/${UNKNOWN}/bar"], |_| {
                     "unbound variable 'UNKNOWN'".to_owned()
                 }),
                 (&["foo/$RECURSIVE/bar"], |_| {
                     "recursion limit in path substitution exceeded for '$RECURSIVE'".to_owned()
                 }),
             ],
         )
     }
 
     #[test]
     fn number() {
         routine(
             "number",
             |sect, value| sect.number(value),
             &[(&["1"], 1), (&["42"], 42)],
             &[(&["true", "YES"], |it| format!("'{it}' not a valid number"))],
         );
     }
 
     #[test]
     fn boolean() {
         routine(
             "boolean",
             |sect, value| sect.boolean(value),
             &[(&["yes", "YES", "Yes"], true), (&["no", "NO", "No"], false)],
             &[(&["true", "1"], |it| {
                 format!("expected 'YES' or 'NO' got '{it}'")
             })],
         );
     }
 
     #[test]
     fn amount() {
         routine(
             "amount",
             |sect, value| sect.amount(value, &Currency::KUDOS),
             &[(
                 &["KUDOS:12", "KUDOS:12.0", "KUDOS:012.0"],
                 amount::amount("KUDOS:12"),
             )],
             &[
                 (&["test", "42"], |it| {
                     format!("amount '{it}' invalid format")
                 }),
                 (&["KUDOS:0.3ABC"], |it| {
                     format!("amount '{it}' invalid fraction (invalid digit found in string)")
                 }),
                 (&["KUDOS:999999999999999999"], |it| {
                     format!("amount '{it}' value overflow (must be <= 4503599627370496)")
                 }),
                 (&["EUR:12"], |_| {
                     "expected currency KUDOS got EUR".to_owned()
                 }),
             ],
         )
     }
 }