Lines
100 %
Functions
91.67 %
Branches
//! Implement a configuration source based on command-line arguments.
use config::{ConfigError, Source, Value};
use once_cell::sync::Lazy;
use regex::Regex;
use std::collections::HashMap;
/// Alias for the Result type from config.
type Result<T> = std::result::Result<T, ConfigError>;
/// A CmdLine holds a set of command-line arguments that augment a
/// configuration.
///
/// These arguments are formatted in toml, and concatenated into a
/// single toml object. With arguments of the form "key=bareword",
/// the bareword is quoted for convenience.
#[derive(Debug, Clone)]
pub struct CmdLine {
/// String for decorating Values.
//
// TODO(nickm): not yet used.
#[allow(dead_code)]
name: String,
/// List of toml lines as given on the command line.
contents: Vec<String>,
}
impl Default for CmdLine {
fn default() -> Self {
Self::new()
impl CmdLine {
/// Make a new empty command-line
pub fn new() -> Self {
CmdLine {
name: "command line".to_string(),
contents: Vec::new(),
/// Add a single line of toml to the configuration.
pub fn push_toml_line(&mut self, line: String) {
self.contents.push(line);
/// Try to adjust the contents of a toml deserialization error so
/// that instead it refers to a single command-line argument.
fn convert_toml_error(&self, s: &str, pos: Option<(usize, usize)>) -> String {
/// Regex to match an error message from the toml crate.
static RE: Lazy<Regex> = Lazy::new(|| {
Regex::new(r"^(.*?) at line [0-9]+ column [0-9]+$").expect("Can't compile regex")
});
let cap = RE.captures(s);
let msg = match cap {
Some(c) => c.get(1).expect("mismatch regex: no capture group").as_str(),
None => s,
};
let location = match pos {
Some((line, _col)) if line < self.contents.len() => {
format!(" in {:?}", self.contents[line])
_ => " on command line".to_string(),
format!("{}{}", msg, location)
/// Compose elements of this cmdline into a single toml string.
fn build_toml(&self) -> String {
let mut toml_s = String::new();
for line in &self.contents {
toml_s.push_str(tweak_toml_bareword(line).as_ref().unwrap_or(line));
toml_s.push('\n');
toml_s
impl Source for CmdLine {
fn clone_into_box(&self) -> Box<dyn Source + Send + Sync> {
Box::new(self.clone())
fn collect(&self) -> Result<HashMap<String, Value>> {
let toml_s = self.build_toml();
let toml_v: toml::Value = match toml::from_str(&toml_s) {
Err(e) => {
return Err(ConfigError::Message(
self.convert_toml_error(&e.to_string(), e.line_col()),
))
Ok(v) => v,
toml_v
.try_into()
.map_err(|e| ConfigError::Foreign(Box::new(e)))
/// If `s` is a string of the form "keyword=bareword", return a new string
/// where `bareword` is quoted. Otherwise return None.
/// This isn't a smart transformation outside the context of 'config',
/// since many serde formats don't do so good a job when they get a
/// string when they wanted a number or whatever. But 'config' is
/// pretty happy to convert strings to other stuff.
fn tweak_toml_bareword(s: &str) -> Option<String> {
/// Regex to match a keyword=bareword item.
Regex::new(
r#"(?x:
^
[ \t]*
# first capture group: dotted barewords
((?:[a-zA-Z0-9_\-]+\.)*
[a-zA-Z0-9_\-]+)
[ \t]*=[ \t]*
# second group: one bareword without hyphens
([a-zA-Z0-9_]+)
$)"#,
)
.expect("Built-in regex compilation failed")
RE.captures(s).map(|c| format!("{}=\"{}\"", &c[1], &c[2]))
#[cfg(test)]
mod test {
#![allow(clippy::unwrap_used)]
use super::*;
#[test]
fn bareword_expansion() {
assert_eq!(tweak_toml_bareword("dsfklj"), None);
assert_eq!(tweak_toml_bareword("=99"), None);
assert_eq!(tweak_toml_bareword("=[1,2,3]"), None);
assert_eq!(tweak_toml_bareword("a=b-c"), None);
assert_eq!(tweak_toml_bareword("a=bc"), Some("a=\"bc\"".into()));
assert_eq!(tweak_toml_bareword("a=b_c"), Some("a=\"b_c\"".into()));
assert_eq!(
tweak_toml_bareword("hello.there.now=a_greeting"),
Some("hello.there.now=\"a_greeting\"".into())
);
fn conv_toml_error() {
let mut cl = CmdLine::new();
cl.push_toml_line("Hello=world".to_string());
cl.push_toml_line("Hola=mundo".to_string());
cl.push_toml_line("Bonjour=monde".to_string());
&cl.convert_toml_error("Nice greeting at line 1 column 1", Some((0, 1))),
"Nice greeting in \"Hello=world\""
&cl.convert_toml_error("Nice greeting at line 1 column 1", Some((7, 1))),
"Nice greeting on command line"
&cl.convert_toml_error("Nice greeting with a thing", Some((0, 1))),
"Nice greeting with a thing in \"Hello=world\""
fn clone_into_box() {
cl.push_toml_line("Molo=Lizwe".to_owned());
let cl2 = cl.clone_into_box();
let v = cl2.collect().unwrap();
assert_eq!(v["Molo"], "Lizwe".into());
fn parse_good() {
let mut cl = CmdLine::default();
cl.push_toml_line("a=3".to_string());
cl.push_toml_line("bcd=hello".to_string());
cl.push_toml_line("ef=\"gh i\"".to_string());
cl.push_toml_line("w=[1,2,3]".to_string());
let v = cl.collect().unwrap();
assert_eq!(v["a"], "3".into());
assert_eq!(v["bcd"], "hello".into());
assert_eq!(v["ef"], "gh i".into());
assert_eq!(v["w"], vec![1, 2, 3].into());
fn parse_bad() {
cl.push_toml_line("x=1 1 1 1 1".to_owned());
let v = cl.collect();
assert!(v.is_err());