Merge branch 'master' into multiline_assert

Author: gilescope

Cargo.lock

@@ -15,9 +15,13 @@ pub enum Verbosity {
 }
 
 pub struct Shell {
-    err: StandardStream,
+    err: ShellOut,
     verbosity: Verbosity,
-    choice: ColorChoice,
+}
+
+enum ShellOut {
+    Write(Box<Write>),
+    Stream(StandardStream, ColorChoice),
 }
 
 #[derive(PartialEq, Clone, Copy)]
@@ -30,9 +34,18 @@ pub enum ColorChoice {
 impl Shell {
     pub fn new() -> Shell {
         Shell {
-            err: StandardStream::stderr(ColorChoice::CargoAuto.to_termcolor_color_choice()),
+            err: ShellOut::Stream(
+                StandardStream::stderr(ColorChoice::CargoAuto.to_termcolor_color_choice()),
+                ColorChoice::CargoAuto,
+            ),
+            verbosity: Verbosity::Verbose,
+        }
+    }
+
+    pub fn from_write(out: Box<Write>) -> Shell {
+        Shell {
+            err: ShellOut::Write(out),
             verbosity: Verbosity::Verbose,
-            choice: ColorChoice::CargoAuto,
         }
     }
 
@@ -44,24 +57,13 @@ impl Shell {
         match self.verbosity {
             Verbosity::Quiet => Ok(()),
             _ => {
-                self.err.reset()?;
-                self.err.set_color(ColorSpec::new()
-                                        .set_bold(true)
-                                        .set_fg(Some(color)))?;
-                if justified {
-                    write!(self.err, "{:>12}", status)?;
-                } else {
-                    write!(self.err, "{}", status)?;
-                }
-                self.err.reset()?;
-                write!(self.err, " {}\n", message)?;
-                Ok(())
+                self.err.print(status, message, color, justified)
             }
         }
     }
 
-    pub fn err(&mut self) -> &mut StandardStream {
-        &mut self.err
+    pub fn err(&mut self) -> &mut Write {
+        self.err.as_write()
     }
 
     pub fn status<T, U>(&mut self, status: T, message: U) -> CargoResult<()>
@@ -117,23 +119,68 @@ impl Shell {
     }
 
     pub fn set_color_choice(&mut self, color: Option<&str>) -> CargoResult<()> {
-        let cfg = match color {
-            Some("always") => ColorChoice::Always,
-            Some("never") => ColorChoice::Never,
+        if let ShellOut::Stream(ref mut err, ref mut cc) =  self.err {
+            let cfg = match color {
+                Some("always") => ColorChoice::Always,
+                Some("never") => ColorChoice::Never,
+
+                Some("auto") |
+                None => ColorChoice::CargoAuto,
+
+                Some(arg) => bail!("argument for --color must be auto, always, or \
+                                    never, but found `{}`", arg),
+            };
+            *cc = cfg;
+            *err = StandardStream::stderr(cfg.to_termcolor_color_choice());
+        }
+        Ok(())
+    }
 
-            Some("auto") |
-            None => ColorChoice::CargoAuto,
+    pub fn color_choice(&self) -> ColorChoice {
+        match self.err {
+            ShellOut::Stream(_, cc) => cc,
+            ShellOut::Write(_) => ColorChoice::Never,
+        }
+    }
+}
 
-            Some(arg) => bail!("argument for --color must be auto, always, or \
-                                never, but found `{}`", arg),
-        };
-        self.choice = cfg;
-        self.err = StandardStream::stderr(cfg.to_termcolor_color_choice());
-        return Ok(());
+impl ShellOut {
+    fn print(&mut self,
+             status: &fmt::Display,
+             message: &fmt::Display,
+             color: Color,
+             justified: bool) -> CargoResult<()> {
+        match *self {
+            ShellOut::Stream(ref mut err, _) => {
+                err.reset()?;
+                err.set_color(ColorSpec::new()
+                                    .set_bold(true)
+                                    .set_fg(Some(color)))?;
+                if justified {
+                    write!(err, "{:>12}", status)?;
+                } else {
+                    write!(err, "{}", status)?;
+                }
+                err.reset()?;
+                write!(err, " {}\n", message)?;
+            }
+            ShellOut::Write(ref mut w) => {
+                if justified {
+                    write!(w, "{:>12}", status)?;
+                } else {
+                    write!(w, "{}", status)?;
+                }
+                write!(w, " {}\n", message)?;
+            }
+        }
+        Ok(())
     }
 
-    pub fn color_choice(&self) -> ColorChoice {
-        self.choice
+    fn as_write(&mut self) -> &mut Write {
+        match *self {
+            ShellOut::Stream(ref mut err, _) => err,
+            ShellOut::Write(ref mut w) => w,
+        }
     }
 }
 

src/cargo/core/shell.rs

@@ -33,7 +33,6 @@ extern crate termcolor;
 extern crate toml;
 extern crate url;
 
-use std::io::Write;
 use std::fmt;
 use std::error::Error;
 

src/cargo/lib.rs

@@ -1,7 +1,6 @@
 use std::collections::BTreeMap;
 use std::env;
 use std::fs;
-use std::io::Write;
 use std::path::Path;
 
 use serde::{Deserialize, Deserializer};

src/cargo/ops/cargo_new.rs

@@ -1,7 +1,7 @@
 use std::collections::HashSet;
 use std::collections::hash_map::HashMap;
 use std::fmt;
-use std::io::{self, Write};
+use std::io;
 use std::mem;
 use std::sync::mpsc::{channel, Sender, Receiver};
 
@@ -113,7 +113,7 @@ impl<'a> JobQueue<'a> {
         let _p = profile::start("executing the job graph");
 
         // We need to give a handle to the send half of our message queue to the
-        // jobserver helper thrad. Unfortunately though we need the handle to be
+        // jobserver helper thread. Unfortunately though we need the handle to be
         // `'static` as that's typically what's required when spawning a
         // thread!
         //

src/cargo/ops/cargo_rustc/job_queue.rs

@@ -1,6 +1,5 @@
 use std::env;
 use std::fs::{self, File};
-use std::io::Write;
 use std::iter::repeat;
 use std::time::Duration;
 

src/cargo/ops/registry.rs

@@ -1415,12 +1415,9 @@ fn normalize(package_root: &Path,
 
     if let Some(ref lib) = *lib {
         lib_target(&mut ret, lib);
-        bin_targets(&mut ret, bins,
-                    &mut |bin| inferred_bin_path(bin, package_root, true, bins.len()));
-    } else if bins.len() > 0 {
-        bin_targets(&mut ret, bins,
-                    &mut |bin| inferred_bin_path(bin, package_root, false, bins.len()));
     }
+    bin_targets(&mut ret, bins,
+                &mut |bin| inferred_bin_path(bin, lib.is_some(), package_root, bins.len()));
 
 
     if let Some(custom_build) = custom_build {
@@ -1443,32 +1440,9 @@ fn normalize(package_root: &Path,
 }
 
 fn inferred_bin_path(bin: &TomlBinTarget,
+                     has_lib: bool,
                      package_root: &Path,
-                     lib: bool,
                      bin_len: usize) -> PathBuf {
-    // we have a lib with multiple bins, so the bins are expected to be located
-    // inside src/bin
-    if lib && bin_len > 1 {
-        return Path::new("src").join("bin").join(&format!("{}.rs", bin.name()))
-                    .to_path_buf()
-    }
-
-    // we have a lib with one bin, so it's either src/main.rs, src/bin/foo.rs or
-    // src/bin/main.rs
-    if lib && bin_len == 1 {
-        let path = Path::new("src").join(&format!("main.rs"));
-        if package_root.join(&path).exists() {
-            return path.to_path_buf()
-        }
-
-        let path = Path::new("src").join("bin").join(&format!("{}.rs", bin.name()));
-        if package_root.join(&path).exists() {
-            return path.to_path_buf()
-        }
-
-        return Path::new("src").join("bin").join(&format!("main.rs")).to_path_buf()
-    }
-
     // here we have a single bin, so it may be located in src/main.rs, src/foo.rs,
     // srb/bin/foo.rs or src/bin/main.rs
     if bin_len == 1 {
@@ -1477,9 +1451,11 @@ fn inferred_bin_path(bin: &TomlBinTarget,
             return path.to_path_buf()
         }
 
-        let path = Path::new("src").join(&format!("{}.rs", bin.name()));
-        if package_root.join(&path).exists() {
-            return path.to_path_buf()
+        if !has_lib {
+            let path = Path::new("src").join(&format!("{}.rs", bin.name()));
+            if package_root.join(&path).exists() {
+                return path.to_path_buf()
+            }
         }
 
         let path = Path::new("src").join("bin").join(&format!("{}.rs", bin.name()));
@@ -1496,9 +1472,11 @@ fn inferred_bin_path(bin: &TomlBinTarget,
         return path.to_path_buf()
     }
 
-    let path = Path::new("src").join(&format!("{}.rs", bin.name()));
-    if package_root.join(&path).exists() {
-        return path.to_path_buf()
+    if !has_lib {
+        let path = Path::new("src").join(&format!("{}.rs", bin.name()));
+        if package_root.join(&path).exists() {
+            return path.to_path_buf()
+        }
     }
 
     let path = Path::new("src").join("bin").join(&format!("main.rs"));

src/cargo/util/toml.rs

@@ -242,11 +242,10 @@ fn cargo_bench_failing_test() {
 [FINISHED] release [optimized] target(s) in [..]
 [RUNNING] target[/]release[/]deps[/]foo-[..][EXE]
 thread '[..]' panicked at 'assertion failed: \
-    `(left == right)`
- left: `\"hello\"`,
-right: `\"nope\"`', src[/]foo.rs:14
-[..]
-", p.url()))
+    `(left == right)`[..]", p.url()))
+                       .with_stderr_contains("[..]left: `\"hello\"`[..]")
+                       .with_stderr_contains("[..]right: `\"nope\"`[..]")
+                       .with_stderr_contains("[..]src[/]foo.rs:14")
                        .with_status(101));
 }
 

tests/bench.rs

@@ -3229,3 +3229,45 @@ fn deterministic_cfg_flags() {
 --cfg cfg_a --cfg cfg_b --cfg cfg_c --cfg cfg_d --cfg cfg_e`
 [FINISHED] dev [unoptimized + debuginfo] target(s) in [..]"));
 }
+
+#[test]
+fn explicit_bins_without_paths() {
+    let p = project("foo")
+        .file("Cargo.toml", r#"
+            [package]
+            name = "foo"
+            version = "0.1.0"
+            authors = []
+
+            [[bin]]
+            name = "foo"
+
+            [[bin]]
+            name = "bar"
+        "#)
+        .file("src/lib.rs", "")
+        .file("src/main.rs", "fn main() {}")
+        .file("src/bin/bar.rs", "fn main() {}");
+
+    assert_that(p.cargo_process("build"), execs().with_status(0));
+}
+
+#[test]
+fn no_bin_in_src_with_lib() {
+    let p = project("foo")
+        .file("Cargo.toml", r#"
+            [package]
+            name = "foo"
+            version = "0.1.0"
+            authors = []
+
+            [[bin]]
+            name = "foo"
+        "#)
+        .file("src/lib.rs", "")
+        .file("src/foo.rs", "fn main() {}");
+
+    assert_that(p.cargo_process("build"),
+                execs().with_status(101)
+                       .with_stderr_contains(r#"[ERROR] couldn't read "[..]main.rs"[..]"#));
+}

tests/build.rs

@@ -436,13 +436,12 @@ impl Execs {
         }
 
         if let Some(ref objects) = self.expect_json {
-            let lines = match str::from_utf8(&actual.stdout) {
-                Err(..) => return Err("stdout was not utf8 encoded".to_owned()),
-                Ok(stdout) => stdout.lines().collect::<Vec<_>>(),
-            };
+            let stdout = str::from_utf8(&actual.stdout)
+                .map_err(|_| "stdout was not utf8 encoded".to_owned())?;
+            let lines = stdout.lines().collect::<Vec<_>>();
             if lines.len() != objects.len() {
-                return Err(format!("expected {} json lines, got {}",
-                                   objects.len(), lines.len()));
+                return Err(format!("expected {} json lines, got {}, stdout:\n{}",
+                                   objects.len(), lines.len(), stdout));
             }
             for (obj, line) in objects.iter().zip(lines) {
                 self.match_json(obj, line)?;