jsonpath_lib/paths/
path_parser.rs

1use std::str::FromStr;
2
3use crate::{debug, trace};
4
5use super::parser_node_visitor::ParserNodeVisitor;
6use super::parser_token_handler::ParserTokenHandler;
7use super::str_reader::StrRange;
8use super::tokenizer::{TokenError, TokenReader};
9use super::tokens::{FilterToken, ParseToken, Token};
10
11#[derive(Clone, Debug)]
12pub struct PathParser<'a> {
13    parser: ParserImpl<'a>,
14}
15
16impl<'a> PathParser<'a> {
17    pub fn compile(input: &'a str) -> Result<Self, TokenError> {
18        let mut parser = ParserImpl::new(input);
19        parser.compile()?;
20        Ok(PathParser { parser })
21    }
22
23    pub(crate) fn parse<F>(&self, parse_token_handler: &mut F) -> Result<(), String>
24    where
25        F: ParserTokenHandler<'a>,
26    {
27        if self.parser.parse_node.is_none() {
28            unreachable!()
29        }
30
31        let token_reader = &self.parser.token_reader;
32        if let Some(parse_node) = self.parser.parse_node.as_ref() {
33            self.visit(parse_node, parse_token_handler, &|s| {
34                token_reader.read_value(s)
35            });
36        }
37
38        Ok(())
39    }
40}
41
42impl<'a> ParserNodeVisitor<'a> for PathParser<'a> {}
43
44#[derive(Clone, Debug)]
45struct ParserImpl<'a> {
46    token_reader: TokenReader<'a>,
47    parse_node: Option<ParserNode>,
48}
49
50impl<'a> ParserImpl<'a> {
51    pub fn new(input: &'a str) -> Self {
52        ParserImpl {
53            token_reader: TokenReader::new(input),
54            parse_node: None,
55        }
56    }
57
58    fn string_to_num<F, S: FromStr>(string: &str, msg_handler: F) -> Result<S, TokenError>
59    where
60        F: Fn() -> TokenError,
61    {
62        match string.parse() {
63            Ok(n) => Ok(n),
64            _ => Err(msg_handler()),
65        }
66    }
67
68    pub fn compile(&mut self) -> Result<&mut Self, TokenError> {
69        self.parse_node = Some(self.json_path()?);
70        Ok(self)
71    }
72
73    fn json_path(&mut self) -> Result<ParserNode, TokenError> {
74        debug!("#json_path");
75        match self.token_reader.next_token() {
76            Ok(Token::Absolute(_)) => {
77                let node = self.create_node(ParseToken::Absolute);
78                self.paths(node)
79            }
80            _ => Err(self.token_reader.to_error()),
81        }
82    }
83
84    fn paths(&mut self, prev: ParserNode) -> Result<ParserNode, TokenError> {
85        debug!("#paths");
86        match self.token_reader.peek_token() {
87            Ok(Token::Dot(_)) => {
88                self.eat_token();
89                self.paths_dot(prev)
90            }
91            Ok(Token::OpenArray(_)) => {
92                self.eat_token();
93                self.eat_whitespace();
94                let node = self.array(prev)?;
95                self.paths(node)
96            }
97            _ => Ok(prev),
98        }
99    }
100
101    fn paths_dot(&mut self, prev: ParserNode) -> Result<ParserNode, TokenError> {
102        debug!("#paths_dot");
103        let node = self.path(prev)?;
104        self.paths(node)
105    }
106
107    fn path(&mut self, prev: ParserNode) -> Result<ParserNode, TokenError> {
108        debug!("#path");
109        match self.token_reader.peek_token() {
110            Ok(Token::Dot(_)) => self.path_leaves(prev),
111            Ok(Token::Asterisk(_)) => self.path_in_all(prev),
112            Ok(Token::Key(_)) => self.path_in_key(prev),
113            Ok(Token::OpenArray(_)) => {
114                self.eat_token();
115                self.array(prev)
116            }
117            _ => Err(self.token_reader.to_error()),
118        }
119    }
120
121    fn path_leaves(&mut self, prev: ParserNode) -> Result<ParserNode, TokenError> {
122        debug!("#path_leaves");
123        self.eat_token();
124        match self.token_reader.peek_token() {
125            Ok(Token::Asterisk(_)) => self.path_leaves_all(prev),
126            Ok(Token::OpenArray(_)) => {
127                let mut leaves_node = self.create_node(ParseToken::Leaves);
128                leaves_node.left = Some(Box::new(prev));
129                Ok(self.paths(leaves_node)?)
130            }
131            _ => self.path_leaves_key(prev),
132        }
133    }
134
135    fn path_leaves_key(&mut self, prev: ParserNode) -> Result<ParserNode, TokenError> {
136        debug!("#path_leaves_key");
137        Ok(ParserNode {
138            token: ParseToken::Leaves,
139            left: Some(Box::new(prev)),
140            right: Some(Box::new(self.key()?)),
141        })
142    }
143
144    fn path_leaves_all(&mut self, prev: ParserNode) -> Result<ParserNode, TokenError> {
145        debug!("#path_leaves_all");
146        self.eat_token();
147        Ok(ParserNode {
148            token: ParseToken::Leaves,
149            left: Some(Box::new(prev)),
150            right: Some(Box::new(self.create_node(ParseToken::All))),
151        })
152    }
153
154    fn path_in_all(&mut self, prev: ParserNode) -> Result<ParserNode, TokenError> {
155        debug!("#path_in_all");
156        self.eat_token();
157        Ok(ParserNode {
158            token: ParseToken::In,
159            left: Some(Box::new(prev)),
160            right: Some(Box::new(self.create_node(ParseToken::All))),
161        })
162    }
163
164    fn path_in_key(&mut self, prev: ParserNode) -> Result<ParserNode, TokenError> {
165        debug!("#path_in_key");
166        Ok(ParserNode {
167            token: ParseToken::In,
168            left: Some(Box::new(prev)),
169            right: Some(Box::new(self.key()?)),
170        })
171    }
172
173    fn key(&mut self) -> Result<ParserNode, TokenError> {
174        debug!("#key");
175        match self.token_reader.next_token() {
176            Ok(Token::Key(s)) => Ok(self.create_node(ParseToken::Key(s))),
177            _ => Err(self.token_reader.to_error()),
178        }
179    }
180
181    fn boolean(&mut self) -> Result<ParserNode, TokenError> {
182        debug!("#boolean");
183
184        fn validation_bool_value(v: &str) -> bool {
185            let b = v.as_bytes();
186            !b.is_empty() && (b[0] == b't' || b[0] == b'T' || b[0] == b'f' || b[0] == b'F')
187        }
188
189        if let Ok(Token::Key(s)) = self.token_reader.next_token() {
190            let v = self.token_reader.read_value(&s);
191            if validation_bool_value(v) {
192                return Ok(self.create_node(ParseToken::Bool(v.eq_ignore_ascii_case("true"))));
193            }
194        }
195
196        Err(self.token_reader.to_error())
197    }
198
199    fn array_keys(&mut self, first_key: StrRange) -> Result<ParserNode, TokenError> {
200        let mut keys = vec![first_key];
201
202        while let Ok(Token::Comma(_)) = self.token_reader.peek_token() {
203            self.eat_token();
204            self.eat_whitespace();
205
206            match self.token_reader.next_token() {
207                Ok(Token::SingleQuoted(s)) | Ok(Token::DoubleQuoted(s)) => {
208                    keys.push(s);
209                }
210                _ => return Err(self.token_reader.to_error()),
211            }
212
213            self.eat_whitespace();
214        }
215
216        Ok(self.create_node(ParseToken::Keys(keys)))
217    }
218
219    fn array_quote_value(&mut self) -> Result<ParserNode, TokenError> {
220        debug!("#array_quote_value");
221        let next = self.token_reader.next_token();
222        match next {
223            Ok(Token::SingleQuoted(s)) | Ok(Token::DoubleQuoted(s)) => {
224                if let Ok(Token::Comma(_)) = self.token_reader.peek_token() {
225                    self.array_keys(s)
226                } else {
227                    Ok(self.create_node(ParseToken::Key(s)))
228                }
229            }
230            _ => Err(self.token_reader.to_error()),
231        }
232    }
233
234    fn array_start(&mut self, prev: ParserNode) -> Result<ParserNode, TokenError> {
235        debug!("#array_start");
236        match self.token_reader.peek_token() {
237            Ok(Token::Question(_)) => {
238                self.eat_token();
239                Ok(ParserNode {
240                    token: ParseToken::Array,
241                    left: Some(Box::new(prev)),
242                    right: Some(Box::new(self.filter()?)),
243                })
244            }
245            Ok(Token::Asterisk(_)) => {
246                self.eat_token();
247                Ok(ParserNode {
248                    token: ParseToken::Array,
249                    left: Some(Box::new(prev)),
250                    right: Some(Box::new(self.create_node(ParseToken::All))),
251                })
252            }
253            _ => Ok(ParserNode {
254                token: ParseToken::Array,
255                left: Some(Box::new(prev)),
256                right: Some(Box::new(self.array_value()?)),
257            }),
258        }
259    }
260
261    fn array(&mut self, prev: ParserNode) -> Result<ParserNode, TokenError> {
262        debug!("#array");
263        let ret = self.array_start(prev)?;
264        self.eat_whitespace();
265        self.close_token(ret, Token::CloseArray(StrRange::new(0, 0)))
266    }
267
268    fn array_value_key(&mut self) -> Result<ParserNode, TokenError> {
269        debug!("#array_value_key");
270
271        if let Ok(Token::Key(s)) = self.token_reader.next_token() {
272            let val = self.token_reader.read_value(&s);
273            let digit = Self::string_to_num(val, || self.token_reader.to_error())?;
274            self.eat_whitespace();
275
276            match self.token_reader.peek_token() {
277                Ok(Token::Comma(_)) => self.union(digit),
278                Ok(Token::Split(_)) => self.range_from(digit),
279                _ => Ok(self.create_node(ParseToken::Number(digit as f64))),
280            }
281        } else {
282            Err(self.token_reader.to_error())
283        }
284    }
285
286    fn array_value(&mut self) -> Result<ParserNode, TokenError> {
287        debug!("#array_value");
288        match self.token_reader.peek_token() {
289            Ok(Token::Key(_)) => self.array_value_key(),
290            Ok(Token::Split(_)) => {
291                self.eat_token();
292                self.range_to()
293            }
294            Ok(Token::DoubleQuoted(_)) | Ok(Token::SingleQuoted(_)) => self.array_quote_value(),
295            Err(TokenError::Eof) => Ok(self.create_node(ParseToken::Eof)),
296            _ => {
297                self.eat_token();
298                Err(self.token_reader.to_error())
299            }
300        }
301    }
302
303    fn union(&mut self, num: isize) -> Result<ParserNode, TokenError> {
304        debug!("#union");
305        let mut values = vec![num];
306        while matches!(self.token_reader.peek_token(), Ok(Token::Comma(_))) {
307            self.eat_token();
308            self.eat_whitespace();
309
310            match self.token_reader.next_token() {
311                Ok(Token::Key(s)) => {
312                    let val = self.token_reader.read_value(&s);
313                    let digit = Self::string_to_num(val, || self.token_reader.to_error())?;
314                    values.push(digit);
315                }
316                _ => {
317                    return Err(self.token_reader.to_error());
318                }
319            }
320        }
321        Ok(self.create_node(ParseToken::Union(values)))
322    }
323
324    fn range_value<S: FromStr>(&mut self) -> Result<Option<S>, TokenError> {
325        self.eat_whitespace();
326
327        match self.token_reader.peek_token() {
328            Ok(Token::Split(_)) => {
329                self.eat_token();
330                self.eat_whitespace();
331            }
332            _ => {
333                return Ok(None);
334            }
335        }
336
337        match self.token_reader.peek_token() {
338            Ok(Token::Key(_)) => {}
339            _ => {
340                return Ok(None);
341            }
342        }
343
344        match self.token_reader.next_token() {
345            Ok(Token::Key(s)) => {
346                let str_step = self.token_reader.read_value(&s);
347                match Self::string_to_num(str_step, || self.token_reader.to_error()) {
348                    Ok(step) => Ok(Some(step)),
349                    Err(e) => Err(e),
350                }
351            }
352            _ => {
353                unreachable!();
354            }
355        }
356    }
357
358    fn range_from(&mut self, from: isize) -> Result<ParserNode, TokenError> {
359        debug!("#range_from");
360        self.eat_token();
361        self.eat_whitespace();
362
363        match self.token_reader.peek_token() {
364            Ok(Token::Key(_)) => self.range(from),
365            Ok(Token::Split(_)) => match self.range_value()? {
366                Some(step) => Ok(self.create_node(ParseToken::Range(Some(from), None, Some(step)))),
367                _ => Ok(self.create_node(ParseToken::Range(Some(from), None, None))),
368            },
369            _ => Ok(self.create_node(ParseToken::Range(Some(from), None, None))),
370        }
371    }
372
373    fn range_to(&mut self) -> Result<ParserNode, TokenError> {
374        debug!("#range_to");
375
376        if let Some(step) = self.range_value()? {
377            return Ok(self.create_node(ParseToken::Range(None, None, Some(step))));
378        }
379
380        if let Ok(Token::CloseArray(_)) = self.token_reader.peek_token() {
381            return Ok(self.create_node(ParseToken::Range(None, None, None)));
382        }
383
384        match self.token_reader.next_token() {
385            Ok(Token::Key(s)) => {
386                let to_str = self.token_reader.read_value(&s);
387                let to = Self::string_to_num(to_str, || self.token_reader.to_error())?;
388                let step = self.range_value()?;
389                Ok(self.create_node(ParseToken::Range(None, Some(to), step)))
390            }
391            _ => Err(self.token_reader.to_error()),
392        }
393    }
394
395    fn range(&mut self, from: isize) -> Result<ParserNode, TokenError> {
396        debug!("#range");
397        match self.token_reader.next_token() {
398            Ok(Token::Key(s)) => {
399                let str_to = self.token_reader.read_value(&s);
400                let to = Self::string_to_num(str_to, || self.token_reader.to_error())?;
401                let step = self.range_value()?;
402                Ok(self.create_node(ParseToken::Range(Some(from), Some(to), step)))
403            }
404            _ => Err(self.token_reader.to_error()),
405        }
406    }
407
408    fn filter(&mut self) -> Result<ParserNode, TokenError> {
409        debug!("#filter");
410        match self.token_reader.next_token() {
411            Ok(Token::OpenParenthesis(_)) => {
412                let ret = self.exprs()?;
413                self.eat_whitespace();
414                self.close_token(ret, Token::CloseParenthesis(StrRange::new(0, 0)))
415            }
416            _ => Err(self.token_reader.to_error()),
417        }
418    }
419
420    fn exprs(&mut self) -> Result<ParserNode, TokenError> {
421        self.eat_whitespace();
422        debug!("#exprs");
423        let node = match self.token_reader.peek_token() {
424            Ok(Token::OpenParenthesis(_)) => {
425                self.eat_token();
426                trace!("\t-exprs - open_parenthesis");
427                let ret = self.exprs()?;
428                self.eat_whitespace();
429                self.close_token(ret, Token::CloseParenthesis(StrRange::new(0, 0)))?
430            }
431            _ => {
432                trace!("\t-exprs - else");
433                self.expr()?
434            }
435        };
436        self.eat_whitespace();
437        self.condition_expr(node)
438    }
439
440    fn condition_expr(&mut self, prev: ParserNode) -> Result<ParserNode, TokenError> {
441        debug!("#condition_expr");
442        match self.token_reader.peek_token() {
443            Ok(Token::And(_)) => {
444                self.eat_token();
445                Ok(ParserNode {
446                    token: ParseToken::Filter(FilterToken::And),
447                    left: Some(Box::new(prev)),
448                    right: Some(Box::new(self.exprs()?)),
449                })
450            }
451            Ok(Token::Or(_)) => {
452                self.eat_token();
453                Ok(ParserNode {
454                    token: ParseToken::Filter(FilterToken::Or),
455                    left: Some(Box::new(prev)),
456                    right: Some(Box::new(self.exprs()?)),
457                })
458            }
459            _ => Ok(prev),
460        }
461    }
462
463    fn expr(&mut self) -> Result<ParserNode, TokenError> {
464        debug!("#expr");
465
466        let has_prop_candidate = matches!(self.token_reader.peek_token(), Ok(Token::At(_)));
467
468        let node = self.term()?;
469        self.eat_whitespace();
470
471        if matches!(
472            self.token_reader.peek_token(),
473            Ok(Token::Equal(_))
474                | Ok(Token::NotEqual(_))
475                | Ok(Token::Little(_))
476                | Ok(Token::LittleOrEqual(_))
477                | Ok(Token::Greater(_))
478                | Ok(Token::GreaterOrEqual(_))
479        ) {
480            self.op(node)
481        } else if has_prop_candidate {
482            Ok(node)
483        } else {
484            Err(self.token_reader.to_error())
485        }
486    }
487
488    fn term_num(&mut self) -> Result<ParserNode, TokenError> {
489        debug!("#term_num");
490        match self.token_reader.next_token() {
491            Ok(Token::Key(s)) => {
492                let val = self.token_reader.read_value(&s);
493                match self.token_reader.peek_token() {
494                    Ok(Token::Dot(_)) => self.term_num_float(val),
495                    _ => {
496                        let number = Self::string_to_num(val, || self.token_reader.to_error())?;
497                        Ok(self.create_node(ParseToken::Number(number)))
498                    }
499                }
500            }
501            _ => Err(self.token_reader.to_error()),
502        }
503    }
504
505    fn term_num_float(&mut self, num: &'a str) -> Result<ParserNode, TokenError> {
506        debug!("#term_num_float");
507        self.eat_token();
508        match self.token_reader.next_token() {
509            Ok(Token::Key(s)) => {
510                let frac = self.token_reader.read_value(&s);
511                let number = Self::string_to_num(&[num, ".", frac].concat(), || {
512                    self.token_reader.to_error()
513                })?;
514                Ok(self.create_node(ParseToken::Number(number)))
515            }
516            _ => Err(self.token_reader.to_error()),
517        }
518    }
519
520    fn term(&mut self) -> Result<ParserNode, TokenError> {
521        debug!("#term");
522
523        if self.token_reader.peek_token().is_err() {
524            return Err(self.token_reader.to_error());
525        }
526
527        let has_term_key = if let Ok(Token::Key(s)) = self.token_reader.peek_token() {
528            Some(s.clone())
529        } else {
530            None
531        };
532
533        if let Some(s) = has_term_key {
534            let key = self.token_reader.read_value(&s);
535            return match key.as_bytes()[0] {
536                b'-' | b'0'..=b'9' => self.term_num(),
537                _ => self.boolean(),
538            };
539        }
540
541        match self.token_reader.peek_token() {
542            Ok(Token::At(_)) => {
543                self.eat_token();
544
545                let node = self.create_node(ParseToken::Relative);
546                match self.token_reader.peek_token() {
547                    Ok(Token::Whitespace(_)) => {
548                        self.eat_whitespace();
549                        Ok(node)
550                    }
551                    _ => self.paths(node),
552                }
553            }
554            Ok(Token::Absolute(_)) => self.json_path(),
555            Ok(Token::DoubleQuoted(_)) | Ok(Token::SingleQuoted(_)) => self.array_quote_value(),
556            _ => Err(self.token_reader.to_error()),
557        }
558    }
559
560    fn op(&mut self, prev: ParserNode) -> Result<ParserNode, TokenError> {
561        debug!("#op");
562        let token = match self.token_reader.next_token() {
563            Ok(Token::Equal(_)) => ParseToken::Filter(FilterToken::Equal),
564            Ok(Token::NotEqual(_)) => ParseToken::Filter(FilterToken::NotEqual),
565            Ok(Token::Little(_)) => ParseToken::Filter(FilterToken::Little),
566            Ok(Token::LittleOrEqual(_)) => ParseToken::Filter(FilterToken::LittleOrEqual),
567            Ok(Token::Greater(_)) => ParseToken::Filter(FilterToken::Greater),
568            Ok(Token::GreaterOrEqual(_)) => ParseToken::Filter(FilterToken::GreaterOrEqual),
569            _ => {
570                return Err(self.token_reader.to_error());
571            }
572        };
573
574        self.eat_whitespace();
575
576        Ok(ParserNode {
577            token,
578            left: Some(Box::new(prev)),
579            right: Some(Box::new(self.term()?)),
580        })
581    }
582
583    fn eat_whitespace(&mut self) {
584        while let Ok(Token::Whitespace(_)) = self.token_reader.peek_token() {
585            let _ = self.token_reader.next_token();
586        }
587    }
588
589    fn eat_token(&mut self) {
590        let _ = self.token_reader.next_token();
591    }
592
593    fn close_token(&mut self, ret: ParserNode, token: Token) -> Result<ParserNode, TokenError> {
594        debug!("#close_token");
595        match self.token_reader.next_token() {
596            Ok(ref t) if t.is_match_token_type(token) => Ok(ret),
597            _ => Err(self.token_reader.to_error()),
598        }
599    }
600
601    fn create_node(&mut self, token: ParseToken) -> ParserNode {
602        ParserNode {
603            left: None,
604            right: None,
605            token,
606        }
607    }
608}
609
610#[derive(Debug, Clone)]
611pub struct ParserNode {
612    pub left: Option<Box<ParserNode>>,
613    pub right: Option<Box<ParserNode>>,
614    pub token: ParseToken,
615}
616
617#[cfg(test)]
618mod path_parser_tests {
619    use crate::paths::path_parser::PathParser;
620    use crate::paths::str_reader::StrRange;
621    use crate::paths::tokens::{FilterToken, ParseToken};
622    use crate::paths::ParserTokenHandler;
623    use crate::trace;
624
625    struct NodeVisitorTestImpl<'a> {
626        input: &'a str,
627        stack: Vec<ParseToken>,
628    }
629
630    impl<'a> NodeVisitorTestImpl<'a> {
631        fn new(input: &'a str) -> Self {
632            NodeVisitorTestImpl {
633                input,
634                stack: Vec::new(),
635            }
636        }
637
638        fn start(&mut self) -> Result<Vec<ParseToken>, String> {
639            let parser = PathParser::compile(self.input).map_err(|_| "Token Error")?;
640            let _ = parser.parse(self);
641            Ok(self.stack.split_off(0))
642        }
643    }
644
645    impl<'a> ParserTokenHandler<'a> for NodeVisitorTestImpl<'a> {
646        fn handle<F>(&mut self, token: &ParseToken, _: &F)
647        where
648            F: Fn(&StrRange) -> &'a str,
649        {
650            trace!("handle {:?}", token);
651            self.stack.push(token.clone());
652        }
653    }
654
655    fn setup() {
656        let _ = env_logger::try_init();
657    }
658
659    fn run(input: &str) -> Result<Vec<ParseToken>, String> {
660        let mut interpreter = NodeVisitorTestImpl::new(input);
661        interpreter.start()
662    }
663
664    #[test]
665    fn parse_error() {
666        setup();
667
668        fn invalid(path: &str) {
669            assert!(run(path).is_err());
670        }
671
672        invalid("$[]");
673        invalid("$[a]");
674        invalid("$[?($.a)]");
675        invalid("$[?(@.a > @.b]");
676        invalid("$[?(@.a < @.b&&(@.c < @.d)]");
677        invalid("@.");
678        invalid("$..[?(a <= @.a)]"); // invalid term value
679        invalid("$['a', b]");
680        invalid("$[0, >=]");
681        invalid("$[a:]");
682        invalid("$[:a]");
683        invalid("$[::a]");
684        invalid("$[:>]");
685        invalid("$[1:>]");
686        invalid("$[1,,]");
687        invalid("$[?]");
688        invalid("$[?(1 = 1)]");
689        invalid("$[?(1 = >)]");
690    }
691
692    #[test]
693    fn parse_path() {
694        setup();
695
696        assert_eq!(
697            run("$.aa"),
698            Ok(vec![
699                ParseToken::Absolute,
700                ParseToken::In,
701                ParseToken::Key(StrRange::new(2, "aa".len()))
702            ])
703        );
704
705        assert_eq!(
706            run("$.00.a"),
707            Ok(vec![
708                ParseToken::Absolute,
709                ParseToken::In,
710                ParseToken::Key(StrRange::new(2, "00".len())),
711                ParseToken::In,
712                ParseToken::Key(StrRange::new(5, "a".len()))
713            ])
714        );
715
716        assert_eq!(
717            run("$.00.韓창.seok"),
718            Ok(vec![
719                ParseToken::Absolute,
720                ParseToken::In,
721                ParseToken::Key(StrRange::new(2, "00".len())),
722                ParseToken::In,
723                ParseToken::Key(StrRange::new(5, "韓창".chars().map(|c| c.len_utf8()).sum())),
724                ParseToken::In,
725                ParseToken::Key(StrRange::new(12, "seok".len()))
726            ])
727        );
728
729        assert_eq!(
730            run("$.*"),
731            Ok(vec![ParseToken::Absolute, ParseToken::In, ParseToken::All])
732        );
733
734        assert_eq!(
735            run("$..*"),
736            Ok(vec![
737                ParseToken::Absolute,
738                ParseToken::Leaves,
739                ParseToken::All
740            ])
741        );
742
743        assert_eq!(
744            run("$..[0]"),
745            Ok(vec![
746                ParseToken::Absolute,
747                ParseToken::Leaves,
748                ParseToken::Array,
749                ParseToken::Number(0.0),
750                ParseToken::ArrayEof
751            ])
752        );
753
754        assert_eq!(
755            run("$.$a"),
756            Ok(vec![
757                ParseToken::Absolute,
758                ParseToken::In,
759                ParseToken::Key(StrRange::new(2, "$a".len()))
760            ])
761        );
762
763        assert_eq!(
764            run("$.['$a']"),
765            Ok(vec![
766                ParseToken::Absolute,
767                ParseToken::Array,
768                ParseToken::Key(StrRange::new(3, "'$a'".len())),
769                ParseToken::ArrayEof,
770            ])
771        );
772
773        if run("$.").is_ok() {
774            panic!();
775        }
776
777        if run("$..").is_ok() {
778            panic!();
779        }
780
781        if run("$. a").is_ok() {
782            panic!();
783        }
784    }
785
786    #[test]
787    fn parse_array_syntax() {
788        setup();
789
790        assert_eq!(
791            run("$.book[?(@.isbn)]"),
792            Ok(vec![
793                ParseToken::Absolute,
794                ParseToken::In,
795                ParseToken::Key(StrRange::new(2, "book".len())),
796                ParseToken::Array,
797                ParseToken::Relative,
798                ParseToken::In,
799                ParseToken::Key(StrRange::new(11, "isbn".len())),
800                ParseToken::ArrayEof
801            ])
802        );
803
804        //
805        // Array도 컨텍스트 In으로 간주 할거라서 중첩되면 하나만
806        //
807        assert_eq!(
808            run("$.[*]"),
809            Ok(vec![
810                ParseToken::Absolute,
811                ParseToken::Array,
812                ParseToken::All,
813                ParseToken::ArrayEof
814            ])
815        );
816
817        assert_eq!(
818            run("$.a[*]"),
819            Ok(vec![
820                ParseToken::Absolute,
821                ParseToken::In,
822                ParseToken::Key(StrRange::new(2, "a".len())),
823                ParseToken::Array,
824                ParseToken::All,
825                ParseToken::ArrayEof
826            ])
827        );
828
829        assert_eq!(
830            run("$.a[*].가"),
831            Ok(vec![
832                ParseToken::Absolute,
833                ParseToken::In,
834                ParseToken::Key(StrRange::new(2, "a".len())),
835                ParseToken::Array,
836                ParseToken::All,
837                ParseToken::ArrayEof,
838                ParseToken::In,
839                ParseToken::Key(StrRange::new(7, '가'.len_utf8()))
840            ])
841        );
842
843        assert_eq!(
844            run("$.a[0][1]"),
845            Ok(vec![
846                ParseToken::Absolute,
847                ParseToken::In,
848                ParseToken::Key(StrRange::new(2, "a".len())),
849                ParseToken::Array,
850                ParseToken::Number(0_f64),
851                ParseToken::ArrayEof,
852                ParseToken::Array,
853                ParseToken::Number(1_f64),
854                ParseToken::ArrayEof
855            ])
856        );
857
858        assert_eq!(
859            run("$.a[1,2]"),
860            Ok(vec![
861                ParseToken::Absolute,
862                ParseToken::In,
863                ParseToken::Key(StrRange::new(2, "a".len())),
864                ParseToken::Array,
865                ParseToken::Union(vec![1, 2]),
866                ParseToken::ArrayEof
867            ])
868        );
869
870        assert_eq!(
871            run("$.a[10:]"),
872            Ok(vec![
873                ParseToken::Absolute,
874                ParseToken::In,
875                ParseToken::Key(StrRange::new(2, "a".len())),
876                ParseToken::Array,
877                ParseToken::Range(Some(10), None, None),
878                ParseToken::ArrayEof
879            ])
880        );
881
882        assert_eq!(
883            run("$.a[:11]"),
884            Ok(vec![
885                ParseToken::Absolute,
886                ParseToken::In,
887                ParseToken::Key(StrRange::new(2, "a".len())),
888                ParseToken::Array,
889                ParseToken::Range(None, Some(11), None),
890                ParseToken::ArrayEof
891            ])
892        );
893
894        assert_eq!(
895            run("$.a[-12:13]"),
896            Ok(vec![
897                ParseToken::Absolute,
898                ParseToken::In,
899                ParseToken::Key(StrRange::new(2, "a".len())),
900                ParseToken::Array,
901                ParseToken::Range(Some(-12), Some(13), None),
902                ParseToken::ArrayEof
903            ])
904        );
905
906        assert_eq!(
907            run(r#"$[0:3:2]"#),
908            Ok(vec![
909                ParseToken::Absolute,
910                ParseToken::Array,
911                ParseToken::Range(Some(0), Some(3), Some(2)),
912                ParseToken::ArrayEof
913            ])
914        );
915
916        assert_eq!(
917            run(r#"$[:3:2]"#),
918            Ok(vec![
919                ParseToken::Absolute,
920                ParseToken::Array,
921                ParseToken::Range(None, Some(3), Some(2)),
922                ParseToken::ArrayEof
923            ])
924        );
925
926        assert_eq!(
927            run(r#"$[:]"#),
928            Ok(vec![
929                ParseToken::Absolute,
930                ParseToken::Array,
931                ParseToken::Range(None, None, None),
932                ParseToken::ArrayEof
933            ])
934        );
935
936        assert_eq!(
937            run(r#"$[::]"#),
938            Ok(vec![
939                ParseToken::Absolute,
940                ParseToken::Array,
941                ParseToken::Range(None, None, None),
942                ParseToken::ArrayEof
943            ])
944        );
945
946        assert_eq!(
947            run(r#"$[::2]"#),
948            Ok(vec![
949                ParseToken::Absolute,
950                ParseToken::Array,
951                ParseToken::Range(None, None, Some(2)),
952                ParseToken::ArrayEof
953            ])
954        );
955
956        assert_eq!(
957            run(r#"$["a", 'b']"#),
958            Ok(vec![
959                ParseToken::Absolute,
960                ParseToken::Array,
961                ParseToken::Keys(vec![
962                    StrRange::new(2, "\"a\"".len()),
963                    StrRange::new(7, "'b'".len())
964                ]),
965                ParseToken::ArrayEof
966            ])
967        );
968
969        assert_eq!(
970            run("$.a[?(1>2)]"),
971            Ok(vec![
972                ParseToken::Absolute,
973                ParseToken::In,
974                ParseToken::Key(StrRange::new(2, "a".len())),
975                ParseToken::Array,
976                ParseToken::Number(1_f64),
977                ParseToken::Number(2_f64),
978                ParseToken::Filter(FilterToken::Greater),
979                ParseToken::ArrayEof
980            ])
981        );
982
983        assert_eq!(
984            run("$.a[?($.b>3)]"),
985            Ok(vec![
986                ParseToken::Absolute,
987                ParseToken::In,
988                ParseToken::Key(StrRange::new(2, "a".len())),
989                ParseToken::Array,
990                ParseToken::Absolute,
991                ParseToken::In,
992                ParseToken::Key(StrRange::new(8, "b".len())),
993                ParseToken::Number(3_f64),
994                ParseToken::Filter(FilterToken::Greater),
995                ParseToken::ArrayEof
996            ])
997        );
998
999        assert_eq!(
1000            run("$[?($.c>@.d && 1==2)]"),
1001            Ok(vec![
1002                ParseToken::Absolute,
1003                ParseToken::Array,
1004                ParseToken::Absolute,
1005                ParseToken::In,
1006                ParseToken::Key(StrRange::new(6, "c".len())),
1007                ParseToken::Relative,
1008                ParseToken::In,
1009                ParseToken::Key(StrRange::new(10, "c".len())),
1010                ParseToken::Filter(FilterToken::Greater),
1011                ParseToken::Number(1_f64),
1012                ParseToken::Number(2_f64),
1013                ParseToken::Filter(FilterToken::Equal),
1014                ParseToken::Filter(FilterToken::And),
1015                ParseToken::ArrayEof
1016            ])
1017        );
1018
1019        assert_eq!(
1020            run("$[?($.c>@.d&&(1==2||3>=4))]"),
1021            Ok(vec![
1022                ParseToken::Absolute,
1023                ParseToken::Array,
1024                ParseToken::Absolute,
1025                ParseToken::In,
1026                ParseToken::Key(StrRange::new(6, "c".len())),
1027                ParseToken::Relative,
1028                ParseToken::In,
1029                ParseToken::Key(StrRange::new(10, "d".len())),
1030                ParseToken::Filter(FilterToken::Greater),
1031                ParseToken::Number(1_f64),
1032                ParseToken::Number(2_f64),
1033                ParseToken::Filter(FilterToken::Equal),
1034                ParseToken::Number(3_f64),
1035                ParseToken::Number(4_f64),
1036                ParseToken::Filter(FilterToken::GreaterOrEqual),
1037                ParseToken::Filter(FilterToken::Or),
1038                ParseToken::Filter(FilterToken::And),
1039                ParseToken::ArrayEof
1040            ])
1041        );
1042
1043        assert_eq!(
1044            run("$[?(@.a<@.b)]"),
1045            Ok(vec![
1046                ParseToken::Absolute,
1047                ParseToken::Array,
1048                ParseToken::Relative,
1049                ParseToken::In,
1050                ParseToken::Key(StrRange::new(6, "a".len())),
1051                ParseToken::Relative,
1052                ParseToken::In,
1053                ParseToken::Key(StrRange::new(10, "b".len())),
1054                ParseToken::Filter(FilterToken::Little),
1055                ParseToken::ArrayEof
1056            ])
1057        );
1058
1059        assert_eq!(
1060            run("$[*][*][*]"),
1061            Ok(vec![
1062                ParseToken::Absolute,
1063                ParseToken::Array,
1064                ParseToken::All,
1065                ParseToken::ArrayEof,
1066                ParseToken::Array,
1067                ParseToken::All,
1068                ParseToken::ArrayEof,
1069                ParseToken::Array,
1070                ParseToken::All,
1071                ParseToken::ArrayEof
1072            ])
1073        );
1074
1075        assert_eq!(
1076            run("$['a']['bb']"),
1077            Ok(vec![
1078                ParseToken::Absolute,
1079                ParseToken::Array,
1080                ParseToken::Key(StrRange::new(2, "'a'".len())),
1081                ParseToken::ArrayEof,
1082                ParseToken::Array,
1083                ParseToken::Key(StrRange::new(7, "'bb'".len())),
1084                ParseToken::ArrayEof
1085            ])
1086        );
1087
1088        assert_eq!(
1089            run("$.a[?(@.e==true)]"),
1090            Ok(vec![
1091                ParseToken::Absolute,
1092                ParseToken::In,
1093                ParseToken::Key(StrRange::new(2, "a".len())),
1094                ParseToken::Array,
1095                ParseToken::Relative,
1096                ParseToken::In,
1097                ParseToken::Key(StrRange::new(8, "e".len())),
1098                ParseToken::Bool(true),
1099                ParseToken::Filter(FilterToken::Equal),
1100                ParseToken::ArrayEof
1101            ])
1102        );
1103
1104        assert_eq!(
1105            run(r#"$[?(@ > 1)]"#),
1106            Ok(vec![
1107                ParseToken::Absolute,
1108                ParseToken::Array,
1109                ParseToken::Relative,
1110                ParseToken::Number(1_f64),
1111                ParseToken::Filter(FilterToken::Greater),
1112                ParseToken::ArrayEof
1113            ])
1114        );
1115
1116        assert_eq!(
1117            run("$[:]"),
1118            Ok(vec![
1119                ParseToken::Absolute,
1120                ParseToken::Array,
1121                ParseToken::Range(None, None, None),
1122                ParseToken::ArrayEof
1123            ])
1124        );
1125
1126        assert_eq!(
1127            run(r#"$['single\'quote']"#),
1128            Ok(vec![
1129                ParseToken::Absolute,
1130                ParseToken::Array,
1131                ParseToken::Key(StrRange::new(2, r#"'single\'quote'"#.len())),
1132                ParseToken::ArrayEof
1133            ])
1134        );
1135
1136        assert_eq!(
1137            run(r#"$["single\"quote"]"#),
1138            Ok(vec![
1139                ParseToken::Absolute,
1140                ParseToken::Array,
1141                ParseToken::Key(StrRange::new(2, r#""single\"quote""#.len())),
1142                ParseToken::ArrayEof
1143            ])
1144        );
1145    }
1146
1147    #[test]
1148    fn parse_array_float() {
1149        setup();
1150
1151        assert_eq!(
1152            run("$[?(1.1<2.1)]"),
1153            Ok(vec![
1154                ParseToken::Absolute,
1155                ParseToken::Array,
1156                ParseToken::Number(1.1),
1157                ParseToken::Number(2.1),
1158                ParseToken::Filter(FilterToken::Little),
1159                ParseToken::ArrayEof
1160            ])
1161        );
1162
1163        if run("$[1.1]").is_ok() {
1164            panic!();
1165        }
1166
1167        if run("$[?(1.1<.2)]").is_ok() {
1168            panic!();
1169        }
1170
1171        if run("$[?(1.1<2.)]").is_ok() {
1172            panic!();
1173        }
1174
1175        if run("$[?(1.1<2.a)]").is_ok() {
1176            panic!();
1177        }
1178    }
1179}
jsonpath_lib/paths/path_parser.rs

jsonpath_lib/paths/
path_parser.rs
