auto merge of #341 : alexcrichton/cargo/doc-test-tweaks, r=wycats

Author: bors

src/cargo/ops/cargo_rustc/compilation.rs

@@ -30,6 +30,10 @@ pub struct Compilation {
 
     /// Output directory for rust dependencies
     pub deps_output: Path,
+
+    /// Extra environment variables that were passed to compilations and should
+    /// be passed to future invocations of programs.
+    pub extra_env: HashMap<String, Option<String>>,
 }
 
 impl Compilation {
@@ -41,6 +45,7 @@ impl Compilation {
             deps_output: Path::new("/"),
             tests: Vec::new(),
             binaries: Vec::new(),
+            extra_env: HashMap::new(),
         }
     }
 
@@ -54,7 +59,11 @@ impl Compilation {
         search_path.push(self.root_output.clone());
         search_path.push(self.deps_output.clone());
         let search_path = os::join_paths(search_path.as_slice()).unwrap();
-        util::process(cmd).env(DynamicLibrary::envvar(),
-                               Some(search_path.as_slice()))
+        let mut cmd = util::process(cmd).env(DynamicLibrary::envvar(),
+                                             Some(search_path.as_slice()));
+        for (k, v) in self.extra_env.iter() {
+            cmd = cmd.env(k.as_slice(), v.as_ref().map(|s| s.as_slice()));
+        }
+        return cmd;
     }
 }

src/cargo/ops/cargo_rustc/context.rs

@@ -1,5 +1,6 @@
 use std::collections::{HashMap, HashSet};
 use std::str;
+use semver::Version;
 
 use core::{SourceMap, Package, PackageId, PackageSet, Resolve, Target};
 use util;
