SerdeのDeserializerを実装する(Part2 JSON編)

use serde::de;
use std::fmt::Display;

#[derive(Debug, thiserror::Error)]
pub enum Error {
    #[error("{0}")]
    Message(String),
}

impl de::Error for Error {
    fn custom<T: Display>(msg: T) -> Self {
        Error::Message(msg.to_string())
    }
}

pub type Result<T> = std::result::Result<T, Error>;

mod error;

use serde::{
    de::{self, Visitor},
    forward_to_deserialize_any, Deserialize,
};

use error::DeserializeError;

pub struct JsonDeserializer<'de> {
    input: &'de str,
}

impl<'de, 'a> de::Deserializer<'de> for &'a mut JsonDeserializer<'de> {
    type Error = DeserializeError;

    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: Visitor<'de>,
    {
        Err(DeserializeError::Message("Unsupported type".to_string()))
    }

    forward_to_deserialize_any! {
        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
        bytes byte_buf option unit unit_struct newtype_struct seq tuple
        tuple_struct map struct enum identifier ignored_any
    }
}

pub fn from_str<'de, T: Deserialize<'de>>(input: &'de str) -> Result<T, DeserializeError> {
    let mut deserializer = JsonDeserializer { input };
    T::deserialize(&mut deserializer)
}

impl<'de> Deserializer<'de> {
    // Look at the first character in the input without consuming it.
    fn peek_char(&mut self) -> Result<char> {
        self.input.chars().next().ok_or(Error::Eof)
    }

    // Consume the first character in the input.
    fn next_char(&mut self) -> Result<char> {
        let ch = self.peek_char()?;
        self.input = &self.input[ch.len_utf8()..];
        Ok(ch)
    }
}

macro_rules! err {
    ($msg:expr) => {
        Error::Message($msg.to_string())
    };
}

impl<'de, 'a> de::Deserializer<'de> for &'a mut JsonDeserializer<'de> {
    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        while let ' ' | '\n' | '\t' | '\r' = self.peek_char()? {
            self.next_char()?;
        }

        match self.peek_char()? {
            'n' => visitor.visit_unit(), // null (Unit)
            't' => {
                for c in ['t', 'r', 'u', 'e'] {
                    if c != self.next_char()? {
                        return Err(err!("Expected true"));
                    }
                }
                visitor.visit_bool(true)
            }
            'f' => {
                for c in ['f', 'a', 'l', 's', 'e'] {
                    if c != self.next_char()? {
                        return Err(err!("Expected false"));
                    }
                }
                visitor.visit_bool(false)
            }
            // 後で実装します
            '"' => visitor.visit_borrowed_str(self.parse_string()?), // string
            '0'..='9' => visitor.visit_u64(self.parse_u64()),        // unsigned number
            '-' => visitor.visit_u64(self.parse_u64()),              // signed number
            '[' => self.parse_deserialize_seq(visitor),
            '{' => self.parse_deserialize_map(visitor),
            _ => Err(err!("Unexpected character")),
        }
    }
	...
}

impl<'de> JsonDeserializer<'de> {
    pub fn parse_u64(&mut self) -> u64 {
        let mut num = 0;
        while let Ok('0'..='9') = self.peek_char() {
            num *= 10;
            num += self.next_char().unwrap().to_digit(10).unwrap() as u64;
        }
        num
    }
    pub fn parse_i64(&mut self) -> Result<i64> {
        let mut num: i64 = 0;
        self.next_char().unwrap();
        if let Ok('0'..='9') = self.peek_char() {
            return Err(err!("Expected number"));
        }
        while let Ok('0'..='9') = self.peek_char() {
            num *= 10;
            num += self.next_char().unwrap().to_digit(10).unwrap() as i64;
        }
        Ok(num)
    }
}

    pub fn parse_string(&mut self) -> Result<&'de str> {
        if self.next_char()? != '"' {
            return Err(err!("Expected string"));
        }
        match self.input.find('"') {
            Some(len) => {
                let s = &self.input[..len];
                self.input = &self.input[len + 1..];
                Ok(s)
            }
            None => Err(err!("Unexpected EOF")),
        }
    }

