Crate access_json

Query a subset of your Serde-Serializable Data

This library allows you to execute a simple path-query against any serde-serializable object; returning the result as a Option<serde_json::Value>.

use access_json::JSONQuery;
use std::collections::HashMap;
use serde_json;

let mut data: HashMap<&str, u32> = HashMap::default();
data.insert("cat", 9);

let query = JSONQuery::parse(".cat")?; // QueryParseErr
let output = query.execute(&data)?; // QueryExecErr
let expected = serde_json::to_value(&9)?; // You must derive Serialize!

assert_eq!(Some(expected), output);

A More Complex, Nested Example

use access_json::JSONQuery;
use serde_json::{self, Value};

let data: Value = serde_json::from_str(r#"{
   "items": [
      {
         "unwanted": 7,
         "wanted": {"x": 3, "y": 7},
         "array": [3,2,1]
      },
      {
         "whatever": true
      }
   ]
}"#)?;

// We can reference dictionary fields and array indices together:
let output = JSONQuery::parse(".items[1].whatever")?.execute(&data)?;
let expected = serde_json::to_value(&true)?;
assert_eq!(Some(expected), output);

// We can have results be of any-size sub-tree, e.g., a whole array or vec.
let output = JSONQuery::parse(".items[0].array")?.execute(&data)?;
let expected = serde_json::to_value(&vec![3,2,1])?;
assert_eq!(Some(expected), output);

Just #[derive(Serialize)] to query any struct or enum:

use access_json::JSONQuery;
#[macro_use]
extern crate serde_derive;

#[derive(Serialize)]
struct Dog {
   name: String,
   age: i32,
   favorites: Vec<String>,
}

let data = Dog {
    name: "Buddy".into(),
    age: 14,
    favorites: vec!["walks".into(), "naps".into()],
};

let found = JSONQuery::parse(".name")?.execute(&data)?.unwrap();
assert_eq!("Buddy", found);

Modules

query
query_executor
query_parser

Structs

JSONQuery

This is the main interface to this library. Create a new JSONQuery by calling parse.

Enums

QueryExecErr	An enum representing a runtime error given a correctly-parsed query.
QueryParseErr	An enum representing errors possible while parsing a query.

Traits

AnySerializable

An object-safe equivalent of Serde's Serialize trait.