$$(SREQ$(1)_T_$(2)_H_$(3)) \
$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_LIBSYNTAX_$(2)) \
$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_LIBRUSTC_$(2)) \
- $$(TBIN$(1)_T_$(2)_H_$(3))/rustpkg$$(X_$(2))
+ $$(TBIN$(1)_T_$(2)_H_$(3))/rustpkg$$(X_$(2)) \
+ $$(TBIN$(1)_T_$(2)_H_$(3))/rustc$$(X_$(2))
@$$(call E, compile_and_link: $$@)
$$(STAGE$(1)_T_$(2)_H_$(3)) -o $$@ $$< --test
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-pub use package_path::{RemotePath, LocalPath, normalize, hash};
use version::{try_getting_version, try_getting_local_version,
Version, NoVersion, split_version};
+use std::rt::io::Writer;
+use std::hash::Streaming;
+use std::hash;
/// Path-fragment identifier of a package such as
/// 'github.com/graydon/test'; path must be a relative
/// path with >=1 component.
#[deriving(Clone)]
pub struct PkgId {
- /// Remote path: for example, github.com/mozilla/quux-whatever
- remote_path: RemotePath,
- /// Local path: for example, /home/quux/github.com/mozilla/quux_whatever
- /// Note that '-' normalizes to '_' when mapping a remote path
- /// onto a local path
- /// Also, this will change when we implement #6407, though we'll still
- /// need to keep track of separate local and remote paths
- local_path: LocalPath,
- /// Short name. This is the local path's filestem, but we store it
+ /// This is a path, on the local filesystem, referring to where the
+ /// files for this package live. For example:
+ /// github.com/mozilla/quux-whatever (it's assumed that if we're
+ /// working with a package ID of this form, rustpkg has already cloned
+ /// the sources into a local directory in the RUST_PATH).
+ path: Path,
+ /// Short name. This is the path's filestem, but we store it
/// redundantly so as to not call get() everywhere (filestem() returns an
/// option)
+ /// The short name does not need to be a valid Rust identifier.
+ /// Users can write: `extern mod foo = "...";` to get around the issue
+ /// of package IDs whose short names aren't valid Rust identifiers.
short_name: ~str,
+ /// The requested package version.
version: Version
}
impl Eq for PkgId {
fn eq(&self, p: &PkgId) -> bool {
- *p.local_path == *self.local_path && p.version == self.version
+ p.path == self.path && p.version == self.version
}
fn ne(&self, p: &PkgId) -> bool {
!(self.eq(p))
}
impl PkgId {
- // The PkgId constructor takes a Path argument so as
- // to be able to infer the version if the path refers
- // to a local git repository
pub fn new(s: &str) -> PkgId {
use conditions::bad_pkg_id::cond;
}
};
- let p = Path(s);
- if p.is_absolute {
- return cond.raise((p, ~"absolute pkgid"));
+ let path = Path(s);
+ if path.is_absolute {
+ return cond.raise((path, ~"absolute pkgid"));
}
- if p.components.len() < 1 {
- return cond.raise((p, ~"0-length pkgid"));
+ if path.components.len() < 1 {
+ return cond.raise((path, ~"0-length pkgid"));
}
- let remote_path = RemotePath(p);
- let local_path = normalize(remote_path.clone());
- let short_name = local_path.clone().filestem().expect(fmt!("Strange path! %s", s));
+ let short_name = path.clone().filestem().expect(fmt!("Strange path! %s", s));
let version = match given_version {
Some(v) => v,
- None => match try_getting_local_version(&*local_path) {
+ None => match try_getting_local_version(&path) {
Some(v) => v,
- None => match try_getting_version(&remote_path) {
+ None => match try_getting_version(&path) {
Some(v) => v,
None => NoVersion
}
}
};
- debug!("local_path = %s, remote_path = %s", local_path.to_str(), remote_path.to_str());
+ debug!("path = %s", path.to_str());
PkgId {
- local_path: local_path,
- remote_path: remote_path,
+ path: path,
short_name: short_name,
version: version
}
}
pub fn hash(&self) -> ~str {
- fmt!("%s-%s-%s", self.remote_path.to_str(),
- hash(self.remote_path.to_str() + self.version.to_str()),
+ fmt!("%s-%s-%s", self.path.to_str(),
+ hash(self.path.to_str() + self.version.to_str()),
self.version.to_str())
}
/// True if the ID has multiple components
pub fn is_complex(&self) -> bool {
- self.short_name != self.local_path.to_str()
+ self.short_name != self.path.to_str()
}
}
impl ToStr for PkgId {
fn to_str(&self) -> ~str {
// should probably use the filestem and not the whole path
- fmt!("%s-%s", self.local_path.to_str(), self.version.to_str())
+ fmt!("%s-%s", self.path.to_str(), self.version.to_str())
}
}
+
+
+pub fn write<W: Writer>(writer: &mut W, string: &str) {
+ writer.write(string.as_bytes());
+}
+
+pub fn hash(data: ~str) -> ~str {
+ let hasher = &mut hash::default_state();
+ write(hasher, data);
+ hasher.result_str()
+}
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// rustpkg utilities having to do with local and remote paths
-
-use std::clone::Clone;
-use std::hash::Streaming;
-use std::hash;
-use std::option::Some;
-use std::path::Path;
-use std::rt::io::Writer;
-
-/// Wrappers to prevent local and remote paths from getting confused
-/// (These will go away after #6407)
-pub struct RemotePath (Path);
-
-impl Clone for RemotePath {
- fn clone(&self) -> RemotePath {
- RemotePath((**self).clone())
- }
-}
-
-pub struct LocalPath (Path);
-
-impl Clone for LocalPath {
- fn clone(&self) -> LocalPath {
- LocalPath((**self).clone())
- }
-}
-
-
-// normalize should be the only way to construct a LocalPath
-// (though this isn't enforced)
-/// Replace all occurrences of '-' in the stem part of path with '_'
-/// This is because we treat rust-foo-bar-quux and rust_foo_bar_quux
-/// as the same name
-pub fn normalize(p_: RemotePath) -> LocalPath {
- let RemotePath(p) = p_;
- match p.filestem() {
- None => LocalPath(p),
- Some(st) => {
- let replaced = st.replace("-", "_");
- if replaced != st {
- LocalPath(p.with_filestem(replaced))
- }
- else {
- LocalPath(p)
- }
- }
- }
-}
-
-pub fn write<W: Writer>(writer: &mut W, string: &str) {
- writer.write(string.as_bytes());
-}
-
-pub fn hash(data: ~str) -> ~str {
- let hasher = &mut hash::default_state();
- write(hasher, data);
- hasher.result_str()
-}
use target::*;
use package_id::PkgId;
use std::path::Path;
-use std::{os, str};
+use std::os;
use context::*;
use crate::Crate;
use messages::*;
fn check_dir(&self) -> Path {
use conditions::nonexistent_package::cond;
- debug!("Pushing onto root: %s | %s", self.id.remote_path.to_str(),
- self.root.to_str());
+ debug!("Pushing onto root: %s | %s", self.id.path.to_str(), self.root.to_str());
let dir;
let dirs = pkgid_src_in_workspace(&self.id, &self.root);
debug!("Checking dirs: %?", dirs);
os::remove_dir_recursive(&local);
debug!("Checking whether %s exists locally. Cwd = %s, does it? %?",
- self.id.local_path.to_str(),
+ self.id.path.to_str(),
os::getcwd().to_str(),
- os::path_exists(&*self.id.local_path));
+ os::path_exists(&self.id.path));
- if os::path_exists(&*self.id.local_path) {
+ if os::path_exists(&self.id.path) {
debug!("%s exists locally! Cloning it into %s",
- self.id.local_path.to_str(), local.to_str());
- git_clone(&*self.id.local_path, &local, &self.id.version);
+ self.id.path.to_str(), local.to_str());
+ git_clone(&self.id.path, &local, &self.id.version);
return Some(local);
}
- let url = fmt!("https://%s", self.id.remote_path.to_str());
+ let url = fmt!("https://%s", self.id.path.to_str());
note(fmt!("Fetching package: git clone %s %s [version=%s]",
url, local.to_str(), self.id.version.to_str()));
if git_clone_general(url, &local, &self.id.version) {
}
/// True if the given path's stem is self's pkg ID's stem
- /// or if the pkg ID's stem is <rust-foo> and the given path's
- /// stem is foo
- /// Requires that dashes in p have already been normalized to
- /// underscores
fn stem_matches(&self, p: &Path) -> bool {
- let self_id = self.id.local_path.filestem();
- if self_id == p.filestem() {
- return true;
- }
- else {
- for pth in self_id.iter() {
- if pth.starts_with("rust_") // because p is already normalized
- && match p.filestem() {
- Some(s) => str::eq_slice(s, pth.slice(5, pth.len())),
- None => false
- } { return true; }
- }
- }
- false
+ p.filestem().map_default(false, |p| { p == &self.id.short_name })
}
fn push_crate(cs: &mut ~[Crate], prefix: uint, p: &Path) {
let dir = self.check_dir();
debug!("Called check_dir, I'm in %s", dir.to_str());
let prefix = dir.components.len();
- debug!("Matching against %?", self.id.local_path.filestem());
+ debug!("Matching against %?", self.id.short_name);
do os::walk_dir(&dir) |pth| {
match pth.filename() {
Some(~"lib.rs") => PkgSrc::push_crate(&mut self.libs,
// rustpkg utilities having to do with paths and directories
-pub use package_path::{RemotePath, LocalPath, normalize};
pub use package_id::PkgId;
pub use target::{OutputType, Main, Lib, Test, Bench, Target, Build, Install};
pub use version::{Version, NoVersion, split_version_general};
pub fn pkgid_src_in_workspace(pkgid: &PkgId, workspace: &Path) -> ~[Path] {
let mut results = ~[];
let result = workspace.push("src").push(fmt!("%s-%s",
- pkgid.local_path.to_str(), pkgid.version.to_str()));
+ pkgid.path.to_str(), pkgid.version.to_str()));
results.push(result);
- results.push(workspace.push("src").push_rel(&*pkgid.remote_path));
+ results.push(workspace.push("src").push_rel(&pkgid.path));
results
}
/// Figure out what the library name for <pkgid> in <workspace>'s build
/// directory is, and if the file exists, return it.
pub fn built_library_in_workspace(pkgid: &PkgId, workspace: &Path) -> Option<Path> {
- library_in_workspace(&pkgid.local_path, pkgid.short_name,
- Build, workspace, "build")
+ library_in_workspace(&pkgid.path, pkgid.short_name, Build, workspace, "build")
}
/// Does the actual searching stuff
pub fn installed_library_in_workspace(short_name: &str, workspace: &Path) -> Option<Path> {
- library_in_workspace(&normalize(RemotePath(Path(short_name))),
- short_name, Install, workspace, "lib")
+ library_in_workspace(&Path(short_name), short_name, Install, workspace, "lib")
}
/// don't know the entire package ID.
/// `workspace` is used to figure out the directory to search.
/// `short_name` is taken as the link name of the library.
-pub fn library_in_workspace(path: &LocalPath, short_name: &str, where: Target,
+pub fn library_in_workspace(path: &Path, short_name: &str, where: Target,
workspace: &Path, prefix: &str) -> Option<Path> {
debug!("library_in_workspace: checking whether a library named %s exists",
short_name);
prefix = %s", short_name, where, workspace.to_str(), prefix);
let dir_to_search = match where {
- Build => workspace.push(prefix).push_rel(&**path),
+ Build => workspace.push(prefix).push_rel(path),
Install => workspace.push(prefix)
};
debug!("Listing directory %s", dir_to_search.to_str());
// Artifacts in the build directory live in a package-ID-specific subdirectory,
// but installed ones don't.
let result = match where {
- Build => workspace.push(subdir).push_rel(&*pkgid.local_path),
+ Build => workspace.push(subdir).push_rel(&pkgid.path),
_ => workspace.push(subdir)
};
if !os::path_exists(&result) && !mkdir_recursive(&result, U_RWX) {
let mut result = workspace.push("build");
// n.b. Should actually use a target-specific
// subdirectory of build/
- result = result.push_rel(&*pkgid.local_path);
+ result = result.push_rel(&pkgid.path);
if os::path_exists(&result) || os::mkdir_recursive(&result, U_RWX) {
result
}
// If we're installing, it just goes under <workspace>...
Install => workspace,
// and if we're just building, it goes in a package-specific subdir
- Build => workspace.push_rel(&*pkg_id.local_path)
+ Build => workspace.push_rel(&pkg_id.path)
};
debug!("[%?:%?] mk_output_path: short_name = %s, path = %s", what, where,
if what == Lib { short_name_with_version.clone() } else { pkg_id.short_name.clone() },
mod installed_packages;
mod messages;
mod package_id;
-mod package_path;
mod package_source;
mod path_util;
mod search;
"list" => {
io::println("Installed packages:");
do installed_packages::list_installed_packages |pkg_id| {
- println(pkg_id.local_path.to_str());
+ println(pkg_id.path.to_str());
true
};
}
fn build(&self, workspace: &Path, pkgid: &PkgId) {
debug!("build: workspace = %s (in Rust path? %? is git dir? %? \
pkgid = %s", workspace.to_str(),
- in_rust_path(workspace), is_git_dir(&workspace.push_rel(&*pkgid.local_path)),
+ in_rust_path(workspace), is_git_dir(&workspace.push_rel(&pkgid.path)),
pkgid.to_str());
let src_dir = first_pkgid_src_in_workspace(pkgid, workspace);
// If workspace isn't in the RUST_PATH, and it's a git repo,
// then clone it into the first entry in RUST_PATH, and repeat
debug!("%? %? %s", in_rust_path(workspace),
- is_git_dir(&workspace.push_rel(&*pkgid.local_path)),
+ is_git_dir(&workspace.push_rel(&pkgid.path)),
workspace.to_str());
- if !in_rust_path(workspace) && is_git_dir(&workspace.push_rel(&*pkgid.local_path)) {
- let out_dir = default_workspace().push("src").push_rel(&*pkgid.local_path);
- source_control::git_clone(&workspace.push_rel(&*pkgid.local_path),
+ if !in_rust_path(workspace) && is_git_dir(&workspace.push_rel(&pkgid.path)) {
+ let out_dir = default_workspace().push("src").push_rel(&pkgid.path);
+ source_control::git_clone(&workspace.push_rel(&pkgid.path),
&out_dir, &pkgid.version);
let default_ws = default_workspace();
debug!("Calling build recursively with %? and %?", default_ws.to_str(),
use context::Ctx;
use std::hashmap::HashMap;
-use std::{io, libc, os, result, run, str};
+use std::{io, libc, os, run, str};
use extra::tempfile::mkdtemp;
use std::run::ProcessOutput;
use installed_packages::list_installed_packages;
-use package_path::*;
use package_id::{PkgId};
use version::{ExactRevision, NoVersion, Version, Tagged};
use path_util::{target_executable_in_workspace, target_library_in_workspace,
fn fake_pkg() -> PkgId {
let sn = ~"bogus";
- let remote = RemotePath(Path(sn));
PkgId {
- local_path: normalize(remote.clone()),
- remote_path: remote,
+ path: Path(sn),
short_name: sn,
version: NoVersion
}
}
fn git_repo_pkg() -> PkgId {
- let remote = RemotePath(Path("mockgithub.com/catamorphism/test-pkg"));
PkgId {
- local_path: normalize(remote.clone()),
- remote_path: remote,
- short_name: ~"test_pkg",
+ path: Path("mockgithub.com/catamorphism/test-pkg"),
+ short_name: ~"test-pkg",
version: NoVersion
}
}
fn git_repo_pkg_with_tag(a_tag: ~str) -> PkgId {
- let remote = RemotePath(Path("mockgithub.com/catamorphism/test-pkg"));
PkgId {
- local_path: normalize(remote.clone()),
- remote_path: remote,
- short_name: ~"test_pkg",
+ path: Path("mockgithub.com/catamorphism/test-pkg"),
+ short_name: ~"test-pkg",
version: Tagged(a_tag)
}
}
out.write_line(contents);
}
-fn mk_empty_workspace(short_name: &LocalPath, version: &Version) -> Path {
+fn mk_empty_workspace(short_name: &Path, version: &Version) -> Path {
let workspace_dir = mkdtemp(&os::tmpdir(), "test").expect("couldn't create temp dir");
mk_workspace(&workspace_dir, short_name, version);
workspace_dir
}
-fn mk_workspace(workspace: &Path, short_name: &LocalPath, version: &Version) -> Path {
+fn mk_workspace(workspace: &Path, short_name: &Path, version: &Version) -> Path {
// include version number in directory name
let package_dir = workspace.push("src").push(fmt!("%s-%s",
short_name.to_str(), version.to_str()));
package_dir
}
-fn mk_temp_workspace(short_name: &LocalPath, version: &Version) -> Path {
+fn mk_temp_workspace(short_name: &Path, version: &Version) -> Path {
let package_dir = mk_empty_workspace(short_name,
version).push("src").push(fmt!("%s-%s",
short_name.to_str(),
}
fn create_local_package(pkgid: &PkgId) -> Path {
- let parent_dir = mk_temp_workspace(&pkgid.local_path, &pkgid.version);
+ let parent_dir = mk_temp_workspace(&pkgid.path, &pkgid.version);
debug!("Created empty package dir for %s, returning %s", pkgid.to_str(), parent_dir.to_str());
parent_dir.pop().pop()
}
}
-fn assert_lib_exists(repo: &Path, short_name: &str, v: Version) {
+fn assert_lib_exists(repo: &Path, short_name: &str, _v: Version) { // ??? version?
debug!("assert_lib_exists: repo = %s, short_name = %s", repo.to_str(), short_name);
let lib = installed_library_in_workspace(short_name, repo);
debug!("assert_lib_exists: checking whether %? exists", lib);
result
}
-// assumes short_name and local_path are one and the same -- I should fix
+// assumes short_name and path are one and the same -- I should fix
fn lib_output_file_name(workspace: &Path, parent: &str, short_name: &str) -> Path {
debug!("lib_output_file_name: given %s and parent %s and short name %s",
workspace.to_str(), parent, short_name);
- library_in_workspace(&normalize(RemotePath(Path(short_name))),
+ library_in_workspace(&Path(short_name),
short_name,
Build,
workspace,
debug!("sysroot = %s", sysroot.to_str());
let ctxt = fake_ctxt(Some(@sysroot));
let temp_pkg_id = fake_pkg();
- let temp_workspace = mk_temp_workspace(&temp_pkg_id.local_path, &NoVersion).pop().pop();
+ let temp_workspace = mk_temp_workspace(&temp_pkg_id.path, &NoVersion).pop().pop();
debug!("temp_workspace = %s", temp_workspace.to_str());
// should have test, bench, lib, and main
ctxt.install(&temp_workspace, &temp_pkg_id);
let sysroot = test_sysroot();
debug!("sysroot = %s", sysroot.to_str());
let temp_pkg_id = git_repo_pkg();
- let repo = init_git_repo(&Path(temp_pkg_id.local_path.to_str()));
+ let repo = init_git_repo(&temp_pkg_id.path);
let repo_subdir = repo.push("mockgithub.com").push("catamorphism").push("test_pkg");
writeFile(&repo_subdir.push("main.rs"),
"fn main() { let _x = (); }");
add_git_tag(&repo_subdir, ~"0.1"); // this has the effect of committing the files
debug!("test_install_git: calling rustpkg install %s in %s",
- temp_pkg_id.local_path.to_str(), repo.to_str());
+ temp_pkg_id.path.to_str(), repo.to_str());
// should have test, bench, lib, and main
- command_line_test([~"install", temp_pkg_id.local_path.to_str()], &repo);
+ command_line_test([~"install", temp_pkg_id.path.to_str()], &repo);
// Check that all files exist
debug!("Checking for files in %s", repo.to_str());
let exec = target_executable_in_workspace(&temp_pkg_id, &repo);
let whatever = PkgId::new("foo");
assert_eq!(~"foo-0.1", whatever.to_str());
- assert!("github.com/catamorphism/test_pkg-0.1" ==
+ assert!("github.com/catamorphism/test-pkg-0.1" ==
PkgId::new("github.com/catamorphism/test-pkg").to_str());
do cond.trap(|(p, e)| {
#[ignore (reason = "Specifying env doesn't work -- see #8028")]
fn rust_path_test() {
let dir_for_path = mkdtemp(&os::tmpdir(), "more_rust").expect("rust_path_test failed");
- let dir = mk_workspace(&dir_for_path, &normalize(RemotePath(Path("foo"))), &NoVersion);
+ let dir = mk_workspace(&dir_for_path, &Path("foo"), &NoVersion);
debug!("dir = %s", dir.to_str());
writeFile(&dir.push("main.rs"), "fn main() { let _x = (); }");
let mut contents = ~[];
let check_dups = |p: &PkgId| {
if contents.contains(p) {
- fail!("package %s appears in `list` output more than once", p.local_path.to_str());
+ fail!("package %s appears in `list` output more than once", p.path.to_str());
}
else {
contents.push((*p).clone());
#[test]
fn test_non_numeric_tag() {
let temp_pkg_id = git_repo_pkg();
- let repo = init_git_repo(&Path(temp_pkg_id.local_path.to_str()));
- let repo_subdir = repo.push("mockgithub.com").push("catamorphism").push("test_pkg");
+ let repo = init_git_repo(&temp_pkg_id.path);
+ let repo_subdir = repo.push("mockgithub.com").push("catamorphism").push("test-pkg");
writeFile(&repo_subdir.push("foo"), "foo");
writeFile(&repo_subdir.push("lib.rs"),
"pub fn f() { let _x = (); }");
writeFile(&repo_subdir.push("not_on_testbranch_only"), "bye bye");
add_all_and_commit(&repo_subdir);
-
- command_line_test([~"install", fmt!("%s#testbranch", temp_pkg_id.remote_path.to_str())],
- &repo);
+ command_line_test([~"install", fmt!("%s#testbranch", temp_pkg_id.path.to_str())], &repo);
let file1 = repo.push_many(["mockgithub.com", "catamorphism",
- "test_pkg", "testbranch_only"]);
- let file2 = repo.push_many(["mockgithub.com", "catamorphism", "test_pkg",
+ "test-pkg", "testbranch_only"]);
+ let file2 = repo.push_many(["mockgithub.com", "catamorphism", "test-pkg",
"master_only"]);
assert!(os::path_exists(&file1));
assert!(!os::path_exists(&file2));
// tjc: by default, use the package ID name as the link name
// not sure if we should support anything else
- let out_dir = workspace.push("build").push_rel(&*pkg_id.local_path);
+ let out_dir = workspace.push("build").push_rel(&pkg_id.path);
let binary = os::args()[0].to_managed();
// Inject the link attributes so we get the right package name and version
if attr::find_linkage_metas(crate.attrs).is_empty() {
let name_to_use = match what {
- Test => fmt!("%stest", pkg_id.local_path.to_str()).to_managed(),
- Bench => fmt!("%sbench", pkg_id.local_path.to_str()).to_managed(),
+ Test => fmt!("%stest", pkg_id.short_name).to_managed(),
+ Bench => fmt!("%sbench", pkg_id.short_name).to_managed(),
_ => pkg_id.short_name.to_managed()
};
debug!("Injecting link name: %s", name_to_use);
attr::mk_name_value_item_str(@"vers", pkg_id.version.to_str().to_managed())] +
if pkg_id.is_complex() {
~[attr::mk_name_value_item_str(@"package_id",
- pkg_id.local_path.to_str().to_managed())]
+ pkg_id.path.to_str().to_managed())]
} else { ~[] };
debug!("link options: %?", link_options);
use extra::semver;
use std::{char, os, result, run, str};
-use package_path::RemotePath;
use extra::tempfile::mkdtemp;
use path_util::rust_path;
/// If `remote_path` refers to a git repo that can be downloaded,
/// and the most recent tag in that repo denotes a version, return it;
/// otherwise, `None`
-pub fn try_getting_version(remote_path: &RemotePath) -> Option<Version> {
+pub fn try_getting_version(remote_path: &Path) -> Option<Version> {
debug!("try_getting_version: %s", remote_path.to_str());
if is_url_like(remote_path) {
debug!("Trying to fetch its sources..");
}
/// Just an approximation
-fn is_url_like(p: &RemotePath) -> bool {
+fn is_url_like(p: &Path) -> bool {
let str = p.to_str();
str.split_iter('/').len_() > 2
}
// tjc: make this a condition
fail!("Package %s not found in any of \
the following workspaces: %s",
- pkgid.remote_path.to_str(),
+ pkgid.path.to_str(),
rust_path().to_str());
}
for ws in workspaces.iter() {
projects / rust.git / commitdiff