jsonpath-rust 0.1.3

Introduction to JsonPath

The library provides the basic functionality to find the set of the data according to the filtering query. The idea comes from XPath for XML structures. The details can be found there Therefore JsonPath is a query language for JSON, similar to XPath for XML. The JsonPath query is a set of assertions to specify the JSON fields that need to be verified.

Simple examples

Let's suppose we have a following json:

  {
  "shop": {
    "orders": [
      {
        "id": 1,
        "active": true
      },
      {
        "id": 2
      },
      {
        "id": 3
      },
      {
        "id": 4,
        "active": true
      }
    ]
  }
}

And we pursue to find all orders id having the field 'active'. We can construct the jsonpath instance like that $.shop.orders[?(@.active)].id and get the result [1,4]

The jsonpath description

Operators

Filter expressions

The expressions appear in the filter operator like that [?(@.len > 0)]. The expression in general consists of the following elements:

• Left and right operands, that is ,in turn, can be a static value,representing as a primitive type like a number, string value 'value', array of them or another json path instance.
• Expression sign, denoting what action can be performed

Examples

Given the 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
}

The library

The library intends to provide the basic functionality for ability to find the slices of data using the syntax, saying above. The dependency can be found as following: jsonpath-rust = 0.1.0

The basic example is the following one:

use crate::{JsonPathFinder};
use serde_json::{json, Value};

fn main() {
    let finder = JsonPathFinder::from_str(r#"{"first":{"second":[{"active":1},{"passive":1}]}}"#, "$.first.second[?(@.active)]")?;
    let slice_of_data: Vec<&Value> = finder.find();
    assert_eq!(slice_of_data, vec![&json!({"active":1})]);
}

or even simpler:

 use crate::{JsonPathFinder};
use serde_json::{json, Value};

fn test(json: &str, path: &str, expected: Vec<&Value>) {
    match JsonPathFinder::from_str(json, path) {
        Ok(finder) => assert_eq!(finder.find(), expected),
        Err(e) => panic!("error while parsing json or jsonpath: {}", e)
    }
}

also it will work with the instances of [[Value]] as well.

  use serde_json::Value;
use crate::path::{json_path_instance, PathInstance};

fn test(json: Value, path: &str) {
    let path = parse_json_path(path).map_err(|e| e.to_string())?;
    JsonPathFinder::new(json, path)
}

also the trait can be used:

use serde_json::{json, Value};
use jsonpath_rust::JsonPathQuery;

fn test() {
    let json: Value = serde_json::from_str("{}").expect("to get json");
    let v = json.path("$..book[?(@.author size 10)].title").expect("the path is correct");
    assert_eq!(v, json!([]));
}

The structure

pub enum JsonPath {
    Root,
    // <- $
    Field(String),
    // <- field of the object 
    Chain(Vec<JsonPath>),
    // <- the whole jsonpath
    Descent(String),
    // <- '..'
    Index(JsonPathIndex),
    // <- the set of indexes represented by the next structure [[JsonPathIndex]]
    Current(Box<JsonPath>),
    // <- @
    Wildcard,
    // <- *
    Empty, // the structure to avoid inconsistency
}

pub enum JsonPathIndex {
    Single(usize),
    // <- [1]
    UnionIndex(Vec<f64>),
    // <- [1,2,3]
    UnionKeys(Vec<String>),
    // <- ['key_1','key_2']
    Slice(i32, i32, usize),
    // [0:10:1]
    Filter(Operand, FilterSign, Operand), // <- [?(operand sign operand)]
}