rustpkg: Implement install command

    The install command should work now, though it only installs
    in-place (anything else has to wait until I implement RUST_PATH).

Also including:
    core: Add remove_directory_recursive, change copy_file

    Make copy_file preserve permissions, and add a remove_directory_recursive
    function.

Author: catamorphism

src/libcore/os.rs

@@ -772,6 +772,28 @@ pub fn list_dir_path(p: &Path) -> ~[~Path] {
     list_dir(p).map(|f| ~p.push(*f))
 }
 
+/// Removes a directory at the specified path, after removing
+/// all its contents. Use carefully!
+pub fn remove_dir_recursive(p: &Path) -> bool {
+    let mut error_happened = false;
+    for walk_dir(p) |inner| {
+        if !error_happened {
+            if path_is_dir(inner) {
+                if !remove_dir_recursive(inner) {
+                    error_happened = true;
+                }
+            }
+            else {
+                if !remove_file(inner) {
+                    error_happened = true;
+                }
+            }
+        }
+    };
+    // Directory should now be empty
+    !error_happened && remove_dir(p)
+}
+
 /// Removes a directory at the specified path
 pub fn remove_dir(p: &Path) -> bool {
    return rmdir(p);
@@ -877,6 +899,10 @@ pub fn copy_file(from: &Path, to: &Path) -> bool {
             if istream as uint == 0u {
                 return false;
             }
+            // Preserve permissions
+            let from_mode = from.get_mode().expect("copy_file: couldn't get permissions \
+                                                    for source file");
+
             let ostream = do as_c_charp(to.to_str()) |top| {
                 do as_c_charp("w+b") |modebuf| {
                     libc::fopen(top, modebuf)
@@ -908,6 +934,15 @@ pub fn copy_file(from: &Path, to: &Path) -> bool {
             }
             fclose(istream);
             fclose(ostream);
+
+            // Give the new file the old file's permissions
+            unsafe {
+                if do str::as_c_str(to.to_str()) |to_buf| {
+                    libc::chmod(to_buf, from_mode as mode_t)
+                } != 0 {
+                    return false; // should be a condition...
+                }
+            }
             return ok;
         }
     }
@@ -1594,13 +1629,15 @@ mod tests {
                       == buf.len() as size_t))
           }
           assert!((libc::fclose(ostream) == (0u as c_int)));
+          let in_mode = in.get_mode();
           let rs = os::copy_file(&in, &out);
           if (!os::path_exists(&in)) {
             fail!(fmt!("%s doesn't exist", in.to_str()));
           }
           assert!((rs));
           let rslt = run::run_program(~"diff", ~[in.to_str(), out.to_str()]);
           assert!((rslt == 0));
+          assert!(out.get_mode() == in_mode);
           assert!((remove_file(&in)));
           assert!((remove_file(&out)));
         }

src/librustpkg/conditions.rs

@@ -18,5 +18,13 @@ condition! {
 }
 
 condition! {
-    nonexistent_package: (super::PkgId, ~str) -> super::Path;
+    nonexistent_package: (super::PkgId, ~str) -> ();
+}
+
+condition! {
+    copy_failed: (super::Path, super::Path) -> ();
+}
+
+condition! {
+    missing_pkg_files: (super::PkgId) -> ();
 }

src/librustpkg/path_util.rs

@@ -12,6 +12,7 @@
 
 use util::PkgId;
 use core::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
+use core::os::mkdir_recursive;
 
 #[deriving(Eq)]
 pub enum OutputType { Main, Lib, Bench, Test }
@@ -23,7 +24,7 @@ pub fn rust_path() -> ~[Path] {
     ~[Path(".")]
 }
 
-static u_rwx: i32 = (S_IRUSR | S_IWUSR | S_IXUSR) as i32;
+pub static u_rwx: i32 = (S_IRUSR | S_IWUSR | S_IXUSR) as i32;
 
 /// Creates a directory that is readable, writeable,
 /// and executable by the user. Returns true iff creation
