v0.2.0 - add: delete, replace feature. resolve #1. remove: map function.

.gitignore

@@ -3,3 +3,4 @@
 !.idea/runConfigurations/
 /target/
 Cargo.lock
+callgrind.out.*

.travis.yml

@@ -36,41 +36,41 @@ matrix:
       script:
         - cargo build --verbose --all
         - cargo test --verbose --all
-    - language: node_js
+#    - language: node_js
-      os: linux
+#      os: linux
-      node_js:
+#      node_js:
-        - '11'
+#        - '11'
-        - '10'
+#        - '10'
-        - '9'
+#        - '9'
-        - '8'
+#        - '8'
-      before_install:
+#      before_install:
-        - curl https://sh.rustup.rs -sSf > /tmp/rustup.sh
+#        - curl https://sh.rustup.rs -sSf > /tmp/rustup.sh
-        - sh /tmp/rustup.sh -y
+#        - sh /tmp/rustup.sh -y
-        - export PATH="$HOME/.cargo/bin:$PATH"
+#        - export PATH="$HOME/.cargo/bin:$PATH"
-        - source "$HOME/.cargo/env"
+#        - source "$HOME/.cargo/env"
-        - npm install -g neon-cli
+#        - npm install -g neon-cli
-        - cd nodejs
+#        - cd nodejs
-        - node -v
+#        - node -v
-        - npm -v
+#        - npm -v
-        - npm install
+#        - npm install
-      script:
+#      script:
-        - npm test
+#        - npm test
-    - language: node_js
+#    - language: node_js
-      os: osx
+#      os: osx
-      node_js:
+#      node_js:
-        - '11'
+#        - '11'
-        - '10'
+#        - '10'
-        - '9'
+#        - '9'
-        - '8'
+#        - '8'
-      before_install:
+#      before_install:
-        - curl https://sh.rustup.rs -sSf > /tmp/rustup.sh
+#        - curl https://sh.rustup.rs -sSf > /tmp/rustup.sh
-        - sh /tmp/rustup.sh -y
+#        - sh /tmp/rustup.sh -y
-        - export PATH="$HOME/.cargo/bin:$PATH"
+#        - export PATH="$HOME/.cargo/bin:$PATH"
-        - source "$HOME/.cargo/env"
+#        - source "$HOME/.cargo/env"
-        - npm install -g neon-cli
+#        - npm install -g neon-cli
-        - cd nodejs
+#        - cd nodejs
-        - node -v
+#        - node -v
-        - npm -v
+#        - npm -v
-        - npm install
+#        - npm install
-      script:
+#      script:
-        - npm test
+#        - npm test

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "jsonpath_lib"
-version = "0.1.13"
+version = "0.2.0"
 authors = ["Changseok Han <freestrings@gmail.com>"]
 
 description = "It is JsonPath engine written in Rust. it provide a similar API interface in Webassembly and Javascript also. - Webassembly Demo: https://freestrings.github.io/jsonpath"
@@ -23,6 +23,7 @@ env_logger = "0.6.0"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = { version = "1.0", features = ["preserve_order"] }
 indexmap = "1.0.2"
+array_tool = "~1.0.3"
 
 [dev-dependencies]
 bencher = "0.1.5"

README.md

