change impl to support json path on generic value

.github/workflows/rust.yml

@@ -0,0 +1,22 @@
+name: Rust
+
+on:
+  push:
+    branches: [ master, generic_json_path ]
+  pull_request:
+    branches: [ master, generic_json_path ]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Build
+      run: cargo build --verbose
+    - name: Run tests
+      run: cargo test --verbose

Cargo.toml

@@ -18,6 +18,7 @@ travis-ci = { repository = "freestrings/jsonpath", branch = "master" }
 
 [dependencies]
 log = "0.4"
+ijson = "0.1.3"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = { version = "1.0", features = ["preserve_order"] }
 array_tool = "1.0.3"

src/lib.rs

@@ -128,20 +128,22 @@ extern crate core;
 extern crate log;
 extern crate serde;
 extern crate serde_json;
+extern crate ijson;
 
 use serde_json::Value;
 
 pub use parser::Parser; // TODO private
 pub use select::JsonPathError;
 pub use select::{Selector, SelectorMut};
+pub use select::json_node::JsonValueUpdater;
 use parser::Node;
 
+// #[doc(hidden)]
+// mod ffi;
 #[doc(hidden)]
-mod ffi;
+pub mod parser;
 #[doc(hidden)]
-mod parser;
-#[doc(hidden)]
-mod select;
+pub mod select;
 
 /// 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.
 ///
@@ -174,7 +176,7 @@ mod select;
     since = "0.2.5",
     note = "Please use the Compiled::compile function instead"
 )]
