fluencelabs/jsonpath
1
0
Fork 0
mirror of https://github.com/fluencelabs/jsonpath synced 2025-04-25 09:22:19 +00:00
Code Issues Projects Releases Wiki Activity

Bump up 0.1.7

Browse Source 
- select_as 추가
This commit is contained in:
freestrings 2019-03-24 21:18:58 +09:00
parent a9f8f0bf4b
commit 8982e07421
31 changed files with 1830 additions and 228 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Cargo.toml
View File

@ -1,6 +1,6 @@
[package]
name = "jsonpath_lib"
version = "0.1.6"
version = "0.1.7"
authors = ["Changseok Han <freestrings@gmail.com>"]
description = "JsonPath in Rust and Webassembly - Webassembly Demo: https://freestrings.github.io/jsonpath"
@ -18,7 +18,7 @@ travis-ci = { repository = "freestrings/jsonpath", branch = "master" }
[dependencies]
log = "0.4"
env_logger = "0.6.0"
serde = "1.0"
serde = { version = "1.0", features = ["derive"] }
serde_json = { version = "1.0", features = ["preserve_order"] }
indexmap = "1.0.2"

37
README.md
View File

@ -30,7 +30,8 @@ To enjoy Rust!
- [jsonpath_lib library](#jsonpath_lib-library)
- [rust - jsonpath::select(json: &serde_json::value::Value, jsonpath: &str)](#rust---jsonpathselectjson-serde_jsonvaluevalue-jsonpath-str)
- [rust - jsonpath::select_str(json_str: &str, jsonpath: &str)](#rust---jsonpathselect_strjson-str-jsonpath-str)
- [rust - jsonpath::select_as_str(json_str: &str, jsonpath: &str)](#rust---jsonpathselect_as_strjson-str-jsonpath-str)
- [rust - jsonpath::select_as\<T\>(json_str: &str, jsonpath: &str)](#rust---jsonpathselect_astjson-str-jsonpath-str)
- [rust - jsonpath::compile(jsonpath: &str)](#rust---jsonpathcompilejsonpath-str)
- [rust - jsonpath::selector(json: &serde_json::value::Value)](#rust---jsonpathselectorjson-serde_jsonvaluevalue)
- [rust - examples](https://github.com/freestrings/jsonpath/wiki/rust-examples)
@ -209,16 +210,46 @@ let ret = json!([ {"id": 0}, {"id": 0} ]);
assert_eq!(json, ret)
```
### rust - jsonpath::select_str(json: &str, jsonpath: &str)
### rust - jsonpath::select_as_str(json: &str, jsonpath: &str)
```rust
let ret = jsonpath::select_str(r#"{
let ret = jsonpath::select_as_str(r#"{
"school": { "friends": [{"id": 0}, {"id": 1}] },
"friends": [{"id": 0}, {"id": 1}]
}"#, "$..friends[0]").unwrap();
assert_eq!(ret, r#"[{"id":0},{"id":0}]"#);
```
### rust - jsonpath::select_as\<T\>(json: &str, jsonpath: &str)
```rust
#[derive(Serialize, Deserialize, PartialEq, Debug)]
struct Person {
name: String,
age: u8,
phones: Vec<String>,
}
let ret: Person = jsonpath::select_as(r#"
{
"person":
{
"name": "Doe John",
"age": 44,
"phones": [
"+44 1234567",
"+44 2345678"
]
}
}
"#, "$.person").unwrap();
let person = Person {
name: "Doe John".to_string(),
age: 44,
phones: vec!["+44 1234567".to_string(), "+44 2345678".to_string()],
};
assert_eq!(person, ret);
```
### rust - jsonpath::compile(jsonpath: &str)
```rust

24
benches/bench.rs
View File

@ -1,10 +1,14 @@
#![feature(test)]
extern crate jsonpath_lib as jsonpath;
extern crate serde;
extern crate serde_json;
extern crate test;
use std::io::Read;
use serde::Deserialize;
use serde_json::Value;
use self::test::Bencher;
fn read_json(path: &str) -> String {
@ -68,3 +72,23 @@ fn bench_compile(b: &mut Bencher) {
}
});
}
#[bench]
fn bench_select_as(b: &mut Bencher) {
let json = get_string();
#[derive(Deserialize, PartialEq, Debug)]
struct Book {
category: String,
author: String,
title: String,
price: f64
}
b.iter(move || {
for _ in 1..100 {
let _: Book = jsonpath::select_as(&json, r#"$..book[?(@.price<30 && @.category=="fiction")][0]"#).unwrap();
}
});
}

6
docs/0.bootstrap.js
View File

File diff suppressed because one or more lines are too long

6
docs/bench/0.bootstrap.js
View File

File diff suppressed because one or more lines are too long

14
docs/bench/bootstrap.js vendored
View File

@ -61,6 +61,9 @@
/******/ "__wbindgen_object_drop_ref": function(p0i32) {
/******/ return installedModules["../browser_pkg/jsonpath_wasm.js"].exports["__wbindgen_object_drop_ref"](p0i32);
/******/ },
/******/ "__wbindgen_object_clone_ref": function(p0i32) {
/******/ return installedModules["../browser_pkg/jsonpath_wasm.js"].exports["__wbindgen_object_clone_ref"](p0i32);
/******/ },
/******/ "__wbindgen_cb_forget": function(p0i32) {
/******/ return installedModules["../browser_pkg/jsonpath_wasm.js"].exports["__wbindgen_cb_forget"](p0i32);
/******/ },
@ -82,17 +85,14 @@
/******/ "__wbindgen_string_get": function(p0i32,p1i32) {
/******/ return installedModules["../browser_pkg/jsonpath_wasm.js"].exports["__wbindgen_string_get"](p0i32,p1i32);
/******/ },
/******/ "__wbindgen_object_clone_ref": function(p0i32) {
/******/ return installedModules["../browser_pkg/jsonpath_wasm.js"].exports["__wbindgen_object_clone_ref"](p0i32);
/******/ },
/******/ "__wbindgen_throw": function(p0i32,p1i32) {
/******/ return installedModules["../browser_pkg/jsonpath_wasm.js"].exports["__wbindgen_throw"](p0i32,p1i32);
/******/ },
/******/ "__wbindgen_closure_wrapper100": function(p0i32,p1i32,p2i32) {
/******/ return installedModules["../browser_pkg/jsonpath_wasm.js"].exports["__wbindgen_closure_wrapper100"](p0i32,p1i32,p2i32);
/******/ },
/******/ "__wbindgen_closure_wrapper102": function(p0i32,p1i32,p2i32) {
/******/ return installedModules["../browser_pkg/jsonpath_wasm.js"].exports["__wbindgen_closure_wrapper102"](p0i32,p1i32,p2i32);
/******/ },
/******/ "__wbindgen_closure_wrapper104": function(p0i32,p1i32,p2i32) {
/******/ return installedModules["../browser_pkg/jsonpath_wasm.js"].exports["__wbindgen_closure_wrapper104"](p0i32,p1i32,p2i32);
/******/ }
/******/ }
/******/ };
@ -192,7 +192,7 @@
/******/ promises.push(installedWasmModuleData);
/******/ else {
/******/ var importObject = wasmImportObjects[wasmModuleId]();
/******/ var req = fetch(__webpack_require__.p + "" + {"../browser_pkg/jsonpath_wasm_bg.wasm":"e354e10adee0b37b85d7"}[wasmModuleId] + ".module.wasm");
/******/ var req = fetch(__webpack_require__.p + "" + {"../browser_pkg/jsonpath_wasm_bg.wasm":"c615fa3fad4c084c8bcd"}[wasmModuleId] + ".module.wasm");
/******/ var promise;
/******/ if(importObject instanceof Promise && typeof WebAssembly.compileStreaming === 'function') {
/******/ promise = Promise.all([WebAssembly.compileStreaming(req), importObject]).then(function(items) {

BIN
docs/bench/c615fa3fad4c084c8bcd.module.wasm Normal file
View File

Binary file not shown.

BIN
docs/bench/e354e10adee0b37b85d7.module.wasm
View File

Binary file not shown.

14
docs/bootstrap.js vendored
View File

@ -61,6 +61,9 @@
/******/ "__wbindgen_object_drop_ref": function(p0i32) {
/******/ return installedModules["../browser_pkg/jsonpath_wasm.js"].exports["__wbindgen_object_drop_ref"](p0i32);
/******/ },
/******/ "__wbindgen_object_clone_ref": function(p0i32) {
/******/ return installedModules["../browser_pkg/jsonpath_wasm.js"].exports["__wbindgen_object_clone_ref"](p0i32);
/******/ },
/******/ "__wbindgen_cb_forget": function(p0i32) {
/******/ return installedModules["../browser_pkg/jsonpath_wasm.js"].exports["__wbindgen_cb_forget"](p0i32);
/******/ },
@ -82,17 +85,14 @@
/******/ "__wbindgen_string_get": function(p0i32,p1i32) {
/******/ return installedModules["../browser_pkg/jsonpath_wasm.js"].exports["__wbindgen_string_get"](p0i32,p1i32);
/******/ },
/******/ "__wbindgen_object_clone_ref": function(p0i32) {
/******/ return installedModules["../browser_pkg/jsonpath_wasm.js"].exports["__wbindgen_object_clone_ref"](p0i32);
/******/ },
/******/ "__wbindgen_throw": function(p0i32,p1i32) {
/******/ return installedModules["../browser_pkg/jsonpath_wasm.js"].exports["__wbindgen_throw"](p0i32,p1i32);
/******/ },
/******/ "__wbindgen_closure_wrapper100": function(p0i32,p1i32,p2i32) {
/******/ return installedModules["../browser_pkg/jsonpath_wasm.js"].exports["__wbindgen_closure_wrapper100"](p0i32,p1i32,p2i32);
/******/ },
/******/ "__wbindgen_closure_wrapper102": function(p0i32,p1i32,p2i32) {
/******/ return installedModules["../browser_pkg/jsonpath_wasm.js"].exports["__wbindgen_closure_wrapper102"](p0i32,p1i32,p2i32);
/******/ },
/******/ "__wbindgen_closure_wrapper104": function(p0i32,p1i32,p2i32) {
/******/ return installedModules["../browser_pkg/jsonpath_wasm.js"].exports["__wbindgen_closure_wrapper104"](p0i32,p1i32,p2i32);
/******/ }
/******/ }
/******/ };
@ -192,7 +192,7 @@
/******/ promises.push(installedWasmModuleData);
/******/ else {
/******/ var importObject = wasmImportObjects[wasmModuleId]();
/******/ var req = fetch(__webpack_require__.p + "" + {"../browser_pkg/jsonpath_wasm_bg.wasm":"e354e10adee0b37b85d7"}[wasmModuleId] + ".module.wasm");
/******/ var req = fetch(__webpack_require__.p + "" + {"../browser_pkg/jsonpath_wasm_bg.wasm":"c615fa3fad4c084c8bcd"}[wasmModuleId] + ".module.wasm");
/******/ var promise;
/******/ if(importObject instanceof Promise && typeof WebAssembly.compileStreaming === 'function') {
/******/ promise = Promise.all([WebAssembly.compileStreaming(req), importObject]).then(function(items) {

BIN
docs/c615fa3fad4c084c8bcd.module.wasm Normal file
View File

Binary file not shown.

BIN
docs/e354e10adee0b37b85d7.module.wasm
View File

Binary file not shown.

10
nodejs/native/src/lib.rs
View File

@ -4,7 +4,11 @@ extern crate neon;
extern crate neon_serde;
extern crate serde_json;
use jsonpath::prelude::*;
use std::ops::Deref;
use jsonpath::filter::value_filter::JsonValueFilter;
use jsonpath::parser::parser::{Node, NodeVisitor, Parser};
use jsonpath::ref_value::model::{RefValue, RefValueWrapper};
use neon::prelude::*;
use serde_json::Value;
@ -70,7 +74,7 @@ declare_types! {
let mut jf = JsonValueFilter::new_from_value(ref_value.into());
jf.visit(node);
match serde_json::to_string(&jf.take_value()) {
match serde_json::to_string(&jf.take_value().deref()) {
Ok(json_str) => Ok(JsString::new(&mut ctx, &json_str).upcast()),
Err(e) => panic!("{:?}", e)
}
@ -107,7 +111,7 @@ declare_types! {
let mut jf = JsonValueFilter::new_from_value(json);
jf.visit(node);
match serde_json::to_string(&jf.take_value()) {
match serde_json::to_string(&jf.take_value().deref()) {
Ok(json_str) => Ok(JsString::new(&mut ctx, &json_str).upcast()),
Err(e) => panic!("{:?}", e)
}

5
src/filter/mod.rs
View File

@ -1,5 +1,4 @@
mod cmp;
mod term;
mod value_filter;
mod value_wrapper;
pub mod prelude;
pub mod value_filter;
pub mod value_wrapper;

1
src/filter/prelude.rs
View File

@ -1 +0,0 @@
pub use super::value_filter::*;

2
src/filter/value_filter.rs
View File

@ -6,8 +6,8 @@ use serde_json::Value;
use filter::term::*;
use filter::value_wrapper::*;
use parser::prelude::*;
use ref_value::model::*;
use parser::parser::{ParseToken, FilterToken, NodeVisitor};
trait ArrayIndex {
fn index(&self, v: &RefValueWrapper) -> usize;

93
src/lib.rs
View File

@ -162,26 +162,27 @@ extern crate env_logger;
extern crate indexmap;
#[macro_use]
extern crate log;
#[macro_use]
extern crate serde;
extern crate serde_json;
use std::ops::Deref;
use std::result;
use serde_json::Value;
use prelude::*;
use filter::value_filter::JsonValueFilter;
use parser::parser::{NodeVisitor, Parser};
use ref_value::model::{RefValue, RefValueWrapper};
#[doc(hidden)]
mod parser;
pub mod parser;
#[doc(hidden)]
mod filter;
pub mod filter;
#[doc(hidden)]
mod ref_value;
pub mod prelude;
pub mod ref_value;
type Result = result::Result<Value, String>;
/// # Read multiple Json multiple times with the same JsonPath
/// # Compile a Jsonpath so it select a JsonObject immediately.
///
/// ```rust
/// extern crate jsonpath_lib as jsonpath;
@ -213,7 +214,7 @@ type Result = result::Result<Value, String>;
/// let ret = json!([ {"id": 0}, {"name": "Millicent Norman"} ]);
/// assert_eq!(json, ret);
/// ```
pub fn compile<'a>(path: &'a str) -> impl FnMut(&Value) -> Result + 'a {
pub fn compile<'a>(path: &'a str) -> impl FnMut(&Value) -> result::Result<Value, String> + 'a {
let mut parser = Parser::new(path);
let node = parser.compile();
move |json| {
@ -229,7 +230,7 @@ pub fn compile<'a>(path: &'a str) -> impl FnMut(&Value) -> Result + 'a {
}
/// # Read the same Json multiple times using different JsonPath
/// # Use multiple JsonPaths for one JsonObject.
///
/// ```rust
/// extern crate jsonpath_lib as jsonpath;
@ -252,7 +253,7 @@ pub fn compile<'a>(path: &'a str) -> impl FnMut(&Value) -> Result + 'a {
/// let ret = json!([ {"id": 1}, {"id": 1} ]);
/// assert_eq!(json, ret);
/// ```
pub fn selector(json: &Value) -> impl FnMut(&str) -> Result {
pub fn selector(json: &Value) -> impl FnMut(&str) -> result::Result<Value, String> {
let wrapper: RefValueWrapper = json.into();
move |path: &str| {
let mut jf = JsonValueFilter::new_from_value(wrapper.clone());
@ -262,12 +263,12 @@ pub fn selector(json: &Value) -> impl FnMut(&str) -> Result {
}
}
/// # Read the same Json multiple times using different JsonPath - Deprecated. use selector
pub fn reader(json: &Value) -> impl FnMut(&str) -> Result {
/// # Deprecated. use `selector`
pub fn reader(json: &Value) -> impl FnMut(&str) -> result::Result<Value, String> {
selector(json)
}
/// # Read Json using JsonPath
/// # Select a JsonObject
///
/// ```rust
/// extern crate jsonpath_lib as jsonpath;
@ -283,34 +284,84 @@ pub fn reader(json: &Value) -> impl FnMut(&str) -> Result {
/// let ret = json!([ {"id": 0}, {"id": 0} ]);
/// assert_eq!(json, ret);
/// ```
pub fn select(json: &Value, path: &str) -> Result {
pub fn select(json: &Value, path: &str) -> result::Result<Value, String> {
let mut jf = JsonValueFilter::new_from_value(json.into());
let mut parser = Parser::new(path);
parser.parse(&mut jf)?;
Ok(jf.take_value().into())
}
/// # Read Json using JsonPath - Deprecated. use select
pub fn read(json: &Value, path: &str) -> Result {
/// # Deprecated. use `select`
pub fn read(json: &Value, path: &str) -> result::Result<Value, String> {
select(json, path)
}
/// # Read Json string using JsonPath
/// # Deprecaed. use `into_str`
pub fn select_str(json: &str, path: &str) -> result::Result<String, String> {
select_as_str(json, path)
}
/// # Return to json string
///
/// ```rust
/// extern crate jsonpath_lib as jsonpath;
/// #[macro_use] extern crate serde_json;
///
/// let ret = jsonpath::select_str(r#"{
/// let ret = jsonpath::select_as_str(r#"{
/// "school": { "friends": [{"id": 0}, {"id": 1}] },
/// "friends": [{"id": 0}, {"id": 1}]
/// }"#, "$..friends[0]").unwrap();
/// assert_eq!(ret, r#"[{"id":0},{"id":0}]"#);
/// ```
pub fn select_str(json: &str, path: &str) -> result::Result<String, String> {
pub fn select_as_str(json: &str, path: &str) -> result::Result<String, String> {
let ref_value: RefValue = serde_json::from_str(json).map_err(|e| format!("{:?}", e))?;
let mut jf = JsonValueFilter::new_from_value(ref_value.into());
let mut parser = Parser::new(path);
parser.parse(&mut jf)?;
serde_json::to_string(&jf.take_value()).map_err(|e| format!("{:?}", e))
serde_json::to_string(&jf.take_value().deref()).map_err(|e| format!("{:?}", e))
}
/// # Return to deserializeable.
/// ```rust
/// extern crate jsonpath_lib as jsonpath;
/// extern crate serde;
/// #[macro_use] extern crate serde_json;
///
/// use serde::{Deserialize, Serialize};
///
/// #[derive(Serialize, Deserialize, PartialEq, Debug)]
/// struct Person {
/// name: String,
/// age: u8,
/// phones: Vec<String>,
/// }
///
/// let ret: Person = jsonpath::select_as(r#"
/// {
/// "person":
/// {
/// "name": "Doe John",
/// "age": 44,
/// "phones": [
/// "+44 1234567",
/// "+44 2345678"
/// ]
/// }
/// }
/// "#, "$.person").unwrap();
///
/// let person = Person {
/// name: "Doe John".to_string(),
/// age: 44,
/// phones: vec!["+44 1234567".to_string(), "+44 2345678".to_string()],
/// };
///
/// assert_eq!(person, ret);
/// ```
pub fn select_as<'a, T: serde::Deserialize<'a>>(json: &str, path: &str) -> result::Result<T, String> {
let ref_value: RefValue = serde_json::from_str(json).map_err(|e| format!("{:?}", e))?;
let mut jf = JsonValueFilter::new_from_value(ref_value.into());
let mut parser = Parser::new(path);
parser.parse(&mut jf)?;
T::deserialize(jf.take_value().deref()).map_err(|e| format!("{:?}", e))
}

5
src/parser/mod.rs
View File

@ -1,4 +1,3 @@
mod path_reader;
mod tokenizer;
mod parser;
pub mod prelude;
pub mod tokenizer;
pub mod parser;

2
src/parser/prelude.rs
View File

@ -1,2 +0,0 @@
pub use super::parser::*;
pub use super::tokenizer::*;

3
src/prelude.rs
View File

@ -1,3 +0,0 @@
pub use parser::prelude::*;
pub use filter::prelude::*;
pub use ref_value::model::*;

111
src/ref_value/convert.rs
View File

@ -1,111 +0,0 @@
use std::ops::Deref;
use indexmap::IndexMap;
use serde_json::Value;
use ref_value::model::{RefValue, RefValueWrapper};
pub struct RefValueConverter;
impl RefValueConverter {
pub fn new(value: &Value) -> RefValueWrapper {
RefValueConverter {}.visit_value(value)
}
fn visit_value(&self, value: &Value) -> RefValueWrapper {
match value {
Value::Null => self.visit_null(),
Value::Bool(v) => self.visit_bool(v),
Value::Number(v) => self.visit_number(v),
Value::String(v) => self.visit_string(v),
Value::Array(v) => self.visit_array(v),
Value::Object(v) => self.visit_object(v),
}
}
fn visit_null(&self) -> RefValueWrapper {
RefValue::Null.into()
}
fn visit_bool(&self, value: &bool) -> RefValueWrapper {
RefValue::Bool(*value).into()
}
fn visit_number(&self, value: &serde_json::Number) -> RefValueWrapper {
RefValue::Number(value.clone()).into()
}
fn visit_string(&self, value: &String) -> RefValueWrapper {
RefValue::String(value.to_string()).into()
}
fn visit_array(&self, value: &Vec<Value>) -> RefValueWrapper {
let mut values = Vec::new();
for v in value {
values.push(self.visit_value(v));
}
RefValue::Array(values).into()
}
fn visit_object(&self, value: &serde_json::Map<String, Value>) -> RefValueWrapper {
let mut map = IndexMap::new();
for (key, _) in value {
let value = self.visit_value(match value.get(key) {
Some(v) => v,
_ => &Value::Null
});
map.insert(key.clone(), value);
}
RefValue::Object(map).into()
}
}
pub struct ValueConverter;
impl ValueConverter {
pub fn new(value: &RefValueWrapper) -> Value {
ValueConverter {}.visit_value(value)
}
fn visit_value(&self, value: &RefValueWrapper) -> Value {
match value.deref() {
RefValue::Null => self.visit_null(),
RefValue::Bool(v) => self.visit_bool(v),
RefValue::Number(v) => self.visit_number(v),
RefValue::String(v) => self.visit_string(v),
RefValue::Array(v) => self.visit_array(v),
RefValue::Object(v) => self.visit_object(v),
}
}
fn visit_null(&self) -> Value {
Value::Null
}
fn visit_bool(&self, value: &bool) -> Value {
Value::Bool(*value)
}
fn visit_number(&self, value: &serde_json::Number) -> Value {
Value::Number(value.clone())
}
fn visit_string(&self, value: &String) -> Value {
Value::String(value.clone())
}
fn visit_array(&self, value: &Vec<RefValueWrapper>) -> Value {
let mut values = Vec::new();
for v in value {
values.push(self.visit_value(v));
}
Value::Array(values)
}
fn visit_object(&self, map: &IndexMap<String, RefValueWrapper>) -> Value {
let mut ret = serde_json::Map::new();
let tmp_null = &RefValue::Null.into();
for (k, _) in map {
let value = self.visit_value(match map.get(k) {
Some(e) => e,
_ => tmp_null
});
ret.insert(k.to_string(), value);
}
Value::Object(ret)
}
}

939
src/ref_value/de.rs
View File

@ -1,20 +1,45 @@
use std::error::Error;
use std::borrow::Cow;
use std::fmt;
use std::ops::Deref;
use std::result::Result;
use std::vec;
use indexmap::IndexMap;
use serde::{Deserialize, Deserializer};
use serde::de::{MapAccess, SeqAccess, Visitor};
use serde::{self, Deserialize, Deserializer};
use serde::de::{DeserializeSeed, EnumAccess, IntoDeserializer, MapAccess, SeqAccess, VariantAccess, Visitor};
use serde_json::Value;
use super::model::*;
use super::serde_error::SerdeError;
///
/// see `serde_json/value/de.rs`
///
macro_rules! deserialize_prim_number {
($method:ident) => {
fn $method<V>(self, visitor: V) -> Result<V::Value, SerdeError>
where
V: Visitor<'de>,
{
match self {
RefValue::Number(ref n) => {
match n.deserialize_any(visitor) {
Ok(v) => Ok(v),
Err(e) => Err(SerdeError::new(format!("{:?}", e)))
}
}
_ => Err(SerdeError::from_str("invalid type")),
}
}
}
}
impl<'de> Deserialize<'de> for RefValue {
fn deserialize<D>(deserializer: D) -> Result<RefValue, D::Error>
where
D: Deserializer<'de>,
{
struct RefValueVisitor {}
impl<'de> Visitor<'de> for RefValueVisitor {
@ -27,7 +52,7 @@ impl<'de> Deserialize<'de> for RefValue {
#[inline]
fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
where
E: Error, {
E: serde::de::Error, {
Ok(RefValue::Bool(v))
}
@ -106,7 +131,6 @@ impl<'de> Deserialize<'de> for RefValue {
Ok(RefValue::Array(vec))
}
#[inline]
fn visit_map<A>(self, mut visitor: A) -> Result<Self::Value, A::Error>
where
A: MapAccess<'de>, {
@ -129,3 +153,906 @@ impl<'de> Deserialize<'de> for RefValue {
deserializer.deserialize_any(RefValueVisitor {})
}
}
fn visit_array<'de, V>(array: Vec<RefValueWrapper>, visitor: V) -> Result<V::Value, SerdeError>
where
V: Visitor<'de>,
{
let mut deserializer = SeqDeserializer::new(array);
let seq = visitor.visit_seq(&mut deserializer)?;
let remaining = deserializer.iter.len();
if remaining == 0 {
Ok(seq)
} else {
Err(SerdeError::from_str("fewer elements in array"))
}
}
fn visit_object<'de, V>(object: IndexMap<String, RefValueWrapper>, visitor: V) -> Result<V::Value, SerdeError>
where
V: Visitor<'de>,
{
let mut deserializer = MapDeserializer::new(object);
let map = visitor.visit_map(&mut deserializer)?;
let remaining = deserializer.iter.len();
if remaining == 0 {
Ok(map)
} else {
Err(SerdeError::from_str("fewer elements in map"))
}
}
fn to_vec(vec: &Vec<RefValueWrapper>) -> Vec<RefValueWrapper> {
vec.iter().map(|v| v.clone()).collect()
}
fn to_map(object: &IndexMap<String, RefValueWrapper>) -> IndexMap<String, RefValueWrapper> {
let mut map = IndexMap::new();
for (k, v) in object {
map.insert(k.to_string(), v.clone());
}
map
}
impl<'de> serde::Deserializer<'de> for RefValue {
type Error = SerdeError;
#[inline]
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'de> {
match self {
RefValue::Null => visitor.visit_unit(),
RefValue::Bool(v) => visitor.visit_bool(v),
RefValue::Number(n) => {
n.deserialize_any(visitor).map_err(|e| SerdeError::new(format!("{:?}", e)))
}
RefValue::String(v) => visitor.visit_string(v),
RefValue::Array(array) => visit_array(array, visitor),
RefValue::Object(object) => visit_object(object, visitor)
}
}
deserialize_prim_number!(deserialize_i8);
deserialize_prim_number!(deserialize_i16);
deserialize_prim_number!(deserialize_i32);
deserialize_prim_number!(deserialize_i64);
deserialize_prim_number!(deserialize_u8);
deserialize_prim_number!(deserialize_u16);
deserialize_prim_number!(deserialize_u32);
deserialize_prim_number!(deserialize_u64);
deserialize_prim_number!(deserialize_f32);
deserialize_prim_number!(deserialize_f64);
#[inline]
fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
match self {
RefValue::Null => visitor.visit_none(),
_ => visitor.visit_some(self),
}
}
#[inline]
fn deserialize_enum<V>(
self,
_name: &str,
_variants: &'static [&'static str],
visitor: V,
) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
let (variant, value) = match self {
RefValue::Object(value) => {
let mut iter = value.into_iter();
let (variant, value) = match iter.next() {
Some(v) => v,
None => {
return Err(SerdeError::from_str("map with a single key"));
}
};
if iter.next().is_some() {
return Err(SerdeError::from_str("map with a single key"));
}
(variant, Some(value))
}
RefValue::String(variant) => (variant, None),
_ => {
return Err(SerdeError::from_str("string or map"));
}
};
visitor.visit_enum(EnumDeserializer {
variant: variant,
value: value,
})
}
#[inline]
fn deserialize_newtype_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
let _ = name;
visitor.visit_newtype_struct(self)
}
fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
match self {
RefValue::Bool(v) => visitor.visit_bool(v),
_ => Err(SerdeError::from_str("invalid type: bool")),
}
}
fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
self.deserialize_string(visitor)
}
fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
self.deserialize_string(visitor)
}
fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
match self {
RefValue::String(v) => visitor.visit_string(v),
_ => Err(SerdeError::from_str("invalid type: string")),
}
}
fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
self.deserialize_byte_buf(visitor)
}
fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
match self {
RefValue::String(v) => visitor.visit_string(v),
RefValue::Array(v) => visit_array(v, visitor),
_ => Err(SerdeError::from_str("invalid type: string or array")),
}
}
fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
match self {
RefValue::Null => visitor.visit_unit(),
_ => Err(SerdeError::from_str("invalid type: null")),
}
}
fn deserialize_unit_struct<V>(
self,
_name: &'static str,
visitor: V,
) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
self.deserialize_unit(visitor)
}
fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
match self {
RefValue::Array(v) => visit_array(v, visitor),
_ => Err(SerdeError::from_str("invalid type: array")),
}
}
fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
self.deserialize_seq(visitor)
}
fn deserialize_tuple_struct<V>(
self,
_name: &'static str,
_len: usize,
visitor: V,
) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
self.deserialize_seq(visitor)
}
fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
match self {
RefValue::Object(v) => visit_object(v, visitor),
_ => Err(SerdeError::from_str("invalid type: object"))
}
}
fn deserialize_struct<V>(
self,
_name: &'static str,
_fields: &'static [&'static str],
visitor: V,
) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
match self {
RefValue::Array(v) => visit_array(v, visitor),
RefValue::Object(v) => visit_object(v, visitor),
_ => Err(SerdeError::from_str("invalid type: array, object"))
}
}
fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
self.deserialize_string(visitor)
}
fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
drop(self);
visitor.visit_unit()
}
}
impl<'de> serde::Deserializer<'de> for &RefValue {
type Error = SerdeError;
#[inline]
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'de> {
match self {
RefValue::Null => visitor.visit_unit(),
RefValue::Bool(v) => visitor.visit_bool(*v),
RefValue::Number(n) => {
n.deserialize_any(visitor).map_err(|e| SerdeError::new(format!("{:?}", e)))
}
RefValue::String(v) => visitor.visit_string(v.to_string()),
RefValue::Array(array) => visit_array(to_vec(array), visitor),
RefValue::Object(object) => {
visit_object(to_map(object), visitor)
}
}
}
deserialize_prim_number!(deserialize_i8);
deserialize_prim_number!(deserialize_i16);
deserialize_prim_number!(deserialize_i32);
deserialize_prim_number!(deserialize_i64);
deserialize_prim_number!(deserialize_u8);
deserialize_prim_number!(deserialize_u16);
deserialize_prim_number!(deserialize_u32);
deserialize_prim_number!(deserialize_u64);
deserialize_prim_number!(deserialize_f32);
deserialize_prim_number!(deserialize_f64);
#[inline]
fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
match self {
RefValue::Null => visitor.visit_none(),
_ => visitor.visit_some(self),
}
}
#[inline]
fn deserialize_enum<V>(
self,
_name: &str,
_variants: &'static [&'static str],
visitor: V,
) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
let (variant, value) = match self {
RefValue::Object(value) => {
let mut iter = value.into_iter();
let (variant, value) = match iter.next() {
Some(v) => v,
None => {
return Err(SerdeError::from_str("map with a single key"));
}
};
if iter.next().is_some() {
return Err(SerdeError::from_str("map with a single key"));
}
(variant, Some(value))
}
RefValue::String(variant) => (variant, None),
_ => {
return Err(SerdeError::from_str("string or map"));
}
};
visitor.visit_enum(EnumDeserializer {
variant: variant.to_string(),
value: match value {
Some(v) => Some(v.clone()),
_ => None
},
})
}
#[inline]
fn deserialize_newtype_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
let _ = name;
visitor.visit_newtype_struct(self)
}
fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
match self {
RefValue::Bool(v) => visitor.visit_bool(*v),
_ => Err(SerdeError::from_str("invalid type: bool")),
}
}
fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
self.deserialize_string(visitor)
}
fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
self.deserialize_string(visitor)
}
fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
match self {
RefValue::String(v) => visitor.visit_string(v.to_string()),
_ => Err(SerdeError::from_str("invalid type: string")),
}
}
fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
self.deserialize_byte_buf(visitor)
}
fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
match self {
RefValue::String(v) => visitor.visit_string(v.to_string()),
RefValue::Array(vec) => visit_array(to_vec(vec), visitor),
_ => Err(SerdeError::from_str("invalid type: string or array")),
}
}
fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
match self {
RefValue::Null => visitor.visit_unit(),
_ => Err(SerdeError::from_str("invalid type: null")),
}
}
fn deserialize_unit_struct<V>(
self,
_name: &'static str,
visitor: V,
) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
self.deserialize_unit(visitor)
}
fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
match self {
RefValue::Array(vec) => visit_array(to_vec(vec), visitor),
_ => Err(SerdeError::from_str("invalid type: array")),
}
}
fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
self.deserialize_seq(visitor)
}
fn deserialize_tuple_struct<V>(
self,
_name: &'static str,
_len: usize,
visitor: V,
) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
self.deserialize_seq(visitor)
}
fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
match self {
RefValue::Object(object) => {
visit_object(to_map(object), visitor)
}
_ => Err(SerdeError::from_str("invalid type: object"))
}
}
fn deserialize_struct<V>(
self,
_name: &'static str,
_fields: &'static [&'static str],
visitor: V,
) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
match self {
RefValue::Array(vec) => visit_array(to_vec(vec), visitor),
RefValue::Object(object) => {
visit_object(to_map(object), visitor)
}
_ => Err(SerdeError::from_str("invalid type: array, object"))
}
}
fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
self.deserialize_string(visitor)
}
fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
drop(self);
visitor.visit_unit()
}
}
struct SeqDeserializer {
iter: vec::IntoIter<RefValueWrapper>,
}
impl SeqDeserializer {
fn new(vec: Vec<RefValueWrapper>) -> Self {
SeqDeserializer {
iter: vec.into_iter(),
}
}
}
impl<'de> serde::Deserializer<'de> for SeqDeserializer {
type Error = SerdeError;
#[inline]
fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
let len = self.iter.len();
if len == 0 {
visitor.visit_unit()
} else {
let ret = visitor.visit_seq(&mut self)?;
let remaining = self.iter.len();
if remaining == 0 {
Ok(ret)
} else {
Err(SerdeError::from_str("fewer elements in array"))
}
}
}
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
}
}
impl<'de> SeqAccess<'de> for SeqDeserializer {
type Error = SerdeError;
fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
where
T: serde::de::DeserializeSeed<'de>,
{
match self.iter.next() {
Some(value) => seed.deserialize(value.deref()).map(Some),
None => Ok(None),
}
}
fn size_hint(&self) -> Option<usize> {
match self.iter.size_hint() {
(lower, Some(upper)) if lower == upper => Some(upper),
_ => None,
}
}
}
struct MapDeserializer {
iter: <IndexMap<String, RefValueWrapper> as IntoIterator>::IntoIter,
value: Option<RefValueWrapper>,
}
impl MapDeserializer {
fn new(map: IndexMap<String, RefValueWrapper>) -> Self {
MapDeserializer {
iter: map.into_iter(),
value: None,
}
}
}
impl<'de> MapAccess<'de> for MapDeserializer {
type Error = SerdeError;
fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
where
T: DeserializeSeed<'de>,
{
match self.iter.next() {
Some((key, value)) => {
self.value = Some(value);
let key_de = MapKeyDeserializer {
key: Cow::Owned(key),
};
seed.deserialize(key_de).map(Some)
}
None => Ok(None),
}
}
fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
where
T: DeserializeSeed<'de>,
{
match self.value.take() {
Some(value) => seed.deserialize(value.deref()),
None => Err(serde::de::Error::custom("value is missing")),
}
}
fn size_hint(&self) -> Option<usize> {
match self.iter.size_hint() {
(lower, Some(upper)) if lower == upper => Some(upper),
_ => None,
}
}
}
impl<'de> serde::Deserializer<'de> for MapDeserializer {
type Error = SerdeError;
#[inline]
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
visitor.visit_map(self)
}
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
}
}
struct MapKeyDeserializer<'de> {
key: Cow<'de, str>,
}
macro_rules! deserialize_integer_key {
($method:ident => $visit:ident) => {
fn $method<V>(self, visitor: V) -> Result<V::Value, SerdeError>
where
V: Visitor<'de>,
{
match (self.key.parse(), self.key) {
(Ok(integer), _) => visitor.$visit(integer),
(Err(_), Cow::Borrowed(s)) => visitor.visit_borrowed_str(s),
(Err(_), Cow::Owned(s)) => visitor.visit_string(s),
}
}
}
}
impl<'de> serde::Deserializer<'de> for MapKeyDeserializer<'de> {
type Error = SerdeError;
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
BorrowedCowStrDeserializer::new(self.key).deserialize_any(visitor)
}
deserialize_integer_key!(deserialize_i8 => visit_i8);
deserialize_integer_key!(deserialize_i16 => visit_i16);
deserialize_integer_key!(deserialize_i32 => visit_i32);
deserialize_integer_key!(deserialize_i64 => visit_i64);
deserialize_integer_key!(deserialize_u8 => visit_u8);
deserialize_integer_key!(deserialize_u16 => visit_u16);
deserialize_integer_key!(deserialize_u32 => visit_u32);
deserialize_integer_key!(deserialize_u64 => visit_u64);
serde_if_integer128! {
deserialize_integer_key!(deserialize_i128 => visit_i128);
deserialize_integer_key!(deserialize_u128 => visit_u128);
}
#[inline]
fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
// Map keys cannot be null.
visitor.visit_some(self)
}
#[inline]
fn deserialize_newtype_struct<V>(
self,
_name: &'static str,
visitor: V,
) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
visitor.visit_newtype_struct(self)
}
fn deserialize_enum<V>(
self,
name: &'static str,
variants: &'static [&'static str],
visitor: V,
) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
self.key
.into_deserializer()
.deserialize_enum(name, variants, visitor)
}
forward_to_deserialize_any! {
bool f32 f64 char str string bytes byte_buf unit unit_struct seq tuple
tuple_struct map struct identifier ignored_any
}
}
struct BorrowedCowStrDeserializer<'de> {
value: Cow<'de, str>,
}
impl<'de> BorrowedCowStrDeserializer<'de> {
fn new(value: Cow<'de, str>) -> Self {
BorrowedCowStrDeserializer { value: value }
}
}
impl<'de> serde::Deserializer<'de> for BorrowedCowStrDeserializer<'de> {
type Error = SerdeError;
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: serde::de::Visitor<'de>,
{
match self.value {
Cow::Borrowed(string) => visitor.visit_borrowed_str(string),
Cow::Owned(string) => visitor.visit_string(string),
}
}
fn deserialize_enum<V>(
self,
_name: &str,
_variants: &'static [&'static str],
visitor: V,
) -> Result<V::Value, Self::Error>
where
V: serde::de::Visitor<'de>,
{
visitor.visit_enum(self)
}
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 identifier ignored_any
}
}
impl<'de> serde::de::EnumAccess<'de> for BorrowedCowStrDeserializer<'de> {
type Error = SerdeError;
type Variant = UnitOnly;
fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error>
where
T: serde::de::DeserializeSeed<'de>,
{
let value = seed.deserialize(self)?;
Ok((value, UnitOnly))
}
}
struct UnitOnly;
impl<'de> serde::de::VariantAccess<'de> for UnitOnly {
type Error = SerdeError;
fn unit_variant(self) -> Result<(), Self::Error> {
Ok(())
}
fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Self::Error>
where
T: serde::de::DeserializeSeed<'de>,
{
Err(SerdeError::from_str("newtype variant"))
}
fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Self::Error>
where
V: serde::de::Visitor<'de>,
{
Err(SerdeError::from_str("tuple variant"))
}
fn struct_variant<V>(
self,
_fields: &'static [&'static str],
_visitor: V,
) -> Result<V::Value, Self::Error>
where
V: serde::de::Visitor<'de>,
{
Err(SerdeError::from_str("struct variant"))
}
}
struct EnumDeserializer {
variant: String,
value: Option<RefValueWrapper>,
}
impl<'de> EnumAccess<'de> for EnumDeserializer {
type Error = SerdeError;
type Variant = VariantDeserializer;
fn variant_seed<V>(self, seed: V) -> Result<(V::Value, VariantDeserializer), Self::Error>
where
V: DeserializeSeed<'de>,
{
let variant = self.variant.into_deserializer();
let visitor = VariantDeserializer { value: self.value };
seed.deserialize(variant).map(|v| (v, visitor))
}
}
struct VariantDeserializer {
value: Option<RefValueWrapper>,
}
impl<'de> VariantAccess<'de> for VariantDeserializer {
type Error = SerdeError;
fn unit_variant(self) -> Result<(), Self::Error> {
match self.value {
Some(value) => Deserialize::deserialize(value.deref()),
None => Ok(()),
}
}
fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
where
T: DeserializeSeed<'de>,
{
match self.value {
Some(value) => seed.deserialize(value.deref()),
None => Err(SerdeError::from_str("newtype variant")),
}
}
fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
match self.value {
Some(ref_value) => {
match ref_value.deref() {
RefValue::Array(vec) => {
serde::Deserializer::deserialize_any(SeqDeserializer::new(to_vec(vec)), visitor)
}
_ => Err(SerdeError::from_str("tuple variant"))
}
}
None => Err(SerdeError::from_str("tuple variant")),
}
}
fn struct_variant<V>(
self,
_fields: &'static [&'static str],
visitor: V,
) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
match self.value {
Some(ref_value) => {
match ref_value.deref() {
RefValue::Object(vec) => {
serde::Deserializer::deserialize_any(MapDeserializer::new(to_map(vec)), visitor)
}
_ => Err(SerdeError::from_str("struct variant"))
}
}
_ => Err(SerdeError::from_str("struct variant")),
}
}
}