@@ -15,43 +15,20 @@ It is JsonPath [JsonPath](https://goessner.net/articles/JsonPath/) engine writte
 
 ## Rust API
 
-- [jsonpath_lib crate](#jsonpath_lib-crate)
+<details><summary><b>jsonpath_lib crate</b></summary>
-- [Rust - jsonpath::Selector struct](#rust---jsonpathselector-struct)
-- [Rust - jsonpath::select(json: &serde_json::value::Value, jsonpath: &str)](#rust---jsonpathselectjson-serde_jsonvaluevalue-jsonpath-str)
-- [Rust - jsonpath::select_as_str(json_str: &str, jsonpath: &str)](#rust---jsonpathselect_as_strjson-str-jsonpath-str)
-- [Rust - jsonpath::select_as\<T: `serde::de::DeserializeOwned`\>(json_str: &str, jsonpath: &str)](#rust---jsonpathselect_ast-serdededeserializeownedjson-str-jsonpath-str)
-- [Rust - jsonpath::compile(jsonpath: &str)](#rust---jsonpathcompilejsonpath-str)
-- [Rust - jsonpath::selector(json: &serde_json::value::Value)](#rust---jsonpathselectorjson-serde_jsonvaluevalue)
-- [Rust - jsonpath::selector_as\<T: `serde::de::DeserializeOwned`\>(json: &serde_json::value::Value)](#rust---jsonpathselector_ast-serdededeserializeownedjson-serde_jsonvaluevalue)
-- [Rust - Other Examples](https://github.com/freestrings/jsonpath/wiki/rust-examples)
 
-## Javascript API
+Go to [`jsonpath_lib` creates.io](https://crates.io/crates/jsonpath_lib)
-
-- [npm package](#npm-package)
-- [Javascript - jsonpath.Selector class](#javascript---selector-class)
-- [Javascript - jsonpath.select(json: string|object, jsonpath: string)](#javascript---jsonpathselectjson-stringobject-jsonpath-string)
-- [Javascript - jsonpath.compile(jsonpath: string)](#javascript---jsonpathcompilejsonpath-string)
-- [Javascript - jsonpath.selector(json: string|object)](#javascript---jsonpathselectorjson-stringobject)
-- [Javascript - allocJson, deallocJson (Webassembly Only)](#javascript---allocjson-deallocjson-webassembly-only)
-- [Javascript - Other Examples](https://github.com/freestrings/jsonpath/wiki/Javascript-examples)
-
----
-
-### Rust API
-
-#### jsonpath_lib crate
-[Go to creates.io](https://crates.io/crates/jsonpath_lib)
 
 ```rust
 extern crate jsonpath_lib as jsonpath;
-#[macro_use]
-extern crate serde_json;
 ```
 
-#### Rust - jsonpath::Selector struct
+</details>
+
+<details><summary><b>Rust - jsonpath::Selector struct</b></summary>
 
 ```rust
-#[derive(Serialize, Deserialize, PartialEq, Debug)]
+#[derive(Deserialize, PartialEq, Debug)]
 struct Friend {
     name: String,
     age: Option<u8>,
@@ -73,46 +50,67 @@ let mut selector = Selector::new();
 
 let result = selector
     .path("$..[?(@.age >= 30)]").unwrap()
-//    .value_from_str(&serde_json::to_string(&json_obj).unwrap() /*&str*/).unwrap()
+    .value(&json_obj)
-//    .value_from(&json_obj /*&impl serde::ser::Serialize*/).unwrap()
+    .select().unwrap();
-    .value(&json_obj /*serde_json::value::Value*/).unwrap()
-    .select_as_value().unwrap();
 
-assert_eq!(json!([{"name": "친구3", "age": 30}]), result);
+assert_eq!(vec![&json!({"name": "친구3", "age": 30})], result);
 
 let result = selector.select_as_str().unwrap();
 assert_eq!(r#"[{"name":"친구3","age":30}]"#, result);
 
-let result = selector.select_as::<Vec<Friend>>().unwrap();
+let result = selector.select_as::<Friend>().unwrap();
 assert_eq!(vec![Friend { name: "친구3".to_string(), age: Some(30) }], result);
-
-let _ = selector.map(|v| {
-    let r = match v {
-        Value::Array(mut vec) => {
-            for mut v in &mut vec {
-                v.as_object_mut().unwrap().remove("age");
-            }
-            Value::Array(vec)
-        }
-        _ => Value::Null
-    };
-    Some(r)
-});
-assert_eq!(json!([{ "name": "친구3" }]), selector.get().unwrap());
-
-let _ = selector.value(&json_obj).unwrap()
-    .map_as(|mut v: Vec<Friend>| {
-        let mut f = v.pop().unwrap();
-        f.name = "friend3".to_string();
-        f.age = None;
-        Some(vec![f])
-    });
-
-assert_eq!(vec![Friend { name: "friend3".to_string(), age: None }],
-           selector.get_as::<Vec<Friend>>().unwrap());
 ```
 
-#### Rust - jsonpath::select(json: &serde_json::value::Value, jsonpath: &str)
+</details>
+
+<details><summary><b>Rust - jsonpath::SelectorMut struct</b></summary>
+
+```rust
+let json_obj = json!({
+    "school": {
+        "friends": [
+            {"name": "친구1", "age": 20},
+            {"name": "친구2", "age": 20}
+        ]
+    },
+    "friends": [
+        {"name": "친구3", "age": 30},
+        {"name": "친구4"}
+]});
+
+let mut selector_mut = SelectorMut::new();
+
+let result = selector_mut
+    .str_path("$..[?(@.age == 20)].age").unwrap()
+    .value(json_obj)
+    .replace_with(&mut |v| {
+        let age = if let Value::Number(n) = v {
+            n.as_u64().unwrap() * 2
+        } else {
+            0
+        };
+
+        json!(age)
+    }).unwrap()
+    .take().unwrap();
+
+assert_eq!(result, json!({
+    "school": {
+        "friends": [
+            {"name": "친구1", "age": 40},
+            {"name": "친구2", "age": 40}
+        ]
+    },
+    "friends": [
+        {"name": "친구3", "age": 30},
+        {"name": "친구4"}
+]}));
+```
+
+</details>
+
+<details><summary><b>Rust - jsonpath::select(json: &serde_json::value::Value, jsonpath: &str)</b></summary>
 
 ```rust
 let json_obj = json!({
@@ -129,14 +127,16 @@ let json_obj = json!({
 
 let json = jsonpath::select(&json_obj, "$..friends[0]").unwrap();
 
-let ret = json!([
+assert_eq!(json, vec![
-    {"name": "친구3", "age": 30},
+    &json!({"name": "친구3", "age": 30}),
-    {"name": "친구1", "age": 20}
+    &json!({"name": "친구1", "age": 20})
 ]);
-assert_eq!(json, ret);
 ```
 
-#### Rust - jsonpath::select_as_str(json: &str, jsonpath: &str)
+</details>
+
+
+<details><summary><b>Rust - jsonpath::select_as_str(json_str: &str, jsonpath: &str)</b></summary>
 
 ```rust
 let ret = jsonpath::select_as_str(r#"
@@ -157,7 +157,9 @@ let ret = jsonpath::select_as_str(r#"
 assert_eq!(ret, r#"[{"name":"친구3","age":30},{"name":"친구1","age":20}]"#);
 ```
 
-#### Rust - jsonpath::select_as\<T: `serde::de::DeserializeOwned`\>(json: &str, jsonpath: &str)
+</details>
+
+<details><summary><b>Rust - jsonpath::select_as&lt;T: `serde::de::DeserializeOwned`&gt;(json_str: &str, jsonpath: &str)</b></summary>
 
 ```rust
 #[derive(Deserialize, PartialEq, Debug)]
@@ -167,7 +169,7 @@ struct Person {
     phones: Vec<String>,
 }
 
-let ret: Person = jsonpath::select_as(r#"
+let ret: Vec<Person> = jsonpath::select_as(r#"
 {
     "person":
         {
@@ -187,10 +189,12 @@ let person = Person {
     phones: vec!["+44 1234567".to_string(), "+44 2345678".to_string()],
 };
 
-assert_eq!(person, ret);
+assert_eq!(ret[0], person);
 ```
 
-#### Rust - jsonpath::compile(jsonpath: &str)
+</details>
+
+<details><summary><b>Rust - jsonpath::compile(jsonpath: &str)</b></summary>
 
 ```rust
 let mut template = jsonpath::compile("$..friends[0]");
@@ -209,15 +213,15 @@ let json_obj = json!({
 
 let json = template(&json_obj).unwrap();
 
-let ret = json!([
+assert_eq!(json, vec![
-    {"name": "친구3", "age": 30},
+    &json!({"name": "친구3", "age": 30}),
-    {"name": "친구1", "age": 20}
+    &json!({"name": "친구1", "age": 20})
 ]);
-
-assert_eq!(json, ret);
 ```
 
-#### Rust - jsonpath::selector(json: &serde_json::value::Value)
+</details>
+
+<details><summary><b>Rust - jsonpath::selector(json: &serde_json::value::Value)</b></summary>
 
 ```rust
 let json_obj = json!({
@@ -236,24 +240,22 @@ let mut selector = jsonpath::selector(&json_obj);
 
 let json = selector("$..friends[0]").unwrap();
 
-let ret = json!([
+assert_eq!(json, vec![
-    {"name": "친구3", "age": 30},
+    &json!({"name": "친구3", "age": 30}),
-    {"name": "친구1", "age": 20}
+    &json!({"name": "친구1", "age": 20})
 ]);
 
-assert_eq!(json, ret);
-
 let json = selector("$..friends[1]").unwrap();
 
-let ret = json!([
+assert_eq!(json, vec![
-    {"name": "친구4"},
+    &json!({"name": "친구4"}),
-    {"name": "친구2", "age": 20}
+    &json!({"name": "친구2", "age": 20})
 ]);
-
-assert_eq!(json, ret);
 ```
 
-#### Rust - jsonpath::selector_as\<T: `serde::de::DeserializeOwned`\>(json: &serde_json::value::Value)
+</details>
+
+<details><summary><b>Rust - jsonpath::selector_as&lt;T: serde::de::DeserializeOwned&gt;(json: &serde_json::value::Value)</b></summary>
 
 ```rust
 let json_obj = json!({
@@ -268,13 +270,13 @@ let json_obj = json!({
         {"name": "친구4"}
 ]});
 
-#[derive(Serialize, Deserialize, PartialEq, Debug)]
+#[derive(Deserialize, PartialEq, Debug)]
 struct Friend {
     name: String,
     age: Option<u8>,
 }
 
-let mut selector = jsonpath::selector_as::<Vec<Friend>>(&json_obj);
+let mut selector = jsonpath::selector_as::<Friend>(&json_obj);
 
 let json = selector("$..friends[0]").unwrap();
 
@@ -294,14 +296,90 @@ let ret = vec!(
 assert_eq!(json, ret);
 ```
 
----
+</details>
 
-### Javascript API
+<details><summary><b>Rust - jsonpath::delete(value: &Value, path: &str)</b></summary>
 
-#### npm package
+```rust
+let json_obj = json!({
+    "school": {
+        "friends": [
+            {"name": "친구1", "age": 20},
+            {"name": "친구2", "age": 20}
+        ]
+    },
+    "friends": [
+        {"name": "친구3", "age": 30},
+        {"name": "친구4"}
+]});
+
+let ret = jsonpath::delete(json_obj, "$..[?(20 == @.age)]").unwrap();
+
+assert_eq!(ret, json!({
+    "school": {
+        "friends": [
+            null,
+            null
+        ]
+    },
+    "friends": [
+        {"name": "친구3", "age": 30},
+        {"name": "친구4"}
+]}));
+```
+
+</details>
+
+<details><summary><b>Rust - jsonpath::replace_with&lt;F: FnMut(&Value) -> Value&gt;(value: &Value, path: &str, fun: &mut F)</b></summary>
+
+```rust
+let json_obj = json!({
+    "school": {
+        "friends": [
+            {"name": "친구1", "age": 20},
+            {"name": "친구2", "age": 20}
+        ]
+    },
+    "friends": [
+        {"name": "친구3", "age": 30},
+        {"name": "친구4"}
+]});
+
+let ret = jsonpath::replace_with(json_obj, "$..[?(@.age == 20)].age", &mut |v| {
+    let age = if let Value::Number(n) = v {
+        n.as_u64().unwrap() * 2
+    } else {
+        0
+    };
+
+    json!(age)
+}).unwrap();
+
+assert_eq!(ret, json!({
+    "school": {
+        "friends": [
+            {"name": "친구1", "age": 40},
+            {"name": "친구2", "age": 40}
+        ]
+    },
+    "friends": [
+        {"name": "친구3", "age": 30},
+        {"name": "친구4"}
+]}));
+```
+
+</details>
+
+[Rust - Other Examples](https://github.com/freestrings/jsonpath/wiki/rust-examples)
+
+## Javascript API
+
+<details><summary><b>npm package</b></summary>
 
 ##### jsonpath-wasm
 
+Goto [`jsonpath-wasm` npmjs.org](https://www.npmjs.com/package/jsonpath-wasm)
+
 ```javascript
 // browser
 import * as jsonpath from "jsonpath-wasm";
@@ -311,13 +389,15 @@ const jsonpath = require('jsonpath-wasm');
 
 ##### jsonpath-rs (NodeJS only)
 
-[Goto npmjs.org](https://www.npmjs.com/package/jsonpath-rs)
+Goto [`jsonpath-rs` npmjs.org](https://www.npmjs.com/package/jsonpath-rs)
 
 ```javascript
 const jsonpath = require('jsonpath-rs');
 ```
 
-#### javascript - Selector class
+</details>
+
+<details><summary><b>Javascript - jsonpath.Selector class</b></summary>
 
 ##### jsonpath-wasm
 `wasm-bindgen` 리턴 타입 제약 때문에 빌더 패턴은 지원하지 않는다.
@@ -347,21 +427,10 @@ let selector = new jsonpath.Selector();
 selector.path('$..friends[0]');
 selector.value(jsonObj);
 
-let selectAsObj = selector.selectAs();
+let retObj = selector.select();
-let selectAsString = selector.selectAsStr();
 
-console.log(
+console.log(JSON.stringify(ret) == JSON.stringify(retObj));
-    JSON.stringify(ret) == JSON.stringify(selectAsObj),
-    JSON.stringify(ret) == selectAsString
-);
 
-selector.map(function(v) {
-    let f1 = v[0];
-    f1.name = 'friend3';
-    return [f1];
-});
-
-console.log(JSON.stringify(selector.get()) === JSON.stringify([{"name": "friend3", "age": 30}]));
 // => true
 ```
 
@@ -390,18 +459,82 @@ let selector = new jsonpath.Selector()
     .path('$..friends[0]')
     .value(jsonObj);
 
-let selectAsObj = selector.selectAs();
+let retObj = selector.select();
-let selectAsString = selector.selectAsStr();
 
-console.log(
+console.log(JSON.stringify(ret) == JSON.stringify(retObj));
-    JSON.stringify(ret) == JSON.stringify(selectAsObj),
-    JSON.stringify(ret) == selectAsString
-);
 
-// => true, true
+// => true
 ```
 
-#### Javascript - jsonpath.select(json: string|object, jsonpath: string)
+</details>
+
+<details><summary><b>Javascript - jsonpath.SelectorMut class</b></summary>
+
+`since 0.2.0`
+
+빌더 패턴 제약은 `Selector class`와 동일하다.
+
+```javascript
+let jsonObj = {
+    'school': {
+        'friends': [
+            {'name': '친구1', 'age': 20},
+            {'name': '친구2', 'age': 20},
+        ],
+    },
+    'friends': [
+        {'name': '친구3', 'age': 30},
+        {'name': '친구4'},
+    ],
+};
+
+let selector = new jsonpath.SelectorMut();
+selector.path('$..[?(@.age == 20)]');
+
+{
+    selector.value(jsonObj);
+    selector.deleteValue();
+
+    let resultObj = {
+        'school': {'friends': [null, null]},
+        'friends': [
+            {'name': '친구3', 'age': 30},
+            {'name': '친구4'},
+        ],
+    };
+    console.log(JSON.stringify(selector.take()) !== JSON.stringify(resultObj));
+    
+    // => true
+}
+
+{
+    selector.value(jsonObj);
+    selector.replaceWith((v) => {
+        v.age = v.age * 2;
+        return v;
+    });
+
+    let resultObj = {
+        'school': {
+            'friends': [
+                {'name': '친구1', 'age': 40},
+                {'name': '친구2', 'age': 40},
+            ],
+        },
+        'friends': [
+            {'name': '친구3', 'age': 30},
+            {'name': '친구4'},
+        ],
+    };
+    console.log(JSON.stringify(selector.take()) !== JSON.stringify(resultObj));
+    
+    // => true
+}
+```
+
+</details>
+
+<details><summary><b>Javascript - jsonpath.select(json: string|object, jsonpath: string)</b></summary>
 
 ```javascript
 let jsonObj = {
@@ -434,7 +567,9 @@ console.log(
 // => true, true
 ```
 
-#### Javascript - jsonpath.compile(jsonpath: string)
+</details>
+
+<details><summary><b>Javascript - jsonpath.compile(jsonpath: string)</b></summary>
 
 ```javascript
 let template = jsonpath.compile('$..friends[0]');
@@ -493,7 +628,9 @@ console.log(
 // => true, true
 ```
     
-#### Javascript - jsonpath.selector(json: string|object)
+</details>
+
+<details><summary><b>Javascript - jsonpath.selector(json: string|object)</b></summary>
 
 ```javascript
 let jsonObj = {
@@ -534,14 +671,13 @@ console.log(
 // => true, true
 ```
 
-#### Javascript - allocJson, deallocJson (Webassembly Only)
+</details>
-wasm-bindgen은 Javascript와 Webassembly간 값을 주고받을 때 JSON 객체는 String으로 변환되기 때문에, 반복해서 사용되는 JSON 객체는 Webassembly 영역에 생성해 두면 성능에 도움이 된다.
 
-Since wasm-bindgen converts JSON objects to String when exchanging values between Javascript and Webassembly, creating frequently used JSON objects in the WebAssembly area helps performance.
+<details><summary><b>Javascript - jsonpath.deleteValue(json: string|object, path: string)</b></summary>
+
+`since 0.2.0`
 
 ```javascript
-const jsonpath = require('jsonpath-wasm');
-
 let jsonObj = {
     "school": {
         "friends": [
@@ -555,37 +691,60 @@ let jsonObj = {
     ]
 };
 
-// allocate jsonObj in webassembly
+let _1 = jsonpath.deleteValue(jsonObj, '$..friends[0]');
-let ptr = jsonpath.allocJson(jsonObj);
+let result = jsonpath.deleteValue(_1, '$..friends[1]');
 
-// `0` is invalid pointer
+console.log(JSON.stringify(result) !== JSON.stringify({
-if(ptr == 0) {
+    "school": { "friends": [null, null]},
-    console.error('invalid ptr'); 
+    "friends": [null, null]
-}
+}));
 
-let path = '$..friends[0]';
+// => true
-let template = jsonpath.compile(path);
-let selector = jsonpath.selector(jsonObj);
-// create selector as pointer
-let ptrSelector = jsonpath.selector(ptr);
 
-let ret1 = selector(path)
-let ret2 = ptrSelector(path)
-let ret3 = template(jsonObj);
-// select as pointer
-let ret4 = template(ptr);
-let ret5 = jsonpath.select(jsonObj, path);
-// select as pointer
-let ret6 = jsonpath.select(ptr, path);
-
-console.log(
-    JSON.stringify(ret1) == JSON.stringify(ret2),
-    JSON.stringify(ret1) == JSON.stringify(ret3),
-    JSON.stringify(ret1) == JSON.stringify(ret4),
-    JSON.stringify(ret1) == JSON.stringify(ret5),
-    JSON.stringify(ret1) == JSON.stringify(ret6));
-
-// => true true true true true
-
-jsonpath.deallocJson(ptr);
 ```
+
+</details>
+
+<details><summary><b>Javascript - jsonpath.replaceWith(json: string|object, path: string, fun: function(json: object) => json: object</b></summary>
+
+`since 0.2.0`
+
+```javascript
+let jsonObj = {
+    "school": {
+        "friends": [
+            {"name": "친구1", "age": 20},
+            {"name": "친구2", "age": 20}
+        ]
+    },
+    "friends": [
+        {"name": "친구3", "age": 30},
+        {"name": "친구4"}
+    ]
+};
+
+let result = jsonpath.replaceWith(jsonObj, '$..friends[0]', (v) => {
+    v.age = v.age * 2;
+    return v;
+});
+
+console.log(JSON.stringify(result) === JSON.stringify({
+    "school": {
+        "friends": [
+            {"name": "친구1", "age": 40},
+            {"name": "친구2", "age": 20}
+        ]
+    },
+    "friends": [
+        {"name": "친구3", "age": 60},
+        {"name": "친구4"}
+    ]
+}));
+
+// => true
+
+```
+
+</details>
+
+[Javascript - Other Examples](https://github.com/freestrings/jsonpath/wiki/Javascript-examples)

benches/bench.rs

@@ -1,18 +1,18 @@
 #![feature(test)]
+extern crate bencher;
 extern crate jsonpath_lib as jsonpath;
 extern crate serde;
 extern crate serde_json;
 extern crate test;
-extern crate bencher;
 
 use std::io::Read;
 
 use serde::Deserialize;
 use serde_json::Value;
 
+use jsonpath::{SelectorMut, Selector};
+
 use self::test::Bencher;
-use jsonpath::ref_value::model::RefValue;
-use serde::ser::Serialize;
 
 fn read_json(path: &str) -> String {
     let mut f = std::fs::File::open(path).unwrap();
@@ -101,28 +101,37 @@ fn bench_select_as(b: &mut Bencher) {
 
     b.iter(move || {
         for _ in 1..100 {
-            let _: Book = jsonpath::select_as(&json, r#"$..book[?(@.price<30 && @.category=="fiction")][0]"#).unwrap();
+            let _: Vec<Book> = jsonpath::select_as(&json, r#"$..book[?(@.price<30 && @.category=="fiction")][0]"#).unwrap();
         }
     });
 }
 
 #[bench]
-fn bench_serde_ser(b: &mut Bencher) {
+fn bench_delete(b: &mut Bencher) {
     let json = get_json();
+    let mut selector = SelectorMut::new();
+    let _ = selector.str_path(get_path());
 
     b.iter(move || {
         for _ in 1..100 {
-            let _: RefValue = json.serialize(jsonpath::ref_value::ser::Serializer).unwrap().into();
+            let _ = selector.value(json.clone()).delete();
         }
     });
 }
 
 #[bench]
-fn bench_serde_de(b: &mut Bencher) {
+fn bench_select_to_compare_with_delete(b: &mut Bencher) {
-    let json_string = get_string();
+    let json = &get_json();
-    let json_str = json_string.as_str();
 
-    b.iter(move || for _ in 1..100 {
+    let mut selector = Selector::new();
-        let _: RefValue = serde_json::from_str(json_str).unwrap();
+    let _ = selector.str_path(get_path());
+
+    b.iter(move || {
+        for _ in 1..100 {
+            let json = json.clone();
+            let mut s = Selector::new();
+            let _ = s.compiled_path(selector.node_ref().unwrap()).value(&json);
+            let _ = s.select();
+        }
     });
 }

benches/bench_example.rs

@@ -0,0 +1,89 @@
+#![feature(test)]
+extern crate bencher;
+extern crate jsonpath_lib as jsonpath;
+extern crate serde;
+extern crate serde_json;
+extern crate test;
+
+use std::io::Read;
+
+use serde_json::Value;
+
+use self::test::Bencher;
+
+fn read_json(path: &str) -> String {
+    let mut f = std::fs::File::open(path).unwrap();
+    let mut contents = String::new();
+    f.read_to_string(&mut contents).unwrap();
+    contents
+}
+
+fn get_string() -> String {
+    read_json("./benches/example.json")
+}
+
+fn get_json() -> Value {
+    let string = get_string();
+    serde_json::from_str(string.as_str()).unwrap()
+}
+
+fn get_path(i: usize) -> &'static str {
+    let paths = vec![
+        "$.store.book[*].author",   //0
+        "$..author",    //1
+        "$.store.*",    //2
+        "$.store..price",   //3
+        "$..book[2]",   //4
+        "$..book[-2]",  //5
+        "$..book[0,1]", //6
+        "$..book[:2]",  //7
+        "$..book[1:2]", //8
+        "$..book[-2:]", //9
+        "$..book[2:]",  //10
+        "$..book[?(@.isbn)]",   //11
+        "$.store.book[?(@.price == 10)]",    //12
+        "$..*", //13
+        "$..book[ ?( (@.price < 13 || $.store.bicycle.price < @.price) && @.price <=10 ) ]", //14
+        "$.store.book[?( (@.price < 10 || @.price > 10) && @.price > 10 )]"
+    ];
+    paths[i]
+}
+
+fn _selector(b: &mut Bencher, index: usize) {
+    let json = get_json();
+    b.iter(move || {
+        for _ in 1..100 {
+            let mut selector = jsonpath::Selector::new();
+            let _ = selector.str_path(get_path(index));
+            selector.value(&json);
+            let r = selector.select();
+            if r.is_err() {
+                panic!()
+            }
+        }
+    });
+}
+
+macro_rules! selector {
+    ($name:ident, $i:expr) => {
+        #[bench]
+        fn $name(b: &mut Bencher) { _selector(b, $i); }
+    };
+}
+
+selector!(example0_1, 0);
+selector!(example1_1, 1);
+selector!(example2_1, 2);
+selector!(example3_1, 3);
+selector!(example4_1, 4);
+selector!(example5_1, 5);
+selector!(example6_1, 6);
+selector!(example7_1, 7);
+selector!(example8_1, 8);
+selector!(example9_1, 9);
+selector!(example_10_1, 10);
+selector!(example_11_1, 11);
+selector!(example_12_1, 12);
+selector!(example_13_1, 13);
+selector!(example_14_1, 14);
+selector!(example_15_1, 15);

benches/bench_native.sh

@@ -35,8 +35,6 @@ __extra () {
     sleep 1
     cd "${DIR}"/javascript && echo "NodeJs - jsonpath-rs - compile: " && time ./bench.sh nativeCompile ${ITER}
     printf "\n"
-    sleep 1
-    cd "${DIR}"/javascript && echo "NodeJs - jsonpath-rs - selectorClassMap: " && time ./bench.sh nativeSelectorClassMap ${ITER}
 }
 
 if [ "$1" = "extra" ]; then

benches/bench_wasm.sh

@@ -36,13 +36,8 @@ __extra () {
     cd "${DIR}"/javascript && echo "NodeJs - jsonpath-wasm - compile: " && time ./bench.sh wasmCompile ${ITER}
     printf "\n"
     sleep 1
-    cd "${DIR}"/javascript && echo "NodeJs - jsonpath-wasm - compile-alloc: " && time ./bench.sh wasmCompileAlloc ${ITER}
-    printf "\n"
-    sleep 1
     cd "${DIR}"/javascript && echo "NodeJs - jsonpath-wasm - Selector: " && time ./bench.sh wasmSelectorClass ${ITER}
     printf "\n"
-    sleep 1
-    cd "${DIR}"/javascript && echo "NodeJs - jsonpath-wasm - Selector map: " && time ./bench.sh wasmSelectorClassMap ${ITER}
 }
 
 if [ "$1" = "extra" ]; then

benches/javascript/bench.js

@@ -71,13 +71,6 @@ function nativeSelect() {
     }
 }
 
-function nativeSelectorClassMap() {
-    let selector = new jpwRs.Selector();
-    for (var i = 0; i < iter; i++) {
-        let _ = selector.path(path).value(jsonStr).map((v) => v).get();
-    }
-}
-
 function wasmSelector() {
     let selector = jpw.selector(getJson());
     for (var i = 0; i < iter; i++) {
@@ -92,61 +85,18 @@ function wasmCompile() {
     }
 }
 
-function wasmCompileAlloc() {
-    let ptr = jpw.allocJson(getJson());
-    if (ptr == 0) {
-        console.error('Invalid pointer');
-        return;
-    }
-
-    try {
-        let template = jpw.compile(path);
-        for (var i = 0; i < iter; i++) {
-            let _ = template(ptr);
-        }
-    } finally {
-        jpw.deallocJson(ptr);
-    }
-}
-
 function wasmSelect() {
     for (var i = 0; i < iter; i++) {
         let _ = jpw.select(getJson(), path);
     }
 }
 
-function wasmSelectAlloc() {
-    let ptr = jpw.allocJson(getJson());
-    if (ptr == 0) {
-        console.error('Invalid pointer');
-        return;
-    }
-
-    try {
-        for (var i = 0; i < iter; i++) {
-            let _ = jpw.select(ptr, path);
-        }
-    } finally {
-        jpw.deallocJson(ptr);
-    }
-}
-
 function wasmSelectorClass() {
     let selector = new jpw.Selector();
     for (var i = 0; i < iter; i++) {
         selector.path(path);
         selector.value(jsonStr);
-        let _ = selector.selectToStr();
+        let _ = selector.select();
-    }
-}
-
-function wasmSelectorClassMap() {
-    let selector = new jpw.Selector();
-    for (var i = 0; i < iter; i++) {
-        selector.path(path);
-        selector.value(jsonStr);
-        let _1 = selector.map((v) => v);
-        let _2 = selector.get();
     }
 }
 

build-wasm.sh

@@ -0,0 +1,104 @@
+#!/bin/bash
+
+set -e
+
+# project_root
+DIR="$(pwd)"
+WASM="${DIR}"/wasm
+WASM_WWW="${WASM}"/www
+WASM_WWW_BENCH="${WASM}"/www_bench
+WASM_BROWSER_PKG="${WASM}"/browser_pkg
+WASM_NODEJS_PKG="${WASM}"/nodejs_pkg
+WASM_ALL_PKG="${WASM}"/all_pkg
+WASM_TEST="${WASM}"/tests
+DOCS="${DIR}"/docs
+DOCS_BENCH="${DOCS}"/bench
+
+__msg () {
+    echo ">>>>>>>>>>$1<<<<<<<<<<"
+}
+
+__cargo_clean () {
+    cd "${WASM}" && cargo clean && \
+    cd "${DIR}" && cargo clean
+}
+
+echo
+__msg "clean wasm"
+rm -rf \
+    "${WASM_NODEJS_PKG}" \
+    "${WASM_BROWSER_PKG}" \
+    "${WASM_ALL_PKG}" \
+    "${WASM_WWW}"/node_modules \
+    "${WASM_WWW_BENCH}"/node_modules \
+    "${WASM_WWW}"/dist \
+    "${WASM_WWW_BENCH}"/dist \
+    "${WASM_TEST}"/node_modules
+
+if [ "$1" = "all" ]; then
+    __msg "clean all wasm"
+    __cargo_clean
+fi
+
+__msg "npm install: wasm"
+cd "${WASM_WWW}" && npm install
+__msg "npm install: wasm_bench"
+cd "${WASM_WWW_BENCH}" && npm install
+__msg "npm install: wasm test"
+cd "${WASM_TEST}" && npm install
+
+echo
+echo
+__msg "wasm-pack"
+cd "${WASM}" && \
+    wasm-pack build --release --target=nodejs --out-dir "${WASM_NODEJS_PKG}"
+
+cd "${WASM}" && \
+    wasm-pack build --release --target=browser --out-dir "${WASM_BROWSER_PKG}"
+#    && \
+#    wasm-pack test --chrome --firefox --headless
+
+__msg "wasm npm packaging"
+cp -r "${WASM_BROWSER_PKG}" "${WASM_ALL_PKG}/" && \
+    sed "s/require[\(]'\.\/jsonpath_wasm_bg/require\('\.\/jsonpath_wasm_nodejs/" "${WASM_NODEJS_PKG}/jsonpath_wasm.js" \
+        > "${WASM_ALL_PKG}/jsonpath_wasm_main.js" && \
+    sed "s/require[\(]'\.\/jsonpath_wasm/require\('\.\/jsonpath_wasm_main/" "${WASM_NODEJS_PKG}/jsonpath_wasm_bg.js" \
+        > "${WASM_ALL_PKG}/jsonpath_wasm_nodejs.js" && \
+    jq ".files += [\"jsonpath_wasm_nodejs.js\"]" ${WASM_ALL_PKG}/package.json \
+        | jq ".main = \"jsonpath_wasm_main.js\"" \
+        | jq ".keywords += [\"jsonpath\", \"json\", \"webassembly\", \"parsing\", \"rust\"]" \
+        > ${WASM_ALL_PKG}/temp.json && \
+    mv -v "${WASM_ALL_PKG}/temp.json" "${WASM_ALL_PKG}/package.json" && \
+    cd "${WASM_ALL_PKG}" && npm link
+
+echo
+__msg "link"
+cd "${WASM_WWW}" && \
+    npm link jsonpath-wasm
+
+cd "${WASM_WWW_BENCH}" && \
+    npm link jsonpath-wasm
+
+cd "${WASM_TEST}" && \
+    npm link jsonpath-wasm
+
+echo
+echo
+__msg "wasm test"
+cd "${WASM_TEST}" && npm test
+
+if [ "$1" = "all" ] || [ "$1" = "docs" ]; then
+    echo
+    __msg "docs"
+    cd "${WASM_WWW}" && \
+        npm run build &&
+        rm -f "${DOCS}"/*.js "${DOCS}"/*.wasm "${DOCS}"/*.html && \
+        cp "${WASM_WWW}"/dist/*.* "${DOCS}"/
+
+    cd "${WASM_WWW_BENCH}" && \
+        npm run build &&
+        rm -f "${DOCS_BENCH}"/*.js "${DOCS_BENCH}"/*.wasm "${DOCS_BENCH}"/*.html && \
+        cp "${WASM_WWW_BENCH}"/dist/*.* "${DOCS_BENCH}"/
+fi
+
+__msg "wasm done"

nodejs/lib/index.js

@@ -1,4 +1,12 @@
-const { CompileFn, SelectorFn, selectStr, Selector: _Selector } = require('../native');
+const {
+    CompileFn,
+    SelectorFn,
+    selectStr,
+    deleteValue: _deleteValue,
+    replaceWith: _replaceWith,
+    Selector: _Selector,
+    SelectorMut: _SelectorMut
+} = require('../native');
 
 function compile(path) {
     let compile = new CompileFn(path);
@@ -27,6 +35,30 @@ function select(json, path) {
     return JSON.parse(selectStr(json, path));
 }
 
+function deleteValue(json, path) {
+    if(typeof json != 'string') {
+        json = JSON.stringify(json)
+    }
+    return JSON.parse(_deleteValue(json, path));
+}
+
+function replaceWith(json, path, fun) {
+    if(typeof json != 'string') {
+        json = JSON.stringify(json)
+    }
+    let result = _replaceWith(json, path, (v) => {
+        let result = fun(JSON.parse(v));
+        if(typeof result != 'string') {
+            result = JSON.stringify(result)
+        }
+        return result;
+    });
+    if(typeof result == 'string') {
+        result = JSON.parse(result);
+    }
+    return result;
+}
+
 class Selector {
     constructor() {
         this._selector = new _Selector();
@@ -42,39 +74,67 @@ class Selector {
         if(typeof json != 'string') {
             json = JSON.stringify(json)
         }
-        this._selector.valueFromStr(json);
+        this._selector.value(json);
         return this;
     }
 
-    selectToStr() {
+    select() {
-        return this.selectAsStr();
+        return JSON.parse(this._selector.select());
+    }
 }
 
-    selectTo() {
+class SelectorMut {
-        return this.selectAs();
+    constructor() {
-    }
-
-    selectAsStr() {
-        return this._selector.selectAsStr();
-    }
-
-    selectAs() {
-        return JSON.parse(this.selectAsStr());
-    }
-
-    map(func) {
-        this._selector.map((json) => {
-            var result = func.call(null, JSON.parse(json));
-            if(typeof result !== 'string') {
-                result = JSON.stringify(result);
-            }
-            return result;
-        });
         return this;
     }
 
-    get() {
+    path(path) {
-        return JSON.parse(this._selector.get());
+        this._path = path;
+        return this;
+    }
+
+    value(json) {
+        if(typeof json != 'string') {
+            json = JSON.stringify(json)
+        }
+        this._json = json;
+        return this;
+    }
+
+    deleteValue() {
+        let selector = new _SelectorMut();
+        if(!this._path) {
+            selector.emptyPathError();
+            return;
+        }
+
+        if(!this._json) {
+            selector.emptyValueError();
+            return;
+        }
+
+        this._json = deleteValue(this._json, this._path);
+        return this;
+    }
+
+    replaceWith(fun) {
+        let selector = new _SelectorMut();
+        if(!this._path) {
+            selector.emptyPathError();
+            return;
+        }
+        if(!this._json) {
+            selector.emptyValueError();
+            return;
+        }
+        this._json = replaceWith(this._json, this._path, fun);
+        return this;
+    }
+
+    take() {
+        let json = this._json;
+        delete this._json;
+        return json;
     }
 }
 
@@ -82,5 +142,8 @@ module.exports = {
     compile,
     selector,
     select,
-    Selector
+    deleteValue,
+    replaceWith,
+    Selector,
+    SelectorMut
 };

nodejs/native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "jsonpath4nodejs"
-version = "0.1.3"
+version = "0.2.0"
 authors = ["Changseok Han <freestrings@gmail.com>"]
 description = "jsonpath_lib bindings for nodejs"
 keywords = ["library", "jsonpath", "json", "nodejs"]
@@ -14,7 +14,8 @@ exclude = ["artifacts.json", "index.node"]
 neon-build = "0.2.0"
 
 [dependencies]
-jsonpath_lib = "0.1.13"
+jsonpath_lib = "0.2.0"
+#jsonpath_lib = { path = "../../" }
 neon = "0.2.0"
 neon-serde = "0.1.1"
 serde_json = { version = "1.0", features = ["preserve_order"] }

nodejs/native/src/lib.rs

@@ -4,13 +4,9 @@ extern crate neon;
 extern crate neon_serde;
 extern crate serde_json;
 
-use jsonpath::filter::value_filter::JsonValueFilter;
+use jsonpath::{JsonPathError, Node, Parser, Selector};
-use jsonpath::parser::parser::{Node, NodeVisitor, Parser};
-use jsonpath::ref_value::model::{RefValue, RefValueWrapper};
-use jsonpath::Selector;
 use neon::prelude::*;
 use serde_json::Value;
-use std::ops::Deref;
 
 ///
 /// `neon_serde::from_value` has very poor performance.
@@ -35,96 +31,176 @@ fn select_str(mut ctx: FunctionContext) -> JsResult<JsValue> {
     }
 }
 
-pub struct CompileFn {
+fn delete(mut ctx: FunctionContext) -> JsResult<JsValue> {
-    node: Node
+    let json_val = ctx.argument::<JsString>(0)?.value();
+    let json: Value = match serde_json::from_str(&json_val) {
+        Ok(value) => value,
+        Err(e) => panic!("{:?}", JsonPathError::Serde(e.to_string()))
+    };
+    let path = ctx.argument::<JsString>(1)?.value();
+    match jsonpath::delete(json, &path) {
+        Ok(value) => Ok(JsString::new(&mut ctx, match serde_json::to_string(&value) {
+            Ok(value) => value,
+            Err(e) => panic!("{:?}", JsonPathError::Serde(e.to_string()))
+        }).upcast()),
+        Err(e) => panic!("{:?}", e)
+    }
 }
 
-pub struct SelectorFn {
+fn replace_with(mut ctx: FunctionContext) -> JsResult<JsValue> {
-    json: RefValueWrapper
+    let json_val = ctx.argument::<JsString>(0)?.value();
+    let json: Value = match serde_json::from_str(&json_val) {
+        Ok(value) => value,
+        Err(e) => panic!("{:?}", JsonPathError::Serde(e.to_string()))
+    };
+    let path = ctx.argument::<JsString>(1)?.value();
+    let fun = ctx.argument::<JsFunction>(2)?;
+    match jsonpath::replace_with(json, &path, &mut |v| {
+        let json_str = JsString::new(&mut ctx, match serde_json::to_string(v) {
+            Ok(value) => value,
+            Err(e) => panic!("{:?}", JsonPathError::Serde(e.to_string()))
+        });
+
+        let null = ctx.null();
+        let args = vec![ctx.string(json_str.value())];
+        let result = match fun.call(&mut ctx, null, args) {
+            Ok(result) => result,
+            Err(e) => panic!("{:?}", e)
+        };
+        let json_str = match result.downcast::<JsString>() {
+            Ok(v) => v.value(),
+            Err(e) => panic!("{:?}", JsonPathError::Serde(e.to_string()))
+        };
+        match serde_json::from_str(&json_str) {
+            Ok(v) => v,
+            Err(e) => panic!("{:?}", JsonPathError::Serde(e.to_string()))
+        }
+    }) {
+        Ok(value) => Ok(JsString::new(&mut ctx, match serde_json::to_string(&value) {
+            Ok(value) => value,
+            Err(e) => panic!("{:?}", JsonPathError::Serde(e.to_string()))
+        }).upcast()),
+        Err(e) => panic!("{:?}", e)
+    }
 }
 
 pub struct SelectorCls {
-    selector: Selector
+    node: Option<Node>,
+    value: Option<Value>,
 }
 
-declare_types! {
+impl SelectorCls {
-    pub class JsCompileFn for CompileFn {
+    fn path(&mut self, path: &str) {
-        init(mut ctx) {
+        let node = match Parser::compile(path) {
-            let path = ctx.argument::<JsString>(0)?.value();
-            let mut parser = Parser::new(path.as_str());
-
-            let node = match parser.compile() {
             Ok(node) => node,
             Err(e) => panic!("{:?}", e)
         };
 
-            Ok(CompileFn { node })
+        self.node = Some(node);
+    }
+
+    fn value(&mut self, json_str: &str) {
+        let value: Value = match serde_json::from_str(&json_str) {
+            Ok(value) => value,
+            Err(e) => panic!("{:?}", JsonPathError::Serde(e.to_string()))
+        };
+
+        self.value = Some(value);
+    }
+
+    fn select(&self) -> String {
+        let node = match &self.node {
+            Some(node) => node,
+            None => panic!("{:?}", JsonPathError::EmptyPath)
+        };
+
+        let value = match &self.value {
+            Some(value) => value,
+            None => panic!("{:?}", JsonPathError::EmptyValue)
+        };
+
+        let mut selector = Selector::new();
+        selector.compiled_path(node);
+        selector.value(&value);
+        match selector.select_as_str() {
+            Ok(ret) => ret,
+            Err(e) => panic!("{:?}", e)
+        }
+    }
+}
+
+pub struct SelectorMutCls {}
+
+declare_types! {
+    pub class JsCompileFn for SelectorCls {
+        init(mut ctx) {
+            let path = ctx.argument::<JsString>(0)?.value();
+            let node = match Parser::compile(path.as_str()) {
+                Ok(node) => node,
+                Err(e) => panic!("{:?}", e)
+            };
+
+            Ok(SelectorCls { node: Some(node), value: None })
         }
 
         method template(mut ctx) {
-            let this = ctx.this();
+            let mut this = ctx.this();
 
-            let node = {
+            let json_str = ctx.argument::<JsString>(0)?.value();
+            {
+                let guard = ctx.lock();
+                let mut this = this.borrow_mut(&guard);
+                let value: Value = match serde_json::from_str(&json_str) {
+                    Ok(value) => value,
+                    Err(e) => panic!("{:?}", JsonPathError::Serde(e.to_string()))
+                };
+                this.value = Some(value);
+            };
+
+            let result_str = {
                 let guard = ctx.lock();
                 let this = this.borrow(&guard);
-                this.node.clone()
+                this.select()
             };
 
-            let json_str = ctx.argument::<JsString>(0)?.value();
+            Ok(JsString::new(&mut ctx, &result_str).upcast())
-            let ref_value: RefValue = match serde_json::from_str(&json_str) {
-                Ok(ref_value) => ref_value,
-                Err(e) => panic!("{:?}", e)
-            };
-
-            let mut jf = JsonValueFilter::new_from_value(ref_value.into());
-            jf.visit(node);
-            match serde_json::to_string(&jf.take_value().deref()) {
-                Ok(json_str) => Ok(JsString::new(&mut ctx, &json_str).upcast()),
-                Err(e) => panic!("{:?}", e)
-            }
         }
     }
 
-    pub class JsSelectorFn for SelectorFn {
+    pub class JsSelectorFn for SelectorCls {
         init(mut ctx) {
             let json_str = ctx.argument::<JsString>(0)?.value();
-            let ref_value: RefValue = match serde_json::from_str(&json_str) {
+            let value: Value = match serde_json::from_str(&json_str) {
-                Ok(ref_value) => ref_value,
+                Ok(value) => value,
-                Err(e) => panic!("{:?}", e)
+                Err(e) => panic!("{:?}", JsonPathError::Serde(e.to_string()))
             };
 
-            Ok(SelectorFn { json: ref_value.into() })
+            Ok(SelectorCls { node: None, value: Some(value) })
         }
 
         method select(mut ctx) {
-            let this = ctx.this();
+            let mut this = ctx.this();
-
-            let json = {
-                let guard = ctx.lock();
-                let this = this.borrow(&guard);
-                this.json.clone()
-            };
 
             let path = ctx.argument::<JsString>(0)?.value();
-            let mut parser = Parser::new(path.as_str());
+            {
+                let guard = ctx.lock();
+                let mut this = this.borrow_mut(&guard);
+                this.path(&path);
+            }
 
-            let node = match parser.compile() {
+            let result_str = {
-                Ok(node) => node,
+                let guard = ctx.lock();
-                Err(e) => panic!("{:?}", e)
+                let this = this.borrow(&guard);
+                this.select()
             };
 
-            let mut jf = JsonValueFilter::new_from_value(json);
+            Ok(JsString::new(&mut ctx, &result_str).upcast())
-            jf.visit(node);
-            match serde_json::to_string(&jf.take_value().deref()) {
-                Ok(json_str) => Ok(JsString::new(&mut ctx, &json_str).upcast()),
-                Err(e) => panic!("{:?}", e)
-            }
         }
     }
 
     pub class JsSelector for SelectorCls {
         init(mut _ctx) {
-            Ok(SelectorCls { selector: Selector::new() })
+            Ok(SelectorCls { node: None, value: None })
         }
 
         method path(mut ctx) {
@@ -134,80 +210,49 @@ declare_types! {
             {
                 let guard = ctx.lock();
                 let mut this = this.borrow_mut(&guard);
-                let _ = this.selector.path(&path);
+                let _ = this.path(&path);
             }
+
             Ok(JsUndefined::new().upcast())
         }
 
-        method valueFromStr(mut ctx) {
+        method value(mut ctx) {
             let mut this = ctx.this();
 
             let json_str = ctx.argument::<JsString>(0)?.value();
             {
                 let guard = ctx.lock();
                 let mut this = this.borrow_mut(&guard);
-                let _ = this.selector.value_from_str(&json_str);
+                let _ = this.value(&json_str);
-            }
-            Ok(JsUndefined::new().upcast())
-        }
-
-        method selectAsStr(mut ctx) {
-             let mut this = ctx.this();
-
-             let result = {
-                let guard = ctx.lock();
-                let this = this.borrow_mut(&guard);
-                this.selector.select_as_str()
-             };
-
-             match result {
-                Ok(json_str) => Ok(JsString::new(&mut ctx, &json_str).upcast()),
-                Err(e) => panic!("{:?}", e)
-             }
-        }
-
-        method map(mut ctx) {
-            let null = ctx.null();
-            let mut this = ctx.this();
-
-            let func = ctx.argument::<JsFunction>(0)?;
-
-            let value = {
-                let guard = ctx.lock();
-                let this = this.borrow_mut(&guard);
-                match this.selector.select_as_str() {
-                    Ok(v) => v,
-                    Err(e) => panic!("{:?}", e)
-                }
-            };
-
-            let js_value = JsString::new(&mut ctx, &value);
-            let json_str = func.call(&mut ctx, null, vec![js_value])?
-                .downcast::<JsString>()
-                .or_throw(&mut ctx)?
-                .value();
-            {
-                let guard = ctx.lock();
-                let mut this = this.borrow_mut(&guard);
-                let _ = this.selector.value_from_str(&json_str);
             }
 
             Ok(JsUndefined::new().upcast())
         }
 
-        method get(mut ctx) {
+        method select(mut ctx) {
-            let mut this = ctx.this();
+             let this = ctx.this();
 
-            let result = {
+             let result_str = {
                 let guard = ctx.lock();
-                let this = this.borrow_mut(&guard);
+                let this = this.borrow(&guard);
-                match this.selector.get() {
+                this.select()
-                    Ok(v) => v,
-                    Err(e) => panic!("{:?}", e)
-                }
              };
 
-            Ok(JsString::new(&mut ctx, &result.to_string()).upcast())
+             Ok(JsString::new(&mut ctx, &result_str).upcast())
+        }
+    }
+
+    pub class JsSelectorMut for SelectorMutCls {
+        init(mut _ctx) {
+            Ok(SelectorMutCls {})
+        }
+
+        method emptyPathError(mut _ctx) {
+            panic!("{:?}", JsonPathError::EmptyPath);
+        }
+
+        method emptyValueError(mut _ctx) {
+            panic!("{:?}", JsonPathError::EmptyValue);
         }
     }
 }
@@ -215,7 +260,10 @@ register_module!(mut m, {
     m.export_class::<JsCompileFn>("CompileFn").expect("CompileFn class error");
     m.export_class::<JsSelectorFn>("SelectorFn").expect("SelectorFn class error");
     m.export_class::<JsSelector>("Selector").expect("Selector class error");
+    m.export_class::<JsSelectorMut>("SelectorMut").expect("SelectorMut class error");
     m.export_function("select", select)?;
+    m.export_function("deleteValue", delete)?;
+    m.export_function("replaceWith", replace_with)?;
     m.export_function("selectStr", select_str)?;
     Ok(())
 });

nodejs/test/index.spec.js

@@ -359,7 +359,7 @@ describe('compile test', () => {
     it('basic', (done) => {
         let template = jsonpath.compile('$.a');
         let result = template({'a': 1});
-        if (result === 1) {
+        if (result[0] === 1) {
             done();
         }
     });
@@ -369,7 +369,7 @@ describe('selector test', () => {
     it('basic', (done) => {
         let selector = jsonpath.selector({'a': 1});
         let result = selector('$.a');
-        if (result === 1) {
+        if (result[0] === 1) {
             done();
         }
     });
@@ -378,7 +378,7 @@ describe('selector test', () => {
 describe('select test', () => {
     it('basic', (done) => {
         let result = jsonpath.select({'a': 1}, '$.a');
-        if (result === 1) {
+        if (result[0] === 1) {
             done();
         }
     });
@@ -400,25 +400,105 @@ describe('filter test', () => {
     }
 });
 
+describe('SelectorMut test', () => {
+    it('delete', (done) => {
+        let jsonObjNew = JSON.parse(JSON.stringify(jsonObj));
+        let result = jsonpath.deleteValue(jsonObjNew, '$.store.book');
+        if (JSON.stringify(result) === JSON.stringify({
+            'store': {
+                'book': null,
+                'bicycle': {
+                    'color': 'red',
+                    'price': 19.95,
+                },
+            },
+            'expensive': 10,
+        })) {
+            done();
+        }
+    });
+
+    it('replaceWith', (done) => {
+        let jsonObjNew = JSON.parse(JSON.stringify(jsonObj));
+        let result = jsonpath.replaceWith(jsonObjNew, '$.store.book', (v) => {
+            let ret = v[0];
+            ret.price = 9;
+            return ret;
+        });
+        if (JSON.stringify(result) === JSON.stringify({
+            'store': {
+                'book': {
+                    'category': 'reference',
+                    'author': 'Nigel Rees',
+                    'title': 'Sayings of the Century',
+                    'price': 9,
+                },
+                'bicycle': {
+                    'color': 'red',
+                    'price': 19.95,
+                },
+            },
+            'expensive': 10,
+        })) {
+            done();
+        }
+    });
+
+    it('SeletorMut delete', (done) => {
+        let jsonObjNew = JSON.parse(JSON.stringify(jsonObj));
+        let selector = new jsonpath.SelectorMut();
+        selector.path('$.store.book').value(jsonObjNew).deleteValue();
+
+        let result = selector.take();
+        if (JSON.stringify(result) === JSON.stringify({
+            'store': {
+                'book': null,
+                'bicycle': {
+                    'color': 'red',
+                    'price': 19.95,
+                },
+            },
+            'expensive': 10,
+        })) {
+            done();
+        }
+    });
+
+    it('SeletorMut replaceWith', (done) => {
+        let jsonObjNew = JSON.parse(JSON.stringify(jsonObj));
+        let selector = new jsonpath.SelectorMut();
+        selector.path('$.store.book').value(jsonObjNew).replaceWith((v) => {
+            let ret = v[0];
+            ret.price = 9;
+            return ret;
+        });
+
+        let result = selector.take();
+        if (JSON.stringify(result) === JSON.stringify({
+            'store': {
+                'book': {
+                    'category': 'reference',
+                    'author': 'Nigel Rees',
+                    'title': 'Sayings of the Century',
+                    'price': 9,
+                },
+                'bicycle': {
+                    'color': 'red',
+                    'price': 19.95,
+                },
+            },
+            'expensive': 10,
+        })) {
+            done();
+        }
+    });
+});
+
 describe('Selector test', () => {
-    it('basic selectTo', (done) => {
-        let result = new jsonpath.Selector().path('$.a').value({'a': 1}).selectTo();
-        if (result === 1) {
-            done();
-        }
-    });
-
-    it('basic selectToStr', (done) => {
-        let result = new jsonpath.Selector().path('$.a').value({'a': 1}).selectToStr();
-        if (result === '1') {
-            done();
-        }
-    });
-
     it('select', (done) => {
         let selector = new jsonpath.Selector().value(jsonObj);
         for(var i in list) {
-            if(JSON.stringify(list[i]) !== selector.path(i).selectToStr()) {
+            if(JSON.stringify(list[i]) !== JSON.stringify(selector.path(i).select())) {
                 throw `fail: ${i}`;
             }
         }
@@ -444,7 +524,7 @@ describe('README test', () => {
         let selector = new jsonpath.Selector().value(jsonObj);
 
         {
-            let jsonObj = selector.path('$..[?(@.age >= 30)]').selectAs();
+            let jsonObj = selector.path('$..[?(@.age >= 30)]').select();
             let resultObj = [{"name": "친구3", "age": 30}];
             if(JSON.stringify(jsonObj) !== JSON.stringify(resultObj)) {
                 throw 'jsonpath.Selector: $..[?(@.age >= 30)]';
@@ -452,7 +532,7 @@ describe('README test', () => {
         }
 
         {
-            let jsonObj = selector.path('$..[?(@.age == 20)]').selectAs();
+            let jsonObj = selector.path('$..[?(@.age == 20)]').select();
             let resultObj = [{"name": "친구1", "age": 20}, {"name": "친구2", "age": 20}];
             if(JSON.stringify(jsonObj) !== JSON.stringify(resultObj)) {
                 throw 'jsonpath.Selector: $..[?(@.age >= 20)]';
@@ -460,29 +540,68 @@ describe('README test', () => {
         }
 
         {
-            let jsonObj = selector.value({"friends": [ {"name": "친구5", "age": 20} ]}).selectAs();
+            let jsonObj = selector.value({"friends": [ {"name": "친구5", "age": 20} ]}).select();
             let resultObj = [{"name": "친구5", "age": 20}];
             if(JSON.stringify(jsonObj) !== JSON.stringify(resultObj)) {
                 throw 'jsonpath.Selector: change value';
             }
         }
 
-        {
+        done();
-            let jsonObj1 = selector.value(jsonObj).map(function(v) {
+    });
-                let f1 = v[0];
-                f1.age = 30;
-                return v;
-            }).get();
 
-            let resultObj1 = [{"name": "친구1", "age": 30}, {"name": "친구2", "age": 20}];
+    it('jsonpath.SelectorMut', (done) => {
-            if(JSON.stringify(jsonObj1) !== JSON.stringify(resultObj1)) {
+        let jsonObj = {
-                throw 'jsonpath.Selector.map';
+            'school': {
+                'friends': [
+                    {'name': '친구1', 'age': 20},
+                    {'name': '친구2', 'age': 20},
+                ],
+            },
+            'friends': [
+                {'name': '친구3', 'age': 30},
+                {'name': '친구4'},
+            ],
+        };
+
+        let selector = new jsonpath.SelectorMut();
+        selector.path('$..[?(@.age == 20)]');
+
+        {
+            selector.value(jsonObj).deleteValue();
+
+            let resultObj = {
+                'school': {'friends': [null, null]},
+                'friends': [
+                    {'name': '친구3', 'age': 30},
+                    {'name': '친구4'},
+                ],
+            };
+            if (JSON.stringify(selector.take()) !== JSON.stringify(resultObj)) {
+                throw 'jsonpath.SelectorMut.deleteValue';
+            }
         }
 
-            let jsonObj2 = selector.path('$..[?(@.age == 20)]').selectAs();
+        {
-            let resultObj2 = [{"name": "친구2", "age": 20}];
+            selector.value(jsonObj).replaceWith((v) => {
-            if(JSON.stringify(jsonObj2) !== JSON.stringify(resultObj2)) {
+                v.age = v.age * 2;
-                throw 'jsonpath.Selector.map and then select';
+                return v;
+            });
+
+            let resultObj = {
+                'school': {
+                    'friends': [
+                        {'name': '친구1', 'age': 40},
+                        {'name': '친구2', 'age': 40},
+                    ],
+                },
+                'friends': [
+                    {'name': '친구3', 'age': 30},
+                    {'name': '친구4'},
+                ],
+            };
+            if (JSON.stringify(selector.take()) !== JSON.stringify(resultObj)) {
+                throw 'jsonpath.SelectorMut.replaceWith';
             }
         }
 
@@ -618,4 +737,64 @@ describe('README test', () => {
 
         done();
     });
+
+    it('jsonpath.deleteValue(json: string|object, path: string)', (done) => {
+        let jsonObj = {
+            "school": {
+                "friends": [
+                    {"name": "친구1", "age": 20},
+                    {"name": "친구2", "age": 20}
+                ]
+            },
+            "friends": [
+                {"name": "친구3", "age": 30},
+                {"name": "친구4"}
+            ]
+        };
+
+        let _1 = jsonpath.deleteValue(jsonObj, '$..friends[0]');
+        let result = jsonpath.deleteValue(_1, '$..friends[1]');
+
+        if(JSON.stringify(result) === JSON.stringify({
+            "school": { "friends": [null, null]},
+            "friends": [null, null]
+        })) {
+            done();
+        }
+    });
+
+    it('jsonpath.replaceWith(json: string|object, path: string, fun: function(json: object) => json: object', (done) => {
+        let jsonObj = {
+            "school": {
+                "friends": [
+                    {"name": "친구1", "age": 20},
+                    {"name": "친구2", "age": 20}
+                ]
+            },
+            "friends": [
+                {"name": "친구3", "age": 30},
+                {"name": "친구4"}
+            ]
+        };
+
+        let result = jsonpath.replaceWith(jsonObj, '$..friends[0]', (v) => {
+            v.age = v.age * 2;
+            return v;
+        });
+
+        if(JSON.stringify(result) === JSON.stringify({
+            "school": {
+                "friends": [
+                    {"name": "친구1", "age": 40},
+                    {"name": "친구2", "age": 20}
+                ]
+            },
+            "friends": [
+                {"name": "친구3", "age": 60},
+                {"name": "친구4"}
+            ]
+        })) {
+            done();
+        }
+    });
 });

profiling.sh

@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+
+set -e
+
+valgrind \
+    --tool=callgrind \
+    --dump-instr=yes \
+    --collect-jumps=yes \
+    --simulate-cache=yes $1 -- $2

src/filter/cmp.rs

@@ -1,191 +0,0 @@
-#[derive(Debug)]
-pub enum CmpType {
-    Eq,
-    Ne,
-    Gt,
-    Ge,
-    Lt,
-    Le,
-}
-
-#[derive(Debug)]
-pub enum CmpCondType {
-    And,
-    Or,
-}
-
-pub trait PrivCmp {
-    fn cmp_bool(&self, v1: &bool, v2: &bool) -> bool;
-
-    fn cmp_f64(&self, v1: &f64, v2: &f64) -> bool;
-
-    fn cmp_string(&self, v1: &String, v2: &String) -> bool;
-}
-
-pub trait IntoType {
-    fn into_type(&self) -> CmpType;
-}
-
-pub struct CmpEq;
-
-impl PrivCmp for CmpEq {
-    fn cmp_bool(&self, v1: &bool, v2: &bool) -> bool {
-        v1 == v2
-    }
-
-    fn cmp_f64(&self, v1: &f64, v2: &f64) -> bool {
-        v1 == v2
-    }
-
-    fn cmp_string(&self, v1: &String, v2: &String) -> bool {
-        v1 == v2
-    }
-}
-
-impl IntoType for CmpEq {
-    fn into_type(&self) -> CmpType {
-        CmpType::Eq
-    }
-}
-
-pub struct CmpNe;
-
-impl PrivCmp for CmpNe {
-    fn cmp_bool(&self, v1: &bool, v2: &bool) -> bool {
-        v1 != v2
-    }
-
-    fn cmp_f64(&self, v1: &f64, v2: &f64) -> bool {
-        v1 != v2
-    }
-
-    fn cmp_string(&self, v1: &String, v2: &String) -> bool {
-        v1 != v2
-    }
-}
-
-impl IntoType for CmpNe {
-    fn into_type(&self) -> CmpType {
-        CmpType::Ne
-    }
-}
-
-pub struct CmpGt;
-
-impl PrivCmp for CmpGt {
-    fn cmp_bool(&self, v1: &bool, v2: &bool) -> bool {
-        v1 > v2
-    }
-
-    fn cmp_f64(&self, v1: &f64, v2: &f64) -> bool {
-        v1 > v2
-    }
-
-    fn cmp_string(&self, v1: &String, v2: &String) -> bool {
-        v1 > v2
-    }
-}
-
-impl IntoType for CmpGt {
-    fn into_type(&self) -> CmpType {
-        CmpType::Gt
-    }
-}
-
-pub struct CmpGe;
-
-impl PrivCmp for CmpGe {
-    fn cmp_bool(&self, v1: &bool, v2: &bool) -> bool {
-        v1 >= v2
-    }
-
-    fn cmp_f64(&self, v1: &f64, v2: &f64) -> bool {
-        v1 >= v2
-    }
-
-    fn cmp_string(&self, v1: &String, v2: &String) -> bool {
-        v1 >= v2
-    }
-}
-
-impl IntoType for CmpGe {
-    fn into_type(&self) -> CmpType {
-        CmpType::Ge
-    }
-}
-
-pub struct CmpLt;
-
-impl PrivCmp for CmpLt {
-    fn cmp_bool(&self, v1: &bool, v2: &bool) -> bool {
-        v1 < v2
-    }
-
-    fn cmp_f64(&self, v1: &f64, v2: &f64) -> bool {
-        v1 < v2
-    }
-
-    fn cmp_string(&self, v1: &String, v2: &String) -> bool {
-        v1 < v2
-    }
-}
-
-impl IntoType for CmpLt {
-    fn into_type(&self) -> CmpType {
-        CmpType::Lt
-    }
-}
-
-pub struct CmpLe;
-
-impl PrivCmp for CmpLe {
-    fn cmp_bool(&self, v1: &bool, v2: &bool) -> bool {
-        v1 <= v2
-    }
-
-    fn cmp_f64(&self, v1: &f64, v2: &f64) -> bool {
-        v1 <= v2
-    }
-
-    fn cmp_string(&self, v1: &String, v2: &String) -> bool {
-        v1 <= v2
-    }
-}
-
-impl IntoType for CmpLe {
-    fn into_type(&self) -> CmpType {
-        CmpType::Le
-    }
-}
-
-pub struct CmpAnd;
-
-impl PrivCmp for CmpAnd {
-    fn cmp_bool(&self, v1: &bool, v2: &bool) -> bool {
-        *v1 && *v2
-    }
-
-    fn cmp_f64(&self, v1: &f64, v2: &f64) -> bool {
-        v1 > &0_f64 && v2 > &0_f64
-    }
-
-    fn cmp_string(&self, v1: &String, v2: &String) -> bool {
-        !v1.is_empty() && !v2.is_empty()
-    }
-}
-
-pub struct CmpOr;
-
-impl PrivCmp for CmpOr {
-    fn cmp_bool(&self, v1: &bool, v2: &bool) -> bool {
-        *v1 || *v2
-    }
-
-    fn cmp_f64(&self, v1: &f64, v2: &f64) -> bool {
-        v1 > &0_f64 || v2 > &0_f64
-    }
-
-    fn cmp_string(&self, v1: &String, v2: &String) -> bool {
-        !v1.is_empty() || !v2.is_empty()
-    }
-}

src/filter/mod.rs

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

src/filter/term.rs

@@ -1,154 +0,0 @@
-use super::cmp::*;
-use super::value_filter::ValueFilterKey;
-use super::value_wrapper::*;
-
-#[derive(Debug)]
-pub enum TermContext {
-    Constants(ExprTerm),
-    Json(Option<ValueFilterKey>, ValueWrapper),
-}
-
-impl TermContext {
-    fn cmp<F: PrivCmp + IntoType>(&self, other: &TermContext, cmp_fn: F, default: bool) -> TermContext {
-        match self {
-            TermContext::Constants(et) => {
-                match other {
-                    TermContext::Constants(oet) => {
-                        trace!("const-const");
-                        TermContext::Constants(ExprTerm::Bool(et.cmp(oet, cmp_fn, default)))
-                    }
-                    TermContext::Json(key, v) => {
-                        trace!("const-json");
-                        TermContext::Json(None, v.take_with(key, et, cmp_fn, true))
-                    }
-                }
-            }
-            TermContext::Json(key, v) => {
-                match other {
-                    TermContext::Json(key_other, ov) => {
-                        trace!("json-json");
-
-                        fn is_json(t: &TermContext) -> bool {
-                            match t {
-                                TermContext::Json(_, _) => true,
-                                _ => false
-                            }
-                        }
-
-                        let c = v.into_term(key);
-                        let oc = ov.into_term(key_other);
-                        if is_json(&c) && is_json(&oc) {
-                            v.cmp(&ov, cmp_fn.into_type())
-                        } else {
-                            c.cmp(&oc, cmp_fn, default)
-                        }
-                    }
-                    TermContext::Constants(et) => {
-                        trace!("json-const");
-                        TermContext::Json(None, v.take_with(key, et, cmp_fn, false))
-                    }
-                }
-            }
-        }
-    }
-
-    fn cmp_cond(&self, other: &TermContext, cmp_cond_type: CmpCondType) -> TermContext {
-        match self {
-            TermContext::Constants(et) => {
-                match other {
-                    TermContext::Constants(oet) => {
-                        match cmp_cond_type {
-                            CmpCondType::Or => {
-                                TermContext::Constants(ExprTerm::Bool(et.cmp(oet, CmpOr, false)))
-                            }
-                            CmpCondType::And => {
-                                TermContext::Constants(ExprTerm::Bool(et.cmp(oet, CmpAnd, false)))
-                            }
-                        }
-                    }
-                    TermContext::Json(_, v) => {
-                        TermContext::Json(None, ValueWrapper::new(v.get_val().clone(), false))
-                    }
-                }
-            }
-            TermContext::Json(_, v) => {
-                match other {
-                    TermContext::Json(_, ov) => {
-                        match cmp_cond_type {
-                            CmpCondType::Or => TermContext::Json(None, v.union(ov)),
-                            CmpCondType::And => TermContext::Json(None, v.intersect(ov)),
-                        }
-                    }
-                    _ => {
-                        TermContext::Json(None, ValueWrapper::new(v.get_val().clone(), false))
-                    }
-                }
-            }
-        }
-    }
-
-    pub fn eq(&self, other: &TermContext) -> TermContext {
-        trace!("eq");
-        self.cmp(other, CmpEq, false)
-    }
-
-    pub fn ne(&self, other: &TermContext) -> TermContext {
-        trace!("ne");
-        self.cmp(other, CmpNe, true)
-    }
-
-    pub fn gt(&self, other: &TermContext) -> TermContext {
-        trace!("gt");
-        self.cmp(other, CmpGt, false)
-    }
-
-    pub fn ge(&self, other: &TermContext) -> TermContext {
-        trace!("ge");
-        self.cmp(other, CmpGe, false)
-    }
-
-    pub fn lt(&self, other: &TermContext) -> TermContext {
-        trace!("lt");
-        self.cmp(other, CmpLt, false)
-    }
-
-    pub fn le(&self, other: &TermContext) -> TermContext {
-        trace!("le");
-        self.cmp(other, CmpLe, false)
-    }
-
-    pub fn and(&self, other: &TermContext) -> TermContext {
-        self.cmp_cond(other, CmpCondType::And)
-    }
-
-    pub fn or(&self, other: &TermContext) -> TermContext {
-        self.cmp_cond(other, CmpCondType::Or)
-    }
-}
-
-
-#[derive(Debug)]
-pub enum ExprTerm {
-    String(String),
-    Number(f64),
-    Bool(bool),
-}
-
-impl ExprTerm {
-    fn cmp<F: PrivCmp>(&self, other: &ExprTerm, cmp_fn: F, default: bool) -> bool {
-        match self {
-            ExprTerm::Bool(v1) => match other {
-                ExprTerm::Bool(v2) => cmp_fn.cmp_bool(v1, v2),
-                _ => default
-            }
-            ExprTerm::Number(v1) => match other {
-                ExprTerm::Number(v2) => cmp_fn.cmp_f64(v1, v2),
-                _ => default
-            }
-            ExprTerm::String(v1) => match other {
-                ExprTerm::String(v2) => cmp_fn.cmp_string(v1, v2),
-                _ => default
-            }
-        }
-    }
-}

src/filter/value_filter.rs

@@ -1,640 +0,0 @@
-use std::error::Error;
-use std::ops::Deref;
-use std::result::Result;
-
-use serde_json::Value;
-
-use filter::term::*;
-use filter::value_wrapper::*;
-use parser::parser::{FilterToken, NodeVisitor, ParseToken};
-use ref_value::model::*;
-
-trait ArrayIndex {
-    fn index(&self, v: &RefValueWrapper) -> usize;
-
-    fn take_value(&self, v: &RefValueWrapper) -> RefValueWrapper {
-        let idx = self.index(v);
-        match v.get(idx) {
-            Some(v) => v.clone(),
-            _ => RefValue::Null.into()
-        }
-    }
-}
-
-impl ArrayIndex for f64 {
-    fn index(&self, v: &RefValueWrapper) -> usize {
-        if v.is_array() && self < &0_f64 {
-            (v.as_array().unwrap().len() as f64 + self) as usize
-        } else {
-            *self as usize
-        }
-    }
-}
-
-impl ArrayIndex for isize {
-    fn index(&self, v: &RefValueWrapper) -> usize {
-        if v.is_array() && self < &0_isize {
-            (v.as_array().unwrap().len() as isize + self) as usize
-        } else {
-            *self as usize
-        }
-    }
-}
-
-impl ArrayIndex for usize {
-    fn index(&self, _: &RefValueWrapper) -> usize {
-        *self as usize
-    }
-}
-
-#[derive(Debug, Clone)]
-pub enum ValueFilterKey {
-    Num(usize),
-    String(String),
-    All,
-}
-
-fn iter_to_value_vec<'a, I: Iterator<Item=&'a RefValueWrapper>>(iter: I) -> Vec<RefValueWrapper> {
-    iter
-        .map(|v| v.clone())
-        .filter(|v| !v.is_null())
-        .collect()
-}
-
-fn get_nested_array<F: ArrayIndex>(v: &RefValueWrapper, key: F, filter_mode: bool) -> RefValueWrapper {
-    if v.is_array() && v.as_array().unwrap().get(key.index(v)).is_some() {
-        if filter_mode {
-            v.clone()
-        } else {
-            let idx = key.index(v);
-            v.get(idx).unwrap().clone()
-        }
-    } else {
-        key.take_value(v)
-    }
-}
-
-fn get_nested_object(v: &RefValueWrapper, key: &String, filter_mode: bool) -> RefValueWrapper {
-    if v.is_object() && v.as_object().unwrap().contains_key(key) {
-        if filter_mode {
-            v.clone()
-        } else {
-            v.get(key.clone()).unwrap().clone()
-        }
-    } else {
-        RefValue::Null.into()
-    }
-}
-
-fn traverse(key: Option<&String>, v: &RefValueWrapper, buf: &mut Vec<RefValueWrapper>) {
-    match v.deref() {
-        RefValue::Array(vec) => {
-            if key.is_none() {
-                for v in vec {
-                    buf.push(v.clone());
-                }
-            }
-            for i in vec {
-                traverse(key, i, buf);
-            }
-        }
-        RefValue::Object(v) => {
-            for (k, v) in v.into_iter() {
-                if match key {
-                    Some(map_key) => map_key == k,
-                    _ => true
-                } {
-                    buf.push(v.clone());
-                }
-            }
-            for (_, v) in v.into_iter() {
-                traverse(key, v, buf);
-            }
-        }
-        _ => {}
-    }
-}
-
-fn collect_all(key: Option<&String>, v: &RefValueWrapper) -> Vec<RefValueWrapper> {
-    let mut buf = Vec::new();
-    traverse(key, v, &mut buf);
-    buf
-}
-
-#[derive(Debug)]
-pub struct ValueFilter {
-    val_wrapper: ValueWrapper,
-    last_key: Option<ValueFilterKey>,
-    filter_mode: bool,
-}
-
-impl ValueFilter {
-    pub fn new(v: RefValueWrapper, is_leaves: bool, filter_mode: bool) -> Self {
-        ValueFilter { val_wrapper: ValueWrapper::new(v, is_leaves), last_key: None, filter_mode }
-    }
-
-    fn step_leaves(&mut self, key: Option<&String>) {
-        let buf = collect_all(key, &self.val_wrapper.get_val());
-        trace!("step_leaves - {:?}", buf);
-        self.val_wrapper = ValueWrapper::new(RefValue::Array(buf).into(), true);
-    }
-
-    pub fn step_leaves_all(&mut self) -> &ValueWrapper {
-        debug!("step_leaves_all");
-        self.step_leaves(None);
-        self.last_key = Some(ValueFilterKey::All);
-        &self.val_wrapper
-    }
-
-    pub fn step_leaves_str(&mut self, key: &str) -> &ValueWrapper {
-        self.step_leaves_string(&key.to_string())
-    }
-
-    pub fn step_leaves_string(&mut self, key: &String) -> &ValueWrapper {
-        debug!("step_leaves_string");
-        self.step_leaves(Some(key));
-        self.last_key = Some(ValueFilterKey::String(key.clone()));
-        &self.val_wrapper
-    }
-
-    pub fn step_in_all(&mut self) -> &ValueWrapper {
-        debug!("step_in_all");
-
-        let vec = match self.val_wrapper.get_val().deref() {
-            RefValue::Object(ref map) => {
-                iter_to_value_vec(map.values())
-            }
-            RefValue::Array(ref list) => {
-                iter_to_value_vec(list.iter())
-            }
-            RefValue::Null => Vec::new(),
-            _ => vec![self.val_wrapper.get_val().clone()]
-        };
-
-        self.last_key = Some(ValueFilterKey::All);
-        self.val_wrapper.replace(RefValue::Array(vec).into());
-        trace!("step_in_all - {:?}", self.val_wrapper.get_val());
-        &self.val_wrapper
-    }
-
-    pub fn step_in_num(&mut self, key: &f64) -> &ValueWrapper {
-        debug!("step_in_num");
-        trace!("step_in_num - before: leaves {}, filterMode {} - {:?}"
-               , self.val_wrapper.is_leaves()
-               , self.filter_mode
-               , self.val_wrapper.get_val());
-
-        let v = if self.val_wrapper.is_leaves() {
-            let filter_mode = self.filter_mode;
-            match self.val_wrapper.get_val().deref() {
-                RefValue::Array(ref vec) => {
-                    let mut ret = Vec::new();
-                    for v in vec {
-                        let wrapper = get_nested_array(v, *key, filter_mode);
-                        if !wrapper.is_null() {
-                            ret.push(wrapper.clone());
-                        }
-                    }
-                    RefValue::Array(ret).into()
-                }
-                _ => key.take_value(&self.val_wrapper.get_val())
-            }
-        } else {
-            key.take_value(&self.val_wrapper.get_val())
-        };
-
-        self.last_key = Some(ValueFilterKey::Num(key.index(&v)));
-        self.val_wrapper.replace(v);
-        trace!("step_in_num - after: {:?}", self.val_wrapper.get_val());
-        &self.val_wrapper
-    }
-
-    pub fn step_in_str(&mut self, key: &str) -> &ValueWrapper {
-        self.step_in_string(&key.to_string())
-    }
-
-    pub fn step_in_string(&mut self, key: &String) -> &ValueWrapper {
-        debug!("step_in_string");
-        trace!("step_in_string - before: {},{},{:?}"
-               , self.val_wrapper.is_leaves()
-               , self.filter_mode
-               , self.val_wrapper.get_val());
-
-        let filter_mode = self.filter_mode;
-        let is_leaves = self.val_wrapper.is_leaves();
-        let val = match self.val_wrapper.get_val().deref() {
-            RefValue::Array(ref vec) if is_leaves => {
-                let mut buf = Vec::new();
-                for v in vec {
-                    if v.is_array() {
-                        let vec = v.as_array().unwrap();
-                        let mut ret = Vec::new();
-                        for v in vec {
-                            let nested_wrapper = get_nested_object(v, key, filter_mode);
-                            if !nested_wrapper.is_null() {
-                                ret.push(nested_wrapper);
-                            }
-                        }
-                        buf.append(&mut ret);
-                    } else if v.is_object() {
-                        let nested_wrapper = get_nested_object(v, key, filter_mode);
-                        if !nested_wrapper.is_null() {
-                            buf.push(nested_wrapper);
-                        }
-                    } else {
-                        match v.get(key.clone()) {
-                            Some(v) => buf.push(v.clone()),
-                            _ => {}
-                        }
-                    }
-                }
-
-                RefValue::Array(buf).into()
-            }
-            RefValue::Array(ref vec) if !is_leaves => {
-                let mut ret = Vec::new();
-                for v in vec {
-                    let wrapper = get_nested_object(v, key, filter_mode);
-                    if !wrapper.is_null() {
-                        ret.push(wrapper);
-                    }
-                }
-                RefValue::Array(ret).into()
-            }
-            _ => {
-                match self.val_wrapper.get_val().get(key.clone()) {
-                    Some(v) => v.clone(),
-                    _ => RefValue::Null.into()
-                }
-            }
-        };
-
-        self.last_key = Some(ValueFilterKey::String(key.clone()));
-        self.val_wrapper.replace(val);
-        trace!("step_in_string - after: {},{},{:?}"
-               , self.val_wrapper.is_leaves()
-               , self.filter_mode
-               , self.val_wrapper.get_val());
-        &self.val_wrapper
-    }
-}
-
-pub struct JsonValueFilter {
-    json: RefValueWrapper,
-    filter_stack: Vec<ValueFilter>,
-    token_stack: Vec<ParseToken>,
-    term_stack: Vec<TermContext>,
-}
-
-impl JsonValueFilter {
-    pub fn new(json: &str) -> Result<Self, String> {
-        let json: RefValue = serde_json::from_str(json)
-            .map_err(|e| e.description().to_string())?;
-        Ok(JsonValueFilter::new_from_value(json.into()))
-    }
-
-    pub fn new_from_value(json: RefValueWrapper) -> Self {
-        JsonValueFilter {
-            json,
-            filter_stack: Vec::new(),
-            token_stack: Vec::new(),
-            term_stack: Vec::new(),
-        }
-    }
-
-    fn is_peek_token_array(&self) -> bool {
-        if let Some(ParseToken::Array) = self.token_stack.last() {
-            true
-        } else {
-            false
-        }
-    }
-
-    fn push_value_filter(&mut self, from_current: bool) {
-        if from_current {
-            self.filter_stack.last()
-                .map(|vf| {
-                    ValueFilter::new(vf.val_wrapper.get_val().clone(), vf.val_wrapper.is_leaves(), from_current)
-                })
-                .and_then(|vf| {
-                    Some(self.filter_stack.push(vf))
-                });
-        } else {
-            self.filter_stack.push({
-                ValueFilter::new(self.json.clone(), false, from_current)
-            });
-        }
-    }
-
-    fn replace_filter_stack(&mut self, v: RefValueWrapper, is_leaves: bool) {
-        if self.filter_stack.is_empty() {
-            self.filter_stack.push(ValueFilter::new(v, is_leaves, false));
-        } else {
-            match self.filter_stack.last_mut() {
-                Some(vf) => {
-                    vf.val_wrapper.set_leaves(is_leaves);
-                    if v.is_null() {
-                        vf.val_wrapper.replace(v);
-                    } else if v.is_array() && v.as_array().unwrap().is_empty() {
-                        vf.val_wrapper.replace(RefValue::Null.into());
-                    } else if vf.val_wrapper.is_array() {
-                        vf.val_wrapper.replace(v);
-                    }
-                }
-                _ => {}
-            }
-        }
-    }
-
-    pub fn into_value(&self) -> Value {
-        match self.filter_stack.last() {
-            Some(v) => v.val_wrapper.into_value(),
-            _ => Value::Null
-        }
-    }
-
-    pub fn take_value(&mut self) -> RefValueWrapper {
-        match self.filter_stack.last_mut() {
-            Some(v) => v.val_wrapper.get_val().clone(),
-            _ => RefValue::Null.into()
-        }
-    }
-
-    fn token_union<F: ArrayIndex>(&mut self, indices: Vec<F>) {
-        self.token_stack.pop();
-
-        match self.filter_stack.last_mut() {
-            Some(ref mut vf) if vf.val_wrapper.is_array() && vf.val_wrapper.is_leaves() => {
-                let mut ret = Vec::new();
-                if let RefValue::Array(val) = vf.val_wrapper.get_val().deref() {
-                    for v in val {
-                        for i in &indices {
-                            let v = i.take_value(v);
-                            if !v.is_null() {
-                                ret.push(v.clone());
-                            }
-                        }
-                    }
-                }
-                vf.val_wrapper.replace(RefValue::Array(ret).into());
-            }
-            Some(ref mut vf) if vf.val_wrapper.is_array() && !vf.val_wrapper.is_leaves() => {
-                let mut ret = Vec::new();
-                for i in indices {
-                    let wrapper = i.take_value(&vf.val_wrapper.get_val());
-                    if !wrapper.is_null() {
-                        ret.push(wrapper.clone());
-                    }
-                }
-                vf.val_wrapper.replace(RefValue::Array(ret).into());
-            }
-            _ => {}
-        }
-    }
-
-    fn token_range(&mut self, from: Option<isize>, to: Option<isize>) {
-        self.token_stack.pop();
-
-        fn _from_to<F: ArrayIndex>(from: Option<F>, to: Option<F>, val: &RefValueWrapper) -> (usize, usize) {
-            let from = match from {
-                Some(v) => v.index(val),
-                _ => 0
-            };
-            let to = match to {
-                Some(v) => v.index(val),
-                _ => {
-                    if let RefValue::Array(v) = val.deref() {
-                        v.len()
-                    } else {
-                        0
-                    }
-                }
-            };
-            (from, to)
-        }
-
-        fn _range(from: usize, to: usize, v: &RefValueWrapper) -> Vec<RefValueWrapper> {
-            trace!("range - {}:{}", from, to);
-
-            (from..to).into_iter()
-                .map(|i| i.take_value(v))
-                .filter(|v| !v.is_null())
-                .map(|v| v.clone())
-                .collect()
-        }
-
-        match self.filter_stack.last_mut() {
-            Some(ref mut vf) if vf.val_wrapper.is_array() && vf.val_wrapper.is_leaves() => {
-                let mut buf = Vec::new();
-                if let RefValue::Array(vec) = vf.val_wrapper.get_val().deref() {
-                    for v in vec {
-                        let (from, to) = _from_to(from, to, v);
-                        let mut v: Vec<RefValueWrapper> = _range(from, to, v);
-                        buf.append(&mut v);
-                    }
-                }
-                vf.val_wrapper.replace(RefValue::Array(buf).into());
-            }
-            Some(ref mut vf) if vf.val_wrapper.is_array() && !vf.val_wrapper.is_leaves() => {
-                let (from, to) = _from_to(from, to, &vf.val_wrapper.get_val());
-                let vec: Vec<RefValueWrapper> = _range(from, to, vf.val_wrapper.get_val());
-                vf.val_wrapper.replace(RefValue::Array(vec).into());
-            }
-            _ => {}
-        }
-    }
-
-    fn token_key(&mut self, key: String) {
-        match self.filter_stack.last_mut() {
-            Some(vf) => {
-                match self.token_stack.pop() {
-                    Some(ParseToken::In) | Some(ParseToken::Array) => {
-                        vf.step_in_string(&key);
-                    }
-                    Some(ParseToken::Leaves) => {
-                        vf.step_leaves_string(&key);
-                    }
-                    _ => {
-                        self.term_stack.push(TermContext::Constants(ExprTerm::String(key)));
-                    }
-                }
-            }
-            _ => {}
-        }
-    }
-
-    fn token_all(&mut self) {
-        match self.filter_stack.last_mut() {
-            Some(vf) => {
-                match self.token_stack.pop() {
-                    Some(ParseToken::In) => {
-                        vf.step_in_all();
-                    }
-                    Some(ParseToken::Leaves) => {
-                        vf.step_leaves_all();
-                    }
-                    _ => {}
-                }
-            }
-            _ => {}
-        }
-    }
-
-    fn token_end_array(&mut self) {
-        trace!("array_eof - term_stack: {:?}", self.term_stack);
-        trace!("array_eof - filter_stack: {:?}", self.filter_stack);
-
-        match self.term_stack.pop() {
-            Some(TermContext::Constants(ExprTerm::Number(v))) => {
-                match self.filter_stack.last_mut() {
-                    Some(vf) => {
-                        vf.step_in_num(&v);
-                    }
-                    _ => {}
-                }
-            }
-            Some(TermContext::Constants(ExprTerm::Bool(false))) => {
-                self.replace_filter_stack(RefValue::Null.into(), false);
-            }
-            Some(TermContext::Json(_, vw)) => {
-                self.replace_filter_stack(vw.get_val().clone(), vw.is_leaves());
-            }
-            _ => {
-                match self.filter_stack.pop() {
-                    Some(vf) => {
-                        let is_leaves = vf.val_wrapper.is_leaves();
-                        match vf.val_wrapper.get_val().deref() {
-                            RefValue::Null | RefValue::Bool(false) => {
-                                self.replace_filter_stack(RefValue::Null.into(), is_leaves);
-                            }
-                            _ => {
-                                self.replace_filter_stack(vf.val_wrapper.get_val().clone(), is_leaves);
-                            }
-                        }
-                    }
-                    _ => {}
-                }
-            }
-        }
-    }
-
-    fn token_op(&mut self, ft: &FilterToken) {
-        let right = self.term_stack.pop();
-        let left = self.term_stack.pop();
-
-        trace!("left {:?}", left);
-        trace!("right {:?}", right);
-
-        if left.is_some() && right.is_some() {
-            let left = left.unwrap();
-            let right = right.unwrap();
-
-            let tc = match ft {
-                FilterToken::Equal => left.eq(&right),
-                FilterToken::NotEqual => left.ne(&right),
-                FilterToken::Greater => left.gt(&right),
-                FilterToken::GreaterOrEqual => left.ge(&right),
-                FilterToken::Little => left.lt(&right),
-                FilterToken::LittleOrEqual => left.le(&right),
-                FilterToken::And => left.and(&right),
-                FilterToken::Or => left.or(&right),
-            };
-            self.term_stack.push(tc);
-        }
-
-        trace!("filter - {:?}", self.term_stack)
-    }
-}
-
-impl NodeVisitor for JsonValueFilter {
-    fn visit_token(&mut self, token: ParseToken) {
-        debug!("visit_token: {:?}", token);
-
-        match token {
-            ParseToken::Absolute
-            | ParseToken::Relative => {
-                if self.is_peek_token_array() {
-                    self.token_stack.pop();
-                }
-                self.push_value_filter(ParseToken::Relative == token);
-            }
-            ParseToken::In
-            | ParseToken::Leaves => {
-                self.token_stack.push(token);
-            }
-            ParseToken::Array => {
-                if let Some(ParseToken::Leaves) = self.token_stack.last() {
-                    self.token_all();
-                }
-                self.token_stack.push(token);
-            }
-            ParseToken::ArrayEof => {
-                self.token_end_array();
-            }
-            ParseToken::All => {
-                self.token_all();
-            }
-            ParseToken::Key(key) => {
-                self.token_key(key);
-            }
-            ParseToken::Filter(ref ft) => {
-                self.token_op(ft);
-            }
-            ParseToken::Number(v) => {
-                self.term_stack.push(TermContext::Constants(ExprTerm::Number(v)))
-            }
-            ParseToken::Range(from, to) => {
-                self.token_range(from, to);
-            }
-            ParseToken::Union(v) => {
-                self.token_union(v);
-            }
-            ParseToken::Eof => {
-                debug!("visit_token eof");
-            }
-        }
-    }
-
-    fn end_term(&mut self) {
-        debug!("end_term");
-
-        if let Some(ParseToken::Array) = self.token_stack.last() {
-            self.token_stack.pop();
-        }
-
-        trace!("end_term - term_stack {:?}", self.term_stack);
-        trace!("end_term - token_stack {:?}", self.token_stack);
-        trace!("end_term - filter_stack {:?}", self.filter_stack);
-
-        if self.token_stack.is_empty() && self.filter_stack.len() > 1 {
-            match self.filter_stack.pop() {
-                Some(vf) => {
-                    self.term_stack.push(TermContext::Json(vf.last_key, vf.val_wrapper));
-                }
-                _ => {}
-            }
-        }
-
-        if match self.token_stack.last() {
-            Some(ParseToken::Key(_))
-            | Some(ParseToken::Number(_)) => true,
-            _ => false
-        } {
-            match self.token_stack.pop() {
-                Some(ParseToken::Key(ref v)) if v.eq_ignore_ascii_case("true") => {
-                    self.term_stack.push(TermContext::Constants(ExprTerm::Bool(true)))
-                }
-                Some(ParseToken::Key(ref v)) if v.eq_ignore_ascii_case("false") => {
-                    self.term_stack.push(TermContext::Constants(ExprTerm::Bool(false)))
-                }
-                Some(ParseToken::Key(v)) => {
-                    self.term_stack.push(TermContext::Constants(ExprTerm::String(v)))
-                }
-                Some(ParseToken::Number(v)) => {
-                    self.term_stack.push(TermContext::Constants(ExprTerm::Number(v)))
-                }
-                _ => {}
-            }
-        }
-    }
-}

src/filter/value_wrapper.rs

@@ -1,307 +0,0 @@
-use std::ops::Deref;
-
-use indexmap::{IndexSet, IndexMap};
-use serde_json::Value;
-
-use ref_value::model::*;
-
-use super::cmp::*;
-use super::term::*;
-use super::value_filter::*;
-
-fn cmp_with_term<F: PrivCmp>(val: &RefValueWrapper, et: &ExprTerm, cmp_fn: &F, default: bool, reverse: bool) -> bool {
-    match val.deref() {
-        RefValue::Bool(ref v1) => {
-            match et {
-                ExprTerm::Bool(v2) => if reverse { cmp_fn.cmp_bool(v2, v1) } else { cmp_fn.cmp_bool(v1, v2) },
-                _ => default
-            }
-        }
-        RefValue::Number(ref v1) => match et {
-            ExprTerm::Number(v2) => if reverse { cmp_fn.cmp_f64(v2, &v1.as_f64().unwrap()) } else { cmp_fn.cmp_f64(&v1.as_f64().unwrap(), v2) },
-            _ => default
-        },
-        RefValue::String(ref v1) => {
-            match et {
-                ExprTerm::String(v2) => if reverse { cmp_fn.cmp_string(v2, v1) } else { cmp_fn.cmp_string(v1, v2) },
-                _ => default
-            }
-        }
-        _ => default
-    }
-}
-
-#[derive(Debug)]
-pub struct ValueWrapper {
-    val: RefValueWrapper,
-    is_leaves: bool,
-}
-
-impl ValueWrapper {
-    pub fn new(val: RefValueWrapper, leaves: bool) -> Self {
-        ValueWrapper { val, is_leaves: leaves }
-    }
-
-    pub fn is_leaves(&self) -> bool {
-        self.is_leaves
-    }
-
-    pub fn set_leaves(&mut self, is_leaves: bool) {
-        self.is_leaves = is_leaves;
-    }
-
-    pub fn cmp(&self, other: &ValueWrapper, cmp_type: CmpType) -> TermContext {
-        match cmp_type {
-            CmpType::Eq => {
-                TermContext::Json(None, self.intersect(other))
-            }
-            CmpType::Ne => {
-                TermContext::Json(None, self.except(other))
-            }
-            CmpType::Gt | CmpType::Ge | CmpType::Lt | CmpType::Le => {
-                TermContext::Constants(ExprTerm::Bool(false))
-            }
-        }
-    }
-
-    fn take_object_in_array<F: PrivCmp>(&self, key: &String, et: &ExprTerm, cmp: &F, reverse: bool) -> Option<Self> {
-        fn _filter_with_object<F: Fn(&RefValueWrapper) -> bool>(v: &RefValueWrapper, key: &String, fun: F) -> bool {
-            match v.deref() {
-                RefValue::Object(map) => {
-                    match map.get(key) {
-                        Some(val) => fun(val),
-                        _ => false
-                    }
-                }
-                _ => false
-            }
-        }
-
-        match self.val.deref() {
-            RefValue::Array(vec) => {
-                let mut set = IndexSet::new();
-                for v in vec {
-                    if _filter_with_object(v, key, |vv| {
-                        cmp_with_term(vv, et, cmp, false, reverse)
-                    }) {
-                        set.insert(v.clone());
-                    }
-                }
-
-                let ret = set.into_iter().collect();
-                Some(ValueWrapper::new(RefValue::Array(ret).into(), false))
-            }
-            _ => None
-        }
-    }
-
-    fn take_with_key_type<F: PrivCmp>(&self, key: &Option<ValueFilterKey>, et: &ExprTerm, cmp: &F, reverse: bool) -> Option<Self> {
-        match key {
-            Some(ValueFilterKey::String(key)) => {
-                self.take_object_in_array(key, et, cmp, reverse)
-            }
-            _ => None
-        }
-    }
-
-    pub fn take_with<F: PrivCmp>(&self, key: &Option<ValueFilterKey>, et: &ExprTerm, cmp: F, reverse: bool) -> Self {
-        match self.take_with_key_type(key, et, &cmp, reverse) {
-            Some(vw) => vw,
-            _ => {
-                match &(*self.val) {
-                    RefValue::Array(vec) => {
-                        let mut set = IndexSet::new();
-                        for v in vec {
-                            if cmp_with_term(v, et, &cmp, false, reverse) {
-                                set.insert(v.clone());
-                            }
-                        }
-                        let ret = set.into_iter().collect();
-                        ValueWrapper::new(RefValue::Array(ret).into(), false)
-                    }
-                    _ => {
-                        if cmp_with_term(&self.val, et, &cmp, false, reverse) {
-                            ValueWrapper::new(self.val.clone(), false)
-                        } else {
-                            ValueWrapper::new(RefValue::Null.into(), false)
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    pub fn replace(&mut self, val: RefValueWrapper) {
-        let is_null = match val.deref() {
-            RefValue::Array(v) => v.is_empty(),
-            RefValue::Object(m) => m.is_empty(),
-            _ => val.is_null()
-        };
-        self.val = if is_null {
-            RefValue::Null.into()
-        } else {
-            val
-        };
-    }
-
-    pub fn get_val(&self) -> &RefValueWrapper {
-        &self.val
-    }
-
-    pub fn into_value(&self) -> Value {
-        self.get_val().into()
-    }
-
-    pub fn is_array(&self) -> bool {
-        self.val.is_array()
-    }
-
-    fn into_hashset(&self) -> IndexSet<&RefValue> {
-        trace!("into_hashset");
-        let mut hashset = IndexSet::new();
-        match self.val.deref() {
-            RefValue::Array(ref v1) => {
-                for v in v1 {
-                    hashset.insert(v.deref());
-                }
-            }
-            _ => {
-                hashset.insert(self.val.deref());
-            }
-        }
-        hashset
-    }
-
-    fn into_hashmap(&self) -> IndexMap<&RefValue, RefValueWrapper> {
-        trace!("into_hashmap");
-        let mut hashmap = IndexMap::new();
-        match self.val.deref() {
-            RefValue::Array(ref v1) => {
-                for v in v1 {
-                    hashmap.insert(v.deref(), v.clone());
-                }
-            }
-            _ => {
-                hashmap.insert(self.val.deref(), self.val.clone());
-            }
-        }
-        hashmap
-    }
-
-    pub fn except(&self, other: &Self) -> Self {
-        trace!("except");
-        let hashset = self.into_hashset();
-        let mut ret: IndexSet<RefValueWrapper> = IndexSet::new();
-        match other.val.deref() {
-            RefValue::Array(ref v1) => {
-                for v in v1 {
-                    if !hashset.contains(v.deref()) {
-                        ret.insert(v.clone());
-                    }
-                }
-            }
-            _ => {
-                if !hashset.contains(&other.val.deref()) {
-                    ret.insert(other.val.clone());
-                }
-            }
-        }
-
-        let vec = ret.into_iter().map(|v| v.clone()).collect();
-        ValueWrapper::new(RefValue::Array(vec).into(), false)
-    }
-
-    pub fn intersect(&self, other: &Self) -> Self {
-        trace!("intersect");
-        let hashset = self.into_hashset();
-        let mut ret: IndexSet<RefValueWrapper> = IndexSet::new();
-        match other.val.deref() {
-            RefValue::Array(ref v1) => {
-                for v in v1 {
-                    if hashset.contains(v.deref()) {
-                        ret.insert(v.clone());
-                    }
-                }
-            }
-            e => {
-                if hashset.contains(e) {
-                    ret.insert(other.val.clone());
-                }
-            }
-        }
-
-        let vec = ret.into_iter().map(|v| v.clone()).collect();
-        ValueWrapper::new(RefValue::Array(vec).into(), false)
-    }
-
-    pub fn union(&self, other: &Self) -> Self {
-        trace!("union");
-        let origin = self.into_hashmap();
-        let mut ret = IndexSet::new();
-
-        for o in origin.values() {
-            ret.insert(o.clone());
-        }
-
-        match other.val.deref() {
-            RefValue::Array(ref v1) => {
-                for v in v1 {
-                    if !origin.contains_key(v.deref()) {
-                        ret.insert(v.clone());
-                    }
-                }
-            }
-            _ => {
-                if !origin.contains_key(&other.val.deref()) {
-                    ret.insert(other.val.clone());
-                }
-            }
-        }
-
-        let mut vw = ValueWrapper::new(RefValue::Null.into(), false);
-        let list = ret.iter().map(|v| v.clone()).collect();
-        vw.replace(RefValue::Array(list).into());
-        vw
-    }
-
-    pub fn into_term(&self, key: &Option<ValueFilterKey>) -> TermContext {
-        match self.val.deref() {
-            RefValue::String(ref s) => TermContext::Constants(ExprTerm::String(s.clone())),
-            RefValue::Number(ref n) => TermContext::Constants(ExprTerm::Number(n.as_f64().unwrap())),
-            RefValue::Bool(b) => TermContext::Constants(ExprTerm::Bool(*b)),
-            _ => TermContext::Json(match key {
-                Some(vk) => Some(vk.clone()),
-                _ => None
-            }, ValueWrapper::new(self.val.clone(), false))
-        }
-    }
-
-    pub fn filter(&self, key: &Option<ValueFilterKey>) -> Self {
-        trace!("filter");
-        let v = match self.val.deref() {
-            RefValue::Array(ref vec) => {
-                let mut ret = Vec::new();
-                for v in vec {
-                    if let Some(ValueFilterKey::String(k)) = key {
-                        if v.get(k.clone()).is_some() {
-                            ret.push(v.clone());
-                        }
-                    }
-                }
-                RefValue::Array(ret).into()
-            }
-            RefValue::Object(ref map) => {
-                match key {
-                    Some(ValueFilterKey::String(k)) => match map.get(k) {
-                        Some(v) => v.clone(),
-                        _ => RefValue::Null.into()
-                    },
-                    _ => RefValue::Null.into()
-                }
-            }
-            _ => self.val.clone()
-        };
-
-        ValueWrapper::new(v, false)
-    }
-}

src/lib.rs

@@ -1,10 +1,9 @@
-//! JsonPath implementation for Rust
+//! JsonPath implementation written in Rust.
 //!
 //! # Example
 //! ```
 //! extern crate jsonpath_lib as jsonpath;
 //! #[macro_use] extern crate serde_json;
-//!
 //! let json_obj = json!({
 //!     "store": {
 //!         "book": [
@@ -45,151 +44,111 @@
 //!
 //! let mut selector = jsonpath::selector(&json_obj);
 //!
-//!    //
+//! assert_eq!(selector("$.store.book[*].author").unwrap(),
-//!    // $.store.book[*].author
+//!             vec![
-//!    //
+//!                 "Nigel Rees", "Evelyn Waugh", "Herman Melville", "J. R. R. Tolkien"
-//!    let json = selector("$.store.book[*].author").unwrap();
+//!             ]);
-//!    let ret = json!(["Nigel Rees","Evelyn Waugh","Herman Melville","J. R. R. Tolkien"]);
-//!    assert_eq!(json, ret);
 //!
-//!    //
+//! assert_eq!(selector("$..author").unwrap(),
-//!    // $..author
+//!             vec![
-//!    //
+//!                 "Nigel Rees", "Evelyn Waugh", "Herman Melville", "J. R. R. Tolkien"
-//!    let json = selector("$..author").unwrap();
+//!             ]);
-//!    let ret = json!(["Nigel Rees","Evelyn Waugh","Herman Melville","J. R. R. Tolkien"]);
-//!    assert_eq!(json, ret);
 //!
-//!    //
+//! assert_eq!(selector("$.store.*").unwrap(),
-//!    // $.store.*
+//!             vec![
-//!    //
+//!                 &json!([
-//!    let json = selector("$.store.*").unwrap();
-//!    let ret = json!([
-//!        [
 //!                     { "category": "reference", "author": "Nigel Rees", "title": "Sayings of the Century", "price": 8.95 },
 //!                     { "category": "fiction", "author": "Evelyn Waugh", "title": "Sword of Honour", "price": 12.99 },
 //!                     { "category": "fiction", "author": "Herman Melville", "title": "Moby Dick", "isbn": "0-553-21311-3", "price": 8.99 },
 //!                     { "category": "fiction", "author": "J. R. R. Tolkien", "title": "The Lord of the Rings", "isbn": "0-395-19395-8", "price": 22.99 }
-//!        ],
+//!                 ]),
-//!        {"color" : "red","price" : 19.95},
+//!                 &json!({ "color": "red", "price": 19.95 })
 //!             ]);
-//!    assert_eq!(ret, json);
 //!
-//!    //
+//! assert_eq!(selector("$.store..price").unwrap(),
-//!    // $.store..price
+//!             vec![
-//!    //
+//!                 8.95, 12.99, 8.99, 22.99, 19.95
-//!    let json = selector("$.store..price").unwrap();
+//!             ]);
-//!    let ret = json!([8.95, 12.99, 8.99, 22.99, 19.95]);
-//!    assert_eq!(ret, json);
 //!
-//!    //
+//! assert_eq!(selector("$..book[2]").unwrap(),
-//!    // $..book[2]
+//!             vec![
-//!    //
+//!                 &json!({
-//!    let json = selector("$..book[2]").unwrap();
-//!    let ret = json!([{
 //!                     "category" : "fiction",
 //!                     "author" : "Herman Melville",
 //!                     "title" : "Moby Dick",
 //!                     "isbn" : "0-553-21311-3",
 //!                     "price" : 8.99
-//!    }]);
+//!                 })
-//!    assert_eq!(ret, json);
+//!             ]);
 //!
-//!    //
+//! assert_eq!(selector("$..book[-2]").unwrap(),
-//!    // $..book[-2]
+//!             vec![
-//!    //
+//!                 &json!({
-//!    let json = selector("$..book[-2]").unwrap();
-//!    let ret = json!([{
 //!                     "category" : "fiction",
 //!                     "author" : "Herman Melville",
 //!                     "title" : "Moby Dick",
 //!                     "isbn" : "0-553-21311-3",
 //!                     "price" : 8.99
-//!     }]);
+//!                 })
-//!    assert_eq!(ret, json);
-//!
-//!    //
-//!    // $..book[0,1]
-//!    //
-//!    let json = selector("$..book[0,1]").unwrap();
-//!    let ret = json!([
-//!        {"category" : "reference","author" : "Nigel Rees","title" : "Sayings of the Century","price" : 8.95},
-//!        {"category" : "fiction","author" : "Evelyn Waugh","title" : "Sword of Honour","price" : 12.99}
 //!             ]);
-//!    assert_eq!(ret, json);
 //!
-//!    //
+//! assert_eq!(selector("$..book[0,1]").unwrap(),
-//!    // $..book[:2]
+//!             vec![
-//!    //
+//!                 &json!({"category" : "reference","author" : "Nigel Rees","title" : "Sayings of the Century","price" : 8.95}),
-//!    let json = selector("$..book[:2]").unwrap();
+//!                 &json!({"category" : "fiction","author" : "Evelyn Waugh","title" : "Sword of Honour","price" : 12.99})
-//!    let ret = json!([
-//!        {"category" : "reference","author" : "Nigel Rees","title" : "Sayings of the Century","price" : 8.95},
-//!        {"category" : "fiction","author" : "Evelyn Waugh","title" : "Sword of Honour","price" : 12.99}
 //!             ]);
-//!    assert_eq!(ret, json);
 //!
-//!    //
+//! assert_eq!(selector("$..book[:2]").unwrap(),
-//!    // $..book[2:]
+//!             vec![
-//!    //
+//!                 &json!({"category" : "reference","author" : "Nigel Rees","title" : "Sayings of the Century","price" : 8.95}),
-//!    let json = selector("$..book[2:]").unwrap();
+//!                 &json!({"category" : "fiction","author" : "Evelyn Waugh","title" : "Sword of Honour","price" : 12.99})
-//!    let ret = json!([
-//!        {"category" : "fiction","author" : "Herman Melville","title" : "Moby Dick","isbn" : "0-553-21311-3","price" : 8.99},
-//!        {"category" : "fiction","author" : "J. R. R. Tolkien","title" : "The Lord of the Rings","isbn" : "0-395-19395-8","price" : 22.99}
 //!             ]);
-//!    assert_eq!(ret, json);
 //!
-//!    //
+//! assert_eq!(selector("$..book[:2]").unwrap(),
-//!    // $..book[?(@.isbn)]
+//!             vec![
-//!    //
+//!                 &json!({"category" : "reference","author" : "Nigel Rees","title" : "Sayings of the Century","price" : 8.95}),
-//!    let json = selector("$..book[?(@.isbn)]").unwrap();
+//!                 &json!({"category" : "fiction","author" : "Evelyn Waugh","title" : "Sword of Honour","price" : 12.99})
-//!    let ret = json!([
-//!        {"category" : "fiction","author" : "Herman Melville","title" : "Moby Dick","isbn" : "0-553-21311-3","price" : 8.99},
-//!        {"category" : "fiction","author" : "J. R. R. Tolkien","title" : "The Lord of the Rings","isbn" : "0-395-19395-8","price" : 22.99}
 //!             ]);
-//!    assert_eq!(ret, json);
 //!
-//!    //
+//! assert_eq!(selector("$..book[?(@.isbn)]").unwrap(),
-//!    // $.store.book[?(@.price < 10)]
+//!             vec![
-//!    //
+//!                 &json!({"category" : "fiction","author" : "Herman Melville","title" : "Moby Dick","isbn" : "0-553-21311-3","price" : 8.99}),
-//!    let json = selector("$.store.book[?(@.price < 10)]").unwrap();
+//!                 &json!({"category" : "fiction","author" : "J. R. R. Tolkien","title" : "The Lord of the Rings","isbn" : "0-395-19395-8","price" : 22.99})
-//!    let ret = json!([
+//!             ]);
-//!        {"category" : "reference","author" : "Nigel Rees","title" : "Sayings of the Century","price" : 8.95},
+//!
-//!        {"category" : "fiction","author" : "Herman Melville","title" : "Moby Dick","isbn" : "0-553-21311-3","price" : 8.99}
+//! assert_eq!(selector("$.store.book[?(@.price < 10)]").unwrap(),
+//!             vec![
+//!                 &json!({"category" : "reference","author" : "Nigel Rees","title" : "Sayings of the Century","price" : 8.95}),
+//!                 &json!({"category" : "fiction","author" : "Herman Melville","title" : "Moby Dick","isbn" : "0-553-21311-3","price" : 8.99})
 //!             ]);
-//!    assert_eq!(ret, json);
 //! ```
-
+extern crate array_tool;
 extern crate core;
 extern crate env_logger;
 extern crate indexmap;
 #[macro_use]
 extern crate log;
-#[macro_use]
 extern crate serde;
 extern crate serde_json;
 
-use core::borrow::BorrowMut;
-use std::result;
-
 use serde_json::Value;
 
-#[doc(hidden)]
+pub use parser::parser::{Node, Parser};
-pub mod parser;
+pub use select::{Selector, SelectorMut};
-#[doc(hidden)]
+pub use select::JsonPathError;
-pub mod filter;
-#[doc(hidden)]
-pub mod ref_value;
-#[doc(hidden)]
-pub mod select;
 
-pub use select::Selector;
+#[doc(hidden)]
+mod parser;
+#[doc(hidden)]
+mod select;
 
-/// It is a high-order function. it compile a JsonPath and then returns a function. this return-function can be reused for different JsonObjects.
+/// It is a high-order function. it compile a jsonpath and then returns a closure that has JSON as argument. if you need to reuse a jsonpath, it is good for performance.
 ///
 /// ```rust
 /// extern crate jsonpath_lib as jsonpath;
 /// #[macro_use] extern crate serde_json;
 ///
-/// let mut template = jsonpath::compile("$..friends[0]");
+/// let mut first_firend = jsonpath::compile("$..friends[0]");
 ///
 /// let json_obj = json!({
 ///     "school": {
@@ -203,25 +162,27 @@ pub use select::Selector;
 ///         {"name": "친구4"}
 /// ]});
 ///
-/// let json = template(&json_obj).unwrap();
+/// let json = first_firend(&json_obj).unwrap();
-/// let ret = json!([
+///
-///     {"name": "친구3", "age": 30},
+/// assert_eq!(json, vec![
-///     {"name": "친구1", "age": 20}
+///     &json!({"name": "친구3", "age": 30}),
+///     &json!({"name": "친구1", "age": 20})
 /// ]);
-/// assert_eq!(json, ret);
 /// ```
-pub fn compile<'a>(path: &'a str) -> impl FnMut(&Value) -> result::Result<Value, String> + 'a {
+pub fn compile(path: &str) -> impl FnMut(&Value) -> Result<Vec<&Value>, JsonPathError> {
-    let mut selector = Selector::new();
+    let node = Parser::compile(path);
-    let _ = selector.path(path);
-    let mut selector = Box::new(selector);
     move |json| {
-        let s: &mut Selector = selector.borrow_mut();
+        match &node {
-        let _ = s.value(&json);
+            Ok(node) => {
-        s.select_as_value()
+                let mut selector = Selector::new();
+                selector.compiled_path(node).value(json).select()
+            }
+            Err(e) => Err(JsonPathError::Path(e.to_string()))
+        }
     }
 }
 
-/// It is a high-order function that return a function. this return-function has a jsonpath as argument and return a serde_json::value::Value. so you can use different JsonPath for one JsonObject.
+/// It is a high-order function. it returns a closure that has a jsonpath string as argument. you can use diffenent jsonpath for one JSON object.
 ///
 /// ```rust
 /// extern crate jsonpath_lib as jsonpath;
@@ -242,30 +203,28 @@ pub fn compile<'a>(path: &'a str) -> impl FnMut(&Value) -> result::Result<Value,
 /// let mut selector = jsonpath::selector(&json_obj);
 ///
 /// let json = selector("$..friends[0]").unwrap();
-/// let ret = json!([
+///
-///     {"name": "친구3", "age": 30},
+/// assert_eq!(json, vec![
-///     {"name": "친구1", "age": 20}
+///     &json!({"name": "친구3", "age": 30}),
+///     &json!({"name": "친구1", "age": 20})
 /// ]);
-/// assert_eq!(json, ret);
 ///
 /// let json = selector("$..friends[1]").unwrap();
-/// let ret = json!([
+///
-///     {"name": "친구4"},
+/// assert_eq!(json, vec![
-///     {"name": "친구2", "age": 20}
+///     &json!({"name": "친구4"}),
+///     &json!({"name": "친구2", "age": 20})
 /// ]);
-/// assert_eq!(json, ret);
 /// ```
-pub fn selector<'a>(json: &Value) -> impl FnMut(&'a str) -> result::Result<Value, String> {
+pub fn selector<'a>(json: &'a Value) -> impl FnMut(&'a str) -> Result<Vec<&Value>, JsonPathError> {
     let mut selector = Selector::new();
-    let _ = selector.value(json.into());
+    let _ = selector.value(json);
-    let mut selector = Box::new(selector);
+    move |path: &str| {
-    move |path: &'a str| {
+        selector.str_path(path)?.reset_value().select()
-        let s: &mut Selector = selector.borrow_mut();
-        s.path(path)?.select_as_value()
     }
 }
 
-/// It is a high-order function that returns a function. this return-function has a jsonpath as argument and return a serde::Deserialize. so you can use different JsonPath for one JsonObject.
+/// It is the same to `selector` function. but it deserialize the result as given type `T`.
 ///
 /// ```rust
 /// extern crate jsonpath_lib as jsonpath;
@@ -286,15 +245,16 @@ pub fn selector<'a>(json: &Value) -> impl FnMut(&'a str) -> result::Result<Value
 ///         {"name": "친구4"}
 /// ]});
 ///
-/// #[derive(Serialize, Deserialize, PartialEq, Debug)]
+/// #[derive(Deserialize, PartialEq, Debug)]
 /// struct Friend {
 ///     name: String,
 ///     age: Option<u8>,
 /// }
 ///
-/// let mut selector = jsonpath::selector_as::<Vec<Friend>>(&json_obj);
+/// let mut selector = jsonpath::selector_as::<Friend>(&json_obj);
 ///
 /// let json = selector("$..friends[0]").unwrap();
+///
 /// let ret = vec!(
 ///     Friend { name: "친구3".to_string(), age: Some(30) },
 ///     Friend { name: "친구1".to_string(), age: Some(20) }
@@ -302,26 +262,23 @@ pub fn selector<'a>(json: &Value) -> impl FnMut(&'a str) -> result::Result<Value
 /// assert_eq!(json, ret);
 ///
 /// let json = selector("$..friends[1]").unwrap();
+///
 /// let ret = vec!(
 ///     Friend { name: "친구4".to_string(), age: None },
 ///     Friend { name: "친구2".to_string(), age: Some(20) }
 /// );
+///
 /// assert_eq!(json, ret);
 /// ```
-pub fn selector_as<T: serde::de::DeserializeOwned>(json: &Value) -> impl FnMut(&str) -> result::Result<T, String> {
+pub fn selector_as<T: serde::de::DeserializeOwned>(json: &Value) -> impl FnMut(&str) -> Result<Vec<T>, JsonPathError> + '_ {
     let mut selector = Selector::new();
-    let _ = selector.value(json.into());
+    let _ = selector.value(json);
     move |path: &str| {
-        selector.path(path)?.select_as()
+        selector.str_path(path)?.reset_value().select_as()
     }
 }
 
-#[deprecated(since = "0.1.4", note = "Please use the selector function instead")]
+/// It is a simple select function. but it compile the jsonpath argument every time.
-pub fn reader<'a>(json: &Value) -> impl FnMut(&'a str) -> result::Result<Value, String> {
-    selector(json)
-}
-
-/// This function compile a jsonpath everytime and it convert `serde_json's Value` to `jsonpath's RefValue` everytime and then it return a `serde_json::value::Value`.
 ///
 /// ```rust
 /// extern crate jsonpath_lib as jsonpath;
@@ -341,28 +298,16 @@ pub fn reader<'a>(json: &Value) -> impl FnMut(&'a str) -> result::Result<Value,
 ///
 /// let json = jsonpath::select(&json_obj, "$..friends[0]").unwrap();
 ///
-/// let ret = json!([
+/// assert_eq!(json, vec![
-///     {"name": "친구3", "age": 30},
+///     &json!({"name": "친구3", "age": 30}),
-///     {"name": "친구1", "age": 20}
+///     &json!({"name": "친구1", "age": 20})
 /// ]);
-/// assert_eq!(json, ret);
 /// ```
-pub fn select(json: &Value, path: &str) -> result::Result<Value, String> {
+pub fn select<'a>(json: &'a Value, path: &'a str) -> Result<Vec<&'a Value>, JsonPathError> {
-    let mut selector = Selector::new();
+    Selector::new().str_path(path)?.value(json).select()
-    selector.path(path)?.value(json.into())?.select_as_value()
 }
 
-#[deprecated(since = "0.1.4", note = "Please use the select function instead")]
+/// It is the same to `select` function but it return the result as string.
-pub fn read(json: &Value, path: &str) -> result::Result<Value, String> {
-    select(json, path)
-}
-
-#[deprecated(since = "0.1.7", note = "Please use the select_as_str function instead")]
-pub fn select_str(json: &str, path: &str) -> result::Result<String, String> {
-    select_as_str(json, path)
-}
-
-/// This function compile a jsonpath everytime and it convert `&str` to `jsonpath's RefValue` everytime and then it return a json string.
 ///
 /// ```rust
 /// extern crate jsonpath_lib as jsonpath;
@@ -385,14 +330,13 @@ pub fn select_str(json: &str, path: &str) -> result::Result<String, String> {
 ///
 /// assert_eq!(ret, r#"[{"name":"친구3","age":30},{"name":"친구1","age":20}]"#);
 /// ```
-pub fn select_as_str(json: &str, path: &str) -> result::Result<String, String> {
+pub fn select_as_str(json_str: &str, path: &str) -> Result<String, JsonPathError> {
-    Selector::new()
+    let json = serde_json::from_str(json_str).map_err(|e| JsonPathError::Serde(e.to_string()))?;
-        .path(path)?
+    let ret = Selector::new().str_path(path)?.value(&json).select()?;
-        .value_from_str(json)?
+    serde_json::to_string(&ret).map_err(|e| JsonPathError::Serde(e.to_string()))
-        .select_as_str()
 }
 
-/// This function compile a jsonpath everytime and it convert `&str` to `jsonpath's RefValue` everytime and then it return a deserialized-instance of type `T`.
+/// It is the same to `select` function but it deserialize the the result as given type `T`.
 ///
 /// ```rust
 /// extern crate jsonpath_lib as jsonpath;
@@ -408,7 +352,7 @@ pub fn select_as_str(json: &str, path: &str) -> result::Result<String, String> {
 ///     phones: Vec<String>,
 /// }
 ///
-/// let ret: Person = jsonpath::select_as(r#"
+/// let ret: Vec<Person> = jsonpath::select_as(r#"
 /// {
 ///     "person":
 ///         {
@@ -428,11 +372,97 @@ pub fn select_as_str(json: &str, path: &str) -> result::Result<String, String> {
 ///     phones: vec!["+44 1234567".to_string(), "+44 2345678".to_string()],
 /// };
 ///
-/// assert_eq!(person, ret);
+/// assert_eq!(ret[0], person);
 /// ```
-pub fn select_as<T: serde::de::DeserializeOwned>(json: &str, path: &str) -> result::Result<T, String> {
+pub fn select_as<T: serde::de::DeserializeOwned>(json_str: &str, path: &str) -> Result<Vec<T>, JsonPathError> {
-    Selector::new()
+    let json = serde_json::from_str(json_str).map_err(|e| JsonPathError::Serde(e.to_string()))?;
-        .path(path)?
+    Selector::new().str_path(path)?.value(&json).select_as()
-        .value_from_str(json)?
+}
-        .select_as()
+
+/// Delete(= replace with null) the JSON property using the jsonpath.
+///
+/// ```rust
+/// extern crate jsonpath_lib as jsonpath;
+/// #[macro_use] extern crate serde_json;
+///
+/// let json_obj = json!({
+///     "school": {
+///         "friends": [
+///             {"name": "친구1", "age": 20},
+///             {"name": "친구2", "age": 20}
+///         ]
+///     },
+///     "friends": [
+///         {"name": "친구3", "age": 30},
+///         {"name": "친구4"}
+/// ]});
+///
+/// let ret = jsonpath::delete(json_obj, "$..[?(20 == @.age)]").unwrap();
+///
+/// assert_eq!(ret, json!({
+///     "school": {
+///         "friends": [
+///             null,
+///             null
+///         ]
+///     },
+///     "friends": [
+///         {"name": "친구3", "age": 30},
+///         {"name": "친구4"}
+/// ]}));
+/// ```
+pub fn delete(value: Value, path: &str) -> Result<Value, JsonPathError> {
+    let mut selector = SelectorMut::new();
+    let ret = selector.str_path(path)?.value(value).delete()?.take().unwrap_or(Value::Null);
+    Ok(ret)
+}
+
+/// Select JSON properties using a jsonpath and transform the result and then replace it. via closure that implements `FnMut` you can transform the selected results.
+///
+/// ```rust
+/// extern crate jsonpath_lib as jsonpath;
+/// #[macro_use] extern crate serde_json;
+///
+/// use serde_json::Value;
+///
+/// let json_obj = json!({
+///     "school": {
+///         "friends": [
+///             {"name": "친구1", "age": 20},
+///             {"name": "친구2", "age": 20}
+///         ]
+///     },
+///     "friends": [
+///         {"name": "친구3", "age": 30},
+///         {"name": "친구4"}
+/// ]});
+///
+/// let ret = jsonpath::replace_with(json_obj, "$..[?(@.age == 20)].age", &mut |v| {
+///     let age = if let Value::Number(n) = v {
+///         n.as_u64().unwrap() * 2
+///     } else {
+///         0
+///     };
+///
+///     json!(age)
+/// }).unwrap();
+///
+/// assert_eq!(ret, json!({
+///     "school": {
+///         "friends": [
+///             {"name": "친구1", "age": 40},
+///             {"name": "친구2", "age": 40}
+///         ]
+///     },
+///     "friends": [
+///         {"name": "친구3", "age": 30},
+///         {"name": "친구4"}
+/// ]}));
+/// ```
+pub fn replace_with<F>(value: Value, path: &str, fun: &mut F) -> Result<Value, JsonPathError>
+    where F: FnMut(&Value) -> Value
+{
+    let mut selector = SelectorMut::new();
+    let ret = selector.str_path(path)?.value(value).replace_with(fun)?.take().unwrap_or(Value::Null);
+    Ok(ret)
 }

src/parser/mod.rs

@@ -1,3 +1,524 @@
 mod path_reader;
-pub mod tokenizer;
+pub(crate) mod tokenizer;
 pub mod parser;
+
+#[cfg(test)]
+mod parser_tests {
+    use parser::parser::{ParseToken, Parser, NodeVisitor, FilterToken};
+
+    struct NodeVisitorTestImpl<'a> {
+        input: &'a str,
+        stack: Vec<ParseToken>,
+    }
+
+    impl<'a> NodeVisitorTestImpl<'a> {
+        fn new(input: &'a str) -> Self {
+            NodeVisitorTestImpl { input, stack: Vec::new() }
+        }
+
+        fn start(&mut self) -> Result<Vec<ParseToken>, String> {
+            let node = Parser::compile(self.input)?;
+            self.visit(&node);
+            Ok(self.stack.split_off(0))
+        }
+    }
+
+    impl<'a> NodeVisitor for NodeVisitorTestImpl<'a> {
+        fn visit_token(&mut self, token: &ParseToken) {
+            self.stack.push(token.clone());
+        }
+    }
+
+    fn setup() {
+        let _ = env_logger::try_init();
+    }
+
+    fn run(input: &str) -> Result<Vec<ParseToken>, String> {
+        let mut interpreter = NodeVisitorTestImpl::new(input);
+        interpreter.start()
+    }
+
+    #[test]
+    fn parse_path() {
+        setup();
+
+        assert_eq!(run("$.aa"), Ok(vec![
+            ParseToken::Absolute,
+            ParseToken::In,
+            ParseToken::Key("aa".to_owned())
+        ]));
+
+        assert_eq!(run("$.00.a"), Ok(vec![
+            ParseToken::Absolute,
+            ParseToken::In,
+            ParseToken::Key("00".to_owned()),
+            ParseToken::In,
+            ParseToken::Key("a".to_owned())
+        ]));
+
+        assert_eq!(run("$.00.韓창.seok"), Ok(vec![
+            ParseToken::Absolute,
+            ParseToken::In,
+            ParseToken::Key("00".to_owned()),
+            ParseToken::In,
+            ParseToken::Key("韓창".to_owned()),
+            ParseToken::In,
+            ParseToken::Key("seok".to_owned())
+        ]));
+
+        assert_eq!(run("$.*"), Ok(vec![
+            ParseToken::Absolute,
+            ParseToken::In,
+            ParseToken::All
+        ]));
+
+        assert_eq!(run("$..*"), Ok(vec![
+            ParseToken::Absolute,
+            ParseToken::Leaves,
+            ParseToken::All
+        ]));
+
+        assert_eq!(run("$..[0]"), Ok(vec![
+            ParseToken::Absolute,
+            ParseToken::Leaves,
+            ParseToken::Array,
+            ParseToken::Number(0.0),
+            ParseToken::ArrayEof
+        ]));
+
+        match run("$.") {
+            Ok(_) => panic!(),
+            _ => {}
+        }
+
+        match run("$..") {
+            Ok(_) => panic!(),
+            _ => {}
+        }
+
+        match run("$. a") {
+            Ok(_) => panic!(),
+            _ => {}
+        }
+    }
+
+    #[test]
+    fn parse_array_sytax() {
+        setup();
+
+        assert_eq!(run("$.book[?(@.isbn)]"), Ok(vec![
+            ParseToken::Absolute,
+            ParseToken::In,
+            ParseToken::Key("book".to_string()),
+            ParseToken::Array,
+            ParseToken::Relative,
+            ParseToken::In,
+            ParseToken::Key("isbn".to_string()),
+            ParseToken::ArrayEof
+        ]));
+
+        //
+        // Array도 컨텍스트 In으로 간주 할거라서 중첩되면 하나만
+        //
+        assert_eq!(run("$.[*]"), Ok(vec![
+            ParseToken::Absolute,
+            ParseToken::Array,
+            ParseToken::All,
+            ParseToken::ArrayEof
+        ]));
+
+        assert_eq!(run("$.a[*]"), Ok(vec![
+            ParseToken::Absolute, ParseToken::In, ParseToken::Key("a".to_owned()),
+            ParseToken::Array,
+            ParseToken::All,
+            ParseToken::ArrayEof
+        ]));
+
+        assert_eq!(run("$.a[*].가"), Ok(vec![
+            ParseToken::Absolute, ParseToken::In, ParseToken::Key("a".to_owned()),
+            ParseToken::Array,
+            ParseToken::All,
+            ParseToken::ArrayEof,
+            ParseToken::In, ParseToken::Key("가".to_owned())
+        ]));
+
+        assert_eq!(run("$.a[0][1]"), Ok(vec![
+            ParseToken::Absolute, ParseToken::In, ParseToken::Key("a".to_owned()),
+            ParseToken::Array,
+            ParseToken::Number(0_f64),
+            ParseToken::ArrayEof,
+            ParseToken::Array,
+            ParseToken::Number(1_f64),
+            ParseToken::ArrayEof
+        ]));
+
+        assert_eq!(run("$.a[1,2]"), Ok(vec![
+            ParseToken::Absolute, ParseToken::In, ParseToken::Key("a".to_owned()),
+            ParseToken::Array,
+            ParseToken::Union(vec![1, 2]),
+            ParseToken::ArrayEof
+        ]));
+
+        assert_eq!(run("$.a[10:]"), Ok(vec![
+            ParseToken::Absolute, ParseToken::In, ParseToken::Key("a".to_owned()),
+            ParseToken::Array,
+            ParseToken::Range(Some(10), None),
+            ParseToken::ArrayEof
+        ]));
+
+        assert_eq!(run("$.a[:11]"), Ok(vec![
+            ParseToken::Absolute, ParseToken::In, ParseToken::Key("a".to_owned()),
+            ParseToken::Array,
+            ParseToken::Range(None, Some(11)),
+            ParseToken::ArrayEof
+        ]));
+
+        assert_eq!(run("$.a[-12:13]"), Ok(vec![
+            ParseToken::Absolute, ParseToken::In, ParseToken::Key("a".to_owned()),
+            ParseToken::Array,
+            ParseToken::Range(Some(-12), Some(13)),
+            ParseToken::ArrayEof
+        ]));
+
+        assert_eq!(run("$.a[?(1>2)]"), Ok(vec![
+            ParseToken::Absolute, ParseToken::In, ParseToken::Key("a".to_owned()),
+            ParseToken::Array,
+            ParseToken::Number(1_f64), ParseToken::Number(2_f64), ParseToken::Filter(FilterToken::Greater),
+            ParseToken::ArrayEof
+        ]));
+
+        assert_eq!(run("$.a[?($.b>3)]"), Ok(vec![
+            ParseToken::Absolute, ParseToken::In, ParseToken::Key("a".to_owned()),
+            ParseToken::Array,
+            ParseToken::Absolute, ParseToken::In, ParseToken::Key("b".to_owned()), ParseToken::Number(3_f64), ParseToken::Filter(FilterToken::Greater),
+            ParseToken::ArrayEof
+        ]));
+
+        assert_eq!(run("$[?($.c>@.d && 1==2)]"), Ok(vec![
+            ParseToken::Absolute,
+            ParseToken::Array,
+            ParseToken::Absolute, ParseToken::In, ParseToken::Key("c".to_owned()),
+            ParseToken::Relative, ParseToken::In, ParseToken::Key("d".to_owned()),
+            ParseToken::Filter(FilterToken::Greater),
+            ParseToken::Number(1_f64), ParseToken::Number(2_f64), ParseToken::Filter(FilterToken::Equal),
+            ParseToken::Filter(FilterToken::And),
+            ParseToken::ArrayEof
+        ]));
+
+        assert_eq!(run("$[?($.c>@.d&&(1==2||3>=4))]"), Ok(vec![
+            ParseToken::Absolute,
+            ParseToken::Array,
+            ParseToken::Absolute, ParseToken::In, ParseToken::Key("c".to_owned()),
+            ParseToken::Relative, ParseToken::In, ParseToken::Key("d".to_owned()),
+            ParseToken::Filter(FilterToken::Greater),
+            ParseToken::Number(1_f64), ParseToken::Number(2_f64), ParseToken::Filter(FilterToken::Equal),
+            ParseToken::Number(3_f64), ParseToken::Number(4_f64), ParseToken::Filter(FilterToken::GreaterOrEqual),
+            ParseToken::Filter(FilterToken::Or),
+            ParseToken::Filter(FilterToken::And),
+            ParseToken::ArrayEof
+        ]));
+
+        assert_eq!(run("$[?(@.a<@.b)]"), Ok(vec![
+            ParseToken::Absolute,
+            ParseToken::Array,
+            ParseToken::Relative, ParseToken::In, ParseToken::Key("a".to_owned()),
+            ParseToken::Relative, ParseToken::In, ParseToken::Key("b".to_owned()),
+            ParseToken::Filter(FilterToken::Little),
+            ParseToken::ArrayEof
+        ]));
+
+        assert_eq!(run("$[*][*][*]"), Ok(vec![
+            ParseToken::Absolute,
+            ParseToken::Array,
+            ParseToken::All,
+            ParseToken::ArrayEof,
+            ParseToken::Array,
+            ParseToken::All,
+            ParseToken::ArrayEof,
+            ParseToken::Array,
+            ParseToken::All,
+            ParseToken::ArrayEof
+        ]));
+
+        assert_eq!(run("$['a']['bb']"), Ok(vec![
+            ParseToken::Absolute,
+            ParseToken::Array,
+            ParseToken::Key("a".to_string()),
+            ParseToken::ArrayEof,
+            ParseToken::Array,
+            ParseToken::Key("bb".to_string()),
+            ParseToken::ArrayEof
+        ]));
+
+        assert_eq!(run("$.a[?(@.e==true)]"), Ok(vec![
+            ParseToken::Absolute,
+            ParseToken::In,
+            ParseToken::Key("a".to_string()),
+            ParseToken::Array,
+            ParseToken::Relative,
+            ParseToken::In,
+            ParseToken::Key("e".to_string()),
+            ParseToken::Bool(true),
+            ParseToken::Filter(FilterToken::Equal),
+            ParseToken::ArrayEof
+        ]));
+
+        match run("$[") {
+            Ok(_) => panic!(),
+            _ => {}
+        }
+
+        match run("$[]") {
+            Ok(_) => panic!(),
+            _ => {}
+        }
+
+        match run("$[a]") {
+            Ok(_) => panic!(),
+            _ => {}
+        }
+
+        match run("$[?($.a)]") {
+            Ok(_) => panic!(),
+            _ => {}
+        }
+
+        match run("$[?(@.a > @.b]") {
+            Ok(_) => panic!(),
+            _ => {}
+        }
+
+        match run("$[?(@.a < @.b&&(@.c < @.d)]") {
+            Ok(_) => panic!(),
+            _ => {}
+        }
+    }
+
+    #[test]
+    fn parse_array_float() {
+        setup();
+
+        assert_eq!(run("$[?(1.1<2.1)]"), Ok(vec![
+            ParseToken::Absolute,
+            ParseToken::Array,
+            ParseToken::Number(1.1), ParseToken::Number(2.1), ParseToken::Filter(FilterToken::Little),
+            ParseToken::ArrayEof
+        ]));
+
+        match run("$[1.1]") {
+            Ok(_) => panic!(),
+            _ => {}
+        }
+
+        match run("$[?(1.1<.2)]") {
+            Ok(_) => panic!(),
+            _ => {}
+        }
+
+        match run("$[?(1.1<2.)]") {
+            Ok(_) => panic!(),
+            _ => {}
+        }
+
+        match run("$[?(1.1<2.a)]") {
+            Ok(_) => panic!(),
+            _ => {}
+        }
+    }
+}
+
+#[cfg(test)]
+mod tokenizer_tests {
+    use parser::tokenizer::{Token, TokenError, Tokenizer, TokenReader};
+
+    fn collect_token(input: &str) -> (Vec<Token>, Option<TokenError>) {
+        let mut tokenizer = Tokenizer::new(input);
+        let mut vec = vec![];
+        loop {
+            match tokenizer.next_token() {
+                Ok(t) => vec.push(t),
+                Err(e) => return (vec, Some(e)),
+            }
+        }
+    }
+
+    fn run(input: &str, expected: (Vec<Token>, Option<TokenError>)) {
+        let (vec, err) = collect_token(input.clone());
+        assert_eq!((vec, err), expected, "\"{}\"", input);
+    }
+
+    #[test]
+    fn peek() {
+        let mut tokenizer = TokenReader::new("$.a");
+        match tokenizer.next_token() {
+            Ok(t) => assert_eq!(Token::Absolute(0), t),
+            _ => panic!()
+        }
+
+        match tokenizer.peek_token() {
+            Ok(t) => assert_eq!(&Token::Dot(1), t),
+            _ => panic!()
+        }
+
+        match tokenizer.peek_token() {
+            Ok(t) => assert_eq!(&Token::Dot(1), t),
+            _ => panic!()
+        }
+
+        match tokenizer.next_token() {
+            Ok(t) => assert_eq!(Token::Dot(1), t),
+            _ => panic!()
+        }
+    }
+
+    #[test]
+    fn token() {
+        run("$.01.a",
+            (
+                vec![
+                    Token::Absolute(0),
+                    Token::Dot(1),
+                    Token::Key(2, "01".to_string()),
+                    Token::Dot(4),
+                    Token::Key(5, "a".to_string())
+                ]
+                , Some(TokenError::Eof)
+            ));
+
+        run("$.   []",
+            (
+                vec![
+                    Token::Absolute(0),
+                    Token::Dot(1),
+                    Token::Whitespace(2, 2),
+                    Token::OpenArray(5),
+                    Token::CloseArray(6)
+                ]
+                , Some(TokenError::Eof)
+            ));
+
+        run("$..",
+            (
+                vec![
+                    Token::Absolute(0),
+                    Token::Dot(1),
+                    Token::Dot(2),
+                ]
+                , Some(TokenError::Eof)
+            ));
+
+        run("$..ab",
+            (
+                vec![
+                    Token::Absolute(0),
+                    Token::Dot(1),
+                    Token::Dot(2),
+                    Token::Key(3, "ab".to_string())
+                ]
+                , Some(TokenError::Eof)
+            ));
+
+        run("$..가 [",
+            (
+                vec![
+                    Token::Absolute(0),
+                    Token::Dot(1),
+                    Token::Dot(2),
+                    Token::Key(3, "가".to_string()),
+                    Token::Whitespace(6, 0),
+                    Token::OpenArray(7),
+                ]
+                , Some(TokenError::Eof)
+            ));
+
+        run("[-1, 2 ]",
+            (
+                vec![
+                    Token::OpenArray(0),
+                    Token::Key(1, "-1".to_string()),
+                    Token::Comma(3),
+                    Token::Whitespace(4, 0),
+                    Token::Key(5, "2".to_string()),
+                    Token::Whitespace(6, 0),
+                    Token::CloseArray(7),
+                ]
+                , Some(TokenError::Eof)
+            ));
+
+        run("[ 1 2 , 3 \"abc\" : -10 ]",
+            (
+                vec![
+                    Token::OpenArray(0),
+                    Token::Whitespace(1, 0),
+                    Token::Key(2, "1".to_string()),
+                    Token::Whitespace(3, 0),
+                    Token::Key(4, "2".to_string()),
+                    Token::Whitespace(5, 0),
+                    Token::Comma(6),
+                    Token::Whitespace(7, 0),
+                    Token::Key(8, "3".to_string()),
+                    Token::Whitespace(9, 0),
+                    Token::DoubleQuoted(10, "abc".to_string()),
+                    Token::Whitespace(15, 0),
+                    Token::Split(16),
+                    Token::Whitespace(17, 0),
+                    Token::Key(18, "-10".to_string()),
+                    Token::Whitespace(21, 0),
+                    Token::CloseArray(22),
+                ]
+                , Some(TokenError::Eof)
+            ));
+
+        run("?(@.a가 <41.01)",
+            (
+                vec![
+                    Token::Question(0),
+                    Token::OpenParenthesis(1),
+                    Token::At(2),
+                    Token::Dot(3),
+                    Token::Key(4, "a가".to_string()),
+                    Token::Whitespace(8, 0),
+                    Token::Little(9),
+                    Token::Key(10, "41".to_string()),
+                    Token::Dot(12),
+                    Token::Key(13, "01".to_string()),
+                    Token::CloseParenthesis(15),
+                ]
+                , Some(TokenError::Eof)
+            ));
+
+        run("?(@.a <4a.01)",
+            (
+                vec![
+                    Token::Question(0),
+                    Token::OpenParenthesis(1),
+                    Token::At(2),
+                    Token::Dot(3),
+                    Token::Key(4, "a".to_string()),
+                    Token::Whitespace(5, 0),
+                    Token::Little(6),
+                    Token::Key(7, "4a".to_string()),
+                    Token::Dot(9),
+                    Token::Key(10, "01".to_string()),
+                    Token::CloseParenthesis(12),
+                ]
+                , Some(TokenError::Eof)
+            ));
+
+        run("?($.c>@.d)", (
+            vec![
+                Token::Question(0),
+                Token::OpenParenthesis(1),
+                Token::Absolute(2),
+                Token::Dot(3),
+                Token::Key(4, "c".to_string()),
+                Token::Greater(5),
+                Token::At(6),
+                Token::Dot(7),
+                Token::Key(8, "d".to_string()),
+                Token::CloseParenthesis(9)
+            ]
+            , Some(TokenError::Eof)
+        ));
+    }
+}

src/parser/parser.rs

@@ -1,5 +1,3 @@
-use std::result::Result;
-
 use super::tokenizer::*;
 
 const DUMMY: usize = 0;
@@ -7,7 +5,6 @@ const DUMMY: usize = 0;
 type ParseResult<T> = Result<T, String>;
 
 mod utils {
-
     pub fn string_to_isize<F>(string: &String, msg_handler: F) -> Result<isize, String>
         where F: Fn() -> String {
         match string.as_str().parse::<isize>() {
@@ -52,6 +49,8 @@ pub enum ParseToken {
 
     Number(f64),
 
+    Bool(bool),
+
     Eof,
 }
 
@@ -74,50 +73,39 @@ pub struct Node {
     token: ParseToken,
 }
 
-pub struct Parser<'a> {
+pub struct Parser;
-    tokenizer: PreloadedTokenizer<'a>
+
+impl Parser {
+    pub fn compile(input: &str) -> ParseResult<Node> {
+        let mut tokenizer = TokenReader::new(input);
+        Ok(Self::json_path(&mut tokenizer)?)
     }
 
-impl<'a> Parser<'a> {
+    fn json_path(tokenizer: &mut TokenReader) -> ParseResult<Node> {
-    pub fn new(input: &'a str) -> Self {
-        Parser { tokenizer: PreloadedTokenizer::new(input) }
-    }
-
-    pub fn compile(&mut self) -> ParseResult<Node> {
-        Ok(self.json_path()?)
-    }
-
-    pub fn parse<V: NodeVisitor>(&mut self, visitor: &mut V) -> ParseResult<()> {
-        let node = self.json_path()?;
-        visitor.visit(node);
-        Ok(())
-    }
-
-    fn json_path(&mut self) -> ParseResult<Node> {
         debug!("#json_path");
-        match self.tokenizer.next_token() {
+        match tokenizer.next_token() {
             Ok(Token::Absolute(_)) => {
-                let node = self.node(ParseToken::Absolute);
+                let node = Self::node(ParseToken::Absolute);
-                self.paths(node)
+                Self::paths(node, tokenizer)
             }
             _ => {
-                Err(self.tokenizer.err_msg())
+                Err(tokenizer.err_msg())
             }
         }
     }
 
-    fn paths(&mut self, prev: Node) -> ParseResult<Node> {
+    fn paths(prev: Node, tokenizer: &mut TokenReader) -> ParseResult<Node> {
         debug!("#paths");
-        match self.tokenizer.peek_token() {
+        match tokenizer.peek_token() {
             Ok(Token::Dot(_)) => {
-                self.eat_token();
+                Self::eat_token(tokenizer);
-                self.paths_dot(prev)
+                Self::paths_dot(prev, tokenizer)
             }
             Ok(Token::OpenArray(_)) => {
-                self.eat_token();
+                Self::eat_token(tokenizer);
-                self.eat_whitespace();
+                Self::eat_whitespace(tokenizer);
-                let node = self.array(prev)?;
+                let node = Self::array(prev, tokenizer)?;
-                self.paths(node)
+                Self::paths(node, tokenizer)
             }
             _ => {
                 Ok(prev)
@@ -125,10 +113,10 @@ impl<'a> Parser<'a> {
         }
     }
 
-    fn paths_dot(&mut self, prev: Node) -> ParseResult<Node> {
+    fn paths_dot(prev: Node, tokenizer: &mut TokenReader) -> ParseResult<Node> {
         debug!("#paths_dot");
-        let node = self.path(prev)?;
+        let node = Self::path(prev, tokenizer)?;
-        match self.tokenizer.peek_token() {
+        match tokenizer.peek_token() {
             Ok(Token::Equal(_))
             | Ok(Token::NotEqual(_))
             | Ok(Token::Little(_))
@@ -140,319 +128,331 @@ impl<'a> Parser<'a> {
                 Ok(node)
             }
             _ => {
-                self.paths(node)
+                Self::paths(node, tokenizer)
             }
         }
     }
 
-    fn path(&mut self, prev: Node) -> ParseResult<Node> {
+    fn path(prev: Node, tokenizer: &mut TokenReader) -> ParseResult<Node> {
         debug!("#path");
-        match self.tokenizer.peek_token() {
+        match tokenizer.peek_token() {
             Ok(Token::Dot(_)) => {
-                self.path_leaves(prev)
+                Self::path_leaves(prev, tokenizer)
             }
             Ok(Token::Asterisk(_)) => {
-                self.path_in_all(prev)
+                Self::path_in_all(prev, tokenizer)
             }
             Ok(Token::Key(_, _)) => {
-                self.path_in_key(prev)
+                Self::path_in_key(prev, tokenizer)
             }
             Ok(Token::OpenArray(_)) => {
-                self.eat_token();
+                Self::eat_token(tokenizer);
-                self.array(prev)
+                Self::array(prev, tokenizer)
             }
             _ => {
-                Err(self.tokenizer.err_msg())
+                Err(tokenizer.err_msg())
             }
         }
     }
 
-    fn path_leaves(&mut self, prev: Node) -> ParseResult<Node> {
+    fn path_leaves(prev: Node, tokenizer: &mut TokenReader) -> ParseResult<Node> {
         debug!("#path_leaves");
-        self.eat_token();
+        Self::eat_token(tokenizer);
-        match self.tokenizer.peek_token() {
+        match tokenizer.peek_token() {
             Ok(Token::Asterisk(_)) => {
-                self.path_leaves_all(prev)
+                Self::path_leaves_all(prev, tokenizer)
             }
             Ok(Token::OpenArray(_)) => {
-                let mut leaves_node = self.node(ParseToken::Leaves);
+                let mut leaves_node = Self::node(ParseToken::Leaves);
                 leaves_node.left = Some(Box::new(prev));
-                Ok(self.paths(leaves_node)?)
+                Ok(Self::paths(leaves_node, tokenizer)?)
             }
             _ => {
-                self.path_leaves_key(prev)
+                Self::path_leaves_key(prev, tokenizer)
             }
         }
     }
 
-    fn path_leaves_key(&mut self, prev: Node) -> ParseResult<Node> {
+    fn path_leaves_key(prev: Node, tokenizer: &mut TokenReader) -> ParseResult<Node> {
         debug!("#path_leaves_key");
         Ok(Node {
             token: ParseToken::Leaves,
             left: Some(Box::new(prev)),
-            right: Some(Box::new(self.key()?)),
+            right: Some(Box::new(Self::key(tokenizer)?)),
         })
     }
 
-    fn path_leaves_all(&mut self, prev: Node) -> ParseResult<Node> {
+    fn path_leaves_all(prev: Node, tokenizer: &mut TokenReader) -> ParseResult<Node> {
         debug!("#path_leaves_all");
-        self.eat_token();
+        Self::eat_token(tokenizer);
         Ok(Node {
             token: ParseToken::Leaves,
             left: Some(Box::new(prev)),
-            right: Some(Box::new(self.node(ParseToken::All))),
+            right: Some(Box::new(Self::node(ParseToken::All))),
         })
     }
 
-    fn path_in_all(&mut self, prev: Node) -> ParseResult<Node> {
+    fn path_in_all(prev: Node, tokenizer: &mut TokenReader) -> ParseResult<Node> {
         debug!("#path_in_all");
-        self.eat_token();
+        Self::eat_token(tokenizer);
         Ok(Node {
             token: ParseToken::In,
             left: Some(Box::new(prev)),
-            right: Some(Box::new(self.node(ParseToken::All))),
+            right: Some(Box::new(Self::node(ParseToken::All))),
         })
     }
 
-    fn path_in_key(&mut self, prev: Node) -> ParseResult<Node> {
+    fn path_in_key(prev: Node, tokenizer: &mut TokenReader) -> ParseResult<Node> {
         debug!("#path_in_key");
         Ok(Node {
             token: ParseToken::In,
             left: Some(Box::new(prev)),
-            right: Some(Box::new(self.key()?)),
+            right: Some(Box::new(Self::key(tokenizer)?)),
         })
     }
 
-    fn key(&mut self) -> ParseResult<Node> {
+    fn key(tokenizer: &mut TokenReader) -> ParseResult<Node> {
         debug!("#key");
-        match self.tokenizer.next_token() {
+        match tokenizer.next_token() {
             Ok(Token::Key(_, v)) => {
-                Ok(self.node(ParseToken::Key(v)))
+                Ok(Self::node(ParseToken::Key(v)))
             }
             _ => {
-                Err(self.tokenizer.err_msg())
+                Err(tokenizer.err_msg())
             }
         }
     }
 
-    fn array_quota_value(&mut self) -> ParseResult<Node> {
+    fn boolean(tokenizer: &mut TokenReader) -> ParseResult<Node> {
+        debug!("#boolean");
+        match tokenizer.next_token() {
+            Ok(Token::Key(_, v)) => {
+                Ok(Self::node(ParseToken::Bool(v.eq_ignore_ascii_case("true"))))
+            }
+            _ => {
+                Err(tokenizer.err_msg())
+            }
+        }
+    }
+
+    fn array_quota_value(tokenizer: &mut TokenReader) -> ParseResult<Node> {
         debug!("#array_quota_value");
-        match self.tokenizer.next_token() {
+        match tokenizer.next_token() {
             Ok(Token::SingleQuoted(_, val))
             | Ok(Token::DoubleQuoted(_, val)) => {
-                Ok(self.node(ParseToken::Key(val)))
+                Ok(Self::node(ParseToken::Key(val)))
             }
             Err(TokenError::Eof) => {
-                Ok(self.node(ParseToken::Eof))
+                Ok(Self::node(ParseToken::Eof))
             }
             _ => {
-                Err(self.tokenizer.err_msg())
+                Err(tokenizer.err_msg())
             }
         }
     }
 
-    fn array_start(&mut self, prev: Node) -> ParseResult<Node> {
+    fn array_start(prev: Node, tokenizer: &mut TokenReader) -> ParseResult<Node> {
         debug!("#array_start");
-        match self.tokenizer.peek_token() {
+        match tokenizer.peek_token() {
             Ok(Token::Question(_)) => {
-                self.eat_token();
+                Self::eat_token(tokenizer);
                 Ok(Node {
                     token: ParseToken::Array,
                     left: Some(Box::new(prev)),
-                    right: Some(Box::new(self.filter()?)),
+                    right: Some(Box::new(Self::filter(tokenizer)?)),
                 })
             }
             Ok(Token::Asterisk(_)) => {
-                self.eat_token();
+                Self::eat_token(tokenizer);
                 Ok(Node {
                     token: ParseToken::Array,
                     left: Some(Box::new(prev)),
-                    right: Some(Box::new(self.node(ParseToken::All))),
+                    right: Some(Box::new(Self::node(ParseToken::All))),
                 })
             }
             _ => {
                 Ok(Node {
                     token: ParseToken::Array,
                     left: Some(Box::new(prev)),
-                    right: Some(Box::new(self.array_value()?)),
+                    right: Some(Box::new(Self::array_value(tokenizer)?)),
                 })
             }
         }
     }
 
-    fn array(&mut self, prev: Node) -> ParseResult<Node> {
+    fn array(prev: Node, tokenizer: &mut TokenReader) -> ParseResult<Node> {
         debug!("#array");
-        let ret = self.array_start(prev)?;
+        let ret = Self::array_start(prev, tokenizer)?;
-        self.eat_whitespace();
+        Self::eat_whitespace(tokenizer);
-        self.close_token(ret, Token::CloseArray(DUMMY))
+        Self::close_token(ret, Token::CloseArray(DUMMY), tokenizer)
     }
 
-    fn array_value_key(&mut self) -> ParseResult<Node> {
+    fn array_value_key(tokenizer: &mut TokenReader) -> ParseResult<Node> {
         debug!("#array_value_key");
-        match self.tokenizer.next_token() {
+        match tokenizer.next_token() {
             Ok(Token::Key(pos, ref val)) => {
-                let digit = utils::string_to_isize(val, || self.tokenizer.err_msg_with_pos(pos))?;
+                let digit = utils::string_to_isize(val, || tokenizer.err_msg_with_pos(pos))?;
-                self.eat_whitespace();
+                Self::eat_whitespace(tokenizer);
 
-                match self.tokenizer.peek_token() {
+                match tokenizer.peek_token() {
                     Ok(Token::Comma(_)) => {
-                        self.union(digit)
+                        Self::union(digit, tokenizer)
                     }
                     Ok(Token::Split(_)) => {
-                        self.range_from(digit)
+                        Self::range_from(digit, tokenizer)
                     }
                     _ => {
-                        Ok(self.node(ParseToken::Number(digit as f64)))
+                        Ok(Self::node(ParseToken::Number(digit as f64)))
                     }
                 }
             }
             _ => {
-                Err(self.tokenizer.err_msg())
+                Err(tokenizer.err_msg())
             }
         }
     }
 
 
-    fn array_value(&mut self) -> ParseResult<Node> {
+    fn array_value(tokenizer: &mut TokenReader) -> ParseResult<Node> {
         debug!("#array_value");
-        match self.tokenizer.peek_token() {
+        match tokenizer.peek_token() {
             Ok(Token::Key(_, _)) => {
-                self.array_value_key()
+                Self::array_value_key(tokenizer)
             }
             Ok(Token::Split(_)) => {
-                self.eat_token();
+                Self::eat_token(tokenizer);
-                self.range_to()
+                Self::range_to(tokenizer)
             }
             Ok(Token::DoubleQuoted(_, _))
             | Ok(Token::SingleQuoted(_, _)) => {
-                self.array_quota_value()
+                Self::array_quota_value(tokenizer)
             }
             Err(TokenError::Eof) => {
-                Ok(self.node(ParseToken::Eof))
+                Ok(Self::node(ParseToken::Eof))
             }
             _ => {
-                self.eat_token();
+                Self::eat_token(tokenizer);
-                Err(self.tokenizer.err_msg())
+                Err(tokenizer.err_msg())
             }
         }
     }
 
-    fn union(&mut self, num: isize) -> ParseResult<Node> {
+    fn union(num: isize, tokenizer: &mut TokenReader) -> ParseResult<Node> {
         debug!("#union");
         let mut values = vec![num];
-        while match self.tokenizer.peek_token() {
+        while match tokenizer.peek_token() {
             Ok(Token::Comma(_)) => true,
             _ => false
         } {
-            self.eat_token();
+            Self::eat_token(tokenizer);
-            self.eat_whitespace();
+            Self::eat_whitespace(tokenizer);
-            match self.tokenizer.next_token() {
+            match tokenizer.next_token() {
                 Ok(Token::Key(pos, ref val)) => {
-                    let digit = utils::string_to_isize(val, || self.tokenizer.err_msg_with_pos(pos))?;
+                    let digit = utils::string_to_isize(val, || tokenizer.err_msg_with_pos(pos))?;
                     values.push(digit);
                 }
                 _ => {
-                    return Err(self.tokenizer.err_msg());
+                    return Err(tokenizer.err_msg());
                 }
             }
         }
-        Ok(self.node(ParseToken::Union(values)))
+        Ok(Self::node(ParseToken::Union(values)))
     }
 
-    fn range_from(&mut self, num: isize) -> ParseResult<Node> {
+    fn range_from(num: isize, tokenizer: &mut TokenReader) -> ParseResult<Node> {
         debug!("#range_from");
-        self.eat_token();
+        Self::eat_token(tokenizer);
-        self.eat_whitespace();
+        Self::eat_whitespace(tokenizer);
-        match self.tokenizer.peek_token() {
+        match tokenizer.peek_token() {
             Ok(Token::Key(_, _)) => {
-                self.range(num)
+                Self::range(num, tokenizer)
             }
             _ => {
-                Ok(self.node(ParseToken::Range(Some(num), None)))
+                Ok(Self::node(ParseToken::Range(Some(num), None)))
             }
         }
     }
 
-    fn range_to(&mut self) -> ParseResult<Node> {
+    fn range_to(tokenizer: &mut TokenReader) -> ParseResult<Node> {
         debug!("#range_to");
-        match self.tokenizer.next_token() {
+        match tokenizer.next_token() {
             Ok(Token::Key(pos, ref val)) => {
-                let digit = utils::string_to_isize(val, || self.tokenizer.err_msg_with_pos(pos))?;
+                let digit = utils::string_to_isize(val, || tokenizer.err_msg_with_pos(pos))?;
-                Ok(self.node(ParseToken::Range(None, Some(digit))))
+                Ok(Self::node(ParseToken::Range(None, Some(digit))))
             }
             _ => {
-                Err(self.tokenizer.err_msg())
+                Err(tokenizer.err_msg())
             }
         }
     }
 
-    fn range(&mut self, num: isize) -> ParseResult<Node> {
+    fn range(num: isize, tokenizer: &mut TokenReader) -> ParseResult<Node> {
         debug!("#range");
-        match self.tokenizer.next_token() {
+        match tokenizer.next_token() {
             Ok(Token::Key(pos, ref val)) => {
-                let digit = utils::string_to_isize(val, || self.tokenizer.err_msg_with_pos(pos))?;
+                let digit = utils::string_to_isize(val, || tokenizer.err_msg_with_pos(pos))?;
-                Ok(self.node(ParseToken::Range(Some(num), Some(digit))))
+                Ok(Self::node(ParseToken::Range(Some(num), Some(digit))))
             }
             _ => {
-                Err(self.tokenizer.err_msg())
+                Err(tokenizer.err_msg())
             }
         }
     }
 
-    fn filter(&mut self) -> ParseResult<Node> {
+    fn filter(tokenizer: &mut TokenReader) -> ParseResult<Node> {
         debug!("#filter");
-        match self.tokenizer.next_token() {
+        match tokenizer.next_token() {
             Ok(Token::OpenParenthesis(_)) => {
-                let ret = self.exprs()?;
+                let ret = Self::exprs(tokenizer)?;
-                self.eat_whitespace();
+                Self::eat_whitespace(tokenizer);
-                self.close_token(ret, Token::CloseParenthesis(DUMMY))
+                Self::close_token(ret, Token::CloseParenthesis(DUMMY), tokenizer)
             }
             Err(TokenError::Eof) => {
-                Ok(self.node(ParseToken::Eof))
+                Ok(Self::node(ParseToken::Eof))
             }
             _ => {
-                Err(self.tokenizer.err_msg())
+                Err(tokenizer.err_msg())
             }
         }
     }
 
-    fn exprs(&mut self) -> ParseResult<Node> {
+    fn exprs(tokenizer: &mut TokenReader) -> ParseResult<Node> {
-        self.eat_whitespace();
+        Self::eat_whitespace(tokenizer);
         debug!("#exprs");
-        let node = match self.tokenizer.peek_token() {
+        let node = match tokenizer.peek_token() {
             Ok(Token::OpenParenthesis(_)) => {
-                self.eat_token();
+                Self::eat_token(tokenizer);
                 trace!("\t-exprs - open_parenthesis");
-                let ret = self.exprs()?;
+                let ret = Self::exprs(tokenizer)?;
-                self.eat_whitespace();
+                Self::eat_whitespace(tokenizer);
-                self.close_token(ret, Token::CloseParenthesis(DUMMY))?
+                Self::close_token(ret, Token::CloseParenthesis(DUMMY), tokenizer)?
             }
             _ => {
                 trace!("\t-exprs - else");
-                self.expr()?
+                Self::expr(tokenizer)?
             }
         };
-        self.eat_whitespace();
+        Self::eat_whitespace(tokenizer);
-        self.condition_expr(node)
+        Self::condition_expr(node, tokenizer)
     }
 
-    fn condition_expr(&mut self, prev: Node) -> ParseResult<Node> {
+    fn condition_expr(prev: Node, tokenizer: &mut TokenReader) -> ParseResult<Node> {
         debug!("#condition_expr");
-        match self.tokenizer.peek_token() {
+        match tokenizer.peek_token() {
             Ok(Token::And(_)) => {
-                self.eat_token();
+                Self::eat_token(tokenizer);
                 Ok(Node {
                     token: ParseToken::Filter(FilterToken::And),
                     left: Some(Box::new(prev)),
-                    right: Some(Box::new(self.exprs()?)),
+                    right: Some(Box::new(Self::exprs(tokenizer)?)),
                 })
             }
             Ok(Token::Or(_)) => {
-                self.eat_token();
+                Self::eat_token(tokenizer);
                 Ok(Node {
                     token: ParseToken::Filter(FilterToken::Or),
                     left: Some(Box::new(prev)),
-                    right: Some(Box::new(self.exprs()?)),
+                    right: Some(Box::new(Self::exprs(tokenizer)?)),
                 })
             }
             _ => {
@@ -461,18 +461,18 @@ impl<'a> Parser<'a> {
         }
     }
 
-    fn expr(&mut self) -> ParseResult<Node> {
+    fn expr(tokenizer: &mut TokenReader) -> ParseResult<Node> {
         debug!("#expr");
 
-        let has_prop_candidate = match self.tokenizer.peek_token() {
+        let has_prop_candidate = match tokenizer.peek_token() {
             Ok(Token::At(_)) => true,
             _ => false
         };
 
-        let node = self.term()?;
+        let node = Self::term(tokenizer)?;
-        self.eat_whitespace();
+        Self::eat_whitespace(tokenizer);
 
-        if match self.tokenizer.peek_token() {
+        if match tokenizer.peek_token() {
             Ok(Token::Equal(_))
             | Ok(Token::NotEqual(_))
             | Ok(Token::Little(_))
@@ -481,91 +481,108 @@ impl<'a> Parser<'a> {
             | Ok(Token::GreaterOrEqual(_)) => true,
             _ => false
         } {
-            self.op(node)
+            Self::op(node, tokenizer)
         } else if has_prop_candidate {
             Ok(node)
         } else {
-            return Err(self.tokenizer.err_msg());
+            return Err(tokenizer.err_msg());
         }
     }
 
-    fn term_num(&mut self) -> ParseResult<Node> {
+    fn term_num(tokenizer: &mut TokenReader) -> ParseResult<Node> {
         debug!("#term_num");
-        match self.tokenizer.next_token() {
+        match tokenizer.next_token() {
             Ok(Token::Key(pos, val)) => {
-                match self.tokenizer.peek_token() {
+                match tokenizer.peek_token() {
                     Ok(Token::Dot(_)) => {
-                        self.term_num_float(val.as_str())
+                        Self::term_num_float(val.as_str(), tokenizer)
                     }
                     _ => {
-                        let number = utils::string_to_f64(&val, || self.tokenizer.err_msg_with_pos(pos))?;
+                        let number = utils::string_to_f64(&val, || tokenizer.err_msg_with_pos(pos))?;
-                        Ok(self.node(ParseToken::Number(number)))
+                        Ok(Self::node(ParseToken::Number(number)))
                     }
                 }
             }
             Err(TokenError::Eof) => {
-                Ok(self.node(ParseToken::Eof))
+                Ok(Self::node(ParseToken::Eof))
             }
             _ => {
-                Err(self.tokenizer.err_msg())
+                Err(tokenizer.err_msg())
             }
         }
     }
 
-    fn term_num_float(&mut self, mut num: &str) -> ParseResult<Node> {
+    fn term_num_float(mut num: &str, tokenizer: &mut TokenReader) -> ParseResult<Node> {
         debug!("#term_num_float");
-        self.eat_token();
+        Self::eat_token(tokenizer);
-        match self.tokenizer.next_token() {
+        match tokenizer.next_token() {
             Ok(Token::Key(pos, frac)) => {
                 let mut f = String::new();
                 f.push_str(&mut num);
                 f.push('.');
                 f.push_str(frac.as_str());
-                let number = utils::string_to_f64(&f, || self.tokenizer.err_msg_with_pos(pos))?;
+                let number = utils::string_to_f64(&f, || tokenizer.err_msg_with_pos(pos))?;
-                Ok(self.node(ParseToken::Number(number)))
+                Ok(Self::node(ParseToken::Number(number)))
             }
             _ => {
-                Err(self.tokenizer.err_msg())
+                Err(tokenizer.err_msg())
             }
         }
     }
 
-    fn term(&mut self) -> ParseResult<Node> {
+    fn peek_key(tokenizer: &mut TokenReader) -> Option<String> {
+        if let Ok(Token::Key(_, k)) = tokenizer.peek_token() {
+            Some(k.clone())
+        } else {
+            None
+        }
+    }
+
+    fn term(tokenizer: &mut TokenReader) -> ParseResult<Node> {
         debug!("#term");
-        match self.tokenizer.peek_token() {
-            Ok(Token::At(_)) => {
-                self.eat_token();
-                let node = self.node(ParseToken::Relative);
 
-                match self.tokenizer.peek_token() {
+        if tokenizer.peek_is(AT) {
+            Self::eat_token(tokenizer);
+            let node = Self::node(ParseToken::Relative);
+
+            return match tokenizer.peek_token() {
                 Ok(Token::Whitespace(_, _)) => {
-                        self.eat_whitespace();
+                    Self::eat_whitespace(tokenizer);
                     Ok(node)
                 }
                 _ => {
-                        self.paths(node)
+                    Self::paths(node, tokenizer)
-                    }
-                }
-            }
-            Ok(Token::Absolute(_)) => {
-                self.json_path()
-            }
-            Ok(Token::DoubleQuoted(_, _))
-            | Ok(Token::SingleQuoted(_, _)) => {
-                self.array_quota_value()
-            }
-            Ok(Token::Key(_, _)) => {
-                self.term_num()
-            }
-            _ => {
-                Err(self.tokenizer.err_msg())
-            }
                 }
+            };
         }
 
-    fn op(&mut self, prev: Node) -> ParseResult<Node> {
+        if tokenizer.peek_is(ABSOLUTE) {
+            return Self::json_path(tokenizer);
+        }
+
+        if tokenizer.peek_is(DOUBLE_QUOTA) || tokenizer.peek_is(SINGLE_QUOTA) {
+            return Self::array_quota_value(tokenizer);
+        }
+
+        if tokenizer.peek_is(KEY) {
+            return match Self::peek_key(tokenizer) {
+                Some(key) => match key.chars().next() {
+                    Some(ch) => match ch {
+                        '-' | '0'...'9' => Self::term_num(tokenizer),
+                        _ => Self::boolean(tokenizer)
+                    }
+                    _ => Err(tokenizer.err_msg())
+                },
+                _ => Err(tokenizer.err_msg())
+            };
+        }
+
+        return Err(tokenizer.err_msg());
+    }
+
+    fn op(prev: Node, tokenizer: &mut TokenReader) -> ParseResult<Node> {
         debug!("#op");
-        let token = match self.tokenizer.next_token() {
+        let token = match tokenizer.next_token() {
             Ok(Token::Equal(_)) => {
                 ParseToken::Filter(FilterToken::Equal)
             }
@@ -588,90 +605,122 @@ impl<'a> Parser<'a> {
                 ParseToken::Eof
             }
             _ => {
-                return Err(self.tokenizer.err_msg());
+                return Err(tokenizer.err_msg());
             }
         };
 
-        self.eat_whitespace();
+        Self::eat_whitespace(tokenizer);
 
         Ok(Node {
             token,
             left: Some(Box::new(prev)),
-            right: Some(Box::new(self.term()?)),
+            right: Some(Box::new(Self::term(tokenizer)?)),
         })
     }
 
-    fn eat_whitespace(&mut self) {
+    fn eat_whitespace(tokenizer: &mut TokenReader) {
-        while let Ok(Token::Whitespace(_, _)) = self.tokenizer.peek_token() {
+        while let Ok(Token::Whitespace(_, _)) = tokenizer.peek_token() {
-            let _ = self.tokenizer.next_token();
+            let _ = tokenizer.next_token();
         }
     }
 
-    fn eat_token(&mut self) {
+    fn eat_token(tokenizer: &mut TokenReader) {
-        let _ = self.tokenizer.next_token();
+        let _ = tokenizer.next_token();
     }
 
-    fn node(&mut self, token: ParseToken) -> Node {
+    fn node(token: ParseToken) -> Node {
-        Node { left: None, right: None, token: token }
+        Node { left: None, right: None, token }
     }
 
-    fn close_token(&mut self, ret: Node, token: Token) -> ParseResult<Node> {
+    fn close_token(ret: Node, token: Token, tokenizer: &mut TokenReader) -> ParseResult<Node> {
         debug!("#close_token");
-        match self.tokenizer.next_token() {
+        match tokenizer.next_token() {
             Ok(ref t) if t.partial_eq(token) => {
                 Ok(ret)
             }
             _ => {
-                Err(self.tokenizer.err_msg())
+                Err(tokenizer.err_msg())
             }
         }
     }
 }
 
 pub trait NodeVisitor {
-    fn visit(&mut self, node: Node) {
+    fn visit(&mut self, node: &Node) {
-        match node.token {
+        match &node.token {
             ParseToken::Absolute
             | ParseToken::Relative
             | ParseToken::All
-            | ParseToken::Key(_) => {
+            | ParseToken::Key(_)
-                self.visit_token(node.token);
+            | ParseToken::Range(_, _)
+            | ParseToken::Union(_)
+            | ParseToken::Number(_)
+            | ParseToken::Bool(_) => {
+                self.visit_token(&node.token);
             }
             ParseToken::In
             | ParseToken::Leaves => {
-                node.left.map(|n| self.visit(*n));
+                match &node.left {
-                self.visit_token(node.token);
+                    Some(n) => self.visit(&*n),
-                node.right.map(|n| self.visit(*n));
+                    _ => {}
-            }
-            | ParseToken::Range(_, _)
-            | ParseToken::Union(_)
-            | ParseToken::Number(_) => {
-                self.visit_token(node.token);
                 }
 
-            | ParseToken::Array => {
+                self.visit_token(&node.token);
-                node.left.map(|n| self.visit(*n));
+
-                self.visit_token(node.token);
+                match &node.right {
-                node.right.map(|n| self.visit(*n));
+                    Some(n) => self.visit(&*n),
-                self.visit_token(ParseToken::ArrayEof);
+                    _ => {}
+                }
+            }
+            ParseToken::Array => {
+                match &node.left {
+                    Some(n) => self.visit(&*n),
+                    _ => {}
+                }
+
+                self.visit_token(&node.token);
+
+                match &node.right {
+                    Some(n) => self.visit(&*n),
+                    _ => {}
+                }
+                self.visit_token(&ParseToken::ArrayEof);
             }
             ParseToken::Filter(FilterToken::And)
             | ParseToken::Filter(FilterToken::Or) => {
-                node.left.map(|n| self.visit(*n));
+                match &node.left {
-                node.right.map(|n| self.visit(*n));
+                    Some(n) => self.visit(&*n),
-                self.visit_token(node.token);
+                    _ => {}
+                }
+
+                match &node.right {
+                    Some(n) => self.visit(&*n),
+                    _ => {}
+                }
+
+                self.visit_token(&node.token);
             }
             ParseToken::Filter(_) => {
-                node.left.map(|n| self.visit(*n));
+                match &node.left {
+                    Some(n) => self.visit(&*n),
+                    _ => {}
+                }
+
                 self.end_term();
-                node.right.map(|n| self.visit(*n));
+
+                match &node.right {
+                    Some(n) => self.visit(&*n),
+                    _ => {}
+                }
+
                 self.end_term();
-                self.visit_token(node.token);
+
+                self.visit_token(&node.token);
             }
             _ => {}
         }
     }
 
-    fn visit_token(&mut self, token: ParseToken);
+    fn visit_token(&mut self, token: &ParseToken);
     fn end_term(&mut self) {}
 }

src/parser/tokenizer.rs

@@ -3,29 +3,29 @@ use std::result::Result;
 
 use super::path_reader::{PathReader, ReaderError};
 
-const ABSOLUTE: &'static str = "$";
+pub const ABSOLUTE: &'static str = "$";
-const DOT: &'static str = ".";
+pub const DOT: &'static str = ".";
-const AT: &'static str = "@";
+pub const AT: &'static str = "@";
-const OPEN_ARRAY: &'static str = "[";
+pub const OPEN_ARRAY: &'static str = "[";
-const CLOSE_ARRAY: &'static str = "]";
+pub const CLOSE_ARRAY: &'static str = "]";
-const ASTERISK: &'static str = "*";
+pub const ASTERISK: &'static str = "*";
-const QUESTION: &'static str = "?";
+pub const QUESTION: &'static str = "?";
-const COMMA: &'static str = ",";
+pub const COMMA: &'static str = ",";
-const SPLIT: &'static str = ":";
+pub const SPLIT: &'static str = ":";
-const OPEN_PARENTHESIS: &'static str = "(";
+pub const OPEN_PARENTHESIS: &'static str = "(";
-const CLOSE_PARENTHESIS: &'static str = ")";
+pub const CLOSE_PARENTHESIS: &'static str = ")";
-const KEY: &'static str = "Key";
+pub const KEY: &'static str = "Key";
-const DOUBLE_QUOTA: &'static str = "\"";
+pub const DOUBLE_QUOTA: &'static str = "\"";
-const SINGLE_QUOTA: &'static str = "'";
+pub const SINGLE_QUOTA: &'static str = "'";
-const EQUAL: &'static str = "==";
+pub const EQUAL: &'static str = "==";
-const GREATER_OR_EQUAL: &'static str = ">=";
+pub const GREATER_OR_EQUAL: &'static str = ">=";
-const GREATER: &'static str = ">";
+pub const GREATER: &'static str = ">";
-const LITTLE: &'static str = "<";
+pub const LITTLE: &'static str = "<";
-const LITTLE_OR_EQUAL: &'static str = "<=";
+pub const LITTLE_OR_EQUAL: &'static str = "<=";
-const NOT_EQUAL: &'static str = "!=";
+pub const NOT_EQUAL: &'static str = "!=";
-const AND: &'static str = "&&";
+pub const AND: &'static str = "&&";
-const OR: &'static str = "||";
+pub const OR: &'static str = "||";
-const WHITESPACE: &'static str = " ";
+pub const WHITESPACE: &'static str = " ";
 
 const CH_DOLLA: char = '$';
 const CH_DOT: char = '.';
@@ -91,6 +91,10 @@ impl Token {
         self.to_simple() == other.to_simple()
     }
 
+    pub fn simple_eq(&self, str_token: &str) -> bool {
+        self.to_simple() == str_token
+    }
+
     fn to_simple(&self) -> &'static str {
         match self {
             Token::Absolute(_) => ABSOLUTE,
@@ -275,7 +279,7 @@ impl<'a> Tokenizer<'a> {
     }
 }
 
-pub struct PreloadedTokenizer<'a> {
+pub struct TokenReader<'a> {
     origin_input: &'a str,
     err: TokenError,
     err_pos: usize,
@@ -283,7 +287,7 @@ pub struct PreloadedTokenizer<'a> {
     curr_pos: Option<usize>,
 }
 
-impl<'a> PreloadedTokenizer<'a> {
+impl<'a> TokenReader<'a> {
     pub fn new(input: &'a str) -> Self {
         let mut tokenizer = Tokenizer::new(input);
         let mut tokens = vec![];
@@ -293,7 +297,7 @@ impl<'a> PreloadedTokenizer<'a> {
                     tokens.insert(0, (tokenizer.current_pos(), t));
                 }
                 Err(e) => {
-                    return PreloadedTokenizer {
+                    return TokenReader {
                         origin_input: input.clone(),
                         err: e,
                         err_pos: tokenizer.current_pos(),
@@ -305,6 +309,13 @@ impl<'a> PreloadedTokenizer<'a> {
         }
     }
 
+    pub fn peek_is(&self, simple_token: &str) -> bool {
+        match self.peek_token() {
+            Ok(t) => t.simple_eq(simple_token),
+            _ => false
+        }
+    }
+
     pub fn peek_token(&self) -> Result<&Token, TokenError> {
         match self.tokens.last() {
             Some((_, t)) => {

src/ref_value/mod.rs

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

src/ref_value/model.rs

@@ -1,293 +0,0 @@
-use std::hash::{Hash, Hasher};
-use std::ops::Deref;
-use std::sync::Arc;
-
-use indexmap::map::IndexMap;
-use serde::ser::Serialize;
-use serde_json::{Number, Value};
-use std::collections::hash_map::DefaultHasher;
-
-type TypeRefValue = Arc<Box<RefValue>>;
-
-#[derive(Debug)]
-pub struct RefValueWrapper {
-    data: TypeRefValue
-}
-
-impl PartialEq for RefValueWrapper {
-    fn eq(&self, other: &RefValueWrapper) -> bool {
-        Arc::ptr_eq(&self.data, &other.data)
-    }
-}
-
-impl Eq for RefValueWrapper {}
-
-impl Deref for RefValueWrapper {
-    type Target = RefValue;
-
-    fn deref(&self) -> &Self::Target {
-        &(**self.data)
-    }
-}
-
-impl Hash for RefValueWrapper {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.deref().hash(state)
-    }
-}
-
-impl Clone for RefValueWrapper {
-    fn clone(&self) -> Self {
-        RefValueWrapper {
-            data: self.data.clone()
-        }
-    }
-}
-
-///
-/// serde_json::Value 참고
-///
-pub trait RefIndex {
-    fn index_into<'v>(&self, v: &'v RefValue) -> Option<&'v RefValueWrapper>;
-    fn index_into_mut<'v>(&self, v: &'v mut RefValue) -> Option<&'v mut RefValueWrapper>;
-    fn index_or_insert<'v>(&self, v: &'v mut RefValue) -> &'v mut RefValueWrapper;
-}
-
-impl RefIndex for usize {
-    fn index_into<'v>(&self, v: &'v RefValue) -> Option<&'v RefValueWrapper> {
-        match *v {
-            RefValue::Array(ref vec) => vec.get(*self),
-            _ => None,
-        }
-    }
-    fn index_into_mut<'v>(&self, v: &'v mut RefValue) -> Option<&'v mut RefValueWrapper> {
-        match *v {
-            RefValue::Array(ref mut vec) => vec.get_mut(*self),
-            _ => None,
-        }
-    }
-    fn index_or_insert<'v>(&self, v: &'v mut RefValue) -> &'v mut RefValueWrapper {
-        match *v {
-            RefValue::Array(ref mut vec) => {
-                let len = vec.len();
-                vec.get_mut(*self).unwrap_or_else(|| {
-                    panic!(
-                        "cannot access index {} of JSON array of length {}",
-                        self, len
-                    )
-                })
-            }
-            _ => panic!("cannot access index {} of JSON {:?}", self, v),
-        }
-    }
-}
-
-impl RefIndex for str {
-    fn index_into<'v>(&self, v: &'v RefValue) -> Option<&'v RefValueWrapper> {
-        match *v {
-            RefValue::Object(ref map) => map.get(self),
-            _ => None,
-        }
-    }
-    fn index_into_mut<'v>(&self, v: &'v mut RefValue) -> Option<&'v mut RefValueWrapper> {
-        match *v {
-            RefValue::Object(ref mut map) => map.get_mut(self),
-            _ => None,
-        }
-    }
-    fn index_or_insert<'v>(&self, v: &'v mut RefValue) -> &'v mut RefValueWrapper {
-        if let RefValue::Null = *v {
-            *v = RefValue::Object(IndexMap::new());
-        }
-        match *v {
-            RefValue::Object(ref mut map) => {
-                map.entry(self.to_owned()).or_insert(RefValue::Null.into())
-            }
-            _ => panic!("cannot access key {:?} in JSON {:?}", self, v),
-        }
-    }
-}
-
-impl RefIndex for String {
-    fn index_into<'v>(&self, v: &'v RefValue) -> Option<&'v RefValueWrapper> {
-        self[..].index_into(v)
-    }
-    fn index_into_mut<'v>(&self, v: &'v mut RefValue) -> Option<&'v mut RefValueWrapper> {
-        self[..].index_into_mut(v)
-    }
-    fn index_or_insert<'v>(&self, v: &'v mut RefValue) -> &'v mut RefValueWrapper {
-        self[..].index_or_insert(v)
-    }
-}
-
-#[derive(Debug)]
-pub enum RefValue {
-    Null,
-    Bool(bool),
-    Number(Number),
-    String(String),
-    Array(Vec<RefValueWrapper>),
-    Object(IndexMap<String, RefValueWrapper>),
-}
-
-impl PartialEq for RefValue {
-    fn eq(&self, other: &RefValue) -> bool {
-        let mut hasher1 = DefaultHasher::new();
-        let mut hasher2 = DefaultHasher::new();
-
-        self.hash(&mut hasher1);
-        other.hash(&mut hasher2);
-
-        hasher1.finish() == hasher2.finish()
-    }
-}
-
-static REF_VALUE_NULL: &'static str = "$jsonpath::ref_value::model::RefValue::Null";
-
-impl Hash for RefValue {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        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)
-                } else if n.is_i64() {
-                    n.as_i64().unwrap().hash(state);
-                } else {
-                    n.as_u64().unwrap().hash(state);
-                }
-            }
-            RefValue::String(s) => {
-                s.hash(state)
-            }
-            RefValue::Object(map) => {
-                for (k, v) in map {
-                    k.hash(state);
-                    v.hash(state);
-                }
-            }
-            RefValue::Array(v) => {
-                for i in v {
-                    i.hash(state);
-                }
-            }
-        }
-    }
-}
-
-impl Eq for RefValue {}
-
-impl RefValue {
-    pub fn get<I: RefIndex>(&self, index: I) -> Option<&RefValueWrapper> {
-        index.index_into(self)
-    }
-
-    pub fn is_object(&self) -> bool {
-        self.as_object().is_some()
-    }
-
-    pub fn as_object(&self) -> Option<&IndexMap<String, RefValueWrapper>> {
-        match *self {
-            RefValue::Object(ref map) => Some(map),
-            _ => None,
-        }
-    }
-
-    pub fn is_array(&self) -> bool {
-        self.as_array().is_some()
-    }
-
-    pub fn as_array(&self) -> Option<&Vec<RefValueWrapper>> {
-        match *self {
-            RefValue::Array(ref array) => Some(&*array),
-            _ => None,
-        }
-    }
-
-    pub fn is_string(&self) -> bool {
-        self.as_str().is_some()
-    }
-
-    pub fn as_str(&self) -> Option<&str> {
-        match *self {
-            RefValue::String(ref s) => Some(s),
-            _ => None,
-        }
-    }
-
-    pub fn is_number(&self) -> bool {
-        match *self {
-            RefValue::Number(_) => true,
-            _ => false,
-        }
-    }
-
-    pub fn as_number(&self) -> Option<Number> {
-        match *self {
-            RefValue::Number(ref n) => Some(n.clone()),
-            _ => None,
-        }
-    }
-
-    pub fn is_boolean(&self) -> bool {
-        self.as_bool().is_some()
-    }
-
-    pub fn as_bool(&self) -> Option<bool> {
-        match *self {
-            RefValue::Bool(b) => Some(b),
-            _ => None,
-        }
-    }
-
-    pub fn is_null(&self) -> bool {
-        self.as_null().is_some()
-    }
-
-    pub fn as_null(&self) -> Option<()> {
-        match *self {
-            RefValue::Null => Some(()),
-            _ => None,
-        }
-    }
-}
-
-impl Into<RefValueWrapper> for RefValue {
-    fn into(self) -> RefValueWrapper {
-        RefValueWrapper {
-            data: Arc::new(Box::new(self))
-        }
-    }
-}
-
-impl Into<RefValue> for &Value {
-    fn into(self) -> RefValue {
-        match self.serialize(super::ser::Serializer) {
-            Ok(v) => v,
-            Err(e) => panic!("Error Value into RefValue: {:?}", e)
-        }
-    }
-}
-
-impl Into<RefValueWrapper> for &Value {
-    fn into(self) -> RefValueWrapper {
-        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 {
-        match serde_json::to_value(self.deref()) {
-            Ok(v) => v,
-            Err(e) => panic!("Error RefValueWrapper into Value: {:?}", e)
-        }
-    }
-}

src/ref_value/ser.rs

@@ -1,624 +0,0 @@
-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,
-    {
-        match *self {
-            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 = try!(serializer.serialize_map(Some(m.len())));
-                for (k, v) in m {
-                    try!(map.serialize_key(k));
-                    try!(map.serialize_value(v.deref()));
-                }
-                map.end()
-            }
-        }
-    }
-}
-
-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_bool(self, value: bool) -> Result<RefValue, Self::Error> {
-        Ok(RefValue::Bool(value))
-    }
-
-    #[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))
-    }
-}

src/ref_value/serde_error.rs

@@ -1,38 +0,0 @@
-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)
-    }
-}

tests/common.rs

@@ -0,0 +1,45 @@
+extern crate env_logger;
+extern crate jsonpath_lib as jsonpath;
+extern crate serde_json;
+
+use std::io::Read;
+
+use serde_json::Value;
+
+use self::jsonpath::Selector;
+
+#[allow(dead_code)]
+pub fn setup() {
+    let _ = env_logger::try_init();
+}
+
+#[allow(dead_code)]
+pub fn read_json(path: &str) -> Value {
+    let mut f = std::fs::File::open(path).unwrap();
+    let mut contents = String::new();
+    f.read_to_string(&mut contents).unwrap();
+    serde_json::from_str(&contents).unwrap()
+}
+
+#[allow(dead_code)]
+pub fn read_contents(path: &str) -> String {
+    let mut f = std::fs::File::open(path).unwrap();
+    let mut contents = String::new();
+    f.read_to_string(&mut contents).unwrap();
+    contents
+}
+
+#[allow(dead_code)]
+pub fn select_and_then_compare<'a>(path: &str, json: Value, target: Value) {
+    let mut s = Selector::new();
+    let _ = s.str_path(path);
+    let _ = s.value(&json);
+    let result = serde_json::to_value(s.select().unwrap()).unwrap();
+    assert_eq!(result, target, "{}", path);
+}
+
+#[allow(dead_code)]
+pub fn compare_result<'a>(result: Vec<&Value>, target: Value) {
+    let result = serde_json::to_value(result).unwrap();
+    assert_eq!(result, target);
+}

tests/filter.rs

@@ -1,222 +1,140 @@
-extern crate core;
-extern crate env_logger;
-extern crate jsonpath_lib as jsonpath;
 #[macro_use]
 extern crate serde_json;
 
-use std::io::Read;
-
 use serde_json::Value;
 
-use jsonpath::filter::value_filter::{JsonValueFilter, ValueFilter};
+use common::{read_json, select_and_then_compare, setup};
-use jsonpath::parser::parser::Parser;
 
-fn setup() {
+mod common;
-    let _ = env_logger::try_init();
-}
-
-fn new_value_filter(file: &str) -> ValueFilter {
-    let string = read_json(file);
-    let json: Value = serde_json::from_str(string.as_str()).unwrap();
-    ValueFilter::new((&json).into(), false, false)
-}
-
-fn do_filter(path: &str, file: &str) -> JsonValueFilter {
-    let string = read_json(file);
-    let mut jf = JsonValueFilter::new(string.as_str()).unwrap();
-    let mut parser = Parser::new(path);
-    parser.parse(&mut jf).unwrap();
-    jf
-}
-
-fn read_json(path: &str) -> String {
-    let mut f = std::fs::File::open(path).unwrap();
-    let mut contents = String::new();
-    f.read_to_string(&mut contents).unwrap();
-    contents
-}
-
-#[test]
-fn step_in() {
-    setup();
-
-    let mut jf = new_value_filter("./benches/data_obj.json");
-    {
-        let current = jf.step_in_str("friends");
-        assert_eq!(current.is_array(), true);
-    }
-
-    let mut jf = new_value_filter("./benches/data_array.json");
-    {
-        let current = jf.step_in_num(&1.0);
-        assert_eq!(current.get_val().is_object(), true);
-    }
-    {
-        let current = jf.step_in_str("friends");
-        assert_eq!(current.is_array(), true);
-    }
-    let mut jf = new_value_filter("./benches/data_obj.json");
-    {
-        jf.step_in_str("school");
-        jf.step_in_str("friends");
-        jf.step_in_all();
-        let current = jf.step_in_str("name");
-        let friends = json!([
-                "Millicent Norman",
-                "Vincent Cannon",
-                "Gray Berry"
-            ]);
-
-        assert_eq!(friends, current.into_value());
-    }
-    let mut jf = new_value_filter("./benches/data_obj.json");
-    {
-        let current = jf.step_leaves_str("name");
-        let names = json!([
-                "Leonor Herman",
-                "Millicent Norman",
-                "Vincent Cannon",
-                "Gray Berry",
-                "Vincent Cannon",
-                "Gray Berry"
-            ]);
-        assert_eq!(names, current.into_value());
-    }
-}
 
 #[test]
 fn array() {
     setup();
 
-    let friends = json!([
+    select_and_then_compare("$.school.friends[1, 2]", read_json("./benches/data_obj.json"), json!([
         {"id": 1, "name": "Vincent Cannon" },
         {"id": 2, "name": "Gray Berry"}
-        ]);
+    ]));
 
-    let jf = do_filter("$.school.friends[1, 2]", "./benches/data_obj.json");
+    select_and_then_compare("$.school.friends[1: ]", read_json("./benches/data_obj.json"), json!([
-    assert_eq!(friends, jf.into_value());
+        {"id": 1, "name": "Vincent Cannon" },
+        {"id": 2, "name": "Gray Berry"}
+    ]));
 
-    let jf = do_filter("$.school.friends[1:]", "./benches/data_obj.json");
+    select_and_then_compare("$.school.friends[:-2]", read_json("./benches/data_obj.json"), json!([
-    assert_eq!(friends, jf.into_value());
-
-    let jf = do_filter("$.school.friends[:-2]", "./benches/data_obj.json");
-    let friends = json!([
         {"id": 0, "name": "Millicent Norman"}
-        ]);
+    ]));
-    assert_eq!(friends, jf.into_value());
 
-    let jf = do_filter("$..friends[2].name", "./benches/data_obj.json");
+    select_and_then_compare("$..friends[2].name", read_json("./benches/data_obj.json"), json!([
-    let friends = json!(["Gray Berry", "Gray Berry"]);
+        "Gray Berry", "Gray Berry"
-    assert_eq!(friends, jf.into_value());
+    ]));
 
-    let jf = do_filter("$..friends[*].name", "./benches/data_obj.json");
+    select_and_then_compare("$..friends[*].name", read_json("./benches/data_obj.json"), json!([
-    let friends = json!(["Vincent Cannon","Gray Berry","Millicent Norman","Vincent Cannon","Gray Berry"]);
+        "Vincent Cannon","Gray Berry","Millicent Norman","Vincent Cannon","Gray Berry"
-    assert_eq!(friends, jf.into_value());
+    ]));
 
-    let jf = do_filter("$['school']['friends'][*].['name']", "./benches/data_obj.json");
+    select_and_then_compare("$['school']['friends'][*].['name']", read_json("./benches/data_obj.json"), json!([
-    let friends = json!(["Millicent Norman","Vincent Cannon","Gray Berry"]);
+        "Millicent Norman","Vincent Cannon","Gray Berry"
-    assert_eq!(friends, jf.into_value());
+    ]));
 
-    let jf = do_filter("$['school']['friends'][0].['name']", "./benches/data_obj.json");
+    select_and_then_compare("$['school']['friends'][0].['name']", read_json("./benches/data_obj.json"), json!([
-    let friends = json!("Millicent Norman");
+        "Millicent Norman"
-    assert_eq!(friends, jf.into_value());
+    ]));
 }
 
 #[test]
 fn return_type() {
     setup();
 
-    let friends = json!({
+    select_and_then_compare("$.school", read_json("./benches/data_obj.json"), json!([{
         "friends": [
             {"id": 0, "name": "Millicent Norman"},
             {"id": 1, "name": "Vincent Cannon" },
             {"id": 2, "name": "Gray Berry"}
         ]
-        });
+    }]));
 
-    let jf = do_filter("$.school", "./benches/data_obj.json");
+    select_and_then_compare("$.school[?(@.friends[0])]", read_json("./benches/data_obj.json"), json!([{
-    assert_eq!(friends, jf.into_value());
+        "friends": [
-
-    let jf = do_filter("$.school[?(@.friends[0])]", "./benches/data_obj.json");
-    assert_eq!(friends, jf.into_value());
-
-    let jf = do_filter("$.school[?(@.friends[10])]", "./benches/data_obj.json");
-    assert_eq!(Value::Null, jf.into_value());
-
-    let jf = do_filter("$.school[?(1==1)]", "./benches/data_obj.json");
-    assert_eq!(friends, jf.into_value());
-
-    let jf = do_filter("$.school.friends[?(1==1)]", "./benches/data_obj.json");
-    let friends = json!([
             {"id": 0, "name": "Millicent Norman"},
             {"id": 1, "name": "Vincent Cannon" },
             {"id": 2, "name": "Gray Berry"}
-        ]);
+        ]
-    assert_eq!(friends, jf.into_value());
+    }]));
+
+    select_and_then_compare("$.school[?(@.friends[10])]", read_json("./benches/data_obj.json"), json!([{
+        "friends": [
+            {"id": 0, "name": "Millicent Norman"},
+            {"id": 1, "name": "Vincent Cannon" },
+            {"id": 2, "name": "Gray Berry"}
+        ]
+    }]));
+
+    select_and_then_compare("$.school[?(1==1)]", read_json("./benches/data_obj.json"), json!([{
+        "friends": [
+            {"id": 0, "name": "Millicent Norman"},
+            {"id": 1, "name": "Vincent Cannon" },
+            {"id": 2, "name": "Gray Berry"}
+        ]
+    }]));
+
+    select_and_then_compare("$.school.friends[?(1==1)]", read_json("./benches/data_obj.json"), json!([[
+        {"id": 0, "name": "Millicent Norman"},
+        {"id": 1, "name": "Vincent Cannon" },
+        {"id": 2, "name": "Gray Berry"}
+    ]]));
 }
 
 #[test]
 fn op_default() {
     setup();
 
-    let jf = do_filter("$.school[?(@.friends == @.friends)]", "./benches/data_obj.json");
+    select_and_then_compare("$.school[?(@.friends == @.friends)]", read_json("./benches/data_obj.json"), json!([{
-    let friends = json!({
         "friends": [
             {"id": 0, "name": "Millicent Norman"},
             {"id": 1, "name": "Vincent Cannon" },
             {"id": 2, "name": "Gray Berry"}
         ]
-    });
+    }]));
-    assert_eq!(friends, jf.into_value());
 
-    let jf = do_filter("$.friends[?(@.name)]", "./benches/data_obj.json");
+    select_and_then_compare("$.friends[?(@.name)]", read_json("./benches/data_obj.json"), json!([
-    let friends = json!([
         { "id" : 1, "name" : "Vincent Cannon" },
         { "id" : 2, "name" : "Gray Berry" }
-        ]);
+    ]));
-    assert_eq!(friends, jf.into_value());
 
-    let jf = do_filter("$.friends[?(@.id >= 2)]", "./benches/data_obj.json");
+    select_and_then_compare("$.friends[?(@.id >= 2)]", read_json("./benches/data_obj.json"), json!([
-    let friends = json!([
         { "id" : 2, "name" : "Gray Berry" }
-        ]);
+    ]));
-    assert_eq!(friends, jf.into_value());
 
-    let jf = do_filter("$.friends[?(@.id >= 2 || @.id == 1)]", "./benches/data_obj.json");
+    select_and_then_compare("$.friends[?(@.id >= 2 || @.id == 1)]", read_json("./benches/data_obj.json"), json!([
-    let friends = json!([
         { "id" : 2, "name" : "Gray Berry" },
         { "id" : 1, "name" : "Vincent Cannon" }
-        ]);
+    ]));
-    assert_eq!(friends, jf.into_value());
 
-    let jf = do_filter("$.friends[?( (@.id >= 2 || @.id == 1) && @.id == 0)]", "./benches/data_obj.json");
+    select_and_then_compare("$.friends[?( (@.id >= 2 || @.id == 1) && @.id == 0)]", read_json("./benches/data_obj.json"), json!([
-    assert_eq!(Value::Null, jf.into_value());
+        Value::Null
+    ]));
 
-    let jf = do_filter("$..friends[?(@.id == $.index)].id", "./benches/data_obj.json");
+    select_and_then_compare("$..friends[?(@.id == $.index)].id", read_json("./benches/data_obj.json"), json!([
-    let friends = json!([0, 0]);
+        0, 0
-    assert_eq!(friends, jf.into_value());
+    ]));
 
-    let jf = do_filter("$..book[?($.store.bicycle.price < @.price)].price", "./benches/example.json");
+    select_and_then_compare("$..book[?($.store.bicycle.price < @.price)].price", read_json("./benches/example.json"), json!([
-    let friends = json!([22.99]);
+        22.99
-    assert_eq!(friends, jf.into_value());
+    ]));
 
-    let jf = do_filter("$..book[?( (@.price == 12.99 || @.category == 'reference') && @.price > 10)].price", "./benches/example.json");
+    select_and_then_compare("$..book[?( (@.price == 12.99 || @.category == 'reference') && @.price > 10)].price", read_json("./benches/example.json"), json!([
-    let friends = json!([12.99]);
+        12.99
-    assert_eq!(friends, jf.into_value());
+    ]));
 
-    let ref value = json!([
+    select_and_then_compare("$..[?(@.age > 40)]", json!([
         { "name": "이름1", "age": 40, "phone": "+33 12341234" },
         { "name": "이름2", "age": 42, "phone": "++44 12341234" }
-    ]);
+    ]), json!([
-    let mut jf = JsonValueFilter::new_from_value(value.into());
-    let mut parser = Parser::new("$..[?(@.age > 40)]");
-    parser.parse(&mut jf).unwrap();
-    let friends = json!([
         { "name" : "이름2", "age" : 42, "phone" : "++44 12341234" }
-    ]);
+    ]));
-    assert_eq!(friends, jf.into_value());
 
-    let ref value = json!({
+    select_and_then_compare("$..[?(@.age >= 30)]", json!({
         "school": {
             "friends": [
                 {"name": "친구1", "age": 20},
@@ -226,103 +144,82 @@ fn op_default() {
         "friends": [
             {"name": "친구3", "age": 30},
             {"name": "친구4"}
-    ]});
+    ]}), json!([
-    let mut jf = JsonValueFilter::new_from_value(value.into());
+        { "name" : "친구3", "age" : 30 }
-    let mut parser = Parser::new("$..[?(@.age >= 30)]");
+    ]));
-    parser.parse(&mut jf).unwrap();
-    let friends = json!([{ "name" : "친구3", "age" : 30 }]);
-    assert_eq!(friends, jf.into_value());
 }
 
 #[test]
 fn op_number() {
     setup();
 
-    let json = json!({ "a": 1 });
+    select_and_then_compare("$.[?(@.a == 1)]", json!({ "a": 1 }), json!([{ "a": 1 }]));
-    let ret = jsonpath::select(&json, "$.[?(@.a == 1)]").unwrap();
+    select_and_then_compare("$.[?(@.a != 2)]", json!({ "a": 1 }), json!([{ "a": 1 }]));
-    assert_eq!(json, ret);
+    select_and_then_compare("$.[?(@.a < 2)]", json!({ "a": 1 }), json!([{ "a": 1 }]));
-    let ret = jsonpath::select(&json, "$.[?(@.a != 2)]").unwrap();
+    select_and_then_compare("$.[?(@.a <= 1)]", json!({ "a": 1 }), json!([{ "a": 1 }]));
-    assert_eq!(json, ret);
+    select_and_then_compare("$.[?(@.a > 0)]", json!({ "a": 1 }), json!([{ "a": 1 }]));
-    let ret = jsonpath::select(&json, "$.[?(@.a < 2)]").unwrap();
+    select_and_then_compare("$.[?(@.a >= 0)]", json!({ "a": 1 }), json!([{ "a": 1 }]));
-    assert_eq!(json, ret);
-    let ret = jsonpath::select(&json, "$.[?(@.a <= 1)]").unwrap();
-    assert_eq!(json, ret);
-    let ret = jsonpath::select(&json, "$.[?(@.a > 0)]").unwrap();
-    assert_eq!(json, ret);
-    let ret = jsonpath::select(&json, "$.[?(@.a >= 0)]").unwrap();
-    assert_eq!(json, ret);
 }
 
 #[test]
 fn op_string() {
     setup();
 
-    let json = json!({ "a": "b" });
+    select_and_then_compare(r#"$.[?(@.a == "b")]"#, json!({ "a": "b" }), json!([{ "a": "b" }]));
-    let ret = jsonpath::select(&json, r#"$.[?(@.a == "b")]"#).unwrap();
+    select_and_then_compare(r#"$.[?(@.a != "c")]"#, json!({ "a": "b" }), json!([{ "a": "b" }]));
-    assert_eq!(json!({ "a": "b" }), ret);
+    select_and_then_compare(r#"$.[?(@.a < "b")]"#, json!({ "a": "b" }), json!([Value::Null]));
-    let ret = jsonpath::select(&json, r#"$.[?(@.a != "c")]"#).unwrap();
+    select_and_then_compare(r#"$.[?(@.a <= "b")]"#, json!({ "a": "b" }), json!([{ "a": "b" }]));
-    assert_eq!(json!({ "a": "b" }), ret);
+    select_and_then_compare(r#"$.[?(@.a > "b")]"#, json!({ "a": "b" }), json!([Value::Null]));
-    let ret = jsonpath::select(&json, r#"$.[?(@.a < "b")]"#).unwrap();
+    select_and_then_compare(r#"$.[?(@.a >= "b")]"#, json!({ "a": "b" }), json!([{ "a": "b" }]));
-    assert_eq!(Value::Null, ret);
-    let ret = jsonpath::select(&json, r#"$.[?(@.a <= "b")]"#).unwrap();
-    assert_eq!(json!({ "a": "b" }), ret);
-    let ret = jsonpath::select(&json, r#"$.[?(@.a > "b")]"#).unwrap();
-    assert_eq!(Value::Null, ret);
-    let ret = jsonpath::select(&json, r#"$.[?(@.a >= "b")]"#).unwrap();
-    assert_eq!(json!({ "a": "b" }), ret);
 }
 
 #[test]
 fn op_object() {
     setup();
 
-    let json = json!({
+    select_and_then_compare(r#"$.[?(@.a == @.c)]"#,
-        "a": { "1": 1 },
+                            json!({"a": { "1": 1 }, "b": { "2": 2 }, "c": { "1": 1 }}),
-        "b": { "2": 2 },
+                            json!([{"a": { "1": 1 }, "b": { "2": 2 }, "c": { "1": 1 }}]));
-        "c": { "1": 1 },
+    select_and_then_compare(r#"$.[?(@.a != @.c)]"#,
-    });
+                            json!({"a": { "1": 1 }, "b": { "2": 2 }, "c": { "1": 1 }}),
-    let ret = jsonpath::select(&json, r#"$.[?(@.a == @.c)]"#).unwrap();
+                            json!([Value::Null]));
-    assert_eq!(json, ret);
+    select_and_then_compare(r#"$.[?(@.a < @.c)]"#,
-    let ret = jsonpath::select(&json, r#"$.[?(@.a != @.c)]"#).unwrap();
+                            json!({"a": { "1": 1 }, "b": { "2": 2 }, "c": { "1": 1 }}),
-    assert_eq!(Value::Null, ret);
+                            json!([Value::Null]));
-    let ret = jsonpath::select(&json, r#"$.[?(@.a < @.c)]"#).unwrap();
+    select_and_then_compare(r#"$.[?(@.a <= @.c)]"#,
-    assert_eq!(Value::Null, ret);
+                            json!({"a": { "1": 1 }, "b": { "2": 2 }, "c": { "1": 1 }}),
-    let ret = jsonpath::select(&json, r#"$.[?(@.a <= @.c)]"#).unwrap();
+                            json!([Value::Null]));
-    assert_eq!(Value::Null, ret);
+    select_and_then_compare(r#"$.[?(@.a > @.c)]"#,
-    let ret = jsonpath::select(&json, r#"$.[?(@.a > @.c)]"#).unwrap();
+                            json!({"a": { "1": 1 }, "b": { "2": 2 }, "c": { "1": 1 }}),
-    assert_eq!(Value::Null, ret);
+                            json!([Value::Null]));
-    let ret = jsonpath::select(&json, r#"$.[?(@.a >= @.c)]"#).unwrap();
+    select_and_then_compare(r#"$.[?(@.a >= @.c)]"#,
-    assert_eq!(Value::Null, ret);
+                            json!({"a": { "1": 1 }, "b": { "2": 2 }, "c": { "1": 1 }}),
+                            json!([Value::Null]));
 }
 
 #[test]
 fn op_complex() {
     setup();
 
-    let json = json!({ "a": { "b": 1 } });
+    select_and_then_compare(r#"$.[?(1 == @.a)]"#, json!({ "a": { "b": 1 } }), json!([Value::Null]));
-    let ret = jsonpath::select(&json, r#"$.[?(1 == @.a)]"#).unwrap();
+    select_and_then_compare(r#"$.[?("1" != @.a)]"#, json!({ "a": { "b": 1 } }), json!([Value::Null]));
-    assert_eq!(Value::Null, ret);
+    select_and_then_compare(r#"$.[?(@.a <= 1)]"#, json!({ "a": { "b": 1 } }), json!([Value::Null]));
-    let ret = jsonpath::select(&json, r#"$.[?("1" != @.a)]"#).unwrap();
+    select_and_then_compare(r#"$.[?(@.a > "1")]"#, json!({ "a": { "b": 1 } }), json!([Value::Null]));
-    assert_eq!(Value::Null, ret);
-    let ret = jsonpath::select(&json, r#"$.[?(@.a <= 1)]"#).unwrap();
-    assert_eq!(Value::Null, ret);
-    let ret = jsonpath::select(&json, r#"$.[?(@.a > "1")]"#).unwrap();
-    assert_eq!(Value::Null, ret);
 }
 
 #[test]
 fn example() {
     setup();
 
-    let jf = do_filter("$.store.book[*].author", "./benches/example.json");
+    select_and_then_compare(r#"$.store.book[*].author"#, read_json("./benches/example.json"), json!([
-    let ret = json!(["Nigel Rees","Evelyn Waugh","Herman Melville","J. R. R. Tolkien"]);
+        "Nigel Rees","Evelyn Waugh","Herman Melville","J. R. R. Tolkien"
-    assert_eq!(ret, jf.into_value());
+    ]));
 
-    let jf = do_filter("$..author", "./benches/example.json");
+    select_and_then_compare(r#"$..author"#, read_json("./benches/example.json"), json!([
-    assert_eq!(ret, jf.into_value());
+        "Nigel Rees","Evelyn Waugh","Herman Melville","J. R. R. Tolkien"
+    ]));
 
-    let jf = do_filter("$.store.*", "./benches/example.json");
+    select_and_then_compare(r#"$.store.*"#, read_json("./benches/example.json"), json!([
-    let ret = json!([
          [
             {"category" : "reference", "author" : "Nigel Rees","title" : "Sayings of the Century", "price" : 8.95},
             {"category" : "fiction", "author" : "Evelyn Waugh","title" : "Sword of Honour","price" : 12.99},
@@ -330,35 +227,33 @@ fn example() {
             {"category" : "fiction", "author" : "J. R. R. Tolkien","title" : "The Lord of the Rings","isbn" : "0-395-19395-8","price" : 22.99}
         ],
         {"color" : "red","price" : 19.95},
-        ]);
+    ]));
-    assert_eq!(ret, jf.into_value());
 
-    let jf = do_filter("$.store..price", "./benches/example.json");
+    select_and_then_compare(r#"$.store..price"#, read_json("./benches/example.json"), json!([
-    let ret = json!([8.95, 12.99, 8.99, 22.99, 19.95]);
+        8.95, 12.99, 8.99, 22.99, 19.95
-    assert_eq!(ret, jf.into_value());
+    ]));
 
-    let jf = do_filter("$..book[2]", "./benches/example.json");
+    select_and_then_compare(r#"$..book[2]"#, read_json("./benches/example.json"), json!([
-    let ret = json!([{
+        {
         "category" : "fiction",
         "author" : "Herman Melville",
         "title" : "Moby Dick",
         "isbn" : "0-553-21311-3",
         "price" : 8.99
-        }]);
+        }
-    assert_eq!(ret, jf.into_value());
+    ]));
 
-    let jf = do_filter("$..book[-2]", "./benches/example.json");
+    select_and_then_compare(r#"$..book[-2]"#, read_json("./benches/example.json"), json!([
-    let ret = json!([{
+        {
             "category" : "fiction",
             "author" : "Herman Melville",
             "title" : "Moby Dick",
             "isbn" : "0-553-21311-3",
             "price" : 8.99
-        }]);
+        }
-    assert_eq!(ret, jf.into_value());
+    ]));
 
-    let jf = do_filter("$..book[0,1]", "./benches/example.json");
+    select_and_then_compare(r#"$..book[0, 1]"#, read_json("./benches/example.json"), json!([
-    let ret = json!([
         {
             "category" : "reference",
             "author" : "Nigel Rees",
@@ -371,11 +266,9 @@ fn example() {
             "title" : "Sword of Honour",
             "price" : 12.99
         }
-        ]);
+    ]));
-    assert_eq!(ret, jf.into_value());
 
-    let jf = do_filter("$..book[:2]", "./benches/example.json");
+    select_and_then_compare(r#"$..book[:2]"#, read_json("./benches/example.json"), json!([
-    let ret = json!([
         {
             "category" : "reference",
             "author" : "Nigel Rees",
@@ -388,11 +281,9 @@ fn example() {
             "title" : "Sword of Honour",
             "price" : 12.99
         }
-        ]);
+    ]));
-    assert_eq!(ret, jf.into_value());
 
-    let jf = do_filter("$..book[2:]", "./benches/example.json");
+    select_and_then_compare(r#"$..book[2:]"#, read_json("./benches/example.json"), json!([
-    let ret = json!([
         {
             "category" : "fiction",
             "author" : "Herman Melville",
@@ -407,11 +298,9 @@ fn example() {
             "isbn" : "0-395-19395-8",
             "price" : 22.99
        }
-        ]);
+    ]));
-    assert_eq!(ret, jf.into_value());
 
-    let jf = do_filter("$..book[?(@.isbn)]", "./benches/example.json");
+    select_and_then_compare(r#"$..book[?(@.isbn)]"#, read_json("./benches/example.json"), json!([
-    let ret = json!([
         {
             "category" : "fiction",
             "author" : "Herman Melville",
@@ -426,11 +315,9 @@ fn example() {
             "isbn" : "0-395-19395-8",
             "price" : 22.99
        }
-        ]);
+    ]));
-    assert_eq!(ret, jf.into_value());
 
-    let jf = do_filter("$.store.book[?(@.price < 10)]", "./benches/example.json");
+    select_and_then_compare(r#"$.store.book[?(@.price < 10)]"#, read_json("./benches/example.json"), json!([
-    let ret = json!([
         {
             "category" : "reference",
             "author" : "Nigel Rees",
@@ -444,29 +331,21 @@ fn example() {
             "isbn" : "0-553-21311-3",
             "price" : 8.99
        }
-        ]);
+    ]));
-    assert_eq!(ret, jf.into_value());
 
-    let jf = do_filter("$..*", "./benches/example.json");
+    select_and_then_compare(r#"$..*"#, read_json("./benches/example.json"),
-    let json: Value = serde_json::from_str(read_json("./benches/giveme_every_thing_result.json").as_str()).unwrap();
+                            read_json("./benches/giveme_every_thing_result.json"));
-    assert_eq!(json, jf.into_value());
 }
 
 #[test]
 fn filer_same_obj() {
     setup();
 
-    let mut jf = JsonValueFilter::new(r#"
+    select_and_then_compare(r#"$..[?(@.a == 1)]"#, json!({
-    {
         "a": 1,
         "b" : {"a": 1},
         "c" : {"a": 1}
-    }
+    }), json!([
-    "#).unwrap();
-    let mut parser = Parser::new("$..[?(@.a == 1)]");
-    parser.parse(&mut jf).unwrap();
-    let ret = jf.into_value();
-    assert_eq!(ret, json!([
         {"a": 1},
         {"a": 1}
     ]));

tests/lib.rs

@@ -1,31 +1,19 @@
-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;
-
-use serde::{Deserialize, Serialize};
 use serde_json::Value;
 
-fn read_json(path: &str) -> Value {
+use common::{compare_result, read_contents, read_json, setup};
-    let mut f = std::fs::File::open(path).unwrap();
-    let mut contents = String::new();
-    f.read_to_string(&mut contents).unwrap();
-    serde_json::from_str(contents.as_str()).unwrap()
-}
 
-fn read_contents(path: &str) -> String {
+mod common;
-    let mut f = std::fs::File::open(path).unwrap();
-    let mut contents = String::new();
-    f.read_to_string(&mut contents).unwrap();
-    contents
-}
 
 #[test]
 fn compile() {
+    setup();
+
     let mut template = jsonpath::compile("$..friends[2]");
     let json_obj = read_json("./benches/data_obj.json");
     let json = template(&json_obj).unwrap();
@@ -33,7 +21,7 @@ fn compile() {
             {"id": 2,"name": "Gray Berry"},
             {"id": 2,"name": "Gray Berry"}
         ]);
-    assert_eq!(json, ret);
+    compare_result(json, ret);
 
     let json_obj = read_json("./benches/data_array.json");
     let json = template(&json_obj).unwrap();
@@ -41,11 +29,13 @@ fn compile() {
             {"id": 2,"name": "Gray Berry"},
             {"id": 2,"name": "Rosetta Erickson"}
         ]);
-    assert_eq!(json, ret);
+    compare_result(json, ret);
 }
 
 #[test]
 fn selector() {
+    setup();
+
     let json_obj = read_json("./benches/data_obj.json");
     let mut reader = jsonpath::selector(&json_obj);
     let json = reader("$..friends[2]").unwrap();
@@ -53,27 +43,26 @@ fn selector() {
             {"id": 2,"name": "Gray Berry"},
             {"id": 2,"name": "Gray Berry"}
         ]);
-    assert_eq!(json, ret);
+    compare_result(json, ret);
 
     let json = reader("$..friends[0]").unwrap();
     let ret = json!([
             {"id": 0},
             {"id": 0,"name": "Millicent Norman"}
         ]);
-    assert_eq!(json, ret);
+    compare_result(json, ret);
 }
 
 #[test]
 fn selector_as() {
-    let json_obj = read_json("./benches/data_obj.json");
+    #[derive(Deserialize, PartialEq, Debug)]
-    let mut selector = jsonpath::selector_as::<Vec<Friend>>(&json_obj);
-
-    #[derive(Serialize, Deserialize, PartialEq, Debug)]
     struct Friend {
         id: u8,
         name: Option<String>,
     }
 
+    let json_obj = read_json("./benches/data_obj.json");
+    let mut selector = jsonpath::selector_as::<Friend>(&json_obj);
     let json = selector("$..friends[2]").unwrap();
 
     let ret = vec!(
@@ -101,7 +90,7 @@ fn select() {
             "isbn" : "0-553-21311-3",
             "price" : 8.99
         }]);
-    assert_eq!(json, ret);
+    compare_result(json, ret);
 }
 
 #[test]
@@ -121,14 +110,14 @@ fn select_str() {
 
 #[test]
 fn test_to_struct() {
-    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    #[derive(Deserialize, PartialEq, Debug)]
     struct Person {
         name: String,
         age: u8,
         phones: Vec<String>,
     }
 
-    let ret: Person = jsonpath::select_as(r#"
+    let ret: Vec<Person> = jsonpath::select_as(r#"
     {
         "person":
             {
@@ -148,5 +137,5 @@ fn test_to_struct() {
         phones: vec!["+44 1234567".to_string(), "+44 2345678".to_string()],
     };
 
-    assert_eq!(person, ret);
+    assert_eq!(vec![person], ret);
 }

tests/mutable.rs

@@ -0,0 +1,40 @@
+extern crate jsonpath_lib as jsonpath;
+#[macro_use]
+extern crate serde_json;
+
+use common::{read_json, setup};
+use jsonpath::{SelectorMut, Selector};
+use serde_json::Value;
+
+mod common;
+
+#[test]
+fn selector_mut() {
+    setup();
+
+    let mut selector_mut = SelectorMut::new();
+
+    let mut nums = Vec::new();
+    let result = selector_mut
+        .str_path(r#"$.store..price"#).unwrap()
+        .value(read_json("./benches/example.json"))
+        .replace_with(&mut |v| {
+            match v {
+                Value::Number(n) => {
+                    nums.push(n.as_f64().unwrap());
+                }
+                _ => {}
+            }
+            Value::String("a".to_string())
+        }).unwrap()
+        .take().unwrap();
+
+    assert_eq!(nums, vec![8.95_f64, 12.99_f64, 8.99_f64, 22.99_f64, 19.95_f64]);
+
+    let mut selector = Selector::new();
+    let result = selector.str_path(r#"$.store..price"#).unwrap()
+        .value(&result)
+        .select().unwrap();
+
+    assert_eq!(vec![&json!("a"), &json!("a"), &json!("a"), &json!("a"), &json!("a")], result);
+}

tests/parser.rs

@@ -1,312 +0,0 @@
-extern crate env_logger;
-extern crate jsonpath_lib as jsonpath;
-
-use std::result;
-use jsonpath::parser::parser::{Parser, ParseToken, NodeVisitor, FilterToken};
-
-struct NodeVisitorTestImpl<'a> {
-    input: &'a str,
-    stack: Vec<ParseToken>,
-}
-
-impl<'a> NodeVisitorTestImpl<'a> {
-    fn new(input: &'a str) -> Self {
-        NodeVisitorTestImpl { input, stack: Vec::new() }
-    }
-
-    fn visit(&mut self) -> result::Result<Vec<ParseToken>, String> {
-        let mut parser = Parser::new(self.input);
-        parser.parse(self)?;
-        Ok(self.stack.split_off(0))
-    }
-}
-
-impl<'a> NodeVisitor for NodeVisitorTestImpl<'a> {
-    fn visit_token(&mut self, token: ParseToken) {
-        self.stack.push(token);
-    }
-}
-
-fn setup() {
-    let _ = env_logger::try_init();
-}
-
-fn run(input: &str) -> result::Result<Vec<ParseToken>, String> {
-    let mut interpreter = NodeVisitorTestImpl::new(input);
-    interpreter.visit()
-}
-
-#[test]
-fn parse_path() {
-    setup();
-
-    assert_eq!(run("$.aa"), Ok(vec![
-        ParseToken::Absolute,
-        ParseToken::In,
-        ParseToken::Key("aa".to_owned())
-    ]));
-
-    assert_eq!(run("$.00.a"), Ok(vec![
-        ParseToken::Absolute,
-        ParseToken::In,
-        ParseToken::Key("00".to_owned()),
-        ParseToken::In,
-        ParseToken::Key("a".to_owned())
-    ]));
-
-    assert_eq!(run("$.00.韓창.seok"), Ok(vec![
-        ParseToken::Absolute,
-        ParseToken::In,
-        ParseToken::Key("00".to_owned()),
-        ParseToken::In,
-        ParseToken::Key("韓창".to_owned()),
-        ParseToken::In,
-        ParseToken::Key("seok".to_owned())
-    ]));
-
-    assert_eq!(run("$.*"), Ok(vec![
-        ParseToken::Absolute,
-        ParseToken::In,
-        ParseToken::All
-    ]));
-
-    assert_eq!(run("$..*"), Ok(vec![
-        ParseToken::Absolute,
-        ParseToken::Leaves,
-        ParseToken::All
-    ]));
-
-    assert_eq!(run("$..[0]"), Ok(vec![
-        ParseToken::Absolute,
-        ParseToken::Leaves,
-        ParseToken::Array,
-        ParseToken::Number(0.0),
-        ParseToken::ArrayEof
-    ]));
-
-    match run("$.") {
-        Ok(_) => panic!(),
-        _ => {}
-    }
-
-    match run("$..") {
-        Ok(_) => panic!(),
-        _ => {}
-    }
-
-    match run("$. a") {
-        Ok(_) => panic!(),
-        _ => {}
-    }
-}
-
-#[test]
-fn parse_array_sytax() {
-    setup();
-
-    assert_eq!(run("$.book[?(@.isbn)]"), Ok(vec![
-        ParseToken::Absolute,
-        ParseToken::In,
-        ParseToken::Key("book".to_string()),
-        ParseToken::Array,
-        ParseToken::Relative,
-        ParseToken::In,
-        ParseToken::Key("isbn".to_string()),
-        ParseToken::ArrayEof
-    ]));
-
-    //
-    // Array도 컨텍스트 In으로 간주 할거라서 중첩되면 하나만
-    //
-    assert_eq!(run("$.[*]"), Ok(vec![
-        ParseToken::Absolute,
-        ParseToken::Array,
-        ParseToken::All,
-        ParseToken::ArrayEof
-    ]));
-
-    assert_eq!(run("$.a[*]"), Ok(vec![
-        ParseToken::Absolute, ParseToken::In, ParseToken::Key("a".to_owned()),
-        ParseToken::Array,
-        ParseToken::All,
-        ParseToken::ArrayEof
-    ]));
-
-    assert_eq!(run("$.a[*].가"), Ok(vec![
-        ParseToken::Absolute, ParseToken::In, ParseToken::Key("a".to_owned()),
-        ParseToken::Array,
-        ParseToken::All,
-        ParseToken::ArrayEof,
-        ParseToken::In, ParseToken::Key("가".to_owned())
-    ]));
-
-    assert_eq!(run("$.a[0][1]"), Ok(vec![
-        ParseToken::Absolute, ParseToken::In, ParseToken::Key("a".to_owned()),
-        ParseToken::Array,
-        ParseToken::Number(0_f64),
-        ParseToken::ArrayEof,
-        ParseToken::Array,
-        ParseToken::Number(1_f64),
-        ParseToken::ArrayEof
-    ]));
-
-    assert_eq!(run("$.a[1,2]"), Ok(vec![
-        ParseToken::Absolute, ParseToken::In, ParseToken::Key("a".to_owned()),
-        ParseToken::Array,
-        ParseToken::Union(vec![1, 2]),
-        ParseToken::ArrayEof
-    ]));
-
-    assert_eq!(run("$.a[10:]"), Ok(vec![
-        ParseToken::Absolute, ParseToken::In, ParseToken::Key("a".to_owned()),
-        ParseToken::Array,
-        ParseToken::Range(Some(10), None),
-        ParseToken::ArrayEof
-    ]));
-
-    assert_eq!(run("$.a[:11]"), Ok(vec![
-        ParseToken::Absolute, ParseToken::In, ParseToken::Key("a".to_owned()),
-        ParseToken::Array,
-        ParseToken::Range(None, Some(11)),
-        ParseToken::ArrayEof
-    ]));
-
-    assert_eq!(run("$.a[-12:13]"), Ok(vec![
-        ParseToken::Absolute, ParseToken::In, ParseToken::Key("a".to_owned()),
-        ParseToken::Array,
-        ParseToken::Range(Some(-12), Some(13)),
-        ParseToken::ArrayEof
-    ]));
-
-    assert_eq!(run("$.a[?(1>2)]"), Ok(vec![
-        ParseToken::Absolute, ParseToken::In, ParseToken::Key("a".to_owned()),
-        ParseToken::Array,
-        ParseToken::Number(1_f64), ParseToken::Number(2_f64), ParseToken::Filter(FilterToken::Greater),
-        ParseToken::ArrayEof
-    ]));
-
-    assert_eq!(run("$.a[?($.b>3)]"), Ok(vec![
-        ParseToken::Absolute, ParseToken::In, ParseToken::Key("a".to_owned()),
-        ParseToken::Array,
-        ParseToken::Absolute, ParseToken::In, ParseToken::Key("b".to_owned()), ParseToken::Number(3_f64), ParseToken::Filter(FilterToken::Greater),
-        ParseToken::ArrayEof
-    ]));
-
-    assert_eq!(run("$[?($.c>@.d && 1==2)]"), Ok(vec![
-        ParseToken::Absolute,
-        ParseToken::Array,
-        ParseToken::Absolute, ParseToken::In, ParseToken::Key("c".to_owned()),
-        ParseToken::Relative, ParseToken::In, ParseToken::Key("d".to_owned()),
-        ParseToken::Filter(FilterToken::Greater),
-        ParseToken::Number(1_f64), ParseToken::Number(2_f64), ParseToken::Filter(FilterToken::Equal),
-        ParseToken::Filter(FilterToken::And),
-        ParseToken::ArrayEof
-    ]));
-
-    assert_eq!(run("$[?($.c>@.d&&(1==2||3>=4))]"), Ok(vec![
-        ParseToken::Absolute,
-        ParseToken::Array,
-        ParseToken::Absolute, ParseToken::In, ParseToken::Key("c".to_owned()),
-        ParseToken::Relative, ParseToken::In, ParseToken::Key("d".to_owned()),
-        ParseToken::Filter(FilterToken::Greater),
-        ParseToken::Number(1_f64), ParseToken::Number(2_f64), ParseToken::Filter(FilterToken::Equal),
-        ParseToken::Number(3_f64), ParseToken::Number(4_f64), ParseToken::Filter(FilterToken::GreaterOrEqual),
-        ParseToken::Filter(FilterToken::Or),
-        ParseToken::Filter(FilterToken::And),
-        ParseToken::ArrayEof
-    ]));
-
-    assert_eq!(run("$[?(@.a<@.b)]"), Ok(vec![
-        ParseToken::Absolute,
-        ParseToken::Array,
-        ParseToken::Relative, ParseToken::In, ParseToken::Key("a".to_owned()),
-        ParseToken::Relative, ParseToken::In, ParseToken::Key("b".to_owned()),
-        ParseToken::Filter(FilterToken::Little),
-        ParseToken::ArrayEof
-    ]));
-
-    assert_eq!(run("$[*][*][*]"), Ok(vec![
-        ParseToken::Absolute,
-        ParseToken::Array,
-        ParseToken::All,
-        ParseToken::ArrayEof,
-        ParseToken::Array,
-        ParseToken::All,
-        ParseToken::ArrayEof,
-        ParseToken::Array,
-        ParseToken::All,
-        ParseToken::ArrayEof
-    ]));
-
-    assert_eq!(run("$['a']['bb']"), Ok(vec![
-        ParseToken::Absolute,
-        ParseToken::Array,
-        ParseToken::Key("a".to_string()),
-        ParseToken::ArrayEof,
-        ParseToken::Array,
-        ParseToken::Key("bb".to_string()),
-        ParseToken::ArrayEof
-    ]));
-
-    match run("$[") {
-        Ok(_) => panic!(),
-        _ => {}
-    }
-
-    match run("$[]") {
-        Ok(_) => panic!(),
-        _ => {}
-    }
-
-    match run("$[a]") {
-        Ok(_) => panic!(),
-        _ => {}
-    }
-
-    match run("$[?($.a)]") {
-        Ok(_) => panic!(),
-        _ => {}
-    }
-
-    match run("$[?(@.a > @.b]") {
-        Ok(_) => panic!(),
-        _ => {}
-    }
-
-    match run("$[?(@.a < @.b&&(@.c < @.d)]") {
-        Ok(_) => panic!(),
-        _ => {}
-    }
-}
-
-#[test]
-fn parse_array_float() {
-    setup();
-
-    assert_eq!(run("$[?(1.1<2.1)]"), Ok(vec![
-        ParseToken::Absolute,
-        ParseToken::Array,
-        ParseToken::Number(1.1), ParseToken::Number(2.1), ParseToken::Filter(FilterToken::Little),
-        ParseToken::ArrayEof
-    ]));
-
-    match run("$[1.1]") {
-        Ok(_) => panic!(),
-        _ => {}
-    }
-
-    match run("$[?(1.1<.2)]") {
-        Ok(_) => panic!(),
-        _ => {}
-    }
-
-    match run("$[?(1.1<2.)]") {
-        Ok(_) => panic!(),
-        _ => {}
-    }
-
-    match run("$[?(1.1<2.a)]") {
-        Ok(_) => panic!(),
-        _ => {}
-    }
-}

tests/readme.rs

@@ -3,14 +3,137 @@ extern crate serde;
 #[macro_use]
 extern crate serde_json;
 
-use serde::{Deserialize, Serialize};
+use serde::Deserialize;
 use serde_json::Value;
 
-use jsonpath::Selector;
+use jsonpath::{Selector, SelectorMut};
+
+mod common;
+
+#[test]
+fn readme() {
+    let json_obj = json!({
+        "store": {
+            "book": [
+                {
+                    "category": "reference",
+                    "author": "Nigel Rees",
+                    "title": "Sayings of the Century",
+                    "price": 8.95
+                },
+                {
+                    "category": "fiction",
+                    "author": "Evelyn Waugh",
+                    "title": "Sword of Honour",
+                    "price": 12.99
+                },
+                {
+                    "category": "fiction",
+                    "author": "Herman Melville",
+                    "title": "Moby Dick",
+                    "isbn": "0-553-21311-3",
+                    "price": 8.99
+                },
+                {
+                    "category": "fiction",
+                    "author": "J. R. R. Tolkien",
+                    "title": "The Lord of the Rings",
+                    "isbn": "0-395-19395-8",
+                    "price": 22.99
+                }
+            ],
+            "bicycle": {
+                "color": "red",
+                "price": 19.95
+            }
+        },
+        "expensive": 10
+    });
+
+    let mut selector = jsonpath::selector(&json_obj);
+
+    assert_eq!(selector("$.store.book[*].author").unwrap(),
+               vec![
+                   "Nigel Rees", "Evelyn Waugh", "Herman Melville", "J. R. R. Tolkien"
+               ]);
+
+    assert_eq!(selector("$..author").unwrap(),
+               vec![
+                   "Nigel Rees", "Evelyn Waugh", "Herman Melville", "J. R. R. Tolkien"
+               ]);
+
+    assert_eq!(selector("$.store.*").unwrap(),
+               vec![
+                   &json!([
+                       { "category": "reference", "author": "Nigel Rees", "title": "Sayings of the Century", "price": 8.95 },
+                       { "category": "fiction", "author": "Evelyn Waugh", "title": "Sword of Honour", "price": 12.99 },
+                       { "category": "fiction", "author": "Herman Melville", "title": "Moby Dick", "isbn": "0-553-21311-3", "price": 8.99 },
+                       { "category": "fiction", "author": "J. R. R. Tolkien", "title": "The Lord of the Rings", "isbn": "0-395-19395-8", "price": 22.99 }
+                   ]),
+                   &json!({ "color": "red", "price": 19.95 })
+               ]);
+
+    assert_eq!(selector("$.store..price").unwrap(),
+               vec![
+                   8.95, 12.99, 8.99, 22.99, 19.95
+               ]);
+
+    assert_eq!(selector("$..book[2]").unwrap(),
+               vec![
+                   &json!({
+                        "category" : "fiction",
+                        "author" : "Herman Melville",
+                        "title" : "Moby Dick",
+                        "isbn" : "0-553-21311-3",
+                        "price" : 8.99
+                    })
+               ]);
+
+    assert_eq!(selector("$..book[-2]").unwrap(),
+               vec![
+                   &json!({
+                        "category" : "fiction",
+                        "author" : "Herman Melville",
+                        "title" : "Moby Dick",
+                        "isbn" : "0-553-21311-3",
+                        "price" : 8.99
+                    })
+               ]);
+
+    assert_eq!(selector("$..book[0,1]").unwrap(),
+               vec![
+                   &json!({"category" : "reference","author" : "Nigel Rees","title" : "Sayings of the Century","price" : 8.95}),
+                   &json!({"category" : "fiction","author" : "Evelyn Waugh","title" : "Sword of Honour","price" : 12.99})
+               ]);
+
+    assert_eq!(selector("$..book[:2]").unwrap(),
+               vec![
+                   &json!({"category" : "reference","author" : "Nigel Rees","title" : "Sayings of the Century","price" : 8.95}),
+                   &json!({"category" : "fiction","author" : "Evelyn Waugh","title" : "Sword of Honour","price" : 12.99})
+               ]);
+
+    assert_eq!(selector("$..book[:2]").unwrap(),
+               vec![
+                   &json!({"category" : "reference","author" : "Nigel Rees","title" : "Sayings of the Century","price" : 8.95}),
+                   &json!({"category" : "fiction","author" : "Evelyn Waugh","title" : "Sword of Honour","price" : 12.99})
+               ]);
+
+    assert_eq!(selector("$..book[?(@.isbn)]").unwrap(),
+               vec![
+                   &json!({"category" : "fiction","author" : "Herman Melville","title" : "Moby Dick","isbn" : "0-553-21311-3","price" : 8.99}),
+                   &json!({"category" : "fiction","author" : "J. R. R. Tolkien","title" : "The Lord of the Rings","isbn" : "0-395-19395-8","price" : 22.99})
+               ]);
+
+    assert_eq!(selector("$.store.book[?(@.price < 10)]").unwrap(),
+               vec![
+                   &json!({"category" : "reference","author" : "Nigel Rees","title" : "Sayings of the Century","price" : 8.95}),
+                   &json!({"category" : "fiction","author" : "Herman Melville","title" : "Moby Dick","isbn" : "0-553-21311-3","price" : 8.99})
+               ]);
+}
 
 #[test]
 fn readme_selector() {
-    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    #[derive(Deserialize, PartialEq, Debug)]
     struct Friend {
         name: String,
         age: Option<u8>,
@@ -31,43 +154,60 @@ fn readme_selector() {
     let mut selector = Selector::new();
 
     let result = selector
-        .path("$..[?(@.age >= 30)]").unwrap()
+        .str_path("$..[?(@.age >= 30)]").unwrap()
-//    .value_from_str(&serde_json::to_string(&json_obj).unwrap() /*&str*/).unwrap()
+        .value(&json_obj)
-//    .value_from(&json_obj /*&impl serde::ser::Serialize*/).unwrap()
+        .select().unwrap();
-        .value(&json_obj /*serde_json::value::Value*/).unwrap()
-        .select_as_value().unwrap();
 
-    assert_eq!(json!([{"name": "친구3", "age": 30}]), result);
+    assert_eq!(vec![&json!({"name": "친구3", "age": 30})], result);
 
     let result = selector.select_as_str().unwrap();
     assert_eq!(r#"[{"name":"친구3","age":30}]"#, result);
 
-    let result = selector.select_as::<Vec<Friend>>().unwrap();
+    let result = selector.select_as::<Friend>().unwrap();
     assert_eq!(vec![Friend { name: "친구3".to_string(), age: Some(30) }], result);
+}
 
-    let _ = selector.map(|v| {
+#[test]
-        let r = match v {
+fn readme_selector_mut() {
-            Value::Array(mut vec) => {
+    let json_obj = json!({
-                for v in &mut vec {
+        "school": {
-                    v.as_object_mut().unwrap().remove("age");
+            "friends": [
-                }
+                {"name": "친구1", "age": 20},
-                Value::Array(vec)
+                {"name": "친구2", "age": 20}
-            }
+            ]
-            _ => Value::Null
+        },
+        "friends": [
+            {"name": "친구3", "age": 30},
+            {"name": "친구4"}
+    ]});
+
+    let mut selector_mut = SelectorMut::new();
+
+    let result = selector_mut
+        .str_path("$..[?(@.age == 20)].age").unwrap()
+        .value(json_obj)
+        .replace_with(&mut |v| {
+            let age = if let Value::Number(n) = v {
+                n.as_u64().unwrap() * 2
+            } else {
+                0
             };
-        Some(r)
-    });
-    assert_eq!(json!([{ "name": "친구3"}]), selector.get().unwrap());
 
-    let _ = selector.value(&json_obj).unwrap()
+            json!(age)
-        .map_as(|mut v: Vec<Friend>| {
+        }).unwrap()
-            let mut f = v.pop().unwrap();
+        .take().unwrap();
-            f.name = "friend3".to_string();
+
-            f.age = None;
+    assert_eq!(result, json!({
-            Some(vec![f])
+        "school": {
-        });
+            "friends": [
-    assert_eq!(vec![Friend { name: "friend3".to_string(), age: None }],
+                {"name": "친구1", "age": 40},
-               selector.get_as::<Vec<Friend>>().unwrap());
+                {"name": "친구2", "age": 40}
+            ]
+        },
+        "friends": [
+            {"name": "친구3", "age": 30},
+            {"name": "친구4"}
+    ]}));
 }
 
 #[test]
@@ -86,11 +226,10 @@ fn readme_select() {
 
     let json = jsonpath::select(&json_obj, "$..friends[0]").unwrap();
 
-    let ret = json!([
+    assert_eq!(json, vec![
-        {"name": "친구3", "age": 30},
+        &json!({"name": "친구3", "age": 30}),
-        {"name": "친구1", "age": 20}
+        &json!({"name": "친구1", "age": 20})
     ]);
-    assert_eq!(json, ret);
 }
 
 #[test]
@@ -122,7 +261,7 @@ fn readme_select_as() {
         phones: Vec<String>,
     }
 
-    let ret: Person = jsonpath::select_as(r#"
+    let ret: Vec<Person> = jsonpath::select_as(r#"
     {
         "person":
             {
@@ -142,12 +281,12 @@ fn readme_select_as() {
         phones: vec!["+44 1234567".to_string(), "+44 2345678".to_string()],
     };
 
-    assert_eq!(person, ret);
+    assert_eq!(ret[0], person);
 }
 
 #[test]
 fn readme_compile() {
-    let mut template = jsonpath::compile("$..friends[0]");
+    let mut first_firend = jsonpath::compile("$..friends[0]");
 
     let json_obj = json!({
         "school": {
@@ -161,14 +300,12 @@ fn readme_compile() {
             {"name": "친구4"}
     ]});
 
-    let json = template(&json_obj).unwrap();
+    let json = first_firend(&json_obj).unwrap();
 
-    let ret = json!([
+    assert_eq!(json, vec![
-        {"name": "친구3", "age": 30},
+        &json!({"name": "친구3", "age": 30}),
-        {"name": "친구1", "age": 20}
+        &json!({"name": "친구1", "age": 20})
     ]);
-
-    assert_eq!(json, ret);
 }
 
 #[test]
@@ -189,21 +326,17 @@ fn readme_selector_fn() {
 
     let json = selector("$..friends[0]").unwrap();
 
-    let ret = json!([
+    assert_eq!(json, vec![
-        {"name": "친구3", "age": 30},
+        &json!({"name": "친구3", "age": 30}),
-        {"name": "친구1", "age": 20}
+        &json!({"name": "친구1", "age": 20})
     ]);
 
-    assert_eq!(json, ret);
-
     let json = selector("$..friends[1]").unwrap();
 
-    let ret = json!([
+    assert_eq!(json, vec![
-        {"name": "친구4"},
+        &json!({"name": "친구4"}),
-        {"name": "친구2", "age": 20}
+        &json!({"name": "친구2", "age": 20})
     ]);
-
-    assert_eq!(json, ret);
 }
 
 #[test]
@@ -220,13 +353,13 @@ fn readme_selector_as() {
             {"name": "친구4"}
     ]});
 
-    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    #[derive(Deserialize, PartialEq, Debug)]
     struct Friend {
         name: String,
         age: Option<u8>,
     }
 
-    let mut selector = jsonpath::selector_as::<Vec<Friend>>(&json_obj);
+    let mut selector = jsonpath::selector_as::<Friend>(&json_obj);
 
     let json = selector("$..friends[0]").unwrap();
 
@@ -245,3 +378,90 @@ fn readme_selector_as() {
 
     assert_eq!(json, ret);
 }
+
+
+#[test]
+fn readme_delete() {
+    let json_obj = json!({
+        "school": {
+            "friends": [
+                {"name": "친구1", "age": 20},
+                {"name": "친구2", "age": 20}
+            ]
+        },
+        "friends": [
+            {"name": "친구3", "age": 30},
+            {"name": "친구4"}
+    ]});
+
+    let ret = jsonpath::delete(json_obj, "$..[?(20 == @.age)]").unwrap();
+
+    assert_eq!(ret, json!({
+        "school": {
+            "friends": [
+                null,
+                null
+            ]
+        },
+        "friends": [
+            {"name": "친구3", "age": 30},
+            {"name": "친구4"}
+    ]}));
+}
+
+#[test]
+fn readme_delete2() {
+    let json_obj = common::read_json("./benches/example.json");
+
+    let ret = jsonpath::delete(json_obj, "$.store.book").unwrap();
+
+    println!("{:?}", ret);
+
+    assert_eq!(ret, json!({
+       "store": {
+           "book": null,
+           "bicycle": {
+               "color": "red",
+               "price": 19.95
+           }
+       },
+       "expensive": 10
+   }));
+}
+
+#[test]
+fn readme_replace_with() {
+    let json_obj = json!({
+        "school": {
+            "friends": [
+                {"name": "친구1", "age": 20},
+                {"name": "친구2", "age": 20}
+            ]
+        },
+        "friends": [
+            {"name": "친구3", "age": 30},
+            {"name": "친구4"}
+    ]});
+
+    let result = jsonpath::replace_with(json_obj, "$..[?(@.age == 20)].age", &mut |v| {
+        let age = if let Value::Number(n) = v {
+            n.as_u64().unwrap() * 2
+        } else {
+            0
+        };
+
+        json!(age)
+    }).unwrap();
+
+    assert_eq!(result, json!({
+        "school": {
+            "friends": [
+                {"name": "친구1", "age": 40},
+                {"name": "친구2", "age": 40}
+            ]
+        },
+        "friends": [
+            {"name": "친구3", "age": 30},
+            {"name": "친구4"}
+    ]}));
+}

tests/selector.rs

@@ -1,209 +0,0 @@
-extern crate jsonpath_lib as jsonpath;
-extern crate serde;
-#[macro_use]
-extern crate serde_json;
-
-use serde::{Deserialize, Serialize};
-use serde_json::Value;
-
-use jsonpath::Selector;
-
-#[derive(Serialize, Deserialize, PartialEq, Debug)]
-struct Person {
-    name: String,
-    age: u8,
-    phone: String,
-}
-
-fn input_str() -> &'static str {
-    r#"[
-        {
-            "name": "이름1",
-            "age": 40,
-            "phone": "+33 12341234"
-        },
-        {
-            "name": "이름2",
-            "age": 42,
-            "phone": "++44 12341234"
-        },
-        {
-            "name": "이름3",
-            "age": 50,
-            "phone": "++55 111111"
-        },
-        {
-            "name": "이름4",
-            "age": 51,
-            "phone": "++55 12341234"
-        }
-    ]"#
-}
-
-fn input_json() -> Value {
-    serde_json::from_str(input_str()).unwrap()
-}
-
-fn input_person() -> Vec<Person> {
-    serde_json::from_str(input_str()).unwrap()
-}
-
-#[test]
-fn selector_value_from() {
-    let result = Selector::new()
-        .path("$..[?(@.age > 40)]").unwrap()
-        .value_from(&input_person()).unwrap()
-        .select_as::<Vec<Person>>().unwrap();
-    assert_eq!(input_person()[1], result[0]);
-}
-
-#[test]
-fn selector_value() {
-    let result = Selector::new()
-        .path("$..[?(@.age > 40)]").unwrap()
-        .value((&input_json()).into()).unwrap()
-        .select_as_value().unwrap();
-    assert_eq!(input_json()[1], result[0]);
-}
-
-#[test]
-fn selector_value_from_str() {
-    let result = Selector::new()
-        .path("$..[?(@.age > 40)]").unwrap()
-        .value_from_str(input_str()).unwrap()
-        .select_as_value().unwrap();
-    assert_eq!(input_json()[1], result[0]);
-}
-
-#[test]
-fn selector_select_to() {
-    let mut selector = Selector::new();
-
-    let result = selector
-        .path("$..[?(@.age > 40)]").unwrap()
-        .value_from_str(input_str()).unwrap()
-        .select_as_value().unwrap();
-    assert_eq!(input_json()[1], result[0]);
-
-    let result = selector.select_as_str().unwrap();
-    let value: Value = serde_json::from_str(&result).unwrap();
-    assert_eq!(input_json()[1], value[0]);
-
-    let result = selector.select_as::<Vec<Person>>().unwrap();
-    assert_eq!(input_person()[1], result[0]);
-
-    let _ = selector.path("$..[?(@.age == 40)]");
-
-    let result = selector.select_as_value().unwrap();
-    assert_eq!(input_json()[0], result[0]);
-
-    let result = selector.select_as_str().unwrap();
-    assert_eq!(serde_json::to_string(&vec![&input_json()[0].clone()]).unwrap(), result);
-
-    let result = selector.select_as::<Vec<Person>>().unwrap();
-    assert_eq!(input_person()[0], result[0]);
-}
-
-fn _remove_name(v: Value) -> Option<Value> {
-    let r = match v {
-        Value::Array(mut vec) => {
-            for v in &mut vec {
-                v.as_object_mut().unwrap().remove("name");
-            }
-            Value::Array(vec)
-        }
-        _ => Value::Null
-    };
-    Some(r)
-}
-
-fn _change_phone_number(v: Value) -> Option<Value> {
-    let r = match v {
-        Value::Array(mut vec) => {
-            let mut v = vec.pop().unwrap();
-            v.as_object_mut().unwrap()
-                .insert("phone".to_string(), Value::String("1234".to_string()));
-            v
-        }
-        _ => Value::Null
-    };
-    Some(r)
-}
-
-fn _rejuvenate(mut vec: Vec<Person>) -> Option<Vec<Person>> {
-    for p in &mut vec {
-        p.age = p.age - 10;
-    }
-    Some(vec)
-}
-
-#[test]
-fn selector_map_basic() {
-    let mut selector = Selector::new();
-
-    let result = selector
-        .path("$..[?(@.age > 40)]").unwrap()
-        .value_from_str(input_str()).unwrap()
-        .map(_remove_name).unwrap()
-        .get().unwrap();
-
-    assert_eq!(result, json!([
-        {"phone": "++44 12341234", "age": 42},
-        {"phone": "++55 111111", "age": 50},
-        {"phone": "++55 12341234", "age": 51},
-    ]));
-}
-
-#[test]
-fn selector_map() {
-    let mut selector = Selector::new();
-
-    let result = selector
-        .path("$..[?(@.age > 40)]").unwrap()
-        .value_from_str(input_str()).unwrap()
-        .map(_remove_name).unwrap()
-        .path("$..[?(@.age == 50)]").unwrap()
-        .map(_change_phone_number).unwrap()
-        .get().unwrap();
-
-    assert_eq!(result, json!({
-        "phone": "1234",
-        "age": 50,
-    }));
-}
-
-#[test]
-fn selector_map_as_basic() {
-    let mut selector = Selector::new();
-
-    let result = selector
-        .path("$..[?(@.age > 40)]").unwrap()
-        .value_from_str(input_str()).unwrap()
-        .map_as(_rejuvenate).unwrap()
-        .get().unwrap();
-
-    assert_eq!(result, json!([
-        {"name": "이름2", "phone": "++44 12341234", "age": 32},
-        {"name": "이름3", "phone": "++55 111111", "age": 40},
-        {"name": "이름4", "phone": "++55 12341234", "age": 41},
-    ]));
-}
-
-#[test]
-fn selector_map_as() {
-    let mut selector = Selector::new();
-
-    let result = selector
-        .path("$..[?(@.age > 40)]").unwrap()
-        .value_from_str(input_str()).unwrap()
-        .map_as(_rejuvenate).unwrap()
-        .path("$..[?(@.age == 40)]").unwrap()
-        .map(_change_phone_number).unwrap()
-        .get().unwrap();
-
-    assert_eq!(result, json!({
-        "name": "이름3",
-        "phone": "1234",
-        "age": 40,
-    }));
-}

tests/serde.rs

@@ -1,39 +0,0 @@
-extern crate jsonpath_lib as jsonpath;
-extern crate serde;
-extern crate serde_json;
-
-use std::io::Read;
-
-use serde_json::Value;
-use jsonpath::ref_value::model::{RefValue, RefValueWrapper};
-
-fn read_json(path: &str) -> String {
-    let mut f = std::fs::File::open(path).unwrap();
-    let mut contents = String::new();
-    f.read_to_string(&mut contents).unwrap();
-    contents
-}
-
-#[test]
-fn de() {
-    let json_str = read_json("./benches/example.json");
-    // RefValue -> Value
-    let ref_value: RefValue = serde_json::from_str(json_str.as_str()).unwrap();
-    let ref value_wrapper: RefValueWrapper = ref_value.into();
-    let value: Value = value_wrapper.into();
-
-    // Value
-    let json: Value = serde_json::from_str(json_str.as_str()).unwrap();
-    assert_eq!(value, json);
-}
-
-#[test]
-fn ser() {
-    let json_str = read_json("./benches/example.json");
-    let ref_value: RefValue = serde_json::from_str(json_str.as_str()).unwrap();
-    let ref_value_str = serde_json::to_string(&ref_value).unwrap();
-
-    let json: Value = serde_json::from_str(json_str.as_str()).unwrap();
-    let json_str = serde_json::to_string(&json).unwrap();
-    assert_eq!(ref_value_str, json_str);
-}

tests/tokenizer.rs

@@ -1,194 +0,0 @@
-extern crate jsonpath_lib as jsonpath;
-
-use jsonpath::parser::tokenizer::{Tokenizer, Token, TokenError, PreloadedTokenizer};
-
-fn collect_token(input: &str) -> (Vec<Token>, Option<TokenError>) {
-    let mut tokenizer = Tokenizer::new(input);
-    let mut vec = vec![];
-    loop {
-        match tokenizer.next_token() {
-            Ok(t) => vec.push(t),
-            Err(e) => return (vec, Some(e)),
-        }
-    }
-}
-
-fn run(input: &str, expected: (Vec<Token>, Option<TokenError>)) {
-    let (vec, err) = collect_token(input.clone());
-    assert_eq!((vec, err), expected, "\"{}\"", input);
-}
-
-#[test]
-fn peek() {
-    let mut tokenizer = PreloadedTokenizer::new("$.a");
-    match tokenizer.next_token() {
-        Ok(t) => assert_eq!(Token::Absolute(0), t),
-        _ => panic!()
-    }
-
-    match tokenizer.peek_token() {
-        Ok(t) => assert_eq!(&Token::Dot(1), t),
-        _ => panic!()
-    }
-
-    match tokenizer.peek_token() {
-        Ok(t) => assert_eq!(&Token::Dot(1), t),
-        _ => panic!()
-    }
-
-    match tokenizer.next_token() {
-        Ok(t) => assert_eq!(Token::Dot(1), t),
-        _ => panic!()
-    }
-}
-
-#[test]
-fn token() {
-    run("$.01.a",
-        (
-            vec![
-                Token::Absolute(0),
-                Token::Dot(1),
-                Token::Key(2, "01".to_string()),
-                Token::Dot(4),
-                Token::Key(5, "a".to_string())
-            ]
-            , Some(TokenError::Eof)
-        ));
-
-    run("$.   []",
-        (
-            vec![
-                Token::Absolute(0),
-                Token::Dot(1),
-                Token::Whitespace(2, 2),
-                Token::OpenArray(5),
-                Token::CloseArray(6)
-            ]
-            , Some(TokenError::Eof)
-        ));
-
-    run("$..",
-        (
-            vec![
-                Token::Absolute(0),
-                Token::Dot(1),
-                Token::Dot(2),
-            ]
-            , Some(TokenError::Eof)
-        ));
-
-    run("$..ab",
-        (
-            vec![
-                Token::Absolute(0),
-                Token::Dot(1),
-                Token::Dot(2),
-                Token::Key(3, "ab".to_string())
-            ]
-            , Some(TokenError::Eof)
-        ));
-
-    run("$..가 [",
-        (
-            vec![
-                Token::Absolute(0),
-                Token::Dot(1),
-                Token::Dot(2),
-                Token::Key(3, "가".to_string()),
-                Token::Whitespace(6, 0),
-                Token::OpenArray(7),
-            ]
-            , Some(TokenError::Eof)
-        ));
-
-    run("[-1, 2 ]",
-        (
-            vec![
-                Token::OpenArray(0),
-                Token::Key(1, "-1".to_string()),
-                Token::Comma(3),
-                Token::Whitespace(4, 0),
-                Token::Key(5, "2".to_string()),
-                Token::Whitespace(6, 0),
-                Token::CloseArray(7),
-            ]
-            , Some(TokenError::Eof)
-        ));
-
-    run("[ 1 2 , 3 \"abc\" : -10 ]",
-        (
-            vec![
-                Token::OpenArray(0),
-                Token::Whitespace(1, 0),
-                Token::Key(2, "1".to_string()),
-                Token::Whitespace(3, 0),
-                Token::Key(4, "2".to_string()),
-                Token::Whitespace(5, 0),
-                Token::Comma(6),
-                Token::Whitespace(7, 0),
-                Token::Key(8, "3".to_string()),
-                Token::Whitespace(9, 0),
-                Token::DoubleQuoted(10, "abc".to_string()),
-                Token::Whitespace(15, 0),
-                Token::Split(16),
-                Token::Whitespace(17, 0),
-                Token::Key(18, "-10".to_string()),
-                Token::Whitespace(21, 0),
-                Token::CloseArray(22),
-            ]
-            , Some(TokenError::Eof)
-        ));
-
-    run("?(@.a가 <41.01)",
-        (
-            vec![
-                Token::Question(0),
-                Token::OpenParenthesis(1),
-                Token::At(2),
-                Token::Dot(3),
-                Token::Key(4, "a가".to_string()),
-                Token::Whitespace(8, 0),
-                Token::Little(9),
-                Token::Key(10, "41".to_string()),
-                Token::Dot(12),
-                Token::Key(13, "01".to_string()),
-                Token::CloseParenthesis(15),
-            ]
-            , Some(TokenError::Eof)
-        ));
-
-    run("?(@.a <4a.01)",
-        (
-            vec![
-                Token::Question(0),
-                Token::OpenParenthesis(1),
-                Token::At(2),
-                Token::Dot(3),
-                Token::Key(4, "a".to_string()),
-                Token::Whitespace(5, 0),
-                Token::Little(6),
-                Token::Key(7, "4a".to_string()),
-                Token::Dot(9),
-                Token::Key(10, "01".to_string()),
-                Token::CloseParenthesis(12),
-            ]
-            , Some(TokenError::Eof)
-        ));
-
-    run("?($.c>@.d)", (
-        vec![
-            Token::Question(0),
-            Token::OpenParenthesis(1),
-            Token::Absolute(2),
-            Token::Dot(3),
-            Token::Key(4, "c".to_string()),
-            Token::Greater(5),
-            Token::At(6),
-            Token::Dot(7),
-            Token::Key(8, "d".to_string()),
-            Token::CloseParenthesis(9)
-        ]
-        , Some(TokenError::Eof)
-    ));
-}

wasm/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "jsonpath-wasm"
-version = "0.1.3"
+version = "0.2.0"
 authors = ["Changseok Han <freestrings@gmail.com>"]
 description = "It is Webassembly version of jsonpath_lib that is JsonPath engine written in Rust - Demo: https://freestrings.github.io/jsonpath"
 keywords = ["jsonpath", "json", "webassembly", "parsing", "rust"]

wasm/src/lib.rs

@@ -1,28 +1,15 @@
 extern crate cfg_if;
 extern crate js_sys;
 extern crate jsonpath_lib as jsonpath;
-#[macro_use]
-extern crate lazy_static;
-extern crate serde;
 extern crate serde_json;
 extern crate wasm_bindgen;
-extern crate web_sys;
-
-use std::collections::HashMap;
-use std::ops::Deref;
-use std::result;
-use std::result::Result;
-use std::sync::Mutex;
 
 use cfg_if::cfg_if;
-use jsonpath::filter::value_filter::JsonValueFilter;
+use jsonpath::{JsonPathError, Parser};
-use jsonpath::parser::parser::{Node, NodeVisitor, Parser};
-use jsonpath::ref_value::model::{RefValue, RefValueWrapper};
 use jsonpath::Selector as _Selector;
+use jsonpath::SelectorMut as _SelectorMut;
 use serde_json::Value;
-use wasm_bindgen::*;
 use wasm_bindgen::prelude::*;
-use web_sys::console;
 
 cfg_if! {
     if #[cfg(feature = "wee_alloc")] {
@@ -42,14 +29,14 @@ cfg_if! {
     }
 }
 
-fn filter_ref_value(json: RefValueWrapper, node: Node) -> JsValue {
+#[wasm_bindgen]
-    let mut jf = JsonValueFilter::new_from_value(json);
+extern "C" {
-    jf.visit(node);
+    #[wasm_bindgen(js_namespace = console)]
-    let taken = &jf.take_value();
+    fn error(s: &str);
-    match JsValue::from_serde(taken.deref()) {
-        Ok(js_value) => js_value,
-        Err(e) => JsValue::from_str(&format!("Json deserialize error: {:?}", e))
 }
+
+macro_rules! console_error {
+    ($($t:tt)*) => (error(&format_args!($($t)*).to_string()))
 }
 
 fn into_serde_json<D>(js_value: &JsValue) -> Result<D, String>
@@ -68,67 +55,55 @@ fn into_serde_json<D>(js_value: &JsValue) -> Result<D, String>
     }
 }
 
-fn into_ref_value(js_value: &JsValue, node: Node) -> JsValue {
+fn replace_fun(v: &Value, fun: &js_sys::Function) -> Value {
-    let result: result::Result<RefValue, String> = into_serde_json::<RefValue>(js_value);
+    match JsValue::from_serde(v) {
-    match result {
+        Ok(js_v) => {
-        Ok(json) => filter_ref_value(json.into(), node),
+            match fun.call1(&JsValue::NULL, &js_v) {
-        Err(e) => JsValue::from_str(&format!("Json serialize error: {}", e))
+                Ok(result) => {
+                    match into_serde_json(&result) {
+                        Ok(json) => json,
+                        Err(e) => {
+                            console_error!("replace_with - closure returned a invalid JSON: {:?}", e);
+                            Value::Null
                         }
                     }
-
-fn get_ref_value(js_value: JsValue, node: Node) -> JsValue {
-    match js_value.as_f64() {
-        Some(val) => {
-            match CACHE_JSON.lock().unwrap().get(&(val as usize)) {
-                Some(json) => filter_ref_value(json.clone(), node),
-                _ => JsValue::from_str("Invalid pointer")
-            }
-        }
-        _ => into_ref_value(&js_value, node)
-    }
-}
-
-lazy_static! {
-    static ref CACHE_JSON: Mutex<HashMap<usize, RefValueWrapper>> = Mutex::new(HashMap::new());
-    static ref CACHE_JSON_IDX: Mutex<usize> = Mutex::new(0);
-}
-
-#[wasm_bindgen(js_name = allocJson)]
-pub extern fn alloc_json(js_value: JsValue) -> usize {
-    let result: result::Result<RefValue, String> = into_serde_json(&js_value);
-    match result {
-        Ok(json) => {
-            let mut map = CACHE_JSON.lock().unwrap();
-            if map.len() >= std::u8::MAX as usize {
-                return 0;
-            }
-
-            let mut idx = CACHE_JSON_IDX.lock().unwrap();
-            *idx += 1;
-            map.insert(*idx, json.into());
-            *idx
                 }
                 Err(e) => {
-            console::error_1(&e.into());
+                    console_error!("replace_with - fail to call closure: {:?}", e);
-            0
+                    Value::Null
                 }
             }
         }
-
+        Err(e) => {
-#[wasm_bindgen(js_name = deallocJson)]
+            console_error!("replace_with - invalid JSON object: {:?}", e);
-pub extern fn dealloc_json(ptr: usize) -> bool {
+            Value::Null
-    let mut map = CACHE_JSON.lock().unwrap();
+        }
-    map.remove(&ptr).is_some()
+    }
 }
 
 #[wasm_bindgen]
 pub fn compile(path: &str) -> JsValue {
-    let mut parser = Parser::new(path);
+    let node = Parser::compile(path);
-    let node = parser.compile();
+
     let cb = Closure::wrap(Box::new(move |js_value: JsValue| {
+        let json = match into_serde_json(&js_value) {
+            Ok(json) => json,
+            Err(e) => return JsValue::from_str(&format!("{:?}", JsonPathError::Serde(e)))
+        };
+
+        let mut selector = _Selector::new();
+
         match &node {
-            Ok(node) => get_ref_value(js_value, node.clone()),
+            Ok(node) => selector.compiled_path(node),
-            Err(e) => JsValue::from_str(&format!("Json path error: {:?}", e))
+            Err(e) => return JsValue::from_str(&format!("{:?}", JsonPathError::Path(e.clone())))
+        };
+
+        match selector.value(&json).select() {
+            Ok(ret) => match JsValue::from_serde(&ret) {
+                Ok(ret) => ret,
+                Err(e) => JsValue::from_str(&format!("{:?}", JsonPathError::Serde(e.to_string())))
+            },
+            Err(e) => JsValue::from_str(&format!("{:?}", e))
         }
     }) as Box<Fn(JsValue) -> JsValue>);
 
@@ -139,26 +114,25 @@ pub fn compile(path: &str) -> JsValue {
 
 #[wasm_bindgen]
 pub fn selector(js_value: JsValue) -> JsValue {
-    let json = match js_value.as_f64() {
+    let json: Value = match JsValue::into_serde(&js_value) {
-        Some(val) => {
+        Ok(json) => json,
-            match CACHE_JSON.lock().unwrap().get(&(val as usize)) {
+        Err(e) => return JsValue::from_str(&format!("{:?}", JsonPathError::Serde(e.to_string())))
-                Some(json) => json.clone(),
-                _ => return JsValue::from_str("Invalid pointer")
-            }
-        }
-        _ => {
-            match into_serde_json::<RefValue>(&js_value) {
-                Ok(json) => json.into(),
-                Err(e) => return JsValue::from_str(e.as_str())
-            }
-        }
     };
 
     let cb = Closure::wrap(Box::new(move |path: String| {
-        let mut parser = Parser::new(path.as_str());
+        match Parser::compile(path.as_str()) {
-        match parser.compile() {
+            Ok(node) => {
-            Ok(node) => filter_ref_value(json.clone(), node),
+                let mut selector = _Selector::new();
-            Err(e) => return JsValue::from_str(e.as_str())
+                let _ = selector.compiled_path(&node);
+                match selector.value(&json).select() {
+                    Ok(ret) => match JsValue::from_serde(&ret) {
+                        Ok(ret) => ret,
+                        Err(e) => JsValue::from_str(&format!("{:?}", JsonPathError::Serde(e.to_string())))
+                    },
+                    Err(e) => JsValue::from_str(&format!("{:?}", e))
+                }
+            }
+            Err(e) => return JsValue::from_str(&format!("{:?}", JsonPathError::Path(e)))
         }
     }) as Box<Fn(String) -> JsValue>);
 
@@ -169,10 +143,108 @@ pub fn selector(js_value: JsValue) -> JsValue {
 
 #[wasm_bindgen]
 pub fn select(js_value: JsValue, path: &str) -> JsValue {
-    let mut parser = Parser::new(path);
+    let json = match into_serde_json(&js_value) {
-    match parser.compile() {
+        Ok(json) => json,
-        Ok(node) => get_ref_value(js_value, node),
+        Err(e) => return JsValue::from_str(&format!("{:?}", JsonPathError::Serde(e)))
-        Err(e) => return JsValue::from_str(e.as_str())
+    };
+
+    match jsonpath::select(&json, path) {
+        Ok(ret) => match JsValue::from_serde(&ret) {
+            Ok(ret) => ret,
+            Err(e) => JsValue::from_str(&format!("{:?}", JsonPathError::Serde(e.to_string())))
+        },
+        Err(e) => JsValue::from_str(&format!("{:?}", e))
+    }
+}
+
+#[wasm_bindgen(catch, js_name = "deleteValue")]
+pub fn delete(js_value: JsValue, path: &str) -> JsValue {
+    let json = match into_serde_json(&js_value) {
+        Ok(json) => json,
+        Err(e) => return JsValue::from_str(&format!("{:?}", JsonPathError::Serde(e)))
+    };
+
+    match jsonpath::delete(json, path) {
+        Ok(ret) => {
+            match JsValue::from_serde(&ret) {
+                Ok(ret) => ret,
+                Err(e) => JsValue::from_str(&format!("{:?}", JsonPathError::Serde(e.to_string())))
+            }
+        }
+        Err(e) => JsValue::from_str(&format!("{:?}", e))
+    }
+}
+
+#[wasm_bindgen(catch, js_name = "replaceWith")]
+pub fn replace_with(js_value: JsValue, path: &str, fun: js_sys::Function) -> JsValue {
+    let json = match into_serde_json(&js_value) {
+        Ok(json) => json,
+        Err(e) => return JsValue::from_str(&format!("{:?}", JsonPathError::Serde(e)))
+    };
+
+    match jsonpath::replace_with(json, path, &mut |v| replace_fun(v, &fun)) {
+        Ok(ret) => match JsValue::from_serde(&ret) {
+            Ok(ret) => ret,
+            Err(e) => JsValue::from_str(&format!("{:?}", JsonPathError::Serde(e.to_string())))
+        },
+        Err(e) => JsValue::from_str(&format!("{:?}", e))
+    }
+}
+
+///
+/// `wasm_bindgen` 제약으로 builder-pattern을 구사 할 수 없다.
+/// lifetime 제약으로 Selector를 사용 할 수 없다.
+///
+#[wasm_bindgen]
+pub struct Selector {
+    path: Option<String>,
+    value: Option<Value>,
+}
+
+#[wasm_bindgen]
+impl Selector {
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> Self {
+        Selector { path: None, value: None }
+    }
+
+    #[wasm_bindgen(catch)]
+    pub fn path(&mut self, path: &str) -> Result<(), JsValue> {
+        self.path = Some(path.to_string());
+        Ok(())
+    }
+
+    #[wasm_bindgen(catch)]
+    pub fn value(&mut self, value: JsValue) -> Result<(), JsValue> {
+        let json = into_serde_json(&value)
+            .map_err(|e| JsValue::from_str(&format!("{:?}", JsonPathError::Serde(e))))?;
+        self.value = Some(json);
+        Ok(())
+    }
+
+    #[wasm_bindgen(catch, js_name = select)]
+    pub fn select(&mut self) -> Result<JsValue, JsValue> {
+        let mut selector = _Selector::new();
+
+        if let Some(path) = &self.path {
+            let _ = selector.str_path(&path).map_err(|e| JsValue::from_str(&format!("{:?}", e)))?;
+        } else {
+            return Err(JsValue::from_str(&format!("{:?}", JsonPathError::EmptyPath)));
+        }
+
+        if let Some(value) = &self.value {
+            let _ = selector.value(value);
+        } else {
+            return Err(JsValue::from_str(&format!("{:?}", JsonPathError::EmptyValue)));
+        }
+
+        match selector.select() {
+            Ok(ret) => match JsValue::from_serde(&ret) {
+                Ok(ret) => Ok(ret),
+                Err(e) => Err(JsValue::from_str(&format!("{:?}", JsonPathError::Serde(e.to_string()))))
+            },
+            Err(e) => Err(JsValue::from_str(&format!("{:?}", e)))
+        }
     }
 }
 
@@ -180,104 +252,90 @@ pub fn select(js_value: JsValue, path: &str) -> JsValue {
 /// `wasm_bindgen` 제약으로 builder-pattern을 구사 할 수 없다.
 ///
 #[wasm_bindgen]
-pub struct Selector {
+pub struct SelectorMut {
-    selector: _Selector
+    path: Option<String>,
+    value: Option<Value>,
 }
 
 #[wasm_bindgen]
-impl Selector {
+impl SelectorMut {
     #[wasm_bindgen(constructor)]
     pub fn new() -> Self {
-        Selector { selector: _Selector::new() }
+        SelectorMut { path: None, value: None }
     }
 
     #[wasm_bindgen(catch)]
-    pub fn path(&mut self, path: &str) -> result::Result<(), JsValue> {
+    pub fn path(&mut self, path: &str) -> Result<(), JsValue> {
-        let _ = self.selector.path(path)?;
+        self.path = Some(path.to_string());
         Ok(())
     }
 
     #[wasm_bindgen(catch)]
-    pub fn value(&mut self, value: JsValue) -> result::Result<(), JsValue> {
+    pub fn value(&mut self, value: JsValue) -> Result<(), JsValue> {
-        let ref ref_value = into_serde_json(&value)?;
+        let json = into_serde_json(&value)
-        let _ = self.selector.value(ref_value)?;
+            .map_err(|e| JsValue::from_str(&format!("{:?}", JsonPathError::Serde(e))))?;
+        self.value = Some(json);
         Ok(())
     }
 
-    #[wasm_bindgen(catch, js_name = selectToStr)]
+    #[wasm_bindgen(catch, js_name = "deleteValue")]
-    pub fn select_to_str(&mut self) -> result::Result<JsValue, JsValue> {
+    pub fn delete(&mut self) -> Result<(), JsValue> {
-        self.select_as_str()
+        let mut selector = _SelectorMut::new();
-    }
 
-    #[wasm_bindgen(catch, js_name = selectAsStr)]
+        if let Some(path) = &self.path {
-    pub fn select_as_str(&mut self) -> result::Result<JsValue, JsValue> {
+            let _ = selector.str_path(path);
-        let json_str = self.selector.select_as_str()?;
+        } else {
-        Ok(JsValue::from_str(&json_str))
+            return Err(JsValue::from_str(&format!("{:?}", JsonPathError::EmptyPath)));
-    }
-
-    #[wasm_bindgen(catch, js_name = selectTo)]
-    pub fn select_to(&mut self) -> result::Result<JsValue, JsValue> {
-        self.select_as()
-    }
-
-    #[wasm_bindgen(catch, js_name = selectAs)]
-    pub fn select_as(&mut self) -> result::Result<JsValue, JsValue> {
-        let ref_value = self.selector.select_as::<RefValue>()
-            .map_err(|e| JsValue::from_str(&e))?;
-        Ok(JsValue::from_serde(&ref_value)
-            .map_err(|e| JsValue::from_str(&e.to_string()))?)
-    }
-
-    #[wasm_bindgen(catch)]
-    pub fn map(&mut self, func: JsValue) -> result::Result<(), JsValue> {
-        if !func.is_function() {
-            return Err(JsValue::from_str("Not a function argument"));
-        }
-
-        let cb: &js_sys::Function = JsCast::unchecked_ref(func.as_ref());
-
-        self.selector.map(|v| {
-            let str_value = match JsValue::from_serde(&v) {
-                Ok(str_value) => str_value,
-                Err(e) => return {
-                    console::error_1(&JsValue::from_str(&e.to_string()));
-                    None
-                }
         };
 
-            match cb.call1(&func, &str_value) {
+        if let Some(value) = self.value.take() {
-                Ok(ret) => {
+            selector.value(value);
-                    match into_serde_json::<Value>(&ret) {
+        } else {
-                        Ok(value) => Some(value),
+            return Err(JsValue::from_str(&format!("{:?}", JsonPathError::EmptyValue)));
-                        Err(e) => {
+        };
-                            console::error_1(&JsValue::from_str(&e.to_string()));
-                            None
-                        }
-                    }
-                }
-                Err(e) => {
-                    console::error_1(&e);
-                    None
-                }
-            }
-        }).map_err(|e| JsValue::from_str(&e))?;
 
+        match selector.delete() {
+            Err(e) => Err(JsValue::from_str(&format!("{:?}", e))),
+            _ => {
+                self.value = selector.take();
                 Ok(())
             }
+        }
+    }
 
-    #[wasm_bindgen(catch)]
+    #[wasm_bindgen(catch, js_name = replaceWith)]
-    pub fn get(&mut self) -> result::Result<JsValue, JsValue> {
+    pub fn replace_with(&mut self, fun: js_sys::Function) -> Result<(), JsValue> {
-        let v = self.selector.get().map_err(|e| JsValue::from_str(&e.to_string()))?;
+        let mut selector = _SelectorMut::new();
-        JsValue::from_serde(&v).map_err(|e| JsValue::from_str(&e.to_string()))
+
+        if let Some(path) = &self.path {
+            let _ = selector.str_path(path);
+        } else {
+            return Err(JsValue::from_str(&format!("{:?}", JsonPathError::EmptyPath)));
+        };
+
+        if let Some(value) = self.value.take() {
+            selector.value(value);
+        } else {
+            return Err(JsValue::from_str(&format!("{:?}", JsonPathError::EmptyValue)));
+        };
+
+        match selector.replace_with(&mut |v| replace_fun(v, &fun)) {
+            Err(e) => Err(JsValue::from_str(&format!("{:?}", e))),
+            _ => {
+                self.value = selector.take();
+                Ok(())
+            }
         }
     }
 
     #[wasm_bindgen(catch)]
-pub fn testa(js_value: JsValue, path: &str, iter: usize) -> result::Result<(), JsValue> {
+    pub fn take(&mut self) -> Result<JsValue, JsValue> {
-    for _ in 0..iter {
+        match self.value.take() {
-        let mut parser = Parser::new(path);
+            Some(ret) => match JsValue::from_serde(&ret) {
-        let node = parser.compile().unwrap();
+                Ok(ret) => Ok(ret),
-        into_ref_value(&js_value, node);
+                Err(e) => Err(JsValue::from_str(&format!("{:?}", e)))
+            },
+            None => Err(JsValue::from_str(&format!("{:?}", JsonPathError::EmptyValue)))
+        }
     }
-    Ok(())
 }

wasm/tests/web.rs

@@ -95,20 +95,6 @@ fn selector() {
     assert_eq!(json, target_json());
 }
 
-#[wasm_bindgen_test]
-fn alloc_dealloc_json() {
-    let ptr = jsonpath::alloc_json(JsValue::from_str(json_str()));
-    assert_eq!(ptr > 0, true);
-
-    let json: Value = jsonpath::select(JsValue::from_f64(ptr as f64), "$..book[2]").into_serde().unwrap();
-    assert_eq!(json, target_json());
-
-    assert_eq!(jsonpath::dealloc_json(ptr), true);
-
-    let err = jsonpath::select(JsValue::from_f64(ptr as f64), "$..book[2]").as_string().unwrap();
-    assert_eq!(err, "Invalid pointer".to_string());
-}
-
 #[wasm_bindgen_test]
 fn selector_struct() {
     let mut selector = jsonpath::Selector::new();

wasm/www_bench/index.js

@@ -61,9 +61,6 @@ let path = '$..book[?(@.price<30 && @.category=="fiction")]';
 let template = jpw.compile(path);
 let selector = jpw.selector(json);
 
-let ptr = jpw.allocJson(json);
-if(ptr == 0) console.error('invalid ptr');
-
 let iterCount = 2000;
 
 run('jsonpath', iterCount, function() { jp.query(json, path) })
@@ -73,17 +70,7 @@ run('jsonpath', iterCount, function() { jp.query(json, path) })
     .then(function() {
         return run('jsonpath-wasm- compile', iterCount, function() { template(json) });
     })
-    .then(function() {
-        return run('jsonpath-wasm- compile-alloc', iterCount, function() { template(ptr) });
-    })
     .then(function() {
         return run('jsonpath-wasm- select', iterCount, function() { jpw.select(json, path) });
     })
-    .then(function() {
+    .finally(function() {});
-        return run('jsonpath-wasm- select-alloc', iterCount, function() { jpw.select(ptr, path) });
-    })
-    .finally(function() {
-        if(!jpw.deallocJson(ptr)) {
-            console.error('fail to dealloc');
-        }
-    });