From 082fe6f1e3d0d761b7738cc18914809316e7a2cc Mon Sep 17 00:00:00 2001
From: ko1N <ko1N1337@gmail.com>
Date: Fri, 13 Sep 2019 15:21:05 +0200
Subject: [PATCH] auto formatted code with rustfmt

---
 src/app.rs             |  57 ++--
 src/error.rs           |  26 +-
 src/file_assoc.rs      |  60 +++--
 src/main.rs            | 326 ++++++++++++++---------
 src/manifest.rs        | 577 +++++++++++++++++++++++------------------
 src/platform.rs        |  33 ++-
 src/templates.rs       |  72 ++---
 src/util.rs            |  23 +-
 tests/integration.rs   |   9 +-
 tests/tests/expr.rs    |  54 ++--
 tests/tests/script.rs  |  37 ++-
 tests/tests/version.rs |   3 +-
 tests/util/mod.rs      |  19 +-
 13 files changed, 766 insertions(+), 530 deletions(-)

diff --git a/src/app.rs b/src/app.rs
index 50cc7aca..590f229c 100644
--- a/src/app.rs
+++ b/src/app.rs
@@ -1,7 +1,7 @@
 use std::env;
 use std::path::PathBuf;
 
-use clap::{App, Arg, ArgGroup, ArgMatches, SubCommand, AppSettings};
+use clap::{App, AppSettings, Arg, ArgGroup, ArgMatches, SubCommand};
 use dirs;
 
 use crate::templates;
@@ -10,24 +10,24 @@ const NAME: &str = "cargo-eval";
 
 #[inline(always)]
 const fn name() -> &'static str {
-  NAME
+    NAME
 }
 
 #[inline(always)]
 fn subcommand_name() -> &'static str {
-  &name()[6..]
+    &name()[6..]
 }
 
 pub fn data_dir() -> Option<PathBuf> {
-  Some(dirs::data_local_dir()?.join(name()))
+    Some(dirs::data_local_dir()?.join(name()))
 }
 
 pub fn cache_dir() -> Option<PathBuf> {
-  Some(dirs::cache_dir()?.join(name()))
+    Some(dirs::cache_dir()?.join(name()))
 }
 
 fn app() -> App<'static, 'static> {
-  let mut app = SubCommand::with_name(subcommand_name())
+    let mut app = SubCommand::with_name(subcommand_name())
     .version(env!("CARGO_PKG_VERSION"))
     .about("Compiles and runs “Cargoified Rust scripts”.")
     .usage("cargo eval [FLAGS OPTIONS] [--] <script> <args>...")
@@ -152,30 +152,33 @@ fn app() -> App<'static, 'static> {
         .requires("expr")
     );
 
-  #[cfg(windows)] {
-    app = app.subcommand(crate::file_assoc::Args::subcommand())
-  }
+    #[cfg(windows)]
+    {
+        app = app.subcommand(crate::file_assoc::Args::subcommand())
+    }
 
-  app = app.subcommand(templates::Args::subcommand());
+    app = app.subcommand(templates::Args::subcommand());
 
-  app
+    app
 }
 
 pub fn get_matches() -> ArgMatches<'static> {
-  let mut args = env::args().collect::<Vec<_>>();
-
-  let subcommand = app();
-
-  // Insert subcommand argument if called directly.
-  if args.get(1).map(|s| *s == subcommand_name()) != Some(true) {
-    args.insert(1, subcommand_name().into());
-  }
-
-  // We have to wrap our command for the output to look right.
-  App::new("cargo")
-    .bin_name("cargo")
-    .setting(AppSettings::SubcommandRequiredElseHelp)
-    .subcommand(subcommand)
-    .get_matches_from(args)
-    .subcommand_matches(subcommand_name()).unwrap().clone()
+    let mut args = env::args().collect::<Vec<_>>();
+
+    let subcommand = app();
+
+    // Insert subcommand argument if called directly.
+    if args.get(1).map(|s| *s == subcommand_name()) != Some(true) {
+        args.insert(1, subcommand_name().into());
+    }
+
+    // We have to wrap our command for the output to look right.
+    App::new("cargo")
+        .bin_name("cargo")
+        .setting(AppSettings::SubcommandRequiredElseHelp)
+        .subcommand(subcommand)
+        .get_matches_from(args)
+        .subcommand_matches(subcommand_name())
+        .unwrap()
+        .clone()
 }
diff --git a/src/error.rs b/src/error.rs
index 941a14e0..0e3aa855 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -31,7 +31,10 @@ Records who we have chosen to blame for a particular error.
 This is used to distinguish between "report this to a user" and "explode violently".
 */
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub enum Blame { Human, Internal }
+pub enum Blame {
+    Human,
+    Internal,
+}
 
 impl MainError {
     pub fn blame(&self) -> Blame {
@@ -41,7 +44,7 @@ impl MainError {
             | Tag(blame, _, _)
             | Other(blame, _)
             | OtherOwned(blame, _)
-            | OtherBorrowed(blame, _) => blame
+            | OtherBorrowed(blame, _) => blame,
         }
     }
 
@@ -56,8 +59,7 @@ impl MainError {
             | Tag(ref mut cur_blame, _, _)
             | Other(ref mut cur_blame, _)
             | OtherOwned(ref mut cur_blame, _)
-            | OtherBorrowed(ref mut cur_blame, _)
-            => *cur_blame = blame,
+            | OtherBorrowed(ref mut cur_blame, _) => *cur_blame = blame,
         }
     }
 }
@@ -96,7 +98,7 @@ macro_rules! from_impl {
                 $e
             }
         }
-    }
+    };
 }
 
 from_impl! { (Blame, io::Error) => MainError, v -> MainError::Io(v.0, v.1) }
