---

yaml
---
r: 112892
b: refs/heads/auto
c: fb72d7c
h: refs/heads/master
v: v3

Author: bors

[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: b537028116c8f5d98ec6e522ba5fe44067d7234e
+refs/heads/auto: fb72d7cfea9ba44581f708b13aa82ab23ee4fa7e
 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 element in both lists is equal, keep going.
+        // If the current elements of both lists are 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 element in both lists is equal, keep going.
+        // If the current elements of both lists are 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 element in both lists is equal, keep going.
+            // If the current elements of both lists are 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.

branches/auto/src/libserialize/json.rs

@@ -2205,6 +2205,10 @@ 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 {
@@ -2643,41 +2647,25 @@ mod tests {
 
     #[test]
     fn test_decode_str() {
-        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());
+        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());
+        }
     }
 
     #[test]

branches/auto/src/libserialize/serialize.rs

@@ -313,6 +313,18 @@ 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)