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