Is there a way to select for update/delete?

let result = selector
    .path("$..[?(@.age >= 30)]").unwrap()
    .value(&json_obj).delete() 

The current callback defined:

FnMut(&Value) -> Value

Allowing the callback to return a Result will allow the callback "abort" replace in case it can't be done.

FnMut(&Value) -> Result<Value, JsonPathError>

Perhaps a new method should be added

pub fn try_replace_with<F>(value: Value, path: &str, fun: &mut F) -> Result<Value, JsonPathError>
where
    F: FnMut(&Value) -> Result<Value, JsonPathError>,

Currently the compile function returns impl FnMut(&Value) -> Result<Vec<&Value>, JsonPathError>. And the error of the parsing process is only evaluated when the function is called, typically when you select for data.

However, to me it would make sense to return ParseResult<impl FnMut(&Value) -> Result<Vec<&Value>, JsonPathError>> instead and simplify the actual implementation, dropping the "match" that is re-executed every time.

I would also do this myself, in a custom function. However the Parser is marked to be made private:

pub use parser::Parser; // TODO private

If that helps, I could create a PR to add new compile function which implements the suggested approach.

This PR adds delete and replace_with to a precompiled expression. Because the Nodes are public, this is needed for me to don't pay the compilation price every time in a hot loop.

btw, a cargo fmt reformatted all files. Is the formatting intentionally different? Otherwise I am happy to add a fmt commit to this PR.

Hi... I'm trying to use the JsonPath with OpenAPI files... there is a lot of redirect references that I can't extract of the form:

{
...
 "$ref": "#/x/y/z",
...
}

Given the following JSON

{
    "Junk1": "This is a test to illustrate use of '$' in the attr for the expression $..['$ref'] ",
    "$ref": "Match Root",
    "Subset1":[
        {"Junk2": "Data...",
         "$ref": "Match Subset1"
        }
    ],
    "hierachy1":{
        "hierachy2.1":{
            "hierachy2.1.1":{ "$ref":"Match 2.1.1"},
            "hierachy2.1.2":{ "ref":"Match 2.1.2"},
            "hierachy2.1.3":{ "ref":"No Match 2.1.3"},
            "hierachy2.1.4":{ "$ref":"Match 2.1.4"},
            "hierachy2.1.5":{ "ref":"No Match 2.1.5"}
        },
        "hierachy2.2":{
            "hierachy2.2.1":{ "ref":"No Match 2.2.1"},
            "hierachy2.2.2":{ "$ref":"Match 2.2.2"},
            "hierachy2.2.3":{ "ref":"No Match 2.2.3"},
            "hierachy2.2.4":{ "ref":"No Match 2.2.5"},
            "hierachy2.2.5":{ "$ref":"Match 2.2.5"}
        },
        "hierachy2.3":{
            "hierachy2.3.1":{ "ref":"No Match 2.3.1"},
            "hierachy2.3.2":{ "ref":"No Match 2.3.2"},
            "hierachy2.3.3":{ "ref":"No Match 2.3.3"},
            "hierachy2.3.4":{ "ref":"No Match 2.3.4"},
            "hierachy2.3.5":{ "ref":"No Match 2.3.5"},
            "hierachy2.3.6":{
                "hierachy2.3.6.1":{ "$ref":"Match 2.3.6.1"},
                "hierachy2.3.6.2":{ "ref":"No Match 2.3.6.2"},
                "hierachy2.3.6.3":{ "ref":"No Match 2.3.6.3"},
                "hierachy2.3.6.4":{ "ref":"No Match 2.3.6.4"},
                "hierachy2.3.6.5":{ "ref":"No Match 2.3.6.5"}
                }
            }
    }
}

Using the online JasonPath evaluator, The expressions "$..['$ref']", "$..[$ref]", "$..$ref" should yeild: The

Select: [String("Match Root")
String("Match Subset1"),
String("Match 2.1.1"),
String("Match 2.1.4"),
String("Match 2.2.2"),
String("Match 2.2.5"),
String("Match 2.3.6.1")]

the expression "$..$ref" causes an error: Select: Err(path error: $.. ^^^ )

This works: "$..ref"

Select: [String("Match 2.1.2"), String("No Match 2.1.3"), String("No Match 2.1.5"), String("No Match 2.2.1"), String("No Match 2.2.3"), String("No Match 2.2.5"), String("No Match 2.3.1"), String("No Match 2.3.2"), String("No Match 2.3.3"), String("No Match 2.3.4"), String("No Match 2.3.5"), String("No Match 2.3.6.2"), String("No Match 2.3.6.3"), String("No Match 2.3.6.4"), String("No Match 2.3.6.5")]

I'll be happy to contribute, if you have some indicator on where to look/fix JR

Selector: $..[0]

Input:

["first", {"key": ["first nested", {"more": [{"nested": ["deepest", "second"]}, ["more", "values"]]}]}]

Expected output:

