jsonpath-plus 0.1.9

A JSONPath implementation in Rust, compliant with the Proposal A specification as well as including several extensions such as parent and subpath selectors.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

use criterion::{criterion_main, BenchmarkId, Criterion};
use jsonpath_plus::JsonPath;
use pprof::criterion::{Output, PProfProfiler};
use serde::Deserialize;
use serde_json::Value;

#[derive(Deserialize)]
pub struct BenchPaths {
    name: String,
    path: String,
    input: Option<Value>,
}

impl BenchPaths {
    fn read() -> Vec<BenchPaths> {
        serde_json::from_reader(std::fs::File::open("benches/bench_paths.json").unwrap()).unwrap()
    }
}

fn config_criterion() -> Criterion {
    Criterion::default()
        .with_profiler(PProfProfiler::new(100, Output::Flamegraph(None)))
        .configure_from_args()
}

pub fn parse() {
    let mut c = config_criterion();
    let mut group = c.benchmark_group("JsonPath::compile");
    for path in BenchPaths::read() {
        group.bench_with_input(
            BenchmarkId::from_parameter(path.name),
            &*path.path,
            |b, p| b.iter(|| JsonPath::compile(p)),
        );
    }
    group.finish()
}

pub fn find() {
    let mut c = config_criterion();
    let mut group = c.benchmark_group("JsonPath::find");
    for path in BenchPaths::read() {
        let input = match &path.input {
            Some(input) => input,
            None => continue,
        };
        let json_path = JsonPath::compile(&path.path).unwrap();

        group.bench_with_input(BenchmarkId::from_parameter(path.name), input, |b, val| {
            b.iter(|| json_path.find(val))
        });
    }
    group.finish()
}

pub fn find_paths() {
    let mut c = config_criterion();
    let mut group = c.benchmark_group("JsonPath::find_paths");
    for path in BenchPaths::read() {
        let input = match &path.input {
            Some(input) => input,
            None => continue,
        };
        let json_path = JsonPath::compile(&path.path).unwrap();

        group.bench_with_input(BenchmarkId::from_parameter(path.name), input, |b, val| {
            b.iter(|| json_path.find_paths(val))
        });
    }
    group.finish()
}

criterion_main!(parse, find, find_paths);