1use crate::parser::model::Selector;
2use crate::query::queryable::Queryable;
3use crate::query::state::{Data, Pointer, State};
4use crate::query::Query;
5use std::cmp::{max, min};
6
7impl Query for Selector {
8 fn process<'a, T: Queryable>(&self, step: State<'a, T>) -> State<'a, T> {
9 match self {
10 Selector::Name(key) => step.flat_map(|d| process_key(d, key)),
11 Selector::Index(idx) => step.flat_map(|d| process_index(d, idx)),
12 Selector::Wildcard => step.flat_map(process_wildcard),
13 Selector::Slice(start, end, sl_step) => {
14 step.flat_map(|d| process_slice(d, start, end, sl_step))
15 }
16 Selector::Filter(f) => f.process(step),
17 }
18 }
19}
20
21fn process_wildcard<T: Queryable>(
22 Pointer {
23 inner: pointer,
24 path,
25 }: Pointer<T>,
26) -> Data<T> {
27 if let Some(array) = pointer.as_array() {
28 if array.is_empty() {
29 Data::Nothing
30 } else {
31 Data::new_refs(
32 array
33 .iter()
34 .enumerate()
35 .map(|(i, elem)| Pointer::idx(elem, path.clone(), i))
36 .collect(),
37 )
38 }
39 } else if let Some(object) = pointer.as_object() {
40 if object.is_empty() {
41 Data::Nothing
42 } else {
43 Data::new_refs(
44 object
45 .into_iter()
46 .map(|(key, value)| Pointer::key(value, path.clone(), key))
47 .collect(),
48 )
49 }
50 } else {
51 Data::Nothing
52 }
53}
54
55fn process_slice<'a, T: Queryable>(
56 Pointer { inner, path }: Pointer<'a, T>,
57 start: &Option<i64>,
58 end: &Option<i64>,
59 step: &Option<i64>,
60) -> Data<'a, T> {
61 let extract_elems = |elements: &'a Vec<T>| -> Vec<(&'a T, usize)> {
62 let len = elements.len() as i64;
63 let norm = |i: i64| {
64 if i >= 0 {
65 i
66 } else {
67 len + i
68 }
69 };
70
71 match step.unwrap_or(1) {
72 e if e > 0 => {
73 let n_start = norm(start.unwrap_or(0));
74 let n_end = norm(end.unwrap_or(len));
75 let lower = min(max(n_start, 0), len);
76 let upper = min(max(n_end, 0), len);
77
78 let mut idx = lower;
79 let mut res = vec![];
80 while idx < upper {
81 let i = idx as usize;
82 if let Some(elem) = elements.get(i) {
83 res.push((elem, i));
84 }
85 idx += e;
86 }
87 res
88 }
89 e if e < 0 => {
90 let n_start = norm(start.unwrap_or(len - 1));
91 let n_end = norm(end.unwrap_or(-len - 1));
92 let lower = min(max(n_end, -1), len - 1);
93 let upper = min(max(n_start, -1), len - 1);
94 let mut idx = upper;
95 let mut res = vec![];
96 while lower < idx {
97 let i = idx as usize;
98 if let Some(elem) = elements.get(i) {
99 res.push((elem, i));
100 }
101 idx += e;
102 }
103 res
104 }
105 _ => vec![],
106 }
107 };
108
109 let elems_to_step = |v: Vec<(&'a T, usize)>| {
110 Data::new_refs(
111 v.into_iter()
112 .map(|(elem, i)| Pointer::idx(elem, path.clone(), i))
113 .collect(),
114 )
115 };
116
117 inner
118 .as_array()
119 .map(extract_elems)
120 .map(elems_to_step)
121 .unwrap_or_default()
122}
123
124pub fn process_key<'a, T: Queryable>(
125 Pointer { inner, path }: Pointer<'a, T>,
126 key: &str,
127) -> Data<'a, T> {
128 inner
129 .get(key)
130 .map(|v| Data::new_ref(Pointer::key(v, path, key)))
131 .unwrap_or_default()
132}
133
134pub fn process_index<'a, T: Queryable>(
135 Pointer { inner, path }: Pointer<'a, T>,
136 idx: &i64,
137) -> Data<'a, T> {
138 inner
139 .as_array()
140 .map(|array| {
141 if *idx >= 0 {
142 if *idx >= array.len() as i64 {
143 Data::Nothing
144 } else {
145 let i = *idx as usize;
146 Data::new_ref(Pointer::idx(&array[i], path, i))
147 }
148 } else {
149 let abs_idx = idx.abs() as usize;
150 if abs_idx > array.len() {
151 Data::Nothing
152 } else {
153 let i = array.len() - abs_idx;
154 Data::new_ref(Pointer::idx(&array[i], path, i))
155 }
156 }
157 })
158 .unwrap_or_default()
159}
160
161#[cfg(test)]
162mod tests {
163 use super::*;
164 use crate::parser::model::Segment;
165 use crate::query::{js_path, Queried};
166 use serde_json::json;
167 use std::vec;
168 #[test]
169 fn test_process_empty_key() {
170 let value = json!({" ": "value"});
171 let segment = Segment::Selector(Selector::Name(" ".to_string()));
172
173 let step = segment.process(State::root(&value));
174
175 assert_eq!(
176 step.ok_ref(),
177 Some(vec![Pointer::new(&json!("value"), "$[' ']".to_string())])
178 );
179 }
180 #[test]
181 fn test_process_key() {
182 let value = json!({"key": "value"});
183 let segment = Segment::Selector(Selector::Name("key".to_string()));
184
185 let step = segment.process(State::root(&value));
186
187 assert_eq!(
188 step.ok_ref(),
189 Some(vec![Pointer::new(&json!("value"), "$['key']".to_string())])
190 );
191 }
192
193 #[test]
194 fn test_process_key_failed() {
195 let value = json!({"key": "value"});
196 let segment = Segment::Selector(Selector::Name("key2".to_string()));
197 let step = segment.process(State::root(&value));
198
199 assert_eq!(step, State::nothing(&value));
200 }
201
202 #[test]
203 fn test_process_index() {
204 let value = json!([1, 2, 3]);
205 let segment = Segment::Selector(Selector::Index(1));
206 let step = segment.process(State::root(&value));
207
208 assert_eq!(
209 step.ok_ref(),
210 Some(vec![Pointer::new(&json!(2), "$[1]".to_string())])
211 );
212 }
213
214 #[test]
215 fn test_process_index_failed() {
216 let value = json!([1, 2, 3]);
217 let segment = Segment::Selector(Selector::Index(3));
218 let step = segment.process(State::root(&value));
219
220 assert_eq!(step, State::nothing(&value));
221 }
222
223 #[test]
224 fn test_process_slice1() {
225 let value = json!([1, 2, 3, 4, 5]);
226 let segment = Segment::Selector(Selector::Slice(Some(1), Some(4), Some(1)));
227 let step = segment.process(State::root(&value));
228
229 assert_eq!(
230 step.ok_ref(),
231 Some(vec![
232 Pointer::new(&json!(2), "$[1]".to_string()),
233 Pointer::new(&json!(3), "$[2]".to_string()),
234 Pointer::new(&json!(4), "$[3]".to_string())
235 ])
236 );
237 }
238
239 #[test]
240 fn test_process_slice2() {
241 let value = json!([1, 2, 3, 4, 5]);
242 let segment = Segment::Selector(Selector::Slice(Some(2), Some(0), Some(-1)));
243 let step = segment.process(State::root(&value));
244
245 assert_eq!(
246 step.ok_ref(),
247 Some(vec![
248 Pointer::new(&json!(3), "$[2]".to_string()),
249 Pointer::new(&json!(2), "$[1]".to_string()),
250 ])
251 );
252 }
253
254 #[test]
255 fn test_process_slice3() {
256 let value = json!([1, 2, 3, 4, 5]);
257 let segment = Segment::Selector(Selector::Slice(Some(0), Some(5), Some(2)));
258 let step = segment.process(State::root(&value));
259
260 assert_eq!(
261 step.ok_ref(),
262 Some(vec![
263 Pointer::new(&json!(1), "$[0]".to_string()),
264 Pointer::new(&json!(3), "$[2]".to_string()),
265 Pointer::new(&json!(5), "$[4]".to_string())
266 ])
267 );
268 }
269
270 #[test]
271 fn test_process_slice_failed() {
272 let value = json!([1, 2, 3, 4, 5]);
273 let segment = Segment::Selector(Selector::Slice(Some(0), Some(5), Some(0)));
274 let step = segment.process(State::root(&value));
275
276 assert_eq!(step.ok_ref(), Some(vec![]));
277 }
278
279 #[test]
280 fn test_process_wildcard() {
281 let value = json!({"key": "value", "key2": "value2"});
282 let segment = Segment::Selector(Selector::Wildcard);
283 let step = segment.process(State::root(&value));
284
285 assert_eq!(
286 step.ok_ref(),
287 Some(vec![
288 Pointer::new(&json!("value"), "$['key']".to_string()),
289 Pointer::new(&json!("value2"), "$['key2']".to_string())
290 ])
291 );
292 }
293
294 #[test]
295 fn test_process_wildcard_array() {
296 let value = json!([1, 2, 3]);
297 let segment = Segment::Selector(Selector::Wildcard);
298 let step = segment.process(State::root(&value));
299
300 assert_eq!(
301 step.ok_ref(),
302 Some(vec![
303 Pointer::new(&json!(1), "$[0]".to_string()),
304 Pointer::new(&json!(2), "$[1]".to_string()),
305 Pointer::new(&json!(3), "$[2]".to_string())
306 ])
307 );
308 }
309
310 #[test]
311 fn test_process_wildcard_failed() {
312 let value = json!(1);
313 let segment = Segment::Selector(Selector::Wildcard);
314 let step = segment.process(State::root(&value));
315
316 assert_eq!(step, State::nothing(&value));
317 }
318
319 #[test]
320 fn multi_selector() -> Queried<()> {
321 let json = json!([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
322
323 let vec = js_path("$['a',1]", &json)?;
324
325 assert_eq!(vec, vec![(&json!(1), "$[1]".to_string()).into(),]);
326
327 Ok(())
328 }
329 #[test]
330 fn multi_selector_space() -> Queried<()> {
331 let json = json!({
332 "a": "ab",
333 "b": "bc"
334 });
335
336 let vec = js_path("$['a',\r'b']", &json)?;
337
338 assert_eq!(
339 vec,
340 vec![
341 (&json!("ab"), "$['a']".to_string()).into(),
342 (&json!("bc"), "$['b']".to_string()).into(),
343 ]
344 );
345
346 Ok(())
347 }
348}