feat: fix

ScuffleTV · Jul 8, 2023 · 1d53d59 · 1d53d59
1 parent 9d068d3
commit 1d53d59
Show file tree

Hide file tree

Showing 11 changed files with 100 additions and 83 deletions.
diff --git a/common/src/config.rs b/common/src/config.rs
@@ -1,7 +1,6 @@
 use anyhow::Result;
 
 use crate::logging;
-use config::KeyGraph;
 
 #[derive(Debug, Clone, Default, PartialEq, config::Config, serde::Deserialize)]
 #[serde(default)]
@@ -27,10 +26,15 @@ pub struct LoggingConfig {
     pub level: String,
 
     /// What logging mode we should use
-    #[config(tree = "KeyTree::String")]
     pub mode: logging::Mode,
 }
 
+impl ::config::Config for logging::Mode {
+    fn graph() -> &'static ::config::KeyGraph {
+        &::config::KeyGraph::String
+    }
+}
+
 impl Default for LoggingConfig {
     fn default() -> Self {
         Self {

diff --git a/config/config/Cargo.toml b/config/config/Cargo.toml
@@ -14,7 +14,7 @@ serde_yaml = "0"
 toml = "0"
 clap = { version = "4", features = ["cargo", "string"] }
 convert_case = "0"
-serde = { version = "1", features = ["derive"] }
+serde = { version = "1", features = ["derive", "rc"] }
 tracing = { version = "0" }
 serde_ignored = "0"
 serde-value = "0"

diff --git a/config/config/example/derive.rs b/config/config/example/derive.rs
@@ -1,8 +1,6 @@
 //! Run with: `cargo run --example derive`
 //! Look at the generated code with: `cargo expand --example derive`
 
-use std::collections::HashMap;
-
 use config::{sources, ConfigBuilder, ConfigError};
 
 type TypeAlias = bool;
@@ -12,17 +10,14 @@ type TypeAlias = bool;
 struct AppConfig {
     enabled: TypeAlias,
     logging: LoggingConfig,
-    optional: Option<LoggingConfig>,
-    #[config(cli(skip), env(skip))]
-    map: HashMap<String, LoggingConfig>,
 }
 
 #[derive(config::Config, Debug, PartialEq, serde::Deserialize)]
 #[serde(default)]
 struct LoggingConfig {
     level: String,
     json: bool,
-    #[config(cli(skip), env(skip))]
+    #[config(cli(skip), env())]
     cycle: Option<Box<LoggingConfig>>,
 }
 
@@ -48,7 +43,7 @@ fn parse() -> Result<AppConfig, ConfigError> {
     builder.add_source(sources::CliSource::new()?);
     builder.add_source(sources::EnvSource::with_prefix("TEST")?);
     builder.add_source(sources::FileSource::json(
-    br#"
+        br#"
     {
         "enabled": "on",
         "optional": null,

diff --git a/config/config/src/key.rs b/config/config/src/key.rs
@@ -1,4 +1,9 @@
-use std::{collections::{BTreeMap, btree_map::Entry}, fmt::Display, cell::RefCell, ptr::NonNull};
+use std::{
+    cell::RefCell,
+    collections::{btree_map::Entry, BTreeMap},
+    fmt::Display,
+    ptr::NonNull,
+};
 
 #[derive(Debug, Default, Clone, PartialEq, Eq, Hash)]
 pub struct KeyPath(Vec<String>);
@@ -70,7 +75,7 @@ impl From<&str> for KeyPath {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone)]
 pub enum KeyType {
     String,
     I8,
@@ -90,6 +95,7 @@ pub enum KeyType {
     Struct(BTreeMap<String, KeyType>),
     Map(Box<KeyType>, Box<KeyType>),
     Seq(Box<KeyType>),
+    CyclicReference,
 }
 
 thread_local! {
@@ -190,7 +196,7 @@ impl std::fmt::Debug for KeyGraph {
             Self::Struct(map) => write!(f, "Struct({:?})", map),
             Self::Map(key, value) => write!(f, "Map({:?}, {:?})", key, value),
             Self::Seq(key) => write!(f, "Seq({:?})", key),
-            Self::Ref(_) => write!(f, "Ref(<already shown>)"),
+            Self::Ref(_) => write!(f, "Ref(...)"),
         }
     }
 }
@@ -220,7 +226,7 @@ impl KeyGraph {
                 KeyType::Map(Box::new(key.key_type()), Box::new(value.key_type()))
             }
             Self::Seq(key) => KeyType::Seq(Box::new(key.key_type())),
-            Self::Ref(_) => todo!("somehow work with keytypes"),
+            Self::Ref(_) => KeyType::CyclicReference,
         }
     }
 

diff --git a/config/config/src/lib.rs b/config/config/src/lib.rs
@@ -303,7 +303,7 @@ pub fn validate_from_graph(tree: &KeyGraph, value: Value) -> Result<Value> {
             } else {
                 validate_from_graph(tree, value)
             }
-        },
+        }
         KeyGraph::Seq(tree) => {
             if let Value::Seq(seq) = value {
                 let mut result = Vec::new();
@@ -317,9 +317,10 @@ pub fn validate_from_graph(tree: &KeyGraph, value: Value) -> Result<Value> {
                 Err(ConfigErrorEnum::ValidationError(format!(
                     "expected sequence, found {:?}",
                     value
-                )).into())
+                ))
+                .into())
             }
-        },
+        }
         KeyGraph::Map(key_tree, value_tree) => {
             if let Value::Map(map) = value {
                 let mut result = BTreeMap::new();
@@ -331,10 +332,10 @@ pub fn validate_from_graph(tree: &KeyGraph, value: Value) -> Result<Value> {
 
                 Ok(Value::Map(result))
             } else {
-                Err(ConfigErrorEnum::ValidationError(format!(
-                    "expected map, found {:?}",
-                    value
-                )).into())
+                Err(
+                    ConfigErrorEnum::ValidationError(format!("expected map, found {:?}", value))
+                        .into(),
+                )
             }
         }
         KeyGraph::Struct(tree) => {
@@ -348,7 +349,8 @@ pub fn validate_from_graph(tree: &KeyGraph, value: Value) -> Result<Value> {
                         return Err(ConfigErrorEnum::ValidationError(format!(
                             "expected string, found {:?}",
                             key
-                        )).into());
+                        ))
+                        .into());
                     };
 
                     let key_tree = if let Some(key_tree) = tree.get(&key_str) {
@@ -365,10 +367,10 @@ pub fn validate_from_graph(tree: &KeyGraph, value: Value) -> Result<Value> {
 
                 Ok(Value::Map(result))
             } else {
-                Err(ConfigErrorEnum::ValidationError(format!(
-                    "expected map, found {:?}",
-                    value
-                )).into())
+                Err(
+                    ConfigErrorEnum::ValidationError(format!("expected map, found {:?}", value))
+                        .into(),
+                )
             }
         }
         KeyGraph::Ref(tree) => validate_from_graph(tree, value),

