jsonpath-rust 1.0.4

The library provides the basic functionality to find the set of the data according to the filtering query.
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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

use crate::parser::model::{Segment, Selector};
use crate::query::queryable::Queryable;
use crate::query::state::{Data, Pointer, State};
use crate::query::Query;

impl Query for Segment {
    fn process<'a, T: Queryable>(&self, step: State<'a, T>) -> State<'a, T> {
        match self {
            Segment::Descendant(segment) => segment.process(step.flat_map(process_descendant)),
            Segment::Selector(selector) => selector.process(step),
            Segment::Selectors(selectors) => process_selectors(step, selectors),
        }
    }
}

fn process_selectors<'a, T: Queryable>(
    step: State<'a, T>,
    selectors: &Vec<Selector>,
) -> State<'a, T> {
    selectors
        .into_iter()
        .map(|s| s.process(step.clone()))
        .reduce(State::reduce)
        .unwrap_or(step.root.into())
}

fn process_descendant<T: Queryable>(data: Pointer<T>) -> Data<T> {
    if let Some(array) = data.inner.as_array() {
        Data::Ref(data.clone()).reduce(
            Data::new_refs(
                array
                    .iter()
                    .enumerate()
                    .map(|(i, elem)| Pointer::idx(elem, data.path.clone(), i))
                    .collect(),
            )
            .flat_map(process_descendant),
        )
    } else if let Some(object) = data.inner.as_object() {
        Data::Ref(data.clone()).reduce(
            Data::new_refs(
                object
                    .into_iter()
                    .map(|(key, value)| Pointer::key(value, data.path.clone(), key))
                    .collect(),
            )
            .flat_map(process_descendant),
        )
    } else {
        Data::Nothing
    }
}

#[cfg(test)]
mod tests {
    use crate::parser::model::{Segment, Selector};
    use crate::query::state::{Pointer, State};
    use crate::query::Query;
    use serde_json::json;

    #[test]
    fn test_process_selectors() {
        let value = json!({"firstName": "John", "lastName" : "doe",});
        let segment = Segment::Selectors(vec![
            Selector::Name("firstName".to_string()),
            Selector::Name("lastName".to_string()),
        ]);
        let step = segment.process(State::root(&value));

        assert_eq!(
            step.ok_ref(),
            Some(vec![
                Pointer::new(&json!("John"), "$['firstName']".to_string()),
                Pointer::new(&json!("doe"), "$['lastName']".to_string())
            ])
        );
    }

    #[test]
    fn test_process_descendant() {
        let value = json!([{"name": "John"}, {"name": "doe"}]);
        let segment = Segment::Descendant(Box::new(Segment::Selector(Selector::Wildcard)));
        let step = segment.process(State::root(&value));

        assert_eq!(
            step.ok_ref(),
            Some(vec![
                Pointer::new(&json!({"name": "John"}), "$[0]".to_string()),
                Pointer::new(&json!({"name": "doe"}), "$[1]".to_string()),
                Pointer::new(&json!("John"), "$[0]['name']".to_string()),
                Pointer::new(&json!("doe"), "$[1]['name']".to_string()),
            ])
        );
    }

    #[test]
    fn test_process_descendant2() {
        let value = json!({"o": [0,1,[2,3]]});
        let segment = Segment::Descendant(Box::new(Segment::Selector(Selector::Index(1))));
        let step = segment.process(State::root(&value));

        assert_eq!(
            step.ok_ref(),
            Some(vec![
                Pointer::new(&json!(1), "$['o'][1]".to_string()),
                Pointer::new(&json!(3), "$['o'][2][1]".to_string()),
            ])
        );
    }
}