---

yaml
---
r: 145007
b: refs/heads/try2
c: b4b375c
h: refs/heads/master
i:
  145005: b519da8
  145003: 13002ca
  144999: 75d13a1
  144991: 255a20a
v: v3

Author: catamorphism

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 19c07352319e1953bdff52618a540dd915a0abbd
+refs/heads/try2: b4b375cbae22f3c0996c02c9b3d998c001b3a837
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/librustpkg/path_util.rs

@@ -399,3 +399,12 @@ pub fn find_dir_using_rust_path_hack(p: &PkgId) -> Option<Path> {
     }
     None
 }
+
+/// True if the user set RUST_PATH to something non-empty --
+/// as opposed to the default paths that rustpkg adds automatically
+pub fn user_set_rust_path() -> bool {
+    match os::getenv("RUST_PATH") {
+        None | Some(~"") => false,
+        Some(_)         => true
+    }
+}

branches/try2/src/librustpkg/rustpkg.rs

@@ -181,7 +181,10 @@ pub trait CtxMethods {
     /// second is a list of declared and discovered inputs
     fn install(&self, src: PkgSrc) -> (~[Path], ~[(~str, ~str)]);
     /// Returns a list of installed files
-    fn install_no_build(&self, workspace: &Path, id: &PkgId) -> ~[Path];
+    fn install_no_build(&self,
+                        source_workspace: &Path,
+                        target_workspace: &Path,
+                        id: &PkgId) -> ~[Path];
     fn prefer(&self, _id: &str, _vers: Option<~str>);
     fn test(&self);
     fn uninstall(&self, _id: &str, _vers: Option<~str>);
@@ -464,28 +467,40 @@ impl CtxMethods for BuildContext {
                 // install to the first workspace in the RUST_PATH if there's
                 // a non-default RUST_PATH. This code installs to the same
                 // workspace the package was built in.
-                debug!("install: destination workspace = %s, id = %s",
-                       destination_workspace, id_str);
-                let result = subself.install_no_build(&Path(destination_workspace), &sub_id);
+                let actual_workspace = if path_util::user_set_rust_path() {
+                    default_workspace()
+                }
+                else {
+                    Path(destination_workspace)
+                };
+                debug!("install: destination workspace = %s, id = %s, installing to %s",
+                       destination_workspace, id_str, actual_workspace.to_str());
+                let result = subself.install_no_build(&Path(destination_workspace),
+                                                      &actual_workspace,
+                                                      &sub_id);
                 debug!("install: id = %s, about to call discover_outputs, %?",
                        id_str, result.to_str());
 
                 discover_outputs(exec, result.clone());
                 sub_files.write(|r| { *r = result.clone(); });
                 sub_inputs.write(|r| { *r = *r + exec.lookup_discovered_inputs() });
+                note(fmt!("Installed package %s to %s", id_str, actual_workspace.to_str()));
             }
         };
         (installed_files.unwrap(), inputs.unwrap())
     }
 
-    fn install_no_build(&self, workspace: &Path, id: &PkgId) -> ~[Path] {
+    fn install_no_build(&self,
+                        source_workspace: &Path,
+                        target_workspace: &Path,
+                        id: &PkgId) -> ~[Path] {
         use conditions::copy_failed::cond;
 
         // Now copy stuff into the install dirs
-        let maybe_executable = built_executable_in_workspace(id, workspace);
-        let maybe_library = built_library_in_workspace(id, workspace);
-        let target_exec = target_executable_in_workspace(id, workspace);
-        let target_lib = maybe_library.map(|_p| target_library_in_workspace(id, workspace));
+        let maybe_executable = built_executable_in_workspace(id, source_workspace);
+        let maybe_library = built_library_in_workspace(id, source_workspace);
+        let target_exec = target_executable_in_workspace(id, target_workspace);
+        let target_lib = maybe_library.map(|_p| target_library_in_workspace(id, target_workspace));
 
         debug!("target_exec = %s target_lib = %? \
                 maybe_executable = %? maybe_library = %?",

branches/try2/src/librustpkg/tests.rs

@@ -1603,6 +1603,25 @@ fn test_recursive_deps() {
     assert_lib_exists(&b_workspace, &Path("c"), NoVersion);
 }
 
+#[test]
+fn test_install_to_rust_path() {
+    let p_id = PkgId::new("foo");
+    let second_workspace = create_local_package(&p_id);
+    let first_workspace = mk_empty_workspace(&Path("p"), &NoVersion, "dest");
+    let rust_path = Some(~[(~"RUST_PATH",
+                            fmt!("%s:%s", first_workspace.to_str(),
+                                 second_workspace.to_str()))]);
+    debug!("RUST_PATH=%s:%s", first_workspace.to_str(), second_workspace.to_str());
+    command_line_test_with_env([test_sysroot().to_str(),
+                       ~"install",
+                       ~"foo"],
+                      &os::getcwd(), rust_path);
+    assert!(!built_executable_exists(&first_workspace, "foo"));
+    assert!(built_executable_exists(&second_workspace, "foo"));
+    assert_executable_exists(&first_workspace, "foo");
+    assert!(!executable_exists(&second_workspace, "foo"));
+}
+
 /// Returns true if p exists and is executable
 fn is_executable(p: &Path) -> bool {
     use std::libc::consts::os::posix88::{S_IXUSR};