Merge pull request #354 from YounessBird/fix-uppercase-lowercase-isses

matthiasbeyer · web-flow · commit 0d58da27e7e8 · 2022-09-17T15:53:13.000+02:00
Fix uppercase lowercase isses
diff --git a/README.md b/README.md
@@ -23,8 +23,10 @@
 [RON]: https://github.com/ron-rs/ron
 [JSON5]: https://github.com/callum-oakley/json5-rs
 
-Please note that this library can not be used to write changed configuration
-values back to the configuration file(s)!
+Please note this library
+
+ - can not be used to write changed configuration values back to the configuration file(s)!
+ - Is case insensitive and all the keys are converted to lowercase internally
 
 ## Usage
 
@@ -63,4 +65,4 @@ We currently support Rust 1.56.1 and newer.
 
 config-rs is primarily distributed under the terms of both the MIT license and the Apache License (Version 2.0).
 
-See LICENSE-APACHE and LICENSE-MIT for details.
+See LICENSE-APACHE and LICENSE-MIT for details.
diff --git a/src/config.rs b/src/config.rs
@@ -110,7 +110,8 @@ impl Config {
     where
         T: Into<Value>,
     {
-        self.defaults.insert(key.parse()?, value.into());
+        self.defaults
+            .insert(key.to_lowercase().as_str().parse()?, value.into());
 
         #[allow(deprecated)]
         self.refresh()
@@ -129,15 +130,16 @@ impl Config {
     where
         T: Into<Value>,
     {
-        self.overrides.insert(key.parse()?, value.into());
+        self.overrides
+            .insert(key.to_lowercase().as_str().parse()?, value.into());
 
         #[allow(deprecated)]
         self.refresh()
     }
 
     #[deprecated(since = "0.12.0", note = "please use 'ConfigBuilder' instead")]
     pub fn set_once(&mut self, key: &str, value: Value) -> Result<()> {
-        let expr: path::Expression = key.parse()?;
+        let expr: path::Expression = key.to_lowercase().as_str().parse()?;
 
         // Traverse the cache using the path to (possibly) retrieve a value
         if let Some(ref mut val) = expr.get_mut(&mut self.cache) {
@@ -149,6 +151,8 @@ impl Config {
     }
 
     pub fn get<'de, T: Deserialize<'de>>(&self, key: &str) -> Result<T> {
+        let k = key.to_lowercase();
+        let key = k.as_str();
         // Parse the key into a path expression
         let expr: path::Expression = key.parse()?;
 
diff --git a/src/de.rs b/src/de.rs
@@ -272,7 +272,7 @@ impl EnumAccess {
     fn variant_deserializer(&self, name: &str) -> Result<StrDeserializer> {
         self.variants
             .iter()
-            .find(|&&s| s == name)
+            .find(|&&s| s.to_lowercase() == name.to_lowercase()) // changing to lowercase will enable deserialization of lowercase values to enums
             .map(|&s| StrDeserializer(s))
             .ok_or_else(|| self.no_constructor_error(name))
     }
diff --git a/src/path/mod.rs b/src/path/mod.rs
@@ -120,7 +120,7 @@ impl Expression {
         match *self {
             Self::Identifier(ref id) => match root.kind {
                 ValueKind::Table(ref mut map) => Some(
-                    map.entry(id.clone())
+                    map.entry(id.to_lowercase())
                         .or_insert_with(|| Value::new(None, ValueKind::Nil)),
                 ),
 
@@ -131,15 +131,15 @@ impl Expression {
                 Some(value) => {
                     if let ValueKind::Table(ref mut map) = value.kind {
                         Some(
-                            map.entry(key.clone())
+                            map.entry(key.to_lowercase())
                                 .or_insert_with(|| Value::new(None, ValueKind::Nil)),
                         )
                     } else {
                         *value = Map::<String, Value>::new().into();
 
                         if let ValueKind::Table(ref mut map) = value.kind {
                             Some(
-                                map.entry(key.clone())
+                                map.entry(key.to_lowercase())
                                     .or_insert_with(|| Value::new(None, ValueKind::Nil)),
                             )
                         } else {
@@ -194,25 +194,25 @@ impl Expression {
                     ValueKind::Table(ref incoming_map) => {
                         // Pull out another table
                         let target = if let ValueKind::Table(ref mut map) = root.kind {
-                            map.entry(id.clone())
+                            map.entry(id.to_lowercase())
                                 .or_insert_with(|| Map::<String, Value>::new().into())
                         } else {
                             unreachable!();
                         };
 
                         // Continue the deep merge
                         for (key, val) in incoming_map {
-                            Self::Identifier(key.clone()).set(target, val.clone());
+                            Self::Identifier(key.to_lowercase()).set(target, val.clone());
                         }
                     }
 
                     _ => {
                         if let ValueKind::Table(ref mut map) = root.kind {
                             // Just do a simple set
-                            if let Some(existing) = map.get_mut(id) {
+                            if let Some(existing) = map.get_mut(&id.to_lowercase()) {
                                 *existing = value;
                             } else {
-                                map.insert(id.clone(), value);
+                                map.insert(id.to_lowercase(), value);
                             }
                         }
                     }
@@ -225,7 +225,7 @@ impl Expression {
                         // Didn't find a table. Oh well. Make a table and do this anyway
                         *parent = Map::<String, Value>::new().into();
                     }
-                    Self::Identifier(key.clone()).set(parent, value);
+                    Self::Identifier(key.to_lowercase()).set(parent, value);
                 }
             }
 
diff --git a/tests/Settings-enum-test.ini b/tests/Settings-enum-test.ini
@@ -0,0 +1,2 @@
+# Test for Enum deserialization. See file_tomls.rs override tests 
+bar = "bar is a lowercase param"
diff --git a/tests/Settings-enum-test.json b/tests/Settings-enum-test.json
@@ -0,0 +1,3 @@
+{
+    "bar": "bar is a lowercase param"
+}
diff --git a/tests/Settings-enum-test.json5 b/tests/Settings-enum-test.json5
@@ -0,0 +1,3 @@
+{
+    bar: "bar is a lowercase param",
+}
diff --git a/tests/Settings-enum-test.ron b/tests/Settings-enum-test.ron
@@ -0,0 +1,3 @@
+(
+    bar: "bar is a lowercase param"
+)
diff --git a/tests/Settings-enum-test.toml b/tests/Settings-enum-test.toml
@@ -0,0 +1,2 @@
+# Test for Enum deserialization. See file_tomls.rs override tests 
+bar = "bar is a lowercase param"
diff --git a/tests/Settings-enum-test.yaml b/tests/Settings-enum-test.yaml
@@ -0,0 +1,2 @@
+# Test for Enum deserialization. See file_yaml.rs override tests
+bar: bar is a lowercase param
diff --git a/tests/Settings-upper-struct.toml b/tests/Settings-upper-struct.toml
@@ -0,0 +1,3 @@
+# For override tests 
+FOO = "FOO should be overridden"
+bar = "I am bar"
diff --git a/tests/Settings.ini b/tests/Settings.ini
@@ -1,5 +1,7 @@
 debug = true
 production = false
+FOO = FOO should be overridden
+bar = I am bar
 [place]
 name = Torre di Pisa
 longitude = 43.7224985
diff --git a/tests/Settings.json b/tests/Settings.json
@@ -15,5 +15,7 @@
       "username": "jsmith",
       "email": "jsmith@localhost"
     }
-  }
+  },
+  "FOO": "FOO should be overridden",
+  "bar": "I am bar"
 }
diff --git a/tests/Settings.json5 b/tests/Settings.json5
@@ -16,5 +16,7 @@
       "username": "jsmith",
       "email": "jsmith@localhost",
     }
-  }
+  },
+  FOO: "FOO should be overridden",
+  bar: "I am bar",
 }
diff --git a/tests/Settings.ron b/tests/Settings.ron
@@ -16,5 +16,7 @@
       "username": "jsmith",
       "email": "jsmith@localhost"
     }
-  )
+  ),
+  FOO: "FOO should be overridden",
+  bar: "I am bar"
 )
diff --git a/tests/Settings.toml b/tests/Settings.toml
@@ -8,6 +8,10 @@ code = 53
 # errors
 boolean_s_parse = "fals"
 
+# For override tests 
+FOO="FOO should be overridden"
+bar="I am bar"
+
 arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 quarks = ["up", "down", "strange", "charm", "bottom", "top"]
 
diff --git a/tests/Settings.yaml b/tests/Settings.yaml
@@ -12,3 +12,6 @@ place:
     name: John Smith
     username: jsmith
     email: jsmith@localhost
+# For override tests
+FOO: FOO should be overridden
+bar: I am bar
diff --git a/tests/file_ini.rs b/tests/file_ini.rs
@@ -66,3 +66,106 @@ fn test_error_parse() {
         )
     );
 }