2
src/ref_value/mod.rs
View File

@ -1,4 +1,4 @@
pub mod model;
mod convert;
pub mod de;
pub mod ser;
pub mod serde_error;

65
src/ref_value/model.rs
View File

@ -3,10 +3,9 @@ use std::ops::Deref;
use std::sync::Arc;
use indexmap::map::IndexMap;
use serde::ser::Serialize;
use serde_json::{Number, Value};
use super::convert::*;
type TypeRefValue = Arc<Box<RefValue>>;
#[derive(Debug, PartialEq)]
@ -14,6 +13,15 @@ pub struct RefValueWrapper {
data: TypeRefValue
}
impl RefValueWrapper {
pub fn try_unwrap(self) -> RefValue {
match Arc::try_unwrap(self.data) {
Ok(ref_value) => *ref_value,
Err(e) => panic!("{:?}", e)
}
}
}
impl Eq for RefValueWrapper {}
impl Deref for RefValueWrapper {
@ -131,10 +139,10 @@ impl Hash for RefValue {
match self {
RefValue::Null => {
REF_VALUE_NULL.hash(state)
},
}
RefValue::Bool(b) => {
b.hash(state)
},
}
RefValue::Number(n) => {
if n.is_f64() {
n.as_f64().unwrap().to_string().hash(state)
@ -146,7 +154,7 @@ impl Hash for RefValue {
}
RefValue::String(s) => {
s.hash(state)
},
}
RefValue::Object(map) => {
for (_, v) in map {
v.hash(state);
@ -246,20 +254,61 @@ impl Into<RefValueWrapper> for RefValue {
}
}
//impl Into<RefValue> for &RefValue {
// fn into(self) -> RefValue {
// match self {
// RefValue::Null => RefValue::Null,
// RefValue::Bool(b) => RefValue::Bool(*b),
// RefValue::String(s) => RefValue::String(s.to_string()),
// RefValue::Number(n) => {
// if n.is_f64() {
// RefValue::Number(n.as_u64().unwrap().into())
// } else if n.is_i64() {
// RefValue::Number(n.as_i64().unwrap().into())
// } else if n.is_u64() {
// RefValue::Number(n.as_u64().unwrap().into())
// } else {
// unreachable!()
// }
// }
// RefValue::Array(ay) => {
// let vec = ay.iter().map(|a| a.try_unwrap().into()).collect();
// RefValue::Array(vec)
// }
// RefValue::Object(map) => {
// let mut ret = IndexMap::new();
// for (k, v) in map {
// ret.insert(k.to_string(), v.try_unwrap().into());
// }
// RefValue::Object(ret)
// }
// }
// }
//}
impl Into<RefValueWrapper> for &Value {
fn into(self) -> RefValueWrapper {
RefValueConverter::new(&self)
match self.serialize(super::ser::Serializer) {
Ok(v) => v.into(),
Err(e) => panic!("Error Value into RefValue: {:?}", e)
}
}
}
impl Into<Value> for RefValueWrapper {
fn into(self) -> Value {
ValueConverter::new(&self)
match serde_json::to_value(self.deref()) {
Ok(v) => v,
Err(e) => panic!("Error RefValueWrapper into Value: {:?}", e)
}
}
}
impl Into<Value> for &RefValueWrapper {
fn into(self) -> Value {
ValueConverter::new(&self)
match serde_json::to_value(self.deref()) {
Ok(v) => v,
Err(e) => panic!("Error RefValueWrapper into Value: {:?}", e)
}
}
}

615
src/ref_value/ser.rs
View File

@ -1,13 +1,22 @@
use std::result::Result;
use indexmap::IndexMap;
use serde::{self, Serialize};
use serde::ser::Impossible;
use ref_value::model::{RefValue, RefValueWrapper};
use super::serde_error::SerdeError;
///
/// see `serde_json/value/ser.rs`
///
impl Serialize for RefValue {
#[inline]
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: serde::Serializer {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: ::serde::Serializer,
{
match *self {
RefValue::Null => serializer.serialize_unit(),
RefValue::Bool(b) => serializer.serialize_bool(b),
@ -17,14 +26,14 @@ impl Serialize for RefValue {
use std::ops::Deref;
let v: Vec<&RefValue> = v.iter().map(|v| v.deref()).collect();
v.serialize(serializer)
},
}
RefValue::Object(ref m) => {
use serde::ser::SerializeMap;
use std::ops::Deref;
let mut map = serializer.serialize_map(Some(m.len()))?;
let mut map = try!(serializer.serialize_map(Some(m.len())));
for (k, v) in m {
map.serialize_key(k)?;
map.serialize_value(v.deref())?;
try!(map.serialize_key(k));
try!(map.serialize_value(v.deref()));
}
map.end()
}
@ -32,32 +41,584 @@ impl Serialize for RefValue {
}
}
impl Serialize for RefValueWrapper {
pub struct Serializer;
impl serde::Serializer for Serializer {
type Ok = RefValue;
type Error = SerdeError;
type SerializeSeq = SerializeVec;
type SerializeTuple = SerializeVec;
type SerializeTupleStruct = SerializeVec;
type SerializeTupleVariant = SerializeTupleVariant;
type SerializeMap = SerializeMap;
type SerializeStruct = SerializeMap;
type SerializeStructVariant = SerializeStructVariant;
#[inline]
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: serde::Serializer {
use std::ops::Deref;
fn serialize_bool(self, value: bool) -> Result<RefValue, Self::Error> {
Ok(RefValue::Bool(value))
}
match *self.deref() {
RefValue::Null => serializer.serialize_unit(),
RefValue::Bool(b) => serializer.serialize_bool(b),
RefValue::Number(ref n) => n.serialize(serializer),
RefValue::String(ref s) => serializer.serialize_str(s),
RefValue::Array(ref v) => {
use std::ops::Deref;
let v: Vec<&RefValue> = v.iter().map(|v| v.deref()).collect();
v.serialize(serializer)
#[inline]
fn serialize_i8(self, value: i8) -> Result<RefValue, Self::Error> {
self.serialize_i64(value as i64)
}
#[inline]
fn serialize_i16(self, value: i16) -> Result<RefValue, Self::Error> {
self.serialize_i64(value as i64)
}
#[inline]
fn serialize_i32(self, value: i32) -> Result<RefValue, Self::Error> {
self.serialize_i64(value as i64)
}
fn serialize_i64(self, value: i64) -> Result<RefValue, Self::Error> {
Ok(RefValue::Number(value.into()))
}
#[inline]
fn serialize_u8(self, value: u8) -> Result<RefValue, Self::Error> {
self.serialize_u64(value as u64)
}
#[inline]
fn serialize_u16(self, value: u16) -> Result<RefValue, Self::Error> {
self.serialize_u64(value as u64)
}
#[inline]
fn serialize_u32(self, value: u32) -> Result<RefValue, Self::Error> {
self.serialize_u64(value as u64)
}
#[inline]
fn serialize_u64(self, value: u64) -> Result<RefValue, Self::Error> {
Ok(RefValue::Number(value.into()))
}
#[inline]
fn serialize_f32(self, value: f32) -> Result<RefValue, Self::Error> {
self.serialize_f64(value as f64)
}
#[inline]
fn serialize_f64(self, value: f64) -> Result<RefValue, Self::Error> {
Ok(serde_json::Number::from_f64(value).map_or(RefValue::Null, RefValue::Number))
}
#[inline]
fn serialize_char(self, value: char) -> Result<RefValue, Self::Error> {
let mut s = String::new();
s.push(value);
self.serialize_str(&s)
}
#[inline]
fn serialize_str(self, value: &str) -> Result<RefValue, Self::Error> {
Ok(RefValue::String(value.to_owned()))
}
fn serialize_bytes(self, value: &[u8]) -> Result<RefValue, Self::Error> {
let vec = value.iter().map(|&b| RefValue::Number(b.into()).into()).collect();
Ok(RefValue::Array(vec))
}
#[inline]
fn serialize_unit(self) -> Result<RefValue, Self::Error> {
Ok(RefValue::Null)
}
#[inline]
fn serialize_unit_struct(self, _name: &'static str) -> Result<RefValue, Self::Error> {
self.serialize_unit()
}
#[inline]
fn serialize_unit_variant(
self,
_name: &'static str,
_variant_index: u32,
variant: &'static str,
) -> Result<RefValue, Self::Error> {
self.serialize_str(variant)
}
#[inline]
fn serialize_newtype_struct<T: ?Sized>(
self,
_name: &'static str,
value: &T,
) -> Result<RefValue, Self::Error>
where
T: Serialize,
{
value.serialize(self)
}
fn serialize_newtype_variant<T: ?Sized>(
self,
_name: &'static str,
_variant_index: u32,
variant: &'static str,
value: &T,
) -> Result<RefValue, Self::Error>
where
T: Serialize,
{
let mut values: IndexMap<String, RefValueWrapper> = IndexMap::new();
values.insert(String::from(variant), {
value.serialize(Serializer)?.into()
});
Ok(RefValue::Object(values))
}
#[inline]
fn serialize_none(self) -> Result<RefValue, Self::Error> {
self.serialize_unit()
}
#[inline]
fn serialize_some<T: ?Sized>(self, value: &T) -> Result<RefValue, Self::Error>
where
T: Serialize,
{
value.serialize(self)
}
fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
Ok(SerializeVec {
vec: Vec::with_capacity(len.unwrap_or(0)),
})
}
fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
self.serialize_seq(Some(len))
}
fn serialize_tuple_struct(
self,
_name: &'static str,
len: usize,
) -> Result<Self::SerializeTupleStruct, Self::Error> {
self.serialize_seq(Some(len))
}
fn serialize_tuple_variant(
self,
_name: &'static str,
_variant_index: u32,
variant: &'static str,
len: usize,
) -> Result<Self::SerializeTupleVariant, Self::Error> {
Ok(SerializeTupleVariant {
name: String::from(variant),
vec: Vec::with_capacity(len),
})
}
fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
Ok(SerializeMap::Map {
map: IndexMap::new(),
next_key: None,
})
}
fn serialize_struct(
self,
name: &'static str,
len: usize,
) -> Result<Self::SerializeStruct, Self::Error> {
match name {
_ => self.serialize_map(Some(len)),
}
}
fn serialize_struct_variant(
self,
_name: &'static str,
_variant_index: u32,
variant: &'static str,
_len: usize,
) -> Result<Self::SerializeStructVariant, Self::Error> {
Ok(SerializeStructVariant {
name: String::from(variant),
map: IndexMap::new(),
})
}
}
pub struct SerializeVec {
vec: Vec<RefValueWrapper>,
}
pub struct SerializeTupleVariant {
name: String,
vec: Vec<RefValueWrapper>,
}
pub enum SerializeMap {
Map {
map: IndexMap<String, RefValueWrapper>,
next_key: Option<String>,
},
RefValue::Object(ref m) => {
use serde::ser::SerializeMap;
use std::ops::Deref;
let mut map = serializer.serialize_map(Some(m.len()))?;
for (k, v) in m {
map.serialize_key(k)?;
map.serialize_value(v.deref())?;
}
map.end()
pub struct SerializeStructVariant {
name: String,
map: IndexMap<String, RefValueWrapper>,
}
impl serde::ser::SerializeSeq for SerializeVec {
type Ok = RefValue;
type Error = SerdeError;
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
where
T: Serialize,
{
self.vec.push({
value.serialize(Serializer)?.into()
});
Ok(())
}
fn end(self) -> Result<RefValue, Self::Error> {
Ok(RefValue::Array(self.vec))
}
}
impl serde::ser::SerializeTuple for SerializeVec {
type Ok = RefValue;
type Error = SerdeError;
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
where
T: Serialize,
{
serde::ser::SerializeSeq::serialize_element(self, value)
}
fn end(self) -> Result<RefValue, Self::Error> {
serde::ser::SerializeSeq::end(self)
}
}
impl serde::ser::SerializeTupleStruct for SerializeVec {
type Ok = RefValue;
type Error = SerdeError;
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
where
T: Serialize,
{
serde::ser::SerializeSeq::serialize_element(self, value)
}
fn end(self) -> Result<RefValue, Self::Error> {
serde::ser::SerializeSeq::end(self)
}
}
impl serde::ser::SerializeTupleVariant for SerializeTupleVariant {
type Ok = RefValue;
type Error = SerdeError;
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
where
T: Serialize,
{
self.vec.push({
let a: RefValue = value.serialize(Serializer)?;
a.into()
});
Ok(())
}
fn end(self) -> Result<RefValue, Self::Error> {
let mut object: IndexMap<String, RefValueWrapper> = IndexMap::new();
object.insert(self.name, RefValue::Array(self.vec).into());
Ok(RefValue::Object(object))
}
}
impl serde::ser::SerializeMap for SerializeMap {
type Ok = RefValue;
type Error = SerdeError;
fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
where
T: Serialize,
{
match *self {
SerializeMap::Map {
ref mut next_key, ..
} => {
*next_key = Some(key.serialize(MapKeySerializer)?);
Ok(())
}
}
}
fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
where
T: Serialize,
{
match *self {
SerializeMap::Map {
ref mut map,
ref mut next_key,
} => {
let key = next_key.take();
// Panic because this indicates a bug in the program rather than an
// expected failure.
let key = key.expect("serialize_value called before serialize_key");
map.insert(key, {
let a: RefValue = value.serialize(Serializer)?;
a.into()
});
Ok(())
}
}
}
fn end(self) -> Result<RefValue, Self::Error> {
match self {
SerializeMap::Map { map, .. } => Ok(RefValue::Object(map)),
}
}
}
struct MapKeySerializer;
fn key_must_be_a_string() -> SerdeError {
SerdeError::from_str("key must be string")
}
impl serde::Serializer for MapKeySerializer {
type Ok = String;
type Error = SerdeError;
type SerializeSeq = Impossible<String, Self::Error>;
type SerializeTuple = Impossible<String, Self::Error>;
type SerializeTupleStruct = Impossible<String, Self::Error>;
type SerializeTupleVariant = Impossible<String, Self::Error>;
type SerializeMap = Impossible<String, Self::Error>;
type SerializeStruct = Impossible<String, Self::Error>;
type SerializeStructVariant = Impossible<String, Self::Error>;
#[inline]
fn serialize_unit_variant(
self,
_name: &'static str,
_variant_index: u32,
variant: &'static str,
) -> Result<Self::Ok, Self::Error> {
Ok(variant.to_owned())
}
#[inline]
fn serialize_newtype_struct<T: ?Sized>(
self,
_name: &'static str,
value: &T,
) -> Result<Self::Ok, Self::Error>
where
T: Serialize,
{
value.serialize(self)
}
fn serialize_bool(self, _value: bool) -> Result<Self::Ok, Self::Error> {
Err(key_must_be_a_string())
}
fn serialize_i8(self, value: i8) -> Result<Self::Ok, Self::Error> {
Ok(value.to_string())
}
fn serialize_i16(self, value: i16) -> Result<Self::Ok, Self::Error> {
Ok(value.to_string())
}
fn serialize_i32(self, value: i32) -> Result<Self::Ok, Self::Error> {
Ok(value.to_string())
}
fn serialize_i64(self, value: i64) -> Result<Self::Ok, Self::Error> {
Ok(value.to_string())
}
fn serialize_u8(self, value: u8) -> Result<Self::Ok, Self::Error> {
Ok(value.to_string())
}
fn serialize_u16(self, value: u16) -> Result<Self::Ok, Self::Error> {
Ok(value.to_string())
}
fn serialize_u32(self, value: u32) -> Result<Self::Ok, Self::Error> {
Ok(value.to_string())
}
fn serialize_u64(self, value: u64) -> Result<Self::Ok, Self::Error> {
Ok(value.to_string())
}
fn serialize_f32(self, _value: f32) -> Result<Self::Ok, Self::Error> {
Err(key_must_be_a_string())
}
fn serialize_f64(self, _value: f64) -> Result<Self::Ok, Self::Error> {
Err(key_must_be_a_string())
}
#[inline]
fn serialize_char(self, value: char) -> Result<Self::Ok, Self::Error> {
Ok({
let mut s = String::new();
s.push(value);
s
})
}
#[inline]
fn serialize_str(self, value: &str) -> Result<Self::Ok, Self::Error> {
Ok(value.to_owned())
}
fn serialize_bytes(self, _value: &[u8]) -> Result<Self::Ok, Self::Error> {
Err(key_must_be_a_string())
}
fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
Err(key_must_be_a_string())
}
fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
Err(key_must_be_a_string())
}
fn serialize_newtype_variant<T: ?Sized>(
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
_value: &T,
) -> Result<Self::Ok, Self::Error>
where
T: Serialize,
{
Err(key_must_be_a_string())
}
fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
Err(key_must_be_a_string())
}
fn serialize_some<T: ?Sized>(self, _value: &T) -> Result<Self::Ok, Self::Error>
where
T: Serialize,
{
Err(key_must_be_a_string())
}
fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
Err(key_must_be_a_string())
}
fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
Err(key_must_be_a_string())
}
fn serialize_tuple_struct(
self,
_name: &'static str,
_len: usize,
) -> Result<Self::SerializeTupleStruct, Self::Error> {
Err(key_must_be_a_string())
}
fn serialize_tuple_variant(
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
_len: usize,
) -> Result<Self::SerializeTupleVariant, Self::Error> {
Err(key_must_be_a_string())
}
fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
Err(key_must_be_a_string())
}
fn serialize_struct(
self,
_name: &'static str,
_len: usize,
) -> Result<Self::SerializeStruct, Self::Error> {
Err(key_must_be_a_string())
}
fn serialize_struct_variant(
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
_len: usize,
) -> Result<Self::SerializeStructVariant, Self::Error> {
Err(key_must_be_a_string())
}
}
impl serde::ser::SerializeStruct for SerializeMap {
type Ok = RefValue;
type Error = SerdeError;
fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
where
T: Serialize,
{
match *self {
SerializeMap::Map { .. } => {
serde::ser::SerializeMap::serialize_key(self, key)?;
serde::ser::SerializeMap::serialize_value(self, value)
}
}
}
fn end(self) -> Result<RefValue, Self::Error> {
match self {
SerializeMap::Map { .. } => serde::ser::SerializeMap::end(self),
}
}
}
impl serde::ser::SerializeStructVariant for SerializeStructVariant {
type Ok = RefValue;
type Error = SerdeError;
fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
where
T: Serialize,
{
self.map.insert(String::from(key), {
let a: RefValue = value.serialize(Serializer)?;
a.into()
});
Ok(())
}
fn end(self) -> Result<RefValue, Self::Error> {
let mut object: IndexMap<String, RefValueWrapper> = IndexMap::new();
object.insert(self.name, RefValue::Object(self.map).into());
Ok(RefValue::Object(object))
}
}

38
src/ref_value/serde_error.rs Normal file
View File

@ -0,0 +1,38 @@
use std::fmt;
#[derive(Debug)]
pub struct SerdeError {
msg: String,
}
impl<'a> SerdeError {
pub fn new(msg: String) -> Self {
SerdeError { msg: msg }
}
pub fn from_str(msg: &str) -> Self {
SerdeError { msg: msg.to_string() }
}
}
impl serde::de::Error for SerdeError {
#[cold]
fn custom<T: fmt::Display>(msg: T) -> SerdeError {
SerdeError { msg: msg.to_string() }
}
}
impl serde::ser::Error for SerdeError {
#[cold]
fn custom<T: fmt::Display>(msg: T) -> SerdeError {
SerdeError { msg: msg.to_string() }
}
}
impl std::error::Error for SerdeError {}
impl fmt::Display for SerdeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.msg)
}
}

