Updated indent and rustversion.txt

diff --git a/src/bin/bench.rs b/src/bin/bench.rs
index 18c90c6248f808911501af30fc5809707341a299..774b3003cf7aaa77b7411036a9b5e89f2463ee04 100644 (file)
--- a/src/bin/bench.rs
+++ b/src/bin/bench.rs
@@ -73,10 +73,10 @@ Compilation can be customized with the `bench` profile in the manifest.
 pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
     let root = find_root_manifest_for_wd(options.flag_manifest_path, config.cwd())?;
     config.configure(options.flag_verbose,
-                          options.flag_quiet,
-                          &options.flag_color,
-                          options.flag_frozen,
-                          options.flag_locked)?;
+                     options.flag_quiet,
+                     &options.flag_color,
+                     options.flag_frozen,
+                     options.flag_locked)?;
     let ops = ops::TestOptions {
         no_run: options.flag_no_run,
         no_fail_fast: false,

diff --git a/src/bin/build.rs b/src/bin/build.rs
index 439201f7420356387c8987613475387231610ba8..7e6688b410fe9295211b9963689d9d13a0fa6c8e 100644 (file)
--- a/src/bin/build.rs
+++ b/src/bin/build.rs
@@ -70,10 +70,10 @@ pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
     debug!("executing; cmd=cargo-build; args={:?}",
            env::args().collect::<Vec<_>>());
     config.configure(options.flag_verbose,
-                          options.flag_quiet,
-                          &options.flag_color,
-                          options.flag_frozen,
-                          options.flag_locked)?;
+                     options.flag_quiet,
+                     &options.flag_color,
+                     options.flag_frozen,
+                     options.flag_locked)?;
 
     let root = find_root_manifest_for_wd(options.flag_manifest_path, config.cwd())?;
 

diff --git a/src/bin/cargo.rs b/src/bin/cargo.rs
index 94bcfbb9e9910b53e2fe8d48d869055e2c41aa0b..05c88019b55b083c14641fb82fcbc41639b2f0b3 100644 (file)
--- a/src/bin/cargo.rs
+++ b/src/bin/cargo.rs
@@ -117,10 +117,10 @@ each_subcommand!(declare_mod);
 */
 fn execute(flags: Flags, config: &Config) -> CliResult<Option<()>> {
     config.configure(flags.flag_verbose,
-                          flags.flag_quiet,
-                          &flags.flag_color,
-                          flags.flag_frozen,
-                          flags.flag_locked)?;
+                     flags.flag_quiet,
+                     &flags.flag_color,
+                     flags.flag_frozen,
+                     flags.flag_locked)?;
 
     init_git_transports(config);
     let _token = cargo::util::job::setup();

diff --git a/src/bin/clean.rs b/src/bin/clean.rs
index 5a36aa6005cfdd89fc65f71d48066e4caef0adc6..35146c687af92a0bcab9fad1c46985cfa4d66c07 100644 (file)
--- a/src/bin/clean.rs
+++ b/src/bin/clean.rs
@@ -45,10 +45,10 @@ and its format, see the `cargo help pkgid` command.
 pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
     debug!("executing; cmd=cargo-clean; args={:?}", env::args().collect::<Vec<_>>());
     config.configure(options.flag_verbose,
-                          options.flag_quiet,
-                          &options.flag_color,
-                          options.flag_frozen,
-                          options.flag_locked)?;
+                     options.flag_quiet,
+                     &options.flag_color,
+                     options.flag_frozen,
+                     options.flag_locked)?;
 
     let root = find_root_manifest_for_wd(options.flag_manifest_path, config.cwd())?;
     let opts = ops::CleanOptions {

diff --git a/src/bin/doc.rs b/src/bin/doc.rs
index c4de72dc07823c5bc21dced090f0d3420d240269..f8b434247a9b17315395ce8bd2cddb949a4f968e 100644 (file)
--- a/src/bin/doc.rs
+++ b/src/bin/doc.rs
@@ -63,10 +63,10 @@ the `cargo help pkgid` command.
 
 pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
     config.configure(options.flag_verbose,
-                          options.flag_quiet,
-                          &options.flag_color,
-                          options.flag_frozen,
-                          options.flag_locked)?;
+                     options.flag_quiet,
+                     &options.flag_color,
+                     options.flag_frozen,
+                     options.flag_locked)?;
 
     let root = find_root_manifest_for_wd(options.flag_manifest_path, config.cwd())?;
 

diff --git a/src/bin/fetch.rs b/src/bin/fetch.rs
index 8d191c55a791945992d1b5ff5f94eef976624800..877d53869a6fff5897e676300f02db61f269a31c 100644 (file)
--- a/src/bin/fetch.rs
+++ b/src/bin/fetch.rs
@@ -40,10 +40,10 @@ all updated.
 
 pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
     config.configure(options.flag_verbose,
-                          options.flag_quiet,
-                          &options.flag_color,
-                          options.flag_frozen,
-                          options.flag_locked)?;
+                     options.flag_quiet,
+                     &options.flag_color,
+                     options.flag_frozen,
+                     options.flag_locked)?;
     let root = find_root_manifest_for_wd(options.flag_manifest_path, config.cwd())?;
     let ws = Workspace::new(&root, config)?;
     ops::fetch(&ws)?;

