Merge pull request #155 from matthiasbeyer/format

Run cargo-fmt

17 files changed, 163 insertions, 144 deletions

diff --git a/src/config.rs b/src/config.rs
index c093dae..888d8cc 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -161,8 +161,7 @@ impl Config {
         match value {
             Some(value) => {
                 // Deserialize the received value into the requested type
-                T::deserialize(value)
-                    .map_err(|e| e.extend_with_key(key))
+                T::deserialize(value).map_err(|e| e.extend_with_key(key))
             }
 
             None => Err(ConfigError::NotFound(key.into())),
diff --git a/src/de.rs b/src/de.rs
index 2776634..c4fdeb2 100644
--- a/src/de.rs
+++ b/src/de.rs
@@ -3,7 +3,7 @@ use error::*;
 use serde::de;
 use std::collections::{HashMap, VecDeque};
 use std::iter::Enumerate;
-use value::{Value, ValueKind, Table};
+use value::{Table, Value, ValueKind};
 
 impl<'de> de::Deserializer<'de> for Value {
     type Error = ConfigError;
@@ -125,7 +125,11 @@ impl<'de> de::Deserializer<'de> for Value {
     where
         V: de::Visitor<'de>,
     {
-        visitor.visit_enum(EnumAccess{ value: self, name, variants })
+        visitor.visit_enum(EnumAccess {
+            value: self,
+            name,
+            variants,
+        })
     }
 
     forward_to_deserialize_any! {
@@ -178,11 +182,10 @@ impl<'de> de::SeqAccess<'de> for SeqAccess {
         T: de::DeserializeSeed<'de>,
     {
         match self.elements.next() {
-            Some((idx, value)) => {
-                seed.deserialize(value)
-                    .map(Some)
-                    .map_err(|e| e.prepend_index(idx))
-            }
+            Some((idx, value)) => seed
+                .deserialize(value)
+                .map(Some)
+                .map_err(|e| e.prepend_index(idx)),
             None => Ok(None),
         }
     }
@@ -229,8 +232,7 @@ impl<'de> de::MapAccess<'de> for MapAccess {
         V: de::DeserializeSeed<'de>,
     {
         let (key, value) = self.elements.pop_front().unwrap();
-        de::DeserializeSeed::deserialize(seed, value)
-            .map_err(|e| e.prepend_key(key))
+        de::DeserializeSeed::deserialize(seed, value).map_err(|e| e.prepend_key(key))
     }
 }
 
@@ -315,21 +317,21 @@ impl<'de> de::VariantAccess<'de> for EnumAccess {
         V: de::Visitor<'de>,
     {
         match self.value.kind {
-            ValueKind::Table(t) => de::Deserializer::deserialize_seq(t.into_iter().next().unwrap().1, visitor),
+            ValueKind::Table(t) => {
+                de::Deserializer::deserialize_seq(t.into_iter().next().unwrap().1, visitor)
+            }
             _ => unreachable!(),
         }
     }
 
-    fn struct_variant<V>(
-        self,
-        _fields: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value>
+    fn struct_variant<V>(self, _fields: &'static [&'static str], visitor: V) -> Result<V::Value>
     where
         V: de::Visitor<'de>,
     {
         match self.value.kind {
-            ValueKind::Table(t) => de::Deserializer::deserialize_map(t.into_iter().next().unwrap().1, visitor),
+            ValueKind::Table(t) => {
+                de::Deserializer::deserialize_map(t.into_iter().next().unwrap().1, visitor)
+            }
             _ => unreachable!(),
         }
     }
@@ -448,7 +450,11 @@ impl<'de> de::Deserializer<'de> for Config {
     where
         V: de::Visitor<'de>,
     {
-        visitor.visit_enum(EnumAccess{ value: self.cache, name, variants })
+        visitor.visit_enum(EnumAccess {
+            value: self.cache,
+            name,
+            variants,
+        })
     }
 
     forward_to_deserialize_any! {
diff --git a/src/error.rs b/src/error.rs
index b6730e3..deb79ee 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -131,14 +131,12 @@ impl ConfigError {
                 unexpected,
                 expected,
                 key,
-            } => {
-                ConfigError::Type {
-                    origin,
-                    unexpected,
-                    expected,
-                    key: Some(concat(key)),
-                }
-            }
+            } => ConfigError::Type {
+                origin,
+                unexpected,
+                expected,
+                key: Some(concat(key)),
+            },
             ConfigError::NotFound(key) => ConfigError::NotFound(concat(Some(key))),
             _ => self,
         }
@@ -210,7 +208,7 @@ impl fmt::Display for ConfigError {
     }
 }
 
-impl Error for ConfigError { }
+impl Error for ConfigError {}
 
 impl de::Error for ConfigError {
     fn custom<T: fmt::Display>(msg: T) -> Self {
diff --git a/src/file/format/ini.rs b/src/file/format/ini.rs
index e5e5950..e5a109f 100644
--- a/src/file/format/ini.rs
+++ b/src/file/format/ini.rs
@@ -15,22 +15,13 @@ pub fn parse(
             Some(ref sec) => {
                 let mut sec_map: HashMap<String, Value> = HashMap::new();
                 for (k, v) in prop.iter() {
-                    sec_map.insert(
-                        k.clone(),
-                        Value::new(uri, ValueKind::String(v.clone())),
-                    );
+                    sec_map.insert(k.clone(), Value::new(uri, ValueKind::String(v.clone())));
                 }
-                map.insert(
-                    sec.clone(),
-                    Value::new(uri, ValueKind::Table(sec_map)),
-                );
+                map.insert(sec.clone(), Value::new(uri, ValueKind::Table(sec_map)));
             }
             None => {
                 for (k, v) in prop.iter() {
-                    map.insert(
-                        k.clone(),
-                        Value::new(uri, ValueKind::String(v.clone())),
-                    );
+                    map.insert(k.clone(), Value::new(uri, ValueKind::String(v.clone())));
                 }
             }
         }
diff --git a/src/file/format/json.rs b/src/file/format/json.rs
index 0d15070..0ff2beb 100644
--- a/src/file/format/json.rs
+++ b/src/file/format/json.rs
@@ -22,13 +22,15 @@ fn from_json_value(uri: Option<&String>, value: &serde_json::Value) -> Value {
     match *value {
         serde_json::Value::String(ref value) => Value::new(uri, ValueKind::String(value.clone())),
 
-        serde_json::Value::Number(ref value) => if let Some(value) = value.as_i64() {
-            Value::new(uri, ValueKind::Integer(value))
-        } else if let Some(value) = value.as_f64() {
-            Value::new(uri, ValueKind::Float(value))
-        } else {
-            unreachable!();
-        },
+        serde_json::Value::Number(ref value) => {
+            if let Some(value) = value.as_i64() {
+                Value::new(uri, ValueKind::Integer(value))
+            } else if let Some(value) = value.as_f64() {
+                Value::new(uri, ValueKind::Float(value))
+            } else {
+                unreachable!();
+            }
+        }
 
         serde_json::Value::Bool(value) => Value::new(uri, ValueKind::Boolean(value)),
 
diff --git a/src/file/mod.rs b/src/file/mod.rs
index ebe93bc..73dfad4 100644
--- a/src/file/mod.rs
+++ b/src/file/mod.rs
@@ -10,8 +10,8 @@ use value::Value;
 pub use self::format::FileFormat;
 use self::source::FileSource;
 
-pub use self::source::string::FileSourceString;
 pub use self::source::file::FileSourceFile;
+pub use self::source::string::FileSourceString;
 
 #[derive(Clone, Debug)]
 pub struct File<T>
@@ -119,9 +119,6 @@ where
         // Parse the string using the given format
         format
             .parse(uri.as_ref(), &contents)
-            .map_err(|cause| ConfigError::FileParse {
-                uri,
-                cause,
-            })
+            .map_err(|cause| ConfigError::FileParse { uri, cause })
     }
 }
diff --git a/src/file/source/file.rs b/src/file/source/file.rs
index 57c251f..804d108 100644
--- a/src/file/source/file.rs
+++ b/src/file/source/file.rs
@@ -58,23 +58,27 @@ impl FileSourceFile {
         }
 
         match format_hint {
-            Some(format) => for ext in format.extensions() {
-                filename.set_extension(ext);
-
-                if filename.is_file() {
-                    return Ok((filename, format));
-                }
-            },
-
-            None => for (format, extensions) in ALL_EXTENSIONS.iter() {
+            Some(format) => {
                 for ext in format.extensions() {
                     filename.set_extension(ext);
 
                     if filename.is_file() {
-                        return Ok((filename, *format));
+                        return Ok((filename, format));
                     }
                 }
-            },
+            }
+
+            None => {
+                for (format, extensions) in ALL_EXTENSIONS.iter() {
+                    for ext in format.extensions() {
+                        filename.set_extension(ext);
+
+                        if filename.is_file() {
+                            return Ok((filename, *format));
+                        }
+                    }
+                }
+            }
         }
 
         Err(Box::new(io::Error::new(
diff --git a/src/path/mod.rs b/src/path/mod.rs
index 3916010..ac28400 100644
--- a/src/path/mod.rs
+++ b/src/path/mod.rs
@@ -151,34 +151,30 @@ impl Expression {
                 _ => None,
             },
 
-            Expression::Subscript(ref expr, index) => {
-                match expr.get_mut_forcibly(root) {
-                    Some(value) => {
-                        match value.kind {
-                            ValueKind::Array(_) => (),
-                            _ => *value = Vec::<Value>::new().into(),
-                        }
-
-                        match value.kind {
-                            ValueKind::Array(ref mut array) => {
-                                let index = sindex_to_uindex(index, array.len());
+            Expression::Subscript(ref expr, index) => match expr.get_mut_forcibly(root) {
+                Some(value) => {
+                    match value.kind {
+                        ValueKind::Array(_) => (),
+                        _ => *value = Vec::<Value>::new().into(),
+                    }
 
-                                if index >= array.len() {
-                                    array.resize(
-                                        (index + 1) as usize,
-                                        Value::new(None, ValueKind::Nil),
-                                    );
-                                }
+                    match value.kind {
+                        ValueKind::Array(ref mut array) => {
+                            let index = sindex_to_uindex(index, array.len());
 
-                                Some(&mut array[index])
+                            if index >= array.len() {
+                                array
+                                    .resize((index + 1) as usize, Value::new(None, ValueKind::Nil));
                             }
 
-                            _ => None,
+                            Some(&mut array[index])
                         }
+
+                        _ => None,
                     }
-                    _ => None,
                 }
-            }
+                _ => None,
+            },
         }
     }
 
@@ -246,10 +242,7 @@ impl Expression {
                     if let ValueKind::Array(ref mut array) = parent.kind {
                         let uindex = sindex_to_uindex(index, array.len());
                         if uindex >= array.len() {
-                            array.resize(
-                                (uindex + 1) as usize,
-                                Value::new(None, ValueKind::Nil),
-                            );
+                            array.resize((uindex + 1) as usize, Value::new(None, ValueKind::Nil));
                         }
 
                         array[uindex] = value;
diff --git a/src/path/parser.rs b/src/path/parser.rs
index d783f3e..7a40cb5 100644
--- a/src/path/parser.rs
+++ b/src/path/parser.rs
@@ -1,49 +1,49 @@
 use super::Expression;
 use nom::{
-  IResult, Err,
-  error::ErrorKind,
-  bytes::complete::{is_a, tag},
-  character::complete::{char, digit1, space0},
-  sequence::{delimited, pair, preceded},
-  branch::alt,
-  combinator::{map, map_res, opt, recognize},
+    branch::alt,
+    bytes::complete::{is_a, tag},
+    character::complete::{char, digit1, space0},
+    combinator::{map, map_res, opt, recognize},
+    error::ErrorKind,
+    sequence::{delimited, pair, preceded},
+    Err, IResult,
 };
 use std::str::{from_utf8, FromStr};
 
 fn raw_ident(i: &str) -> IResult<&str, String> {
-  map(is_a(
-        "abcdefghijklmnopqrstuvwxyz \
+    map(
+        is_a(
+            "abcdefghijklmnopqrstuvwxyz \
          ABCDEFGHIJKLMNOPQRSTUVWXYZ \
          0123456789 \
-         _-"
-  ), |s:&str| s.to_string())(i)
+         _-",
+        ),
+        |s: &str| s.to_string(),
+    )(i)
 }
 
 fn integer(i: &str) -> IResult<&str, isize> {
-  map_res(
-    delimited(
-      space0,
-      recognize(pair(opt(tag("-")), digit1)),
-      space0
-    ),
-    FromStr::from_str
-  )(i)
+    map_res(
+        delimited(space0, recognize(pair(opt(tag("-")), digit1)), space0),
+        FromStr::from_str,
+    )(i)
 }
 
 fn ident(i: &str) -> IResult<&str, Expression> {
-  map(raw_ident, Expression::Identifier)(i)
+    map(raw_ident, Expression::Identifier)(i)
 }
 
 fn postfix<'a>(expr: Expression) -> impl Fn(&'a str) -> IResult<&'a str, Expression> {
-  let e2 = expr.clone();
-  let child = map(preceded(tag("."), raw_ident), move |id| Expression::Child(Box::new(expr.clone()), id));
+    let e2 = expr.clone();
+    let child = map(preceded(tag("."), raw_ident), move |id| {
+        Expression::Child(Box::new(expr.clone()), id)
+    });
 
-  let subscript = map(delimited(char('['), integer, char(']')), move |num| Expression::Subscript(Box::new(e2.clone()), num));
+    let subscript = map(delimited(char('['), integer, char(']')), move |num| {
+        Expression::Subscript(Box::new(e2.clone()), num)
+    });
 
-  alt((
-    child,
-    subscript
-  ))
+    alt((child, subscript))
 }
 
 pub fn from_str(input: &str) -> Result<Expression, ErrorKind> {
@@ -72,10 +72,10 @@ pub fn from_str(input: &str) -> Result<Expression, ErrorKind> {
 }
 
 pub fn to_error_kind(e: Err<(&str, ErrorKind)>) -> ErrorKind {
-  match e {
-    Err::Incomplete(_) => ErrorKind::Complete,
-    Err::Failure((_, e)) | Err::Error((_, e)) => e,
-  }
+    match e {
+        Err::Incomplete(_) => ErrorKind::Complete,
+        Err::Failure((_, e)) | Err::Error((_, e)) => e,
+    }
 }
 
 #[cfg(test)]
diff --git a/src/ser.rs b/src/ser.rs
index c3b93d6..39c02b9 100644
--- a/src/ser.rs
+++ b/src/ser.rs
@@ -48,10 +48,9 @@ impl ConfigSerializer {
             self.keys
                 .get_mut(len - 1)
                 .map(|pair| pair.1 = pair.1.map(|i| i + 1).or(Some(0)))
-                .ok_or_else(|| ConfigError::Message(format!(
-                    "last key is not found in {} keys",
-                    len
-                )))
+                .ok_or_else(|| {
+                    ConfigError::Message(format!("last key is not found in {} keys", len))
+                })
         } else {
             Err(ConfigError::Message("keys is empty".to_string()))
         }
diff --git a/tests/errors.rs b/tests/errors.rs
index 3a626c7..e59608e 100644
--- a/tests/errors.rs
+++ b/tests/errors.rs
@@ -21,12 +21,15 @@ fn test_error_parse() {
     let mut c = Config::default();
     let res = c.merge(File::new("tests/Settings-invalid", FileFormat::Toml));
 
-    let path : PathBuf = ["tests", "Settings-invalid.toml"].iter().collect();
+    let path: PathBuf = ["tests", "Settings-invalid.toml"].iter().collect();
 
     assert!(res.is_err());
     assert_eq!(
         res.unwrap_err().to_string(),
-        format!("failed to parse datetime for key `error` at line 2 column 9 in {}", path.display())
+        format!(
+            "failed to parse datetime for key `error` at line 2 column 9 in {}",
+            path.display()
+        )
     );
 }
 
@@ -36,12 +39,15 @@ fn test_error_type() {
 
     let res = c.get::<bool>("boolean_s_parse");
 
-    let path : PathBuf = ["tests", "Settings.toml"].iter().collect();
+    let path: PathBuf = ["tests", "Settings.toml"].iter().collect();
 
     assert!(res.is_err());
     assert_eq!(
         res.unwrap_err().to_string(),
-        format!("invalid type: string \"fals\", expected a boolean for key `boolean_s_parse` in {}", path.display())
+        format!(
+            "invalid type: string \"fals\", expected a boolean for key `boolean_s_parse` in {}",
+            path.display()
+        )
     );
 }
 
@@ -83,11 +89,14 @@ fn test_error_enum_de() {
         "value of enum Diode should be represented by either string or table with exactly one key"
     );
 
-
-    let confused_v: Value =
-    [("Brightness".to_string(), 100.into()),
-     ("Blinking".to_string(), vec![300, 700].into())]
-    .iter().cloned().collect::<std::collections::HashMap<String, Value>>().into();
+    let confused_v: Value = [
+        ("Brightness".to_string(), 100.into()),
+        ("Blinking".to_string(), vec![300, 700].into()),
+    ]
+    .iter()
+    .cloned()
+    .collect::<std::collections::HashMap<String, Value>>()
+    .into();
     let confused_d = confused_v.try_into::<Diode>();
     assert_eq!(
         confused_d.unwrap_err().to_string(),
@@ -114,7 +123,10 @@ inner:
     let mut cfg = Config::new();
     cfg.merge(File::from_str(CFG, FileFormat::Yaml)).unwrap();
     let e = cfg.try_into::<Outer>().unwrap_err();
-    if let ConfigError::Type { key: Some(path), .. } = e {
+    if let ConfigError::Type {
+        key: Some(path), ..
+    } = e
+    {
         assert_eq!(path, "inner.test");
     } else {
         panic!("Wrong error {:?}", e);
diff --git a/tests/file_hjson.rs b/tests/file_hjson.rs
index 70d7ca0..87318eb 100644
--- a/tests/file_hjson.rs
+++ b/tests/file_hjson.rs
@@ -70,7 +70,7 @@ fn test_error_parse() {
     let mut c = Config::default();
     let res = c.merge(File::new("tests/Settings-invalid", FileFormat::Hjson));
 
-    let path : PathBuf = ["tests", "Settings-invalid.hjson"].iter().collect();
+    let path: PathBuf = ["tests", "Settings-invalid.hjson"].iter().collect();
 
     assert!(res.is_err());
     assert_eq!(
diff --git a/tests/file_ini.rs b/tests/file_ini.rs
index 0b7b6a0..088eb2c 100644
--- a/tests/file_ini.rs
+++ b/tests/file_ini.rs
@@ -58,11 +58,14 @@ fn test_error_parse() {
     let mut c = Config::default();
     let res = c.merge(File::new("tests/Settings-invalid", FileFormat::Ini));
 
-    let path : PathBuf = ["tests", "Settings-invalid.ini"].iter().collect();
+    let path: PathBuf = ["tests", "Settings-invalid.ini"].iter().collect();
 
     assert!(res.is_err());
     assert_eq!(
         res.unwrap_err().to_string(),
-        format!(r#"2:0 Expecting "[Some('='), Some(':')]" but found EOF. in {}"#, path.display())
+        format!(
+            r#"2:0 Expecting "[Some('='), Some(':')]" but found EOF. in {}"#,
+            path.display()
+        )
     );
 }
diff --git a/tests/file_json.rs b/tests/file_json.rs
index 09c42bb..307312e 100644
--- a/tests/file_json.rs
+++ b/tests/file_json.rs
@@ -70,11 +70,14 @@ fn test_error_parse() {
     let mut c = Config::default();
     let res = c.merge(File::new("tests/Settings-invalid", FileFormat::Json));
 
-    let path_with_extension : PathBuf = ["tests", "Settings-invalid.json"].iter().collect();
+    let path_with_extension: PathBuf = ["tests", "Settings-invalid.json"].iter().collect();
 
     assert!(res.is_err());
     assert_eq!(
         res.unwrap_err().to_string(),
-        format!("expected `:` at line 4 column 1 in {}", path_with_extension.display())
+        format!(
+            "expected `:` at line 4 column 1 in {}",
+            path_with_extension.display()
+        )
     );
 }
diff --git a/tests/file_toml.rs b/tests/file_toml.rs
index 4d2015e..b964586 100644
--- a/tests/file_toml.rs
+++ b/tests/file_toml.rs
@@ -80,11 +80,14 @@ fn test_error_parse() {
     let mut c = Config::default();
     let res = c.merge(File::new("tests/Settings-invalid", FileFormat::Toml));
 
-    let path_with_extension : PathBuf = ["tests", "Settings-invalid.toml"].iter().collect();
+    let path_with_extension: PathBuf = ["tests", "Settings-invalid.toml"].iter().collect();
 
     assert!(res.is_err());
     assert_eq!(
         res.unwrap_err().to_string(),
-        format!("failed to parse datetime for key `error` at line 2 column 9 in {}", path_with_extension.display())
+        format!(
+            "failed to parse datetime for key `error` at line 2 column 9 in {}",
+            path_with_extension.display()
+        )
     );
 }
diff --git a/tests/file_yaml.rs b/tests/file_yaml.rs
index 8f7814e..59174e6 100644
--- a/tests/file_yaml.rs
+++ b/tests/file_yaml.rs
@@ -70,12 +70,15 @@ fn test_error_parse() {
     let mut c = Config::default();
     let res = c.merge(File::new("tests/Settings-invalid", FileFormat::Yaml));
 
-    let path_with_extension : PathBuf = ["tests", "Settings-invalid.yaml"].iter().collect();
+    let path_with_extension: PathBuf = ["tests", "Settings-invalid.yaml"].iter().collect();
 
     assert!(res.is_err());
     assert_eq!(
         res.unwrap_err().to_string(),
-        format!("while parsing a block mapping, did not find expected key at \
-         line 2 column 1 in {}", path_with_extension.display())
+        format!(
+            "while parsing a block mapping, did not find expected key at \
+         line 2 column 1 in {}",
+            path_with_extension.display()
+        )
     );
 }
diff --git a/tests/get.rs b/tests/get.rs
index 64196e5..10ec066 100644
--- a/tests/get.rs
+++ b/tests/get.rs
@@ -224,7 +224,13 @@ fn test_enum() {
     assert_eq!(s.diodes["green"], Diode::Off);
     assert_eq!(s.diodes["red"], Diode::Brightness(100));
     assert_eq!(s.diodes["blue"], Diode::Blinking(300, 700));
-    assert_eq!(s.diodes["white"], Diode::Pattern{name: "christmas".into(), inifinite: true,});
+    assert_eq!(
+        s.diodes["white"],
+        Diode::Pattern {
+            name: "christmas".into(),
+            inifinite: true,
+        }
+    );
 }
 
 #[test]