diff --git a/config/config/src/primitives.rs b/config/config/src/primitives.rs
@@ -1,9 +1,9 @@
 use std::{
     cell::{Cell, RefCell},
-    collections::{BTreeSet, BinaryHeap, HashSet, LinkedList, VecDeque, BTreeMap, HashMap},
+    collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, LinkedList, VecDeque},
     marker::PhantomData,
     net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6},
-    path::{PathBuf},
+    path::PathBuf,
     rc::Rc,
     sync::{Arc, Mutex, RwLock},
     time::{Duration, SystemTime},
@@ -415,7 +415,11 @@ impl<C: Config + std::cmp::Ord> Config for BinaryHeap<C> {
     }
 }
 
-impl<C: Config + std::hash::Hash + std::cmp::Eq, S: std::hash::BuildHasher + std::default::Default + 'static> Config for HashSet<C, S> {
+impl<
+        C: Config + std::hash::Hash + std::cmp::Eq,
+        S: std::hash::BuildHasher + std::default::Default + 'static,
+    > Config for HashSet<C, S>
+{
     fn graph() -> &'static KeyGraph {
         if let Some(graph) = KeyGraph::get::<Self>() {
             return graph;
@@ -573,10 +577,7 @@ impl<K: Config + std::cmp::Ord, V: Config> Config for BTreeMap<K, V> {
             return graph;
         }
 
-        KeyGraph::store::<Self>(KeyGraph::Map(
-            K::graph(),
-            V::graph(),
-        ))
+        KeyGraph::store::<Self>(KeyGraph::Map(K::graph(), V::graph()))
     }
 
     fn validate(value: Value) -> Result<Value> {
@@ -602,16 +603,18 @@ impl<K: Config + std::cmp::Ord, V: Config> Config for BTreeMap<K, V> {
     }
 }
 
-impl<K: Config + std::hash::Hash + std::cmp::Eq, V: Config, S: std::hash::BuildHasher + std::default::Default + 'static> Config for HashMap<K, V, S> {
+impl<
+        K: Config + std::hash::Hash + std::cmp::Eq,
+        V: Config,
+        S: std::hash::BuildHasher + std::default::Default + 'static,
+    > Config for HashMap<K, V, S>
+{
     fn graph() -> &'static KeyGraph {
         if let Some(graph) = KeyGraph::get::<Self>() {
             return graph;
         }
 
-        KeyGraph::store::<Self>(KeyGraph::Map(
-            K::graph(),
-            V::graph(),
-        ))
+        KeyGraph::store::<Self>(KeyGraph::Map(K::graph(), V::graph()))
     }
 
     fn validate(value: Value) -> Result<Value> {
@@ -909,10 +912,6 @@ macro_rules! impl_slice {
 }
 
 impl_slice!(
-    0, 1, 2, 3, 4, 5, 6, 
-    7, 8, 9, 10, 11, 12,
-    13, 14, 15, 16, 17,
-    18, 19, 20, 21, 22,
-    23, 24, 25, 26, 27,
-    28, 29, 30, 31, 32
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
+    26, 27, 28, 29, 30, 31, 32
 );
diff --git a/config/config/src/sources/cli.rs b/config/config/src/sources/cli.rs
@@ -4,7 +4,7 @@ use clap::{command, Arg, ArgAction, ArgMatches, Command};
 use convert_case::{Case, Casing};
 
 use crate::{
-    Config, ConfigError, ConfigErrorEnum, ErrorSource, KeyPath, KeyGraph, Result, Source, Value,
+    Config, ConfigError, ConfigErrorEnum, ErrorSource, KeyGraph, KeyPath, Result, Source, Value,
 };
 
 use super::utils;
@@ -177,13 +177,13 @@ fn extend_cmd(
                 ConfigError::new(ConfigErrorEnum::UnsupportedType(tree.key_type()))
                     .with_path(path.clone()),
             )
-        },
+        }
         KeyGraph::Ref(_) => {
             return Err(
                 ConfigError::new(ConfigErrorEnum::UnsupportedType(tree.key_type()))
                     .with_path(path.clone()),
             )
-        },
+        }
     })
 }
 
