From b78ef63bdf72946ca85b3b37a80c2202504a9b1a Mon Sep 17 00:00:00 2001 From: Edward Shen Date: Wed, 3 Mar 2021 18:14:57 -0500 Subject: [PATCH] remove serde code for now --- Cargo.toml | 2 - src/de.rs | 410 --------------------------------------------------- src/error.rs | 45 ------ src/ser.rs | 184 ----------------------- 4 files changed, 641 deletions(-) delete mode 100644 src/de.rs delete mode 100644 src/error.rs delete mode 100644 src/ser.rs diff --git a/Cargo.toml b/Cargo.toml index 8d7de63..3b8378d 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -10,8 +10,6 @@ keywords = ["git-config", "git", "config", "gitoxide"] categories = ["config", "parser-implementations"] exclude = ["fuzz/**/*", ".vscode/**/*", "benches/**/*"] -# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html - [features] # serde = ["serde_crate"] diff --git a/src/de.rs b/src/de.rs deleted file mode 100644 index 9b85af0..0000000 --- a/src/de.rs +++ /dev/null @@ -1,410 +0,0 @@ -use std::ops::{AddAssign, MulAssign, Neg}; - -use crate::values::Boolean; -use crate::{ - error::{Error, Result}, - values::PeekParse, -}; -use serde::de::{ - self, DeserializeSeed, EnumAccess, IntoDeserializer, MapAccess, SeqAccess, VariantAccess, - Visitor, -}; - -use serde::Deserialize; - -pub struct Deserializer<'de> { - // This string starts with the input data and characters are truncated off - // the beginning as data is parsed. - input: &'de str, -} - -impl<'de> Deserializer<'de> { - // By convention, `Deserializer` constructors are named like `from_xyz`. - // That way basic use cases are satisfied by something like - // `serde_json::from_str(...)` while advanced use cases that require a - // deserializer can make one with `serde_json::Deserializer::from_str(...)`. - pub fn from_str(input: &'de str) -> Self { - Deserializer { input } - } -} - -// By convention, the public API of a Serde deserializer is one or more -// `from_xyz` methods such as `from_str`, `from_bytes`, or `from_reader` -// depending on what Rust types the deserializer is able to consume as input. -// -// This basic deserializer supports only `from_str`. -pub fn from_str<'a, T>(s: &'a str) -> Result -where - T: Deserialize<'a>, -{ - let mut deserializer = Deserializer::from_str(s); - let t = T::deserialize(&mut deserializer)?; - if deserializer.input.is_empty() { - Ok(t) - } else { - todo!() - } -} - -impl<'de> Deserializer<'de> { - fn peek(&mut self) -> Result { - self.input.chars().next().ok_or(Error::Eof) - } - - fn next(&mut self) -> Result { - let ch = self.peek()?; - self.input = &self.input[ch.len_utf8()..]; - Ok(ch) - } - - fn parse_bool(&mut self) -> Result { - let (value, size) = Boolean::peek_parse(self.input)?; - self.input = &self.input[size..]; - Ok(value) - } - - fn parse_unsigned(&mut self) -> Result { - self.parse_int(true) - } - - fn parse_signed(&mut self) -> Result { - self.parse_int(false) - } - - fn parse_int(&mut self, positive_only: bool) -> Result { - self.consume_whitespace()?; - - match self.next()? { - c @ '0'..='9' => { - let mut significand = (c as u8 - b'0') as u64; - - loop { - match self.peek()? { - c @ '0'..='9' => { - let digit = (c as u8 - b'0') as u64; - - if significand.wrapping_mul(10).wrapping_add(digit) < u64::MAX {} - - let _ = self.next(); - significand = significand * 10 + digit; - } - _ => { - // return self.parse_number(positive, significand); - todo!() - } - } - } - } - _ => Err(Error::InvalidInteger), - } - } - - fn consume_whitespace(&mut self) -> Result<()> { - loop { - match self.peek()? { - ' ' | '\n' | '\t' | '\r' => { - let _ = self.next(); - } - _ => { - return Ok(()); - } - } - } - } -} - -impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> { - type Error = Error; - - fn deserialize_any(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - match self.peek()? { - _ => todo!(), - } - } - - fn deserialize_bool(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - visitor.visit_bool(self.parse_bool()?) - } - - fn deserialize_i8(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - visitor.visit_i8(self.parse_signed()?) - } - - fn deserialize_i16(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - visitor.visit_i16(self.parse_signed()?) - } - - fn deserialize_i32(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - visitor.visit_i32(self.parse_signed()?) - } - - fn deserialize_i64(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - visitor.visit_i64(self.parse_signed()?) - } - - fn deserialize_u8(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - visitor.visit_u8(self.parse_unsigned()?) - } - - fn deserialize_u16(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - visitor.visit_u16(self.parse_unsigned()?) - } - - fn deserialize_u32(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - visitor.visit_u32(self.parse_unsigned()?) - } - - fn deserialize_u64(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - visitor.visit_u64(self.parse_unsigned()?) - } - - fn deserialize_f32(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.deserialize_f64(visitor) - } - - fn deserialize_f64(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - unimplemented!("Cannot deserialize into a float value! Use a integer variant instead.") - } - - fn deserialize_char(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.deserialize_str(visitor) - } - - fn deserialize_str(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - todo!() - } - - fn deserialize_string(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.deserialize_str(visitor) - } - - fn deserialize_bytes(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - todo!() - } - - fn deserialize_byte_buf(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - todo!() - } - - fn deserialize_option(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - todo!() - } - - fn deserialize_unit(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - visitor.visit_unit() - } - - fn deserialize_unit_struct(self, _name: &'static str, visitor: V) -> Result - where - V: Visitor<'de>, - { - visitor.visit_unit() - } - - fn deserialize_newtype_struct(self, name: &'static str, visitor: V) -> Result - where - V: Visitor<'de>, - { - visitor.visit_newtype_struct(self) - } - - fn deserialize_seq(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - todo!() - } - - fn deserialize_tuple(self, _len: usize, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.deserialize_seq(visitor) - } - - fn deserialize_tuple_struct( - self, - _name: &'static str, - _len: usize, - visitor: V, - ) -> Result - where - V: Visitor<'de>, - { - self.deserialize_seq(visitor) - } - - fn deserialize_map(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.consume_whitespace()?; - Ok(visitor.visit_map(self)?) - } - - fn deserialize_struct( - self, - _name: &'static str, - _fields: &'static [&'static str], - visitor: V, - ) -> Result - where - V: Visitor<'de>, - { - visitor.visit_map(self) - } - - fn deserialize_enum( - self, - name: &'static str, - variants: &'static [&'static str], - visitor: V, - ) -> Result - where - V: Visitor<'de>, - { - todo!() - } - - fn deserialize_identifier(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - todo!() - } - - fn deserialize_ignored_any(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - todo!() - } -} - -impl<'de, 'a> MapAccess<'de> for Deserializer<'de> { - type Error = Error; - - fn next_key_seed(&mut self, seed: K) -> Result> - where - K: DeserializeSeed<'de>, - { - // A map section is ended when another section begins or we hit EOL. - // Therefore, we only check if a next section begins or in the case of - // EOL indicate that we're done. - if self.peek().unwrap_or('[') == '[' { - return Ok(None); - } - - seed.deserialize(self).map(Some) - } - - fn next_value_seed(&mut self, seed: V) -> Result - where - V: DeserializeSeed<'de>, - { - seed.deserialize(self) - } -} - -#[cfg(test)] -mod deserialize { - use crate::from_str; - use serde_derive::Deserialize; - - #[test] - fn unit() { - #[derive(Deserialize, PartialEq, Debug)] - struct Test; - assert_eq!(Test, from_str("").unwrap()); - assert_eq!((), from_str("").unwrap()); - } - - #[test] - #[should_panic] - fn float() { - from_str::("").unwrap(); - } - - #[test] - fn basic() { - #[derive(Deserialize, PartialEq, Debug)] - struct Config { - user: User, - } - - #[derive(Deserialize, PartialEq, Debug)] - struct User { - email: String, - name: String, - } - - let expected = Config { - user: User { - email: "code@eddie.sh".to_string(), - name: "Edward Shen".to_string(), - }, - }; - - assert_eq!( - expected, - from_str("[user]\nemail=code@eddie.sh\nname=Edward Shen\n").unwrap() - ); - } -} diff --git a/src/error.rs b/src/error.rs deleted file mode 100644 index 6ffd9b1..0000000 --- a/src/error.rs +++ /dev/null @@ -1,45 +0,0 @@ -use std::fmt::{self, Display}; - -#[cfg(feature = "serde")] -use serde::{de, ser}; - -pub type Result = std::result::Result; - -// This is a bare-bones implementation. A real library would provide additional -// information in its error type, for example the line and column at which the -// error occurred, the byte offset into the input, or the current key being -// processed. -#[derive(Clone, Debug, PartialEq)] -pub enum Error { - Message(String), - Eof, - InvalidInteger, - InvalidBoolean(String), -} - -#[cfg(feature = "serde")] -impl ser::Error for Error { - fn custom(msg: T) -> Self { - Error::Message(msg.to_string()) - } -} - -#[cfg(feature = "serde")] -impl de::Error for Error { - fn custom(msg: T) -> Self { - Error::Message(msg.to_string()) - } -} - -impl Display for Error { - fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - match self { - Error::Message(msg) => formatter.write_str(msg), - Error::Eof => formatter.write_str("unexpected end of input"), - Error::InvalidInteger => formatter.write_str("invalid integer given"), - Error::InvalidBoolean(_) => formatter.write_str("invalid boolean given"), - } - } -} - -impl std::error::Error for Error {} diff --git a/src/ser.rs b/src/ser.rs deleted file mode 100644 index 8aeeca9..0000000 --- a/src/ser.rs +++ /dev/null @@ -1,184 +0,0 @@ -use crate::error::{Error, Result}; -use ser::SerializeSeq; -use serde::{de::MapAccess, ser, Serialize}; - -pub struct Serializer { - output: String, -} - -pub fn to_string(value: &T) -> Result -where - T: Serialize, -{ - let mut serializer = Serializer { - output: String::new(), - }; - value.serialize(&mut serializer)?; - Ok(serializer.output) -} - -impl<'a> ser::Serializer for &'a mut Serializer { - type Ok = (); - type Error = Error; - type SerializeSeq = Self; - type SerializeTuple = Self; - type SerializeTupleStruct = Self; - type SerializeTupleVariant = Self; - type SerializeMap = Self; - type SerializeStruct = Self; - type SerializeStructVariant = Self; - - fn serialize_bool(self, v: bool) -> Result { - self.output += if v { "true" } else { "false" }; - Ok(()) - } - - fn serialize_i8(self, v: i8) -> Result { - self.serialize_i64(i64::from(v)) - } - - fn serialize_i16(self, v: i16) -> Result { - self.serialize_i64(i64::from(v)) - } - - fn serialize_i32(self, v: i32) -> Result { - self.serialize_i64(i64::from(v)) - } - - fn serialize_i64(self, v: i64) -> Result { - self.output += &v.to_string(); - Ok(()) - } - - fn serialize_u8(self, v: u8) -> Result { - self.serialize_u64(u64::from(v)) - } - - fn serialize_u16(self, v: u16) -> Result { - self.serialize_u64(u64::from(v)) - } - - fn serialize_u32(self, v: u32) -> Result { - self.serialize_u64(u64::from(v)) - } - - fn serialize_u64(self, v: u64) -> Result { - self.output += &v.to_string(); - Ok(()) - } - - fn serialize_f32(self, v: f32) -> Result { - self.serialize_f64(f64::from(v)) - } - - fn serialize_f64(self, v: f64) -> Result { - self.output += &v.to_string(); - Ok(()) - } - - fn serialize_char(self, v: char) -> Result { - self.output += &v.to_string(); - Ok(()) - } - - fn serialize_str(self, v: &str) -> Result { - self.output += v; - Ok(()) - } - - fn serialize_bytes(self, v: &[u8]) -> Result { - todo!() - } - - fn serialize_none(self) -> Result { - todo!() - } - - fn serialize_some(self, value: &T) -> Result - where - T: Serialize, - { - todo!() - } - - fn serialize_unit(self) -> Result { - todo!() - } - - fn serialize_unit_struct(self, name: &'static str) -> Result { - todo!() - } - - fn serialize_unit_variant( - self, - name: &'static str, - variant_index: u32, - variant: &'static str, - ) -> Result { - todo!() - } - - fn serialize_newtype_struct(self, name: &'static str, value: &T) -> Result - where - T: Serialize, - { - todo!() - } - - fn serialize_newtype_variant( - self, - name: &'static str, - variant_index: u32, - variant: &'static str, - value: &T, - ) -> Result - where - T: Serialize, - { - todo!() - } - - fn serialize_seq(self, len: Option) -> Result { - todo!() - } - - fn serialize_tuple(self, len: usize) -> Result { - self.serialize_seq(Some(len)) - } - - fn serialize_tuple_struct( - self, - name: &'static str, - len: usize, - ) -> Result { - self.serialize_seq(Some(len)) - } - - fn serialize_tuple_variant( - self, - name: &'static str, - variant_index: u32, - variant: &'static str, - len: usize, - ) -> Result { - todo!() - } - - fn serialize_map(self, len: Option) -> Result { - todo!() - } - - fn serialize_struct(self, name: &'static str, len: usize) -> Result { - todo!() - } - - fn serialize_struct_variant( - self, - name: &'static str, - variant_index: u32, - variant: &'static str, - len: usize, - ) -> Result { - todo!() - } -}