@@ -70,34 +71,137 @@ pub fn pkgid_src_in_workspace(pkgid: PkgId, workspace: &Path) -> Path {
     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, 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 {
+        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 mut result = workspace.push("build");
+    result = result.push_rel(&pkgid.path);
+    // should use a target-specific subdirectory
+    result = mk_output_path(Lib, pkgid.path.to_str(), result);
+    debug!("built_library_in_workspace: checking whether %s exists",
+           result.to_str());
+
+    // We don't know what the hash is, so we have to search through the directory
+    // contents
+    let dir_contents = os::list_dir(&result.pop());
+    debug!("dir has %? entries", dir_contents.len());
+
+    // 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);
+
+    let mut result_filename = None;
+    for dir_contents.each |&p| {
+        let mut which = 0;
+        let mut hash = None;
+        // Find a filename that matches the pattern: (lib_prefix)-hash-(version)(lib_suffix)
+        // and remember what the hash was
+        for p.each_split_char('-') |piece| {
+            debug!("a piece = %s", piece);
+            if which == 0 && piece != lib_prefix {
+                break;
+            }
+            else if which == 0 {
+                which += 1;
+            }
+            else if which == 1 {
+                hash = Some(piece.to_owned());
+                which += 1;
+            }
+            else if which == 2 && piece != lib_filetype {
+                hash = None;
+                break;
+            }
+            else if which == 2 {
+                break;
+            }
+            else {
+                // something went wrong
+                hash = None;
+                break;
+            }
+        }
+        if hash.is_some() {
+            result_filename = Some(p);
+            break;
+        }
+    }
+
+    // Return the filename that matches, which we now know exists
+    // (if result_filename != None)
+    debug!("result_filename = %?", result_filename);
+    match result_filename {
+        None => None,
+        Some(result_filename) => {
+            let result_filename = result.with_filename(result_filename);
+            debug!("result_filename = %s", result_filename.to_str());
+            Some(result_filename)
+        }
+    }
+}
+
 /// Returns the executable that would be installed for <pkgid>
 /// in <workspace>
+/// As a side effect, creates the bin-dir if it doesn't exist
 pub fn target_executable_in_workspace(pkgid: PkgId, workspace: &Path) -> Path {
-    let result = workspace.push("bin");
-    // should use a target-specific subdirectory
-    mk_output_path(Main, pkgid.path.to_str(), result)
+    target_file_in_workspace(pkgid, workspace, Main)
 }
 
 
 /// Returns the executable that would be installed for <pkgid>
 /// in <workspace>
+/// As a side effect, creates the bin-dir if it doesn't exist
 pub fn target_library_in_workspace(pkgid: PkgId, workspace: &Path) -> Path {
-    let result = workspace.push("lib");
-    mk_output_path(Lib, pkgid.path.to_str(), result)
+    target_file_in_workspace(pkgid, workspace, Lib)
 }
 
 /// Returns the test executable that would be installed for <pkgid>
 /// in <workspace>
 pub fn target_test_in_workspace(pkgid: PkgId, workspace: &Path) -> Path {
-    let result = workspace.push("build");
-    mk_output_path(Test, pkgid.path.to_str(), result)
+    target_file_in_workspace(pkgid, workspace, Test)
 }
 
 /// Returns the bench executable that would be installed for <pkgid>
 /// in <workspace>
 pub fn target_bench_in_workspace(pkgid: PkgId, workspace: &Path) -> Path {
-    let result = workspace.push("build");
-    mk_output_path(Bench, pkgid.path.to_str(), result)
+    target_file_in_workspace(pkgid, workspace, Bench)
+}
+
+fn target_file_in_workspace(pkgid: PkgId, workspace: &Path,
+                            what: OutputType) -> Path {
+    use conditions::bad_path::cond;
+
+    let (subdir, create_dir) = match what {
+        Main => ("bin", true), Lib => ("lib", true), Test | Bench => ("build", false)
+    };
+    let result = workspace.push(subdir);
+    if create_dir {
+        if !os::path_exists(&result) && !mkdir_recursive(&result, u_rwx) {
+            cond.raise((result, fmt!("I couldn't create the %s dir", subdir)));
+        }
+    }
+    mk_output_path(what, pkgid.path.to_str(), result)
+
 }
 
 /// Return the directory for <pkgid>'s build artifacts in <workspace>.
@@ -123,7 +227,11 @@ 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,
-                           if what == Test { ~"test" } else { ~"" },
+                           match what {
+                               Test => "test",
+                               Bench => "bench",
+                               _     => ""
+                           }
                            os::EXE_SUFFIX))
     }
 }