json_walk 0.1.0

Access values in your JSON data using string paths (e.g. "result.item[0].value").
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

use anyhow::anyhow;
use regex::Regex;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Segment {
    /// The give key is not a list.
    Key(String),
    /// The given key has an index, usually will get this if the key is a list type. Example: item[0]
    Index(String, usize),
}

/// Parsers a json path
#[derive(Debug, Clone)]
pub struct JsonPathParser {}

impl JsonPathParser {
    /// Parses the given JSON path.Returns a vector containing each segment of the path.
    pub fn parse(path: &str) -> anyhow::Result<Vec<Segment>> {
        let mut data: Vec<Segment> = Vec::new();
        for value in path.split(".") {
            data.push(Self::check_segment(value)?);
        }
        Ok(data)
    }

    /// Determines the Segment variant
    /// Parameters:
    /// value - The index value. Example: item[0], first_name, last_name
    pub fn check_segment(value: &str) -> anyhow::Result<Segment> {
        let pattern = r"(\w+)(\[(\d+)\])?";
        let re = Regex::new(pattern)?;

        match re.captures(value) {
            Some(captures) => {
                let key = if let Some(value) = captures.get(1) {
                    value.as_str().to_string()
                } else {
                    return Err(anyhow!("INVALID_PATH_KEY"));
                };
                if let Some(index) = captures.get(3) {
                    let index = index.as_str().parse::<usize>()?;
                    Ok(Segment::Index(key, index))
                } else {
                    Ok(Segment::Key(key))
                }
            }
            None => Err(anyhow!("INVALID_PATH")),
        }
    }
}

#[test]
fn test_json_path_parser() {
    let result = JsonPathParser::check_segment("item[0]");
    assert!(result.is_ok(), "{:#?}", result.err());
    assert_eq!(Segment::Index("item".to_string(), 0), result.unwrap());
    let result = JsonPathParser::check_segment("meta1");
    assert!(result.is_ok(), "{:#?}", result.err());
    assert_eq!(Segment::Key("meta1".to_string()), result.unwrap());

    let test_cases = vec![
        (
            "result.item[0].value",
            vec![
                Segment::Key("result".to_string()),
                Segment::Index("item".to_string(), 0),
                Segment::Key("value".to_string()),
            ],
        ),
        (
            "result.item[1].details.color",
            vec![
                Segment::Key("result".to_string()),
                Segment::Index("item".to_string(), 1),
                Segment::Key("details".to_string()),
                Segment::Key("color".to_string()),
            ],
        ),
        (
            "result.meta.count",
            vec![
                Segment::Key("result".to_string()),
                Segment::Key("meta".to_string()),
                Segment::Key("count".to_string()),
            ],
        ),
        ("status", vec![Segment::Key("status".to_string())]),
        (
            "result.item[0].details.price",
            vec![
                Segment::Key("result".to_string()),
                Segment::Index("item".to_string(), 0),
                Segment::Key("details".to_string()),
                Segment::Key("price".to_string()),
            ],
        ),
        ("timestamp", vec![Segment::Key("timestamp".to_string())]),
    ];
    for test_case in test_cases {
        let parser = JsonPathParser::parse(test_case.0);
        assert!(parser.is_ok(), "{:#?}", parser.err());
        assert_eq!(test_case.1, parser.unwrap())
    }
}