diff --git a/src/bin/generate_lockfile.rs b/src/bin/generate_lockfile.rs
index 7c170d05bc22eb7cb1d5b69e4c2133cad4ad6991..40717435f04cca2ddb49b7040e39493512b358ab 100644 (file)
--- a/src/bin/generate_lockfile.rs
+++ b/src/bin/generate_lockfile.rs
@@ -34,10 +34,10 @@ Options:
 pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
     debug!("executing; cmd=cargo-generate-lockfile; args={:?}", env::args().collect::<Vec<_>>());
     config.configure(options.flag_verbose,
-                          options.flag_quiet,
-                          &options.flag_color,
-                          options.flag_frozen,
-                          options.flag_locked)?;
+                     options.flag_quiet,
+                     &options.flag_color,
+                     options.flag_frozen,
+                     options.flag_locked)?;
     let root = find_root_manifest_for_wd(options.flag_manifest_path, config.cwd())?;
 
     let ws = Workspace::new(&root, config)?;

diff --git a/src/bin/git_checkout.rs b/src/bin/git_checkout.rs
index ebfde445e53779694f94316388b06cc83886f946..268776c7b7456aec087328f81928fb8e79b6e2e7 100644 (file)
--- a/src/bin/git_checkout.rs
+++ b/src/bin/git_checkout.rs
@@ -31,10 +31,10 @@ Options:
 
 pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
     config.configure(options.flag_verbose,
-                          options.flag_quiet,
-                          &options.flag_color,
-                          options.flag_frozen,
-                          options.flag_locked)?;
+                     options.flag_quiet,
+                     &options.flag_color,
+                     options.flag_frozen,
+                     options.flag_locked)?;
     let Options { flag_url: url, flag_reference: reference, .. } = options;
 
     let url = url.to_url()?;

diff --git a/src/bin/init.rs b/src/bin/init.rs
index c5d5017f57697795dede427f2dd9b8cd126597a1..1b69a2204deb928a715188e1f6b0b96c12ea851a 100644 (file)
--- a/src/bin/init.rs
+++ b/src/bin/init.rs
@@ -42,10 +42,10 @@ Options:
 pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
     debug!("executing; cmd=cargo-init; args={:?}", env::args().collect::<Vec<_>>());
     config.configure(options.flag_verbose,
-                          options.flag_quiet,
-                          &options.flag_color,
-                          options.flag_frozen,
-                          options.flag_locked)?;
+                     options.flag_quiet,
+                     &options.flag_color,
+                     options.flag_frozen,
+                     options.flag_locked)?;
 
     let Options { flag_bin, flag_lib, arg_path, flag_name, flag_vcs, .. } = options;
 
@@ -60,8 +60,8 @@ pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
     ops::init(opts, config)?;
 
     config.shell().status("Created", format!("{} project",
-                                                   if opts_lib { "library" }
-                                                   else {"binary (application)"}))?;
+                                             if opts_lib { "library" }
+                                             else {"binary (application)"}))?;
 
     Ok(None)
 }

diff --git a/src/bin/install.rs b/src/bin/install.rs
index c9e75ade072c160b232cb7b5118661b5c7c21d32..c27db56ffaf9372237ccaa4d9a49a8adec5c66d8 100644 (file)
--- a/src/bin/install.rs
+++ b/src/bin/install.rs
@@ -96,10 +96,10 @@ The `--list` option will list all installed packages (and their versions).
 
 pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
     config.configure(options.flag_verbose,
-                          options.flag_quiet,
-                          &options.flag_color,
-                          options.flag_frozen,
-                          options.flag_locked)?;
+                     options.flag_quiet,
+                     &options.flag_color,
+                     options.flag_frozen,
+                     options.flag_locked)?;
 
     let compile_opts = ops::CompileOptions {
         config: config,

diff --git a/src/bin/login.rs b/src/bin/login.rs
index d93e11f8d3451f0e13609f343daac555afbb020b..6bb3618da1f4b94e85acccf914915f01f3d75273 100644 (file)
--- a/src/bin/login.rs
+++ b/src/bin/login.rs
@@ -36,10 +36,10 @@ Options:
 
 pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
     config.configure(options.flag_verbose,
-                          options.flag_quiet,
-                          &options.flag_color,
-                          options.flag_frozen,
-                          options.flag_locked)?;
+                     options.flag_quiet,
+                     &options.flag_color,
+                     options.flag_frozen,
+                     options.flag_locked)?;
     let token = match options.arg_token.clone() {
         Some(token) => token,
         None => {

diff --git a/src/bin/metadata.rs b/src/bin/metadata.rs
index df3b21ad6b65ddd0d0f0dc44bc8c21880fbe1f3f..7971d0707b7a32b32fd184fe3782f70817443b8f 100644 (file)
--- a/src/bin/metadata.rs
+++ b/src/bin/metadata.rs
@@ -44,10 +44,10 @@ Options:
 
 pub fn execute(options: Options, config: &Config) -> CliResult<Option<ExportInfo>> {
     config.configure(options.flag_verbose,
-                          options.flag_quiet,
-                          &options.flag_color,
-                          options.flag_frozen,
-                          options.flag_locked)?;
+                     options.flag_quiet,
+                     &options.flag_color,
+                     options.flag_frozen,
+                     options.flag_locked)?;
     let manifest = find_root_manifest_for_wd(options.flag_manifest_path, config.cwd())?;
 
     let options = OutputMetadataOptions {

diff --git a/src/bin/new.rs b/src/bin/new.rs
index da505af4970bc5797ef5022f8c382be9c45a7d3a..7b7ab664ba1bf869d99d584f09d834bc33270f28 100644 (file)
--- a/src/bin/new.rs
+++ b/src/bin/new.rs
@@ -42,10 +42,10 @@ Options:
 pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
     debug!("executing; cmd=cargo-new; args={:?}", env::args().collect::<Vec<_>>());
     config.configure(options.flag_verbose,
-                          options.flag_quiet,
-                          &options.flag_color,
-                          options.flag_frozen,
-                          options.flag_locked)?;
+                     options.flag_quiet,
+                     &options.flag_color,
+                     options.flag_frozen,
+                     options.flag_locked)?;
 
     let Options { flag_bin, flag_lib, arg_path, flag_name, flag_vcs, .. } = options;
 
@@ -59,9 +59,9 @@ pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
     ops::new(opts, config)?;
 
     config.shell().status("Created", format!("{} `{}` project",
-                                                   if opts_lib { "library" }
-                                                   else {"binary (application)"},
-                                                   arg_path))?;
+                                             if opts_lib { "library" }
+                                             else {"binary (application)"},
+                                             arg_path))?;
 
     Ok(None)
 }