4
tests/filter.rs
View File

@ -6,8 +6,8 @@ extern crate serde_json;
use std::io::Read;
use serde_json::Value;
use jsonpath::prelude::*;
use jsonpath::filter::value_filter::{ValueFilter, JsonValueFilter};
use jsonpath::parser::parser::Parser;
fn setup() {
let _ = env_logger::try_init();

34
tests/lib.rs
View File

@ -1,11 +1,13 @@
extern crate env_logger;
extern crate jsonpath_lib as jsonpath;
extern crate log;
extern crate serde;
#[macro_use]
extern crate serde_json;
use std::io::Read;
use serde::{Deserialize, Serialize};
use serde_json::Value;
fn read_json(path: &str) -> Value {
@ -89,3 +91,35 @@ fn select_str() {
let json: Value = serde_json::from_str(&result_str).unwrap();
assert_eq!(json, ret);
}
#[test]
fn test_to_struct() {
#[derive(Serialize, Deserialize, PartialEq, Debug)]
struct Person {
name: String,
age: u8,
phones: Vec<String>,
}
let ret: Person = jsonpath::select_as(r#"
{
"person":
{
"name": "Doe John",
"age": 44,
"phones": [
"+44 1234567",
"+44 2345678"
]
}
}
"#, "$.person").unwrap();
let person = Person {
name: "Doe John".to_string(),
age: 44,
phones: vec!["+44 1234567".to_string(), "+44 2345678".to_string()],
};
assert_eq!(person, ret);
}

3
tests/parser.rs
View File

@ -2,8 +2,7 @@ extern crate env_logger;
extern crate jsonpath_lib as jsonpath;
use std::result;
use jsonpath::prelude::*;
use jsonpath::parser::parser::{Parser, ParseToken, NodeVisitor, FilterToken};
struct NodeVisitorTestImpl<'a> {
input: &'a str,

4
tests/serde.rs
View File

@ -1,11 +1,11 @@
extern crate jsonpath_lib as jsonpath;
extern crate serde;
extern crate serde_json;
use std::io::Read;
use serde_json::Value;
use jsonpath::prelude::*;
use jsonpath::ref_value::model::{RefValue, RefValueWrapper};
fn read_json(path: &str) -> String {
let mut f = std::fs::File::open(path).unwrap();

2
tests/tokenizer.rs
View File

@ -1,6 +1,6 @@
extern crate jsonpath_lib as jsonpath;
use jsonpath::prelude::*;
use jsonpath::parser::tokenizer::{Tokenizer, Token, TokenError, PreloadedTokenizer};
fn collect_token(input: &str) -> (Vec<Token>, Option<TokenError>) {
let mut tokenizer = Tokenizer::new(input);

5
wasm/src/lib.rs
View File

@ -11,11 +11,14 @@ use std::result::Result;
use std::sync::Mutex;
use cfg_if::cfg_if;
use jsonpath::prelude::*;
use serde_json::Value;
use wasm_bindgen::prelude::*;
use web_sys::console;
use jsonpath::filter::value_filter::JsonValueFilter;
use jsonpath::parser::parser::{Node, NodeVisitor, Parser};
use jsonpath::ref_value::model::{RefValue, RefValueWrapper};
mod utils;
cfg_if! {