---

yaml
---
r: 61316
b: refs/heads/try
c: 7e4a176
h: refs/heads/master
v: v3

Author: brendanzab

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2d28d645422c1617be58c8ca7ad9a457264ca850
-refs/heads/try: c3875e8c7066b5879437b3a5b578a6665fe767f2
+refs/heads/try: 7e4a176dd3a1789d5d10cb995a62daa185cb9cdd
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/libcore/vec.rs

@@ -2071,8 +2071,6 @@ pub trait ImmutableVector<'self, T> {
     fn initn(&self, n: uint) -> &'self [T];
     fn last(&self) -> &'self T;
     fn last_opt(&self) -> Option<&'self T>;
-    fn position(&self, f: &fn(t: &T) -> bool) -> Option<uint>;
-    fn rposition(&self, f: &fn(t: &T) -> bool) -> Option<uint>;
     #[cfg(stage0)]
     fn each_reverse(&self, blk: &fn(&T) -> bool);
     #[cfg(not(stage0))]
@@ -2140,30 +2138,6 @@ impl<'self,T> ImmutableVector<'self, T> for &'self [T] {
     #[inline]
     fn last_opt(&self) -> Option<&'self T> { last_opt(*self) }
 
-    /**
-     * Find the first index matching some predicate
-     *
-     * Apply function `f` to each element of `v`.  When function `f` returns
-     * true then an option containing the index is returned. If `f` matches no
-     * elements then none is returned.
-     */
-    #[inline]
-    fn position(&self, f: &fn(t: &T) -> bool) -> Option<uint> {
-        position(*self, f)
-    }
-
-    /**
-     * Find the last index matching some predicate
-     *
-     * Apply function `f` to each element of `v` in reverse order.  When
-     * function `f` returns true then an option containing the index is
-     * returned. If `f` matches no elements then none is returned.
-     */
-    #[inline]
-    fn rposition(&self, f: &fn(t: &T) -> bool) -> Option<uint> {
-        rposition(*self, f)
-    }
-
     /// Iterates over a vector's elements in reverse.
     #[inline]
     #[cfg(stage0)]