diff --git a/src/bin/owner.rs b/src/bin/owner.rs
index f1232e99bfb543d785e72513010588f928b1ffa1..4c6976aa7d165084a52763d960ebb4d575e1f868 100644 (file)
--- a/src/bin/owner.rs
+++ b/src/bin/owner.rs
@@ -46,10 +46,10 @@ and troubleshooting.
 
 pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
     config.configure(options.flag_verbose,
-                          options.flag_quiet,
-                          &options.flag_color,
-                          options.flag_frozen,
-                          options.flag_locked)?;
+                     options.flag_quiet,
+                     &options.flag_color,
+                     options.flag_frozen,
+                     options.flag_locked)?;
     let opts = ops::OwnersOptions {
         krate: options.arg_crate,
         token: options.flag_token,

diff --git a/src/bin/package.rs b/src/bin/package.rs
index 66cf3ada7899ca0bd4edbfe24510e20a53345eba..f3f95a99c644123efceb9d6e369ed1f376b9d97e 100644 (file)
--- a/src/bin/package.rs
+++ b/src/bin/package.rs
@@ -41,10 +41,10 @@ Options:
 
 pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
     config.configure(options.flag_verbose,
-                          options.flag_quiet,
-                          &options.flag_color,
-                          options.flag_frozen,
-                          options.flag_locked)?;
+                     options.flag_quiet,
+                     &options.flag_color,
+                     options.flag_frozen,
+                     options.flag_locked)?;
     let root = find_root_manifest_for_wd(options.flag_manifest_path, config.cwd())?;
     let ws = Workspace::new(&root, config)?;
     ops::package(&ws, &ops::PackageOpts {

diff --git a/src/bin/pkgid.rs b/src/bin/pkgid.rs
index e0588cae3acf947bc4a0a00a930142e1fefb01ac..e18a505bf58c3b6fde0461a0784da8e36fd34437 100644 (file)
--- a/src/bin/pkgid.rs
+++ b/src/bin/pkgid.rs
@@ -55,10 +55,10 @@ Example Package IDs
 pub fn execute(options: Options,
                config: &Config) -> CliResult<Option<()>> {
     config.configure(options.flag_verbose,
-                          options.flag_quiet,
-                          &options.flag_color,
-                          options.flag_frozen,
-                          options.flag_locked)?;
+                     options.flag_quiet,
+                     &options.flag_color,
+                     options.flag_frozen,
+                     options.flag_locked)?;
     let root = find_root_manifest_for_wd(options.flag_manifest_path.clone(), config.cwd())?;
     let ws = Workspace::new(&root, config)?;
 

diff --git a/src/bin/publish.rs b/src/bin/publish.rs
index 60534f4cf4dd2e4a88acd9531625bf8f4fb1e401..56db84d17662267b895042fc1c8a471ebe7f58c4 100644 (file)
--- a/src/bin/publish.rs
+++ b/src/bin/publish.rs
@@ -44,10 +44,10 @@ Options:
 
 pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
     config.configure(options.flag_verbose,
-                          options.flag_quiet,
-                          &options.flag_color,
-                          options.flag_frozen,
-                          options.flag_locked)?;
+                     options.flag_quiet,
+                     &options.flag_color,
+                     options.flag_frozen,
+                     options.flag_locked)?;
     let Options {
         flag_token: token,
         flag_host: host,

diff --git a/src/bin/run.rs b/src/bin/run.rs
index 1de5ccbba78d4380d4bd2785e47e5c07ef8abef8..1e7089a75722bbed7d9f66580f00de49b8ca8950 100644 (file)
--- a/src/bin/run.rs
+++ b/src/bin/run.rs
@@ -59,10 +59,10 @@ the ones before go to Cargo.
 
 pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
     config.configure(options.flag_verbose,
-                          options.flag_quiet,
-                          &options.flag_color,
-                          options.flag_frozen,
-                          options.flag_locked)?;
+                     options.flag_quiet,
+                     &options.flag_color,
+                     options.flag_frozen,
+                     options.flag_locked)?;
 
     let root = find_root_manifest_for_wd(options.flag_manifest_path, config.cwd())?;
 

diff --git a/src/bin/rustc.rs b/src/bin/rustc.rs
index 1268c7ba266ca54d55ea1c8498f23326fb172e97..a73088bfd64ad2b04362190d7879ad4cce80d33f 100644 (file)
--- a/src/bin/rustc.rs
+++ b/src/bin/rustc.rs
@@ -77,13 +77,13 @@ pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
     debug!("executing; cmd=cargo-rustc; args={:?}",
            env::args().collect::<Vec<_>>());
     config.configure(options.flag_verbose,
-                          options.flag_quiet,
-                          &options.flag_color,
-                          options.flag_frozen,
-                          options.flag_locked)?;
+                     options.flag_quiet,
+                     &options.flag_color,
+                     options.flag_frozen,
+                     options.flag_locked)?;
 
     let root = find_root_manifest_for_wd(options.flag_manifest_path,
-                                              config.cwd())?;
+                                         config.cwd())?;
     let mode = match options.flag_profile.as_ref().map(|t| &t[..]) {
         Some("dev") | None => CompileMode::Build,
         Some("test") => CompileMode::Test,

diff --git a/src/bin/rustdoc.rs b/src/bin/rustdoc.rs
index d993a48503acf8f3415ae374aef8ba7be5147cc8..0d159f47a8e8cf9e1995f8b6e6c83538652d067d 100644 (file)
--- a/src/bin/rustdoc.rs
+++ b/src/bin/rustdoc.rs
@@ -72,13 +72,13 @@ the `cargo help pkgid` command.
 
 pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
     config.configure(options.flag_verbose,
-                          options.flag_quiet,
-                          &options.flag_color,
-                          options.flag_frozen,
-                          options.flag_locked)?;
+                     options.flag_quiet,
+                     &options.flag_color,
+                     options.flag_frozen,
+                     options.flag_locked)?;
 
     let root = find_root_manifest_for_wd(options.flag_manifest_path,
-                                              config.cwd())?;
+                                         config.cwd())?;
 
     let doc_opts = ops::DocOptions {
         open_result: options.flag_open,

diff --git a/src/bin/search.rs b/src/bin/search.rs
index 828356dc0d0702e63b7f904752bb3530b1e24748..eebe34988fbbcf0e5d21d3db364aef25c021f20c 100644 (file)
--- a/src/bin/search.rs
+++ b/src/bin/search.rs
@@ -35,10 +35,10 @@ Options:
 
 pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
     config.configure(options.flag_verbose,
-                          options.flag_quiet,
-                          &options.flag_color,
-                          options.flag_frozen,
-                          options.flag_locked)?;
+                     options.flag_quiet,
+                     &options.flag_color,
+                     options.flag_frozen,
+                     options.flag_locked)?;
     let Options {
         flag_host: host,
         flag_limit: limit,

diff --git a/src/bin/test.rs b/src/bin/test.rs
index 5ae7dee946aa963900d854f32e0c413cdedd4483..c28ff8fc431308c2707b147a190eef3ba984e69d 100644 (file)
--- a/src/bin/test.rs
+++ b/src/bin/test.rs
@@ -90,10 +90,10 @@ To get the list of all options available for the test binaries use this:
 
 pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
     config.configure(options.flag_verbose,
-                          options.flag_quiet,
-                          &options.flag_color,
-                          options.flag_frozen,
-                          options.flag_locked)?;
+                     options.flag_quiet,
+                     &options.flag_color,
+                     options.flag_frozen,
+                     options.flag_locked)?;
 
     let root = find_root_manifest_for_wd(options.flag_manifest_path, config.cwd())?;
 