pub struct CommaSeparated<'a, 'de: 'a> {
    de: &'a mut JsonDeserializer<'de>,
    first: bool,
}

impl<'a, 'de> CommaSeparated<'a, 'de> {
    fn new(de: &'a mut JsonDeserializer<'de>) -> Self {
        CommaSeparated { de, first: true }
    }
}

// `SeqAccess` is provided to the `Visitor` to give it the ability to iterate
// through elements of the sequence.
impl<'de, 'a> SeqAccess<'de> for CommaSeparated<'a, 'de> {
    type Error = Error;

    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
    where
        T: DeserializeSeed<'de>,
    {
        // Check if there are no more elements.
        if self.de.peek_char()? == ']' {
            return Ok(None);
        }
        // Comma is required before every element except the first.
        if !self.first && self.de.next_char()? != ',' {
            return Err(err!("Expected array comma"));
        }
        self.first = false;
        // Deserialize an array element.
        seed.deserialize(&mut *self.de).map(Some)
    }
}

impl<'de> JsonDeserializer<'de> {
    pub fn parse_deserialize_seq<V>(&mut self, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        // Parse the opening bracket of the sequence.
        if self.next_char()? == '[' {
            // Give the visitor access to each element of the sequence.
            let value = visitor.visit_seq(CommaSeparated::new(self))?;
            // Parse the closing bracket of the sequence.
            if self.next_char()? == ']' {
                Ok(value)
            } else {
                Err(err!("Expected array closing bracket"))
            }
        } else {
            Err(err!("Expected array opening bracket"))
        }
    }
}

impl<'de, 'a> MapAccess<'de> for CommaSeparated<'a, 'de> {
    type Error = Error;

    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
    where
        K: DeserializeSeed<'de>,
    {
        // Check if there are no more entries.
        if self.de.peek_char()? == '}' {
            return Ok(None);
        }
        // Comma is required before every entry except the first.
        if !self.first && self.de.next_char()? != ',' {
            return Err(err!("Expected map comma"));
        }
        self.first = false;
        // Deserialize a map key.
        seed.deserialize(&mut *self.de).map(Some)
    }

    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
    where
        V: DeserializeSeed<'de>,
    {
        // It doesn't make a difference whether the colon is parsed at the end
        // of `next_key_seed` or at the beginning of `next_value_seed`. In this
        // case the code is a bit simpler having it here.
        if self.de.next_char()? != ':' {
            return Err(err!("Expected map colon"));
        }
        // Deserialize a map value.
        seed.deserialize(&mut *self.de)
    }
}

impl<'de> JsonDeserializer<'de> {
    pub fn parse_deserialize_map<V>(&mut self, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        // Parse the opening brace of the map.
        if self.next_char()? == '{' {
            // Give the visitor access to each entry of the map.
            let value = visitor.visit_map(CommaSeparated::new(self))?;
            // Parse the closing brace of the map.
            if self.next_char()? == '}' {
                Ok(value)
            } else {
                Err(err!("Expected map closing brace"))
            }
        } else {
            Err(err!("Expected map opening brace"))
        }
    }
}

use serde::Deserialize;
use serde_deserializer_2::from_str;

fn main() {
    #[derive(Deserialize, PartialEq, Debug)]
    struct Test {
        key: String,
        array: Vec<u64>,
    }

    let j = r#"{"key":"value","array":[1,2,3]}"#;

    let expected = Test {
        key: "value".to_string(),
        array: vec![1, 2, 3],
    };
    assert_eq!(expected, from_str(j).unwrap());
}

$ cargo run
   Compiling serde-deserializer-2 v0.1.0 (/home/nazo/dev/playground/serde-deserializer-2)
    Finished dev [unoptimized + debuginfo] target(s) in 0.15s
     Running `target/debug/serde-deserializer-2`