@@ -127,7 +128,32 @@ impl<'a, 'b> Context<'a, 'b> {
         self.compilation.root_output = self.layout(KindTarget).proxy().dest().clone();
         self.compilation.deps_output = self.layout(KindTarget).proxy().deps().clone();
 
-        Ok(())
+        let env = &mut self.compilation.extra_env;
+        env.insert("CARGO_PKG_VERSION_MAJOR".to_string(),
+                   Some(pkg.get_version().major.to_string()));
+        env.insert("CARGO_PKG_VERSION_MINOR".to_string(),
+                   Some(pkg.get_version().minor.to_string()));
+        env.insert("CARGO_PKG_VERSION_PATCH".to_string(),
+                   Some(pkg.get_version().patch.to_string()));
+        env.insert("CARGO_PKG_VERSION_PRE".to_string(),
+                   pre_version_component(pkg.get_version()));
+
+        return Ok(());
+
+        fn pre_version_component(v: &Version) -> Option<String> {
+            if v.pre.is_empty() {
+                return None;
+            }
+
+            let mut ret = String::new();
+
+            for (i, x) in v.pre.iter().enumerate() {
+                if i != 0 { ret.push_char('.') };
+                ret.push_str(x.to_string().as_slice());
+            }
+
+            Some(ret)
+        }
     }
 
     fn build_requirements(&mut self, pkg: &'a Package, target: &'a Target,

src/cargo/ops/cargo_rustc/fingerprint.rs

@@ -82,7 +82,7 @@ pub fn prepare_target(cx: &mut Context, pkg: &Package, target: &Target,
                 cx.compilation.tests.push(dst.clone());
             } else if target.is_bin() {
                 cx.compilation.binaries.push(dst.clone());
-            } else if target.is_lib() && target.get_profile().is_compile() {
+            } else if target.is_lib() {
                 let pkgid = pkg.get_package_id().clone();
                 cx.compilation.libraries.find_or_insert(pkgid, Vec::new())
                                         .push(root.join(filename));

src/cargo/ops/cargo_rustc/mod.rs

@@ -2,10 +2,8 @@ use std::collections::HashSet;
 use std::dynamic_lib::DynamicLibrary;
 use std::io::{fs, UserRWX};
 use std::os;
-use semver::Version;
 
 use core::{SourceMap, Package, PackageId, PackageSet, Target, Resolve};
-use util;
 use util::{CargoResult, ProcessBuilder, CargoError, human, caused_human};
 use util::{Config, internal, ChainError, Fresh, profile};
 
@@ -433,26 +431,9 @@ pub fn process<T: ToCStr>(cmd: T, pkg: &Package, cx: &Context) -> ProcessBuilder
     search_path.push(cx.layout(KindPlugin).deps().clone());
     let search_path = os::join_paths(search_path.as_slice()).unwrap();
 
-    util::process(cmd)
-        .cwd(pkg.get_root())
-        .env(DynamicLibrary::envvar(), Some(search_path.as_slice()))
-        .env("CARGO_PKG_VERSION_MAJOR", Some(pkg.get_version().major.to_string()))
-        .env("CARGO_PKG_VERSION_MINOR", Some(pkg.get_version().minor.to_string()))
-        .env("CARGO_PKG_VERSION_PATCH", Some(pkg.get_version().patch.to_string()))
-        .env("CARGO_PKG_VERSION_PRE", pre_version_component(pkg.get_version()))
-}
-
-fn pre_version_component(v: &Version) -> Option<String> {
-    if v.pre.is_empty() {
-        return None;
-    }
-
-    let mut ret = String::new();
-
-    for (i, x) in v.pre.iter().enumerate() {
-        if i != 0 { ret.push_char('.') };
-        ret.push_str(x.to_string().as_slice());
-    }
-
-    Some(ret)
+    // We want to use the same environment and such as normal processes, but we
+    // want to override the dylib search path with the one we just calculated.
+    cx.compilation.process(cmd).cwd(pkg.get_root())
+                               .env(DynamicLibrary::envvar(),
+                                    Some(search_path.as_slice()))
 }

src/cargo/ops/cargo_test.rs

@@ -21,8 +21,14 @@ pub fn run_tests(manifest_path: &Path,
             Some(path) => path,
             None => exe.clone(),
         };
-        try!(options.shell.status("Running", to_display.display()));
-        match compile.process(exe).args(args).exec() {
+        let cmd = compile.process(exe).args(args);
+        try!(options.shell.concise(|shell| {
+            shell.status("Running", to_display.display().to_string())
+        }));
+        try!(options.shell.verbose(|shell| {
+            shell.status("Running", cmd.to_string())
+        }));
+        match cmd.exec() {
             Ok(()) => {}
             Err(e) => return Ok(Some(e))
         }
@@ -58,6 +64,9 @@ pub fn run_tests(manifest_path: &Path,
             }
         }
 
+        try!(options.shell.verbose(|shell| {
+            shell.status("Running", p.to_string())
+        }));
         match p.exec() {
             Ok(()) => {}
             Err(e) => return Ok(Some(e)),

src/snapshots.txt

@@ -1,3 +1,10 @@
+2014-08-06
+  linux-i386 eb7c2a87b30db077f6f1c4ea724ebd0e5cc07d1c
+  linux-x86_64 1672657adb9012df2912bbb2f43466f1c6817e55
+  macos-i386 1224207bbfa9f46796940512ac8a7a9ab9f5665b
+  macos-x86_64 da4afea32d7336a0a91b8fe160d38896385d4ae2
+  winnt-i386 2b6b2efe9ec77d3d456c943bb2e54f2281309ef1
+
 2014-08-04
   linux-i386 49032ce8c5c2b94d73e298dcbdb09e0b2fbe573c
   linux-x86_64 98c83ecc7cac3765d62f5e8b19bdc506e01f3cab

tests/test_cargo_compile.rs

@@ -787,28 +787,32 @@ test!(crate_version_env_vars {
     let p = project("foo")
         .file("Cargo.toml", r#"
             [project]
-
             name = "foo"
             version = "0.5.1-alpha.1"
             authors = ["[email protected]"]
-
-            [[bin]]
-            name = "foo"
         "#)
-        .file("src/foo.rs", r#"
-            use std::os;
+        .file("src/main.rs", r#"
+            extern crate foo;
 
             static VERSION_MAJOR: &'static str = env!("CARGO_PKG_VERSION_MAJOR");
             static VERSION_MINOR: &'static str = env!("CARGO_PKG_VERSION_MINOR");
             static VERSION_PATCH: &'static str = env!("CARGO_PKG_VERSION_PATCH");
             static VERSION_PRE: &'static str = env!("CARGO_PKG_VERSION_PRE");
 
             fn main() {
-                println!("{}-{}-{} @ {}",
-                         VERSION_MAJOR,
-                         VERSION_MINOR,
-                         VERSION_PATCH,
-                         VERSION_PRE);
+                let s = format!("{}-{}-{} @ {}", VERSION_MAJOR, VERSION_MINOR,
+                                VERSION_PATCH, VERSION_PRE);
+                assert_eq!(s, foo::version());
+                println!("{}", s);
+            }
+        "#)
+        .file("src/lib.rs", r#"
+            pub fn version() -> String {
+                format!("{}-{}-{} @ {}",
+                        env!("CARGO_PKG_VERSION_MAJOR"),
+                        env!("CARGO_PKG_VERSION_MINOR"),
+                        env!("CARGO_PKG_VERSION_PATCH"),
+                        env!("CARGO_PKG_VERSION_PRE"))
             }
         "#);
 
@@ -817,6 +821,8 @@ test!(crate_version_env_vars {
     assert_that(
       process(p.bin("foo")),
       execs().with_stdout("0-5-1 @ alpha.1\n"));
+
+    assert_that(p.process(cargo_dir().join("cargo-test")), execs().with_status(0));
 })
 
 test!(custom_build_in_dependency {

tests/test_cargo_compile_git_deps.rs

@@ -714,9 +714,6 @@ test!(dep_with_submodule {
             pub fn foo() { dep1::dep() }
         ");
 
-    let root = project.url();
-    let git_root = git_project.url();
-
     assert_that(project.cargo_process("cargo-build"),
         execs().with_stderr("").with_status(0));
 })

tests/test_cargo_test.rs

@@ -46,6 +46,27 @@ test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured\n\n",
         RUNNING)));
 })
 
+test!(cargo_test_verbose {
+    let p = project("foo")
+        .file("Cargo.toml", basic_bin_manifest("foo").as_slice())
+        .file("src/foo.rs", r#"
+            fn main() {}
+            #[test] fn test_hello() {}
+        "#);
+
+    assert_that(p.cargo_process("cargo-test").arg("-v").arg("hello"),
+        execs().with_stdout(format!("\
+{running} `rustc src[..]foo.rs [..]`
+{compiling} foo v0.5.0 ({url})
+{running} `[..]target[..]test[..]foo-[..] hello`
+
+running 1 test
+test test_hello ... ok
+
+test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured\n\n",
+        compiling = COMPILING, url = p.url(), running = RUNNING)));
+})
+
 test!(many_similar_names {
     let p = project("foo")
         .file("Cargo.toml", r#"
@@ -498,13 +519,15 @@ test!(lib_with_standard_name {
             name = "syntax"
             version = "0.0.1"
             authors = []
-
-            [[lib]]
-            name = "syntax"
-            test = false
         "#)
         .file("src/lib.rs", "
+            /// ```
+            /// syntax::foo();
+            /// ```
             pub fn foo() {}
+
+            #[test]
+            fn foo_test() {}
         ")
         .file("tests/test.rs", "
             extern crate syntax;
@@ -517,15 +540,29 @@ test!(lib_with_standard_name {
                 execs().with_status(0)
                        .with_stdout(format!("\
 {compiling} syntax v0.0.1 ({dir})
+{running} target[..]test[..]syntax-[..]
+
+running 1 test
+test foo_test ... ok
+
+test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured\n\n\
+
 {running} target[..]test[..]test-[..]
 
 running 1 test
 test test ... ok
 
+test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured\n\n\
+
+{doctest} syntax
+
+running 1 test
+test foo_0 ... ok
+
 test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured\n\n\
                        ",
                        compiling = COMPILING, running = RUNNING,
-                       dir = p.url()).as_slice()));
+                       doctest = DOCTEST, dir = p.url()).as_slice()));
 })
 
 test!(lib_with_standard_name2 {