1use crate::error::Error;
19use crate::project::select::{
20 ArraySelect, CmpOp, HashField, ProjectPathSegment, SelectExpr,
21};
22
23pub fn parse_jmespath_expr(input: &str) -> Result<SelectExpr, Error> {
25 let mut p = Parser::new(input);
26 let expr = p.parse_pipe()?;
27 p.skip_ws();
28 if !p.eof() {
29 return Err(Error::InvalidPath {
30 msg: "Trailing junk after JMESPath expression",
31 });
32 }
33 Ok(expr)
34}
35
36pub fn select_from_project_path(path: &str) -> Result<SelectExpr, Error> {
38 segs_to_select(&parse_project_path(path)?)
39}
40
41pub fn parse_project_path(s: &str) -> Result<Vec<ProjectPathSegment>, Error> {
43 let mut rest = s.trim();
44 let mut segments = Vec::new();
45 if rest.is_empty() {
46 return Err(Error::InvalidPath {
47 msg: "Empty project path",
48 });
49 }
50 while !rest.is_empty() {
51 if rest.starts_with('.') {
52 rest = &rest[1..];
53 continue;
54 }
55 if rest.starts_with('[') {
56 let end_idx = rest.find(']').ok_or(Error::InvalidPath {
57 msg: "Unclosed '[' in project path",
58 })?;
59 let inner = rest[1..end_idx].trim();
60 if inner.is_empty() {
61 segments.push(ProjectPathSegment::ArrayWildcard);
63 } else if inner == "*" {
64 segments.push(ProjectPathSegment::ArrayWildcard);
65 } else if inner.contains(':') {
66 segments.push(parse_slice_inner(inner)?);
67 } else {
68 let idx = parse_signed(inner).map_err(|_| Error::InvalidPath {
69 msg: "Invalid array index",
70 })?;
71 segments.push(ProjectPathSegment::Index(idx));
72 }
73 rest = &rest[end_idx + 1..];
74 } else {
75 let end_key = rest.find(['.', '[']).unwrap_or(rest.len());
76 let key = &rest[..end_key];
77 if key.is_empty() {
78 return Err(Error::InvalidPath {
79 msg: "Empty key segment in project path",
80 });
81 }
82 segments.push(ProjectPathSegment::Key(key.to_string()));
83 rest = &rest[end_key..];
84 }
85 }
86 Ok(segments)
87}
88
89fn parse_slice_inner(inner: &str) -> Result<ProjectPathSegment, Error> {
90 let parts: Vec<&str> = inner.split(':').collect();
91 if parts.len() > 3 {
92 return Err(Error::InvalidPath {
93 msg: "Slice has too many components",
94 });
95 }
96 let parse_opt = |s: &str| -> Result<Option<i64>, Error> {
97 let s = s.trim();
98 if s.is_empty() {
99 Ok(None)
100 } else {
101 Ok(Some(parse_signed(s).map_err(|_| Error::InvalidPath {
102 msg: "Invalid slice bound",
103 })?))
104 }
105 };
106 let start = parse_opt(parts.first().copied().unwrap_or(""))?;
107 let end = parse_opt(parts.get(1).copied().unwrap_or(""))?;
108 let step = if parts.len() == 3 {
109 parse_opt(parts[2])?
110 } else {
111 None
112 };
113 Ok(ProjectPathSegment::ArraySlice { start, end, step })
114}
115
116fn parse_signed(s: &str) -> Result<i64, ()> {
117 s.trim().parse().map_err(|_| ())
118}
119
120fn segs_to_select(segs: &[ProjectPathSegment]) -> Result<SelectExpr, Error> {
121 if segs.is_empty() {
122 return Ok(SelectExpr::Identity);
123 }
124 let mut expr = SelectExpr::Identity;
125 for seg in segs.iter().rev() {
126 expr = match seg {
127 ProjectPathSegment::Key(k) => {
128 if matches!(expr, SelectExpr::Identity | SelectExpr::Current) {
129 SelectExpr::Field(k.clone())
130 } else {
131 SelectExpr::Sub(Box::new(SelectExpr::Field(k.clone())), Box::new(expr))
132 }
133 }
134 ProjectPathSegment::Index(i) => {
135 let mut map = std::collections::HashMap::new();
136 map.insert(*i, expr);
137 SelectExpr::Array(ArraySelect::Indices(map))
138 }
139 ProjectPathSegment::ArrayWildcard => {
140 SelectExpr::Array(ArraySelect::Each(Box::new(expr)))
141 }
142 ProjectPathSegment::ArraySlice { start, end, step } => {
143 SelectExpr::Array(ArraySelect::Slice {
144 start: *start,
145 end: *end,
146 step: *step,
147 each: Box::new(expr),
148 })
149 }
150 };
151 }
152 Ok(expr)
153}
154
155struct Parser<'a> {
156 s: &'a str,
157 i: usize,
158}
159
160impl<'a> Parser<'a> {
161 fn new(s: &'a str) -> Self {
162 Self { s, i: 0 }
163 }
164
165 fn eof(&self) -> bool {
166 self.i >= self.s.len()
167 }
168
169 fn peek(&self) -> Option<char> {
170 self.s[self.i..].chars().next()
171 }
172
173 fn peek_str(&self) -> &str {
174 &self.s[self.i..]
175 }
176
177 fn bump(&mut self) -> Option<char> {
178 let c = self.peek()?;
179 self.i += c.len_utf8();
180 Some(c)
181 }
182
183 fn skip_ws(&mut self) {
184 while self.peek().is_some_and(|c| c.is_whitespace()) {
185 self.bump();
186 }
187 }
188
189 fn eat(&mut self, expected: char) -> Result<(), Error> {
190 self.skip_ws();
191 match self.bump() {
192 Some(c) if c == expected => Ok(()),
193 _ => Err(Error::InvalidPath {
194 msg: "Unexpected character in JMESPath",
195 }),
196 }
197 }
198
199 fn starts_with(&self, lit: &str) -> bool {
200 self.peek_str().starts_with(lit)
201 }
202
203 fn parse_pipe(&mut self) -> Result<SelectExpr, Error> {
205 let mut left = self.parse_or()?;
206 loop {
207 self.skip_ws();
208 if self.peek() == Some('|') && !self.starts_with("||") {
209 self.bump();
210 self.skip_ws();
211 if self.peek() == Some('[') {
212 let save = self.i;
213 self.bump();
214 self.skip_ws();
215 if self.peek() == Some(']') {
216 self.bump();
217 left = SelectExpr::Flatten(Box::new(left));
218 continue;
219 }
220 self.i = save;
221 }
222 let right = self.parse_or()?;
223 left = SelectExpr::Pipe(Box::new(left), Box::new(right));
224 } else {
225 break;
226 }
227 }
228 Ok(left)
229 }
230
231 fn parse_or(&mut self) -> Result<SelectExpr, Error> {
232 let mut left = self.parse_and()?;
233 loop {
234 self.skip_ws();
235 if self.starts_with("||") {
236 self.i += 2;
237 let right = self.parse_and()?;
238 left = SelectExpr::Or(Box::new(left), Box::new(right));
239 } else {
240 break;
241 }
242 }
243 Ok(left)
244 }
245
246 fn parse_and(&mut self) -> Result<SelectExpr, Error> {
247 let mut left = self.parse_not()?;
248 loop {
249 self.skip_ws();
250 if self.starts_with("&&") {
251 self.i += 2;
252 let right = self.parse_not()?;
253 left = SelectExpr::And(Box::new(left), Box::new(right));
254 } else {
255 break;
256 }
257 }
258 Ok(left)
259 }
260
261 fn parse_not(&mut self) -> Result<SelectExpr, Error> {
262 self.skip_ws();
263 if self.peek() == Some('!') && !self.starts_with("!=") {
264 self.bump();
265 let inner = self.parse_not()?;
266 return Ok(SelectExpr::Not(Box::new(inner)));
267 }
268 self.parse_compare()
269 }
270
271 fn parse_compare(&mut self) -> Result<SelectExpr, Error> {
272 let left = self.parse_project()?;
273 self.skip_ws();
274 let op = if self.starts_with("==") {
275 self.i += 2;
276 Some(CmpOp::Eq)
277 } else if self.starts_with("!=") {
278 self.i += 2;
279 Some(CmpOp::Ne)
280 } else if self.starts_with("<=") {
281 self.i += 2;
282 Some(CmpOp::Le)
283 } else if self.starts_with(">=") {
284 self.i += 2;
285 Some(CmpOp::Ge)
286 } else if self.peek() == Some('<') {
287 self.bump();
288 Some(CmpOp::Lt)
289 } else if self.peek() == Some('>') {
290 self.bump();
291 Some(CmpOp::Gt)
292 } else {
293 None
294 };
295 if let Some(op) = op {
296 let right = self.parse_project()?;
297 Ok(SelectExpr::Cmp {
298 op,
299 left: Box::new(left),
300 right: Box::new(right),
301 })
302 } else {
303 Ok(left)
304 }
305 }
306
307 fn parse_project(&mut self) -> Result<SelectExpr, Error> {
308 self.skip_ws();
309 if self.peek() == Some('&') {
311 self.bump();
312 let inner = self.parse_project()?;
313 return Ok(SelectExpr::Expref(Box::new(inner)));
314 }
315 if self.peek() == Some('{') {
316 let expr = self.parse_multi_hash()?;
317 return self.parse_projection_suffixes(expr);
318 }
319 if self.peek() == Some('[') {
321 let expr = self.parse_bracket_expr()?;
322 return self.parse_projection_suffixes(expr);
323 }
324 if self.peek() == Some('*') {
326 self.bump();
327 let expr = SelectExpr::ObjectProjection(Box::new(SelectExpr::Identity));
328 return self.parse_projection_suffixes(expr);
329 }
330 let mut expr = self.parse_atom()?;
331 expr = self.parse_projection_suffixes(expr)?;
332 Ok(expr)
333 }
334
335 fn parse_projection_suffixes(&mut self, mut expr: SelectExpr) -> Result<SelectExpr, Error> {
337 loop {
338 self.skip_ws();
339 match self.peek() {
340 Some('.') => {
341 self.bump();
342 self.skip_ws();
343 if self.peek() == Some('*') {
344 self.bump();
345 expr = chain_sub(
347 expr,
348 SelectExpr::ObjectProjection(Box::new(SelectExpr::Identity)),
349 );
350 } else if self.peek() == Some('{') {
351 let right = self.parse_multi_hash()?;
352 if matches!(&right, SelectExpr::MultiSelectHash(f) if f.is_empty()) {
354 return Err(Error::InvalidPath {
355 msg: "Empty multi-select hash after '.'",
356 });
357 }
358 expr = chain_sub(expr, right);
359 } else if self.peek() == Some('[') {
360 let save = self.i;
363 self.bump(); self.skip_ws();
365 let bad_number = self
366 .peek()
367 .is_some_and(|c| c == '-' || c.is_ascii_digit());
368 self.i = save;
369 if bad_number {
370 return Err(Error::InvalidPath {
371 msg: "Multi-select list after '.' cannot start with a number",
372 });
373 }
374 let right = self.parse_bracket_expr()?;
375 if let SelectExpr::MultiSelectList(items) = &right {
377 for it in items {
378 if matches!(it, SelectExpr::Literal(b) if is_json_number_lit(b)) {
379 return Err(Error::InvalidPath {
380 msg: "Number not allowed as multi-select list item here",
381 });
382 }
383 }
384 }
385 expr = chain_sub(expr, right);
386 } else if self.peek() == Some('"') {
387 let name = self.parse_dq_string_raw()?;
389 expr = chain_sub(expr, SelectExpr::FieldQuoted(name));
390 } else {
391 let name = self.parse_ident()?;
392 if self.peek() == Some('(') {
393 let args = self.parse_arg_list()?;
394 expr = chain_sub(
395 expr,
396 SelectExpr::Call { name, args },
397 );
398 } else {
399 expr = chain_sub(expr, SelectExpr::Field(name));
400 }
401 }
402 }
403 Some('[') => {
404 let bracket = self.parse_bracket_suffix()?;
405 expr = chain_sub(expr, bracket);
406 }
407 Some('(') => {
408 if let SelectExpr::Field(name) = expr {
410 let args = self.parse_arg_list()?;
411 expr = SelectExpr::Call { name, args };
412 } else if matches!(expr, SelectExpr::FieldQuoted(_)) {
413 return Err(Error::InvalidPath {
414 msg: "Quoted identifier is not a function name",
415 });
416 } else {
417 break;
418 }
419 }
420 _ => break,
421 }
422 }
423 Ok(expr)
424 }
425
426 fn parse_atom(&mut self) -> Result<SelectExpr, Error> {
427 self.skip_ws();
428 match self.peek() {
429 Some('@') => {
430 self.bump();
431 Ok(SelectExpr::Current)
432 }
433 Some('&') => {
434 self.bump();
435 let inner = self.parse_project()?;
436 Ok(SelectExpr::Expref(Box::new(inner)))
437 }
438 Some('*') => {
439 self.bump();
440 Ok(SelectExpr::ObjectProjection(Box::new(SelectExpr::Identity)))
441 }
442 Some('(') => {
443 self.bump();
444 let e = self.parse_pipe()?;
445 self.eat(')')?;
446 Ok(SelectExpr::Paren(Box::new(e)))
447 }
448 Some('"') => {
450 let name = self.parse_dq_string_raw()?;
452 Ok(SelectExpr::FieldQuoted(name))
453 }
454 Some('\'') => self.parse_raw_string_literal(),
455 Some('`') => self.parse_backtick_literal(),
456 Some(c) if c == '-' || c.is_ascii_digit() => self.parse_number_literal(),
457 Some('{') => self.parse_multi_hash(),
458 Some('[') => self.parse_bracket_expr(),
459 Some(c) if is_ident_start(c) => {
460 let name = self.parse_ident()?;
461 self.skip_ws();
462 if self.peek() == Some('(') {
463 let args = self.parse_arg_list()?;
464 Ok(SelectExpr::Call { name, args })
465 } else if name == "true" {
466 Ok(SelectExpr::Literal(b"true".to_vec()))
467 } else if name == "false" {
468 Ok(SelectExpr::Literal(b"false".to_vec()))
469 } else if name == "null" {
470 Ok(SelectExpr::Literal(b"null".to_vec()))
471 } else {
472 Ok(SelectExpr::Field(name))
473 }
474 }
475 _ => Err(Error::InvalidPath {
476 msg: "Expected JMESPath atom",
477 }),
478 }
479 }
480
481 fn parse_arg_list(&mut self) -> Result<Vec<SelectExpr>, Error> {
482 self.eat('(')?;
483 let mut args = Vec::new();
484 self.skip_ws();
485 if self.peek() == Some(')') {
486 self.bump();
487 return Ok(args);
488 }
489 loop {
490 args.push(self.parse_pipe()?);
491 self.skip_ws();
492 match self.peek() {
493 Some(',') => {
494 self.bump();
495 continue;
496 }
497 Some(')') => {
498 self.bump();
499 break;
500 }
501 _ => {
502 return Err(Error::InvalidPath {
503 msg: "Expected ',' or ')' in function args",
504 });
505 }
506 }
507 }
508 Ok(args)
509 }
510
511 fn parse_ident(&mut self) -> Result<String, Error> {
512 self.skip_ws();
513 let start = self.i;
514 match self.peek() {
515 Some(c) if is_ident_start(c) => {
516 self.bump();
517 }
518 _ => {
519 return Err(Error::InvalidPath {
520 msg: "Expected identifier",
521 });
522 }
523 }
524 while self.peek().is_some_and(is_ident_continue) {
525 self.bump();
526 }
527 Ok(self.s[start..self.i].to_string())
528 }
529
530 fn parse_multi_hash(&mut self) -> Result<SelectExpr, Error> {
531 self.eat('{')?;
532 let mut fields = Vec::new();
533 self.skip_ws();
534 if self.peek() == Some('}') {
535 self.bump();
536 return Ok(SelectExpr::MultiSelectHash(fields));
537 }
538 loop {
539 self.skip_ws();
540 let key = if self.peek() == Some('"') {
541 self.parse_dq_string_raw()?
542 } else if self.peek() == Some('\'') {
543 self.parse_raw_string_raw()?
544 } else {
545 self.parse_ident()?
546 };
547 self.skip_ws();
548 self.eat(':')?;
549 let expr = self.parse_pipe()?;
550 fields.push(HashField::new(key, expr));
551 self.skip_ws();
552 match self.peek() {
553 Some(',') => {
554 self.bump();
555 continue;
556 }
557 Some('}') => {
558 self.bump();
559 break;
560 }
561 _ => {
562 return Err(Error::InvalidPath {
563 msg: "Expected ',' or '}' in multi-select hash",
564 });
565 }
566 }
567 }
568 Ok(SelectExpr::MultiSelectHash(fields))
569 }
570
571 fn parse_bracket_expr(&mut self) -> Result<SelectExpr, Error> {
573 self.parse_bracket_common(true)
574 }
575
576 fn parse_bracket_suffix(&mut self) -> Result<SelectExpr, Error> {
578 self.parse_bracket_common(false)
579 }
580
581 fn parse_bracket_common(&mut self, allow_multi_list: bool) -> Result<SelectExpr, Error> {
582 self.eat('[')?;
583 if self.peek() == Some('?') {
585 self.bump();
586 let pred = self.parse_pipe()?;
587 self.eat(']')?;
588 return Ok(SelectExpr::Array(ArraySelect::Filter {
589 pred: Box::new(pred),
590 each: Box::new(SelectExpr::Identity),
591 }));
592 }
593 self.skip_ws();
594 if self.peek() == Some(']') {
598 self.bump();
599 return Ok(SelectExpr::Flatten(Box::new(SelectExpr::Identity)));
600 }
601 if self.peek() == Some('*') {
603 let save = self.i;
604 self.bump();
605 if self.peek() == Some(']') {
606 self.bump();
607 return Ok(SelectExpr::Array(ArraySelect::Each(Box::new(
608 SelectExpr::Identity,
609 ))));
610 }
611 self.i = save;
612 }
614 let save = self.i;
616 if self.peek().is_some_and(|c| c == '-' || c == ':' || c.is_ascii_digit()) {
617 let inner_start = self.i;
618 while self.peek().is_some_and(|c| c != ']') {
619 self.bump();
620 }
621 let inner = self.s[inner_start..self.i].trim();
622 if self.peek() == Some(']') {
623 self.bump();
624 if inner.contains(':') {
625 return match parse_slice_inner(inner)? {
626 ProjectPathSegment::ArraySlice { start, end, step } => {
627 Ok(SelectExpr::Array(ArraySelect::Slice {
628 start,
629 end,
630 step,
631 each: Box::new(SelectExpr::Identity),
632 }))
633 }
634 _ => unreachable!(),
635 };
636 }
637 if let Ok(idx) = parse_signed(inner) {
638 let mut map = std::collections::HashMap::new();
639 map.insert(idx, SelectExpr::Identity);
640 return Ok(SelectExpr::Array(ArraySelect::Indices(map)));
641 }
642 }
643 self.i = save;
644 }
645 if !allow_multi_list {
646 return Err(Error::InvalidPath {
647 msg: "Invalid bracket suffix",
648 });
649 }
650 let mut items = Vec::new();
652 loop {
653 items.push(self.parse_pipe()?);
654 self.skip_ws();
655 match self.peek() {
656 Some(',') => {
657 self.bump();
658 continue;
659 }
660 Some(']') => {
661 self.bump();
662 break;
663 }
664 _ => {
665 return Err(Error::InvalidPath {
666 msg: "Expected ',' or ']' in multi-select list",
667 });
668 }
669 }
670 }
671 Ok(SelectExpr::MultiSelectList(items))
672 }
673
674 fn parse_dq_string_raw(&mut self) -> Result<String, Error> {
675 self.eat('"')?;
676 let mut out = String::new();
677 while let Some(c) = self.bump() {
678 match c {
679 '"' => return Ok(out),
680 '\\' => {
681 let e = self.bump().ok_or(Error::InvalidPath {
682 msg: "Bad escape",
683 })?;
684 match e {
685 '"' | '\\' | '/' => out.push(e),
686 'b' => out.push('\u{0008}'),
687 'f' => out.push('\u{000c}'),
688 'n' => out.push('\n'),
689 't' => out.push('\t'),
690 'r' => out.push('\r'),
691 'u' => {
692 let ch = self.parse_unicode_escape()?;
693 out.push(ch);
694 }
695 other => out.push(other),
696 }
697 }
698 c => out.push(c),
699 }
700 }
701 Err(Error::InvalidPath {
702 msg: "Unclosed string",
703 })
704 }
705
706 fn parse_unicode_escape(&mut self) -> Result<char, Error> {
708 let hi = self.read_u4_hex()?;
709 if (0xD800..=0xDBFF).contains(&hi) {
710 if self.peek() != Some('\\') {
712 return Err(Error::InvalidPath {
713 msg: "Lone UTF-16 high surrogate in quoted identifier",
714 });
715 }
716 self.bump();
717 if self.peek() != Some('u') {
718 return Err(Error::InvalidPath {
719 msg: "Expected \\u after high surrogate",
720 });
721 }
722 self.bump();
723 let lo = self.read_u4_hex()?;
724 if !(0xDC00..=0xDFFF).contains(&lo) {
725 return Err(Error::InvalidPath {
726 msg: "Invalid UTF-16 low surrogate",
727 });
728 }
729 let cp = 0x10000 + (((u32::from(hi) - 0xD800) << 10) | (u32::from(lo) - 0xDC00));
730 char::from_u32(cp).ok_or(Error::InvalidPath {
731 msg: "Invalid Unicode code point",
732 })
733 } else if (0xDC00..=0xDFFF).contains(&hi) {
734 Err(Error::InvalidPath {
735 msg: "Lone UTF-16 low surrogate in quoted identifier",
736 })
737 } else {
738 char::from_u32(u32::from(hi)).ok_or(Error::InvalidPath {
739 msg: "Invalid Unicode code point",
740 })
741 }
742 }
743
744 fn read_u4_hex(&mut self) -> Result<u16, Error> {
745 let mut v = 0u16;
746 for _ in 0..4 {
747 let c = self.bump().ok_or(Error::InvalidPath {
748 msg: "Incomplete \\u escape",
749 })?;
750 let dig = c.to_digit(16).ok_or(Error::InvalidPath {
751 msg: "Invalid hex in \\u escape",
752 })?;
753 v = (v << 4) | dig as u16;
754 }
755 Ok(v)
756 }
757
758 fn parse_raw_string_literal(&mut self) -> Result<SelectExpr, Error> {
759 let raw = self.parse_raw_string_raw()?;
760 Ok(SelectExpr::Literal(encode_json_string(&raw)))
761 }
762
763 fn parse_raw_string_raw(&mut self) -> Result<String, Error> {
764 self.eat('\'')?;
765 let mut out = String::new();
766 while let Some(c) = self.bump() {
767 if c == '\\' {
771 out.push('\\');
772 if let Some(n) = self.bump() {
773 out.push(n);
774 }
775 } else if c == '\'' {
776 return Ok(out.replace("\\'", "'"));
777 } else {
778 out.push(c);
779 }
780 }
781 Err(Error::InvalidPath {
782 msg: "Unclosed raw string",
783 })
784 }
785
786 fn parse_backtick_literal(&mut self) -> Result<SelectExpr, Error> {
787 self.eat('`')?;
788 let mut raw = String::new();
789 while let Some(c) = self.peek() {
790 if c == '`' {
791 self.bump();
792 let inner = raw.trim();
793 return Ok(SelectExpr::Literal(inner.as_bytes().to_vec()));
796 }
797 if c == '\\' {
798 self.bump();
799 match self.peek() {
800 Some('`') => {
801 self.bump();
802 raw.push('`');
803 }
804 Some(e) => {
805 raw.push('\\');
807 raw.push(e);
808 self.bump();
809 }
810 None => raw.push('\\'),
811 }
812 } else {
813 raw.push(c);
814 self.bump();
815 }
816 }
817 Err(Error::InvalidPath {
818 msg: "Unclosed backtick literal",
819 })
820 }
821
822 fn parse_number_literal(&mut self) -> Result<SelectExpr, Error> {
823 self.skip_ws();
824 let start = self.i;
825 if self.peek() == Some('-') {
826 self.bump();
827 }
828 while self.peek().is_some_and(|c| c.is_ascii_digit()) {
829 self.bump();
830 }
831 if self.peek() == Some('.') {
832 self.bump();
833 while self.peek().is_some_and(|c| c.is_ascii_digit()) {
834 self.bump();
835 }
836 }
837 let lit = self.s.as_bytes()[start..self.i].to_vec();
838 if lit.is_empty() || lit == b"-" {
839 return Err(Error::InvalidPath {
840 msg: "Invalid number literal",
841 });
842 }
843 Ok(SelectExpr::Literal(lit))
844 }
845}
846
847fn encode_json_string(raw: &str) -> Vec<u8> {
848 let mut bytes = Vec::with_capacity(raw.len() + 2);
849 bytes.push(b'"');
850 for b in raw.bytes() {
851 match b {
852 b'"' | b'\\' => {
853 bytes.push(b'\\');
854 bytes.push(b);
855 }
856 c if c < 0x20 => bytes.extend_from_slice(format!("\\u{c:04x}").as_bytes()),
857 c => bytes.push(c),
858 }
859 }
860 bytes.push(b'"');
861 bytes
862}
863
864fn is_ident_start(c: char) -> bool {
865 c.is_ascii_alphabetic() || c == '_'
866}
867
868fn is_json_number_lit(b: &[u8]) -> bool {
869 let t = b.trim_ascii();
870 if t.is_empty() {
871 return false;
872 }
873 t.iter()
874 .all(|c| c.is_ascii_digit() || *c == b'-' || *c == b'+' || *c == b'.' || *c == b'e' || *c == b'E')
875 && t.iter().any(|c| c.is_ascii_digit())
876}
877
878fn is_ident_continue(c: char) -> bool {
879 c.is_ascii_alphanumeric() || c == '_'
880}
881
882fn chain_sub(prefix: SelectExpr, suffix: SelectExpr) -> SelectExpr {
883 if let SelectExpr::Flatten(inner) = &suffix {
885 if matches!(inner.as_ref(), SelectExpr::Identity | SelectExpr::Current) {
886 return SelectExpr::Flatten(Box::new(prefix));
887 }
888 return SelectExpr::Flatten(Box::new(chain_sub(prefix, *inner.clone())));
889 }
890 match prefix {
891 SelectExpr::Field(name) => {
892 SelectExpr::Sub(Box::new(SelectExpr::Field(name)), Box::new(suffix))
893 }
894 SelectExpr::FieldQuoted(name) => {
895 SelectExpr::Sub(Box::new(SelectExpr::FieldQuoted(name)), Box::new(suffix))
896 }
897 SelectExpr::ObjectProjection(inner) => {
898 SelectExpr::ObjectProjection(Box::new(chain_into(*inner, suffix)))
900 }
901 SelectExpr::Flatten(inner) => SelectExpr::Sub(
904 Box::new(SelectExpr::Flatten(inner)),
905 Box::new(SelectExpr::Array(ArraySelect::Each(Box::new(suffix)))),
906 ),
907 SelectExpr::Array(ArraySelect::Each(inner)) => {
908 SelectExpr::Array(ArraySelect::Each(Box::new(chain_into(*inner, suffix))))
909 }
910 SelectExpr::Array(ArraySelect::Slice {
911 start,
912 end,
913 step,
914 each,
915 }) => SelectExpr::Array(ArraySelect::Slice {
916 start,
917 end,
918 step,
919 each: Box::new(chain_into(*each, suffix)),
920 }),
921 SelectExpr::Array(ArraySelect::Filter { pred, each }) => {
922 SelectExpr::Array(ArraySelect::Filter {
923 pred,
924 each: Box::new(chain_into(*each, suffix)),
925 })
926 }
927 SelectExpr::Array(ArraySelect::Indices(mut map)) if map.len() == 1 => {
928 let (k, v) = map.drain().next().unwrap();
929 map.insert(k, chain_into(v, suffix));
930 SelectExpr::Array(ArraySelect::Indices(map))
931 }
932 SelectExpr::Sub(left, right) => {
933 SelectExpr::Sub(left, Box::new(chain_into(*right, suffix)))
934 }
935 SelectExpr::Expref(inner) => SelectExpr::Expref(Box::new(chain_into(*inner, suffix))),
936 SelectExpr::Paren(inner) => chain_sub(*inner, suffix),
937 other => SelectExpr::Sub(Box::new(other), Box::new(suffix)),
938 }
939}
940
941fn chain_into(inner: SelectExpr, suffix: SelectExpr) -> SelectExpr {
942 if matches!(inner, SelectExpr::Identity | SelectExpr::Current) {
943 suffix
944 } else {
945 chain_sub(inner, suffix)
946 }
947}