diff --git a/src/bin/uninstall.rs b/src/bin/uninstall.rs
index 659702bd9f43f73ef70f0c97f14c560d26340c21..b5c827e7a4fd72c4a5df2d76fd499e594f51721e 100644 (file)
--- a/src/bin/uninstall.rs
+++ b/src/bin/uninstall.rs
@@ -39,10 +39,10 @@ only uninstall particular binaries.
 
 pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
     config.configure(options.flag_verbose,
-                          options.flag_quiet,
-                          &options.flag_color,
-                          options.flag_frozen,
-                          options.flag_locked)?;
+                     options.flag_quiet,
+                     &options.flag_color,
+                     options.flag_frozen,
+                     options.flag_locked)?;
 
     let root = options.flag_root.as_ref().map(|s| &s[..]);
     ops::uninstall(root, &options.arg_spec, &options.flag_bin, config)?;

diff --git a/src/bin/update.rs b/src/bin/update.rs
index 064bb5ee991389a07ef278eab2a3a696dcf413de..6cf1e79864c1844374d0bb381016255872bc519e 100644 (file)
--- a/src/bin/update.rs
+++ b/src/bin/update.rs
@@ -60,10 +60,10 @@ For more information about package id specifications, see `cargo help pkgid`.
 pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
     debug!("executing; cmd=cargo-update; args={:?}", env::args().collect::<Vec<_>>());
     config.configure(options.flag_verbose,
-                          options.flag_quiet,
-                          &options.flag_color,
-                          options.flag_frozen,
-                          options.flag_locked)?;
+                     options.flag_quiet,
+                     &options.flag_color,
+                     options.flag_frozen,
+                     options.flag_locked)?;
     let root = find_root_manifest_for_wd(options.flag_manifest_path, config.cwd())?;
 
     let update_opts = ops::UpdateOptions {

diff --git a/src/bin/verify_project.rs b/src/bin/verify_project.rs
index 447bf7a5dc870a0bc5cd9b5d0480034591ceb229..726e1ab358b7ec1bc1ff59256903814e47bbf0bf 100644 (file)
--- a/src/bin/verify_project.rs
+++ b/src/bin/verify_project.rs
@@ -39,10 +39,10 @@ Options:
 
 pub fn execute(args: Flags, config: &Config) -> CliResult<Option<Error>> {
     config.configure(args.flag_verbose,
-                          args.flag_quiet,
-                          &args.flag_color,
-                          args.flag_frozen,
-                          args.flag_locked)?;
+                     args.flag_quiet,
+                     &args.flag_color,
+                     args.flag_frozen,
+                     args.flag_locked)?;
 
     let mut contents = String::new();
     let filename = args.flag_manifest_path.unwrap_or("Cargo.toml".into());

diff --git a/src/bin/yank.rs b/src/bin/yank.rs
index bac383c4fcdcd64000f27a9f0a04d9f8c0d5741e..760e8cb80b0e1ae3ef97252a5ac8845ff277797d 100644 (file)
--- a/src/bin/yank.rs
+++ b/src/bin/yank.rs
@@ -44,16 +44,16 @@ crates to be locked to any yanked version.
 
 pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
     config.configure(options.flag_verbose,
-                          options.flag_quiet,
-                          &options.flag_color,
-                          options.flag_frozen,
-                          options.flag_locked)?;
+                     options.flag_quiet,
+                     &options.flag_color,
+                     options.flag_frozen,
+                     options.flag_locked)?;
     ops::yank(config,
-                   options.arg_crate,
-                   options.flag_vers,
-                   options.flag_token,
-                   options.flag_index,
-                   options.flag_undo)?;
+              options.arg_crate,
+              options.flag_vers,
+              options.flag_token,
+              options.flag_index,
+              options.flag_undo)?;
     Ok(None)
 }
 

