Merge branch 'master' of https://github.com/rust-lang/cargo

Author: Victor-Savu

src/cargo/core/manifest.rs

@@ -118,7 +118,7 @@ pub struct Profile {
     test: bool,
     doctest: bool,
     doc: bool,
-    dest: Option<String>,
+    dest: String,
     for_host: bool,
     harness: bool, // whether to use the test harness (--test)
     custom_build: bool,
@@ -135,7 +135,7 @@ impl Profile {
             rpath: false,
             test: false,
             doc: false,
-            dest: None,
+            dest: "debug".to_string(),
             for_host: false,
             doctest: false,
             custom_build: false,
@@ -157,7 +157,6 @@ impl Profile {
             env: "test".to_string(),
             debug: true,
             test: true,
-            dest: None,
             .. Profile::default()
         }
     }
@@ -172,26 +171,23 @@ impl Profile {
     pub fn default_bench() -> Profile {
         Profile {
             env: "bench".to_string(),
-            opt_level: 3,
             test: true,
-            dest: Some("release".to_string()),
-            .. Profile::default()
+            .. Profile::default_release()
         }
     }
 
     pub fn default_release() -> Profile {
         Profile {
             env: "release".to_string(),
             opt_level: 3,
-            dest: Some("release".to_string()),
+            dest: "release".to_string(),
             .. Profile::default()
         }
     }
 
     pub fn default_doc() -> Profile {
         Profile {
             env: "doc".to_string(),
-            dest: None,
             doc: true,
             .. Profile::default()
         }
@@ -210,10 +206,7 @@ impl Profile {
     pub fn opt_level(&self) -> u32 { self.opt_level }
     pub fn rpath(&self) -> bool { self.rpath }
     pub fn uses_test_harness(&self) -> bool { self.harness }
-
-    pub fn dest(&self) -> Option<&str> {
-        self.dest.as_ref().map(|d| d.as_slice())
-    }
+    pub fn dest(&self) -> &str { &self.dest }
 
     pub fn set_opt_level(mut self, level: u32) -> Profile {
         self.opt_level = level;

src/cargo/ops/cargo_package.rs

@@ -6,8 +6,7 @@ use tar::Archive;
 use flate2::{GzBuilder, Compression};
 use flate2::read::GzDecoder;
 
-use core::source::{Source, SourceId};
-use core::Package;
+use core::{Source, SourceId, Package, PackageId};
 use sources::PathSource;
 use util::{self, CargoResult, human, internal, ChainError, Config};
 use ops;
@@ -160,16 +159,23 @@ fn run_verify(config: &Config, pkg: &Package, tar: &Path)
     // When packages are uploaded to the registry, all path dependencies are
     // implicitly converted to registry-based dependencies, so we rewrite those
     // dependencies here.
+    //
+    // We also be sure to point all paths at `dst` instead of the previous
+    // location that the package was original read from. In locking the
+    // `SourceId` we're telling it that the corresponding `PathSource` will be
+    // considered updated and won't actually read any packages.
     let registry = try!(SourceId::for_central(config));
+    let precise = Some("locked".to_string());
+    let new_src = try!(SourceId::for_path(&dst)).with_precise(precise);
+    let new_pkgid = try!(PackageId::new(pkg.name(), pkg.version(), &new_src));
     let new_summary = pkg.summary().clone().map_dependencies(|d| {
         if !d.source_id().is_path() { return d }
         d.set_source_id(registry.clone())
     });
     let mut new_manifest = pkg.manifest().clone();
-    new_manifest.set_summary(new_summary);
+    new_manifest.set_summary(new_summary.override_id(new_pkgid));
     new_manifest.set_target_dir(dst.join("target"));
-    let new_pkg = Package::new(new_manifest, &manifest_path,
-                               pkg.package_id().source_id());
+    let new_pkg = Package::new(new_manifest, &manifest_path, &new_src);
 
     // Now that we've rewritten all our path dependencies, compile it!
     try!(ops::compile_pkg(&new_pkg, &ops::CompileOptions {

src/cargo/ops/cargo_run.rs

@@ -53,10 +53,8 @@ pub fn run(manifest_path: &Path,
         None => dst,
     };
     let exe = match (bin.profile().dest(), bin.is_example()) {
-        (Some(s), true) => dst.join(s).join("examples").join(bin.name()),
-        (Some(s), false) => dst.join(s).join(bin.name()),
-        (None, true) => dst.join("examples").join(bin.name()),
-        (None, false) => dst.join(bin.name()),
+        (s, true) => dst.join(s).join("examples").join(bin.name()),
+        (s, false) => dst.join(s).join(bin.name()),
     };
     let exe = match exe.relative_from(config.cwd()) {
         Some(path) => path,

src/cargo/ops/cargo_rustc/context.rs

@@ -96,7 +96,8 @@ impl<'a, 'b: 'a> Context<'a, 'b> {
                .arg("--crate-name").arg("_")
                .arg("--crate-type").arg("dylib")
                .arg("--crate-type").arg("bin")
-               .arg("--print=file-names");
+               .arg("--print=file-names")
+               .env_remove("RUST_LOG");
         if let Some(s) = target {
             process.arg("--target").arg(s);
         };

src/cargo/ops/cargo_rustc/layout.rs

@@ -68,16 +68,13 @@ pub struct LayoutProxy<'a> {
 }
 
 impl Layout {
-    pub fn new(pkg: &Package, triple: Option<&str>, dest: Option<&str>) -> Layout {
+    pub fn new(pkg: &Package, triple: Option<&str>, dest: &str) -> Layout {
         let mut path = pkg.absolute_target_dir();
         match triple {
             Some(s) => path.push(s),
             None => {}
         }
-        match dest {
-            Some(s) => path.push(s),
-            None => {}
-        }
+        path.push(dest);
         Layout::at(path)
     }
 

src/cargo/ops/cargo_rustc/mod.rs

@@ -75,14 +75,14 @@ pub fn rustc_version() -> CargoResult<(String, String)> {
 // This is a temporary assert that ensures the consistency of the arguments
 // given the current limitations of Cargo. The long term fix is to have each
 // Target know the absolute path to the build location.
-fn uniq_target_dest<'a>(targets: &[&'a Target]) -> Option<&'a str> {
-    let mut curr: Option<Option<&str>> = None;
+fn uniq_target_dest<'a>(targets: &[&'a Target]) -> &'a str {
+    let mut curr: Option<&str> = None;
 
     for t in targets.iter().filter(|t| !t.profile().is_custom_build()) {
         let dest = t.profile().dest();
 
         match curr {
-            Some(curr) => assert!(curr == dest),
+            Some(curr) => assert_eq!(curr, dest),
             None => curr = Some(dest)
         }
     }
@@ -483,7 +483,8 @@ fn prepare_rustc(package: &Package, target: &Target, crate_types: Vec<&str>,
 fn rustdoc(package: &Package, target: &Target,
            cx: &mut Context) -> CargoResult<Work> {
     let kind = Kind::Target;
-    let cx_root = cx.layout(package, kind).proxy().dest().join("doc");
+    let cx_root = cx.get_package(cx.resolve.root()).absolute_target_dir()
+                    .join("doc");
     let mut rustdoc = try!(process(CommandType::Rustdoc, package, target, cx));
     rustdoc.arg(&root_path(cx, package, target))
            .cwd(cx.config.cwd())

src/cargo/sources/path.rs

@@ -58,8 +58,19 @@ impl<'a, 'b> PathSource<'a, 'b> {
     }
 
     pub fn read_packages(&self) -> CargoResult<Vec<Package>> {
+
         if self.updated {
             Ok(self.packages.clone())
+        } else if self.id.is_path() && self.id.precise().is_some() {
+            // If our source id is a path and it's listed with a precise
+            // version, then it means that we're not allowed to have nested
+            // dependencies (they've been rewritten to crates.io dependencies)
+            // In this case we specifically read just one package, not a list of
+            // packages.
+            let path = self.path.join("Cargo.toml");
+            let (pkg, _) = try!(ops::read_package(&path, &self.id,
+                                                  self.config));
+            Ok(vec![pkg])
         } else {
             ops::read_packages(&self.path, &self.id, self.config)
         }
@@ -203,7 +214,7 @@ impl<'a, 'b> PathSource<'a, 'b> {
     {
         let mut ret = Vec::new();
         for pkg in self.packages.iter().filter(|p| *p == pkg) {
-            let loc = pkg.manifest_path().parent().unwrap();
+            let loc = pkg.root();
             try!(walk(loc, &mut ret, true, &mut filter));
         }
         return Ok(ret);

src/cargo/util/to_semver.rs

@@ -22,3 +22,9 @@ impl<'a> ToSemver for &'a String {
         (**self).to_semver()
     }
 }
+
+impl<'a> ToSemver for &'a Version {
+    fn to_semver(self) -> Result<Version, String> {
+        Ok(self.clone())
+    }
+}

src/doc/config.md

@@ -23,10 +23,12 @@ with a configuration file in your home directory.
 
 # Configuration Format
 
-All configuration is currently in the TOML format (like the manifest), with
-simple key-value pairs inside of sections (tables) which all get merged
+All configuration is currently in the [TOML format][toml] (like the manifest),
+with simple key-value pairs inside of sections (tables) which all get merged
 together.
 
+[toml]: https://github.com/toml-lang/toml
+
 # Configuration keys
 
 All of the following keys are optional, and their defaults are listed as their

src/doc/crates-io.md

@@ -174,9 +174,9 @@ Be sure to check out the [metadata you can
 specify](manifest.html#package-metadata) to ensure your crate can be discovered
 more easily!
 
-## Limitations
+## Restrictions
 
-There are a few limitations when publish a crate in the registry:
+There are a few restrictions when publishing a crate in the registry:
 
 * Once a version is uploaded, it can never be overwritten. To upload a new copy
   of a crate you must upload a new version.
@@ -192,19 +192,19 @@ to manage a crate.
 
 ## `cargo owner`
 
-A crate is often not developed by only one person, or perhaps the main developer
-changes over time! The owners of a crate is the only person allowed to publish
-new versions of the crate, but owners may also add other owners! This subcommand
-allows you to allow others to publish new versions as well as add new owners
-themselves:
+A crate is often developed by more than one person, or the primary maintainer
+may change over time! The owner of a crate is the only person allowed to publish
+new versions of the crate, but an owner may designate additional owners. Using
+this subcommand, an owner allows others to publish new versions, as well as to
+manage the list of owners themselves:
 
 ```notrust
 $ cargo owner --add my-buddy
 $ cargo owner --remove my-buddy
 ```
 
-The logins specified are the GitHub logins used by the user in question. The
-owner being added must also already have logged into crates.io previously.
+The owner IDs given to these commands must be GitHub user names. In order to be
+added, an owner must have also logged into crates.io previously.
 
 ## `cargo yank`