---

yaml
---
r: 145071
b: refs/heads/try2
c: ec8f884
h: refs/heads/master
i:
  145069: 3bc5877
  145067: e0917ca
  145063: 0f82453
  145055: d70ca1f
v: v3

Author: brendanzab

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 5f2f952dbcc1a0e2b57539ae7000710453fa3fb0
+refs/heads/try2: ec8f88417c2ced5bed685c6bc94d11a7c0840f96
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/doc/rust.md

@@ -1717,8 +1717,7 @@ Supported traits for `deriving` are:
 * `Clone` and `DeepClone`, to perform (deep) copies.
 * `IterBytes`, to iterate over the bytes in a data type.
 * `Rand`, to create a random instance of a data type.
-* `Default`, to create an empty instance of a data type.
-* `Zero`, to create an zero instance of a numeric data type.
+* `Zero`, to create an zero (or empty) instance of a data type.
 * `ToStr`, to convert to a string. For a type with this instance,
   `obj.to_str()` has similar output as `fmt!("%?", obj)`, but it differs in that
   each constituent field of the type must also implement `ToStr` and will have

branches/try2/doc/tutorial.md

@@ -2249,7 +2249,7 @@ enum ABC { A, B, C }
 
 The full list of derivable traits is `Eq`, `TotalEq`, `Ord`,
 `TotalOrd`, `Encodable` `Decodable`, `Clone`, `DeepClone`,
-`IterBytes`, `Rand`, `Default`, `Zero`, and `ToStr`.
+`IterBytes`, `Rand`, `Zero`, and `ToStr`.
 
 # Crates and the module system
 

branches/try2/src/compiletest/compiletest.rs

