---

yaml
---
r: 56428
b: refs/heads/auto
c: 1d53bab
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -14,6 +14,6 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 4e2c8f422aec1aef910fdfdac57f5f66a7465355
+refs/heads/auto: 1d53babd2f23439975518fda94d9122b15e779c9
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c

branches/auto/src/libcore/iterator.rs

@@ -312,6 +312,19 @@ impl<A, T: Iterator<A>> Iterator<A> for TakeIterator<T> {
     }
 }
 
+pub struct ScanIterator<'self, A, B, T, St> {
+    priv iter: T,
+    priv f: &'self fn(&mut St, A) -> Option<B>,
+    state: St
+}
+
+impl<'self, A, B, T: Iterator<A>, St> Iterator<B> for ScanIterator<'self, A, B, T, St> {
+    #[inline]
+    fn next(&mut self) -> Option<B> {
+        self.iter.next().chain(|a| (self.f)(&mut self.state, a))
+    }
+}
+
 pub struct UnfoldrIterator<'self, A, St> {
     priv f: &'self fn(&mut St) -> Option<A>,
     state: St
@@ -335,16 +348,25 @@ impl<'self, A, St> Iterator<A> for UnfoldrIterator<'self, A, St> {
     }
 }
 
-pub struct ScanIterator<'self, A, B, T, St> {
-    priv iter: T,
-    priv f: &'self fn(&mut St, A) -> Option<B>,
-    state: St
+/// An infinite iterator starting at `start` and advancing by `step` with each iteration
+pub struct Counter<A> {
+    state: A,
+    step: A
 }
 