@@ -237,7 +237,13 @@ pub fn generate_command<C: Config>() -> Result<Command> {
         }
     };
 
-    let (arg, mut command) = extend_cmd(command, &KeyGraph::Struct(map.clone()), None, &KeyPath::new(), false)?;
+    let (arg, mut command) = extend_cmd(
+        command,
+        &KeyGraph::Struct(map.clone()),
+        None,
+        &KeyPath::new(),
+        false,
+    )?;
 
     if let Some(arg) = arg {
         command = command.arg(arg);
@@ -483,16 +489,10 @@ fn matches_to_value(
             }
         }
         KeyGraph::Map(_, _) => {
-            Err(
-                ConfigError::new(ConfigErrorEnum::UnsupportedType(tree.key_type()))
-                    .with_path(path),
-            )
+            Err(ConfigError::new(ConfigErrorEnum::UnsupportedType(tree.key_type())).with_path(path))
         }
         KeyGraph::Ref(_) => {
-            Err(
-                ConfigError::new(ConfigErrorEnum::UnsupportedType(tree.key_type()))
-                    .with_path(path),
-            )
+            Err(ConfigError::new(ConfigErrorEnum::UnsupportedType(tree.key_type())).with_path(path))
         }
     }
 }

diff --git a/config/config/src/sources/env.rs b/config/config/src/sources/env.rs
@@ -1,7 +1,7 @@
 use std::{collections::BTreeMap, marker::PhantomData};
 
 use crate::{
-    Config, ConfigError, ConfigErrorEnum, ErrorSource, KeyPath, KeyGraph, KeyType, Result, Source,
+    Config, ConfigError, ConfigErrorEnum, ErrorSource, KeyGraph, KeyPath, KeyType, Result, Source,
     Value,
 };
 
