Replace serde1 with serde2!

Closes #26!

.gitignore

@@ -1,3 +1,2 @@
 /target/
 /Cargo.lock
-/serde2/Cargo.lock

Cargo.toml

@@ -1,15 +1,13 @@
 [package]
 name = "serde"
-version = "0.1.0"
+version = "0.2.0"
 authors = ["Erick Tryzelaar <[email protected]>"]
-license = "MIT/Apache-2.0"
 
 [lib]
 name = "serde"
-path = "src/lib.rs"
 
 [dependencies]
 rustc-serialize = "*"
 
-[dependencies.serde_macros]
+[dev-dependencies.serde_macros]
 path = "serde_macros/"

benches/bench_enum.rs

@@ -1,4 +1,4 @@
-#![feature(plugin, test)]
+#![feature(custom_derive, plugin, test)]
 #![plugin(serde_macros)]
 
 extern crate serde;
@@ -26,9 +26,16 @@ enum Animal {
 
 #[derive(Debug)]
 pub enum Error {
- EndOfStream,
+ EndOfStreamError,
  SyntaxError,
- OtherError(String),
+}
+
+impl serde::de::Error for Error {
+ fn syntax_error() -> Error { Error::SyntaxError }
+
+ fn end_of_stream_error() -> Error { Error::EndOfStreamError }
+
+ fn missing_field_error(_: &'static str) -> Error { Error::SyntaxError }
 }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -38,7 +45,6 @@ mod decoder {
 
  use super::{Animal, Error};
  use super::Animal::{Dog, Frog};
- use super::Error::{SyntaxError, OtherError};
  use self::State::{AnimalState, IsizeState, StringState};
 
  enum State {
@@ -64,37 +70,35 @@ mod decoder {
  impl Decoder for AnimalDecoder {
  type Error = Error;
 
- fn error(&mut self, msg: &str) -> Error {
- OtherError(msg.to_string())
- }
+ fn error(&mut self, _: &str) -> Error { Error::SyntaxError }
 
  // Primitive types:
- fn read_nil(&mut self) -> Result<(), Error> { Err(SyntaxError) }
- fn read_usize(&mut self) -> Result<usize, Error> { Err(SyntaxError) }
- fn read_u64(&mut self) -> Result<u64, Error> { Err(SyntaxError) }
- fn read_u32(&mut self) -> Result<u32, Error> { Err(SyntaxError) }
- fn read_u16(&mut self) -> Result<u16, Error> { Err(SyntaxError) }
- fn read_u8(&mut self) -> Result<u8, Error> { Err(SyntaxError) }
+ fn read_nil(&mut self) -> Result<(), Error> { Err(Error::SyntaxError) }
+ fn read_usize(&mut self) -> Result<usize, Error> { Err(Error::SyntaxError) }
+ fn read_u64(&mut self) -> Result<u64, Error> { Err(Error::SyntaxError) }
+ fn read_u32(&mut self) -> Result<u32, Error> { Err(Error::SyntaxError) }
+ fn read_u16(&mut self) -> Result<u16, Error> { Err(Error::SyntaxError) }
+ fn read_u8(&mut self) -> Result<u8, Error> { Err(Error::SyntaxError) }
  #[inline]
  fn read_isize(&mut self) -> Result<isize, Error> {
  match self.stack.pop() {
  Some(IsizeState(x)) => Ok(x),
- _ => Err(SyntaxError),
+ _ => Err(Error::SyntaxError),
  }
  }
- fn read_i64(&mut self) -> Result<i64, Error> { Err(SyntaxError) }
- fn read_i32(&mut self) -> Result<i32, Error> { Err(SyntaxError) }
- fn read_i16(&mut self) -> Result<i16, Error> { Err(SyntaxError) }
- fn read_i8(&mut self) -> Result<i8, Error> { Err(SyntaxError) }
- fn read_bool(&mut self) -> Result<bool, Error> { Err(SyntaxError) }
- fn read_f64(&mut self) -> Result<f64, Error> { Err(SyntaxError) }
- fn read_f32(&mut self) -> Result<f32, Error> { Err(SyntaxError) }
- fn read_char(&mut self) -> Result<char, Error> { Err(SyntaxError) }
+ fn read_i64(&mut self) -> Result<i64, Error> { Err(Error::SyntaxError) }
+ fn read_i32(&mut self) -> Result<i32, Error> { Err(Error::SyntaxError) }
+ fn read_i16(&mut self) -> Result<i16, Error> { Err(Error::SyntaxError) }
+ fn read_i8(&mut self) -> Result<i8, Error> { Err(Error::SyntaxError) }
+ fn read_bool(&mut self) -> Result<bool, Error> { Err(Error::SyntaxError) }
+ fn read_f64(&mut self) -> Result<f64, Error> { Err(Error::SyntaxError) }
+ fn read_f32(&mut self) -> Result<f32, Error> { Err(Error::SyntaxError) }
+ fn read_char(&mut self) -> Result<char, Error> { Err(Error::SyntaxError) }
  #[inline]
  fn read_str(&mut self) -> Result<String, Error> {
  match self.stack.pop() {
  Some(StringState(x)) => Ok(x),
- _ => Err(SyntaxError),
+ _ => Err(Error::SyntaxError),
  }
  }
 
@@ -109,10 +113,10 @@ mod decoder {
  if name == "Animal" {
  f(self)
  } else {
- Err(SyntaxError)
+ Err(Error::SyntaxError)
  }
  }
- _ => Err(SyntaxError)
+ _ => Err(Error::SyntaxError)
  }
  }
 
@@ -127,12 +131,12 @@ mod decoder {
  self.stack.push(StringState(x0));
  "Frog"
  }
- _ => { return Err(SyntaxError); }
+ _ => { return Err(Error::SyntaxError); }
  };
 
  let idx = match names.iter().position(|n| *n == name) {
  Some(idx) => idx,
- None => { return Err(SyntaxError); }
+ None => { return Err(Error::SyntaxError); }
  };
 
  f(self, idx)
@@ -197,7 +201,7 @@ mod decoder {
  fn read_option<T, F>(&mut self, _f: F) -> Result<T, Error> where
  F: FnOnce(&mut AnimalDecoder, bool) -> Result<T, Error>,
  {
- Err(SyntaxError)
+ Err(Error::SyntaxError)
  }
 
  #[inline]
@@ -217,19 +221,19 @@ mod decoder {
  fn read_map<T, F>(&mut self, _f: F) -> Result<T, Error> where
  F: FnOnce(&mut AnimalDecoder, usize) -> Result<T, Error>,
  {
- Err(SyntaxError)
+ Err(Error::SyntaxError)
  }
 
  fn read_map_elt_key<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
  F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
  {
- Err(SyntaxError)
+ Err(Error::SyntaxError)
  }
 
  fn read_map_elt_val<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
  F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
  {
- Err(SyntaxError)
+ Err(Error::SyntaxError)
  }
  }
 }
@@ -238,18 +242,14 @@ mod decoder {
 
 mod deserializer {
  use super::{Animal, Error};
- use super::Animal::{Dog, Frog};
- use super::Error::{EndOfStream, SyntaxError};
- use self::State::{AnimalState, IsizeState, StringState, EndState};
 
  use serde::de;
 
  enum State {
  AnimalState(Animal),
  IsizeState(isize),
  StringState(String),
- EndState,
-
+ UnitState,
  }
 
  pub struct AnimalDeserializer {
@@ -260,67 +260,108 @@ mod deserializer {
  #[inline]
  pub fn new(animal: Animal) -> AnimalDeserializer {
  AnimalDeserializer {
- stack: vec!(AnimalState(animal)),
+ stack: vec!(State::AnimalState(animal)),
  }
  }
  }
 
- impl Iterator for AnimalDeserializer {
- type Item = Result<de::Token, Error>;
+ impl de::Deserializer for AnimalDeserializer {
+ type Error = Error;
 
  #[inline]
- fn next(&mut self) -> Option<Result<de::Token, Error>> {
+ fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+ where V: de::Visitor,
+ {
  match self.stack.pop() {
- Some(AnimalState(Dog)) => {
- self.stack.push(EndState);
- Some(Ok(de::Token::EnumStart("Animal", "Dog", 0)))
+ Some(State::AnimalState(Animal::Dog)) => {
+ self.stack.push(State::UnitState);
+ visitor.visit_enum("Animal", "Dog", DogVisitor {
+ de: self,
+ })
  }
- Some(AnimalState(Frog(x0, x1))) => {
- self.stack.push(EndState);
- self.stack.push(IsizeState(x1));
- self.stack.push(StringState(x0));
- Some(Ok(de::Token::EnumStart("Animal", "Frog", 2)))
+ Some(State::AnimalState(Animal::Frog(x0, x1))) => {
+ self.stack.push(State::IsizeState(x1));
+ self.stack.push(State::StringState(x0));
+ visitor.visit_enum("Animal", "Frog", FrogVisitor {
+ de: self,
+ state: 0,
+ })
+ }
+ Some(State::IsizeState(value)) => {
+ visitor.visit_isize(value)
  }
- Some(IsizeState(x)) => {
- Some(Ok(de::Token::Isize(x)))
+ Some(State::StringState(value)) => {
+ visitor.visit_string(value)
  }
- Some(StringState(x)) => {
- Some(Ok(de::Token::String(x)))
+ Some(State::UnitState) => {
+ visitor.visit_unit()
  }
- Some(EndState) => {
- Some(Ok(de::Token::End))
+ None => {
+ Err(Error::EndOfStreamError)
  }
- None => None,
  }
  }
  }
 
- impl de::Deserializer<Error> for AnimalDeserializer {
- #[inline]
- fn end_of_stream_error(&mut self) -> Error {
- EndOfStream
+ struct DogVisitor<'a> {
+ de: &'a mut AnimalDeserializer,
+ }
+
+ impl<'a> de::EnumVisitor for DogVisitor<'a> {
+ type Error = Error;
+
+ fn visit_unit(&mut self) -> Result<(), Error> {
+ de::Deserialize::deserialize(self.de)
  }
+ }
 
- #[inline]
- fn syntax_error(&mut self, _token: de::Token, _expected: &[de::TokenKind]) -> Error {
- SyntaxError
+ struct FrogVisitor<'a> {
+ de: &'a mut AnimalDeserializer,
+ state: usize,
+ }
+
+ impl<'a> de::EnumVisitor for FrogVisitor<'a> {
+ type Error = Error;
+
+ fn visit_seq<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+ where V: de::EnumSeqVisitor,
+ {
+ visitor.visit(self)
  }
+ }
 
- #[inline]
- fn unexpected_name_error(&mut self, _token: de::Token) -> Error {
- SyntaxError
+ impl<'a> de::SeqVisitor for FrogVisitor<'a> {
+ type Error = Error;
+
+ fn visit<T>(&mut self) -> Result<Option<T>, Error>
+ where T: de::Deserialize,
+ {
+ match self.state {
+ 0 => {
+ self.state += 1;
+ Ok(Some(try!(de::Deserialize::deserialize(self.de))))
+ }
+ 1 => {
+ self.state += 1;
+ Ok(Some(try!(de::Deserialize::deserialize(self.de))))
+ }
+ _ => {
+ Ok(None)
+ }
+ }
  }
 
- #[inline]
- fn conversion_error(&mut self, _token: de::Token) -> Error {
- SyntaxError
+ fn end(&mut self) -> Result<(), Error> {
+ if self.state == 2 {
+ Ok(())
+ } else {
+ Err(Error::SyntaxError)
+ }
  }
 
- #[inline]
- fn missing_field<
- T: de::Deserialize<AnimalDeserializer, Error>
- >(&mut self, _field: &'static str) -> Result<T, Error> {
- Err(SyntaxError)
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ let len = 2 - self.state;
+ (len, Some(len))
  }
  }
 }