refactor(stream): Rename JSONStream to StreamDeserializer

This is a tad more consistent with the rest of the library.

json/src/de.rs

@@ -813,6 +813,58 @@ impl<Iter> de::VariantVisitor for Deserializer<Iter>
     }
 }
 
+//////////////////////////////////////////////////////////////////////////////
+
+/// Iterator that deserializes a stream into multiple JSON values.
+pub struct StreamDeserializer<T, Iter>
+    where Iter: Iterator<Item=io::Result<u8>>,
+          T: de::Deserialize
+{
+    deser: Deserializer<Iter>,
+    _marker: PhantomData<T>,
+}
+
+impl <T, Iter> StreamDeserializer<T, Iter>
+    where Iter:Iterator<Item=io::Result<u8>>,
+          T: de::Deserialize
+{
+    /// Returns an `Iterator` of decoded JSON values from an iterator over
+    /// `Iterator<Item=io::Result<u8>>`.
+    pub fn new(iter: Iter) -> StreamDeserializer<T, Iter> {
+        StreamDeserializer {
+            deser: Deserializer::new(iter),
+            _marker: PhantomData
+        }
+    }
+}
+
+impl <T, Iter> Iterator for StreamDeserializer<T, Iter>
+    where Iter: Iterator<Item=io::Result<u8>>,
+          T: de::Deserialize
+{
+    type Item = Result<T>;
+
+    fn next(&mut self) -> Option<Result<T>> {
+        // skip whitespaces, if any
+        // this helps with trailing whitespaces, since whitespaces between
+        // values are handled for us.
+        if let Err(e) = self.deser.parse_whitespace() {
+            return Some(Err(e))
+        };
+
+        match self.deser.eof() {
+            Ok(true) => None,
+            Ok(false) => match de::Deserialize::deserialize(&mut self.deser) {
+                Ok(v) => Some(Ok(v)),
+                Err(e) => Some(Err(e))
+            },
+            Err(e) => Some(Err(e))
+        }
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
 /// Decodes a json value from an iterator over an iterator
 /// `Iterator<Item=io::Result<u8>>`.
 pub fn from_iter<I, T>(iter: I) -> Result<T>
@@ -848,48 +900,3 @@ pub fn from_str<T>(s: &str) -> Result<T>
 {
     from_slice(s.as_bytes())
 }
-
-/// Iterator over parsed JSON values
-pub struct JSONStream<T, Iter>
-    where Iter: Iterator<Item=io::Result<u8>>,
-          T: de::Deserialize
-{
-    deser: Deserializer<Iter>,
-    _marker: PhantomData<T>,
-}
-
-/// Iterator over parsed JSON values
-impl <T, Iter> JSONStream<T, Iter>
-    where Iter:Iterator<Item=io::Result<u8>>,
-          T: de::Deserialize {
-    /// Returns Iterator of decoded JSON value from an iterator over
-    /// `Iterator<Item=io::Result<u8>>`.
-    pub fn new(i: Iter) -> JSONStream<T, Iter> {
-        JSONStream {
-            deser: Deserializer::new(i),
-            _marker: PhantomData
-        }
-    }
-}
-
-impl <T, Iter> Iterator for JSONStream<T, Iter>
-    where Iter:Iterator<Item=io::Result<u8>>,
-          T: de::Deserialize {
-    type Item = Result<T>;
-    fn next(&mut self) -> Option<Result<T>> {
-        // skip whitespaces, if any
-        // this helps with trailing whitespaces, since whitespaces between
-        // values are handled for us.
-        if let Err(e) = self.deser.parse_whitespace() {
-            return Some(Err(e))
-        };
-        match self.deser.eof() {
-            Ok(true) => None,
-            Ok(false) => match de::Deserialize::deserialize(&mut self.deser) {
-                Ok(v) => Some(Ok(v)),
-                Err(e) => Some(Err(e))
-            },
-            Err(e) => Some(Err(e))
-        }
-    }
-}

json/src/lib.rs

@@ -122,7 +122,7 @@ extern crate serde;
 
 pub use self::de::{
     Deserializer,
-    JSONStream,
+    StreamDeserializer,
     from_iter,
     from_reader,
     from_slice,

json_tests/tests/test_json.rs

@@ -11,8 +11,8 @@ use serde::bytes::{ByteBuf, Bytes};
 
 use serde_json::{
     self,
+    StreamDeserializer,
     Value,
-    JSONStream,
     from_str,
     from_value,
     to_value,
@@ -1416,8 +1416,10 @@ fn test_byte_buf_de() {
 #[test]
 fn test_json_stream_newlines() {
     let stream = "{\"x\":39} {\"x\":40}{\"x\":41}\n{\"x\":42}".to_string();
-    let mut parsed:JSONStream<Value, _> = JSONStream::new(
-        stream.as_bytes().iter().map(|byte| Ok(*byte)));
+    let mut parsed: StreamDeserializer<Value, _> = StreamDeserializer::new(
+        stream.as_bytes().iter().map(|byte| Ok(*byte))
+    );
+
     assert_eq!(parsed.next().unwrap().ok().unwrap().lookup("x").unwrap(),
                &Value::U64(39));
     assert_eq!(parsed.next().unwrap().ok().unwrap().lookup("x").unwrap(),
@@ -1432,8 +1434,10 @@ fn test_json_stream_newlines() {
 #[test]
 fn test_json_stream_trailing_whitespaces() {
     let stream = "{\"x\":42} \t\n".to_string();
-    let mut parsed:JSONStream<Value, _> = JSONStream::new(
-        stream.as_bytes().iter().map(|byte| Ok(*byte)));
+    let mut parsed: StreamDeserializer<Value, _> = StreamDeserializer::new(
+        stream.as_bytes().iter().map(|byte| Ok(*byte))
+    );
+
     assert_eq!(parsed.next().unwrap().ok().unwrap().lookup("x").unwrap(),
                &Value::U64(42));
     assert!(parsed.next().is_none());
@@ -1442,8 +1446,10 @@ fn test_json_stream_trailing_whitespaces() {
 #[test]
 fn test_json_stream_truncated() {
     let stream = "{\"x\":40}\n{\"x\":".to_string();
-    let mut parsed:JSONStream<Value, _> = JSONStream::new(
-        stream.as_bytes().iter().map(|byte| Ok(*byte)));
+    let mut parsed: StreamDeserializer<Value, _> = StreamDeserializer::new(
+        stream.as_bytes().iter().map(|byte| Ok(*byte))
+    );
+
     assert_eq!(parsed.next().unwrap().ok().unwrap().lookup("x").unwrap(),
                &Value::U64(40));
     assert!(parsed.next().unwrap().is_err());
@@ -1453,7 +1459,9 @@ fn test_json_stream_truncated() {
 #[test]
 fn test_json_stream_empty() {
     let stream = "".to_string();
-    let mut parsed:JSONStream<Value, _> = JSONStream::new(
-        stream.as_bytes().iter().map(|byte| Ok(*byte)));
+    let mut parsed: StreamDeserializer<Value, _> = StreamDeserializer::new(
+        stream.as_bytes().iter().map(|byte| Ok(*byte))
+    );
+
     assert!(parsed.next().is_none());
 }