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