functora-cfg lite refactoring

Author: functora

rust/functora-cfg/src/lib.rs

@@ -19,14 +19,18 @@ where
 
     // Def
     if let Some(cfg) = def {
-        builder = builder.add_source(any_to_config(cfg)?);
+        builder = builder.add_source(term_to_config(cfg)?);
     }
 
     // Cfg
     if let Some(path) = get_cfg_path(cli) {
         let path = Path::new(&path);
-        if path.exists() {
+        if path.exists() && path.is_file() {
             builder = builder.add_source(File::from(path));
+        } else {
+            return Err(ConfigError::Message(
+                "Config file path does not exist!".into(),
+            ));
         }
     }
 
@@ -37,40 +41,31 @@ where
     );
 
     // Cli
-    builder = builder.add_source(any_to_config(cli)?);
+    builder = builder.add_source(term_to_config(cli)?);
 
     builder.build()?.try_deserialize()
 }
 
-fn any_to_config<T: Serialize>(
+fn term_to_config<T: Serialize>(
     value: &T,
 ) -> Result<Config, ConfigError> {
     let toml = toml::Value::try_from(value)
         .map_err(|e| ConfigError::Message(e.to_string()))?;
 
-    if let TomlValue::Table(table) = toml {
-        toml_to_config_table(table)
+    if let TomlValue::Table(kv) = toml {
+        kv.into_iter()
+            .try_fold(Config::builder(), |acc, (k, v)| {
+                acc.set_override(k, toml_to_config(v))
+            })?
+            .build()
     } else {
         Err(ConfigError::Message(
             "Expected table at root".into(),
         ))
     }
 }
 
-fn toml_to_config_table(
-    table: toml::value::Table,
-) -> Result<Config, ConfigError> {
-    let mut builder = Config::builder();
-
-    for (k, v) in table {
-        builder = builder
-            .set_override(k, toml_to_config_value(v))?;
-    }
-
-    builder.build()
-}
-
-fn toml_to_config_value(toml: TomlValue) -> Value {
+fn toml_to_config(toml: TomlValue) -> Value {
     match toml {
         TomlValue::String(x) => Value::from(x),
         TomlValue::Integer(x) => Value::from(x),
@@ -81,12 +76,12 @@ fn toml_to_config_value(toml: TomlValue) -> Value {
         }
         TomlValue::Array(xs) => Value::from(
             xs.into_iter()
-                .map(toml_to_config_value)
+                .map(toml_to_config)
                 .collect::<Vec<_>>(),
         ),
         TomlValue::Table(kv) => Value::from(
             kv.into_iter()
-                .map(|(k, v)| (k, toml_to_config_value(v)))
+                .map(|(k, v)| (k, toml_to_config(v)))
                 .collect::<config::Map<String, Value>>(),
         ),
     }