-impl<'self, A, B, T: Iterator<A>, St> Iterator<B> for ScanIterator<'self, A, B, T, St> {
-    #[inline]
-    fn next(&mut self) -> Option<B> {
-        self.iter.next().chain(|a| (self.f)(&mut self.state, a))
+pub impl<A> Counter<A> {
+    #[inline(always)]
+    fn new(start: A, step: A) -> Counter<A> {
+        Counter{state: start, step: step}
+    }
+}
+
+impl<A: Add<A, A> + Clone> Iterator<A> for Counter<A> {
+    #[inline(always)]
+    fn next(&mut self) -> Option<A> {
+        let result = self.state.clone();
+        self.state = self.state.add(&self.step); // FIXME: #6050
+        Some(result)
     }
 }
 
@@ -353,6 +375,13 @@ mod tests {
     use super::*;
     use prelude::*;
 
+    #[test]
+    fn test_counter_to_vec() {
+        let mut it = Counter::new(0, 5).take(10);
+        let xs = iter::iter_to_vec(|f| it.advance(f));
+        assert_eq!(xs, ~[0, 5, 10, 15, 20, 25, 30, 35, 40, 45]);
+    }
+
     #[test]
     fn test_iterator_chain() {
         let xs = [0u, 1, 2, 3, 4, 5];

branches/auto/src/libcore/os.rs

@@ -43,6 +43,8 @@ use vec;
 pub use libc::fclose;
 pub use os::consts::*;
 
+// FIXME: move these to str perhaps? #2620
+
 pub fn close(fd: c_int) -> c_int {
     unsafe {
         libc::close(fd)
@@ -77,8 +79,6 @@ pub fn getcwd() -> Path {
     }
 }
 
-// FIXME: move these to str perhaps? #2620
-
 pub fn as_c_charp<T>(s: &str, f: &fn(*c_char) -> T) -> T {
     str::as_c_str(s, |b| f(b as *c_char))
 }

branches/auto/src/librustpkg/README.txt

@@ -1,24 +1,4 @@
-Right now, commands that work are "build" and "clean".
+Right now (2013-04-11), only one package works, the branch of rust-sdl at:
+https://github.com/catamorphism/rust-sdl/tree/new-rustpkg
 
-`rustpkg build` and `rustpkg clean` should work
-
-for example:
-$ cd ~/rust/src/librustpkg/testsuite/pass
-$ rustpkg build hello-world
-... some output ...
-$ rustpkg clean hello-world
-
--------------
-the following test packages in librustpkg/testsuite/pass:
-      * hello-world
-      * install-paths
-      * simple-lib
-      * deeply/nested/path
-      * fancy-lib
-
-   It fails on the following test packages:
-      * external-crate (no support for `extern mod` inference yet)
-
-and should fail with proper error messages
-on all of the test packages in librustpkg/testsuite/fail
-      * no-inferred-crates
+and only one command works, "build".

branches/auto/src/librustpkg/conditions.rs

@@ -11,12 +11,7 @@
 // Useful conditions
 
 pub use core::path::Path;
-pub use util::PkgId;
 
 condition! {
     bad_path: (super::Path, ~str) -> super::Path;
 }
-
-condition! {
-    nonexistent_package: (super::PkgId, ~str) -> super::Path;
-}

branches/auto/src/librustpkg/context.rs

@@ -15,43 +15,39 @@ use core::{os, str};
 use core::option::*;
 use util::PkgId;
 
-#[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
-/// environment; for now, it's hard-wired to just be "."
-pub fn rust_path() -> ~[Path] {
-    ~[Path(".")]
+/// Returns the output directory to use.
+/// Right now is always the default, should
+/// support changing it.
+pub fn dest_dir(pkgid: PkgId) -> Path {
+    default_dest_dir(&pkgid.path)
 }
 
-/// Creates a directory that is readable, writeable,
-/// and executable by the user. Returns true iff creation
-/// succeeded.
-pub fn make_dir_rwx(p: &Path) -> bool {
+/// Returns the default output directory for compilation.
+/// Creates that directory if it doesn't exist.
+pub fn default_dest_dir(pkg_dir: &Path) -> Path {
     use core::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
+    use conditions::bad_path::cond;
 
-    os::make_dir(p, (S_IRUSR | S_IWUSR | S_IXUSR) as i32)
-}
-
-/// Creates a directory that is readable, writeable,
-/// and executable by the user. Returns true iff creation
-/// succeeded. Also creates all intermediate subdirectories
-/// if they don't already exist.
-pub fn mkdir_recursive(p: &Path) -> bool {
-    if os::path_is_dir(p) {
-        return true;
-    }
-    let parent = p.dir_path();
-    debug!("mkdir_recursive: parent = %s",
-           parent.to_str());
-    if parent.to_str() == ~"."
-        || parent.to_str() == ~"/" { // !!!
-        // No parent directories to create
-        os::path_is_dir(&parent) && make_dir_rwx(p)
+    // For now: assumes that pkg_dir exists and is relative
+    // to the CWD. Change this later when we do path searching.
+    let rslt = pkg_dir.push("build");
+    let is_dir = os::path_is_dir(&rslt);
+    if os::path_exists(&rslt) {
+        if is_dir {
+            rslt
+        }
+        else {
+            cond.raise((rslt, ~"Path names a file that isn't a directory"))
+        }
     }
     else {
-        mkdir_recursive(&parent) && make_dir_rwx(p)
+        // Create it
+        if os::make_dir(&rslt, (S_IRUSR | S_IWUSR | S_IXUSR) as i32) {
+            rslt
+        }
+        else {
+            cond.raise((rslt, ~"Could not create directory"))
+        }
     }
 }
 
@@ -73,94 +69,34 @@ pub fn normalize(p: ~Path) -> ~Path {
     }
 }
 
-// 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.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.path.to_str())
-}
-
-/// Returns the executable that would be installed for <pkgid>
-/// in <workspace>
-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)
-}
-
-
-/// Returns the executable that would be installed for <pkgid>
-/// in <workspace>
-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)
-}
-
-/// 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)
-}
-
-/// 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)
-}
-
-/// Return the directory for <pkgid>'s build artifacts in <workspace>.
-/// Creates it if it doesn't exist.
-pub fn build_pkg_id_in_workspace(pkgid: PkgId, workspace: &Path) -> Path {
-    use conditions::bad_path::cond;
-
-    let mut result = workspace.push("build");
-    // n.b. Should actually use a target-specific
-    // subdirectory of build/
-    result = result.push(normalize(~pkgid.path).to_str());
-    if os::path_exists(&result) || mkdir_recursive(&result) {
-        result
-    }
-    else {
-        cond.raise((result, fmt!("Could not create directory for package %s", pkgid.to_str())))
-    }
-}
-
-/// 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, 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 { ~"" },
-                           os::EXE_SUFFIX))
-    }
-}
-
 #[cfg(test)]
 mod test {
-    use core::os;
+    use core::{os, rand};
+    use core::path::Path;
+    use path_util::*;
+    use core::rand::RngUtil;
+
+    // Helper function to create a directory name that doesn't exist
+    pub fn mk_nonexistent(tmpdir: &Path, suffix: &str) -> Path {
+        let r = rand::rng();
+        for 1000.times {
+            let p = tmpdir.push(r.gen_str(16) + suffix);
+            if !os::path_exists(&p) {
+                return p;
+            }
+        }
+        fail!(~"Couldn't compute a non-existent path name; this is worrisome")
+    }
 
     #[test]
-    fn recursive_mkdir_ok() {
-        let root = os::tmpdir();
-        let path = "xy/z/zy";
-        let nested = root.push(path);
-        assert!(super::mkdir_recursive(&nested));
-        assert!(os::path_is_dir(&root.push("xy")));
-        assert!(os::path_is_dir(&root.push("xy/z")));
-        assert!(os::path_is_dir(&nested));
+    fn default_dir_ok() {
+        let the_path = os::tmpdir();
+        let substitute_path = Path("xyzzy");
+        assert!(default_dest_dir(&the_path) == the_path.push(~"build"));
+        let nonexistent_path = mk_nonexistent(&the_path, "quux");
+        let bogus = do ::conditions::bad_path::cond.trap(|_| {
+            substitute_path
+        }).in { default_dest_dir(&nonexistent_path) };
+        assert!(bogus == substitute_path);
     }
 }