---

yaml
---
r: 112891
b: refs/heads/auto
c: b537028
h: refs/heads/master
i:
  112889: 2a9da16
  112887: 3326712
v: v3

Author: aochagavia

[refs]

@@ -13,7 +13,7 @@ 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: e4ad24f1b2f16fad780bdb433bfaaea80eb7fd1d
+refs/heads/auto: b537028116c8f5d98ec6e522ba5fe44067d7234e
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/doc/tutorial.md

@@ -1197,7 +1197,7 @@ fn eq(xs: &List, ys: &List) -> bool {
     match (xs, ys) {
         // If we have reached the end of both lists, they are equal.
         (&Nil, &Nil) => true,
-        // If the current elements of both lists are equal, keep going.
+        // If the current element in both lists is equal, keep going.
         (&Cons(x, ~ref next_xs), &Cons(y, ~ref next_ys))
                 if x == y => eq(next_xs, next_ys),
         // If the current elements are not equal, the lists are not equal.
@@ -1304,7 +1304,7 @@ fn eq<T: Eq>(xs: &List<T>, ys: &List<T>) -> bool {
     match (xs, ys) {
         // If we have reached the end of both lists, they are equal.
         (&Nil, &Nil) => true,
-        // If the current elements of both lists are equal, keep going.
+        // If the current element in both lists is equal, keep going.
         (&Cons(ref x, ~ref next_xs), &Cons(ref y, ~ref next_ys))
                 if x == y => eq(next_xs, next_ys),
         // If the current elements are not equal, the lists are not equal.
@@ -1333,7 +1333,7 @@ impl<T: Eq> Eq for List<T> {
         match (self, ys) {
             // If we have reached the end of both lists, they are equal.
             (&Nil, &Nil) => true,
-            // If the current elements of both lists are equal, keep going.
+            // If the current element in both lists is equal, keep going.
             (&Cons(ref x, ~ref next_xs), &Cons(ref y, ~ref next_ys))
                     if x == y => next_xs == next_ys,
             // If the current elements are not equal, the lists are not equal.
@@ -2965,7 +2965,7 @@ use farm::*;
 ~~~
 
 > *Note:* This feature of the compiler is currently gated behind the
-> `#[feature(globs)]` directive. More about these directives can be found in
+> `#![feature(globs)]` directive. More about these directives can be found in
 > the manual.
 
 However, that's not all. You can also rename an item while you're bringing it into scope:

branches/auto/src/libserialize/json.rs

@@ -2205,10 +2205,6 @@ impl ToJson for ~str {
     fn to_json(&self) -> Json { String((*self).clone()) }
 }
 
-impl ToJson for StrBuf {
-    fn to_json(&self) -> Json { String((*self).as_slice().into_owned()) }
-}
-
 impl<A:ToJson,B:ToJson> ToJson for (A, B) {
     fn to_json(&self) -> Json {
         match *self {
@@ -2647,25 +2643,41 @@ mod tests {
 
     #[test]
     fn test_decode_str() {
-        let s = [("\"\"", ""),
-                 ("\"foo\"", "foo"),
-                 ("\"\\\"\"", "\""),
-                 ("\"\\b\"", "\x08"),
-                 ("\"\\n\"", "\n"),
-                 ("\"\\r\"", "\r"),
-                 ("\"\\t\"", "\t"),
-                 ("\"\\u12ab\"", "\u12ab"),
-                 ("\"\\uAB12\"", "\uAB12")];
-
-        for &(i, o) in s.iter() {
-            let mut decoder = Decoder::new(from_str(i).unwrap());
-            let v: StrBuf = Decodable::decode(&mut decoder).unwrap();
-            assert_eq!(v.as_slice(), o);
-
-            let mut decoder = Decoder::new(from_str(i).unwrap());
-            let v: ~str = Decodable::decode(&mut decoder).unwrap();
-            assert_eq!(v, o.to_owned());
-        }
+        let mut decoder = Decoder::new(from_str("\"\"").unwrap());
+        let v: ~str = Decodable::decode(&mut decoder).unwrap();
+        assert_eq!(v, "".to_owned());
+
+        let mut decoder = Decoder::new(from_str("\"foo\"").unwrap());
+        let v: ~str = Decodable::decode(&mut decoder).unwrap();
+        assert_eq!(v, "foo".to_owned());
+
+        let mut decoder = Decoder::new(from_str("\"\\\"\"").unwrap());
+        let v: ~str = Decodable::decode(&mut decoder).unwrap();
+        assert_eq!(v, "\"".to_owned());
+
+        let mut decoder = Decoder::new(from_str("\"\\b\"").unwrap());
+        let v: ~str = Decodable::decode(&mut decoder).unwrap();
+        assert_eq!(v, "\x08".to_owned());
+
+        let mut decoder = Decoder::new(from_str("\"\\n\"").unwrap());
+        let v: ~str = Decodable::decode(&mut decoder).unwrap();
+        assert_eq!(v, "\n".to_owned());
+
+        let mut decoder = Decoder::new(from_str("\"\\r\"").unwrap());
+        let v: ~str = Decodable::decode(&mut decoder).unwrap();
+        assert_eq!(v, "\r".to_owned());
+
+        let mut decoder = Decoder::new(from_str("\"\\t\"").unwrap());
+        let v: ~str = Decodable::decode(&mut decoder).unwrap();
+        assert_eq!(v, "\t".to_owned());
+
+        let mut decoder = Decoder::new(from_str("\"\\u12ab\"").unwrap());
+        let v: ~str = Decodable::decode(&mut decoder).unwrap();
+        assert_eq!(v, "\u12ab".to_owned());
+
+        let mut decoder = Decoder::new(from_str("\"\\uAB12\"").unwrap());
+        let v: ~str = Decodable::decode(&mut decoder).unwrap();
+        assert_eq!(v, "\uAB12".to_owned());
     }
 
     #[test]

branches/auto/src/libserialize/serialize.rs

@@ -313,18 +313,6 @@ impl<E, D:Decoder<E>> Decodable<D, E> for ~str {
     }
 }
 
-impl<E, S:Encoder<E>> Encodable<S, E> for StrBuf {
-    fn encode(&self, s: &mut S) -> Result<(), E> {
-        s.emit_str(self.as_slice())
-    }
-}
-
-impl<E, D:Decoder<E>> Decodable<D, E> for StrBuf {
-    fn decode(d: &mut D) -> Result<StrBuf, E> {
-        Ok(StrBuf::from_str(try!(d.read_str())))
-    }
-}
-
 impl<E, S:Encoder<E>> Encodable<S, E> for f32 {
     fn encode(&self, s: &mut S) -> Result<(), E> {
         s.emit_f32(*self)