@@ -309,7 +309,7 @@ pub fn make_test_name(config: &config, testfile: &Path) -> test::TestName {
         let filename = path.filename();
         let p = path.pop();
         let dir = p.filename();
-        fmt!("%s/%s", dir.unwrap_or(""), filename.unwrap_or(""))
+        fmt!("%s/%s", dir.unwrap_or_default(""), filename.unwrap_or_default(""))
     }
 
     test::DynTestName(fmt!("[%s] %s",

branches/try2/src/etc/emacs/README.md

@@ -1,29 +1,27 @@
-`rust-mode`: A major Emacs mode for editing Rust source code
-============================================================
+rust-mode: A major emacs mode for editing Rust source code
+==========================================================
 
-`rust-mode` makes editing [Rust](http://rust-lang.org) code with Emacs
+`rust-mode` makes editing [Rust](http://rust-lang.org) code with emacs
 enjoyable.
 
 
 ### Manual Installation
 
-To install manually, check out this repository and add this to your
-`.emacs` file:
+To install manually, check out this repository and add this to your .emacs
+file:
 
-```lisp
-(add-to-list 'load-path "/path/to/rust-mode/")
-(require 'rust-mode)
-```
+    (add-to-list 'load-path "/path/to/rust-mode/")
+    (require 'rust-mode)
 
-`rust-mode` will automatically be associated with `.rs` files. To enable it
-explicitly, do <kbd>M-x rust-mode</kbd>.
+Rust mode will automatically be associated with .rs files. To enable it
+explicitly, do `M-x rust-mode`.
 
-### `package.el` installation via Marmalade or MELPA
+### package.el installation via Marmalade or MELPA
 
 It can be more convenient to use Emacs's package manager to handle
 installation for you if you use many elisp libraries. If you have
-`package.el` but haven't added Marmalade or MELPA, the community
-package source, yet, add this to `~/.emacs.d/init.el`:
+package.el but haven't added Marmalade or MELPA, the community package source,
+yet, add this to ~/.emacs.d/init.el:
 
 Using Marmalade:
 
@@ -49,33 +47,32 @@ Then do this to load the package listing:
 * <kbd>M-x package-refresh-contents</kbd>
 
 If you use a version of Emacs prior to 24 that doesn't include
-`package.el`, you can get it from [here](http://bit.ly/pkg-el23).
+package.el, you can get it from http://bit.ly/pkg-el23.
 
-If you have an older ELPA `package.el` installed from tromey.com, you
+If you have an older ELPA package.el installed from tromey.com, you
 should upgrade in order to support installation from multiple sources.
 The ELPA archive is deprecated and no longer accepting new packages,
 so the version there (1.7.1) is very outdated.
 
-#### Install `rust-mode`
+#### Install rust-mode
 
-One you have `package.el`, you can install `rust-mode` or any other
-modes by choosing them from a list:
+From there you can install rust-mode or any other modes by choosing
+them from a list:
 
 * <kbd>M-x package-list-packages</kbd>
 
-Now, to install packages, move your cursor to them and press
-<kbd>i</kbd>. This will mark the packages for installation. When
-you're done with marking, press <kbd>x</kbd>, and ELPA will install
-the packages for you (under `~/.emacs.d/elpa/`).
+Now, to install packages, move your cursor to them and press i. This
+will mark the packages for installation. When you're done with
+marking, press x, and ELPA will install the packages for you (under
+~/.emacs.d/elpa/).
 
-* or using <kbd>M-x package-install rust-mode</kbd>
+* or using <kbd>M-x package-install rust-mode
 
 ### Tests via ERT
 
-The file `rust-mode-tests.el` contains tests that can be run via
-[ERT](http://www.gnu.org/software/emacs/manual/html_node/ert/index.html).
-You can use `run_rust_emacs_tests.sh` to run them in batch mode, if
-Emacs is somewhere in your `$PATH`.
+The file `rust-mode-tests.el` contains tests that can be run via ERT.  You can
+use `run_rust_emacs_tests.sh` to run them in batch mode, if emacs is somewhere
+in your `$PATH`.
 
 ### Known bugs
 

branches/try2/src/libextra/glob.rs

@@ -137,17 +137,7 @@ fn list_dir_sorted(path: &Path) -> ~[Path] {
 /**
  * A compiled Unix shell style pattern.
  */
-#[cfg(stage0)]
-#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, IterBytes)]
-pub struct Pattern {
-    priv tokens: ~[PatternToken]
-}
-
-/**
- * A compiled Unix shell style pattern.
- */
-#[cfg(not(stage0))]
-#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, IterBytes, Default)]
+#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, IterBytes, Zero)]
 pub struct Pattern {
     priv tokens: ~[PatternToken]
 }
@@ -322,7 +312,7 @@ impl Pattern {
         let require_literal = |c| {
             (options.require_literal_separator && is_sep(c)) ||
             (options.require_literal_leading_dot && c == '.'
-             && is_sep(prev_char.unwrap_or('/')))
+             && is_sep(prev_char.unwrap_or_default('/')))
         };
 
         for (ti, token) in self.tokens.slice_from(i).iter().enumerate() {
@@ -468,37 +458,7 @@ fn is_sep(c: char) -> bool {
 /**
  * Configuration options to modify the behaviour of `Pattern::matches_with(..)`
  */
-#[cfg(stage0)]
-#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, IterBytes)]
-pub struct MatchOptions {
-
-    /**
-     * Whether or not patterns should be matched in a case-sensitive manner. This
-     * currently only considers upper/lower case relationships between ASCII characters,
-     * but in future this might be extended to work with Unicode.
-     */
-    case_sensitive: bool,
-
-    /**
-     * If this is true then path-component separator characters (e.g. `/` on Posix)
-     * must be matched by a literal `/`, rather than by `*` or `?` or `[...]`
-     */
-    require_literal_separator: bool,
-
-    /**
-     * If this is true then paths that contain components that start with a `.` will
-     * not match unless the `.` appears literally in the pattern: `*`, `?` or `[...]`
-     * will not match. This is useful because such files are conventionally considered
-     * hidden on Unix systems and it might be desirable to skip them when listing files.
-     */
-    require_literal_leading_dot: bool
-}
-
-/**
- * Configuration options to modify the behaviour of `Pattern::matches_with(..)`
- */
-#[cfg(not(stage0))]
-#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, IterBytes, Default)]
+#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, IterBytes, Zero)]
 pub struct MatchOptions {
 
     /**

branches/try2/src/libextra/num/bigint.rs

@@ -635,7 +635,7 @@ impl BigUint {
 
     // Converts this BigUint into an int, unless it would overflow.
     pub fn to_int_opt(&self) -> Option<int> {
-        self.to_uint_opt().and_then(|n| {
+        self.to_uint_opt().chain(|n| {
             // If top bit of uint is set, it's too large to convert to
             // int.
             if (n >> (2*BigDigit::bits - 1) != 0) {
@@ -1221,7 +1221,7 @@ impl BigInt {
         match self.sign {
             Plus  => self.data.to_int_opt(),
             Zero  => Some(0),
-            Minus => self.data.to_uint_opt().and_then(|n| {
+            Minus => self.data.to_uint_opt().chain(|n| {
                 let m: uint = 1 << (2*BigDigit::bits-1);
                 if (n > m) {
                     None

branches/try2/src/libextra/num/rational.rs

@@ -273,9 +273,9 @@ impl<T: FromStr + Clone + Integer + Ord>
             return None
         }
         let a_option: Option<T> = FromStr::from_str(split[0]);
-        do a_option.and_then |a| {
+        do a_option.chain |a| {
             let b_option: Option<T> = FromStr::from_str(split[1]);
-            do b_option.and_then |b| {
+            do b_option.chain |b| {
                 Some(Ratio::new(a.clone(), b.clone()))
             }
         }
@@ -291,10 +291,10 @@ impl<T: FromStrRadix + Clone + Integer + Ord>
         } else {
             let a_option: Option<T> = FromStrRadix::from_str_radix(split[0],
                                                                    radix);
-            do a_option.and_then |a| {
+            do a_option.chain |a| {
                 let b_option: Option<T> =
                     FromStrRadix::from_str_radix(split[1], radix);
-                do b_option.and_then |b| {
+                do b_option.chain |b| {
                     Some(Ratio::new(a.clone(), b.clone()))
                 }
             }

branches/try2/src/libextra/tempfile.rs

@@ -28,6 +28,97 @@ pub fn mkdtemp(tmpdir: &Path, suffix: &str) -> Option<Path> {
     None
 }
 
-// the tests for this module need to change the path using change_dir,
-// and this doesn't play nicely with other tests so these unit tests are located
-// in src/test/run-pass/tempfile.rs
+#[cfg(test)]
+mod tests {
+
+    use tempfile::mkdtemp;
+
+    use std::os;
+
+    #[test]
+    fn test_mkdtemp() {
+        let p = mkdtemp(&Path("."), "foobar").unwrap();
+        os::remove_dir(&p);
+        assert!(p.to_str().ends_with("foobar"));
+    }
+
+    // Ideally these would be in std::os but then core would need
+    // to depend on std
+    #[test]
+    fn recursive_mkdir_rel() {
+        use std::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
+        use std::os;
+        use std::unstable::change_dir_locked;
+
+        let root = mkdtemp(&os::tmpdir(), "recursive_mkdir_rel").
+            expect("recursive_mkdir_rel");
+        assert!(do change_dir_locked(&root) {
+            let path = Path("frob");
+            debug!("recursive_mkdir_rel: Making: %s in cwd %s [%?]", path.to_str(),
+                   os::getcwd().to_str(),
+                   os::path_exists(&path));
+            assert!(os::mkdir_recursive(&path,  (S_IRUSR | S_IWUSR | S_IXUSR) as i32));
+            assert!(os::path_is_dir(&path));
+            assert!(os::mkdir_recursive(&path,  (S_IRUSR | S_IWUSR | S_IXUSR) as i32));
+            assert!(os::path_is_dir(&path));
+        });
+    }
+
+    #[test]
+    fn recursive_mkdir_dot() {
+        use std::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
+        use std::os;
+
+        let dot = Path(".");
+        assert!(os::mkdir_recursive(&dot,  (S_IRUSR | S_IWUSR | S_IXUSR) as i32));
+        let dotdot = Path("..");
+        assert!(os::mkdir_recursive(&dotdot,  (S_IRUSR | S_IWUSR | S_IXUSR) as i32));
+    }
+
+    #[test]
+    fn recursive_mkdir_rel_2() {
+        use std::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
+        use std::os;
+        use std::unstable::change_dir_locked;
+
+        let root = mkdtemp(&os::tmpdir(), "recursive_mkdir_rel_2").
+            expect("recursive_mkdir_rel_2");
+        assert!(do change_dir_locked(&root) {
+            let path = Path("./frob/baz");
+            debug!("recursive_mkdir_rel_2: Making: %s in cwd %s [%?]", path.to_str(),
+                   os::getcwd().to_str(), os::path_exists(&path));
+            assert!(os::mkdir_recursive(&path, (S_IRUSR | S_IWUSR | S_IXUSR) as i32));
+                assert!(os::path_is_dir(&path));
+            assert!(os::path_is_dir(&path.pop()));
+            let path2 = Path("quux/blat");
+            debug!("recursive_mkdir_rel_2: Making: %s in cwd %s", path2.to_str(),
+                   os::getcwd().to_str());
+            assert!(os::mkdir_recursive(&path2, (S_IRUSR | S_IWUSR | S_IXUSR) as i32));
+                assert!(os::path_is_dir(&path2));
+            assert!(os::path_is_dir(&path2.pop()));
+        });
+    }
+
+    // Ideally this would be in core, but needs mkdtemp
+    #[test]
+    pub fn test_rmdir_recursive_ok() {
+        use std::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
+        use std::os;
+
+        let rwx = (S_IRUSR | S_IWUSR | S_IXUSR) as i32;
+
+        let tmpdir = mkdtemp(&os::tmpdir(), "test").expect("test_rmdir_recursive_ok: \
+                                            couldn't create temp dir");
+        let root = tmpdir.push("foo");
+
+        debug!("making %s", root.to_str());
+        assert!(os::make_dir(&root, rwx));
+        assert!(os::make_dir(&root.push("foo"), rwx));
+        assert!(os::make_dir(&root.push("foo").push("bar"), rwx));
+        assert!(os::make_dir(&root.push("foo").push("bar").push("blat"), rwx));
+        assert!(os::remove_dir_recursive(&root));
+        assert!(!os::path_exists(&root));
+        assert!(!os::path_exists(&root.push("bar")));
+        assert!(!os::path_exists(&root.push("bar").push("blat")));
+    }
+}