diff --git a/src/cargo/core/package.rs b/src/cargo/core/package.rs
index 6fa0bb7f3e0f8bbd15f0cc7f2f1fff83eaafab77..03ed7d88729d6f5f72288a1a76b81e80738c269b 100644 (file)
--- a/src/cargo/core/package.rs
+++ b/src/cargo/core/package.rs
@@ -74,7 +74,7 @@ impl Package {
         let path = manifest_path.parent().unwrap();
         let source_id = SourceId::for_path(path)?;
         let (pkg, _) = ops::read_package(&manifest_path, &source_id,
-                                              config)?;
+                                         config)?;
         Ok(pkg)
     }
 

diff --git a/src/cargo/core/resolver/mod.rs b/src/cargo/core/resolver/mod.rs
index b67e32d56dc83492b233823f243e3eb982b5af58..0469f3c23309f32d6c2aa9912211d8f9f919cc5e 100644 (file)
--- a/src/cargo/core/resolver/mod.rs
+++ b/src/cargo/core/resolver/mod.rs
@@ -451,7 +451,7 @@ fn activate_deps_loop<'a>(mut cx: Context<'a>,
         let summary = Rc::new(summary.clone());
         let candidate = Candidate { summary: summary, replace: None };
         remaining_deps.extend(activate(&mut cx, registry, None, candidate,
-                                            method)?);
+                                       method)?);
     }
 
     // Main resolution loop, this is the workhorse of the resolution algorithm.
@@ -559,7 +559,7 @@ fn activate_deps_loop<'a>(mut cx: Context<'a>,
         trace!("{}[{}]>{} trying {}", parent.name(), cur, dep.name(),
                candidate.summary.version());
         remaining_deps.extend(activate(&mut cx, registry, Some(&parent),
-                                            candidate, &method)?);
+                              candidate, &method)?);
     }
 
     Ok(cx)
@@ -713,7 +713,7 @@ fn build_features(s: &Summary, method: &Method)
             }
             for dep in s.dependencies().iter().filter(|d| d.is_optional()) {
                 add_feature(s, dep.name(), &mut deps, &mut used,
-                                 &mut visited)?;
+                            &mut visited)?;
             }
         }
         Method::Required { features: requested_features, .. } =>  {
@@ -727,7 +727,7 @@ fn build_features(s: &Summary, method: &Method)
         Method::Required { uses_default_features: true, .. } => {
             if s.features().get("default").is_some() {
                 add_feature(s, "default", &mut deps, &mut used,
-                                 &mut visited)?;
+                            &mut visited)?;
             }
         }
         Method::Required { uses_default_features: false, .. } => {}
@@ -989,10 +989,10 @@ fn check_cycles(resolve: &Resolve,
     for pkg in all_packages {
         if !checked.contains(pkg) {
             visit(resolve,
-                       pkg,
-                       &summaries,
-                       &mut HashSet::new(),
-                       &mut checked)?
+                  pkg,
+                  &summaries,
+                  &mut HashSet::new(),
+                  &mut checked)?
         }
     }
     return Ok(());

diff --git a/src/cargo/core/workspace.rs b/src/cargo/core/workspace.rs
index 95b2cd67fdb46d4a38096690946042f14d70945c..f35432f646986c581c6635099319b5659d053c2f 100644 (file)
--- a/src/cargo/core/workspace.rs
+++ b/src/cargo/core/workspace.rs
@@ -483,7 +483,7 @@ impl<'cfg> Packages<'cfg> {
             Entry::Vacant(v) => {
                 let source_id = SourceId::for_path(key)?;
                 let pair = ops::read_manifest(&manifest_path, &source_id,
-                                                   self.config)?;
+                                              self.config)?;
                 let (manifest, _nested_paths) = pair;
                 Ok(v.insert(match manifest {
                     EitherManifest::Real(manifest) => {

diff --git a/src/cargo/ops/cargo_compile.rs b/src/cargo/ops/cargo_compile.rs
index a8ebb30e2c8fc2ea615d949f4525ab189576e2af..74b787694763d1c02558c6c1fe3bd38ee5bcaa22 100644 (file)
--- a/src/cargo/ops/cargo_compile.rs
+++ b/src/cargo/ops/cargo_compile.rs
@@ -205,7 +205,7 @@ pub fn compile_ws<'a>(ws: &Workspace<'a>,
         }
         (Some(args), _) => {
             let targets = generate_targets(to_builds[0], profiles,
-                                                mode, filter, release)?;
+                                           mode, filter, release)?;
             if targets.len() == 1 {
                 let (target, profile) = targets[0];
                 let mut profile = profile.clone();
@@ -219,7 +219,7 @@ pub fn compile_ws<'a>(ws: &Workspace<'a>,
         }
         (None, Some(args)) => {
             let targets = generate_targets(to_builds[0], profiles,
-                                                mode, filter, release)?;
+                                           mode, filter, release)?;
             if targets.len() == 1 {
                 let (target, profile) = targets[0];
                 let mut profile = profile.clone();
@@ -234,7 +234,7 @@ pub fn compile_ws<'a>(ws: &Workspace<'a>,
         (None, None) => {
             for &to_build in to_builds.iter() {
                 let targets = generate_targets(to_build, profiles, mode,
-                                                    filter, release)?;
+                                               filter, release)?;
                 package_targets.push((to_build, targets));
             }
         }
@@ -257,12 +257,12 @@ pub fn compile_ws<'a>(ws: &Workspace<'a>,
         }
 
         ops::compile_targets(ws,
-                                  &package_targets,
-                                  &packages,
-                                  &resolve_with_overrides,
-                                  config,
-                                  build_config,
-                                  profiles)?
+                             &package_targets,
+                             &packages,
+                             &resolve_with_overrides,
+                             config,
+                             build_config,
+                             profiles)?
     };
 
     ret.to_doc_test = to_builds.iter().map(|&p| p.clone()).collect();

diff --git a/src/cargo/ops/cargo_generate_lockfile.rs b/src/cargo/ops/cargo_generate_lockfile.rs
index c09ee67022f78bc36ef6b49bafffb8858bf68716..989534cea79b454ec60ccfd7e6f455948619a367 100644 (file)
--- a/src/cargo/ops/cargo_generate_lockfile.rs
+++ b/src/cargo/ops/cargo_generate_lockfile.rs
@@ -18,8 +18,8 @@ pub struct UpdateOptions<'a> {
 pub fn generate_lockfile(ws: &Workspace) -> CargoResult<()> {
     let mut registry = PackageRegistry::new(ws.config())?;
     let resolve = ops::resolve_with_previous(&mut registry, ws,
-                                                  Method::Everything,
-                                                  None, None, &[])?;
+                                             Method::Everything,
+                                             None, None, &[])?;
     ops::write_pkg_lockfile(ws, &resolve)?;
     Ok(())
 }

