WIP Case sensitivity support

Signed-off-by: Matthias Beyer <mail@beyermatthias.de>

Author: matthiasbeyer

src/config.rs

@@ -39,24 +39,46 @@ impl Default for ConfigKind {
 /// A prioritized configuration repository. It maintains a set of
 /// configuration sources, fetches values to populate those, and provides
 /// them according to the source's priority.
+///
+/// By default, keys and enum variants are deserialized case sensitive, so "FOO" != "foo"
 #[derive(Clone, Debug)]
 pub struct Config {
     kind: ConfigKind,
 
     /// Root of the cached configuration.
     pub cache: Value,
+
+    /// Flag whether keys should be deserialized case-sensitive
+    pub(crate) keys_case_sensitive: bool,
+
+    /// Flag whether enum variants should be deserialized case-sensitive
+    pub(crate) enum_variants_case_sensitive: bool,
 }
 
 impl Default for Config {
     fn default() -> Self {
         Config {
             kind: ConfigKind::default(),
             cache: Value::new(None, Table::new()),
+            keys_case_sensitive: true,
+            enum_variants_case_sensitive: true,
         }
     }
 }
 
 impl Config {
+    pub fn with_keys_case_sensitive(mut self, b: bool) -> Self {
+        self.keys_case_sensitive = b;
+        self.cache.keys_case_sensitive = b;
+        self
+    }
+
+    pub fn with_enum_variants_case_sensitive(mut self, b: bool) -> Self {
+        self.enum_variants_case_sensitive = b;
+        self.cache.enum_variants_case_sensitive = b;
+        self
+    }
+
     /// Merge in a configuration property source.
     pub fn merge<T>(&mut self, source: T) -> Result<&mut Config>
     where

src/de.rs

@@ -21,7 +21,7 @@ impl<'de> de::Deserializer<'de> for Value {
             ValueKind::Float(f) => visitor.visit_f64(f),
             ValueKind::String(s) => visitor.visit_string(s),
             ValueKind::Array(values) => visitor.visit_seq(SeqAccess::new(values)),
-            ValueKind::Table(map) => visitor.visit_map(MapAccess::new(map)),
+            ValueKind::Table(map) => visitor.visit_map(MapAccess::new(map, self.keys_case_sensitive, self.enum_variants_case_sensitive)),
         }
     }
 
@@ -126,6 +126,7 @@ impl<'de> de::Deserializer<'de> for Value {
         V: de::Visitor<'de>,
     {
         visitor.visit_enum(EnumAccess {
+            variants_case_sensitive: self.enum_variants_case_sensitive,
             value: self,
             name,
             variants,
@@ -200,12 +201,16 @@ impl<'de> de::SeqAccess<'de> for SeqAccess {
 
 struct MapAccess {
     elements: VecDeque<(String, Value)>,
+    keys_case_sensitive: bool,
+    enum_variants_case_sensitive: bool,
 }
 
 impl MapAccess {
-    fn new(table: HashMap<String, Value>) -> Self {
+    fn new(table: HashMap<String, Value>, keys_case_sensitive: bool, enum_variants_case_sensitive: bool) -> Self {
         MapAccess {
             elements: table.into_iter().collect(),
+            keys_case_sensitive,
+            enum_variants_case_sensitive,
         }
     }
 }
@@ -218,7 +223,9 @@ impl<'de> de::MapAccess<'de> for MapAccess {
         K: de::DeserializeSeed<'de>,
     {
         if let Some(&(ref key_s, _)) = self.elements.front() {
-            let key_de = Value::new(None, key_s as &str);
+            let mut key_de = Value::new(None, key_s as &str);
+            key_de.keys_case_sensitive = self.keys_case_sensitive;
+            key_de.enum_variants_case_sensitive = self.enum_variants_case_sensitive;
             let key = de::DeserializeSeed::deserialize(seed, key_de)?;
 
             Ok(Some(key))
@@ -240,13 +247,14 @@ struct EnumAccess {
     value: Value,
     name: &'static str,
     variants: &'static [&'static str],
+    variants_case_sensitive: bool,
 }
 
 impl EnumAccess {
     fn variant_deserializer(&self, name: &str) -> Result<StrDeserializer> {
         self.variants
             .iter()
-            .find(|&&s| s == name)
+            .find(|&&s| s == name || (!self.variants_case_sensitive && s.eq_ignore_ascii_case(name)))
             .map(|&s| StrDeserializer(s))
             .ok_or_else(|| self.no_constructor_error(name))
     }
@@ -353,7 +361,7 @@ impl<'de> de::Deserializer<'de> for Config {
             ValueKind::Float(f) => visitor.visit_f64(f),
             ValueKind::String(s) => visitor.visit_string(s),
             ValueKind::Array(values) => visitor.visit_seq(SeqAccess::new(values)),
-            ValueKind::Table(map) => visitor.visit_map(MapAccess::new(map)),
+            ValueKind::Table(map) => visitor.visit_map(MapAccess::new(map, self.keys_case_sensitive, self.enum_variants_case_sensitive)),
         }
     }
 
@@ -454,6 +462,7 @@ impl<'de> de::Deserializer<'de> for Config {
             value: self.cache,
             name,
             variants,
+            variants_case_sensitive: self.enum_variants_case_sensitive,
         })
     }
 

src/value.rs

@@ -136,6 +136,12 @@ pub struct Value {
 
     /// Underlying kind of the configuration value.
     pub kind: ValueKind,
+
+    /// Flag whether keys should be deserialized case-sensitive
+    pub(crate) keys_case_sensitive: bool,
+
+    /// Flag whether enum variants should be deserialized case-sensitive
+    pub(crate) enum_variants_case_sensitive: bool,
 }
 
 impl Value {
@@ -147,6 +153,8 @@ impl Value {
         Value {
             origin: origin.cloned(),
             kind: kind.into(),
+            keys_case_sensitive: true,
+            enum_variants_case_sensitive: true,
         }
     }
 
@@ -533,6 +541,8 @@ where
         Value {
             origin: None,
             kind: value.into(),
+            keys_case_sensitive: true,
+            enum_variants_case_sensitive: true,
         }
     }
 }