+
+#[derive(Debug, Deserialize, PartialEq)]
+enum EnumSettings {
+    Bar(String),
+}
+
+#[derive(Debug, Deserialize, PartialEq)]
+struct StructSettings {
+    foo: String,
+    bar: String,
+}
+#[derive(Debug, Deserialize, PartialEq)]
+#[allow(non_snake_case)]
+struct CapSettings {
+    FOO: String,
+}
+
+#[test]
+fn test_override_uppercase_value_for_struct() {
+    std::env::set_var("APP_FOO", "I HAVE BEEN OVERRIDDEN_WITH_UPPER_CASE");
+
+    let cfg = Config::builder()
+        .add_source(File::new("tests/Settings", FileFormat::Ini))
+        .add_source(config::Environment::with_prefix("APP").separator("_"))
+        .build()
+        .unwrap();
+    let cap_settings = cfg.clone().try_deserialize::<CapSettings>();
+    let lower_settings = cfg.try_deserialize::<StructSettings>().unwrap();
+
+    match cap_settings {
+        Ok(v) => {
+            // this assertion will ensure that the map has only lowercase keys
+            assert_ne!(v.FOO, "FOO should be overridden");
+            assert_eq!(
+                lower_settings.foo,
+                "I HAVE BEEN OVERRIDDEN_WITH_UPPER_CASE".to_string()
+            );
+        }
+        Err(e) => {
+            if e.to_string().contains("missing field `FOO`") {
+                assert_eq!(
+                    lower_settings.foo,
+                    "I HAVE BEEN OVERRIDDEN_WITH_UPPER_CASE".to_string()
+                );
+            } else {
+                panic!("{}", e);
+            }
+        }
+    }
+}
+
+#[test]
+fn test_override_lowercase_value_for_struct() {
+    std::env::set_var("config_foo", "I have been overridden_with_lower_case");
+
+    let cfg = Config::builder()
+        .add_source(File::new("tests/Settings", FileFormat::Ini))
+        .add_source(config::Environment::with_prefix("config").separator("_"))
+        .build()
+        .unwrap();
+
+    let values: StructSettings = cfg.try_deserialize().unwrap();
+    assert_eq!(
+        values.foo,
+        "I have been overridden_with_lower_case".to_string()
+    );
+    assert_ne!(values.foo, "I am bar".to_string());
+}
+
+#[test]
+fn test_override_uppercase_value_for_enums() {
+    std::env::set_var("APPS_BAR", "I HAVE BEEN OVERRIDDEN_WITH_UPPER_CASE");
+
+    let cfg = Config::builder()
+        .add_source(File::new("tests/Settings-enum-test", FileFormat::Ini))
+        .add_source(config::Environment::with_prefix("APPS").separator("_"))
+        .build()
+        .unwrap();
+    let val: EnumSettings = cfg.try_deserialize().unwrap();
+
+    assert_eq!(
+        val,
+        EnumSettings::Bar("I HAVE BEEN OVERRIDDEN_WITH_UPPER_CASE".to_string())
+    );
+}
+
+#[test]
+fn test_override_lowercase_value_for_enums() {
+    std::env::set_var("test_bar", "I have been overridden_with_lower_case");
+
+    let cfg = Config::builder()
+        .add_source(File::new("tests/Settings-enum-test", FileFormat::Ini))
+        .add_source(config::Environment::with_prefix("test").separator("_"))
+        .build()
+        .unwrap();
+
+    let param: EnumSettings = cfg.try_deserialize().unwrap();
+
+    assert_eq!(
+        param,
+        EnumSettings::Bar("I have been overridden_with_lower_case".to_string())
+    );
+}
diff --git a/tests/file_json.rs b/tests/file_json.rs
diff --git a/tests/file_json5.rs b/tests/file_json5.rs
diff --git a/tests/file_ron.rs b/tests/file_ron.rs
diff --git a/tests/file_toml.rs b/tests/file_toml.rs
diff --git a/tests/file_yaml.rs b/tests/file_yaml.rs

Original file line number	Diff line number	Diff line change
`@@ -272,7 +272,7 @@ impl EnumAccess {`
`272`	`272`	`fn variant_deserializer(&self, name: &str) -> Result<StrDeserializer> {`
`273`	`273`	`self.variants`
`274`	`274`	`.iter()`
`275`		`- .find(\|&&s\| s == name)`
	`275`	`+ .find(\|&&s\| s.to_lowercase() == name.to_lowercase()) // changing to lowercase will enable deserialization of lowercase values to enums`
`276`	`276`	`.map(\|&s\| StrDeserializer(s))`
`277`	`277`	`.ok_or_else(\|\| self.no_constructor_error(name))`
`278`	`278`	`}`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+# Test for Enum deserialization. See file_tomls.rs override tests`
	`2`	`+bar = "bar is a lowercase param"`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+{`
	`2`	`+ "bar": "bar is a lowercase param"`
	`3`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+{`
	`2`	`+ bar: "bar is a lowercase param",`
	`3`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+(`
	`2`	`+ bar: "bar is a lowercase param"`
	`3`	`+)`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+# Test for Enum deserialization. See file_yaml.rs override tests`
	`2`	`+bar: bar is a lowercase param`