cargo fmt

Author: dead10ck

examples/all.rs

@@ -2,12 +2,12 @@
 extern crate error_chain;
 
 pub mod inner {
-    error_chain! {}
+    error_chain!{}
 }
 
 #[cfg(feature = "a_feature")]
 pub mod feature {
-    error_chain! {}
+    error_chain!{}
 }
 
 error_chain! {

examples/chain_err.rs

@@ -9,7 +9,7 @@ use std::fs::File;
 mod errors {
     use std::io;
     use super::LaunchStage;
-    
+
     error_chain! {
         foreign_links {
             Io(io::Error) #[doc = "Error during IO"];
@@ -27,7 +27,7 @@ mod errors {
             }
         }
     }
-    
+
     impl From<LaunchStage> for ErrorKind {
         fn from(v: LaunchStage) -> Self {
             ErrorKind::Launch(v)
@@ -54,14 +54,16 @@ fn load_config(rel_path: &str) -> Result<()> {
 /// Launch the service.
 fn launch(rel_path: &str) -> Result<()> {
     load_config(rel_path).map_err(|e| match e {
-        e @ Error(ErrorKind::ConfigLoad(_), _) => e.chain_err(|| LaunchStage::ConfigLoad),
-        e => e.chain_err(|| "Unknown failure")
-    })
+                                      e @ Error(ErrorKind::ConfigLoad(_), _) => {
+                                          e.chain_err(|| LaunchStage::ConfigLoad)
+                                      }
+                                      e => e.chain_err(|| "Unknown failure"),
+                                  })
 }
 
 fn main() {
     let chain = launch("does_not_exist.json").unwrap_err();
     for err in chain.iter() {
         println!("{}", err);
     }
-}
+}

examples/doc.rs

@@ -7,8 +7,7 @@ extern crate error_chain;
 
 /// Inner module.
 pub mod inner {
-    error_chain! {
-    }
+    error_chain!{}
 }
 
 error_chain! {

examples/quickstart.rs

@@ -14,7 +14,7 @@ extern crate error_chain;
 // `error_chain!` creates.
 mod errors {
     // Create the Error, ErrorKind, ResultExt, and Result types
-    error_chain! { }
+    error_chain!{}
 }
 
 // This only gives access within this module. Make this `pub use errors::*;`
@@ -24,7 +24,7 @@ use errors::*;
 
 fn main() {
     if let Err(ref e) = run() {
-        use ::std::io::Write;
+        use std::io::Write;
         let stderr = &mut ::std::io::stderr();
         let errmsg = "Error writing to stderr";
 

examples/size.rs

@@ -32,9 +32,7 @@ fn main() {
     }
     #[cfg(not(feature = "backtrace"))]
     {
-        let state = error_chain::State {
-            next_error: None,
-        };
+        let state = error_chain::State { next_error: None };
         println!("      State.next_error: {}", size_of_val(&state.next_error));
     }
 }

src/example_generated.rs

@@ -21,7 +21,7 @@
 
 /// Another code generated by the macro.
 pub mod inner {
-    error_chain! {}
+    error_chain!{}
 }
 
 error_chain! {

src/lib.rs

@@ -259,7 +259,7 @@
 //! ## Chaining errors
 //! error-chain supports extending an error chain by appending new errors.
 //! This can be done on a Result or on an existing Error.
-//! 
+//!
 //! To extend the error chain:
 //!
 //! ```
@@ -281,9 +281,9 @@
 //! boxes the original error to store as the cause, then returns a new
 //! error containing the original error.
 //!
-//! Calling `chain_err` on an existing `Error` instance has the same 
+//! Calling `chain_err` on an existing `Error` instance has the same
 //! signature and produces the same outcome as being called on a `Result`
-//! matching the properties described above. This is most useful when 
+//! matching the properties described above. This is most useful when
 //! partially handling errors using the `map_err` function.
 //!
 //! To chain an error directly, use `with_chain`:

src/quick_main.rs

@@ -65,9 +65,13 @@ pub trait ExitCode {
 }
 
 impl ExitCode for i32 {
-    fn code(self) -> i32 { self }
+    fn code(self) -> i32 {
+        self
+    }
 }
 
 impl ExitCode for () {
-    fn code(self) -> i32 { 0 }
+    fn code(self) -> i32 {
+        0
+    }
 }

tests/quick_main.rs

@@ -24,7 +24,5 @@ mod i32 {
 
 mod closure {
     use super::*;
-    quick_main!(|| -> Result<()> {
-        Ok(())
-    });
+    quick_main!(|| -> Result<()> { Ok(()) });
 }

tests/tests.rs

@@ -197,7 +197,7 @@ fn order_test_8() {
 
 #[test]
 fn empty() {
-    error_chain! { };
+    error_chain!{};
 }
 
 #[test]
@@ -251,7 +251,7 @@ fn chain_err() {
     let _: Result<()> = Err(Error::from_kind(ErrorKind::Test)).chain_err(|| "");
 }
 
-/// Verify that an error chain is extended one by `Error::chain_err`, with 
+/// Verify that an error chain is extended one by `Error::chain_err`, with
 /// the new error added to the end.
 #[test]
 fn error_chain_err() {
@@ -260,10 +260,10 @@ fn error_chain_err() {
             Test
         }
     }
-    
+
     let base = Error::from(ErrorKind::Test);
     let ext = base.chain_err(|| "Test passes");
-    
+
     if let Error(ErrorKind::Msg(_), _) = ext {
         // pass
     } else {
@@ -274,7 +274,7 @@ fn error_chain_err() {
 #[test]
 fn links() {
     mod test {
-        error_chain! {}
+        error_chain!{}
     }
 
     error_chain! {
@@ -293,15 +293,17 @@ mod foreign_link_test {
     // signature of the public foreign_link_error_path
     #[derive(Debug)]
     pub struct ForeignError {
-        cause: ForeignErrorCause
+        cause: ForeignErrorCause,
     }
 
     impl ::std::error::Error for ForeignError {
         fn description(&self) -> &'static str {
             "Foreign error description"
         }
 
-        fn cause(&self) -> Option<&::std::error::Error> { Some(&self.cause) }
+        fn cause(&self) -> Option<&::std::error::Error> {
+            Some(&self.cause)
+        }
     }
 
     impl fmt::Display for ForeignError {
@@ -318,7 +320,9 @@ mod foreign_link_test {
             "Foreign error cause description"
         }
 
-        fn cause(&self) -> Option<&::std::error::Error> { None }
+        fn cause(&self) -> Option<&::std::error::Error> {
+            None
+        }
     }
 
     impl fmt::Display for ForeignErrorCause {
@@ -342,43 +346,31 @@ mod foreign_link_test {
     #[test]
     fn display_underlying_error() {
         let chained_error = try_foreign_error().err().unwrap();
-        assert_eq!(
-            format!("{}", ForeignError{ cause: ForeignErrorCause{} }),
-            format!("{}", chained_error)
-        );
+        assert_eq!(format!("{}", ForeignError { cause: ForeignErrorCause {} }),
+                   format!("{}", chained_error));
     }
 
     #[test]
     fn finds_cause() {
         let chained_error = try_foreign_error().err().unwrap();
-        assert_eq!(
-            format!("{}", ForeignErrorCause{}),
-            format!("{}", ::std::error::Error::cause(&chained_error).unwrap())
-        );
+        assert_eq!(format!("{}", ForeignErrorCause {}),
+                   format!("{}", ::std::error::Error::cause(&chained_error).unwrap()));
     }
 
     #[test]
     fn iterates() {
         let chained_error = try_foreign_error().err().unwrap();
         let mut error_iter = chained_error.iter();
-        assert_eq!(
-            format!("{}", ForeignError{ cause: ForeignErrorCause{} }),
-            format!("{}", error_iter.next().unwrap())
-        );
-        assert_eq!(
-            format!("{}", ForeignErrorCause{}),
-            format!("{}", error_iter.next().unwrap())
-        );
-        assert_eq!(
-            format!("{:?}", None as Option<&::std::error::Error>),
-            format!("{:?}", error_iter.next())
-        );
+        assert_eq!(format!("{}", ForeignError { cause: ForeignErrorCause {} }),
+                   format!("{}", error_iter.next().unwrap()));
+        assert_eq!(format!("{}", ForeignErrorCause {}),
+                   format!("{}", error_iter.next().unwrap()));
+        assert_eq!(format!("{:?}", None as Option<&::std::error::Error>),
+                   format!("{:?}", error_iter.next()));
     }
 
     fn try_foreign_error() -> Result<()> {
-        try!(Err(ForeignError{
-            cause: ForeignErrorCause{}
-        }));
+        try!(Err(ForeignError { cause: ForeignErrorCause {} }));
         Ok(())
     }
 }
@@ -390,9 +382,7 @@ mod attributes_test {
 
     #[cfg(not(test))]
     mod inner {
-        error_chain! {
-
-        }
+        error_chain!{}
     }
 
     error_chain! {
@@ -440,7 +430,7 @@ fn without_result() {
 #[test]
 fn documentation() {
     mod inner {
-        error_chain! {}
+        error_chain!{}
     }
 
     error_chain! {
@@ -464,13 +454,13 @@ mod multiple_error_same_mod {
             MyError, MyErrorKind, MyResultExt, MyResult;
         }
     }
-    error_chain! {}
+    error_chain!{}
 }
 
 #[doc(test)]
 #[deny(dead_code)]
 mod allow_dead_code {
-    error_chain! {}
+    error_chain!{}
 }
 
 // Make sure links actually work!
@@ -503,8 +493,7 @@ fn error_patterns() {
 
     // Tuples look nice when matching errors
     match Error::from("Test") {
-        Error(ErrorKind::Msg(_), _) => {
-        }
+        Error(ErrorKind::Msg(_), _) => {}
     }
 }
 
@@ -607,10 +596,8 @@ fn rewrapping() {
         NotUnicode(_) => Err(e).chain_err(|| "env var was bork文字化ã"),
     });
 
-    assert_eq!(
-        format!("{}", our_error_a.unwrap_err()),
-        format!("{}", our_error_b.unwrap_err())
-    );
+    assert_eq!(format!("{}", our_error_a.unwrap_err()),
+               format!("{}", our_error_b.unwrap_err()));
 
 }