jsonpath-rust

Python bindings for jsonpath-rust are available via PyPI under the package name jsonpath-rust-bindings.

pip install jsonpath-rust-bindings

To verify the RFC 9535 implementation, run the main.rs file. The test runner will output results to the console and save a detailed report to results.csv.

Console Output Format:

• Skips are indicated as: Skipping test case: <name> because of reason: <reason>
• Failures are grouped under Failed tests: with the test name and reason.
• A summary section provides the total count of tests, passed, failed, and skipped cases.

# Run the main test entry point
# (Assuming cargo or rustc is configured to run main.rs)
rustc rfc9535/src/main.rs && ./main

Version 1.0.0 introduced breaking changes to achieve RFC 9535 compliance. If you are upgrading from older versions, note the following mapping:

Note: The length function was removed. Use Rust's native length expressions within filters instead.

The Queryable trait abstracts JSON-like data structures, allowing them to be used with the JSONPath query engine. To use your own data type with JSONPath, you must implement Queryable and satisfy several trait bounds including Default, Clone, Debug, and conversions from &str, bool, i64, f64, Vec<Self>, and String.

use jsonpath_rust::JsonPath;
use serde_json::json;

let data = json!({
    "store": {
        "books": [
            {"title": "Book 1", "price": 10},
            {"title": "Book 2", "price": 15}
        ]
    }
});

// Access data using the Queryable trait
let books = data.query("$.store.books[*].title").expect("no errors");

To protect against stack overflow during recursive parsing, jsonpath-rust enforces a maximum nesting depth for parentheses () and brackets [].

• The limit is set by MAX_NESTING_DEPTH (currently 128).
• The depth check is performed by scanning the raw input string before the full parse tree is built.
• Brackets and parentheses inside string literals are ignored by the depth checker and do not count towards the limit.

The library allows for targeted updates to JSON structures. While the specific reference_mut and delete_by_path methods are part of the broader API (often accessed via traits on Queryable types), the pattern involves:

1. Finding the path of the element to modify using query_only_path.
2. Using the resulting path to obtain a mutable reference or perform a deletion.

// Conceptual pattern for updating
let mut json = serde_json::json!([{"verb": "RUN", "distance": [1]}]);
let path_elements = json.query_only_path("$[?(@.verb == 'RUN')]")?;

if let Some(path) = path_elements.first() {
    // Use the path to mutate the underlying structure
    // (Implementation details depend on the specific Queryable implementation)
}

You can exclude specific test cases from the compliance suite by using the filtered_cases.json file. This file must be a JSON array containing objects that specify which test case names to filter out and the reason for doing so.

[
  {
    "name": "test_case_name",
    "reason": "reason_for_skipping"
  }
]

If you are running the same JSONPath query multiple times against different data structures, you should avoid parsing the path string repeatedly. Instead, parse the path once into a JpQuery object and use js_path_process to execute it.

1. Parse the path using parse_json_path(path) to get a JpQuery.
2. Call js_path_process(&query, &value) for each data object.

use crate::parser::parse_json_path;

let query = parse_json_path("$.store.book[*].author")?;

let json1 = serde_json::json!({ "store": { "book": [ {"author": "A"}, {"author": "B"} ] } });
let json2 = serde_json::json!({ "store": { "book": [ {"author": "C"}, {"author": "D"} ] } });

let res1 = js_path_process(&query, &json1)?;
let res2 = js_path_process(&query, &json2)?;

The library provides several custom filter extensions to check relationships between elements and arrays:

• in: Checks if the first argument is in the array provided as the second argument. Example: $.elems[?in(@, $.list)]
• nin: Checks if the first argument is not in the array provided as the second argument. Example: $.elems[?nin(@, $.list)]
• none_of: Checks if none of the elements in the first array are in the second array. Example: $.elems[?none_of(@, $.list)]
• any_of: Checks if any of the elements in the first array are in the second array. Example: $.elems[?any_of(@, $.list)]
• subset_of: Checks if all elements in the first array are in the second array. Example: $.elems[?subset_of(@, $.list)]