From cbb9ef88ea6f6452614dd8bbffce7203b1358a55 Mon Sep 17 00:00:00 2001
From: Ryan Leckey <leckey.ryan@gmail.com>
Date: Mon, 2 Jul 2018 15:33:38 -0700
Subject: Run rustfmt (nightly)

---
 src/ser.rs | 235 ++++++++++++++++++++++++++++++++++++++++++-------------------
 1 file changed, 161 insertions(+), 74 deletions(-)

(limited to 'src/ser.rs')

diff --git a/src/ser.rs b/src/ser.rs
index 0366472..32b99ac 100644
--- a/src/ser.rs
+++ b/src/ser.rs
@@ -1,10 +1,10 @@
-use std::mem;
-use std::fmt::Display;
 use serde::ser;
+use std::fmt::Display;
+use std::mem;
 
-use Config;
-use value::{Value, ValueKind, ValueWithKey};
 use error::*;
+use value::{Value, ValueKind, ValueWithKey};
+use Config;
 
 #[derive(Default, Debug)]
 pub struct ConfigSerializer {
@@ -14,12 +14,18 @@ pub struct ConfigSerializer {
 
 impl ConfigSerializer {
     fn serialize_primitive<T>(&mut self, value: T) -> Result<()>
-        where T: Into<Value> + Display
+    where
+        T: Into<Value> + Display,
     {
         let key = match self.last_key_index_pair() {
             Some((key, Some(index))) => format!("{}[{}]", key, index),
             Some((key, None)) => key.to_string(),
-            None => return Err(ConfigError::Message(format!("key is not found for value {}", value)))
+            None => {
+                return Err(ConfigError::Message(format!(
+                    "key is not found for value {}",
+                    value
+                )))
+            }
         };
         self.output.set(&key, value.into())?;
         Ok(())
@@ -28,7 +34,8 @@ impl ConfigSerializer {
     fn last_key_index_pair(&self) -> Option<(&str, Option<usize>)> {
         let len = self.keys.len();
         if len > 0 {
-            self.keys.get(len - 1)
+            self.keys
+                .get(len - 1)
                 .map(|&(ref key, opt)| (key.as_str(), opt))
         } else {
             None
@@ -38,13 +45,13 @@ impl ConfigSerializer {
     fn inc_last_key_index(&mut self) -> Result<()> {
         let len = self.keys.len();
         if len > 0 {
-            self.keys.get_mut(len - 1)
-                .map(|pair| {
-                    pair.1 = pair.1.map(|i| i + 1).or(Some(0))
-                })
-                .ok_or(ConfigError::Message(
-                    format!("last key is not found in {} keys", len)
-                ))
+            self.keys
+                .get_mut(len - 1)
+                .map(|pair| pair.1 = pair.1.map(|i| i + 1).or(Some(0)))
+                .ok_or(ConfigError::Message(format!(
+                    "last key is not found in {} keys",
+                    len
+                )))
         } else {
             Err(ConfigError::Message("keys is empty".to_string()))
         }
@@ -58,7 +65,7 @@ impl ConfigSerializer {
                     format!("{}[{}].{}", prev_key, index, key)
                 } else {
                     format!("{}.{}", prev_key, key)
-                }
+                };
             }
         }
         key.to_string()
@@ -119,9 +126,11 @@ impl<'a> ser::Serializer for &'a mut ConfigSerializer {
 
     fn serialize_u64(self, v: u64) -> Result<Self::Ok> {
         if v > (i64::max_value() as u64) {
-            Err(ConfigError::Message(
-                format!("value {} is greater than the max {}", v, i64::max_value())
-            ))
+            Err(ConfigError::Message(format!(
+                "value {} is greater than the max {}",
+                v,
+                i64::max_value()
+            )))
         } else {
             self.serialize_i64(v as i64)
         }
@@ -157,7 +166,8 @@ impl<'a> ser::Serializer for &'a mut ConfigSerializer {
     }
 
     fn serialize_some<T>(self, value: &T) -> Result<Self::Ok>
-        where T: ?Sized + ser::Serialize
+    where
+        T: ?Sized + ser::Serialize,
     {
         value.serialize(self)
     }
@@ -170,21 +180,31 @@ impl<'a> ser::Serializer for &'a mut ConfigSerializer {
         self.serialize_unit()
     }
 
-    fn serialize_unit_variant(self, _name: &'static str, _variant_index: u32, variant: &'static str)
-        -> Result<Self::Ok>
-    {
+    fn serialize_unit_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        variant: &'static str,
+    ) -> Result<Self::Ok> {
         self.serialize_str(&variant.to_lowercase())
     }
 
     fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<Self::Ok>
-        where T: ?Sized + ser::Serialize
+    where
+        T: ?Sized + ser::Serialize,
     {
         value.serialize(self)
     }
 
-    fn serialize_newtype_variant<T>(self, _name: &'static str, _variant_index: u32, variant: &'static str, value: &T)
-        -> Result<Self::Ok>
-        where T: ?Sized + ser::Serialize
+    fn serialize_newtype_variant<T>(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        variant: &'static str,
+        value: &T,
+    ) -> Result<Self::Ok>
+    where
+        T: ?Sized + ser::Serialize,
     {
         self.push_key(&variant.to_lowercase());
         value.serialize(&mut *self)?;
@@ -200,15 +220,21 @@ impl<'a> ser::Serializer for &'a mut ConfigSerializer {
         self.serialize_seq(Some(len))
     }
 
-    fn serialize_tuple_struct(self, _name: &'static str, len: usize)
-        -> Result<Self::SerializeTupleStruct>
-    {
+    fn serialize_tuple_struct(
+        self,
+        _name: &'static str,
+        len: usize,
+    ) -> Result<Self::SerializeTupleStruct> {
         self.serialize_seq(Some(len))
     }
 
-    fn serialize_tuple_variant(self, name: &'static str, _variant_index: u32, variant: &'static str, _len: usize)
-        -> Result<Self::SerializeTupleVariant>
-    {
+    fn serialize_tuple_variant(
+        self,
+        name: &'static str,
+        _variant_index: u32,
+        variant: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeTupleVariant> {
         self.push_key(&variant.to_lowercase());
         Ok(self)
     }
@@ -221,9 +247,13 @@ impl<'a> ser::Serializer for &'a mut ConfigSerializer {
         self.serialize_map(Some(len))
     }
 
-    fn serialize_struct_variant(self, _name: &'static str, _variant_index: u32, variant: &'static str, len: usize)
-        -> Result<Self::SerializeStructVariant>
-    {
+    fn serialize_struct_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        variant: &'static str,
+        len: usize,
+    ) -> Result<Self::SerializeStructVariant> {
         self.push_key(&variant.to_lowercase());
         Ok(self)
     }
@@ -234,7 +264,8 @@ impl<'a> ser::SerializeSeq for &'a mut ConfigSerializer {
     type Error = ConfigError;
 
     fn serialize_element<T>(&mut self, value: &T) -> Result<()>
-        where T: ?Sized + ser::Serialize
+    where
+        T: ?Sized + ser::Serialize,
     {
         self.inc_last_key_index()?;
         value.serialize(&mut **self)?;
@@ -251,7 +282,8 @@ impl<'a> ser::SerializeTuple for &'a mut ConfigSerializer {
     type Error = ConfigError;
 
     fn serialize_element<T>(&mut self, value: &T) -> Result<()>
-        where T: ?Sized + ser::Serialize
+    where
+        T: ?Sized + ser::Serialize,
     {
         self.inc_last_key_index()?;
         value.serialize(&mut **self)?;
@@ -268,7 +300,8 @@ impl<'a> ser::SerializeTupleStruct for &'a mut ConfigSerializer {
     type Error = ConfigError;
 
     fn serialize_field<T>(&mut self, value: &T) -> Result<()>
-        where T: ?Sized + ser::Serialize
+    where
+        T: ?Sized + ser::Serialize,
     {
         self.inc_last_key_index()?;
         value.serialize(&mut **self)?;
@@ -285,7 +318,8 @@ impl<'a> ser::SerializeTupleVariant for &'a mut ConfigSerializer {
     type Error = ConfigError;
 
     fn serialize_field<T>(&mut self, value: &T) -> Result<()>
-        where T: ?Sized + ser::Serialize
+    where
+        T: ?Sized + ser::Serialize,
     {
         self.inc_last_key_index()?;
         value.serialize(&mut **self)?;
@@ -303,7 +337,8 @@ impl<'a> ser::SerializeMap for &'a mut ConfigSerializer {
     type Error = ConfigError;
 
     fn serialize_key<T>(&mut self, key: &T) -> Result<()>
-        where T: ?Sized + ser::Serialize
+    where
+        T: ?Sized + ser::Serialize,
     {
         let key_serializer = StringKeySerializer;
         let key = key.serialize(key_serializer)?;
@@ -312,7 +347,8 @@ impl<'a> ser::SerializeMap for &'a mut ConfigSerializer {
     }
 
     fn serialize_value<T>(&mut self, value: &T) -> Result<()>
-        where T: ?Sized + ser::Serialize
+    where
+        T: ?Sized + ser::Serialize,
     {
         value.serialize(&mut **self)?;
         self.pop_key();
@@ -329,7 +365,8 @@ impl<'a> ser::SerializeStruct for &'a mut ConfigSerializer {
     type Error = ConfigError;
 
     fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
-        where T: ?Sized + ser::Serialize
+    where
+        T: ?Sized + ser::Serialize,
     {
         self.push_key(key);
         value.serialize(&mut **self)?;
@@ -347,7 +384,8 @@ impl<'a> ser::SerializeStructVariant for &'a mut ConfigSerializer {
     type Error = ConfigError;
 
     fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
-        where T: ?Sized + ser::Serialize
+    where
+        T: ?Sized + ser::Serialize,
     {
         self.push_key(key);
         value.serialize(&mut **self)?;
@@ -435,7 +473,8 @@ impl ser::Serializer for StringKeySerializer {
     }
 
     fn serialize_some<T>(self, value: &T) -> Result<Self::Ok>
-        where T: ?Sized + ser::Serialize
+    where
+        T: ?Sized + ser::Serialize,
     {
         value.serialize(self)
     }
@@ -448,63 +487,101 @@ impl ser::Serializer for StringKeySerializer {
         self.serialize_unit()
     }
 
-    fn serialize_unit_variant(self, _name: &str, _variant_index: u32, variant: &str) -> Result<Self::Ok> {
+    fn serialize_unit_variant(
+        self,
+        _name: &str,
+        _variant_index: u32,
+        variant: &str,
+    ) -> Result<Self::Ok> {
         Ok(variant.to_lowercase())
     }
 
     fn serialize_newtype_struct<T>(self, _name: &str, value: &T) -> Result<Self::Ok>
-        where T: ?Sized + ser::Serialize
+    where
+        T: ?Sized + ser::Serialize,
     {
         value.serialize(self)
     }
 
-    fn serialize_newtype_variant<T>(self, _name: &str, _variant_index: u32, _variant: &str, value: &T)
-        -> Result<Self::Ok>
-        where T: ?Sized + ser::Serialize
+    fn serialize_newtype_variant<T>(
+        self,
+        _name: &str,
+        _variant_index: u32,
+        _variant: &str,
+        value: &T,
+    ) -> Result<Self::Ok>
+    where
+        T: ?Sized + ser::Serialize,
     {
         value.serialize(self)
     }
 
     fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
-        Err(ConfigError::Message("seq can't serialize to string key".to_string()))
+        Err(ConfigError::Message(
+            "seq can't serialize to string key".to_string(),
+        ))
     }
 
     fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
-        Err(ConfigError::Message("tuple can't serialize to string key".to_string()))
+        Err(ConfigError::Message(
+            "tuple can't serialize to string key".to_string(),
+        ))
     }
 
     fn serialize_tuple_struct(self, name: &str, _len: usize) -> Result<Self::SerializeTupleStruct> {
-        Err(ConfigError::Message(format!("tuple struct {} can't serialize to string key", name)))
+        Err(ConfigError::Message(format!(
+            "tuple struct {} can't serialize to string key",
+            name
+        )))
     }
 
-    fn serialize_tuple_variant(self, name: &str, _variant_index: u32, variant: &str, _len: usize)
-        -> Result<Self::SerializeTupleVariant>
-    {
-        Err(ConfigError::Message(format!("tuple variant {}::{} can't serialize to string key", name, variant)))
+    fn serialize_tuple_variant(
+        self,
+        name: &str,
+        _variant_index: u32,
+        variant: &str,
+        _len: usize,
+    ) -> Result<Self::SerializeTupleVariant> {
+        Err(ConfigError::Message(format!(
+            "tuple variant {}::{} can't serialize to string key",
+            name, variant
+        )))
     }
 
     fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
-        Err(ConfigError::Message("map can't serialize to string key".to_string()))
+        Err(ConfigError::Message(
+            "map can't serialize to string key".to_string(),
+        ))
     }
 
     fn serialize_struct(self, name: &str, _len: usize) -> Result<Self::SerializeStruct> {
-        Err(ConfigError::Message(format!("struct {} can't serialize to string key", name)))
-    }
-
-    fn serialize_struct_variant(self, name: &str, _variant_index: u32, variant: &str, _len: usize)
-        -> Result<Self::SerializeStructVariant>
-    {
-        Err(ConfigError::Message(format!("struct variant {}::{} can't serialize to string key", name, variant)))
+        Err(ConfigError::Message(format!(
+            "struct {} can't serialize to string key",
+            name
+        )))
+    }
+
+    fn serialize_struct_variant(
+        self,
+        name: &str,
+        _variant_index: u32,
+        variant: &str,
+        _len: usize,
+    ) -> Result<Self::SerializeStructVariant> {
+        Err(ConfigError::Message(format!(
+            "struct variant {}::{} can't serialize to string key",
+            name, variant
+        )))
     }
 }
 
-
 impl ser::SerializeSeq for StringKeySerializer {
     type Ok = String;
     type Error = ConfigError;
 
     fn serialize_element<T>(&mut self, value: &T) -> Result<()>
-        where T: ?Sized + ser::Serialize
+    where
+        T: ?Sized + ser::Serialize,
     {
         unreachable!()
     }
@@ -519,7 +596,8 @@ impl ser::SerializeTuple for StringKeySerializer {
     type Error = ConfigError;
 
     fn serialize_element<T>(&mut self, value: &T) -> Result<()>
-        where T: ?Sized + ser::Serialize
+    where
+        T: ?Sized + ser::Serialize,
     {
         unreachable!()
     }
@@ -534,7 +612,8 @@ impl ser::SerializeTupleStruct for StringKeySerializer {
     type Error = ConfigError;
 
     fn serialize_field<T>(&mut self, value: &T) -> Result<()>
-        where T: ?Sized + ser::Serialize
+    where
+        T: ?Sized + ser::Serialize,
     {
         unreachable!()
     }
@@ -549,7 +628,8 @@ impl ser::SerializeTupleVariant for StringKeySerializer {
     type Error = ConfigError;
 
     fn serialize_field<T>(&mut self, value: &T) -> Result<()>
-        where T: ?Sized + ser::Serialize
+    where
+        T: ?Sized + ser::Serialize,
     {
         unreachable!()
     }
@@ -564,13 +644,15 @@ impl ser::SerializeMap for StringKeySerializer {
     type Error = ConfigError;
 
     fn serialize_key<T>(&mut self, key: &T) -> Result<()>
-        where T: ?Sized + ser::Serialize
+    where
+        T: ?Sized + ser::Serialize,
     {
         unreachable!()
     }
 
     fn serialize_value<T>(&mut self, value: &T) -> Result<()>
-        where T: ?Sized + ser::Serialize
+    where
+        T: ?Sized + ser::Serialize,
     {
         unreachable!()
     }
@@ -585,7 +667,8 @@ impl ser::SerializeStruct for StringKeySerializer {
     type Error = ConfigError;
 
     fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
-        where T: ?Sized + ser::Serialize
+    where
+        T: ?Sized + ser::Serialize,
     {
         unreachable!()
     }
@@ -600,7 +683,8 @@ impl ser::SerializeStructVariant for StringKeySerializer {
     type Error = ConfigError;
 
     fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
-        where T: ?Sized + ser::Serialize
+    where
+        T: ?Sized + ser::Serialize,
     {
         unreachable!()
     }
@@ -623,7 +707,10 @@ mod test {
             seq: Vec<String>,
         }
 
-        let test = Test { int: 1, seq: vec!["a".to_string(), "b".to_string()] };
+        let test = Test {
+            int: 1,
+            seq: vec!["a".to_string(), "b".to_string()],
+        };
         let config = Config::try_from(&test).unwrap();
 
         let actual: Test = config.try_into().unwrap();
-- 
cgit v1.2.3