fail!("Bad kind in build_crates")
});
}
+ debug!("Compiling crate {}; its output will be in {}",
+ subpath.display(), sub_dir.display());
let result = compile_crate(&subcx,
exec,
&id,
let tests = self.tests.clone();
let benchs = self.benchs.clone();
debug!("Building libs in {}, destination = {}",
- self.destination_workspace.display(),
- self.destination_workspace.display());
+ self.source_workspace.display(),
+ self.build_workspace().display());
self.build_crates(build_context,
&mut deps,
libs,
build_inputs,
&pkg_src.destination_workspace,
&id).map(|s| Path::new(s.as_slice()));
- debug!("install: id = {}, about to call discover_outputs, {:?}",
- id.to_str(), result.map(|p| p.display().to_str()));
installed_files = installed_files + result;
note(format!("Installed package {} to {}",
id.to_str(),
assert!(!built_library_exists(&source_dir, "foo"));
}
+#[test]
+fn rust_path_hack_build_with_dependency() {
+ let foo_id = PkgId::new("foo");
+ let dep_id = PkgId::new("dep");
+ // Tests that when --rust-path-hack is in effect, dependencies get built
+ // into the destination workspace and not the source directory
+ let work_dir = create_local_package(&foo_id);
+ let work_dir = work_dir.path();
+ let dep_workspace = create_local_package(&dep_id);
+ let dep_workspace = dep_workspace.path();
+ let dest_workspace = mk_emptier_workspace("dep");
+ let dest_workspace = dest_workspace.path();
+ let source_dir = work_dir.join_many(["src", "foo-0.1"]);
+ writeFile(&source_dir.join("lib.rs"), "extern mod dep; pub fn f() { }");
+ let dep_dir = dep_workspace.join_many(["src", "dep-0.1"]);
+ let rust_path = Some(~[(~"RUST_PATH",
+ format!("{}:{}",
+ dest_workspace.display(),
+ dep_dir.display()))]);
+ command_line_test_with_env([~"build", ~"--rust-path-hack", ~"foo"], work_dir, rust_path);
+ assert_built_library_exists(dest_workspace, "dep");
+ assert!(!built_library_exists(dep_workspace, "dep"));
+}
+
#[test]
fn rust_path_install_target() {
let dir_for_path = TempDir::new(
// Find all the workspaces in the RUST_PATH that contain this package.
let workspaces = pkg_parent_workspaces(&self.context.context,
&pkg_id);
- // Two cases:
+ // Three cases:
// (a) `workspaces` is empty. That means there's no local source
// for this package. In that case, we pass the default workspace
// into `PkgSrc::new`, so that if it exists as a remote repository,
- // its sources will be fetched into it.
- // (b) `workspaces` is non-empty -- we found a local source for this
- // package.
- let dest_workspace = if workspaces.is_empty() {
- default_workspace()
- } else { workspaces[0] };
+ // its sources will be fetched into it. We also put the output in the
+ // same workspace.
+ // (b) We're using the Rust path hack. In that case, the output goes
+ // in the destination workspace.
+ // (c) `workspaces` is non-empty -- we found a local source for this
+ // package and will build in that workspace.
+ let (source_workspace, dest_workspace) = if workspaces.is_empty() {
+ (default_workspace(), default_workspace())
+ } else {
+ if self.context.context.use_rust_path_hack {
+ (workspaces[0], default_workspace())
+ } else {
+ (workspaces[0].clone(), workspaces[0])
+ }
+ };
// In this case, the source and destination workspaces are the same:
// Either it's a remote package, so the local sources don't exist
// and the `PkgSrc` constructor will detect that;
// or else it's already in a workspace and we'll build into that
// workspace
- let pkg_src = PkgSrc::new(dest_workspace.clone(),
+ let pkg_src = PkgSrc::new(source_workspace,
dest_workspace,
// Use the rust_path_hack to search for dependencies iff
// we were already using it