@@ -106,7 +108,10 @@ from_impl! { io::Error => MainError, v -> MainError::Io(Blame::Internal, v) }
 from_impl! { String => MainError, v -> MainError::OtherOwned(Blame::Internal, v) }
 from_impl! { &'static str => MainError, v -> MainError::OtherBorrowed(Blame::Internal, v) }
 
-impl<T> From<Box<T>> for MainError where T: 'static + Error {
+impl<T> From<Box<T>> for MainError
+where
+    T: 'static + Error,
+{
     fn from(src: Box<T>) -> Self {
         MainError::Other(Blame::Internal, src)
     }
@@ -115,7 +120,8 @@ impl<T> From<Box<T>> for MainError where T: 'static + Error {
 pub trait ResultExt {
     type Ok;
     fn err_tag<S>(self, msg: S) -> Result<Self::Ok>
-    where S: Into<Cow<'static, str>>;
+    where
+        S: Into<Cow<'static, str>>;
 
     fn shift_blame(self, blame: Blame) -> Self;
 }
@@ -124,7 +130,9 @@ impl<T> ResultExt for Result<T> {
     type Ok = T;
 
     fn err_tag<S>(self, msg: S) -> Result<T>
-    where S: Into<Cow<'static, str>> {
+    where
+        S: Into<Cow<'static, str>>,
+    {
         match self {
             Ok(v) => Ok(v),
             Err(e) => Err(MainError::Tag(e.blame(), msg.into(), Box::new(e))),
@@ -137,7 +145,7 @@ impl<T> ResultExt for Result<T> {
             Err(mut e) => {
                 e.shift_blame(blame);
                 Err(e)
-            },
+            }
         }
     }
 }
diff --git a/src/file_assoc.rs b/src/file_assoc.rs
index 5df81fb1..baeadb21 100644
--- a/src/file_assoc.rs
+++ b/src/file_assoc.rs
@@ -5,7 +5,7 @@ use std::io;
 
 use clap;
 use itertools::Itertools;
-use winreg::{RegKey, enums as wre};
+use winreg::{enums as wre, RegKey};
 
 use crate::error::{Blame, Result};
 
@@ -36,13 +36,11 @@ impl Args {
 
     pub fn parse(m: &clap::ArgMatches) -> Self {
         match m.subcommand() {
-            ("install", Some(m)) => {
-                Args::Install {
-                    amend_pathext: m.is_present("amend_pathext"),
-                }
+            ("install", Some(m)) => Args::Install {
+                amend_pathext: m.is_present("amend_pathext"),
             },
             ("uninstall", _) => Args::Uninstall,
-            (name, _) => panic!("bad subcommand: {:?}", name)
+            (name, _) => panic!("bad subcommand: {:?}", name),
         }
     }
 }
@@ -88,7 +86,9 @@ fn install(amend_pathext: bool) -> Result<()> {
         Ok(()) => (),
         Err(e) => {
             if e.kind() == io::ErrorKind::PermissionDenied {
-                println!("Access denied.  Make sure you run this command from an administrator prompt.");
+                println!(
+                    "Access denied.  Make sure you run this command from an administrator prompt."
+                );
                 return Err((Blame::Human, e).into());
             } else {
                 return Err(e.into());
@@ -102,7 +102,8 @@ fn install(amend_pathext: bool) -> Result<()> {
     // Amend PATHEXT.
     if amend_pathext {
         let hklm = RegKey::predef(wre::HKEY_LOCAL_MACHINE);
-        let env = hklm.open_subkey(r#"SYSTEM\CurrentControlSet\Control\Session Manager\Environment"#)?;
+        let env =
+            hklm.open_subkey(r#"SYSTEM\CurrentControlSet\Control\Session Manager\Environment"#)?;
 
         let pathext: String = env.get_value("PATHEXT")?;
         if !pathext.split(';').any(|e| e.eq_ignore_ascii_case(".crs")) {
@@ -110,28 +111,37 @@ fn install(amend_pathext: bool) -> Result<()> {
             env.set_value("PATHEXT", &pathext)?;
         }
 
-        println!("Added `.crs` to PATHEXT.  You may need to log out for the change to take effect.");
+        println!(
+            "Added `.crs` to PATHEXT.  You may need to log out for the change to take effect."
+        );
     }
 
     Ok(())
 }
 
 fn uninstall() -> Result<()> {
-  let hlcr = RegKey::predef(wre::HKEY_CLASSES_ROOT);
-  hlcr.delete_subkey(r#"CargoScript.Crs\shell\open\command"#).ignore_missing()?;
-  hlcr.delete_subkey(r#"CargoScript.Crs\shell\open"#).ignore_missing()?;
-  hlcr.delete_subkey(r#"CargoScript.Crs\shell"#).ignore_missing()?;
-  hlcr.delete_subkey(r#"CargoScript.Crs"#).ignore_missing()?;
+    let hlcr = RegKey::predef(wre::HKEY_CLASSES_ROOT);
+    hlcr.delete_subkey(r#"CargoScript.Crs\shell\open\command"#)
+        .ignore_missing()?;
+    hlcr.delete_subkey(r#"CargoScript.Crs\shell\open"#)
+        .ignore_missing()?;
+    hlcr.delete_subkey(r#"CargoScript.Crs\shell"#)
+        .ignore_missing()?;
+    hlcr.delete_subkey(r#"CargoScript.Crs"#).ignore_missing()?;
 
     println!("Deleted cargo-eval registry entry.");
 
     {
         let hklm = RegKey::predef(wre::HKEY_LOCAL_MACHINE);
-        let env = hklm.open_subkey(r#"SYSTEM\CurrentControlSet\Control\Session Manager\Environment"#)?;
+        let env =
+            hklm.open_subkey(r#"SYSTEM\CurrentControlSet\Control\Session Manager\Environment"#)?;
 
         let pathext: String = env.get_value("PATHEXT")?;
         if pathext.split(';').any(|e| e.eq_ignore_ascii_case(".crs")) {
-            let pathext = pathext.split(';').filter(|e| !e.eq_ignore_ascii_case(".crs")).join(";");
+            let pathext = pathext
+                .split(';')
+                .filter(|e| !e.eq_ignore_ascii_case(".crs"))
+                .join(";");
             env.set_value("PATHEXT", &pathext)?;
             println!("Removed `.crs` from PATHEXT.  You may need to log out for the change to take effect.");
         }
@@ -141,17 +151,17 @@ fn uninstall() -> Result<()> {
 }
 
 trait IgnoreMissing {
-  fn ignore_missing(self) -> Self;
+    fn ignore_missing(self) -> Self;
 }
 
 impl IgnoreMissing for io::Result<()> {
-  fn ignore_missing(self) -> Self {
-    if let Err(ref e) = self {
-      if e.kind() == io::ErrorKind::NotFound {
-        return Ok(())
-      }
-    }
+    fn ignore_missing(self) -> Self {
+        if let Err(ref e) = self {
+            if e.kind() == io::ErrorKind::NotFound {
+                return Ok(());
+            }
+        }
 
-    self
-  }
+        self
+    }
 }
diff --git a/src/main.rs b/src/main.rs
index ad84e4f3..4c8eaa3a 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -11,13 +11,16 @@ As such, `cargo-eval` does two major things:
 */
 extern crate clap;
 extern crate env_logger;
-#[macro_use] extern crate lazy_static;
-#[macro_use] extern crate log;
+#[macro_use]
+extern crate lazy_static;
+#[macro_use]
+extern crate log;
 
-use serde::{Serialize, Deserialize};
+use serde::{Deserialize, Serialize};
 
-#[cfg(feature="chan")]
-#[macro_use] extern crate chan;
+#[cfg(feature = "chan")]
+#[macro_use]
+extern crate chan;
 
 /**
 If this is set to `true`, the digests used for package IDs will be replaced with "stub" to make testing a bit easier.  Obviously, you don't want this `true` for release...
@@ -27,16 +30,16 @@ const STUB_HASHES: bool = false;
 /**
 Length of time to suppress Cargo output.
 */
-#[cfg(feature="suppress-cargo-output")]
+#[cfg(feature = "suppress-cargo-output")]
 const CARGO_OUTPUT_TIMEOUT: u64 = 2_000/*ms*/;
 
+mod app;
 mod consts;
 mod error;
 mod manifest;
 mod platform;
 mod templates;
 mod util;
-mod app;
 
 #[cfg(windows)]
 mod file_assoc;
@@ -49,7 +52,7 @@ use std::path::{Path, PathBuf};
 use std::process::{self, Command};
 
 use crate::error::{Blame, MainError, Result};
-use crate::util::{Defer};
+use crate::util::Defer;
 
 #[derive(Debug)]
 enum SubCommand {
@@ -110,14 +113,13 @@ impl BuildKind {
             (false, false) => BuildKind::Normal,
             (true, false) => BuildKind::Test,
             (false, true) => BuildKind::Bench,
-            _ => panic!("got both test and bench")
+            _ => panic!("got both test and bench"),
         }
     }
 }
 
-
 fn parse_args() -> SubCommand {
-  use clap::{value_t, values_t};
+    use clap::{value_t, values_t};
 
     let m = app::get_matches();
 
@@ -125,7 +127,8 @@ fn parse_args() -> SubCommand {
         return self::SubCommand::Templates(templates::Args::parse(m));
     }
 
-    #[cfg(windows)] {
+    #[cfg(windows)]
+    {
         if let Some(m) = m.subcommand_matches("file-association") {
             return self::SubCommand::FileAssoc(file_assoc::Args::parse(m));
         }
@@ -135,7 +138,7 @@ fn parse_args() -> SubCommand {
         v.map(|v| match v {
             "yes" => true,
             "no" => false,
-            _ => unreachable!()
+            _ => unreachable!(),
         })
     }
 
@@ -171,11 +174,11 @@ fn main() {
         Ok(0) => (),
         Ok(code) => {
             std::process::exit(code);
-        },
+        }
         Err(ref err) if err.is_human() => {
             writeln!(stderr, "error: {}", err).unwrap();
             std::process::exit(1);
-        },
+        }
         Err(ref err) => {
             writeln!(stderr, "internal error: {}", err).unwrap();
             std::process::exit(1);
@@ -227,9 +230,10 @@ fn try_main() -> Result<i32> {
     let input = match (&args.script, args.expr, args.loop_) {
         (Some(script), false, false) => {
             let (path, mut file) = find_script(&script)
-              .ok_or_else(|| format!("could not find script '{}'", script))?;
+                .ok_or_else(|| format!("could not find script '{}'", script))?;
 
-            script_name = path.file_stem()
+            script_name = path
+                .file_stem()
                 .map(|os| os.to_string_lossy().into_owned())
                 .unwrap_or_else(|| "unknown".into());
 
@@ -242,15 +246,15 @@ fn try_main() -> Result<i32> {
             content = body;
 
             Input::File(&script_name, &script_path, &content, mtime)
-        },
+        }
         (Some(expr), true, false) => {
             content = expr.clone();
             Input::Expr(&content, args.template.as_ref().map(|s| &**s))
-        },
+        }
         (Some(loop_), false, true) => {
             content = loop_.clone();
             Input::Loop(&content, args.count)
-        },
+        }
         _ => unreachable!(),
     };
     info!("input: {:?}", input);
@@ -263,21 +267,24 @@ fn try_main() -> Result<i32> {
     - Expand `pkg` into `pkg=*`.
     */
     let deps = {
-        use std::collections::HashMap;
         use std::collections::hash_map::Entry::{Occupied, Vacant};
+        use std::collections::HashMap;
 
         let mut deps: HashMap<String, String> = HashMap::new();
         for dep in args.dep.iter().cloned() {
             // Append '=*' if it needs it.
             let dep = match dep.find('=') {
                 Some(_) => dep,
-                None => dep + "=*"
+                None => dep + "=*",
             };
 
             let mut parts = dep.splitn(2, '=');
             let name = parts.next().expect("dependency is missing name");
             let version = parts.next().expect("dependency is missing version");
-            assert!(parts.next().is_none(), "dependency somehow has three parts?!");
+            assert!(
+                parts.next().is_none(),
+                "dependency somehow has three parts?!"
+            );
 
             if name == "" {
                 return Err((Blame::Human, "cannot have empty dependency package name").into());
@@ -290,14 +297,19 @@ fn try_main() -> Result<i32> {
             match deps.entry(name.into()) {
                 Vacant(ve) => {
                     ve.insert(version.into());
-                },
+                }
                 Occupied(oe) => {
                     // This is *only* a problem if the versions don't match.  We won't try to do anything clever in terms of upgrading or resolving or anything... exact match or go home.
                     let existing = oe.get();
                     if version != existing {
-                        return Err((Blame::Human,
-                            format!("conflicting versions for dependency '{}': '{}', '{}'",
-                                name, existing, version)).into());
+                        return Err((
+                            Blame::Human,
+                            format!(
+                                "conflicting versions for dependency '{}': '{}', '{}'",
+                                name, existing, version
+                            ),
+                        )
+                            .into());
                     }
                 }
             }
@@ -314,7 +326,9 @@ fn try_main() -> Result<i32> {
     Generate the prelude items, if we need any.  Again, ensure consistent and *valid* sorting.
     */
     let prelude_items = {
-        let unstable_features = args.unstable_features.iter()
+        let unstable_features = args
+            .unstable_features
+            .iter()
             .map(|uf| format!("#![feature({})]", uf));
 
         let mut items: Vec<_> = unstable_features.collect();
@@ -324,12 +338,7 @@ fn try_main() -> Result<i32> {
     info!("prelude_items: {:?}", prelude_items);
 
     // Work out what to do.
-    let action = decide_action_for(
-        &input,
-        deps,
-        prelude_items,
-        &args,
-    )?;
+    let action = decide_action_for(&input, deps, prelude_items, &args)?;
     info!("action: {:?}", action);
 
     gen_pkg_and_compile(&input, &action)?;
@@ -348,9 +357,14 @@ fn try_main() -> Result<i32> {
 
     // Run it!
     if action.execute {
-        fn hint<F: FnOnce(&mut Command) -> &mut Command>(f: F) -> F { f }
+        fn hint<F: FnOnce(&mut Command) -> &mut Command>(f: F) -> F {
+            f
+        }
         let add_env = hint(move |cmd| {
-            cmd.env("CARGO_EVAL_SCRIPT_PATH", input.path().unwrap_or_else(|| Path::new("")));
+            cmd.env(
+                "CARGO_EVAL_SCRIPT_PATH",
+                input.path().unwrap_or_else(|| Path::new("")),
+            );
             cmd.env("CARGO_EVAL_SAFE_NAME", input.safe_name());
             cmd.env("CARGO_EVAL_PKG_NAME", input.package_name());
             cmd.env("CARGO_EVAL_BASE_PATH", input.base_path());
@@ -364,11 +378,10 @@ fn try_main() -> Result<i32> {
                 let mut cmd = Command::new(exe_path);
                 cmd.args(&args.args);
                 add_env(&mut cmd);
-                cmd.status()
-                    .map(|st| st.code().unwrap_or(1))
+                cmd.status().map(|st| st.code().unwrap_or(1))
             }? {
                 0 => (),
-                n => return Ok(n)
+                n => return Ok(n),
             }
         } else {
             let cmd_name = action.build_kind.exec_command();
@@ -377,7 +390,7 @@ fn try_main() -> Result<i32> {
             add_env(&mut cmd);
             match cmd.status().map(|st| st.code().unwrap_or(1))? {
                 0 => (),
-                n => return Ok(n)
+                n => return Ok(n),
             }
         }
     }
@@ -410,13 +423,15 @@ fn clean_cache(max_age: u128) -> Result<()> {
     let cache_dir = script_cache_path();
 
     if !cache_dir.is_dir() {
-      return Ok(())
+        return Ok(());
     }
 
     for child in fs::read_dir(cache_dir)? {
         let child = child?;
         let path = child.path();
-        if path.is_file() { continue }
+        if path.is_file() {
+            continue;
+        }
 
         info!("checking: {:?}", path);
 
@@ -434,7 +449,7 @@ fn clean_cache(max_age: u128) -> Result<()> {
                     Ok(file) => file,
                     Err(..) => {
                         info!("couldn't open metadata for {:?}", path);
-                        return true
+                        return true;
                     }
                 };
                 platform::file_last_modified(&meta_file)
@@ -460,10 +475,7 @@ Generate and compile a package from the input.
 
 Why take `PackageMetadata`?  To ensure that any information we need to depend on for compilation *first* passes through `decide_action_for` *and* is less likely to not be serialised with the rest of the metadata.
 */
-fn gen_pkg_and_compile(
-    input: &Input,
-    action: &InputAction,
-) -> Result<()> {
+fn gen_pkg_and_compile(input: &Input, action: &InputAction) -> Result<()> {
     let pkg_path = &action.pkg_path;
     let meta = &action.metadata;
     let old_meta = action.old_metadata.as_ref();
@@ -492,7 +504,7 @@ fn gen_pkg_and_compile(
             FileOverwrite::Same => (),
             FileOverwrite::Changed { new_hash } => {
                 meta.manifest_hash = new_hash;
-            },
+            }
         }
         mani_path
     };
@@ -512,7 +524,7 @@ fn gen_pkg_and_compile(
             FileOverwrite::Same => (),
             FileOverwrite::Changed { new_hash } => {
                 meta.script_hash = new_hash;
-            },
+            }
         }
     }
 
@@ -530,40 +542,52 @@ fn gen_pkg_and_compile(
     let mut compile_err = Ok(());
     if action.compile {
         info!("compiling...");
-        let mut cmd = cargo("build", &*mani_path.to_string_lossy(), action.use_bincache, &meta)?;
-
-        #[cfg(feature="suppress-cargo-output")]
+        let mut cmd = cargo(
+            "build",
+            &*mani_path.to_string_lossy(),
+            action.use_bincache,
+            &meta,
+        )?;
+
+        #[cfg(feature = "suppress-cargo-output")]
         macro_rules! get_status {
             ($cmd:expr) => {
-              util::suppress_child_output(
-                &mut $cmd,
-                ::std::time::Duration::from_millis(CARGO_OUTPUT_TIMEOUT)
-              )?.status()
-            }
+                util::suppress_child_output(
+                    &mut $cmd,
+                    ::std::time::Duration::from_millis(CARGO_OUTPUT_TIMEOUT),
+                )?
+                .status()
+            };
         }
 
-        #[cfg(not(feature="suppress-cargo-output"))]
+        #[cfg(not(feature = "suppress-cargo-output"))]
         macro_rules! get_status {
             ($cmd:expr) => {
                 $cmd.status()
-            }
+            };
         }
 
-        compile_err = get_status!(cmd).map_err(Into::<MainError>::into)
-            .and_then(|st|
-                match st.code() {
-                    Some(0) => Ok(()),
-                    Some(st) => Err(format!("cargo failed with status {}", st).into()),
-                    None => Err("cargo failed".into())
-                });
+        compile_err = get_status!(cmd)
+            .map_err(Into::<MainError>::into)
+            .and_then(|st| match st.code() {
+                Some(0) => Ok(()),
+                Some(st) => Err(format!("cargo failed with status {}", st).into()),
+                None => Err("cargo failed".into()),
+            });
 
         // Drop out now if compilation failed.
         if let Err(err) = compile_err {
-          return Err(err)
+            return Err(err);
         }
 
         // Find out and cache what the executable was called.
-        let _ = cargo_target(input, pkg_path, &*mani_path.to_string_lossy(), action.use_bincache, &meta)?;
+        let _ = cargo_target(
+            input,
+            pkg_path,
+            &*mani_path.to_string_lossy(),
+            action.use_bincache,
+            &meta,
+        )?;
 
         if action.use_bincache {
             // Write out the metadata hash to tie this executable to a particular chunk of metadata.  This is to avoid issues with multiple scripts with the same name being compiled to a common target directory.
@@ -643,7 +667,12 @@ impl InputAction {
     }
 
     fn cargo(&self, cmd: &str) -> Result<Command> {
-        cargo(cmd, &*self.manifest_path().to_string_lossy(), self.use_bincache, &self.metadata)
+        cargo(
+            cmd,
+            &*self.manifest_path().to_string_lossy(),
+            self.use_bincache,
+            &self.metadata,
+        )
     }
 }
 
@@ -699,15 +728,17 @@ fn decide_action_for(
     prelude: Vec<String>,
     args: &Args,
 ) -> Result<InputAction> {
-    let (pkg_path, using_cache) = args.pkg_path.as_ref().map(|p| (p.into(), false))
+    let (pkg_path, using_cache) = args
+        .pkg_path
+        .as_ref()
+        .map(|p| (p.into(), false))
         .unwrap_or_else(|| {
             // This can't fail.  Seriously, we're *fucked* if we can't work this out.
             let cache_path = script_cache_path();
             info!("cache_path: {:?}", cache_path);
 
             let id = {
-                let deps_iter = deps.iter()
-                    .map(|&(ref n, ref v)| (n as &str, v as &str));
+                let deps_iter = deps.iter().map(|&(ref n, ref v)| (n as &str, v as &str));
 
                 // Again, also fucked if we can't work this out.
                 input.compute_id(deps_iter).unwrap()
@@ -732,12 +763,11 @@ fn decide_action_for(
     // Construct input metadata.
     let input_meta = {
         let (path, mtime, template) = match *input {
-            Input::File(_, path, _, mtime)
-                => (Some(path.to_string_lossy().into_owned()), Some(mtime), None),
-            Input::Expr(_, template)
-                => (None, None, template),
-            Input::Loop(..)
-                => (None, None, None)
+            Input::File(_, path, _, mtime) => {
+                (Some(path.to_string_lossy().into_owned()), Some(mtime), None)
+            }
+            Input::Expr(_, template) => (None, None, template),
+            Input::Loop(..) => (None, None, None),
         };
         PackageMetadata {
             path,
@@ -856,7 +886,9 @@ Figures out where the output executable for the input should be.
 This *requires* that `cargo_target` has already been called on the package.
 */
 fn get_exe_path<P>(build_kind: BuildKind, pkg_path: P) -> Result<PathBuf>
-where P: AsRef<Path> {
+where
+    P: AsRef<Path>,
+{
     use std::fs::File;
 
     // We don't directly run tests and benchmarks.
@@ -864,7 +896,7 @@ where P: AsRef<Path> {
         BuildKind::Normal => (),
         BuildKind::Test | BuildKind::Bench => {
             return Err("tried to get executable path for test/bench build".into());
-        },
+        }
     }
 
     let package_path = pkg_path.as_ref();
@@ -880,7 +912,9 @@ where P: AsRef<Path> {
 Figures out where the `meta-hash` file should be.
 */
 fn get_meta_hash_path<P>(use_bincache: bool, pkg_path: P) -> Result<PathBuf>
-where P: AsRef<Path> {
+where
+    P: AsRef<Path>,
+{
     if !use_bincache {
         panic!("tried to get meta-hash path when not using binary cache");
     }
@@ -891,7 +925,9 @@ where P: AsRef<Path> {
 Load the package metadata, given the path to the package's cache folder.
 */
 fn get_pkg_metadata<P>(pkg_path: P) -> Result<PackageMetadata>
-where P: AsRef<Path> {
+where
+    P: AsRef<Path>,
+{
     let meta_path = get_pkg_metadata_path(pkg_path);
     debug!("meta_path: {:?}", meta_path);
     let mut meta_file = fs::File::open(&meta_path)?;
@@ -901,8 +937,7 @@ where P: AsRef<Path> {
         meta_file.read_to_string(&mut s).unwrap();
         s
     };
-    let meta: PackageMetadata = serde_json::from_str(&meta_str)
-        .map_err(|err| err.to_string())?;
+    let meta: PackageMetadata = serde_json::from_str(&meta_str).map_err(|err| err.to_string())?;
 
     Ok(meta)
 }
@@ -911,7 +946,9 @@ where P: AsRef<Path> {
 Work out the path to a package's metadata file.
 */
 fn get_pkg_metadata_path<P>(pkg_path: P) -> PathBuf
-where P: AsRef<Path> {
+where
+    P: AsRef<Path>,
+{
     pkg_path.as_ref().join("metadata.json")
 }
 
@@ -919,12 +956,13 @@ where P: AsRef<Path> {
 Save the package metadata, given the path to the package's cache folder.
 */
 fn write_pkg_metadata<P>(pkg_path: P, meta: &PackageMetadata) -> Result<()>
-where P: AsRef<Path> {
+where
+    P: AsRef<Path>,
+{
     let meta_path = get_pkg_metadata_path(pkg_path);
     debug!("meta_path: {:?}", meta_path);
     let mut meta_file = fs::File::create(&meta_path)?;
-    let meta_str = serde_json::to_string(meta)
-        .map_err(|err| err.to_string())?;
+    let meta_str = serde_json::to_string(meta).map_err(|err| err.to_string())?;
     write!(&mut meta_file, "{}", meta_str)?;
     meta_file.flush()?;
     Ok(())
@@ -934,21 +972,23 @@ where P: AsRef<Path> {
 Returns the path to the cache directory.
 */
 fn script_cache_path() -> PathBuf {
-  app::cache_dir().unwrap().join("scripts")
+    app::cache_dir().unwrap().join("scripts")
 }
 
 /**
 Returns the path to the binary cache directory.
 */
 fn binary_cache_path() -> PathBuf {
-  app::cache_dir().unwrap().join("bin")
+    app::cache_dir().unwrap().join("bin")
 }
 
 /**
 Attempts to locate the script specified by the given path.  If the path as-given doesn't yield anything, it will try adding file extensions.
 */
 fn find_script<P>(path: P) -> Option<(PathBuf, fs::File)>
-where P: AsRef<Path> {
+where
+    P: AsRef<Path>,
+{
     let path = path.as_ref();
 
     // Try the path directly.
@@ -1041,15 +1081,10 @@ impl<'a> Input<'a> {
                 (0, '0'..='9') => {
                     r.push('_');
                     r.push(c);
-                },
-                (_, '0'..='9')
-                | (_, 'a'..='z')
-                | (_, 'A'..='Z')
-                | (_, '_')
-                | (_, '-')
-                => {
+                }
+                (_, '0'..='9') | (_, 'a'..='z') | (_, 'A'..='Z') | (_, '_') | (_, '-') => {
                     r.push(c);
-                },
+                }
                 (_, _) => {
                     r.push('_');
                 }
@@ -1064,8 +1099,13 @@ impl<'a> Input<'a> {
     */
     pub fn base_path(&self) -> PathBuf {
         match *self {
-            Input::File(_, path, _, _) => path.parent().expect("couldn't get parent directory for file input base path").into(),
-            Input::Expr(..) | Input::Loop(..) => std::env::current_dir().expect("couldn't get current directory for input base path"),
+            Input::File(_, path, _, _) => path
+                .parent()
+                .expect("couldn't get parent directory for file input base path")
+                .into(),
+            Input::Expr(..) | Input::Loop(..) => {
+                std::env::current_dir().expect("couldn't get current directory for input base path")
+            }
         }
     }
 
@@ -1073,7 +1113,9 @@ impl<'a> Input<'a> {
     Compute the package ID for the input.  This is used as the name of the cache folder into which the Cargo package will be generated.
     */
     pub fn compute_id<'dep, DepIt>(&self, deps: DepIt) -> Result<OsString>
-    where DepIt: IntoIterator<Item=(&'dep str, &'dep str)> {
+    where
+        DepIt: IntoIterator<Item = (&'dep str, &'dep str)>,
+    {
         use shaman::digest::Digest;
         use shaman::sha1::Sha1;
         use Input::*;
@@ -1105,7 +1147,7 @@ impl<'a> Input<'a> {
                 id.push("-");
                 id.push(if STUB_HASHES { "stub" } else { &*digest });
                 Ok(id)
-            },
+            }
             Expr(content, template) => {
                 let mut hasher = hash_deps();
 
@@ -1121,7 +1163,7 @@ impl<'a> Input<'a> {
                 id.push("expr-");
                 id.push(if STUB_HASHES { "stub" } else { &*digest });
                 Ok(id)
-            },
+            }
             Loop(content, count) => {
                 let mut hasher = hash_deps();
 
@@ -1137,7 +1179,7 @@ impl<'a> Input<'a> {
                 id.push("loop-");
                 id.push(if STUB_HASHES { "stub" } else { &*digest });
                 Ok(id)
-            },
+            }
         }
     }
 }
@@ -1162,7 +1204,9 @@ enum FileOverwrite {
 Overwrite a file if and only if the contents have changed.
 */
 fn overwrite_file<P>(path: P, content: &str, hash: Option<&str>) -> Result<FileOverwrite>
-where P: AsRef<Path> {
+where
+    P: AsRef<Path>,
+{
     debug!("overwrite_file({:?}, _, {:?})", path.as_ref(), hash);
     let new_hash = hash_str(content);
     if Some(&*new_hash) == hash {
@@ -1180,10 +1224,14 @@ where P: AsRef<Path> {
 /**
 Constructs a Cargo command that runs on the script package.
 */
-fn cargo(cmd_name: &str, manifest: &str, use_bincache: bool, meta: &PackageMetadata) -> Result<Command> {
+fn cargo(
+    cmd_name: &str,
+    manifest: &str,
+    use_bincache: bool,
+    meta: &PackageMetadata,
+) -> Result<Command> {
     let mut cmd = Command::new("cargo");
-    cmd.arg(cmd_name)
-        .arg("--manifest-path").arg(manifest);
+    cmd.arg(cmd_name).arg("--manifest-path").arg(manifest);
 
     if platform::force_cargo_color() {
         cmd.arg("--color").arg("always");
@@ -1210,9 +1258,22 @@ Tries to find the path to a package's target file.
 
 This will also cache this information such that `exe_path` can find it later.
 */
-fn cargo_target<P>(input: &Input, pkg_path: P, manifest: &str, use_bincache: bool, meta: &PackageMetadata) -> Result<PathBuf>
-where P: AsRef<Path> {
-    trace!("cargo_target(_, {:?}, {:?}, {:?}, _)", pkg_path.as_ref(), manifest, use_bincache);
+fn cargo_target<P>(
+    input: &Input,
+    pkg_path: P,
+    manifest: &str,
+    use_bincache: bool,
+    meta: &PackageMetadata,
+) -> Result<PathBuf>
+where
+    P: AsRef<Path>,
+{
+    trace!(
+        "cargo_target(_, {:?}, {:?}, {:?}, _)",
+        pkg_path.as_ref(),
+        manifest,
+        use_bincache
+    );
 
     let exe_path = cargo_target_by_message(input, manifest, use_bincache, meta)?;
 
@@ -1234,10 +1295,19 @@ where P: AsRef<Path> {
 }
 
 // Gets the path to the package's target file by parsing the output of `cargo build`.
-fn cargo_target_by_message(input: &Input, manifest: &str, use_bincache: bool, meta: &PackageMetadata) -> Result<PathBuf> {
+fn cargo_target_by_message(
+    input: &Input,
+    manifest: &str,
+    use_bincache: bool,
+    meta: &PackageMetadata,
+) -> Result<PathBuf> {
     use std::io::{BufRead, BufReader};
 
-    trace!("cargo_target_by_message(_, {:?}, {:?}, _)", manifest, use_bincache);
+    trace!(
+        "cargo_target_by_message(_, {:?}, {:?}, _)",
+        manifest,
+        use_bincache
+    );
 
     let mut cmd = cargo("build", manifest, use_bincache, meta)?;
     cmd.arg("--message-format=json");
@@ -1255,27 +1325,35 @@ fn cargo_target_by_message(input: &Input, manifest: &str, use_bincache: bool, me
 
     #[derive(Deserialize)]
     struct Target {
-      name: String,
+        name: String,
     }
 
     #[derive(Deserialize)]
     struct Line {
-      reason: String,
-      target: Target,
-      filenames: Vec<PathBuf>,
+        reason: String,
+        target: Target,
+        filenames: Vec<PathBuf>,
     }
 
     while let Some(Ok(line)) = lines.next() {
         if let Ok(mut l) = serde_json::from_str::<Line>(&line).map_err(Box::new) {
-          if l.reason == "compiler-artifact" && l.target.name == package_name {
-            let _ = child.kill();
-            return Ok(l.filenames.swap_remove(0))
-          }
+            if l.reason == "compiler-artifact" && l.target.name == package_name {
+                let _ = child.kill();
+                return Ok(l.filenames.swap_remove(0));
+            }
         }
     }
 
     match child.wait()?.code() {
-        Some(st) => Err(format!("could not determine target filename: cargo exited with status {}", st).into()),
-        None => Err("could not determine target filename: cargo exited abnormally".to_string().into()),
+        Some(st) => Err(format!(
+            "could not determine target filename: cargo exited with status {}",
+            st
+        )
+        .into()),
+        None => Err(
+            "could not determine target filename: cargo exited abnormally"
+                .to_string()
+                .into(),
+        ),
     }
 }
diff --git a/src/manifest.rs b/src/manifest.rs
index 40d045d2..4462493f 100644
--- a/src/manifest.rs
+++ b/src/manifest.rs
@@ -4,7 +4,7 @@ This module is concerned with how `cargo-eval` extracts the manfiest from a scri
 use std::collections::HashMap;
 use std::path::Path;
 
-use pulldown_cmark::{CodeBlockKind, Parser, Options, Event, Tag};
+use pulldown_cmark::{CodeBlockKind, Event, Options, Parser, Tag};
 use regex::Regex;
 use toml;
 
@@ -13,8 +13,8 @@ use crate::templates;
 use crate::Input;
 
 lazy_static! {
-    static ref RE_SHORT_MANIFEST: Regex = Regex::new(
-        r"^(?i)\s*//\s*cargo-deps\s*:(.*?)(\r\n|\n)").unwrap();
+    static ref RE_SHORT_MANIFEST: Regex =
+        Regex::new(r"^(?i)\s*//\s*cargo-deps\s*:(.*?)(\r\n|\n)").unwrap();
     static ref RE_MARGIN: Regex = Regex::new(r"^\s*\*( |$)").unwrap();
     static ref RE_SPACE: Regex = Regex::new(r"^(\s+)").unwrap();
     static ref RE_NESTING: Regex = Regex::new(r"/\*|\*/").unwrap();
@@ -36,33 +36,45 @@ Splits input into a complete Cargo manifest and unadultered Rust source.
 
 Unless we have prelude items to inject, in which case it will be *slightly* adulterated.
 */
-pub fn split_input(input: &Input, deps: &[(String, String)], prelude_items: &[String]) -> Result<(String, String)> {
+pub fn split_input(
+    input: &Input,
+    deps: &[(String, String)],
+    prelude_items: &[String],
+) -> Result<(String, String)> {
     let template_buf;
     let (part_mani, source, template, sub_prelude) = match *input {
         Input::File(_, _, content, _) => {
             assert_eq!(prelude_items.len(), 0);
             let content = strip_hashbang(content).trim_end();
-            let (manifest, source) = find_embedded_manifest(content)
-                .unwrap_or((Manifest::Toml(""), content));
+            let (manifest, source) =
+                find_embedded_manifest(content).unwrap_or((Manifest::Toml(""), content));
 
             (manifest, source, templates::get_template("file")?, false)
-        },
-        Input::Expr("meaning-of-life", None) | Input::Expr("meaning_of_life", None) => {
-            (Manifest::Toml(""), r#"
+        }
+        Input::Expr("meaning-of-life", None) | Input::Expr("meaning_of_life", None) => (
+            Manifest::Toml(""),
+            r#"
                 println!("42");
                 std::process::exit(42);
-            "#, templates::get_template("expr")?, true)
-        },
+            "#,
+            templates::get_template("expr")?,
+            true,
+        ),
         Input::Expr(content, template) => {
             template_buf = templates::get_template(template.unwrap_or("expr"))?;
             let (manifest, template_src) = find_embedded_manifest(&template_buf)
                 .unwrap_or((Manifest::Toml(""), &template_buf));
             (manifest, content, template_src.into(), true)
-        },
+        }
         Input::Loop(content, count) => {
             let templ = if count { "loop-count" } else { "loop" };
-            (Manifest::Toml(""), content, templates::get_template(templ)?, true)
-        },
+            (
+                Manifest::Toml(""),
+                content,
+                templates::get_template(templ)?,
+                true,
+            )
+        }
     };
 
     let mut prelude_str;
@@ -70,10 +82,8 @@ pub fn split_input(input: &Input, deps: &[(String, String)], prelude_items: &[St
     subs.insert("script", &source[..]);
 
     if sub_prelude {
-        prelude_str = String::with_capacity(prelude_items
-            .iter()
-            .map(|i| i.len() + 1)
-            .sum::<usize>());
+        prelude_str =
+            String::with_capacity(prelude_items.iter().map(|i| i.len() + 1).sum::<usize>());
         for i in prelude_items {
             prelude_str.push_str(i);
             prelude_str.push_str("\n");
@@ -109,7 +119,9 @@ pub fn split_input(input: &Input, deps: &[(String, String)], prelude_items: &[St
 #[test]
 fn test_split_input() {
     macro_rules! si {
-        ($i:expr) => (split_input(&$i, &[], &[]).ok())
+        ($i:expr) => {
+            split_input(&$i, &[], &[]).ok()
+        };
     }
 
     let dummy_path: ::std::path::PathBuf = "p".into();
@@ -117,14 +129,15 @@ fn test_split_input() {
     let f = |c| Input::File("n", &dummy_path, c, 0);
 
     macro_rules! r {
-        ($m:expr, $r:expr) => (Some(($m.into(), $r.into())));
+        ($m:expr, $r:expr) => {
+            Some(($m.into(), $r.into()))
+        };
     }
 
-    assert_eq!(si!(f(
-r#"fn main() {}"#
-        )),
+    assert_eq!(
+        si!(f(r#"fn main() {}"#)),
         r!(
-r#"[[bin]]
+            r#"[[bin]]
 name = "n"
 path = "n.rs"
 
@@ -136,19 +149,18 @@ edition = "2018"
 name = "n"
 version = "0.1.0"
 "#,
-r#"fn main() {}"#
+            r#"fn main() {}"#
         )
     );
 
     // Ensure removed prefix manifests don't work.
-    assert_eq!(si!(f(
-r#"
+    assert_eq!(
+        si!(f(r#"
 ---
 fn main() {}
-"#
-        )),
+"#)),
         r!(
-r#"[[bin]]
+            r#"[[bin]]
 name = "n"
 path = "n.rs"
 
@@ -160,21 +172,20 @@ edition = "2018"
 name = "n"
 version = "0.1.0"
 "#,
-r#"
+            r#"
 ---
 fn main() {}"#
         )
     );
 
-    assert_eq!(si!(f(
-r#"[dependencies]
+    assert_eq!(
+        si!(f(r#"[dependencies]
 time="0.1.25"
 ---
 fn main() {}
-"#
-        )),
+"#)),
         r!(
-r#"[[bin]]
+            r#"[[bin]]
 name = "n"
 path = "n.rs"
 
@@ -186,21 +197,20 @@ edition = "2018"
 name = "n"
 version = "0.1.0"
 "#,
-r#"[dependencies]
+            r#"[dependencies]
 time="0.1.25"
 ---
 fn main() {}"#
         )
     );
 
-    assert_eq!(si!(f(
-r#"
+    assert_eq!(
+        si!(f(r#"
 // Cargo-Deps: time="0.1.25"
 fn main() {}
-"#
-        )),
+"#)),
         r!(
-r#"[[bin]]
+            r#"[[bin]]
 name = "n"
 path = "n.rs"
 
@@ -213,20 +223,19 @@ edition = "2018"
 name = "n"
 version = "0.1.0"
 "#,
-r#"
+            r#"
 // Cargo-Deps: time="0.1.25"
 fn main() {}"#
         )
     );
 
-    assert_eq!(si!(f(
-r#"
+    assert_eq!(
+        si!(f(r#"
 // Cargo-Deps: time="0.1.25", libc="0.2.5"
 fn main() {}
-"#
-        )),
+"#)),
         r!(
-r#"[[bin]]
+            r#"[[bin]]
 name = "n"
 path = "n.rs"
 
@@ -240,14 +249,14 @@ edition = "2018"
 name = "n"
 version = "0.1.0"
 "#,
-r#"
+            r#"
 // Cargo-Deps: time="0.1.25", libc="0.2.5"
 fn main() {}"#
         )
     );
 
-    assert_eq!(si!(f(
-r#"
+    assert_eq!(
+        si!(f(r#"
 /*!
 Here is a manifest:
 
@@ -257,10 +266,9 @@ time = "0.1.25"
 ```
 */
 fn main() {}
-"#
-        )),
+"#)),
         r!(
-r#"[[bin]]
+            r#"[[bin]]
 name = "n"
 path = "n.rs"
 
@@ -273,7 +281,7 @@ edition = "2018"
 name = "n"
 version = "0.1.0"
 "#,
-r#"
+            r#"
 /*!
 Here is a manifest:
 
@@ -293,29 +301,39 @@ Returns a slice of the input string with the leading hashbang, if there is one,
 fn strip_hashbang(s: &str) -> &str {
     match RE_HASHBANG.find(s) {
         Some(m) => &s[m.end()..],
-        None => s
+        None => s,
     }
 }
 
 #[test]
 fn test_strip_hashbang() {
-    assert_eq!(strip_hashbang("\
+    assert_eq!(
+        strip_hashbang(
+            "\
 #!/usr/bin/env cargo eval --
 and the rest
 \
-        "), "\
+        "
+        ),
+        "\
 and the rest
 \
-        ");
-    assert_eq!(strip_hashbang("\
+        "
+    );
+    assert_eq!(
+        strip_hashbang(
+            "\
 #![thingy]
 and the rest
 \
-        "), "\
+        "
+        ),
+        "\
 #![thingy]
 and the rest
 \
-        ");
+        "
+    );
 }
 
 /**
@@ -336,10 +354,10 @@ impl<'s> Manifest<'s> {
     pub fn into_toml(self) -> Result<toml::value::Table> {
         use self::Manifest::*;
         match self {
-            Toml(s) => Ok(toml::from_str(s)
-                .map_err(|_| "could not parse embedded manifest")?),
-            TomlOwned(ref s) => Ok(toml::from_str(&s)
-                .map_err(|_| "could not parse embedded manifest")?),
+            Toml(s) => Ok(toml::from_str(s).map_err(|_| "could not parse embedded manifest")?),
+            TomlOwned(ref s) => {
+                Ok(toml::from_str(&s).map_err(|_| "could not parse embedded manifest")?)
+            }
             DepList(s) => Manifest::dep_list_to_toml(s),
         }
     }
@@ -350,16 +368,15 @@ impl<'s> Manifest<'s> {
         for dep in s.trim().split(',') {
             // If there's no version specified, add one.
             if dep.contains('=') {
-              r.push_str(dep);
-              r.push_str("\n");
+                r.push_str(dep);
+                r.push_str("\n");
             } else {
-              r.push_str(dep);
-              r.push_str("=\"*\"\n");
+                r.push_str(dep);
+                r.push_str("=\"*\"\n");
             }
         }
 
-        Ok(toml::from_str(&r)
-            .map_err(|_| "could not parse embedded manifest")?)
+        Ok(toml::from_str(&r).map_err(|_| "could not parse embedded manifest")?)
     }
 }
 
@@ -369,8 +386,7 @@ Locates a manifest embedded in Rust source.
 Returns `Some((manifest, source))` if it finds a manifest, `None` otherwise.
 */
 fn find_embedded_manifest(s: &str) -> Option<(Manifest, &str)> {
-    find_short_comment_manifest(s)
-        .or_else(|| find_code_block_manifest(s))
+    find_short_comment_manifest(s).or_else(|| find_code_block_manifest(s))
 }
 
 #[test]
@@ -381,125 +397,140 @@ fn test_find_embedded_manifest() {
 
     assert_eq!(fem("fn main() {}"), None);
 
-    assert_eq!(fem(
-"
+    assert_eq!(
+        fem("
 fn main() {}
 "),
-    None);
+        None
+    );
 
     // Ensure removed prefix manifests don't work.
-    assert_eq!(fem(
-r#"
+    assert_eq!(
+        fem(r#"
 ---
 fn main() {}
 "#),
-    None);
+        None
+    );
 
-    assert_eq!(fem(
-"[dependencies]
+    assert_eq!(
+        fem("[dependencies]
 time = \"0.1.25\"
 ---
 fn main() {}
 "),
-    None);
+        None
+    );
 
-    assert_eq!(fem(
-"[dependencies]
+    assert_eq!(
+        fem("[dependencies]
 time = \"0.1.25\"
 
 fn main() {}
 "),
-    None);
+        None
+    );
 
     // Make sure we aren't just grabbing the *last* line.
-    assert_eq!(fem(
-"[dependencies]
+    assert_eq!(
+        fem("[dependencies]
 time = \"0.1.25\"
 
 fn main() {
     println!(\"Hi!\");
 }
 "),
-    None);
+        None
+    );
 
-    assert_eq!(fem(
-"// cargo-deps: time=\"0.1.25\"
+    assert_eq!(
+        fem("// cargo-deps: time=\"0.1.25\"
 fn main() {}
 "),
-    Some((
-DepList(" time=\"0.1.25\""),
-"// cargo-deps: time=\"0.1.25\"
+        Some((
+            DepList(" time=\"0.1.25\""),
+            "// cargo-deps: time=\"0.1.25\"
 fn main() {}
 "
-    )));
+        ))
+    );
 
-    assert_eq!(fem(
-"// cargo-deps: time=\"0.1.25\", libc=\"0.2.5\"
+    assert_eq!(
+        fem("// cargo-deps: time=\"0.1.25\", libc=\"0.2.5\"
 fn main() {}
 "),
-    Some((
-DepList(" time=\"0.1.25\", libc=\"0.2.5\""),
-"// cargo-deps: time=\"0.1.25\", libc=\"0.2.5\"
+        Some((
+            DepList(" time=\"0.1.25\", libc=\"0.2.5\""),
+            "// cargo-deps: time=\"0.1.25\", libc=\"0.2.5\"
 fn main() {}
 "
-    )));
+        ))
+    );
 
-    assert_eq!(fem(
-"
+    assert_eq!(
+        fem("
   // cargo-deps: time=\"0.1.25\"  \n\
 fn main() {}
 "),
-    Some((
-DepList(" time=\"0.1.25\"  "),
-"
+        Some((
+            DepList(" time=\"0.1.25\"  "),
+            "
   // cargo-deps: time=\"0.1.25\"  \n\
 fn main() {}
 "
-    )));
+        ))
+    );
 
-    assert_eq!(fem(
-"/* cargo-deps: time=\"0.1.25\" */
+    assert_eq!(
+        fem("/* cargo-deps: time=\"0.1.25\" */
 fn main() {}
 "),
-    None);
+        None
+    );
 
-    assert_eq!(fem(
-r#"//! [dependencies]
+    assert_eq!(
+        fem(r#"//! [dependencies]
 //! time = "0.1.25"
 fn main() {}
 "#),
-    None);
+        None
+    );
 
-    assert_eq!(fem(
-r#"//! ```Cargo
+    assert_eq!(
+        fem(r#"//! ```Cargo
 //! [dependencies]
 //! time = "0.1.25"
 //! ```
 fn main() {}
 "#),
-    Some((
-TomlOwned(r#"[dependencies]
+        Some((
+            TomlOwned(
+                r#"[dependencies]
 time = "0.1.25"
-"#.into()),
-r#"//! ```Cargo
+"#
+                .into()
+            ),
+            r#"//! ```Cargo
 //! [dependencies]
 //! time = "0.1.25"
 //! ```
 fn main() {}
 "#
-    )));
+        ))
+    );
 
-    assert_eq!(fem(
-r#"/*!
+    assert_eq!(
+        fem(r#"/*!
 [dependencies]
 time = "0.1.25"
 */
 fn main() {}
 "#),
-    None);
+        None
+    );
 
-    assert_eq!(fem(
-r#"/*!
+    assert_eq!(
+        fem(r#"/*!
 ```Cargo
 [dependencies]
 time = "0.1.25"
@@ -507,11 +538,14 @@ time = "0.1.25"
 */
 fn main() {}
 "#),
-    Some((
-TomlOwned(r#"[dependencies]
+        Some((
+            TomlOwned(
+                r#"[dependencies]
 time = "0.1.25"
-"#.into()),
-r#"/*!
+"#
+                .into()
+            ),
+            r#"/*!
 ```Cargo
 [dependencies]
 time = "0.1.25"
@@ -519,19 +553,21 @@ time = "0.1.25"
 */
 fn main() {}
 "#
-    )));
+        ))
+    );
 
-    assert_eq!(fem(
-r#"/*!
+    assert_eq!(
+        fem(r#"/*!
  * [dependencies]
  * time = "0.1.25"
  */
 fn main() {}
 "#),
-    None);
+        None
+    );
 
-    assert_eq!(fem(
-r#"/*!
+    assert_eq!(
+        fem(r#"/*!
  * ```Cargo
  * [dependencies]
  * time = "0.1.25"
@@ -539,11 +575,14 @@ r#"/*!
  */
 fn main() {}
 "#),
-    Some((
-TomlOwned(r#"[dependencies]
+        Some((
+            TomlOwned(
+                r#"[dependencies]
 time = "0.1.25"
-"#.into()),
-r#"/*!
+"#
+                .into()
+            ),
+            r#"/*!
  * ```Cargo
  * [dependencies]
  * time = "0.1.25"
@@ -551,7 +590,8 @@ r#"/*!
  */
 fn main() {}
 "#
-    )));
+        ))
+    );
 }
 
 /**
@@ -564,7 +604,7 @@ fn find_short_comment_manifest(s: &str) -> Option<(Manifest, &str)> {
     let re = &*RE_SHORT_MANIFEST;
     if let Some(cap) = re.captures(s) {
         if let Some(m) = cap.get(1) {
-            return Some((Manifest::DepList(m.as_str()), &s[..]))
+            return Some((Manifest::DepList(m.as_str()), &s[..]));
         }
     }
     None
@@ -586,66 +626,80 @@ fn find_code_block_manifest(s: &str) -> Option<(Manifest, &str)> {
     let start = match RE_CRATE_COMMENT.captures(s) {
         Some(cap) => match cap.get(1) {
             Some(m) => m.start(),
-            None => return None
+            None => return None,
         },
-        None => return None
+        None => return None,
     };
 
     let comment = match extract_comment(&s[start..]) {
         Ok(s) => s,
         Err(err) => {
             error!("error slicing comment: {}", err);
-            return None
+            return None;
         }
     };
 
-    scrape_markdown_manifest(&comment)
-        .map(|m| (Manifest::TomlOwned(m), s))
+    scrape_markdown_manifest(&comment).map(|m| (Manifest::TomlOwned(m), s))
 }
 
 /**
 Extracts the first `Cargo` fenced code block from a chunk of Markdown.
 */
 fn scrape_markdown_manifest(content: &str) -> Option<String> {
-  // To match `librustdoc/html/markdown.rs` `opts`.
-  let exts = Options::ENABLE_TABLES | Options::ENABLE_FOOTNOTES;
+    // To match `librustdoc/html/markdown.rs` `opts`.
+    let exts = Options::ENABLE_TABLES | Options::ENABLE_FOOTNOTES;
 
-  let md = Parser::new_ext(&content, exts);
+    let md = Parser::new_ext(&content, exts);
 
-  let mut it = md.skip_while(|e| if let Event::Start(Tag::CodeBlock(CodeBlockKind::Fenced(ref info))) = e {
-    info.to_lowercase() != "cargo"
-  } else {
-    true
-  });
+    let mut it = md.skip_while(|e| {
+        if let Event::Start(Tag::CodeBlock(CodeBlockKind::Fenced(ref info))) = e {
+            info.to_lowercase() != "cargo"
+        } else {
+            true
+        }
+    });
 
-  it.next()?;
+    it.next()?;
 
-  let s = it.take_while(|e| if let Event::End(Tag::CodeBlock(_)) = e { false } else { true})
-  .filter_map(|e| if let Event::Text(text) = e {
-    Some(text.into_string())
-  } else {
-    None
-  })
-  .collect::<String>();
+    let s = it
+        .take_while(|e| {
+            if let Event::End(Tag::CodeBlock(_)) = e {
+                false
+            } else {
+                true
+            }
+        })
+        .filter_map(|e| {
+            if let Event::Text(text) = e {
+                Some(text.into_string())
+            } else {
+                None
+            }
+        })
+        .collect::<String>();
 
-  Some(s)
+    Some(s)
 }
 
 #[test]
 fn test_scrape_markdown_manifest() {
     macro_rules! smm {
-        ($c:expr) => (scrape_markdown_manifest($c));
+        ($c:expr) => {
+            scrape_markdown_manifest($c)
+        };
     }
 
-    assert_eq!(smm!(
-r#"There is no manifest in this comment.
+    assert_eq!(
+        smm!(
+            r#"There is no manifest in this comment.
 "#
         ),
-None
+        None
     );
 
-    assert_eq!(smm!(
-r#"There is no manifest in this comment.
+    assert_eq!(
+        smm!(
+            r#"There is no manifest in this comment.
 
 ```
 This is not a manifest.
@@ -658,23 +712,28 @@ println!("Nor is this.");
     Or this.
 "#
         ),
-None
+        None
     );
 
-    assert_eq!(smm!(
-r#"This is a manifest:
+    assert_eq!(
+        smm!(
+            r#"This is a manifest:
 
 ```cargo
 dependencies = { time = "*" }
 ```
 "#
         ),
-Some(r#"dependencies = { time = "*" }
-"#.into())
+        Some(
+            r#"dependencies = { time = "*" }
+"#
+            .into()
+        )
     );
 
-    assert_eq!(smm!(
-r#"This is *not* a manifest:
+    assert_eq!(
+        smm!(
+            r#"This is *not* a manifest:
 
 ```
 He's lying, I'm *totally* a manifest!
@@ -687,12 +746,16 @@ dependencies = { time = "*" }
 ```
 "#
         ),
-Some(r#"dependencies = { time = "*" }
-"#.into())
+        Some(
+            r#"dependencies = { time = "*" }
+"#
+            .into()
+        )
     );
 
-    assert_eq!(smm!(
-r#"This is a manifest:
+    assert_eq!(
+        smm!(
+            r#"This is a manifest:
 
 ```cargo
 dependencies = { time = "*" }
@@ -705,8 +768,11 @@ dependencies = { explode = true }
 ```
 "#
         ),
-Some(r#"dependencies = { time = "*" }
-"#.into())
+        Some(
+            r#"dependencies = { time = "*" }
+"#
+            .into()
+        )
     );
 }
 
@@ -718,7 +784,7 @@ fn extract_comment(s: &str) -> Result<String> {
 
     fn n_leading_spaces(s: &str, n: usize) -> Result<()> {
         if !s.chars().take(n).all(|c| c == ' ') {
-            return Err(format!("leading {:?} chars aren't all spaces: {:?}", n, s).into())
+            return Err(format!("leading {:?} chars aren't all spaces: {:?}", n, s).into());
         }
         Ok(())
     }
@@ -746,46 +812,45 @@ fn extract_comment(s: &str) -> Result<String> {
         let mut depth: u32 = 1;
 
         for line in s.lines() {
-            if depth == 0 { break }
+            if depth == 0 {
+                break;
+            }
 
             // Update nesting and look for end-of-comment.
             let mut end_of_comment = None;
 
-            for (end, marker) in {
-                nesting_re.find_iter(line)
-                    .map(|m| (m.start(), m.as_str()))
-            } {
+            for (end, marker) in { nesting_re.find_iter(line).map(|m| (m.start(), m.as_str())) } {
                 match (marker, depth) {
                     ("/*", _) => depth += 1,
                     ("*/", 1) => {
                         end_of_comment = Some(end);
                         depth = 0;
                         break;
-                    },
+                    }
                     ("*/", _) => depth -= 1,
-                    _ => panic!("got a comment marker other than /* or */")
+                    _ => panic!("got a comment marker other than /* or */"),
                 }
             }
 
             let line = end_of_comment.map(|end| &line[..end]).unwrap_or(line);
 
             // Detect and strip margin.
-            margin = margin
-                .or_else(|| margin_re.find(line)
-                    .map(|m| m.as_str()));
+            margin = margin.or_else(|| margin_re.find(line).map(|m| m.as_str()));
 
             let line = if let Some(margin) = margin {
-                let end = line.char_indices().take(margin.len())
-                    .map(|(i,c)| i + c.len_utf8()).last().unwrap_or(0);
+                let end = line
+                    .char_indices()
+                    .take(margin.len())
+                    .map(|(i, c)| i + c.len_utf8())
+                    .last()
+                    .unwrap_or(0);
                 &line[end..]
             } else {
                 line
             };
 
             // Detect and strip leading indentation.
-            leading_space = leading_space
-                .or_else(|| space_re.find(line)
-                    .map(|m| m.end()));
+            leading_space = leading_space.or_else(|| space_re.find(line).map(|m| m.end()));
 
             /*
             Make sure we have only leading spaces.
@@ -821,14 +886,16 @@ fn extract_comment(s: &str) -> Result<String> {
             // Strip leading comment marker.
             let content = match comment_re.find(line) {
                 Some(m) => &line[m.end()..],
-                None => break
+                None => break,
             };
 
             // Detect and strip leading indentation.
-            leading_space = leading_space
-                .or_else(|| space_re.captures(content)
+            leading_space = leading_space.or_else(|| {
+                space_re
+                    .captures(content)
                     .and_then(|c| c.get(1))
-                    .map(|m| m.end()));
+                    .map(|m| m.end())
+            });
 
             /*
             Make sure we have only leading spaces.
@@ -864,17 +931,15 @@ fn extract_comment(s: &str) -> Result<String> {
 #[test]
 fn test_extract_comment() {
     macro_rules! ec {
-        ($s:expr) => (extract_comment($s).map_err(|e| e.to_string()))
+        ($s:expr) => {
+            extract_comment($s).map_err(|e| e.to_string())
+        };
     }
 
-    assert_eq!(ec!(
-r#"fn main () {}"#
-        ),
-Err("no doc comment found".into())
-    );
+    assert_eq!(ec!(r#"fn main () {}"#), Err("no doc comment found".into()));
 
-    assert_eq!(ec!(
-r#"/*!
+    assert_eq!(
+        ec!(r#"/*!
 Here is a manifest:
 
 ```cargo
@@ -883,9 +948,8 @@ time = "*"
 ```
 */
 fn main() {}
-"#
-        ),
-Ok(r#"
+"#),
+        Ok(r#"
 Here is a manifest:
 
 ```cargo
@@ -893,11 +957,12 @@ Here is a manifest:
 time = "*"
 ```
 
-"#.into())
+"#
+        .into())
     );
 
-    assert_eq!(ec!(
-r#"/*!
+    assert_eq!(
+        ec!(r#"/*!
  * Here is a manifest:
  *
  * ```cargo
@@ -906,9 +971,8 @@ r#"/*!
  * ```
  */
 fn main() {}
-"#
-        ),
-Ok(r#"
+"#),
+        Ok(r#"
 Here is a manifest:
 
 ```cargo
@@ -916,26 +980,27 @@ Here is a manifest:
 time = "*"
 ```
 
-"#.into())
+"#
+        .into())
     );
 
-    assert_eq!(ec!(
-r#"//! Here is a manifest:
+    assert_eq!(
+        ec!(r#"//! Here is a manifest:
 //!
 //! ```cargo
 //! [dependencies]
 //! time = "*"
 //! ```
 fn main() {}
-"#
-        ),
-Ok(r#"Here is a manifest:
+"#),
+        Ok(r#"Here is a manifest:
 
 ```cargo
 [dependencies]
 time = "*"
 ```
-"#.into())
+"#
+        .into())
     );
 }
 
@@ -948,10 +1013,12 @@ fn default_manifest(input: &Input) -> Result<toml::value::Table> {
         let mut subs = HashMap::with_capacity(2);
         subs.insert("name", &*pkg_name);
         subs.insert("file", &input.safe_name()[..]);
-        templates::expand(include_str!("templates/default_manifest.toml").trim_end(), &subs)?
+        templates::expand(
+            include_str!("templates/default_manifest.toml").trim_end(),
+            &subs,
+        )?
     };
-    toml::from_str(&mani_str)
-        .map_err(|_| "could not parse default manifest, somehow".into())
+    toml::from_str(&mani_str).map_err(|_| "could not parse default manifest, somehow".into())
 }
 
 /**
@@ -973,8 +1040,7 @@ fn deps_manifest(deps: &[(String, String)]) -> Result<toml::value::Table> {
         mani_str.push_str("\n");
     }
 
-    toml::from_str(&mani_str)
-        .map_err(|_| "could not parse dependency manifest".into())
+    toml::from_str(&mani_str).map_err(|_| "could not parse dependency manifest".into())
 }
 
 /**
@@ -982,7 +1048,10 @@ Given two Cargo manifests, merges the second *into* the first.
 
 Note that the "merge" in this case is relatively simple: only *top-level* tables are actually merged; everything else is just outright replaced.
 */
-fn merge_manifest(mut into_t: toml::value::Table, from_t: toml::value::Table) -> Result<toml::value::Table> {
+fn merge_manifest(
+    mut into_t: toml::value::Table,
+    from_t: toml::value::Table,
+) -> Result<toml::value::Table> {
     for (k, v) in from_t {
         match v {
             toml::Value::Table(from_t) => {
@@ -992,19 +1061,21 @@ fn merge_manifest(mut into_t: toml::value::Table, from_t: toml::value::Table) ->
                 match into_t.entry(k) {
                     Vacant(e) => {
                         e.insert(toml::Value::Table(from_t));
-                    },
+                    }
                     Occupied(e) => {
-                        let into_t = as_table_mut(e.into_mut())
-                            .ok_or((Blame::Human, "cannot merge manifests: cannot merge \
-                                table and non-table values"))?;
+                        let into_t = as_table_mut(e.into_mut()).ok_or((
+                            Blame::Human,
+                            "cannot merge manifests: cannot merge \
+                             table and non-table values",
+                        ))?;
                         into_t.extend(from_t);
                     }
                 }
-            },
+            }
             v => {
                 // Just replace.
                 into_t.insert(k, v);
-            },
+            }
         }
     }
 
@@ -1013,7 +1084,7 @@ fn merge_manifest(mut into_t: toml::value::Table, from_t: toml::value::Table) ->
     fn as_table_mut(t: &mut toml::Value) -> Option<&mut toml::value::Table> {
         match *t {
             toml::Value::Table(ref mut t) => Some(t),
-            _ => None
+            _ => None,
         }
     }
 }
@@ -1036,11 +1107,11 @@ fn fix_manifest_paths(mani: toml::value::Table, base: &Path) -> Result<toml::val
     for path in paths {
         iterate_toml_mut_path(&mut mani, path, &mut |v| {
             if let toml::Value::String(ref mut s) = *v {
-              if Path::new(s).is_relative() {
-                  if let Some(p) = base.join(&*s).to_str() {
-                    *s = p.into();
-                  }
-              }
+                if Path::new(s).is_relative() {
+                    if let Some(p) = base.join(&*s).to_str() {
+                        *s = p.into();
+                    }
+                }
             }
             Ok(())
         })?
@@ -1056,7 +1127,9 @@ fn fix_manifest_paths(mani: toml::value::Table, base: &Path) -> Result<toml::val
 Iterates over the specified TOML values via a path specification.
 */
 fn iterate_toml_mut_path<F>(base: &mut toml::Value, path: &[&str], on_each: &mut F) -> Result<()>
-where F: FnMut(&mut toml::Value) -> Result<()> {
+where
+    F: FnMut(&mut toml::Value) -> Result<()>,
+{
     if path.is_empty() {
         return on_each(base);
     }
@@ -1065,15 +1138,15 @@ where F: FnMut(&mut toml::Value) -> Result<()> {
     let tail = &path[1..];
 
     if cur == "*" {
-      if let toml::Value::Table(ref mut tab) = *base {
-        for (_, v) in tab.iter_mut() {
-            iterate_toml_mut_path(v, tail, on_each)?;
+        if let toml::Value::Table(ref mut tab) = *base {
+            for (_, v) in tab.iter_mut() {
+                iterate_toml_mut_path(v, tail, on_each)?;
+            }
         }
-      }
     } else if let toml::Value::Table(ref mut tab) = *base {
-      if let Some(v) = tab.get_mut(cur) {
-        iterate_toml_mut_path(v, tail, on_each)?;
-      }
+        if let Some(v) = tab.get_mut(cur) {
+            iterate_toml_mut_path(v, tail, on_each)?;
+        }
     }
 
     Ok(())
diff --git a/src/platform.rs b/src/platform.rs
index 6798c03f..9f475906 100644
--- a/src/platform.rs
+++ b/src/platform.rs
@@ -5,30 +5,41 @@ pub use self::inner::*;
 
 // Last-modified time of a file, in milliseconds since the UNIX epoch.
 pub fn file_last_modified(file: &File) -> u128 {
-  file.metadata().and_then(|md| md.modified().map(|t| t.duration_since(UNIX_EPOCH).unwrap().as_millis())).unwrap_or(0)
+    file.metadata()
+        .and_then(|md| {
+            md.modified()
+                .map(|t| t.duration_since(UNIX_EPOCH).unwrap().as_millis())
+        })
+        .unwrap_or(0)
 }
 
-
 // Current system time, in milliseconds since the UNIX epoch.
 pub fn current_time() -> u128 {
-  SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_millis()
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap()
+        .as_millis()
 }
 
 #[cfg(unix)]
 mod inner {
     pub use super::*;
 
-    use std::path::{Path, PathBuf};
     use std::io;
     use std::os::unix::ffi::OsStrExt;
+    use std::path::{Path, PathBuf};
 
     pub fn write_path<W>(w: &mut W, path: &Path) -> io::Result<()>
-    where W: io::Write {
+    where
+        W: io::Write,
+    {
         w.write_all(path.as_os_str().as_bytes())
     }
 
     pub fn read_path<R>(r: &mut R) -> io::Result<PathBuf>
-    where R: io::Read {
+    where
+        R: io::Read,
+    {
         use std::ffi::OsStr;
         let mut buf = vec![];
         r.read_to_end(&mut buf)?;
@@ -53,11 +64,13 @@ pub mod inner {
 
     use std::ffi::OsString;
     use std::io;
-    use std::path::{Path, PathBuf};
     use std::os::windows::ffi::{OsStrExt, OsStringExt};
+    use std::path::{Path, PathBuf};
 
     pub fn write_path<W>(w: &mut W, path: &Path) -> io::Result<()>
-    where W: io::Write {
+    where
+        W: io::Write,
+    {
         for word in path.as_os_str().encode_wide() {
             let lo = (word & 0xff) as u8;
             let hi = (word >> 8) as u8;
@@ -67,7 +80,9 @@ pub mod inner {
     }
 
     pub fn read_path<R>(r: &mut R) -> io::Result<PathBuf>
-    where R: io::Read {
+    where
+        R: io::Read,
+    {
         let mut buf = vec![];
         r.read_to_end(&mut buf)?;
 
diff --git a/src/templates.rs b/src/templates.rs
index 0477b27c..ccc52594 100644
--- a/src/templates.rs
+++ b/src/templates.rs
@@ -1,15 +1,15 @@
 /*!
 This module contains code related to template support.
 */
+use crate::app;
+use crate::error::{Blame, MainError, Result, ResultExt};
+use clap;
+use open;
+use regex::Regex;
 use std::borrow::Cow;
 use std::collections::HashMap;
 use std::fs;
 use std::path::PathBuf;
-use clap;
-use open;
-use regex::Regex;
-use crate::error::{Blame, MainError, Result, ResultExt};
-use crate::app;
 
 lazy_static! {
     static ref RE_SUB: Regex = Regex::new(r#"#\{([A-Za-z_][A-Za-z0-9_]*)}"#).unwrap();
@@ -54,18 +54,14 @@ impl Args {
 
     pub fn parse(m: &clap::ArgMatches) -> Self {
         match m.subcommand() {
-            ("dump", Some(m)) => {
-                Args::Dump {
-                    name: m.value_of("template").unwrap().into(),
-                }
+            ("dump", Some(m)) => Args::Dump {
+                name: m.value_of("template").unwrap().into(),
             },
             ("list", _) => Args::List,
-            ("show", Some(m)) => {
-                Args::Show {
-                    path: m.is_present("show_path"),
-                }
+            ("show", Some(m)) => Args::Show {
+                path: m.is_present("show_path"),
             },
-            (name, _) => panic!("bad subcommand: {:?}", name)
+            (name, _) => panic!("bad subcommand: {:?}", name),
         }
     }
 }
@@ -82,10 +78,7 @@ pub fn try_main(args: Args) -> Result<i32> {
 
 pub fn expand(src: &str, subs: &HashMap<&str, &str>) -> Result<String> {
     // The estimate of final size is the sum of the size of all the input.
-    let sub_size = subs
-        .iter()
-        .map(|(_, v)| v.len())
-        .sum::<usize>();
+    let sub_size = subs.iter().map(|(_, v)| v.len()).sum::<usize>();
     let est_size = src.len() + sub_size;
 
     let mut anchor = 0;
@@ -105,7 +98,12 @@ pub fn expand(src: &str, subs: &HashMap<&str, &str>) -> Result<String> {
         let sub_name = m.get(1).unwrap().as_str();
         match subs.get(sub_name) {
             Some(s) => result.push_str(s),
-            None => return Err(MainError::OtherOwned(Blame::Human, format!("substitution `{}` in template is unknown", sub_name))),
+            None => {
+                return Err(MainError::OtherOwned(
+                    Blame::Human,
+                    format!("substitution `{}` in template is unknown", sub_name),
+                ))
+            }
         }
     }
     result.push_str(&src[anchor..]);
@@ -116,13 +114,13 @@ pub fn expand(src: &str, subs: &HashMap<&str, &str>) -> Result<String> {
 Returns the path to the template directory.
 */
 pub fn get_template_path() -> PathBuf {
-  use std::env;
+    use std::env;
 
-  if let Ok(path) = env::var("CARGO_EVAL_TEMPLATE_DIR") {
-    return path.into();
-  }
+    if let Ok(path) = env::var("CARGO_EVAL_TEMPLATE_DIR") {
+        return path.into();
+    }
 
-  app::data_dir().unwrap().join("templates")
+    app::data_dir().unwrap().join("templates")
 }
 
 /**
@@ -135,15 +133,17 @@ pub fn get_template(name: &str) -> Result<Cow<'static, str>> {
 
     let file = fs::File::open(base.join(format!("{}.rs", name)))
         .map_err(MainError::from)
-        .err_tag(format!("template file `{}.rs` does not exist in {}",
+        .err_tag(format!(
+            "template file `{}.rs` does not exist in {}",
             name,
-            base.display()))
+            base.display()
+        ))
         .shift_blame(Blame::Human);
 
     // If the template is one of the built-in ones, do fallback if it wasn't found on disk.
     if file.is_err() {
         if let Some(text) = builtin_template(name) {
-            return Ok(text.into())
+            return Ok(text.into());
         }
     }
 
@@ -176,11 +176,19 @@ fn list() -> Result<()> {
     let t_path = get_template_path();
 
     if !t_path.exists() {
-        return Err(format!("cannot list template directory `{}`: it does not exist", t_path.display()).into());
+        return Err(format!(
+            "cannot list template directory `{}`: it does not exist",
+            t_path.display()
+        )
+        .into());
     }
 
     if !t_path.is_dir() {
-        return Err(format!("cannot list template directory `{}`: it is not a directory", t_path.display()).into());
+        return Err(format!(
+            "cannot list template directory `{}`: it is not a directory",
+            t_path.display()
+        )
+        .into());
     }
 
     for entry in fs::read_dir(&t_path)? {
@@ -212,7 +220,11 @@ fn show(path: bool) -> Result<()> {
         if t_path.is_dir() {
             open::that(&t_path)?;
         } else {
-            return Err(format!("cannot open directory `{}`; it isn't a directory", t_path.display()).into());
+            return Err(format!(
+                "cannot open directory `{}`; it isn't a directory",
+                t_path.display()
+            )
+            .into());
         }
         Ok(())
     }
diff --git a/src/util.rs b/src/util.rs
index d30b9471..51163c5d 100644
--- a/src/util.rs
+++ b/src/util.rs
@@ -13,12 +13,14 @@ A `Defer` can also be "disarmed", preventing the closure from running at all.
 */
 #[must_use]
 pub struct Defer<'a, F, E>(Option<F>, PhantomData<&'a F>)
-where F: 'a + FnOnce() -> Result<(), E>,
+where
+    F: 'a + FnOnce() -> Result<(), E>,
     E: Error;
 
 impl<'a, F, E> Defer<'a, F, E>
-where F: 'a + FnOnce() -> Result<(), E>,
-    E: Error
+where
+    F: 'a + FnOnce() -> Result<(), E>,
+    E: Error,
 {
     /**
     Create a new `Defer` with the given closure.
@@ -39,7 +41,7 @@ where F: 'a + FnOnce() -> Result<(), E>,
 impl<'a, F, E> ::std::ops::Drop for Defer<'a, F, E>
 where
     F: 'a + FnOnce() -> Result<(), E>,
-    E: Error
+    E: Error,
 {
     fn drop(&mut self) {
         if let Some(f) = self.0.take() {
@@ -50,17 +52,17 @@ where
     }
 }
 
-#[cfg(feature="suppress-cargo-output")]
-pub use self::suppress_child_output::{ChildToken, suppress_child_output};
+#[cfg(feature = "suppress-cargo-output")]
+pub use self::suppress_child_output::{suppress_child_output, ChildToken};
 
-#[cfg(feature="suppress-cargo-output")]
+#[cfg(feature = "suppress-cargo-output")]
 mod suppress_child_output {
+    use crate::error::Result;
+    use chan;
     use std::io;
     use std::process::{self, Command};
     use std::thread;
     use std::time::Duration;
-    use chan;
-    use crate::error::Result;
 
     /**
     Suppresses the stderr output of a child process, unless:
@@ -95,8 +97,7 @@ mod suppress_child_output {
             }
             if show_stderr {
                 let mut stderr = stderr;
-                io::copy(&mut stderr, &mut io::stderr())
-                    .expect("could not copy child stderr");
+                io::copy(&mut stderr, &mut io::stderr()).expect("could not copy child stderr");
             }
             if !recv_done {
                 done_gate.recv();
diff --git a/tests/integration.rs b/tests/integration.rs
index 1fe53925..91de160b 100644
--- a/tests/integration.rs
+++ b/tests/integration.rs
@@ -5,9 +5,12 @@ Because *both* Cargo and Rust both know better than I do and won't let me tell t
 
 *All* integration tests have to be glommed into a single runner so that we can use locks to prevent Cargo from falling over and breaking both its legs as soon as a gentle breeze comes along.  I *would* do this "properly" using file locks, except that's apparently impossible in Rust without writing the whole stack yourself directly on native OS calls, and I just can't be arsed to go to *that* much effort just to get some bloody tests to work.
 */
-#[macro_use] extern crate lazy_static;
-#[macro_use] extern crate scan_rules;
-#[macro_use] mod util;
+#[macro_use]
+extern crate lazy_static;
+#[macro_use]
+extern crate scan_rules;
+#[macro_use]
+mod util;
 
 mod tests {
     mod expr;
diff --git a/tests/tests/expr.rs b/tests/tests/expr.rs
index ec3199ec..f86d2557 100644
--- a/tests/tests/expr.rs
+++ b/tests/tests/expr.rs
@@ -3,7 +3,8 @@ fn test_expr_0() {
     let out = cargo_eval!("-e", with_output_marker!("0")).unwrap();
     scan!(out.stdout_output();
         ("0") => ()
-    ).unwrap()
+    )
+    .unwrap()
 }
 
 #[test]
@@ -11,7 +12,8 @@ fn test_expr_comma() {
     let out = cargo_eval!("-e", with_output_marker!("[1, 2, 3]")).unwrap();
     scan!(out.stdout_output();
         ("[1, 2, 3]") => ()
-    ).unwrap()
+    )
+    .unwrap()
 }
 
 #[test]
@@ -28,14 +30,20 @@ fn test_expr_temporary() {
 
 #[test]
 fn test_expr_dep() {
-    let out = cargo_eval!("-d", "boolinator=0.1.0",
-        "-e", with_output_marker!(
+    let out = cargo_eval!(
+        "-d",
+        "boolinator=0.1.0",
+        "-e",
+        with_output_marker!(
             prelude "use boolinator::Boolinator;";
             "true.as_some(1)"
-        )).unwrap();
+        )
+    )
+    .unwrap();
     scan!(out.stdout_output();
         ("Some(1)") => ()
-    ).unwrap()
+    )
+    .unwrap()
 }
 
 #[test]
@@ -50,7 +58,8 @@ fn test_expr_qmark() {
     let out = cargo_eval!("-e", code).unwrap();
     scan!(out.stdout_output();
         ("43") => ()
-    ).unwrap();
+    )
+    .unwrap();
 }
 
 #[test]
@@ -58,11 +67,16 @@ fn test_expr_template() {
     let template_dir = "tests/data/templates";
     let out = cargo_eval!(
         #[env(CARGO_EVAL_TEMPLATE_DIR=template_dir)]
-        "-t", "shout", "-e", with_output_marker!(r#""no way? no way!""#)
-    ).unwrap();
+        "-t",
+        "shout",
+        "-e",
+        with_output_marker!(r#""no way? no way!""#)
+    )
+    .unwrap();
     scan!(out.stdout_output();
         ("NO WAY? NO WAY!") => ()
-    ).unwrap();
+    )
+    .unwrap();
 }
 
 #[test]
@@ -70,11 +84,16 @@ fn test_expr_template_with_deps() {
     let template_dir = "tests/data/templates";
     let out = cargo_eval!(
         #[env(CARGO_EVAL_TEMPLATE_DIR=template_dir)]
-        "-t", "boolinate", "-e", with_output_marker!(r#"true"#)
-    ).unwrap();
+        "-t",
+        "boolinate",
+        "-e",
+        with_output_marker!(r#"true"#)
+    )
+    .unwrap();
     scan!(out.stdout_output();
         ("Some(())") => ()
-    ).unwrap();
+    )
+    .unwrap();
 }
 
 #[test]
@@ -82,9 +101,12 @@ fn test_expr_template_override_expr() {
     let template_dir = "tests/data/templates/override";
     let out = cargo_eval!(
         #[env(CARGO_EVAL_TEMPLATE_DIR=template_dir)]
-        "-e", with_output_marker!(r#"true"#)
-    ).unwrap();
+        "-e",
+        with_output_marker!(r#"true"#)
+    )
+    .unwrap();
     scan!(out.stdout_output();
         ("Some(())") => ()
-    ).unwrap();
+    )
+    .unwrap();
 }
diff --git a/tests/tests/script.rs b/tests/tests/script.rs
index 129dc0af..71224e1a 100644
--- a/tests/tests/script.rs
+++ b/tests/tests/script.rs
@@ -3,7 +3,8 @@ fn test_script_explicit() {
     let out = cargo_eval!("-dboolinator", "tests/data/script-explicit.rs").unwrap();
     scan!(out.stdout_output();
         ("Some(1)") => ()
-    ).unwrap()
+    )
+    .unwrap()
 }
 
 #[test]
@@ -11,7 +12,8 @@ fn test_script_features() {
     let out = cargo_eval!("--features", "dont-panic", "tests/data/script-features.rs").unwrap();
     scan!(out.stdout_output();
         ("Keep calm and borrow check.") => ()
-    ).unwrap();
+    )
+    .unwrap();
 
     let out = cargo_eval!("tests/data/script-features.rs").unwrap();
     assert!(!out.success());
@@ -22,7 +24,8 @@ fn test_script_full_block() {
     let out = cargo_eval!("tests/data/script-full-block.rs").unwrap();
     scan!(out.stdout_output();
         ("Some(1)") => ()
-    ).unwrap()
+    )
+    .unwrap()
 }
 
 #[test]
@@ -30,7 +33,8 @@ fn test_script_full_line() {
     let out = cargo_eval!("tests/data/script-full-line.rs").unwrap();
     scan!(out.stdout_output();
         ("Some(1)") => ()
-    ).unwrap()
+    )
+    .unwrap()
 }
 
 #[test]
@@ -38,7 +42,8 @@ fn test_script_invalid_doc_comment() {
     let out = cargo_eval!("tests/data/script-invalid-doc-comment.rs").unwrap();
     scan!(out.stdout_output();
         ("Hello, World!") => ()
-    ).unwrap()
+    )
+    .unwrap()
 }
 
 #[test]
@@ -46,7 +51,8 @@ fn test_script_no_deps() {
     let out = cargo_eval!("tests/data/script-no-deps.rs").unwrap();
     scan!(out.stdout_output();
         ("Hello, World!") => ()
-    ).unwrap()
+    )
+    .unwrap()
 }
 
 #[test]
@@ -54,7 +60,8 @@ fn test_script_short() {
     let out = cargo_eval!("tests/data/script-short.rs").unwrap();
     scan!(out.stdout_output();
         ("Some(1)") => ()
-    ).unwrap()
+    )
+    .unwrap()
 }
 
 #[test]
@@ -71,7 +78,8 @@ fn test_script_hyphens() {
         ("[0]:", let _: QuotedString, "[1]:", let arg: QuotedString) => {
             assert_eq!(arg, "-NotAnArg");
         }
-    ).unwrap()
+    )
+    .unwrap()
 }
 
 #[test]
@@ -85,20 +93,21 @@ fn test_script_slow_output() {
     let out = cargo_eval!(
         "--use-shared-binary-cache=no",
         "tests/data/script-slow-output.rs"
-    ).unwrap();
+    )
+    .unwrap();
     assert!(out.stderr_raw().contains("Compiling slow-build"));
     assert!(out.stderr_raw().contains("Compiling script-slow-output"));
     scan!(out.stdout_output();
         ("Ok") => ()
-    ).unwrap()
+    )
+    .unwrap()
 }
 
 #[test]
 fn test_script_cs_env() {
-    let out = cargo_eval!(
-        "tests/data/script-cs-env.rs"
-    ).unwrap();
+    let out = cargo_eval!("tests/data/script-cs-env.rs").unwrap();
     scan!(out.stdout_output();
         ("Ok") => ()
-    ).unwrap()
+    )
+    .unwrap()
 }
diff --git a/tests/tests/version.rs b/tests/tests/version.rs
index f8d74aee..0b173bac 100644
--- a/tests/tests/version.rs
+++ b/tests/tests/version.rs
@@ -4,5 +4,6 @@ fn test_version() {
     assert!(out.success());
     scan!(&out.stdout;
         ("cargo-eval", &::std::env::var("CARGO_PKG_VERSION").unwrap(), .._) => ()
-    ).unwrap();
+    )
+    .unwrap();
 }
diff --git a/tests/util/mod.rs b/tests/util/mod.rs
index 692a1dcf..f6935473 100644
--- a/tests/util/mod.rs
+++ b/tests/util/mod.rs
@@ -84,15 +84,16 @@ impl Output {
     pub fn stdout_output(&self) -> &str {
         assert!(self.success());
         for marker in self.stdout.matches(OUTPUT_MARKER) {
-            let i = subslice_offset(&self.stdout, marker)
-                .expect("couldn't find marker in output");
-            let before_cp = self.stdout[..i].chars().rev().next()
-                .unwrap_or('\n');
-            if !(before_cp == '\r' || before_cp == '\n') { continue; }
-            let after = &self.stdout[i+OUTPUT_MARKER.len()..];
-            let after_cp = after.chars().next()
-                .expect("couldn't find cp after marker");
-            if !(after_cp == '\r' || after_cp == '\n') { continue; }
+            let i = subslice_offset(&self.stdout, marker).expect("couldn't find marker in output");
+            let before_cp = self.stdout[..i].chars().rev().next().unwrap_or('\n');
+            if !(before_cp == '\r' || before_cp == '\n') {
+                continue;
+            }
+            let after = &self.stdout[i + OUTPUT_MARKER.len()..];
+            let after_cp = after.chars().next().expect("couldn't find cp after marker");
+            if !(after_cp == '\r' || after_cp == '\n') {
+                continue;
+            }
             return after;
         }
         panic!("could not find `{}` in script output", OUTPUT_MARKER);