diff --git a/src/cargo/ops/cargo_install.rs b/src/cargo/ops/cargo_install.rs
index b9a5aa85b06fad6dddeeb70dc1f922932b266e08..c2a348e2e99031b90c42485263d227b5f01bf6c1 100644 (file)
--- a/src/cargo/ops/cargo_install.rs
+++ b/src/cargo/ops/cargo_install.rs
@@ -57,7 +57,7 @@ pub fn install(root: Option<&str>,
     let map = SourceConfigMap::new(config)?;
     let (pkg, source) = if source_id.is_git() {
         select_pkg(GitSource::new(source_id, config), source_id,
-                        krate, vers, &mut |git| git.read_packages())?
+                   krate, vers, &mut |git| git.read_packages())?
     } else if source_id.is_path() {
         let path = source_id.url().to_file_path().ok()
                             .expect("path sources must have a valid path");
@@ -68,14 +68,14 @@ pub fn install(root: Option<&str>,
                            specify an alternate source", path.display()))
         })?;
         select_pkg(PathSource::new(&path, source_id, config),
-                        source_id, krate, vers,
-                        &mut |path| path.read_packages())?
+                   source_id, krate, vers,
+                   &mut |path| path.read_packages())?
     } else {
         select_pkg(map.load(source_id)?,
-                        source_id, krate, vers,
-                        &mut |_| Err(human("must specify a crate to install from \
-                                            crates.io, or use --path or --git to \
-                                            specify alternate source")))?
+                   source_id, krate, vers,
+                   &mut |_| Err(human("must specify a crate to install from \
+                                       crates.io, or use --path or --git to \
+                                       specify alternate source")))?
     };
 
 

