timw4mail/json-parser
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Fun with traits for better ergonomics of the JSONValue Enum

Browse Source
This commit is contained in:
Timothy Warren 2020-02-11 19:12:01 -05:00
parent a4cb3f9b0e
commit 97bfd16b32
1 changed files with 196 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

237
src/lib.rs
View File

@ -7,6 +7,7 @@ use std::iter::FromIterator;
use std::{char, u16};
pub type JSONResult = Result<JSONValue, ParseError>;
pub type JSONArray = Vec<JSONValue>;
pub type JSONMap = HashMap<String, JSONValue>;
/// The type of JSON value
@ -34,6 +35,139 @@ pub enum JSONValue {
Null,
}
impl JSONValue {
/// Convert the wrapped JSONValue to its simpler rust value
///
/// Example:
/// ```
/// use naive_json_parser::JSONValue;
///
/// let str = "Four score and seven years ago...";
/// let wrapped = JSONValue::from(str);
///
/// // s is now the `String` that was in the `JSONValue` enum
/// let s: String = wrapped.unwrap();
///
/// # assert_eq!(str, &s);
/// ```
pub fn unwrap<T: From<JSONValue>>(self) -> T {
T::from(self)
}
}
impl From<JSONValue> for JSONMap {
/// Extracts the `HashMap` in the `JSONValue` enum, if it exists.
/// Otherwise, panics.
fn from(val: JSONValue) -> JSONMap {
match val {
JSONValue::Object(o) => o,
_ => panic!("Invalid type conversion")
}
}
}
impl From<JSONValue> for JSONArray{
/// Extracts the `Vec` in the `JSONValue` enum, if it exists.
/// Otherwise, panics.
fn from(val: JSONValue) -> JSONArray {
match val {
JSONValue::Array(a) => a,
_ => panic!("Invalid type conversion")
}
}
}
impl From<JSONValue> for f64 {
/// Extracts the `f64` in the `JSONValue` enum, if it exists.
/// Otherwise, panics.
fn from(val: JSONValue) -> f64 {
match val {
JSONValue::Number(n) => n,
_ => panic!("Invalid type conversion")
}
}
}
impl From<JSONValue> for String {
/// Extracts the `String` in the `JSONValue` enum, if it exists.
/// Otherwise, panics.
fn from(val: JSONValue) -> String {
match val {
JSONValue::String(s) => s,
_ => panic!("Invalid type conversion")
}
}
}
impl From<JSONValue> for bool {
/// Extracts the `bool` value from the `JSONValue` enum, if it exists.
/// Otherwise, panics.
fn from(val: JSONValue) -> bool {
match val {
JSONValue::True => true,
JSONValue::False => false,
_ => panic!("Invalid type conversion")
}
}
}
impl From<JSONValue> for () {
/// This will just swallow the enum value and return a unit tuple
fn from(_: JSONValue) -> () { () }
}
impl From<JSONMap> for JSONValue {
/// Wraps the `HashMap` in the `JSONValue` enum
fn from(val: JSONMap) -> JSONValue {
Self::Object(val)
}
}
impl From<JSONArray> for JSONValue {
/// Wraps the `Vec` in the `JSONValue` enum
fn from(val: JSONArray) -> JSONValue {
Self::Array(val)
}
}
impl From<bool> for JSONValue {
/// Sets the `JSONValue` enum to the `True` or `False` value
fn from(val: bool) -> Self {
match val {
true => Self::True,
false => Self::False,
}
}
}
impl From<f64> for JSONValue {
/// Wraps the `f64` in the `JSONValue` enum
fn from(n: f64) -> Self {
Self::Number(n)
}
}
impl From<()> for JSONValue {
/// Sets the `JSONValue` enum to the `Null` value
fn from(_s: ()) -> Self {
Self::Null
}
}
impl From<String> for JSONValue {
/// Wraps the `String` in the `JSONValue` enum
fn from(s: String) -> Self {
Self::String(s)
}
}
impl From<&str> for JSONValue {
/// Creates a `String` and wraps it in the `JSONValue` enum
fn from(s: &str) -> Self {
Self::String(String::from(s))
}
}
/// The type of error returned by the parser
#[derive(Debug, PartialEq)]
pub enum ParseError {
@ -111,9 +245,7 @@ impl JSON {
);
// Every parser failed, so the syntax is probably incorrect
Err(ParseError::UnexpectedEndOfInput(String::from(
"Doesn't seem to be valid JSON",
)))
Err(ParseError::UnexpectedEndOfInput(format!("Doesn't seem to be valid JSON")))
}
/// See if there's a `JSONValue::Object` next in the JSON
@ -315,7 +447,7 @@ impl JSON {
match str.parse::<f64>() {
Ok(number) => {
self.increment(str.len());
return Ok(Some(JSONValue::Number(number)));
return Ok(Some(JSONValue::from(number)));
}
Err(e) => Err(ParseError::ExpectedDigit(format!("'{}', {:#?}", str, e))),
}
@ -391,20 +523,39 @@ mod tests {
use super::JSONValue::{Array, False, Null, Number, Object, True};
use super::*;
impl JSONValue {
fn unwrap_object(self) -> JSONMap {
match self {
JSONValue::Object(o) => o,
_ => panic!("Tried to unwrap a non-object"),
}
#[test]
fn value_conversion() {
let map: JSONMap = HashMap::new();
let num = 9.380831539;
let str = "applesauce";
let arr: JSONArray = vec![JSONValue::from(map.clone()), JSONValue::from(num), JSONValue::from(str)];
assert_eq!(map.clone(), JSONMap::from(JSONValue::from(map.clone())));
assert_eq!(num, f64::from(JSONValue::from(num)));
assert_eq!(String::from(str), String::from(JSONValue::from(str)));
assert_eq!(arr.clone(), JSONArray::from(JSONValue::from(arr.clone())));
assert_eq!(true, bool::from(JSONValue::from(true)));
assert_eq!(false, bool::from(JSONValue::from(false)));
assert_eq!((), <()>::from(JSONValue::from(())));
}
fn unwrap_array(self) -> Vec<JSONValue> {
match self {
JSONValue::Array(a) => a,
_ => panic!("Tried to unwrap a non-array"),
}
}
#[test]
fn wrap_and_unwrap() {
let map: JSONMap = HashMap::new();
let num = 9.380831539;
let str = "applesauce";
let arr: JSONArray = vec![JSONValue::from(map.clone()), JSONValue::from(num), JSONValue::from(str)];
let s: String = JSONValue::from(str).unwrap();
let a: JSONArray = JSONValue::from(arr.clone()).unwrap();
assert_eq!(map.clone(), JSONValue::from(map.clone()).unwrap());
assert_eq!(num, JSONValue::from(num).unwrap());
assert_eq!(str, &s);
assert_eq!(arr.clone(), a);
assert_eq!(true, JSONValue::from(true).unwrap());
assert_eq!(false, JSONValue::from(false).unwrap());
assert_eq!((), JSONValue::from(()).unwrap());
}
#[test]
@ -426,10 +577,10 @@ mod tests {
#[test]
fn parse_string() {
let res = JSON::new(r#""\t""#).parse_string();
assert_eq!(res, Ok(Some(JSONValue::String(String::from("\t")))));
assert_eq!(res, Ok(Some(JSONValue::from("\t"))));
let res = JSON::new(r#""\u203d""#).parse_string();
assert_eq!(res, Ok(Some(JSONValue::String(String::from("‽")))));
assert_eq!(res, Ok(Some(JSONValue::from("‽"))));
}
#[test]
@ -468,7 +619,7 @@ mod tests {
let result = JSON::new(r#"{"foo": "bar"}"#).parse_object();
let mut hash_map: JSONMap = HashMap::new();
hash_map.insert(String::from("foo"), JSONValue::String(String::from("bar")));
hash_map.insert(String::from("foo"), JSONValue::from("bar"));
assert_eq!(result, Ok(Some(JSONValue::Object(hash_map))));
}
@ -491,7 +642,7 @@ mod tests {
let res = JSON::parse(r#""/^$/""#);
assert_eq!(
res,
Ok(JSONValue::String(String::from("/^$/"))),
Ok(JSONValue::from("/^$/")),
"Failed to parse string"
);
@ -542,16 +693,16 @@ mod tests {
let result =
JSON::parse(r#"["\"", "\\", "/", "\b", "\f", "\n", "\r", "\t", "\u0001", "\uface"]"#);
let expected = Ok(Array(vec![
JSONValue::String(String::from("\"")),
JSONValue::String(String::from("\\")),
JSONValue::String(String::from("/")),
JSONValue::String(String::from("\u{8}")),
JSONValue::String(String::from("\x0C")),
JSONValue::String(String::from("\n")),
JSONValue::String(String::from("\r")),
JSONValue::String(String::from("\t")),
JSONValue::String(String::from("\u{1}")),
JSONValue::String(String::from("\u{face}")),
JSONValue::from("\""),
JSONValue::from("\\"),
JSONValue::from("/"),
JSONValue::from("\u{8}"),
JSONValue::from("\x0C"),
JSONValue::from("\n"),
JSONValue::from("\r"),
JSONValue::from("\t"),
JSONValue::from("\u{1}"),
JSONValue::from("\u{face}"),
]));
assert_eq!(result, expected);
@ -591,27 +742,29 @@ mod tests {
String::from("c"),
Array(vec![Number(1f64), Number(2f64), Number(3f64)]),
);
map.insert(String::from("d"), JSONValue::String(String::from("foo")));
map.insert(String::from("d"), JSONValue::from("foo"));
map.insert(String::from("e"), Object(emap));
map.insert(
String::from("i"),
Array(vec![
JSONValue::String(String::from("\"")),
JSONValue::String(String::from("\\")),
JSONValue::String(String::from("/")),
JSONValue::String(String::from("\u{8}")),
JSONValue::String(String::from("\x0C")),
JSONValue::String(String::from("\n")),
JSONValue::String(String::from("\r")),
JSONValue::String(String::from("\t")),
JSONValue::String(String::from("\u{1}")),
JSONValue::String(String::from("\u{face}")),
JSONValue::from("\""),
JSONValue::from("\\"),
JSONValue::from("/"),
JSONValue::from("\u{8}"),
JSONValue::from("\x0C"),
JSONValue::from("\n"),
JSONValue::from("\r"),
JSONValue::from("\t"),
JSONValue::from("\u{1}"),
JSONValue::from("\u{face}"),
]),
);
assert!(result.is_ok(), format!("{:#?}", result));
let result_map = result.unwrap().unwrap_array()[0].clone().unwrap_object();
let outer_array: Vec<JSONValue> = result.unwrap().unwrap();
let result_map: JSONMap = outer_array[0].clone().unwrap();
for (k, v) in &map {
assert_eq!(