From 4910e60b1a7aba1cf4bedcc9cff3490cbf6286bc Mon Sep 17 00:00:00 2001 From: Ed Page Date: Fri, 3 Sep 2021 12:07:25 -0500 Subject: [PATCH] fix!: Rename `Encoded` to `Decoded` --- CHANGELOG.md | 4 + crates/harness/src/lib.rs | 4 +- src/decoded.rs | 389 ++++++++++++++++++++++++++++++++++++++ src/encoded.rs | 369 ------------------------------------ src/lib.rs | 22 +-- src/verify.rs | 10 +- tests/decoded.rs | 6 + tests/encoded.rs | 2 +- 8 files changed, 408 insertions(+), 398 deletions(-) create mode 100644 src/decoded.rs delete mode 100644 src/encoded.rs create mode 100644 tests/decoded.rs diff --git a/CHANGELOG.md b/CHANGELOG.md index d87e45a..c01479d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/). ## [Unreleased] - ReleaseDate +#### Breaking Changes + +- Fixed the naming of `Encoded` to `Decoded` + ## [0.2.5] - 2021-08-24 - Improve panic message diff --git a/crates/harness/src/lib.rs b/crates/harness/src/lib.rs index 389d146..0ff9983 100644 --- a/crates/harness/src/lib.rs +++ b/crates/harness/src/lib.rs @@ -1,7 +1,7 @@ use std::io::Write; -pub use toml_test::encoded::Encoded; -pub use toml_test::encoded::EncodedValue; +pub use toml_test::decoded::Decoded; +pub use toml_test::decoded::DecodedValue; pub use toml_test::verify::Decoder; pub use toml_test::verify::Encoder; pub use toml_test::Error; diff --git a/src/decoded.rs b/src/decoded.rs new file mode 100644 index 0000000..3ebef6c --- /dev/null +++ b/src/decoded.rs @@ -0,0 +1,389 @@ +use std::io::Read; +use std::io::Write; + +#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)] +#[serde(untagged)] +pub enum Decoded { + Value(DecodedValue), + Table(std::collections::HashMap), + Array(Vec), +} + +impl Decoded { + pub fn from_slice(v: &[u8]) -> Result { + serde_json::from_slice(v).map_err(crate::Error::new) + } + + pub fn to_string_pretty(&self) -> Result { + serde_json::to_string_pretty(self).map_err(crate::Error::new) + } + + /// External parser helper for [verify] + pub fn from_stdin() -> Result { + let mut buf = Vec::new(); + std::io::stdin() + .read_to_end(&mut buf) + .map_err(crate::Error::new)?; + Self::from_slice(&buf) + } + + /// External parser helper for [verify] + pub fn into_stdout(&self) -> Result<(), crate::Error> { + let s = self.to_string_pretty()?; + std::io::stdout() + .write_all(s.as_bytes()) + .map_err(crate::Error::new) + } +} + +#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] +#[serde(rename_all = "kebab-case")] +#[serde(tag = "type", content = "value")] +pub enum DecodedValue { + String(String), + Integer(String), + Float(String), + Bool(String), + Datetime(String), + DatetimeLocal(String), + DateLocal(String), + TimeLocal(String), +} + +impl DecodedValue { + pub fn as_str(&self) -> &str { + match self { + DecodedValue::String(v) + | DecodedValue::Integer(v) + | DecodedValue::Float(v) + | DecodedValue::Bool(v) + | DecodedValue::Datetime(v) + | DecodedValue::DatetimeLocal(v) + | DecodedValue::DateLocal(v) + | DecodedValue::TimeLocal(v) => v.as_str(), + } + } +} + +impl<'a> From<&'a str> for DecodedValue { + fn from(other: &'a str) -> Self { + DecodedValue::String(other.to_owned()) + } +} + +impl<'a> From<&'a String> for DecodedValue { + fn from(other: &'a String) -> Self { + DecodedValue::String(other.clone()) + } +} + +impl From for DecodedValue { + fn from(other: String) -> Self { + DecodedValue::String(other) + } +} + +impl From for DecodedValue { + fn from(other: i64) -> Self { + DecodedValue::Integer(other.to_string()) + } +} + +impl From for DecodedValue { + fn from(other: f64) -> Self { + let s = if other.is_nan() { + "nan".to_owned() + } else if other.is_infinite() && other.is_sign_negative() { + "-inf".to_owned() + } else if other.is_infinite() && other.is_sign_positive() { + "inf".to_owned() + } else { + let s = format!("{:.15}", other); + let s = s.trim_end_matches('0'); + if s.ends_with('.') { + format!("{}0", s) + } else { + s.to_owned() + } + }; + DecodedValue::Float(s) + } +} + +impl From for DecodedValue { + fn from(other: bool) -> Self { + DecodedValue::Bool(other.to_string()) + } +} + +impl PartialEq for DecodedValue { + fn eq(&self, other: &Self) -> bool { + #[allow(clippy::if_same_then_else)] + match (self, other) { + (DecodedValue::String(s), DecodedValue::String(o)) => s == o, + (DecodedValue::Integer(s), DecodedValue::Integer(o)) => s == o, + (DecodedValue::Float(s), DecodedValue::Float(o)) => { + if s == "inf" && o == "+inf" { + true + } else if s == "+inf" && o == "inf" { + true + } else if s == "nan" && o == "nan" { + true + } else { + let s = s.parse::().unwrap(); + let o = o.parse::().unwrap(); + s == o + } + } + (DecodedValue::Bool(s), DecodedValue::Bool(o)) => s == o, + (DecodedValue::Datetime(s), DecodedValue::Datetime(o)) => { + parse_date_time(s) == parse_date_time(o) + } + (DecodedValue::DatetimeLocal(s), DecodedValue::DatetimeLocal(o)) => { + parse_date_time_local(s) == parse_date_time_local(o) + } + (DecodedValue::DateLocal(s), DecodedValue::DateLocal(o)) => { + parse_date_local(s) == parse_date_local(o) + } + (DecodedValue::TimeLocal(s), DecodedValue::TimeLocal(o)) => { + parse_time_local(s) == parse_time_local(o) + } + (_, _) => false, + } + } +} + +fn parse_date_time(s: &str) -> chrono::DateTime { + match normalize_datetime(s).parse() { + Ok(d) => d, + Err(err) => panic!("Failed to parse {:?}: {}", s, err), + } +} + +fn parse_date_time_local(s: &str) -> chrono::NaiveDateTime { + match normalize_datetime(s).parse() { + Ok(d) => d, + Err(err) => panic!("Failed to parse {:?}: {}", s, err), + } +} + +fn parse_date_local(s: &str) -> chrono::NaiveDate { + match s.parse() { + Ok(d) => d, + Err(err) => panic!("Failed to parse {:?}: {}", s, err), + } +} + +fn parse_time_local(s: &str) -> chrono::NaiveTime { + match s.parse() { + Ok(d) => d, + Err(err) => panic!("Failed to parse {:?}: {}", s, err), + } +} + +fn normalize_datetime(s: &str) -> String { + s.chars() + .map(|c| match c { + ' ' => 'T', + 't' => 'T', + 'z' => 'Z', + _ => c, + }) + .collect() +} + +impl Eq for DecodedValue {} + +#[cfg(test)] +mod test { + use super::*; + + #[test] + fn string_equality() { + assert_eq!(DecodedValue::from("foo"), DecodedValue::from("foo")); + assert_ne!(DecodedValue::from("foo"), DecodedValue::from("bar")); + assert_ne!(DecodedValue::from("42"), DecodedValue::from(42)); + assert_ne!(DecodedValue::from("true"), DecodedValue::from(true)); + } + + #[test] + fn integer_equality() { + assert_eq!(DecodedValue::from(42), DecodedValue::from(42)); + assert_ne!(DecodedValue::from(42), DecodedValue::from(21)); + assert_ne!(DecodedValue::from(42), DecodedValue::from("42")); + } + + #[test] + fn float_equality() { + assert_eq!(DecodedValue::from(42.0), DecodedValue::from(42.0)); + assert_ne!(DecodedValue::from(42.0), DecodedValue::from(21.0)); + assert_ne!(DecodedValue::from(42.0), DecodedValue::from("42.0")); + } + + #[test] + fn nan_equality() { + assert_eq!(DecodedValue::from(f64::NAN), DecodedValue::from(f64::NAN)); + assert_eq!( + DecodedValue::from(f64::NAN), + DecodedValue::Float("nan".to_owned()) + ); + assert_ne!(DecodedValue::from(f64::NAN), DecodedValue::from("nan")); + } + + #[test] + fn inf_equality() { + assert_eq!( + DecodedValue::from(f64::INFINITY), + DecodedValue::from(f64::INFINITY) + ); + assert_ne!( + DecodedValue::from(f64::INFINITY), + DecodedValue::from(f64::NEG_INFINITY) + ); + assert_eq!( + DecodedValue::from(f64::INFINITY), + DecodedValue::Float("inf".to_owned()) + ); + assert_eq!( + DecodedValue::from(f64::INFINITY), + DecodedValue::Float("+inf".to_owned()) + ); + assert_ne!(DecodedValue::from(f64::INFINITY), DecodedValue::from("inf")); + } + + #[test] + fn float_exp_equality() { + assert_eq!(DecodedValue::from(3.0e14), DecodedValue::from(3.0e14)); + assert_eq!( + DecodedValue::from(3.0e14), + DecodedValue::Float("3.0e14".to_owned()) + ); + } + + #[test] + fn float_binary_equality() { + #![allow(clippy::excessive_precision)] + + // These cases are equivalent, just wanting to call out how Rust, at times, encodes the + // number in a string. + assert_eq!( + DecodedValue::from(3141.5927), + DecodedValue::Float("3141.5927".to_owned()) + ); + assert_eq!( + DecodedValue::from(3141.59270000000015), + DecodedValue::Float("3141.5927".to_owned()) + ); + } + + #[test] + fn neg_inf_equality() { + assert_eq!( + DecodedValue::from(f64::NEG_INFINITY), + DecodedValue::from(f64::NEG_INFINITY) + ); + assert_ne!( + DecodedValue::from(f64::NEG_INFINITY), + DecodedValue::from(f64::INFINITY) + ); + assert_eq!( + DecodedValue::from(f64::NEG_INFINITY), + DecodedValue::Float("-inf".to_owned()) + ); + assert_ne!( + DecodedValue::from(f64::NEG_INFINITY), + DecodedValue::from("-inf") + ); + } + + #[test] + fn bool_equality() { + assert_eq!(DecodedValue::from(true), DecodedValue::from(true)); + assert_ne!(DecodedValue::from(true), DecodedValue::from(false)); + assert_ne!(DecodedValue::from(true), DecodedValue::from("true")); + } + + #[test] + fn datetime_equality() { + assert_eq!( + DecodedValue::Datetime("1987-07-05 17:45:00Z".to_owned()), + DecodedValue::Datetime("1987-07-05 17:45:00Z".to_owned()) + ); + assert_eq!( + DecodedValue::Datetime("1987-07-05T17:45:56.123456Z".to_owned()), + DecodedValue::Datetime("1987-07-05T17:45:56.123456Z".to_owned()), + ); + assert_ne!( + DecodedValue::Datetime("1987-07-05 17:45:00Z".to_owned()), + DecodedValue::Datetime("2000-07-05 17:45:00Z".to_owned()) + ); + assert_eq!( + DecodedValue::Datetime("1987-07-05t17:45:00z".to_owned()), + DecodedValue::Datetime("1987-07-05 17:45:00Z".to_owned()) + ); + assert_ne!( + DecodedValue::Datetime("1987-07-05 17:45:00Z".to_owned()), + DecodedValue::from("1987-07-05 17:45:00Z") + ); + } + + #[test] + fn datetime_local_equality() { + assert_eq!( + DecodedValue::DatetimeLocal("1987-07-05 17:45:00".to_owned()), + DecodedValue::DatetimeLocal("1987-07-05 17:45:00".to_owned()) + ); + assert_eq!( + DecodedValue::DatetimeLocal("1987-07-05 17:45:00.444".to_owned()), + DecodedValue::DatetimeLocal("1987-07-05 17:45:00.444".to_owned()) + ); + assert_ne!( + DecodedValue::DatetimeLocal("1987-07-05 17:45:00".to_owned()), + DecodedValue::DatetimeLocal("2000-07-05 17:45:00".to_owned()) + ); + assert_eq!( + DecodedValue::DatetimeLocal("1987-07-05t17:45:00".to_owned()), + DecodedValue::DatetimeLocal("1987-07-05 17:45:00".to_owned()) + ); + assert_ne!( + DecodedValue::DatetimeLocal("1987-07-05 17:45:00".to_owned()), + DecodedValue::from("1987-07-05 17:45:00") + ); + } + + #[test] + fn date_local_equality() { + assert_eq!( + DecodedValue::DateLocal("1987-07-05".to_owned()), + DecodedValue::DateLocal("1987-07-05".to_owned()) + ); + assert_ne!( + DecodedValue::DateLocal("1987-07-05".to_owned()), + DecodedValue::DateLocal("2000-07-05".to_owned()) + ); + assert_ne!( + DecodedValue::DateLocal("1987-07-05".to_owned()), + DecodedValue::from("1987-07-05") + ); + } + + #[test] + fn time_local_equality() { + assert_eq!( + DecodedValue::TimeLocal("17:45:00".to_owned()), + DecodedValue::TimeLocal("17:45:00".to_owned()) + ); + assert_eq!( + DecodedValue::TimeLocal("17:45:00.444".to_owned()), + DecodedValue::TimeLocal("17:45:00.444".to_owned()) + ); + assert_ne!( + DecodedValue::TimeLocal("17:45:00".to_owned()), + DecodedValue::TimeLocal("19:45:00".to_owned()) + ); + assert_ne!( + DecodedValue::TimeLocal("17:45:00".to_owned()), + DecodedValue::from("17:45:00") + ); + } +} diff --git a/src/encoded.rs b/src/encoded.rs deleted file mode 100644 index 8af542d..0000000 --- a/src/encoded.rs +++ /dev/null @@ -1,369 +0,0 @@ -#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)] -#[serde(untagged)] -pub enum Encoded { - Value(EncodedValue), - Table(std::collections::HashMap), - Array(Vec), -} - -impl Encoded { - pub fn from_slice(v: &[u8]) -> Result { - serde_json::from_slice(v).map_err(crate::Error::new) - } - - pub fn to_string_pretty(&self) -> Result { - serde_json::to_string_pretty(self).map_err(crate::Error::new) - } -} - -#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] -#[serde(rename_all = "kebab-case")] -#[serde(tag = "type", content = "value")] -pub enum EncodedValue { - String(String), - Integer(String), - Float(String), - Bool(String), - Datetime(String), - DatetimeLocal(String), - DateLocal(String), - TimeLocal(String), -} - -impl EncodedValue { - pub fn as_str(&self) -> &str { - match self { - EncodedValue::String(v) - | EncodedValue::Integer(v) - | EncodedValue::Float(v) - | EncodedValue::Bool(v) - | EncodedValue::Datetime(v) - | EncodedValue::DatetimeLocal(v) - | EncodedValue::DateLocal(v) - | EncodedValue::TimeLocal(v) => v.as_str(), - } - } -} - -impl<'a> From<&'a str> for EncodedValue { - fn from(other: &'a str) -> Self { - EncodedValue::String(other.to_owned()) - } -} - -impl<'a> From<&'a String> for EncodedValue { - fn from(other: &'a String) -> Self { - EncodedValue::String(other.clone()) - } -} - -impl From for EncodedValue { - fn from(other: String) -> Self { - EncodedValue::String(other) - } -} - -impl From for EncodedValue { - fn from(other: i64) -> Self { - EncodedValue::Integer(other.to_string()) - } -} - -impl From for EncodedValue { - fn from(other: f64) -> Self { - let s = if other.is_nan() { - "nan".to_owned() - } else if other.is_infinite() && other.is_sign_negative() { - "-inf".to_owned() - } else if other.is_infinite() && other.is_sign_positive() { - "inf".to_owned() - } else { - let s = format!("{:.15}", other); - let s = s.trim_end_matches('0'); - if s.ends_with('.') { - format!("{}0", s) - } else { - s.to_owned() - } - }; - EncodedValue::Float(s) - } -} - -impl From for EncodedValue { - fn from(other: bool) -> Self { - EncodedValue::Bool(other.to_string()) - } -} - -impl PartialEq for EncodedValue { - fn eq(&self, other: &Self) -> bool { - #[allow(clippy::if_same_then_else)] - match (self, other) { - (EncodedValue::String(s), EncodedValue::String(o)) => s == o, - (EncodedValue::Integer(s), EncodedValue::Integer(o)) => s == o, - (EncodedValue::Float(s), EncodedValue::Float(o)) => { - if s == "inf" && o == "+inf" { - true - } else if s == "+inf" && o == "inf" { - true - } else if s == "nan" && o == "nan" { - true - } else { - let s = s.parse::().unwrap(); - let o = o.parse::().unwrap(); - s == o - } - } - (EncodedValue::Bool(s), EncodedValue::Bool(o)) => s == o, - (EncodedValue::Datetime(s), EncodedValue::Datetime(o)) => { - parse_date_time(s) == parse_date_time(o) - } - (EncodedValue::DatetimeLocal(s), EncodedValue::DatetimeLocal(o)) => { - parse_date_time_local(s) == parse_date_time_local(o) - } - (EncodedValue::DateLocal(s), EncodedValue::DateLocal(o)) => { - parse_date_local(s) == parse_date_local(o) - } - (EncodedValue::TimeLocal(s), EncodedValue::TimeLocal(o)) => { - parse_time_local(s) == parse_time_local(o) - } - (_, _) => false, - } - } -} - -fn parse_date_time(s: &str) -> chrono::DateTime { - match normalize_datetime(s).parse() { - Ok(d) => d, - Err(err) => panic!("Failed to parse {:?}: {}", s, err), - } -} - -fn parse_date_time_local(s: &str) -> chrono::NaiveDateTime { - match normalize_datetime(s).parse() { - Ok(d) => d, - Err(err) => panic!("Failed to parse {:?}: {}", s, err), - } -} - -fn parse_date_local(s: &str) -> chrono::NaiveDate { - match s.parse() { - Ok(d) => d, - Err(err) => panic!("Failed to parse {:?}: {}", s, err), - } -} - -fn parse_time_local(s: &str) -> chrono::NaiveTime { - match s.parse() { - Ok(d) => d, - Err(err) => panic!("Failed to parse {:?}: {}", s, err), - } -} - -fn normalize_datetime(s: &str) -> String { - s.chars() - .map(|c| match c { - ' ' => 'T', - 't' => 'T', - 'z' => 'Z', - _ => c, - }) - .collect() -} - -impl Eq for EncodedValue {} - -#[cfg(test)] -mod test { - use super::*; - - #[test] - fn string_equality() { - assert_eq!(EncodedValue::from("foo"), EncodedValue::from("foo")); - assert_ne!(EncodedValue::from("foo"), EncodedValue::from("bar")); - assert_ne!(EncodedValue::from("42"), EncodedValue::from(42)); - assert_ne!(EncodedValue::from("true"), EncodedValue::from(true)); - } - - #[test] - fn integer_equality() { - assert_eq!(EncodedValue::from(42), EncodedValue::from(42)); - assert_ne!(EncodedValue::from(42), EncodedValue::from(21)); - assert_ne!(EncodedValue::from(42), EncodedValue::from("42")); - } - - #[test] - fn float_equality() { - assert_eq!(EncodedValue::from(42.0), EncodedValue::from(42.0)); - assert_ne!(EncodedValue::from(42.0), EncodedValue::from(21.0)); - assert_ne!(EncodedValue::from(42.0), EncodedValue::from("42.0")); - } - - #[test] - fn nan_equality() { - assert_eq!(EncodedValue::from(f64::NAN), EncodedValue::from(f64::NAN)); - assert_eq!( - EncodedValue::from(f64::NAN), - EncodedValue::Float("nan".to_owned()) - ); - assert_ne!(EncodedValue::from(f64::NAN), EncodedValue::from("nan")); - } - - #[test] - fn inf_equality() { - assert_eq!( - EncodedValue::from(f64::INFINITY), - EncodedValue::from(f64::INFINITY) - ); - assert_ne!( - EncodedValue::from(f64::INFINITY), - EncodedValue::from(f64::NEG_INFINITY) - ); - assert_eq!( - EncodedValue::from(f64::INFINITY), - EncodedValue::Float("inf".to_owned()) - ); - assert_eq!( - EncodedValue::from(f64::INFINITY), - EncodedValue::Float("+inf".to_owned()) - ); - assert_ne!(EncodedValue::from(f64::INFINITY), EncodedValue::from("inf")); - } - - #[test] - fn float_exp_equality() { - assert_eq!(EncodedValue::from(3.0e14), EncodedValue::from(3.0e14)); - assert_eq!( - EncodedValue::from(3.0e14), - EncodedValue::Float("3.0e14".to_owned()) - ); - } - - #[test] - fn float_binary_equality() { - #![allow(clippy::excessive_precision)] - - // These cases are equivalent, just wanting to call out how Rust, at times, encodes the - // number in a string. - assert_eq!( - EncodedValue::from(3141.5927), - EncodedValue::Float("3141.5927".to_owned()) - ); - assert_eq!( - EncodedValue::from(3141.59270000000015), - EncodedValue::Float("3141.5927".to_owned()) - ); - } - - #[test] - fn neg_inf_equality() { - assert_eq!( - EncodedValue::from(f64::NEG_INFINITY), - EncodedValue::from(f64::NEG_INFINITY) - ); - assert_ne!( - EncodedValue::from(f64::NEG_INFINITY), - EncodedValue::from(f64::INFINITY) - ); - assert_eq!( - EncodedValue::from(f64::NEG_INFINITY), - EncodedValue::Float("-inf".to_owned()) - ); - assert_ne!( - EncodedValue::from(f64::NEG_INFINITY), - EncodedValue::from("-inf") - ); - } - - #[test] - fn bool_equality() { - assert_eq!(EncodedValue::from(true), EncodedValue::from(true)); - assert_ne!(EncodedValue::from(true), EncodedValue::from(false)); - assert_ne!(EncodedValue::from(true), EncodedValue::from("true")); - } - - #[test] - fn datetime_equality() { - assert_eq!( - EncodedValue::Datetime("1987-07-05 17:45:00Z".to_owned()), - EncodedValue::Datetime("1987-07-05 17:45:00Z".to_owned()) - ); - assert_eq!( - EncodedValue::Datetime("1987-07-05T17:45:56.123456Z".to_owned()), - EncodedValue::Datetime("1987-07-05T17:45:56.123456Z".to_owned()), - ); - assert_ne!( - EncodedValue::Datetime("1987-07-05 17:45:00Z".to_owned()), - EncodedValue::Datetime("2000-07-05 17:45:00Z".to_owned()) - ); - assert_eq!( - EncodedValue::Datetime("1987-07-05t17:45:00z".to_owned()), - EncodedValue::Datetime("1987-07-05 17:45:00Z".to_owned()) - ); - assert_ne!( - EncodedValue::Datetime("1987-07-05 17:45:00Z".to_owned()), - EncodedValue::from("1987-07-05 17:45:00Z") - ); - } - - #[test] - fn datetime_local_equality() { - assert_eq!( - EncodedValue::DatetimeLocal("1987-07-05 17:45:00".to_owned()), - EncodedValue::DatetimeLocal("1987-07-05 17:45:00".to_owned()) - ); - assert_eq!( - EncodedValue::DatetimeLocal("1987-07-05 17:45:00.444".to_owned()), - EncodedValue::DatetimeLocal("1987-07-05 17:45:00.444".to_owned()) - ); - assert_ne!( - EncodedValue::DatetimeLocal("1987-07-05 17:45:00".to_owned()), - EncodedValue::DatetimeLocal("2000-07-05 17:45:00".to_owned()) - ); - assert_eq!( - EncodedValue::DatetimeLocal("1987-07-05t17:45:00".to_owned()), - EncodedValue::DatetimeLocal("1987-07-05 17:45:00".to_owned()) - ); - assert_ne!( - EncodedValue::DatetimeLocal("1987-07-05 17:45:00".to_owned()), - EncodedValue::from("1987-07-05 17:45:00") - ); - } - - #[test] - fn date_local_equality() { - assert_eq!( - EncodedValue::DateLocal("1987-07-05".to_owned()), - EncodedValue::DateLocal("1987-07-05".to_owned()) - ); - assert_ne!( - EncodedValue::DateLocal("1987-07-05".to_owned()), - EncodedValue::DateLocal("2000-07-05".to_owned()) - ); - assert_ne!( - EncodedValue::DateLocal("1987-07-05".to_owned()), - EncodedValue::from("1987-07-05") - ); - } - - #[test] - fn time_local_equality() { - assert_eq!( - EncodedValue::TimeLocal("17:45:00".to_owned()), - EncodedValue::TimeLocal("17:45:00".to_owned()) - ); - assert_eq!( - EncodedValue::TimeLocal("17:45:00.444".to_owned()), - EncodedValue::TimeLocal("17:45:00.444".to_owned()) - ); - assert_ne!( - EncodedValue::TimeLocal("17:45:00".to_owned()), - EncodedValue::TimeLocal("19:45:00".to_owned()) - ); - assert_ne!( - EncodedValue::TimeLocal("17:45:00".to_owned()), - EncodedValue::from("17:45:00") - ); - } -} diff --git a/src/lib.rs b/src/lib.rs index 6a22704..3c243d2 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,25 +1,5 @@ -use std::io::Read; -use std::io::Write; - mod error; -pub mod encoded; +pub mod decoded; pub mod verify; pub use error::Error; - -/// External parser helper for [verify] -pub fn encoder_in() -> Result { - let mut buf = Vec::new(); - std::io::stdin() - .read_to_end(&mut buf) - .map_err(crate::Error::new)?; - encoded::Encoded::from_slice(&buf) -} - -/// External parser helper for [verify] -pub fn decoder_out(e: encoded::Encoded) -> Result<(), Error> { - let s = e.to_string_pretty()?; - std::io::stdout() - .write_all(s.as_bytes()) - .map_err(crate::Error::new) -} diff --git a/src/verify.rs b/src/verify.rs index ffd1b1e..73dca00 100644 --- a/src/verify.rs +++ b/src/verify.rs @@ -1,17 +1,17 @@ use std::io::Write; pub trait Encoder { - fn encode(&self, data: crate::encoded::Encoded) -> Result; + fn encode(&self, data: crate::decoded::Decoded) -> Result; fn name(&self) -> &str; } pub trait Decoder { - fn decode(&self, data: &[u8]) -> Result; + fn decode(&self, data: &[u8]) -> Result; fn verify_valid_case(&self, fixture: &[u8], expected: &[u8]) -> Result<(), crate::Error> { let actual = self.decode(fixture)?; - let expected = crate::encoded::Encoded::from_slice(expected)?; + let expected = crate::decoded::Decoded::from_slice(expected)?; if actual == expected { Ok(()) } else { @@ -50,7 +50,7 @@ impl Command { } impl Decoder for Command { - fn decode(&self, data: &[u8]) -> Result { + fn decode(&self, data: &[u8]) -> Result { let mut cmd = std::process::Command::new(&self.bin); cmd.stdin(std::process::Stdio::piped()) .stdout(std::process::Stdio::piped()) @@ -66,7 +66,7 @@ impl Decoder for Command { let output = child.wait_with_output().map_err(crate::Error::new)?; if output.status.success() { let output = - crate::encoded::Encoded::from_slice(&output.stdout).map_err(crate::Error::new)?; + crate::decoded::Decoded::from_slice(&output.stdout).map_err(crate::Error::new)?; Ok(output) } else { let message = String::from_utf8_lossy(&output.stderr); diff --git a/tests/decoded.rs b/tests/decoded.rs new file mode 100644 index 0000000..116e02f --- /dev/null +++ b/tests/decoded.rs @@ -0,0 +1,6 @@ +#[test] +fn can_load() { + for valid in toml_test_data::valid() { + toml_test::decoded::Decoded::from_slice(valid.expected).unwrap(); + } +} diff --git a/tests/encoded.rs b/tests/encoded.rs index 8de56e9..116e02f 100644 --- a/tests/encoded.rs +++ b/tests/encoded.rs @@ -1,6 +1,6 @@ #[test] fn can_load() { for valid in toml_test_data::valid() { - toml_test::encoded::Encoded::from_slice(valid.expected).unwrap(); + toml_test::decoded::Decoded::from_slice(valid.expected).unwrap(); } }