-pub fn compile(path: &str) -> impl FnMut(&Value) -> Result<Vec<&Value>, JsonPathError> {
+pub fn compile(path: &str) -> impl FnMut(&Value) -> Result<Vec<&Value>, JsonPathError> + '_ {
     let node = parser::Parser::compile(path);
     move |json| match &node {
         Ok(node) => {
@@ -220,7 +222,7 @@ pub fn compile(path: &str) -> impl FnMut(&Value) -> Result<Vec<&Value>, JsonPath
 /// ]);
 /// ```
 #[allow(clippy::needless_lifetimes)]
-pub fn selector<'a>(json: &'a Value) -> impl FnMut(&str) -> Result<Vec<&'a Value>, JsonPathError> {
+pub fn selector<'a>(json: &'a Value) -> impl FnMut(&'a str) -> Result<Vec<&'a Value>, JsonPathError> {
     let mut selector = Selector::default();
     let _ = selector.value(json);
     move |path: &str| selector.str_path(path)?.reset_value().select()
@@ -272,12 +274,27 @@ pub fn selector<'a>(json: &'a Value) -> impl FnMut(&str) -> Result<Vec<&'a Value
 ///
 /// assert_eq!(json, ret);
 /// ```
-pub fn selector_as<T: serde::de::DeserializeOwned>(
-    json: &Value,
-) -> impl FnMut(&str) -> Result<Vec<T>, JsonPathError> + '_ {
+pub fn selector_as<'a, T: serde::de::DeserializeOwned>(
+    json: &'a Value,
+) -> impl FnMut(&'a str) -> Result<Vec<T>, JsonPathError> + '_ {
     let mut selector = Selector::default();
     let _ = selector.value(json);
-    move |path: &str| selector.str_path(path)?.reset_value().select_as()
+    move |path: &str| {
+        let res = selector.str_path(path)?.reset_value().select();
+        match res {
+            Ok(vec) => {
+                let mut ret = Vec::new();
+                for v in vec {
+                    match T::deserialize(v) {
+                        Ok(v) => ret.push(v),
+                        Err(e) => return Err(JsonPathError::Serde(e.to_string())),
+                    }
+                }
+                Ok(ret)
+            }
+            _ => Err(JsonPathError::EmptyValue),
+        }
+    }
 }
 
 /// It is a simple select function. but it compile the jsonpath argument every time.
@@ -333,56 +350,56 @@ pub fn select<'a>(json: &'a Value, path: &str) -> Result<Vec<&'a Value>, JsonPat
 /// assert_eq!(ret, r#"[{"name":"친구3","age":30},{"name":"친구1","age":20}]"#);
 /// ```
 pub fn select_as_str(json_str: &str, path: &str) -> Result<String, JsonPathError> {
-    let json = serde_json::from_str(json_str).map_err(|e| JsonPathError::Serde(e.to_string()))?;
+    let json: Value = serde_json::from_str(json_str).map_err(|e| JsonPathError::Serde(e.to_string()))?;
     let ret = Selector::default().str_path(path)?.value(&json).select()?;
     serde_json::to_string(&ret).map_err(|e| JsonPathError::Serde(e.to_string()))
 }
 
-/// It is the same to `select` function but it deserialize the the result as given type `T`.
-///
-/// ```rust
-/// extern crate jsonpath_lib as jsonpath;
-/// extern crate serde;
-/// #[macro_use] extern crate serde_json;
-///
-/// use serde::{Deserialize, Serialize};
-///
-/// #[derive(Deserialize, PartialEq, Debug)]
-/// struct Person {
-///     name: String,
-///     age: u8,
-///     phones: Vec<String>,
-/// }
-///
-/// let ret: Vec<Person> = jsonpath::select_as(r#"
-/// {
-///     "person":
-///         {
-///             "name": "Doe John",
-///             "age": 44,
-///             "phones": [
-///                 "+44 1234567",
-///                 "+44 2345678"
-///             ]
-///         }
-/// }
-/// "#, "$.person").unwrap();
-///
-/// let person = Person {
-///     name: "Doe John".to_string(),
-///     age: 44,
-///     phones: vec!["+44 1234567".to_string(), "+44 2345678".to_string()],
-/// };
-///
-/// assert_eq!(ret[0], person);
-/// ```
-pub fn select_as<T: serde::de::DeserializeOwned>(
-    json_str: &str,
-    path: &str,
-) -> Result<Vec<T>, JsonPathError> {
-    let json = serde_json::from_str(json_str).map_err(|e| JsonPathError::Serde(e.to_string()))?;
-    Selector::default().str_path(path)?.value(&json).select_as()
-}
+// /// It is the same to `select` function but it deserialize the the result as given type `T`.
+// ///
+// /// ```rust
+// /// extern crate jsonpath_lib as jsonpath;
+// /// extern crate serde;
+// /// #[macro_use] extern crate serde_json;
+// ///
+// /// use serde::{Deserialize, Serialize};
+// ///
+// /// #[derive(Deserialize, PartialEq, Debug)]
+// /// struct Person {
+// ///     name: String,
+// ///     age: u8,
+// ///     phones: Vec<String>,
+// /// }
+// ///
+// /// let ret: Vec<Person> = jsonpath::select_as(r#"
+// /// {
+// ///     "person":
+// ///         {
+// ///             "name": "Doe John",
+// ///             "age": 44,
+// ///             "phones": [
+// ///                 "+44 1234567",
+// ///                 "+44 2345678"
+// ///             ]
+// ///         }
+// /// }
+// /// "#, "$.person").unwrap();
+// ///
+// /// let person = Person {
+// ///     name: "Doe John".to_string(),
+// ///     age: 44,
+// ///     phones: vec!["+44 1234567".to_string(), "+44 2345678".to_string()],
+// /// };
+// ///
+// /// assert_eq!(ret[0], person);
+// /// ```
+// pub fn select_as<T: serde::de::DeserializeOwned>(
+//     json_str: &str,
+//     path: &str,
+// ) -> Result<Vec<T>, JsonPathError> {
+//     let json = serde_json::from_str(json_str).map_err(|e| JsonPathError::Serde(e.to_string()))?;
+//     (selector_as(&json))(path)
+// }
 
 /// Delete(= replace with null) the JSON property using the jsonpath.
 ///
@@ -416,10 +433,11 @@ pub fn select_as<T: serde::de::DeserializeOwned>(
 ///         {"name": "친구4"}
 /// ]}));
 /// ```
-pub fn delete(value: Value, path: &str) -> Result<Value, JsonPathError> {
+pub fn delete(mut value: Value, path: &str) -> Result<Value, JsonPathError> {
     let mut selector = SelectorMut::default();
-    let value = selector.str_path(path)?.value(value).delete()?;
-    Ok(value.take().unwrap_or(Value::Null))
+    let mut updater = JsonValueUpdater::new(|_| Some(Value::Null));
+    selector.str_path(path)?.value(&mut value).replace_with(&mut updater)?;
+    Ok(value)
 }
 
 /// 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.
@@ -464,13 +482,18 @@ pub fn delete(value: Value, path: &str) -> Result<Value, JsonPathError> {
 ///         {"name": "친구4"}
 /// ]}));
 /// ```
-pub fn replace_with<F>(value: Value, path: &str, fun: &mut F) -> Result<Value, JsonPathError>
+pub fn replace_with<'a, F>(mut value: Value, path: &str, fun: F) -> Result<Value, JsonPathError>
 where
     F: FnMut(Value) -> Option<Value>,
 {
     let mut selector = SelectorMut::default();
-    let value = selector.str_path(path)?.value(value).replace_with(fun)?;
-    Ok(value.take().unwrap_or(Value::Null))
+    let mut updater = JsonValueUpdater::new(fun);
+    selector.str_path(path)?.value(&mut value).replace_with(&mut updater)?;
+    Ok(value)
+
+    // let mut selector = SelectorMut::default();
+    // let value = selector.str_path(path)?.value(value).replace_with(fun)?;
+    // Ok(value.take().unwrap_or(Value::Null))
 }
 
 /// A pre-compiled expression.
@@ -516,11 +539,11 @@ where
 /// ]);
 /// ```
 #[derive(Clone, Debug)]
-pub struct Compiled {
-    node: Node,
+pub struct Compiled<'a> {
+    node: Node<'a>,
 }
 
-impl Compiled {
+impl<'a> Compiled<'a> {
     /// Compile a path expression and return a compiled instance.
     ///
     /// If parsing the path fails, it will return an error.
@@ -532,7 +555,7 @@ impl Compiled {
     }
 
     /// Execute the select operation on the pre-compiled path.
-    pub fn select<'a>(&self, value: &'a Value) -> Result<Vec<&'a Value>, JsonPathError> {
+    pub fn select<'b>(&self, value: &'b Value) -> Result<Vec<&'b Value>, JsonPathError> {
         let mut selector = Selector::default();
         selector.compiled_path(&self.node).value(value).select()
     }