["deepest", "first nested", "first", "more", {"nested": ["deepest", "second"]}]

Actual output:

["first"]

Compare https://cburgmer.github.io/json-path-comparison/. For reference, the output was generated by the program in https://github.com/cburgmer/json-path-comparison/tree/master/implementations/Rust_jsonpath_lib.

When profiling the compile function you can see that a lot of time is wasted on memory allocations. It seems like most of them can be avoided it the the Parser and the Tokenizer will try to work with slices from the original path and not allocate new Strings

ref https://github.com/RedisJSON/RedisJSON/issues/424 & https://github.com/RedisJSON/RedisJSON/issues/425

Hello,

I'm working on a project that pulls in jsonpath_lib as a transitive dependency, and jsonpath's unexpected dependency on env_logger causes cargo-deny conflicts:

error[B004]: found 2 duplicate entries for crate 'env_logger'
   │  
30 │ ╭ env_logger 0.7.1 registry+https://github.com/rust-lang/crates.io-index
31 │ │ env_logger 0.8.3 registry+https://github.com/rust-lang/crates.io-index
   │ ╰──────────────────────────────────────────────────────────────────────^ lock entries
   │  

I see that this dependency has been removed in https://github.com/freestrings/jsonpath/pull/66.

Are you planning to do a release sometime soon? I'd love to be able to be able to avoid the unnecessary dependency in my release code. Please let me know if there's anything I can do to make this easier :) Thanks!

Just noticed this dependency cropped up in my application through cargo tree -d.

Since (as far as I understand) this is just a library and all references of env-logger I found are in tests, it should be moved to [dev-dependencies].

On my local both cargo build and cargo test succeed (with rustc 1.50).

Hi, thank you for the library!

I am trying to use select with Vec<Rc<serde_json::Value>>, but it seems that the only option I have now is to construct a new array-like serde_json::Value. What about adding (or even replacing existing select methods) new pub trait for navigating in json or some other more flexible API? F.e. wolker that can in-depth and in-width move across json could suit here.

Make JsonPathError implement std::error::Error so it can be encapsulated as a valid source by libraries or programs that implement their own error type. Specifically this is usefull when using thiserror, for example now we can have the following error type in our program that uses jsonpath:

use thiserror::Error;

#[derive(Error, Debug)]
pub enum MyError {
    #[error("General error: {0}")]
    GeneralError(String),

    #[error("JSON path error {0}")]
    InvalidJsonPath(#[from] jsonpath_lib::JsonPathError),

    #[error("Some other error")]
    SomeOtherError,
}

Filter might return duplicate results when the internal objects are similar.

e.g. input JSON both objects have name == {"first":"A","middle":"A"}

[{{"name":{"first":"A","middle":"A"},"rank":8},{"name":{"first":"A","middle":"A"},"rank":90}]

When running:

$[?($.name.first=="A")]

The following result is returned:

[{{"name":{"first":"A","middle":"A"},"rank":8},{"name":{"first":"A","middle":"A"},"rank":8},{{"name":{"first":"A","middle":"A"},"rank":90},{"name":{"first":"A","middle":"A"},"rank":90}]

It seems like the bug is in this code which compares all the candidates with all values and return each "parent" twice. https://github.com/freestrings/jsonpath/blob/1a84c5af9445e617a6deed14dadfaee13af0d95f/src/select/expr_term.rs#L107

ref https://github.com/RedisJSON/RedisJSON/issues/667

Path: $[*][?(@.inner.for.inner=='u8')]

JSON:

{
    "0:4": {
      "id": "0:4",
      "inner": {
        "for": {"inner": "u8", "kind": "primitive"}
      }
    }
}

jsonpath matches to []

Expected:

[
   {
      "id" : "0:4",
      "inner" : {
         "for" : {
            "inner" : "u8",
            "kind" : "primitive"
         }
      }
   }
]

(from jayway, via https://jsonpath.herokuapp.com/)

Path such as $.store.book[0]category Does not throw an error and is silently ignoring the surplus text category beyond the ] And is parsed as $.store.book[0]

Can be demonstrated also on https://freestrings.github.io/jsonpath/ The same value is returned with and without the surplus text category. Parser should throw an error on surplus text.

Notice that If there is a dot delimiter before the surplus text then everything is OK, e.g., $.store.book[0].category is working as expeced.

Adding a test such as the following, fails when a filter contains an OR expression with one of its operands being compared to a none-existing value, e.g., Slightly modifying an existing test named op_object_or_default in op.rs:

#[test]
fn op_object_or_nonexisting_default() {
    setup();

    select_and_then_compare(
        "$.friends[?(@.id >= 2 || @.id == 4)]",
        read_json("./benchmark/data_obj.json"),
        json!([
            { "id" : 2, "name" : "Gray Berry" }
        ]),
    );
}

The selected result is empty, while it should be equal to the target json.

When removing the right operand || @.id == 4 it succeeds (with filter "$.friends[?(@.id >= 2)]" )