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
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
111
112
113

use super::{Error, Input};
use chumsky::primitive::just;
use chumsky::Parser;

#[cfg(feature = "spanned")]
use super::Span;

// 'Wrapping' tokens

macro_rules! wrapping_tokens {
        ($($name:ident($start:literal, $end:literal));* $(;)?) => {
            $(
            #[cfg(feature = "spanned")]
            pub struct $name(Span, Span);
            #[cfg(not(feature = "spanned"))]
            pub struct $name(());

            impl $name {
                #[cfg(feature = "spanned")]
                pub(super) fn parser<T>(item: impl Parser<Input, T, Error = Error>) -> impl Parser<Input, (Self, T), Error = Error> {
                    item.delimited_by(just($start), just($end))
                        .map_with_span(|inner, span| {
                            let start = span.start()..(span.start() + 1);
                            let end = (span.end() - 1)..span.end();

                            ($name(start.into(), end.into()), inner)
                        })
                }

                #[cfg(not(feature = "spanned"))]
                pub(super) fn parser<T>(item: impl Parser<Input, T, Error = Error>) -> impl Parser<Input, (Self, T), Error = Error> {
                    item.delimited_by(just($start), just($end))
                        .map(|inner| {
                            ($name(()), inner)
                        })
                }
            }

            #[cfg(feature = "spanned")]
            impl crate::ast::Spanned for $name {
                fn span(&self) -> crate::ast::Span {
                    self.0.join(self.1)
                }
            }
            )*
        }
    }

wrapping_tokens! {
    Bracket('[', ']');
    Paren('(', ')');
    // Brace('{', '}');
}

// Simple tokens

macro_rules! simple_tokens {
        ($($name:ident($just:literal));* $(;)?) => {
            $(
            #[cfg(feature = "spanned")]
            pub struct $name(Span);
            #[cfg(not(feature = "spanned"))]
            pub struct $name(());

            impl $name {
                #[cfg(feature = "spanned")]
                pub(super) fn parser() -> impl Parser<Input, Self, Error = Error> {
                    just::<_, _, Error>($just)
                        .map_with_span(|_, span| $name(span.into()))
                }

                #[cfg(not(feature = "spanned"))]
                pub(super) fn parser() -> impl Parser<Input, Self, Error = Error> {
                    just::<_, _, Error>($just).map(|_| $name(()))
                }
            }

            #[cfg(feature = "spanned")]
            impl crate::ast::Spanned for $name {
                fn span(&self) -> crate::ast::Span {
                    self.0
                }
            }
            )*
        }
    }

simple_tokens! {
    At('@');
    Bang('!');
    Caret('^');
    Colon(':');
    Dash('-');
    Dollar('$');
    Dot('.');
    DotDot("..");
    DoubleAnd("&&");
    DoublePipe("||");
    DoubleQuote('"');
    EqEq("==");
    GreaterEq(">=");
    GreaterThan('>');
    // LeftSlash('\\');
    LessEq("<=");
    LessThan('<');
    Percent('%');
    Plus('+');
    Question('?');
    RightSlash('/');
    SingleQuote('\'');
    Star('*');
    Tilde('~');
}