@@ -2256,17 +2230,43 @@ impl<'self,T> ImmutableVector<'self, T> for &'self [T] {
 }
 
 pub trait ImmutableEqVector<T:Eq> {
+    fn position(&self, f: &fn(t: &T) -> bool) -> Option<uint>;
     fn position_elem(&self, t: &T) -> Option<uint>;
+    fn rposition(&self, f: &fn(t: &T) -> bool) -> Option<uint>;
     fn rposition_elem(&self, t: &T) -> Option<uint>;
 }
 
 impl<'self,T:Eq> ImmutableEqVector<T> for &'self [T] {
+    /**
+     * Find the first index matching some predicate
+     *
+     * Apply function `f` to each element of `v`.  When function `f` returns
+     * true then an option containing the index is returned. If `f` matches no
+     * elements then none is returned.
+     */
+    #[inline]
+    fn position(&self, f: &fn(t: &T) -> bool) -> Option<uint> {
+        position(*self, f)
+    }
+
     /// Find the first index containing a matching value
     #[inline]
     fn position_elem(&self, x: &T) -> Option<uint> {
         position_elem(*self, x)
     }
 
+    /**
+     * Find the last index matching some predicate
+     *
+     * Apply function `f` to each element of `v` in reverse order.  When
+     * function `f` returns true then an option containing the index is
+     * returned. If `f` matches no elements then none is returned.
+     */
+    #[inline]
+    fn rposition(&self, f: &fn(t: &T) -> bool) -> Option<uint> {
+        rposition(*self, f)
+    }
+
     /// Find the last index containing a matching value
     #[inline]
     fn rposition_elem(&self, t: &T) -> Option<uint> {

branches/try/src/librustpkg/path_util.rs

@@ -10,10 +10,12 @@
 
 // rustpkg utilities having to do with paths and directories
 
-pub use util::{PkgId, RemotePath, LocalPath};
+use util::PkgId;
 use core::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
 use core::os::mkdir_recursive;
-pub use util::{normalize, OutputType, Main, Lib, Bench, Test};
+
+#[deriving(Eq)]
+pub enum OutputType { Main, Lib, Bench, Test }
 
 /// Returns the value of RUST_PATH, as a list
 /// of Paths. In general this should be read from the
@@ -29,73 +31,67 @@ pub static u_rwx: i32 = (S_IRUSR | S_IWUSR | S_IXUSR) as i32;
 /// succeeded.
 pub fn make_dir_rwx(p: &Path) -> bool { os::make_dir(p, u_rwx) }
 
+/// 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: ~Path) -> ~Path {
+    match p.filestem() {
+        None => p,
+        Some(st) => {
+            let replaced = str::replace(st, "-", "_");
+            if replaced != st {
+                ~p.with_filestem(replaced)
+            }
+            else {
+                p
+            }
+        }
+    }
+}
+
 // n.b. So far this only handles local workspaces
 // n.b. The next three functions ignore the package version right
 // now. Should fix that.
 
 /// True if there's a directory in <workspace> with
 /// pkgid's short name
-pub fn workspace_contains_package_id(pkgid: PkgId, workspace: &Path) -> bool {
-    let pkgpath = workspace.push("src").push(pkgid.local_path.to_str());
+pub fn workspace_contains_package_id(pkgid: &PkgId, workspace: &Path) -> bool {
+    let pkgpath = workspace.push("src").push(pkgid.path.to_str());
     os::path_is_dir(&pkgpath)
 }
 
 /// Return the directory for <pkgid>'s source files in <workspace>.
 /// Doesn't check that it exists.
 pub fn pkgid_src_in_workspace(pkgid: &PkgId, workspace: &Path) -> Path {
     let result = workspace.push("src");
-    result.push(pkgid.local_path.to_str())
+    result.push(pkgid.path.to_str())
 }
 
 /// Figure out what the executable name for <pkgid> in <workspace>'s build
 /// directory is, and if the file exists, return it.
 pub fn built_executable_in_workspace(pkgid: &PkgId, workspace: &Path) -> Option<Path> {
     let mut result = workspace.push("build");
+    result = result.push_rel(&pkgid.path);
     // should use a target-specific subdirectory
-    result = mk_output_path(Main, pkgid, &result);
+    result = mk_output_path(Main, fmt!("%s-%s", pkgid.path.to_str(), pkgid.version.to_str()),
+                                       result);
     debug!("built_executable_in_workspace: checking whether %s exists",
            result.to_str());
     if os::path_exists(&result) {
         Some(result)
     }
     else {
-        // This is not an error, but it's worth logging it
-        error!(fmt!("built_executable_in_workspace: %s does not exist", result.to_str()));
         None
     }
 }
 
-/// Figure out what the test name for <pkgid> in <workspace>'s build
-/// directory is, and if the file exists, return it.
-pub fn built_test_in_workspace(pkgid: PkgId, workspace: &Path) -> Option<Path> {
-    output_in_workspace(pkgid, workspace, Test)
-}
-
-/// Figure out what the test name for <pkgid> in <workspace>'s build
+/// Figure out what the library name for <pkgid> in <workspace>'s build
 /// directory is, and if the file exists, return it.
-pub fn built_bench_in_workspace(pkgid: PkgId, workspace: &Path) -> Option<Path> {
-    output_in_workspace(pkgid, workspace, Bench)
-}
-
-fn output_in_workspace(pkgid: PkgId, workspace: &Path, what: OutputType) -> Option<Path> {
+pub fn built_library_in_workspace(pkgid: &PkgId, workspace: &Path) -> Option<Path> {
     let mut result = workspace.push("build");
+    result = result.push_rel(&pkgid.path);
     // should use a target-specific subdirectory
-    result = mk_output_path(what, pkgid, &result);
-    debug!("output_in_workspace: checking whether %s exists",
-           result.to_str());
-    if os::path_exists(&result) {
-        Some(result)
-    }
-    else {
-        error!(fmt!("output_in_workspace: %s does not exist", result.to_str()));
-        None
-    }
-}
-
-/// 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> {
-    let result = mk_output_path(Lib, pkgid, &workspace.push("build"));
+    result = mk_output_path(Lib, pkgid.path.to_str(), result);
     debug!("built_library_in_workspace: checking whether %s exists",
            result.to_str());
 
@@ -104,7 +100,8 @@ pub fn built_library_in_workspace(pkgid: PkgId, workspace: &Path) -> Option<Path
     let dir_contents = os::list_dir(&result.pop());
     debug!("dir has %? entries", dir_contents.len());
 
-    let lib_prefix = fmt!("%s%s", os::consts::DLL_PREFIX, pkgid.short_name);
+    // n.b. This code assumes the pkgid's path only has one element
+    let lib_prefix = fmt!("%s%s", os::consts::DLL_PREFIX, pkgid.path.to_str());
     let lib_filetype = fmt!("%s%s", pkgid.version.to_str(), os::consts::DLL_SUFFIX);
 
     debug!("lib_prefix = %s and lib_filetype = %s", lib_prefix, lib_filetype);
@@ -176,15 +173,13 @@ pub fn target_library_in_workspace(pkgid: &PkgId, workspace: &Path) -> Path {
 
 /// Returns the test executable that would be installed for <pkgid>
 /// in <workspace>
-/// note that we *don't* install test executables, so this is just for unit testing
-pub fn target_test_in_workspace(pkgid: PkgId, workspace: &Path) -> Path {
+pub fn target_test_in_workspace(pkgid: &PkgId, workspace: &Path) -> Path {
     target_file_in_workspace(pkgid, workspace, Test)
 }
 
 /// Returns the bench executable that would be installed for <pkgid>
 /// in <workspace>
-/// note that we *don't* install bench executables, so this is just for unit testing
-pub fn target_bench_in_workspace(pkgid: PkgId, workspace: &Path) -> Path {
+pub fn target_bench_in_workspace(pkgid: &PkgId, workspace: &Path) -> Path {
     target_file_in_workspace(pkgid, workspace, Bench)
 }
 
@@ -193,14 +188,17 @@ fn target_file_in_workspace(pkgid: &PkgId, workspace: &Path,
     use conditions::bad_path::cond;
 
     let (subdir, create_dir) = match what {
-        Lib => "lib", Main | Test | Bench => "bin"
+        Main => ("bin", true), Lib => ("lib", true), Test | Bench => ("build", false)
     };
     let result = workspace.push(subdir);
-    debug!("target_file_in_workspace: %s %?", result.to_str(), create_dir);
-    if !os::path_exists(&result) && !mkdir_recursive(&result, u_rwx) {
-        cond.raise((result, fmt!("I couldn't create the %s dir", subdir)));
+    if create_dir {
+        if !os::path_exists(&result) && !mkdir_recursive(&result, u_rwx) {
+            cond.raise((copy result,
+                        fmt!("I couldn't create the %s dir", subdir)));
+        }
     }
-    mk_output_path(what, pkgid, &result)
+    mk_output_path(what, pkgid.path.to_str(), result)
+
 }
 
 /// Return the directory for <pkgid>'s build artifacts in <workspace>.
@@ -211,7 +209,7 @@ pub fn build_pkg_id_in_workspace(pkgid: &PkgId, workspace: &Path) -> Path {
     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(normalize(~copy pkgid.path).to_str());
     if os::path_exists(&result) || os::mkdir_recursive(&result, u_rwx) {
         result
     }
@@ -222,15 +220,8 @@ pub fn build_pkg_id_in_workspace(pkgid: &PkgId, workspace: &Path) -> Path {
 
 /// Return the output file for a given directory name,
 /// given whether we're building a library and whether we're building tests
-pub fn mk_output_path(what: OutputType, pkg_id: PkgId, workspace: &Path) -> Path {
-    let short_name = pkg_id.short_name_with_version();
-    // Not local_path.dir_path()! For package foo/bar/blat/, we want
-    // the executable blat-0.5 to live under blat/
-    let dir = workspace.push_rel(&*pkg_id.local_path);
-    debug!("mk_output_path: short_name = %s, path = %s",
-           short_name, dir.to_str());
-    let output_path = match what {
-        // this code is duplicated from elsewhere; fix this
+pub fn mk_output_path(what: OutputType, short_name: ~str, dir: Path) -> Path {
+    match what {
         Lib => dir.push(os::dll_filename(short_name)),
         _ => dir.push(fmt!("%s%s%s", short_name,
                            match what {
@@ -239,7 +230,5 @@ pub fn mk_output_path(what: OutputType, pkg_id: PkgId, workspace: &Path) -> Path
                                _     => ""
                            }
                            os::EXE_SUFFIX))
-    };
-    debug!("mk_output_path: returning %s", output_path.to_str());
-    output_path
+    }
 }