jsonpath_lib/parser/
mod.rs

1mod path_reader;
2mod tokenizer;
3
4use std::str::FromStr;
5
6use self::tokenizer::*;
7
8const DUMMY: usize = 0;
9
10type ParseResult<T> = Result<T, String>;
11
12mod utils {
13    use std::str::FromStr;
14
15    pub fn string_to_num<F, S: FromStr>(string: &str, msg_handler: F) -> Result<S, String>
16    where
17        F: Fn() -> String,
18    {
19        match string.parse() {
20            Ok(n) => Ok(n),
21            _ => Err(msg_handler()),
22        }
23    }
24}
25
26#[derive(Debug, PartialEq, Clone)]
27pub enum ParseToken {
28    // '$'
29    Absolute,
30    // '@'
31    Relative,
32    // '.'
33    In,
34    // '..'
35    Leaves,
36    // '*'
37    All,
38
39    Key(String),
40    Keys(Vec<String>),
41    // []
42    Array,
43    // 메타토큰
44    ArrayEof,
45    // ?( filter )
46    Filter(FilterToken),
47    // 1 : 2
48    Range(Option<isize>, Option<isize>, Option<usize>),
49    // 1, 2, 3
50    Union(Vec<isize>),
51
52    Number(f64),
53
54    Bool(bool),
55
56    Eof,
57}
58
59#[derive(Debug, PartialEq, Clone)]
60pub enum FilterToken {
61    Equal,
62    NotEqual,
63    Little,
64    LittleOrEqual,
65    Greater,
66    GreaterOrEqual,
67    And,
68    Or,
69}
70
71#[derive(Debug, Clone)]
72pub struct Node {
73    left: Option<Box<Node>>,
74    right: Option<Box<Node>>,
75    token: ParseToken,
76}
77
78pub struct Parser;
79
80impl Parser {
81    pub fn compile(input: &str) -> ParseResult<Node> {
82        let mut tokenizer = TokenReader::new(input);
83        Ok(Self::json_path(&mut tokenizer)?)
84    }
85
86    fn json_path(tokenizer: &mut TokenReader) -> ParseResult<Node> {
87        debug!("#json_path");
88        match tokenizer.next_token() {
89            Ok(Token::Absolute(_)) => {
90                let node = Self::node(ParseToken::Absolute);
91                Self::paths(node, tokenizer)
92            }
93            _ => Err(tokenizer.err_msg()),
94        }
95    }
96
97    fn paths(prev: Node, tokenizer: &mut TokenReader) -> ParseResult<Node> {
98        debug!("#paths");
99        match tokenizer.peek_token() {
100            Ok(Token::Dot(_)) => {
101                Self::eat_token(tokenizer);
102                Self::paths_dot(prev, tokenizer)
103            }
104            Ok(Token::OpenArray(_)) => {
105                Self::eat_token(tokenizer);
106                Self::eat_whitespace(tokenizer);
107                let node = Self::array(prev, tokenizer)?;
108                Self::paths(node, tokenizer)
109            }
110            _ => Ok(prev),
111        }
112    }
113
114    fn paths_dot(prev: Node, tokenizer: &mut TokenReader) -> ParseResult<Node> {
115        debug!("#paths_dot");
116        let node = Self::path(prev, tokenizer)?;
117        Self::paths(node, tokenizer)
118    }
119
120    fn path(prev: Node, tokenizer: &mut TokenReader) -> ParseResult<Node> {
121        debug!("#path");
122        match tokenizer.peek_token() {
123            Ok(Token::Dot(_)) => Self::path_leaves(prev, tokenizer),
124            Ok(Token::Asterisk(_)) => Self::path_in_all(prev, tokenizer),
125            Ok(Token::Key(_, _)) => Self::path_in_key(prev, tokenizer),
126            Ok(Token::OpenArray(_)) => {
127                Self::eat_token(tokenizer);
128                Self::array(prev, tokenizer)
129            }
130            _ => Err(tokenizer.err_msg()),
131        }
132    }
133
134    fn path_leaves(prev: Node, tokenizer: &mut TokenReader) -> ParseResult<Node> {
135        debug!("#path_leaves");
136        Self::eat_token(tokenizer);
137        match tokenizer.peek_token() {
138            Ok(Token::Asterisk(_)) => Self::path_leaves_all(prev, tokenizer),
139            Ok(Token::OpenArray(_)) => {
140                let mut leaves_node = Self::node(ParseToken::Leaves);
141                leaves_node.left = Some(Box::new(prev));
142                Ok(Self::paths(leaves_node, tokenizer)?)
143            }
144            _ => Self::path_leaves_key(prev, tokenizer),
145        }
146    }
147
148    fn path_leaves_key(prev: Node, tokenizer: &mut TokenReader) -> ParseResult<Node> {
149        debug!("#path_leaves_key");
150        Ok(Node {
151            token: ParseToken::Leaves,
152            left: Some(Box::new(prev)),
153            right: Some(Box::new(Self::key(tokenizer)?)),
154        })
155    }
156
157    fn path_leaves_all(prev: Node, tokenizer: &mut TokenReader) -> ParseResult<Node> {
158        debug!("#path_leaves_all");
159        Self::eat_token(tokenizer);
160        Ok(Node {
161            token: ParseToken::Leaves,
162            left: Some(Box::new(prev)),
163            right: Some(Box::new(Self::node(ParseToken::All))),
164        })
165    }
166
167    fn path_in_all(prev: Node, tokenizer: &mut TokenReader) -> ParseResult<Node> {
168        debug!("#path_in_all");
169        Self::eat_token(tokenizer);
170        Ok(Node {
171            token: ParseToken::In,
172            left: Some(Box::new(prev)),
173            right: Some(Box::new(Self::node(ParseToken::All))),
174        })
175    }
176
177    fn path_in_key(prev: Node, tokenizer: &mut TokenReader) -> ParseResult<Node> {
178        debug!("#path_in_key");
179        Ok(Node {
180            token: ParseToken::In,
181            left: Some(Box::new(prev)),
182            right: Some(Box::new(Self::key(tokenizer)?)),
183        })
184    }
185
186    fn key(tokenizer: &mut TokenReader) -> ParseResult<Node> {
187        debug!("#key");
188        match tokenizer.next_token() {
189            Ok(Token::Key(_, v)) => Ok(Self::node(ParseToken::Key(v))),
190            _ => Err(tokenizer.err_msg()),
191        }
192    }
193
194    fn boolean(tokenizer: &mut TokenReader) -> ParseResult<Node> {
195        debug!("#boolean");
196
197        fn validation_bool_value(v: &str) -> bool {
198            let b = v.as_bytes();
199            !b.is_empty() && (b[0] == b't' || b[0] == b'T' || b[0] == b'f' || b[0] == b'F')
200        }
201
202        match tokenizer.next_token() {
203            Ok(Token::Key(_, ref v)) if validation_bool_value(v) => {
204                Ok(Self::node(ParseToken::Bool(v.eq_ignore_ascii_case("true"))))
205            }
206            _ => Err(tokenizer.err_msg()),
207        }
208    }
209
210    fn array_keys(tokenizer: &mut TokenReader, first_key: String) -> ParseResult<Node> {
211        let mut keys = vec![first_key];
212
213        while let Ok(Token::Comma(_)) = tokenizer.peek_token() {
214            Self::eat_token(tokenizer);
215            Self::eat_whitespace(tokenizer);
216
217            match tokenizer.next_token() {
218                Ok(Token::SingleQuoted(_, val)) | Ok(Token::DoubleQuoted(_, val)) => {
219                    keys.push(val);
220                }
221                _ => return Err(tokenizer.err_msg()),
222            }
223
224            Self::eat_whitespace(tokenizer);
225        }
226
227        Ok(Self::node(ParseToken::Keys(keys)))
228    }
229
230    fn array_quote_value(tokenizer: &mut TokenReader) -> ParseResult<Node> {
231        debug!("#array_quote_value");
232        match tokenizer.next_token() {
233            Ok(Token::SingleQuoted(_, val)) | Ok(Token::DoubleQuoted(_, val)) => {
234                if let Ok(Token::Comma(_)) = tokenizer.peek_token() {
235                    Self::array_keys(tokenizer, val)
236                } else {
237                    Ok(Self::node(ParseToken::Key(val)))
238                }
239            }
240            _ => Err(tokenizer.err_msg()),
241        }
242    }
243
244    fn array_start(prev: Node, tokenizer: &mut TokenReader) -> ParseResult<Node> {
245        debug!("#array_start");
246        match tokenizer.peek_token() {
247            Ok(Token::Question(_)) => {
248                Self::eat_token(tokenizer);
249                Ok(Node {
250                    token: ParseToken::Array,
251                    left: Some(Box::new(prev)),
252                    right: Some(Box::new(Self::filter(tokenizer)?)),
253                })
254            }
255            Ok(Token::Asterisk(_)) => {
256                Self::eat_token(tokenizer);
257                Ok(Node {
258                    token: ParseToken::Array,
259                    left: Some(Box::new(prev)),
260                    right: Some(Box::new(Self::node(ParseToken::All))),
261                })
262            }
263            _ => Ok(Node {
264                token: ParseToken::Array,
265                left: Some(Box::new(prev)),
266                right: Some(Box::new(Self::array_value(tokenizer)?)),
267            }),
268        }
269    }
270
271    fn array(prev: Node, tokenizer: &mut TokenReader) -> ParseResult<Node> {
272        debug!("#array");
273        let ret = Self::array_start(prev, tokenizer)?;
274        Self::eat_whitespace(tokenizer);
275        Self::close_token(ret, Token::CloseArray(DUMMY), tokenizer)
276    }
277
278    fn array_value_key(tokenizer: &mut TokenReader) -> ParseResult<Node> {
279        debug!("#array_value_key");
280        match tokenizer.next_token() {
281            Ok(Token::Key(pos, ref val)) => {
282                let digit = utils::string_to_num(val, || tokenizer.err_msg_with_pos(pos))?;
283                Self::eat_whitespace(tokenizer);
284
285                match tokenizer.peek_token() {
286                    Ok(Token::Comma(_)) => Self::union(digit, tokenizer),
287                    Ok(Token::Split(_)) => Self::range_from(digit, tokenizer),
288                    _ => Ok(Self::node(ParseToken::Number(digit as f64))),
289                }
290            }
291            _ => Err(tokenizer.err_msg()),
292        }
293    }
294
295    fn array_value(tokenizer: &mut TokenReader) -> ParseResult<Node> {
296        debug!("#array_value");
297        match tokenizer.peek_token() {
298            Ok(Token::Key(_, _)) => Self::array_value_key(tokenizer),
299            Ok(Token::Split(_)) => {
300                Self::eat_token(tokenizer);
301                Self::range_to(tokenizer)
302            }
303            Ok(Token::DoubleQuoted(_, _)) | Ok(Token::SingleQuoted(_, _)) => {
304                Self::array_quote_value(tokenizer)
305            }
306            Err(TokenError::Eof) => Ok(Self::node(ParseToken::Eof)),
307            _ => {
308                Self::eat_token(tokenizer);
309                Err(tokenizer.err_msg())
310            }
311        }
312    }
313
314    fn union(num: isize, tokenizer: &mut TokenReader) -> ParseResult<Node> {
315        debug!("#union");
316        let mut values = vec![num];
317        while match tokenizer.peek_token() {
318            Ok(Token::Comma(_)) => true,
319            _ => false,
320        } {
321            Self::eat_token(tokenizer);
322            Self::eat_whitespace(tokenizer);
323            match tokenizer.next_token() {
324                Ok(Token::Key(pos, ref val)) => {
325                    let digit = utils::string_to_num(val, || tokenizer.err_msg_with_pos(pos))?;
326                    values.push(digit);
327                }
328                _ => {
329                    return Err(tokenizer.err_msg());
330                }
331            }
332        }
333        Ok(Self::node(ParseToken::Union(values)))
334    }
335
336    fn range_value<S: FromStr>(tokenizer: &mut TokenReader) -> Result<Option<S>, String> {
337        Self::eat_whitespace(tokenizer);
338
339        match tokenizer.peek_token() {
340            Ok(Token::Split(_)) => {
341                Self::eat_token(tokenizer);
342                Self::eat_whitespace(tokenizer);
343            }
344            _ => {
345                return Ok(None);
346            }
347        }
348
349        match tokenizer.peek_token() {
350            Ok(Token::Key(_, _)) => {}
351            _ => {
352                return Ok(None);
353            }
354        }
355
356        match tokenizer.next_token() {
357            Ok(Token::Key(pos, str_step)) => {
358                match utils::string_to_num(&str_step, || tokenizer.err_msg_with_pos(pos)) {
359                    Ok(step) => Ok(Some(step)),
360                    Err(e) => Err(e),
361                }
362            }
363            _ => {
364                unreachable!();
365            }
366        }
367    }
368
369    fn range_from(from: isize, tokenizer: &mut TokenReader) -> ParseResult<Node> {
370        debug!("#range_from");
371        Self::eat_token(tokenizer);
372        Self::eat_whitespace(tokenizer);
373
374        match tokenizer.peek_token() {
375            Ok(Token::Key(_, _)) => Self::range(from, tokenizer),
376            Ok(Token::Split(_)) => match Self::range_value(tokenizer)? {
377                Some(step) => Ok(Self::node(ParseToken::Range(Some(from), None, Some(step)))),
378                _ => Ok(Self::node(ParseToken::Range(Some(from), None, None))),
379            },
380            _ => Ok(Self::node(ParseToken::Range(Some(from), None, None))),
381        }
382    }
383
384    fn range_to(tokenizer: &mut TokenReader) -> ParseResult<Node> {
385        debug!("#range_to");
386
387        if let Some(step) = Self::range_value(tokenizer)? {
388            return Ok(Self::node(ParseToken::Range(None, None, Some(step))));
389        }
390
391        if let Ok(Token::CloseArray(_)) = tokenizer.peek_token() {
392            return Ok(Self::node(ParseToken::Range(None, None, None)));
393        }
394
395        match tokenizer.next_token() {
396            Ok(Token::Key(pos, ref to_str)) => {
397                let to = utils::string_to_num(to_str, || tokenizer.err_msg_with_pos(pos))?;
398                let step = Self::range_value(tokenizer)?;
399                Ok(Self::node(ParseToken::Range(None, Some(to), step)))
400            }
401            _ => Err(tokenizer.err_msg()),
402        }
403    }
404
405    fn range(from: isize, tokenizer: &mut TokenReader) -> ParseResult<Node> {
406        debug!("#range");
407        match tokenizer.next_token() {
408            Ok(Token::Key(pos, ref str_to)) => {
409                let to = utils::string_to_num(str_to, || tokenizer.err_msg_with_pos(pos))?;
410                let step = Self::range_value(tokenizer)?;
411                Ok(Self::node(ParseToken::Range(Some(from), Some(to), step)))
412            }
413            _ => Err(tokenizer.err_msg()),
414        }
415    }
416
417    fn filter(tokenizer: &mut TokenReader) -> ParseResult<Node> {
418        debug!("#filter");
419        match tokenizer.next_token() {
420            Ok(Token::OpenParenthesis(_)) => {
421                let ret = Self::exprs(tokenizer)?;
422                Self::eat_whitespace(tokenizer);
423                Self::close_token(ret, Token::CloseParenthesis(DUMMY), tokenizer)
424            }
425            _ => Err(tokenizer.err_msg()),
426        }
427    }
428
429    fn exprs(tokenizer: &mut TokenReader) -> ParseResult<Node> {
430        Self::eat_whitespace(tokenizer);
431        debug!("#exprs");
432        let node = match tokenizer.peek_token() {
433            Ok(Token::OpenParenthesis(_)) => {
434                Self::eat_token(tokenizer);
435                trace!("\t-exprs - open_parenthesis");
436                let ret = Self::exprs(tokenizer)?;
437                Self::eat_whitespace(tokenizer);
438                Self::close_token(ret, Token::CloseParenthesis(DUMMY), tokenizer)?
439            }
440            _ => {
441                trace!("\t-exprs - else");
442                Self::expr(tokenizer)?
443            }
444        };
445        Self::eat_whitespace(tokenizer);
446        Self::condition_expr(node, tokenizer)
447    }
448
449    fn condition_expr(prev: Node, tokenizer: &mut TokenReader) -> ParseResult<Node> {
450        debug!("#condition_expr");
451        match tokenizer.peek_token() {
452            Ok(Token::And(_)) => {
453                Self::eat_token(tokenizer);
454                Ok(Node {
455                    token: ParseToken::Filter(FilterToken::And),
456                    left: Some(Box::new(prev)),
457                    right: Some(Box::new(Self::exprs(tokenizer)?)),
458                })
459            }
460            Ok(Token::Or(_)) => {
461                Self::eat_token(tokenizer);
462                Ok(Node {
463                    token: ParseToken::Filter(FilterToken::Or),
464                    left: Some(Box::new(prev)),
465                    right: Some(Box::new(Self::exprs(tokenizer)?)),
466                })
467            }
468            _ => Ok(prev),
469        }
470    }
471
472    fn expr(tokenizer: &mut TokenReader) -> ParseResult<Node> {
473        debug!("#expr");
474
475        let has_prop_candidate = match tokenizer.peek_token() {
476            Ok(Token::At(_)) => true,
477            _ => false,
478        };
479
480        let node = Self::term(tokenizer)?;
481        Self::eat_whitespace(tokenizer);
482
483        if match tokenizer.peek_token() {
484            Ok(Token::Equal(_))
485            | Ok(Token::NotEqual(_))
486            | Ok(Token::Little(_))
487            | Ok(Token::LittleOrEqual(_))
488            | Ok(Token::Greater(_))
489            | Ok(Token::GreaterOrEqual(_)) => true,
490            _ => false,
491        } {
492            Self::op(node, tokenizer)
493        } else if has_prop_candidate {
494            Ok(node)
495        } else {
496            Err(tokenizer.err_msg())
497        }
498    }
499
500    fn term_num(tokenizer: &mut TokenReader) -> ParseResult<Node> {
501        debug!("#term_num");
502        match tokenizer.next_token() {
503            Ok(Token::Key(pos, val)) => match tokenizer.peek_token() {
504                Ok(Token::Dot(_)) => Self::term_num_float(val.as_str(), tokenizer),
505                _ => {
506                    let number = utils::string_to_num(&val, || tokenizer.err_msg_with_pos(pos))?;
507                    Ok(Self::node(ParseToken::Number(number)))
508                }
509            },
510            _ => Err(tokenizer.err_msg()),
511        }
512    }
513
514    fn term_num_float(num: &str, tokenizer: &mut TokenReader) -> ParseResult<Node> {
515        debug!("#term_num_float");
516        Self::eat_token(tokenizer);
517        match tokenizer.next_token() {
518            Ok(Token::Key(pos, frac)) => {
519                let mut f = String::new();
520                f.push_str(&num);
521                f.push('.');
522                f.push_str(frac.as_str());
523                let number = utils::string_to_num(&f, || tokenizer.err_msg_with_pos(pos))?;
524                Ok(Self::node(ParseToken::Number(number)))
525            }
526            _ => Err(tokenizer.err_msg()),
527        }
528    }
529
530    fn term(tokenizer: &mut TokenReader) -> ParseResult<Node> {
531        debug!("#term");
532
533        match tokenizer.peek_token() {
534            Ok(Token::At(_)) => {
535                Self::eat_token(tokenizer);
536                let node = Self::node(ParseToken::Relative);
537
538                match tokenizer.peek_token() {
539                    Ok(Token::Whitespace(_, _)) => {
540                        Self::eat_whitespace(tokenizer);
541                        Ok(node)
542                    }
543                    _ => Self::paths(node, tokenizer),
544                }
545            }
546            Ok(Token::Absolute(_)) => Self::json_path(tokenizer),
547            Ok(Token::DoubleQuoted(_, _)) | Ok(Token::SingleQuoted(_, _)) => {
548                Self::array_quote_value(tokenizer)
549            }
550            Ok(Token::Key(_, key)) => match key.as_bytes()[0] {
551                b'-' | b'0'..=b'9' => Self::term_num(tokenizer),
552                _ => Self::boolean(tokenizer),
553            },
554            _ => Err(tokenizer.err_msg()),
555        }
556    }
557
558    fn op(prev: Node, tokenizer: &mut TokenReader) -> ParseResult<Node> {
559        debug!("#op");
560        let token = match tokenizer.next_token() {
561            Ok(Token::Equal(_)) => ParseToken::Filter(FilterToken::Equal),
562            Ok(Token::NotEqual(_)) => ParseToken::Filter(FilterToken::NotEqual),
563            Ok(Token::Little(_)) => ParseToken::Filter(FilterToken::Little),
564            Ok(Token::LittleOrEqual(_)) => ParseToken::Filter(FilterToken::LittleOrEqual),
565            Ok(Token::Greater(_)) => ParseToken::Filter(FilterToken::Greater),
566            Ok(Token::GreaterOrEqual(_)) => ParseToken::Filter(FilterToken::GreaterOrEqual),
567            _ => {
568                return Err(tokenizer.err_msg());
569            }
570        };
571
572        Self::eat_whitespace(tokenizer);
573
574        Ok(Node {
575            token,
576            left: Some(Box::new(prev)),
577            right: Some(Box::new(Self::term(tokenizer)?)),
578        })
579    }
580
581    fn eat_whitespace(tokenizer: &mut TokenReader) {
582        while let Ok(Token::Whitespace(_, _)) = tokenizer.peek_token() {
583            let _ = tokenizer.next_token();
584        }
585    }
586
587    fn eat_token(tokenizer: &mut TokenReader) {
588        let _ = tokenizer.next_token();
589    }
590
591    fn node(token: ParseToken) -> Node {
592        Node {
593            left: None,
594            right: None,
595            token,
596        }
597    }
598
599    fn close_token(ret: Node, token: Token, tokenizer: &mut TokenReader) -> ParseResult<Node> {
600        debug!("#close_token");
601        match tokenizer.next_token() {
602            Ok(ref t) if t.is_match_token_type(token) => Ok(ret),
603            _ => Err(tokenizer.err_msg()),
604        }
605    }
606}
607
608pub trait NodeVisitor {
609    fn visit(&mut self, node: &Node) {
610        match &node.token {
611            ParseToken::Absolute
612            | ParseToken::Relative
613            | ParseToken::All
614            | ParseToken::Key(_)
615            | ParseToken::Keys(_)
616            | ParseToken::Range(_, _, _)
617            | ParseToken::Union(_)
618            | ParseToken::Number(_)
619            | ParseToken::Bool(_) => {
620                self.visit_token(&node.token);
621            }
622            ParseToken::In | ParseToken::Leaves => {
623                if let Some(n) = &node.left {
624                    self.visit(&*n);
625                }
626
627                self.visit_token(&node.token);
628
629                if let Some(n) = &node.right {
630                    self.visit(&*n);
631                }
632            }
633            ParseToken::Array => {
634                if let Some(n) = &node.left {
635                    self.visit(&*n);
636                }
637
638                self.visit_token(&node.token);
639
640                if let Some(n) = &node.right {
641                    self.visit(&*n);
642                }
643
644                self.visit_token(&ParseToken::ArrayEof);
645            }
646            ParseToken::Filter(FilterToken::And) | ParseToken::Filter(FilterToken::Or) => {
647                if let Some(n) = &node.left {
648                    self.visit(&*n);
649                }
650
651                if let Some(n) = &node.right {
652                    self.visit(&*n);
653                }
654
655                self.visit_token(&node.token);
656            }
657            ParseToken::Filter(_) => {
658                if let Some(n) = &node.left {
659                    self.visit(&*n);
660                }
661
662                self.end_term();
663
664                if let Some(n) = &node.right {
665                    self.visit(&*n);
666                }
667
668                self.end_term();
669
670                self.visit_token(&node.token);
671            }
672            _ => {}
673        }
674    }
675
676    fn visit_token(&mut self, token: &ParseToken);
677    fn end_term(&mut self) {}
678}
679
680#[cfg(test)]
681mod parser_tests {
682    use parser::{FilterToken, NodeVisitor, ParseToken, Parser};
683
684    struct NodeVisitorTestImpl<'a> {
685        input: &'a str,
686        stack: Vec<ParseToken>,
687    }
688
689    impl<'a> NodeVisitorTestImpl<'a> {
690        fn new(input: &'a str) -> Self {
691            NodeVisitorTestImpl {
692                input,
693                stack: Vec::new(),
694            }
695        }
696
697        fn start(&mut self) -> Result<Vec<ParseToken>, String> {
698            let node = Parser::compile(self.input)?;
699            self.visit(&node);
700            Ok(self.stack.split_off(0))
701        }
702    }
703
704    impl<'a> NodeVisitor for NodeVisitorTestImpl<'a> {
705        fn visit_token(&mut self, token: &ParseToken) {
706            self.stack.push(token.clone());
707        }
708    }
709
710    fn setup() {
711        let _ = env_logger::try_init();
712    }
713
714    fn run(input: &str) -> Result<Vec<ParseToken>, String> {
715        let mut interpreter = NodeVisitorTestImpl::new(input);
716        interpreter.start()
717    }
718
719    #[test]
720    fn parse_error() {
721        setup();
722
723        fn invalid(path: &str) {
724            assert!(run(path).is_err());
725        }
726
727        invalid("$[]");
728        invalid("$[a]");
729        invalid("$[?($.a)]");
730        invalid("$[?(@.a > @.b]");
731        invalid("$[?(@.a < @.b&&(@.c < @.d)]");
732        invalid("@.");
733        invalid("$..[?(a <= @.a)]"); // invalid term value
734        invalid("$['a', b]");
735        invalid("$[0, >=]");
736        invalid("$[a:]");
737        invalid("$[:a]");
738        invalid("$[::a]");
739        invalid("$[:>]");
740        invalid("$[1:>]");
741        invalid("$[1,,]");
742        invalid("$[?]");
743        invalid("$[?(1 = 1)]");
744        invalid("$[?(1 = >)]");
745    }
746
747    #[test]
748    fn parse_path() {
749        setup();
750
751        assert_eq!(
752            run("$.aa"),
753            Ok(vec![
754                ParseToken::Absolute,
755                ParseToken::In,
756                ParseToken::Key("aa".to_owned())
757            ])
758        );
759
760        assert_eq!(
761            run("$.00.a"),
762            Ok(vec![
763                ParseToken::Absolute,
764                ParseToken::In,
765                ParseToken::Key("00".to_owned()),
766                ParseToken::In,
767                ParseToken::Key("a".to_owned())
768            ])
769        );
770
771        assert_eq!(
772            run("$.00.韓창.seok"),
773            Ok(vec![
774                ParseToken::Absolute,
775                ParseToken::In,
776                ParseToken::Key("00".to_owned()),
777                ParseToken::In,
778                ParseToken::Key("韓창".to_owned()),
779                ParseToken::In,
780                ParseToken::Key("seok".to_owned())
781            ])
782        );
783
784        assert_eq!(
785            run("$.*"),
786            Ok(vec![ParseToken::Absolute, ParseToken::In, ParseToken::All])
787        );
788
789        assert_eq!(
790            run("$..*"),
791            Ok(vec![
792                ParseToken::Absolute,
793                ParseToken::Leaves,
794                ParseToken::All
795            ])
796        );
797
798        assert_eq!(
799            run("$..[0]"),
800            Ok(vec![
801                ParseToken::Absolute,
802                ParseToken::Leaves,
803                ParseToken::Array,
804                ParseToken::Number(0.0),
805                ParseToken::ArrayEof
806            ])
807        );
808
809        assert_eq!(
810            run("$.$a"),
811            Ok(vec![
812                ParseToken::Absolute,
813                ParseToken::In,
814                ParseToken::Key("$a".to_owned())
815            ])
816        );
817
818        assert_eq!(
819            run("$.['$a']"),
820            Ok(vec![
821                ParseToken::Absolute,
822                ParseToken::Array,
823                ParseToken::Key("$a".to_owned()),
824                ParseToken::ArrayEof,
825            ])
826        );
827
828        if run("$.").is_ok() {
829            panic!();
830        }
831
832        if run("$..").is_ok() {
833            panic!();
834        }
835
836        if run("$. a").is_ok() {
837            panic!();
838        }
839    }
840
841    #[test]
842    fn parse_array_syntax() {
843        setup();
844
845        assert_eq!(
846            run("$.book[?(@.isbn)]"),
847            Ok(vec![
848                ParseToken::Absolute,
849                ParseToken::In,
850                ParseToken::Key("book".to_string()),
851                ParseToken::Array,
852                ParseToken::Relative,
853                ParseToken::In,
854                ParseToken::Key("isbn".to_string()),
855                ParseToken::ArrayEof
856            ])
857        );
858
859        //
860        // Array도 컨텍스트 In으로 간주 할거라서 중첩되면 하나만
861        //
862        assert_eq!(
863            run("$.[*]"),
864            Ok(vec![
865                ParseToken::Absolute,
866                ParseToken::Array,
867                ParseToken::All,
868                ParseToken::ArrayEof
869            ])
870        );
871
872        assert_eq!(
873            run("$.a[*]"),
874            Ok(vec![
875                ParseToken::Absolute,
876                ParseToken::In,
877                ParseToken::Key("a".to_owned()),
878                ParseToken::Array,
879                ParseToken::All,
880                ParseToken::ArrayEof
881            ])
882        );
883
884        assert_eq!(
885            run("$.a[*].가"),
886            Ok(vec![
887                ParseToken::Absolute,
888                ParseToken::In,
889                ParseToken::Key("a".to_owned()),
890                ParseToken::Array,
891                ParseToken::All,
892                ParseToken::ArrayEof,
893                ParseToken::In,
894                ParseToken::Key("가".to_owned())
895            ])
896        );
897
898        assert_eq!(
899            run("$.a[0][1]"),
900            Ok(vec![
901                ParseToken::Absolute,
902                ParseToken::In,
903                ParseToken::Key("a".to_owned()),
904                ParseToken::Array,
905                ParseToken::Number(0_f64),
906                ParseToken::ArrayEof,
907                ParseToken::Array,
908                ParseToken::Number(1_f64),
909                ParseToken::ArrayEof
910            ])
911        );
912
913        assert_eq!(
914            run("$.a[1,2]"),
915            Ok(vec![
916                ParseToken::Absolute,
917                ParseToken::In,
918                ParseToken::Key("a".to_owned()),
919                ParseToken::Array,
920                ParseToken::Union(vec![1, 2]),
921                ParseToken::ArrayEof
922            ])
923        );
924
925        assert_eq!(
926            run("$.a[10:]"),
927            Ok(vec![
928                ParseToken::Absolute,
929                ParseToken::In,
930                ParseToken::Key("a".to_owned()),
931                ParseToken::Array,
932                ParseToken::Range(Some(10), None, None),
933                ParseToken::ArrayEof
934            ])
935        );
936
937        assert_eq!(
938            run("$.a[:11]"),
939            Ok(vec![
940                ParseToken::Absolute,
941                ParseToken::In,
942                ParseToken::Key("a".to_owned()),
943                ParseToken::Array,
944                ParseToken::Range(None, Some(11), None),
945                ParseToken::ArrayEof
946            ])
947        );
948
949        assert_eq!(
950            run("$.a[-12:13]"),
951            Ok(vec![
952                ParseToken::Absolute,
953                ParseToken::In,
954                ParseToken::Key("a".to_owned()),
955                ParseToken::Array,
956                ParseToken::Range(Some(-12), Some(13), None),
957                ParseToken::ArrayEof
958            ])
959        );
960
961        assert_eq!(
962            run(r#"$[0:3:2]"#),
963            Ok(vec![
964                ParseToken::Absolute,
965                ParseToken::Array,
966                ParseToken::Range(Some(0), Some(3), Some(2)),
967                ParseToken::ArrayEof
968            ])
969        );
970
971        assert_eq!(
972            run(r#"$[:3:2]"#),
973            Ok(vec![
974                ParseToken::Absolute,
975                ParseToken::Array,
976                ParseToken::Range(None, Some(3), Some(2)),
977                ParseToken::ArrayEof
978            ])
979        );
980
981        assert_eq!(
982            run(r#"$[:]"#),
983            Ok(vec![
984                ParseToken::Absolute,
985                ParseToken::Array,
986                ParseToken::Range(None, None, None),
987                ParseToken::ArrayEof
988            ])
989        );
990
991        assert_eq!(
992            run(r#"$[::]"#),
993            Ok(vec![
994                ParseToken::Absolute,
995                ParseToken::Array,
996                ParseToken::Range(None, None, None),
997                ParseToken::ArrayEof
998            ])
999        );
1000
1001        assert_eq!(
1002            run(r#"$[::2]"#),
1003            Ok(vec![
1004                ParseToken::Absolute,
1005                ParseToken::Array,
1006                ParseToken::Range(None, None, Some(2)),
1007                ParseToken::ArrayEof
1008            ])
1009        );
1010
1011        assert_eq!(
1012            run(r#"$["a", 'b']"#),
1013            Ok(vec![
1014                ParseToken::Absolute,
1015                ParseToken::Array,
1016                ParseToken::Keys(vec!["a".to_string(), "b".to_string()]),
1017                ParseToken::ArrayEof
1018            ])
1019        );
1020
1021        assert_eq!(
1022            run("$.a[?(1>2)]"),
1023            Ok(vec![
1024                ParseToken::Absolute,
1025                ParseToken::In,
1026                ParseToken::Key("a".to_owned()),
1027                ParseToken::Array,
1028                ParseToken::Number(1_f64),
1029                ParseToken::Number(2_f64),
1030                ParseToken::Filter(FilterToken::Greater),
1031                ParseToken::ArrayEof
1032            ])
1033        );
1034
1035        assert_eq!(
1036            run("$.a[?($.b>3)]"),
1037            Ok(vec![
1038                ParseToken::Absolute,
1039                ParseToken::In,
1040                ParseToken::Key("a".to_owned()),
1041                ParseToken::Array,
1042                ParseToken::Absolute,
1043                ParseToken::In,
1044                ParseToken::Key("b".to_owned()),
1045                ParseToken::Number(3_f64),
1046                ParseToken::Filter(FilterToken::Greater),
1047                ParseToken::ArrayEof
1048            ])
1049        );
1050
1051        assert_eq!(
1052            run("$[?($.c>@.d && 1==2)]"),
1053            Ok(vec![
1054                ParseToken::Absolute,
1055                ParseToken::Array,
1056                ParseToken::Absolute,
1057                ParseToken::In,
1058                ParseToken::Key("c".to_owned()),
1059                ParseToken::Relative,
1060                ParseToken::In,
1061                ParseToken::Key("d".to_owned()),
1062                ParseToken::Filter(FilterToken::Greater),
1063                ParseToken::Number(1_f64),
1064                ParseToken::Number(2_f64),
1065                ParseToken::Filter(FilterToken::Equal),
1066                ParseToken::Filter(FilterToken::And),
1067                ParseToken::ArrayEof
1068            ])
1069        );
1070
1071        assert_eq!(
1072            run("$[?($.c>@.d&&(1==2||3>=4))]"),
1073            Ok(vec![
1074                ParseToken::Absolute,
1075                ParseToken::Array,
1076                ParseToken::Absolute,
1077                ParseToken::In,
1078                ParseToken::Key("c".to_owned()),
1079                ParseToken::Relative,
1080                ParseToken::In,
1081                ParseToken::Key("d".to_owned()),
1082                ParseToken::Filter(FilterToken::Greater),
1083                ParseToken::Number(1_f64),
1084                ParseToken::Number(2_f64),
1085                ParseToken::Filter(FilterToken::Equal),
1086                ParseToken::Number(3_f64),
1087                ParseToken::Number(4_f64),
1088                ParseToken::Filter(FilterToken::GreaterOrEqual),
1089                ParseToken::Filter(FilterToken::Or),
1090                ParseToken::Filter(FilterToken::And),
1091                ParseToken::ArrayEof
1092            ])
1093        );
1094
1095        assert_eq!(
1096            run("$[?(@.a<@.b)]"),
1097            Ok(vec![
1098                ParseToken::Absolute,
1099                ParseToken::Array,
1100                ParseToken::Relative,
1101                ParseToken::In,
1102                ParseToken::Key("a".to_owned()),
1103                ParseToken::Relative,
1104                ParseToken::In,
1105                ParseToken::Key("b".to_owned()),
1106                ParseToken::Filter(FilterToken::Little),
1107                ParseToken::ArrayEof
1108            ])
1109        );
1110
1111        assert_eq!(
1112            run("$[*][*][*]"),
1113            Ok(vec![
1114                ParseToken::Absolute,
1115                ParseToken::Array,
1116                ParseToken::All,
1117                ParseToken::ArrayEof,
1118                ParseToken::Array,
1119                ParseToken::All,
1120                ParseToken::ArrayEof,
1121                ParseToken::Array,
1122                ParseToken::All,
1123                ParseToken::ArrayEof
1124            ])
1125        );
1126
1127        assert_eq!(
1128            run("$['a']['bb']"),
1129            Ok(vec![
1130                ParseToken::Absolute,
1131                ParseToken::Array,
1132                ParseToken::Key("a".to_string()),
1133                ParseToken::ArrayEof,
1134                ParseToken::Array,
1135                ParseToken::Key("bb".to_string()),
1136                ParseToken::ArrayEof
1137            ])
1138        );
1139
1140        assert_eq!(
1141            run("$.a[?(@.e==true)]"),
1142            Ok(vec![
1143                ParseToken::Absolute,
1144                ParseToken::In,
1145                ParseToken::Key("a".to_string()),
1146                ParseToken::Array,
1147                ParseToken::Relative,
1148                ParseToken::In,
1149                ParseToken::Key("e".to_string()),
1150                ParseToken::Bool(true),
1151                ParseToken::Filter(FilterToken::Equal),
1152                ParseToken::ArrayEof
1153            ])
1154        );
1155
1156        assert_eq!(
1157            run(r#"$[?(@ > 1)]"#),
1158            Ok(vec![
1159                ParseToken::Absolute,
1160                ParseToken::Array,
1161                ParseToken::Relative,
1162                ParseToken::Number(1_f64),
1163                ParseToken::Filter(FilterToken::Greater),
1164                ParseToken::ArrayEof
1165            ])
1166        );
1167
1168        assert_eq!(
1169            run("$[:]"),
1170            Ok(vec![
1171                ParseToken::Absolute,
1172                ParseToken::Array,
1173                ParseToken::Range(None, None, None),
1174                ParseToken::ArrayEof
1175            ])
1176        );
1177
1178        assert_eq!(
1179            run(r#"$['single\'quote']"#),
1180            Ok(vec![
1181                ParseToken::Absolute,
1182                ParseToken::Array,
1183                ParseToken::Key("single'quote".to_string()),
1184                ParseToken::ArrayEof
1185            ])
1186        );
1187
1188        assert_eq!(
1189            run(r#"$["single\"quote"]"#),
1190            Ok(vec![
1191                ParseToken::Absolute,
1192                ParseToken::Array,
1193                ParseToken::Key(r#"single"quote"#.to_string()),
1194                ParseToken::ArrayEof
1195            ])
1196        );
1197    }
1198
1199    #[test]
1200    fn parse_array_float() {
1201        setup();
1202
1203        assert_eq!(
1204            run("$[?(1.1<2.1)]"),
1205            Ok(vec![
1206                ParseToken::Absolute,
1207                ParseToken::Array,
1208                ParseToken::Number(1.1),
1209                ParseToken::Number(2.1),
1210                ParseToken::Filter(FilterToken::Little),
1211                ParseToken::ArrayEof
1212            ])
1213        );
1214
1215        if run("$[1.1]").is_ok() {
1216            panic!();
1217        }
1218
1219        if run("$[?(1.1<.2)]").is_ok() {
1220            panic!();
1221        }
1222
1223        if run("$[?(1.1<2.)]").is_ok() {
1224            panic!();
1225        }
1226
1227        if run("$[?(1.1<2.a)]").is_ok() {
1228            panic!();
1229        }
1230    }
1231}
1232
1233#[cfg(test)]
1234mod tokenizer_tests {
1235    use parser::tokenizer::{Token, TokenError, TokenReader, Tokenizer};
1236
1237    fn setup() {
1238        let _ = env_logger::try_init();
1239    }
1240
1241    fn collect_token(input: &str) -> (Vec<Token>, Option<TokenError>) {
1242        let mut tokenizer = Tokenizer::new(input);
1243        let mut vec = vec![];
1244        loop {
1245            match tokenizer.next_token() {
1246                Ok(t) => vec.push(t),
1247                Err(e) => return (vec, Some(e)),
1248            }
1249        }
1250    }
1251
1252    fn run(input: &str, expected: (Vec<Token>, Option<TokenError>)) {
1253        let (vec, err) = collect_token(input);
1254        assert_eq!((vec, err), expected, "\"{}\"", input);
1255    }
1256
1257    #[test]
1258    fn peek() {
1259        let mut tokenizer = TokenReader::new("$.a");
1260        match tokenizer.next_token() {
1261            Ok(t) => assert_eq!(Token::Absolute(0), t),
1262            _ => panic!(),
1263        }
1264
1265        match tokenizer.peek_token() {
1266            Ok(t) => assert_eq!(&Token::Dot(1), t),
1267            _ => panic!(),
1268        }
1269
1270        match tokenizer.peek_token() {
1271            Ok(t) => assert_eq!(&Token::Dot(1), t),
1272            _ => panic!(),
1273        }
1274
1275        match tokenizer.next_token() {
1276            Ok(t) => assert_eq!(Token::Dot(1), t),
1277            _ => panic!(),
1278        }
1279    }
1280
1281    #[test]
1282    fn token() {
1283        setup();
1284
1285        run(
1286            "$.01.a",
1287            (
1288                vec![
1289                    Token::Absolute(0),
1290                    Token::Dot(1),
1291                    Token::Key(2, "01".to_string()),
1292                    Token::Dot(4),
1293                    Token::Key(5, "a".to_string()),
1294                ],
1295                Some(TokenError::Eof),
1296            ),
1297        );
1298
1299        run(
1300            "$.   []",
1301            (
1302                vec![
1303                    Token::Absolute(0),
1304                    Token::Dot(1),
1305                    Token::Whitespace(2, 2),
1306                    Token::OpenArray(5),
1307                    Token::CloseArray(6),
1308                ],
1309                Some(TokenError::Eof),
1310            ),
1311        );
1312
1313        run(
1314            "$..",
1315            (
1316                vec![Token::Absolute(0), Token::Dot(1), Token::Dot(2)],
1317                Some(TokenError::Eof),
1318            ),
1319        );
1320
1321        run(
1322            "$..ab",
1323            (
1324                vec![
1325                    Token::Absolute(0),
1326                    Token::Dot(1),
1327                    Token::Dot(2),
1328                    Token::Key(3, "ab".to_string()),
1329                ],
1330                Some(TokenError::Eof),
1331            ),
1332        );
1333
1334        run(
1335            "$..가 [",
1336            (
1337                vec![
1338                    Token::Absolute(0),
1339                    Token::Dot(1),
1340                    Token::Dot(2),
1341                    Token::Key(3, "가".to_string()),
1342                    Token::Whitespace(6, 0),
1343                    Token::OpenArray(7),
1344                ],
1345                Some(TokenError::Eof),
1346            ),
1347        );
1348
1349        run(
1350            "[-1, 2 ]",
1351            (
1352                vec![
1353                    Token::OpenArray(0),
1354                    Token::Key(1, "-1".to_string()),
1355                    Token::Comma(3),
1356                    Token::Whitespace(4, 0),
1357                    Token::Key(5, "2".to_string()),
1358                    Token::Whitespace(6, 0),
1359                    Token::CloseArray(7),
1360                ],
1361                Some(TokenError::Eof),
1362            ),
1363        );
1364
1365        run(
1366            "[ 1 2 , 3 \"abc\" : -10 ]",
1367            (
1368                vec![
1369                    Token::OpenArray(0),
1370                    Token::Whitespace(1, 0),
1371                    Token::Key(2, "1".to_string()),
1372                    Token::Whitespace(3, 0),
1373                    Token::Key(4, "2".to_string()),
1374                    Token::Whitespace(5, 0),
1375                    Token::Comma(6),
1376                    Token::Whitespace(7, 0),
1377                    Token::Key(8, "3".to_string()),
1378                    Token::Whitespace(9, 0),
1379                    Token::DoubleQuoted(10, "abc".to_string()),
1380                    Token::Whitespace(15, 0),
1381                    Token::Split(16),
1382                    Token::Whitespace(17, 0),
1383                    Token::Key(18, "-10".to_string()),
1384                    Token::Whitespace(21, 0),
1385                    Token::CloseArray(22),
1386                ],
1387                Some(TokenError::Eof),
1388            ),
1389        );
1390
1391        run(
1392            "?(@.a가 <41.01)",
1393            (
1394                vec![
1395                    Token::Question(0),
1396                    Token::OpenParenthesis(1),
1397                    Token::At(2),
1398                    Token::Dot(3),
1399                    Token::Key(4, "a가".to_string()),
1400                    Token::Whitespace(8, 0),
1401                    Token::Little(9),
1402                    Token::Key(10, "41".to_string()),
1403                    Token::Dot(12),
1404                    Token::Key(13, "01".to_string()),
1405                    Token::CloseParenthesis(15),
1406                ],
1407                Some(TokenError::Eof),
1408            ),
1409        );
1410
1411        run(
1412            "?(@.a <4a.01)",
1413            (
1414                vec![
1415                    Token::Question(0),
1416                    Token::OpenParenthesis(1),
1417                    Token::At(2),
1418                    Token::Dot(3),
1419                    Token::Key(4, "a".to_string()),
1420                    Token::Whitespace(5, 0),
1421                    Token::Little(6),
1422                    Token::Key(7, "4a".to_string()),
1423                    Token::Dot(9),
1424                    Token::Key(10, "01".to_string()),
1425                    Token::CloseParenthesis(12),
1426                ],
1427                Some(TokenError::Eof),
1428            ),
1429        );
1430
1431        run(
1432            "?($.c>@.d)",
1433            (
1434                vec![
1435                    Token::Question(0),
1436                    Token::OpenParenthesis(1),
1437                    Token::Absolute(2),
1438                    Token::Dot(3),
1439                    Token::Key(4, "c".to_string()),
1440                    Token::Greater(5),
1441                    Token::At(6),
1442                    Token::Dot(7),
1443                    Token::Key(8, "d".to_string()),
1444                    Token::CloseParenthesis(9),
1445                ],
1446                Some(TokenError::Eof),
1447            ),
1448        );
1449
1450        run(
1451            "$[:]",
1452            (
1453                vec![
1454                    Token::Absolute(0),
1455                    Token::OpenArray(1),
1456                    Token::Split(2),
1457                    Token::CloseArray(3),
1458                ],
1459                Some(TokenError::Eof),
1460            ),
1461        );
1462
1463        run(
1464            r#"$['single\'quote']"#,
1465            (
1466                vec![
1467                    Token::Absolute(0),
1468                    Token::OpenArray(1),
1469                    Token::SingleQuoted(2, "single\'quote".to_string()),
1470                    Token::CloseArray(17),
1471                ],
1472                Some(TokenError::Eof),
1473            ),
1474        );
1475
1476        run(
1477            r#"$['single\'1','single\'2']"#,
1478            (
1479                vec![
1480                    Token::Absolute(0),
1481                    Token::OpenArray(1),
1482                    Token::SingleQuoted(2, "single\'1".to_string()),
1483                    Token::Comma(13),
1484                    Token::SingleQuoted(14, "single\'2".to_string()),
1485                    Token::CloseArray(25),
1486                ],
1487                Some(TokenError::Eof),
1488            ),
1489        );
1490
1491        run(
1492            r#"$["double\"quote"]"#,
1493            (
1494                vec![
1495                    Token::Absolute(0),
1496                    Token::OpenArray(1),
1497                    Token::DoubleQuoted(2, "double\"quote".to_string()),
1498                    Token::CloseArray(17),
1499                ],
1500                Some(TokenError::Eof),
1501            ),
1502        );
1503    }
1504}
jsonpath_lib/parser/mod.rs

jsonpath_lib/parser/
mod.rs