@@ -34,7 +34,18 @@ impl<C: Config> EnvSource<C> {
                 false,
                 false,
             )
-            .map_err(|e| e.with_source(ErrorSource::Env))?
+            .map_err(|e| {
+                let e = e.with_source(ErrorSource::Env);
+                if prefix.is_some() {
+                    if let Some(path) = e.path().cloned() {
+                        e.with_path(path.drop_root())
+                    } else {
+                        e
+                    }
+                } else {
+                    e
+                }
+            })?
             .unwrap_or(Value::Option(None)),
         })
     }
@@ -96,15 +107,17 @@ fn extract_keys(
                         return None;
                     }
 
-                    Some(extract_keys(
-                        key.tree(),
-                        prefix,
-                        path.push_child(child_path),
-                        joiner,
-                        false,
-                        false,
+                    Some(
+                        extract_keys(
+                            key.tree(),
+                            prefix,
+                            path.push_child(child_path),
+                            joiner,
+                            false,
+                            false,
+                        )
+                        .map(|value| value.map(|value| (Value::String(child_path.clone()), value))),
                     )
-                    .map(|value| value.map(|value| (Value::String(child_path.clone()), value))))
                 })
                 .collect::<Result<Vec<_>>>()?
                 .into_iter()
@@ -136,12 +149,13 @@ fn extract_keys(
             }
 
             extract_keys(tree, prefix, path, joiner, true, false)
-        },
+        }
         KeyGraph::Map(_, _) => {
-            Err(ConfigError::new(ConfigErrorEnum::UnsupportedType(tree.key_type()))
-                .with_path(path))
+            Err(ConfigError::new(ConfigErrorEnum::UnsupportedType(tree.key_type())).with_path(path))
+        }
+        KeyGraph::Ref(_) => {
+            Err(ConfigError::new(ConfigErrorEnum::UnsupportedType(tree.key_type())).with_path(path))
         }
-        KeyGraph::Ref(_) => Err(ConfigError::new(ConfigErrorEnum::UnsupportedType(tree.key_type())).with_path(path)),
     }
 }
 
@@ -168,6 +182,6 @@ fn parse_to_value(key_type: KeyType, s: &str) -> Result<Value> {
 
 impl<C: Config> Source<C> for EnvSource<C> {
     fn get_key(&self, path: &KeyPath) -> Result<Option<Value>> {
-        utils::get_key(&self.value, path).map_err(|e| e.with_source(ErrorSource::Cli))
+        utils::get_key(&self.value, path).map_err(|e| e.with_source(ErrorSource::Env))
     }
 }