mirror of
https://github.com/fluencelabs/jsonpath
synced 2025-04-25 09:22:19 +00:00
Bump up 0.1.7
- select_as 추가
This commit is contained in:
freestrings
parent
a9f8f0bf4b
commit
8982e07421
@ -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
37
README.md
@ -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
|
||||
|
||||
@ -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();
|
||||
}
|
||||
});
|
||||
}
|
||||
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
14
docs/bench/bootstrap.js
vendored
14
docs/bench/bootstrap.js
vendored
@ -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
BIN
docs/bench/c615fa3fad4c084c8bcd.module.wasm
Normal file
Binary file not shown.
Binary file not shown.
14
docs/bootstrap.js
vendored
14
docs/bootstrap.js
vendored
@ -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
BIN
docs/c615fa3fad4c084c8bcd.module.wasm
Normal file
Binary file not shown.
Binary file not shown.
@ -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)
|
||||
}
|
||||
|
||||
@ -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 +0,0 @@
|
||||
pub use super::value_filter::*;
|
||||
@ -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
93
src/lib.rs
@ -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))
|
||||
}
|
||||
@ -1,4 +1,3 @@
|
||||
mod path_reader;
|
||||
mod tokenizer;
|
||||
mod parser;
|
||||
pub mod prelude;
|
||||
pub mod tokenizer;
|
||||
pub mod parser;
|
||||
@ -1,2 +0,0 @@
|
||||
pub use super::parser::*;
|
||||
pub use super::tokenizer::*;
|
||||
@ -1,3 +0,0 @@
|
||||
pub use parser::prelude::*;
|
||||
pub use filter::prelude::*;
|
||||
pub use ref_value::model::*;
|
||||
@ -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)
|
||||
}
|
||||
}
|
||||
@ -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")),
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,4 +1,4 @@
|
||||
pub mod model;
|
||||
mod convert;
|
||||
pub mod de;
|
||||
pub mod ser;
|
||||
pub mod serde_error;
|
||||
@ -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)
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -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)
|
||||
},
|
||||
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()
|
||||
#[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>,
|
||||
},
|
||||
}
|
||||
|
||||
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
38
src/ref_value/serde_error.rs
Normal 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)
|
||||
}
|
||||
}
|
||||
@ -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
34
tests/lib.rs
@ -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);
|
||||
}
|
||||
@ -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,
|
||||
|
||||
@ -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();
|
||||
|
||||
@ -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);
|
||||
|
||||
@ -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! {
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user