diff --git a/src/cargo/ops/cargo_output_metadata.rs b/src/cargo/ops/cargo_output_metadata.rs
index b8dfca5ef363cdf08974ca2210ce1fdf82de4a64..bc1a04f0cfdb84ad6a82b4d08f106d3f542c17b2 100644 (file)
--- a/src/cargo/ops/cargo_output_metadata.rs
+++ b/src/cargo/ops/cargo_output_metadata.rs
@@ -47,11 +47,11 @@ fn metadata_full(ws: &Workspace,
         PackageIdSpec::from_package_id(pkg.package_id())
     }).collect::<Vec<_>>();
     let deps = ops::resolve_dependencies(ws,
-                                              None,
-                                              &opt.features,
-                                              opt.all_features,
-                                              opt.no_default_features,
-                                              &specs)?;
+                                         None,
+                                         &opt.features,
+                                         opt.all_features,
+                                         opt.no_default_features,
+                                         &specs)?;
     let (packages, resolve) = deps;
 
     let packages = try!(packages.package_ids()

diff --git a/src/cargo/ops/cargo_rustc/layout.rs b/src/cargo/ops/cargo_rustc/layout.rs
index 1e371a9517e1d07328c029c81542f1a2e5001f55..dae91aae79ff8e9354e4e884d82fd1147afdb0b4 100644 (file)
--- a/src/cargo/ops/cargo_rustc/layout.rs
+++ b/src/cargo/ops/cargo_rustc/layout.rs
@@ -78,8 +78,7 @@ impl Layout {
         // the target triple as a Path and then just use the file stem as the
         // component for the directory name.
         if let Some(triple) = triple {
-            path.push(Path::new(triple).file_stem()
-                           .ok_or(human(format!("target was empty")))?);
+            path.push(Path::new(triple).file_stem().ok_or(human(format!("target was empty")))?);
         }
         path.push(dest);
         Layout::at(ws.config(), path)

diff --git a/src/cargo/ops/resolve.rs b/src/cargo/ops/resolve.rs
index 42898b6afc93b7834b36ecd584fa254ddda7ac75..335c06b88d784c4604f063511f3b5c50eb63185d 100644 (file)
--- a/src/cargo/ops/resolve.rs
+++ b/src/cargo/ops/resolve.rs
@@ -15,8 +15,8 @@ pub fn resolve_ws(registry: &mut PackageRegistry, ws: &Workspace)
                    -> CargoResult<Resolve> {
     let prev = ops::load_pkg_lockfile(ws)?;
     let resolve = resolve_with_previous(registry, ws,
-                                             Method::Everything,
-                                             prev.as_ref(), None, &[])?;
+                                        Method::Everything,
+                                        prev.as_ref(), None, &[])?;
 
     // Avoid writing a lockfile if we are `cargo install`ing a non local package.
     if ws.current_opt().map(|pkg| pkg.package_id().source_id().is_path()).unwrap_or(true) {
@@ -88,8 +88,7 @@ pub fn resolve_with_previous<'a>(registry: &mut PackageRegistry,
 
     let mut summaries = Vec::new();
     for member in ws.members() {
-        registry.add_sources(&[member.package_id().source_id()
-                                          .clone()])?;
+        registry.add_sources(&[member.package_id().source_id().clone()])?;
         let method_to_resolve = match method {
             // When everything for a workspace we want to be sure to resolve all
             // members in the workspace, so propagate the `Method::Everything`.

diff --git a/src/cargo/sources/path.rs b/src/cargo/sources/path.rs
index 197d756d66fab5f72910b8717287194ad72023a8..e5a7ae6f8ce427c8568a597dccb15043af3bdc22 100644 (file)
--- a/src/cargo/sources/path.rs
+++ b/src/cargo/sources/path.rs
@@ -94,10 +94,8 @@ impl<'cfg> PathSource<'cfg> {
                 human(format!("could not parse pattern `{}`: {}", p, e))
             })
         };
-        let exclude = pkg.manifest().exclude().iter()
-                              .map(|p| parse(p)).collect::<Result<Vec<_>, _>>()?;
-        let include = pkg.manifest().include().iter()
-                              .map(|p| parse(p)).collect::<Result<Vec<_>, _>>()?;
+        let exclude = pkg.manifest().exclude().iter().map(|p| parse(p)).collect::<Result<Vec<_>, _>>()?;
+        let include = pkg.manifest().include().iter().map(|p| parse(p)).collect::<Result<Vec<_>, _>>()?;
 
         let mut filter = |p: &Path| {
             let relative_path = util::without_prefix(p, &root).unwrap();

diff --git a/src/cargo/sources/registry/local.rs b/src/cargo/sources/registry/local.rs
index 6c108cd90171c6d8a97fa6cbffdb50afb655a338..67e88a9c72df829339c2202e5668adf2e5a8fac6 100644 (file)
--- a/src/cargo/sources/registry/local.rs
+++ b/src/cargo/sources/registry/local.rs
@@ -61,8 +61,8 @@ impl<'cfg> RegistryData for LocalRegistry<'cfg> {
                 -> CargoResult<FileLock> {
         let crate_file = format!("{}-{}.crate", pkg.name(), pkg.version());
         let mut crate_file = self.root.open_ro(&crate_file,
-                                                    self.config,
-                                                    "crate file")?;
+                                               self.config,
+                                               "crate file")?;
 
         // If we've already got an unpacked version of this crate, then skip the
         // checksum below as it is in theory already verified.

diff --git a/src/cargo/sources/registry/remote.rs b/src/cargo/sources/registry/remote.rs
index d4bc144889ac2c469327a9634baf7e3128500455..480b7185950a626b56c57bed44cf116af79a1b0d 100644 (file)
--- a/src/cargo/sources/registry/remote.rs
+++ b/src/cargo/sources/registry/remote.rs
@@ -45,8 +45,8 @@ impl<'cfg> RegistryData for RemoteRegistry<'cfg> {
 
     fn config(&self) -> CargoResult<Option<RegistryConfig>> {
         let lock = self.index_path.open_ro(Path::new(INDEX_LOCK),
-                                                self.config,
-                                                "the registry index")?;
+                                           self.config,
+                                           "the registry index")?;
         let path = lock.path().parent().unwrap();
         let contents = paths::read(&path.join("config.json"))?;
         let config = json::decode(&contents)?;
@@ -65,8 +65,8 @@ impl<'cfg> RegistryData for RemoteRegistry<'cfg> {
         // Then we actually update the index
         self.index_path.create_dir()?;
         let lock = self.index_path.open_rw(Path::new(INDEX_LOCK),
-                                                self.config,
-                                                "the registry index")?;
+                                           self.config,
+                                           "the registry index")?;
         let path = lock.path().parent().unwrap();
 
         self.config.shell().status("Updating",

diff --git a/src/cargo/util/flock.rs b/src/cargo/util/flock.rs
index a6f90afc33552442f089a5000e34a1ad4fd459ae..a20540d06c3ab2c47f866e8243bda8b75db7a7cf 100644 (file)
--- a/src/cargo/util/flock.rs
+++ b/src/cargo/util/flock.rs
@@ -217,13 +217,13 @@ impl Filesystem {
         match state {
             State::Exclusive => {
                 acquire(config, msg, &path,
-                             &|| f.try_lock_exclusive(),
-                             &|| f.lock_exclusive())?;
+                        &|| f.try_lock_exclusive(),
+                        &|| f.lock_exclusive())?;
             }
             State::Shared => {
                 acquire(config, msg, &path,
-                             &|| f.try_lock_shared(),
-                             &|| f.lock_shared())?;
+                        &|| f.try_lock_shared(),
+                        &|| f.lock_shared())?;
             }
             State::Unlocked => {}
 

diff --git a/src/cargo/util/paths.rs b/src/cargo/util/paths.rs
index 23a42a84c706d8e007e1a06f24176b134c0ee5c2..d47598a2ece148aab39d562967182408cd50954b 100644 (file)
--- a/src/cargo/util/paths.rs
+++ b/src/cargo/util/paths.rs
@@ -102,10 +102,10 @@ pub fn write(path: &Path, contents: &[u8]) -> CargoResult<()> {
 pub fn append(path: &Path, contents: &[u8]) -> CargoResult<()> {
     (|| -> CargoResult<()> {
         let mut f = OpenOptions::new()
-                            .write(true)
-                            .append(true)
-                            .create(true)
-                            .open(path)?;
+                                 .write(true)
+                                 .append(true)
+                                 .create(true)
+                                 .open(path)?;
 
         f.write_all(contents)?;
         Ok(())

diff --git a/src/cargo/util/toml.rs b/src/cargo/util/toml.rs
index c45ef1707a79e4f3cfb441d13ccbe7caab348bc1..ca61e3a546baeb0cf40c9a8f7c3e1828ecacbcda 100644 (file)
--- a/src/cargo/util/toml.rs
+++ b/src/cargo/util/toml.rs
@@ -597,24 +597,15 @@ impl TomlManifest {
             }
 
             // Collect the deps
-            process_dependencies(&mut cx, self.dependencies.as_ref(),
-                                      None)?;
-            process_dependencies(&mut cx, self.dev_dependencies.as_ref(),
-                                      Some(Kind::Development))?;
-            process_dependencies(&mut cx, self.build_dependencies.as_ref(),
-                                      Some(Kind::Build))?;
+            process_dependencies(&mut cx, self.dependencies.as_ref(), None)?;
+            process_dependencies(&mut cx, self.dev_dependencies.as_ref(), Some(Kind::Development))?;
+            process_dependencies(&mut cx, self.build_dependencies.as_ref(), Some(Kind::Build))?;
 
             for (name, platform) in self.target.iter().flat_map(|t| t) {
                 cx.platform = Some(name.parse()?);
-                process_dependencies(&mut cx,
-                                          platform.dependencies.as_ref(),
-                                          None)?;
-                process_dependencies(&mut cx,
-                                          platform.build_dependencies.as_ref(),
-                                          Some(Kind::Build))?;
-                process_dependencies(&mut cx,
-                                          platform.dev_dependencies.as_ref(),
-                                          Some(Kind::Development))?;
+                process_dependencies(&mut cx, platform.dependencies.as_ref(), None)?;
+                process_dependencies(&mut cx, platform.build_dependencies.as_ref(), Some(Kind::Build))?;
+                process_dependencies(&mut cx, platform.dev_dependencies.as_ref(), Some(Kind::Development))?;
             }
 
             replace = self.replace(&mut cx)?;
@@ -635,9 +626,7 @@ impl TomlManifest {
         let exclude = project.exclude.clone().unwrap_or(Vec::new());
         let include = project.include.clone().unwrap_or(Vec::new());
 
-        let summary = Summary::new(pkgid, deps,
-                                        self.features.clone()
-                                            .unwrap_or(HashMap::new()))?;
+        let summary = Summary::new(pkgid, deps, self.features.clone() .unwrap_or(HashMap::new()))?;
         let metadata = ManifestMetadata {
             description: project.description.clone(),
             homepage: project.homepage.clone(),

diff --git a/src/rustversion.txt b/src/rustversion.txt
index 53b3604545efe2e872265ba9ffb6f836c3ea091c..e10ea319408b5bf22b7332c4a7b324f709850f55 100644 (file)
--- a/src/rustversion.txt
+++ b/src/rustversion.txt
@@ -1 +1 @@
-2016-10-21
+2016-11-11

diff --git a/tests/cargotest/support/mod.rs b/tests/cargotest/support/mod.rs
index 6da0aa56cef253bec9185d3838cf9223054262e2..3a13b46baeccd1f0bb569a31adfd1fe74d096966 100644 (file)
--- a/tests/cargotest/support/mod.rs
+++ b/tests/cargotest/support/mod.rs
@@ -316,14 +316,14 @@ impl Execs {
 
     fn match_stdout(&self, actual: &Output) -> ham::MatchResult {
         self.match_std(self.expect_stdout.as_ref(), &actual.stdout,
-                            "stdout", &actual.stderr, false)?;
+                       "stdout", &actual.stderr, false)?;
         for expect in self.expect_stdout_contains.iter() {
             self.match_std(Some(expect), &actual.stdout, "stdout",
-                                &actual.stderr, true)?;
+                           &actual.stderr, true)?;
         }
         for expect in self.expect_stderr_contains.iter() {
             self.match_std(Some(expect), &actual.stderr, "stderr",
-                                &actual.stdout, true)?;
+                           &actual.stdout, true)?;
         }
 
         if let Some(ref objects) = self.expect_json {

diff --git a/tests/resolve.rs b/tests/resolve.rs
index b40c26f840a2b489cfb6575019a362db3d210aea..15f583b51c1f0b8505b8568d41442a7ff1c97f41 100644 (file)
--- a/tests/resolve.rs
+++ b/tests/resolve.rs
@@ -18,9 +18,7 @@ fn resolve<R: Registry>(pkg: PackageId, deps: Vec<Dependency>,
                         -> CargoResult<Vec<PackageId>> {
     let summary = Summary::new(pkg.clone(), deps, HashMap::new()).unwrap();
     let method = Method::Everything;
-    Ok(resolver::resolve(&[(summary, method)],
-                              &[],
-                              registry)?.iter().map(|p| {
+    Ok(resolver::resolve(&[(summary, method)], &[], registry)?.iter().map(|p| {
         p.clone()
     }).collect())
 }