json_flat_parser/
parser.rs

1use std::mem;
2use crate::{concat_string, FlatJsonValue, ParseOptions, ParseResult, PointerFragment, PointerKey, ValueType};
3use crate::lexer::{Lexer, Token};
4
5pub struct Parser<'a, 'json> {
6    lexer: &'a mut Lexer<'json>,
7    current_token: Option<Token<'json>>,
8    pub state_seen_start_parse_at: bool,
9    pub start_parse_at_index_start: usize,
10    pub start_parse_at_index_end: usize,
11    pub max_depth: usize,
12    pub depth_after_start_at: u8,
13}
14
15
16impl<'a, 'json: 'a> Parser<'a, 'json> {
17    pub fn new(lexer: &'a mut Lexer<'json>) -> Self {
18        Self { lexer, current_token: None, state_seen_start_parse_at: false, start_parse_at_index_start: 0, start_parse_at_index_end: 0, max_depth: 0, depth_after_start_at: 0 }
19    }
20    pub fn new_for_change_depth(lexer: &'a mut Lexer<'json>, depth_after_start_at: u8, max_depth: usize) -> Self {
21        Self { lexer, current_token: None, state_seen_start_parse_at: true, start_parse_at_index_start: 0, start_parse_at_index_end: 0, max_depth, depth_after_start_at }
22    }
23
24    pub fn parse(&mut self, parse_option: &ParseOptions, depth: u8) -> Result<ParseResult<&'json str>, String> {
25        let mut values: Vec<FlatJsonValue<&'json str>> = Vec::with_capacity(64);
26        self.next_token();
27        let mut position = 0_usize;
28        if let Some(current_token) = self.current_token.as_ref() {
29            if matches!(current_token, Token::CurlyOpen) {
30                let mut pointer_fragment: Vec<String> = Vec::with_capacity(16);
31                if let Some(ref p) = parse_option.prefix { pointer_fragment.push(p.clone()) }
32                let i = 0;
33                // values.push((PointerKey::from_pointer("".to_string(), ValueType::Object, depth, position), None));
34                self.process_object(&mut pointer_fragment, &mut values, depth, i, parse_option, &mut position)?;
35                return Ok(ParseResult {
36                    json: values,
37                    max_json_depth: self.max_depth,
38                    parsing_max_depth: parse_option.max_depth,
39                    started_parsing_at: parse_option.start_parse_at.clone(),
40                    started_parsing_at_index_start: self.start_parse_at_index_start,
41                    started_parsing_at_index_end: self.start_parse_at_index_end,
42                    parsing_prefix: parse_option.prefix.clone(),
43                    depth_after_start_at: self.depth_after_start_at,
44                });
45            }
46            if matches!(current_token, Token::SquareOpen) {
47                let mut pointer_fragment: Vec<String> = Vec::with_capacity(128);
48                if let Some(ref p) = parse_option.prefix { pointer_fragment.push(p.clone()) }
49                let i = 0;
50                let pointer_index = values.len() as isize;
51
52                values.push(FlatJsonValue { pointer: PointerKey::from_pointer("".to_string(), ValueType::Array(0), depth, i), value: None });
53                self.process_array(&mut pointer_fragment, &mut values, depth, i + 1, parse_option, &mut position, pointer_index)?;
54                return Ok(ParseResult {
55                    json: values,
56                    max_json_depth: self.max_depth,
57                    parsing_max_depth: parse_option.max_depth,
58                    started_parsing_at: parse_option.start_parse_at.clone(),
59                    started_parsing_at_index_start: self.start_parse_at_index_start,
60                    started_parsing_at_index_end: self.start_parse_at_index_end,
61                    parsing_prefix: parse_option.prefix.clone(),
62                    depth_after_start_at: self.depth_after_start_at,
63                });
64            }
65            Err(format!("Expected json to start with {{ or [ but started with {:?}", current_token))
66        } else {
67            Err("Json is empty".to_string())
68        }
69    }
70
71    fn process_object(&mut self, route: &mut PointerFragment, target: &mut Vec<FlatJsonValue<&'json str>>, depth: u8, count: usize, parse_option: &ParseOptions, position: &mut usize) -> Result<(usize), String> {
72        let mut object_elements = 0 as usize;
73        if self.max_depth < depth as usize {
74            self.max_depth = depth as usize;
75        }
76        self.next_token();
77        while let Some(ref token) = self.current_token {
78            match token {
79                Token::String(key) => {
80                    object_elements += 1;
81                    route.push(concat_string!("/", key));
82                }
83                Token::CurlyClose => {
84                    // empty object
85                    break;
86                }
87                _ => return Err(format!("Expected object to have a key at this location: {}, previous valid parsed value: {:?}", Self::concat_route(route),
88                                        target.last().map(|e| e.pointer.pointer.as_str()).unwrap_or("")))
89            }
90            self.next_token();
91            if let Some(ref _token) = self.current_token {
92                match self.current_token {
93                    Some(ref token) if matches!(token, Token::Colon) => {
94                        self.next_token();
95                    }
96                    _ => return Err(format!("Expected ':' after object key at this location: {}, previous valid parsed value: {:?}", Self::concat_route(route),
97                                            target.last().map(|e| e.pointer.pointer.as_str()).unwrap_or("")))
98                }
99            } else {
100                return Err("Expected ':' after object key".to_string());
101            }
102            self.parse_value(route, target, depth, count, parse_option, position)?;
103            self.next_token();
104
105            if self.state_seen_start_parse_at && self.depth_after_start_at == depth && self.start_parse_at_index_end == 0 {
106                self.start_parse_at_index_end = target.len() - 1;
107            }
108
109
110            match self.current_token {
111                Some(ref token) if matches!(token, Token::Comma) => {
112                    self.next_token();
113                }
114                Some(ref token) if matches!(token, Token::CurlyClose) => {
115                    route.pop();
116                    break;
117                }
118                Some(ref token) if matches!(token, Token::SquareClose) => {
119                    // route.pop();
120                    panic!("End of array should not be consumed from there, json probably wrong");
121                    // break;
122                }
123                None => break,
124                _ => {
125                    let mut index = 0;
126                    if target.len() > 0 {
127                        index = target.len() - 1;
128                    }
129                    return Err(format!("Expected ',' or '}}' or ']' after object value, got: {:?}, previous nodes {:?}", self.current_token, target[index]));
130                }
131            }
132            route.pop();
133        }
134        Ok(object_elements)
135    }
136
137    fn process_array(&mut self, route: &mut PointerFragment, target: &mut Vec<FlatJsonValue<&'json str>>, depth: u8, count: usize, parse_option: &ParseOptions, position: &mut usize, pointer_index: isize) -> Result<(), String> {
138        let array_start_index = self.lexer.reader_index() - 1;
139        self.next_token();
140        let mut i = 1;
141        while let Some(ref token) = self.current_token {
142            if matches!(token, Token::SquareClose) {
143                if pointer_index >= 0 {
144                    let PointerKey { pointer, position, depth, .. } = mem::take(&mut target[pointer_index as usize].pointer);
145                    target[pointer_index as usize] = FlatJsonValue { pointer: PointerKey::from_pointer(pointer, ValueType::Array(i), depth, position), value: None };
146                }
147                break;
148            }
149            let mut nested_array = false;
150            if matches!(token, Token::SquareOpen) {
151                nested_array = true;
152            }
153            if self.should_parse_array(&route, parse_option) {
154                if !self.state_seen_start_parse_at && parse_option.start_parse_at.is_some() {
155                    self.state_seen_start_parse_at = true;
156                    self.start_parse_at_index_start = target.len() - 1;
157                    self.depth_after_start_at = depth - 1;
158                }
159                if depth - self.depth_after_start_at <= parse_option.max_depth {
160                    route.push("/0".to_string());
161                    self.parse_value(route, target, depth, count, parse_option, position)?;
162                    route.pop();
163                    self.next_token();
164                    while let Some(ref token) = self.current_token {
165                        if !matches!(token, Token::Comma) {
166                            break;
167                        }
168                        self.next_token();
169                        if let Some(ref _token) = self.current_token {
170                            route.push(format!("/{}", i));
171                            self.parse_value(route, target, depth, count, parse_option, position)?;
172                            route.pop();
173                        } else {
174                            break;
175                        }
176                        self.next_token();
177                        i += 1;
178                    }
179                } else if let Some(array_str) = self.lexer.consume_string_until_end_of_array(array_start_index, nested_array) {
180                    if pointer_index >= 0 {
181                        let PointerKey { pointer, position, depth, .. } = mem::take(&mut target[pointer_index as usize].pointer);
182                        target[pointer_index as usize] = FlatJsonValue { pointer: PointerKey::from_pointer(pointer, ValueType::Array(i), depth, position), value: Some(array_str) };
183                    }
184                    break;
185                }
186            } else if let Some(array_str) = self.lexer.consume_string_until_end_of_array(array_start_index, nested_array) {
187                if pointer_index >= 0 {
188                    let PointerKey { position, depth, .. } = target[pointer_index as usize].pointer;
189                    target[pointer_index as usize] = FlatJsonValue { pointer: PointerKey::from_pointer(Self::concat_route(route), ValueType::Array(i), depth, position), value: Some(array_str) };
190                }
191                break;
192            }
193        }
194        Ok(())
195    }
196
197    fn parse_value(&mut self, route: &mut PointerFragment, target: &mut Vec<FlatJsonValue<&'json str>>, depth: u8, count: usize, parse_option: &ParseOptions, position: &mut usize) -> Result<(), String> {
198        match self.current_token {
199            Some(ref token) => match token {
200                Token::CurlyOpen => {
201                    if depth - self.depth_after_start_at <= parse_option.max_depth {
202                        let start = self.lexer.reader_index();
203                        if let Some(object_str) = self.lexer.consume_string_until_end_of_object(true) {
204                            *position += 1;
205                            let mut parsed = true;
206                            let pointer = Self::concat_route(route);
207                            if Self::should_push_to_target(parse_option, &pointer) {
208                                if parse_option.keep_object_raw_data || depth - self.depth_after_start_at == parse_option.max_depth {
209                                    target.push(FlatJsonValue { pointer: PointerKey::from_pointer(pointer, ValueType::Object(depth - self.depth_after_start_at < parse_option.max_depth, 0), depth, *position), value: Some(object_str) });
210                                } else {
211                                    target.push(FlatJsonValue { pointer: PointerKey::from_pointer(pointer, ValueType::Object(true, 0), depth, *position), value: None });
212                                }
213                            }
214                            self.lexer.set_reader_index(start);
215                            let object_index = if target.len() > 0 { target.len() - 1 } else { 0 };
216                            let elements_count = self.process_object(route, target, depth + 1, count, parse_option, position)?;
217                            if object_index < target.len() && matches!(target[object_index].pointer.value_type, ValueType::Object(true, _)) {
218                                target[object_index].pointer.value_type = ValueType::Object(true, elements_count);
219                            }
220                        } else {
221                            panic!("We should no go there! we have not found matching closing curly {}", String::from_utf8_lossy(&self.lexer.reader().data()[start..start + 1000]))
222                        }
223                    } else {
224                        // consuming remaining token
225                        self.lexer.consume_string_until_end_of_object(false);
226                        // self.process_object(route, target, depth + 1, count, parse_option, position);
227                    }
228                    Ok(())
229                }
230                Token::SquareOpen => {
231                    let mut pointer_index: isize = -1;
232                    let pointer = Self::concat_route(route);
233                    let should_parse_array= Self::should_push_to_target(parse_option, &pointer);
234                    if depth - self.depth_after_start_at <= parse_option.max_depth {
235                        *position += 1;
236                        pointer_index = target.len() as isize;
237                        if should_parse_array {
238                            target.push(FlatJsonValue { pointer: PointerKey::from_pointer(pointer, ValueType::Array(0), depth, *position), value: None });
239                        }
240                    }
241                    if should_parse_array {
242                        self.process_array(route, target, depth + 1, count, parse_option, position, pointer_index)?;
243                    } else {
244                        self.lexer.consume_string_until_end_of_array(self.lexer.reader_index() - 1, false);
245                    }
246                    Ok(())
247                }
248                Token::String(value) => {
249                    if depth - self.depth_after_start_at <= parse_option.max_depth {
250                        let pointer = Self::concat_route(route);
251                        if Self::should_push_to_target(parse_option, &pointer) {
252                            *position += 1;
253                            target.push(FlatJsonValue { pointer: PointerKey::from_pointer(pointer, ValueType::String, depth, *position), value: Some(value) });
254                        }
255                    }
256
257                    Ok(())
258                }
259                Token::Number(value) => {
260                    if depth - self.depth_after_start_at <= parse_option.max_depth {
261                        let pointer = Self::concat_route(route);
262                        if Self::should_push_to_target(parse_option, &pointer) {
263                            *position += 1;
264                            target.push(FlatJsonValue { pointer: PointerKey::from_pointer(pointer, ValueType::Number, depth, *position), value: Some(value) });
265                        }
266                    }
267                    Ok(())
268                }
269                Token::Boolean(value) => {
270                    if depth - self.depth_after_start_at <= parse_option.max_depth {
271                        let pointer = Self::concat_route(route);
272                        if Self::should_push_to_target(parse_option, &pointer) {
273                            *position += 1;
274                            target.push(FlatJsonValue { pointer: PointerKey::from_pointer(pointer, ValueType::Bool, depth, *position), value: Some(value) });
275                        }
276                    }
277                    Ok(())
278                }
279                Token::Null => {
280                    if depth <= parse_option.max_depth {
281                        let pointer = Self::concat_route(route);
282                        if Self::should_push_to_target(parse_option, &pointer) {
283                            *position += 1;
284                            target.push(FlatJsonValue { pointer: PointerKey::from_pointer(pointer, ValueType::Null, depth, *position), value: None });
285                        }
286                    }
287                    Ok(())
288                }
289                _ => Err(format!("Unexpected token: {:?}", token))
290            },
291            _ => Err("Unexpected end of input".to_string())
292        }
293    }
294
295    #[inline]
296    fn should_push_to_target(parse_option: &ParseOptions, pointer: &String) -> bool {
297        parse_option.start_parse_at.is_none() || parse_option.start_parse_at.is_some() && pointer.starts_with(parse_option.start_parse_at.as_ref().unwrap())
298    }
299
300    fn should_parse_array(&mut self, route: &&mut PointerFragment, parse_option: &ParseOptions) -> bool {
301        parse_option.parse_array
302            || parse_option.start_parse_at.is_none() && route.is_empty()
303            // When parse_array is disable, we allow to parse array if we set a pointer from where we start parsing and this pointer is an array itself, otherwise we would not parse anything
304            || (parse_option.start_parse_at.is_some() && !self.state_seen_start_parse_at && parse_option.start_parse_at.as_ref().unwrap().eq(&Self::concat_route(route)))
305    }
306    #[inline]
307    fn concat_route(route: &PointerFragment) -> String {
308        let mut res = String::with_capacity(64);
309        for p in route {
310            res.push_str(p);
311        }
312        res
313    }
314    #[inline]
315    fn next_token(&mut self) {
316        self.current_token = self.lexer.next_token();
317    }
318}
319
320
321#[cfg(test)]
322mod tests {
323    use std::fs;
324    use std::path::Path;
325    use crate::{JSONParser, ParseOptions, ValueType};
326
327    #[test]
328    fn object() {
329        let json = r#"
330        {
331              "id": 1,
332              "maxLevel": 99,
333              "name": "NV_BAS\IC\"",
334              "aaa": true
335            }"#;
336
337        let res = JSONParser::parse(json, ParseOptions::default()).unwrap();
338        let vec = res.json;
339        assert_eq!(vec[0].pointer.pointer, "/id");
340        assert_eq!(vec[0].pointer.value_type, ValueType::Number);
341        assert_eq!(vec[0].value, Some("1"));
342        assert_eq!(vec[1].pointer.pointer, "/maxLevel");
343        assert_eq!(vec[1].pointer.value_type, ValueType::Number);
344        assert_eq!(vec[1].value, Some("99"));
345        assert_eq!(vec[2].pointer.pointer, "/name");
346        assert_eq!(vec[2].pointer.value_type, ValueType::String);
347        assert_eq!(vec[2].value, Some("NV_BAS\\IC\\\""));
348        assert_eq!(vec[3].pointer.pointer, "/aaa");
349        assert_eq!(vec[3].pointer.value_type, ValueType::Bool);
350        assert_eq!(vec[3].value, Some("true"));
351    }
352
353    #[test]
354    fn max_depth_object() {
355        let json = r#"{"nested": {"a1": "a","b": {"a2": "a","c": {"a3": "a"}}}"#;
356
357        let mut result1 = JSONParser::parse(json, ParseOptions::default().max_depth(1)).unwrap();
358        let vec = &result1.json;
359        assert_eq!(vec.len(), 1);
360        assert_eq!(vec[0].pointer.pointer, "/nested");
361        assert_eq!(vec[0].pointer.value_type, ValueType::Object(false, 0));
362        assert_eq!(vec[0].value, Some("{\"a1\": \"a\",\"b\": {\"a2\": \"a\",\"c\": {\"a3\": \"a\"}}}"));
363        let result2 = JSONParser::parse(json, ParseOptions::default().max_depth(2)).unwrap();
364
365        let vec = &result2.json;
366        assert_eq!(vec.len(), 3);
367        assert_eq!(vec[0].pointer.pointer, "/nested");
368        assert_eq!(vec[0].pointer.value_type, ValueType::Object(true, 2));
369        assert_eq!(vec[0].value, Some("{\"a1\": \"a\",\"b\": {\"a2\": \"a\",\"c\": {\"a3\": \"a\"}}}"));
370        assert_eq!(vec[1].pointer.pointer, "/nested/a1");
371        assert_eq!(vec[1].pointer.value_type, ValueType::String);
372        assert_eq!(vec[1].value, Some("a"));
373        assert_eq!(vec[2].pointer.pointer, "/nested/b");
374        assert_eq!(vec[2].pointer.value_type, ValueType::Object(false, 0));
375        assert_eq!(vec[2].value, Some("{\"a2\": \"a\",\"c\": {\"a3\": \"a\"}}"));
376        JSONParser::change_depth(&mut result1, ParseOptions::default().max_depth(2)).unwrap();
377        let vec = &result1.json;
378        assert_eq!(vec.len(), 3);
379        assert_eq!(vec[0].pointer.pointer, "/nested");
380        assert_eq!(vec[0].pointer.value_type, ValueType::Object(true, 2));
381        assert_eq!(vec[0].value, Some("{\"a1\": \"a\",\"b\": {\"a2\": \"a\",\"c\": {\"a3\": \"a\"}}}"));
382        assert_eq!(vec[1].pointer.pointer, "/nested/a1");
383        assert_eq!(vec[1].pointer.value_type, ValueType::String);
384        assert_eq!(vec[1].value, Some("a"));
385        assert_eq!(vec[2].pointer.pointer, "/nested/b");
386        assert_eq!(vec[2].pointer.value_type, ValueType::Object(false, 0));
387        assert_eq!(vec[2].value, Some("{\"a2\": \"a\",\"c\": {\"a3\": \"a\"}}"));
388    }
389
390    #[test]
391    fn max_depth_object2() {
392        let json = r#"{"skills": [{"description": "Bash", "bonusToTarget": [{"level":1,"value":2}], "copyflags": {
393        "plagiarism": true,"reproduce": true}, "bonusToSelf": [{"level":1,"value":2}]}, {"description": "Bash", "copyflags": {"plagiarism": true,"reproduce": true}}]"#;
394
395        let result1 = JSONParser::parse(json, ParseOptions::default().parse_array(false).start_parse_at("/skills".to_string()).max_depth(1)).unwrap();
396        let _vec = &result1.json;
397    }
398
399    #[test]
400    fn parse_empty_object() {
401        let json = r#"{"a": {"c": [ ], "b": { }, "d": 1}, "e": 2}"#;
402        let result1 = JSONParser::parse(json, ParseOptions::default()).unwrap();
403        let vec = &result1.json;
404
405        assert_eq!(vec[0].pointer.pointer, "/a");
406        assert_eq!(vec[0].pointer.value_type, ValueType::Object(true, 3));
407        assert_eq!(vec[1].pointer.pointer, "/a/c");
408        assert_eq!(vec[1].pointer.value_type, ValueType::Array(1));
409        assert_eq!(vec[2].pointer.pointer, "/a/b");
410        assert_eq!(vec[2].pointer.value_type, ValueType::Object(true, 0));
411        assert_eq!(vec[3].pointer.pointer, "/a/d");
412        assert_eq!(vec[3].pointer.value_type, ValueType::Number);
413        assert_eq!(vec[4].pointer.pointer, "/e");
414        assert_eq!(vec[4].pointer.value_type, ValueType::Number);
415    }
416    #[test]
417    fn parse_array_of_array() {
418        let json = r#"{"data": [ [ "row-mnid.ac5t.8e6c", 0, 1583413338, null, "{ }", "2020"], [ "row-wgxs-vi8e-i2eq", "00000000-0000-0000-B3DA-6C4E63133CC6", 0 ] ]"#;
419        let result1 = JSONParser::parse(json, ParseOptions::default()).unwrap();
420        let vec = &result1.json;
421        assert_eq!(vec.len(), 12);
422
423        let result1 = JSONParser::parse(json, ParseOptions::default().parse_array(false)).unwrap();
424        let vec = &result1.json;
425        assert_eq!(vec.len(), 1);
426    }
427
428    #[test]
429    fn nested_object() {
430        let json = r#"
431        {
432              "id": 1,
433              "maxLevel": 99,
434              "name": "NV_BASIC",
435              "aaa": true,
436              "flags": {"a": true, "b": false, "c": {"nested": "Oui"}}
437            }"#;
438
439        let json = json.replace(['\n', ' '], "");
440        let json = json.as_str();
441
442        let vec = JSONParser::parse(json, ParseOptions::default()).unwrap().json;
443        assert_eq!(vec[0].pointer.pointer, "/id");
444        assert_eq!(vec[0].pointer.value_type, ValueType::Number);
445        assert_eq!(vec[0].value, Some("1"));
446        assert_eq!(vec[1].pointer.pointer, "/maxLevel");
447        assert_eq!(vec[1].pointer.value_type, ValueType::Number);
448        assert_eq!(vec[1].value, Some("99"));
449        assert_eq!(vec[2].pointer.pointer, "/name");
450        assert_eq!(vec[2].pointer.value_type, ValueType::String);
451        assert_eq!(vec[2].value, Some("NV_BASIC"));
452        assert_eq!(vec[3].pointer.pointer, "/aaa");
453        assert_eq!(vec[3].pointer.value_type, ValueType::Bool);
454        assert_eq!(vec[3].value, Some("true"));
455        assert_eq!(vec[4].pointer.pointer, "/flags");
456        assert_eq!(vec[4].pointer.value_type, ValueType::Object(true, 3));
457        assert_eq!(vec[5].pointer.pointer, "/flags/a");
458        assert_eq!(vec[5].pointer.value_type, ValueType::Bool);
459        assert_eq!(vec[5].value, Some("true"));
460        assert_eq!(vec[6].pointer.pointer, "/flags/b");
461        assert_eq!(vec[6].pointer.value_type, ValueType::Bool);
462        assert_eq!(vec[6].value, Some("false"));
463        assert_eq!(vec[7].pointer.pointer, "/flags/c");
464        assert_eq!(vec[7].pointer.value_type, ValueType::Object(true, 1));
465        assert_eq!(vec[8].pointer.pointer, "/flags/c/nested");
466        assert_eq!(vec[8].pointer.value_type, ValueType::String);
467        assert_eq!(vec[8].value, Some("Oui"));
468    }
469
470    #[test]
471    fn simple_array() {
472        let json = r#"
473            [1,2,3]
474        "#;
475
476
477        let res = JSONParser::parse(json, ParseOptions::default()).unwrap();
478        let vec = res.json;
479        // assert_eq!(res.root_array_len, 3);
480        assert_eq!(vec[0].pointer.pointer, "");
481        assert_eq!(vec[0].pointer.value_type, ValueType::Array(3));
482        assert_eq!(vec[1].pointer.pointer, "/0");
483        assert_eq!(vec[1].pointer.value_type, ValueType::Number);
484        assert_eq!(vec[1].value, Some("1"));
485        assert_eq!(vec[2].pointer.pointer, "/1");
486        assert_eq!(vec[2].pointer.value_type, ValueType::Number);
487        assert_eq!(vec[2].value, Some("2"));
488        assert_eq!(vec[3].pointer.pointer, "/2");
489        assert_eq!(vec[3].pointer.value_type, ValueType::Number);
490        assert_eq!(vec[3].value, Some("3"));
491    }
492
493    #[test]
494    fn simple_array_nested() {
495        let json = r#"
496            [[1],[2],[3]]
497        "#;
498
499
500        let vec = JSONParser::parse(json, ParseOptions::default()).unwrap().json;
501        assert_eq!(vec[0].pointer.pointer, "");
502        assert_eq!(vec[0].pointer.value_type, ValueType::Array(3));
503        assert_eq!(vec[1].pointer.pointer, "/0");
504        assert_eq!(vec[1].pointer.value_type, ValueType::Array(1));
505        assert_eq!(vec[2].pointer.pointer, "/0/0");
506        assert_eq!(vec[2].pointer.value_type, ValueType::Number);
507        assert_eq!(vec[2].value, Some("1"));
508
509        assert_eq!(vec[3].pointer.pointer, "/1");
510        assert_eq!(vec[3].pointer.value_type, ValueType::Array(1));
511        assert_eq!(vec[4].pointer.pointer, "/1/0");
512        assert_eq!(vec[4].pointer.value_type, ValueType::Number);
513        assert_eq!(vec[4].value, Some("2"));
514
515        assert_eq!(vec[5].pointer.pointer, "/2");
516        assert_eq!(vec[5].pointer.value_type, ValueType::Array(1));
517        assert_eq!(vec[6].pointer.pointer, "/2/0");
518        assert_eq!(vec[6].pointer.value_type, ValueType::Number);
519        assert_eq!(vec[6].value, Some("3"));
520    }
521
522    #[test]
523    fn simple_array_nested_parse_false() {
524        let json = r#"
525            [[1],[2],[3]]
526        "#;
527
528
529        let vec = JSONParser::parse(json, ParseOptions::default().parse_array(false)).unwrap().json;
530        println!("{:?}", vec);
531        assert_eq!(vec[0].pointer.pointer, "");
532        assert_eq!(vec[0].pointer.value_type, ValueType::Array(3));
533        assert_eq!(vec[1].pointer.pointer, "/0");
534        assert_eq!(vec[1].pointer.value_type, ValueType::Array(1));
535        assert_eq!(vec[2].pointer.pointer, "/1");
536        assert_eq!(vec[2].pointer.value_type, ValueType::Array(1));
537        assert_eq!(vec[3].pointer.pointer, "/2");
538        assert_eq!(vec[3].pointer.value_type, ValueType::Array(1));
539    }
540
541    #[test]
542    fn array_of_object_parse_false() {
543        let json = r#"
544            [{"description": "Basic Skill"}, {"description": "Bash"}]
545        "#;
546
547
548        let vec = JSONParser::parse(json, ParseOptions::default().parse_array(false).max_depth(1)).unwrap().json;
549        println!("{:?}", vec);
550        assert_eq!(vec[0].pointer.pointer, "");
551        assert_eq!(vec[0].pointer.value_type, ValueType::Array(2));
552        assert_eq!(vec[1].pointer.pointer, "/0");
553        assert_eq!(vec[1].pointer.value_type, ValueType::Object(false, 0));
554        assert_eq!(vec[2].pointer.pointer, "/1");
555        assert_eq!(vec[2].pointer.value_type, ValueType::Object(false, 0));
556    }
557
558    #[test]
559    fn array() {
560        let json = r#"
561            {
562                "skills": [
563                    {"description": "Basic Skill"},
564                    {"description": "Heal"},
565                    {"description": "Bash"}
566                ]
567            }
568        "#;
569
570        let json = json.replace(['\n', ' '], "");
571        let json = json.as_str();
572
573        let vec = JSONParser::parse(json, ParseOptions::default()).unwrap().json;
574        assert_eq!(vec[0].pointer.pointer, "/skills");
575        assert_eq!(vec[0].pointer.value_type, ValueType::Array(3));
576        assert_eq!(vec[1].pointer.pointer, "/skills/0");
577        assert_eq!(vec[1].pointer.value_type, ValueType::Object(true, 1));
578        assert_eq!(vec[2].pointer.pointer, "/skills/0/description");
579        assert_eq!(vec[2].pointer.parent(), "/skills/0");
580        assert_eq!(vec[2].pointer.value_type, ValueType::String);
581        assert_eq!(vec[2].value, Some("BasicSkill"));
582        assert_eq!(vec[3].pointer.pointer, "/skills/1");
583        assert_eq!(vec[3].pointer.value_type, ValueType::Object(true, 1));
584        assert_eq!(vec[4].pointer.pointer, "/skills/1/description");
585        assert_eq!(vec[4].pointer.value_type, ValueType::String);
586        assert_eq!(vec[4].value, Some("Heal"));
587        assert_eq!(vec[5].pointer.pointer, "/skills/2");
588        assert_eq!(vec[5].pointer.value_type, ValueType::Object(true, 1));
589        assert_eq!(vec[6].pointer.pointer, "/skills/2/description");
590        assert_eq!(vec[6].pointer.value_type, ValueType::String);
591        assert_eq!(vec[6].value, Some("Bash"));
592    }
593
594    #[test]
595    fn array_with_start_parse_at() {
596        let json = r#"
597            {
598                "skills": [
599                    {"description": "Basic Skill", "inner": [2]},
600                    {"description": "Heal", "inner": [3]},
601                    {"description": "Bash", "inner": [1]}
602                ],
603                "statuses": [
604                    {"agi": 10},
605                    {"dex": 19},
606                ],
607                "tree": {
608                    "level": 1
609                }
610            }
611        "#;
612
613        let json = json.replace(['\n', ' '], "");
614        let json = json.as_str();
615
616        let result = JSONParser::parse(json, ParseOptions::default().start_parse_at("/skills".to_string()).parse_array(false)).unwrap();
617        let vec = result.json;
618        assert_eq!(vec.len(), 10);
619        assert_eq!(vec[0].pointer.pointer, "/skills");
620        assert_eq!(vec[0].pointer.value_type, ValueType::Array(3));
621        assert_eq!(vec[1].pointer.pointer, "/skills/0");
622        assert_eq!(vec[1].pointer.value_type, ValueType::Object(true, 2));
623        assert_eq!(vec[2].pointer.pointer, "/skills/0/description");
624        assert_eq!(vec[2].pointer.value_type, ValueType::String);
625        assert_eq!(vec[3].pointer.pointer, "/skills/0/inner");
626        assert_eq!(vec[3].pointer.value_type, ValueType::Array(1));
627        assert_eq!(vec[5].pointer.pointer, "/skills/1/description");
628        assert_eq!(vec[5].pointer.value_type, ValueType::String);
629        assert_eq!(vec[6].pointer.pointer, "/skills/1/inner");
630        assert_eq!(vec[6].pointer.value_type, ValueType::Array(1));
631        assert_eq!(vec[8].pointer.pointer, "/skills/2/description");
632        assert_eq!(vec[8].pointer.value_type, ValueType::String);
633        assert_eq!(vec[9].pointer.pointer, "/skills/2/inner");
634        assert_eq!(vec[9].pointer.value_type, ValueType::Array(1));
635        assert_eq!(result.started_parsing_at_index_start, 0);
636        assert_eq!(result.started_parsing_at_index_end, 9);
637    }
638
639    #[test]
640    fn array_with_parse_option_false() {
641        let json = r#"
642            {
643                "skills": [
644                    {"description": "Basic Skill"},
645                    {"description": "Heal"},
646                    {"description": "Bash"}
647                ]
648            }
649        "#;
650
651
652        let vec = JSONParser::parse(json, ParseOptions::default().parse_array(false)).unwrap().json;
653        assert_eq!(vec[0].pointer.pointer, "/skills");
654        assert_eq!(vec[0].pointer.value_type, ValueType::Array(1));
655        assert_eq!(vec[0].value.unwrap().replace(['\n', ' '], ""), "[{\"description\": \"Basic Skill\"},\n                    {\"description\": \"Heal\"},\n                    {\"description\": \"Bash\"}\n                ]".replace(['\n', ' '], ""));
656    }
657
658    #[test]
659    fn depth() {
660        let json = r#"{
661  "skills": [
662    {
663      "requires": {"spCostPerLevel": [{"level": 1, "value": 10}, {"level": 2, "value": 20}]}
664    }
665  ]
666}"#;
667
668        let result_ref = JSONParser::parse(json, ParseOptions::default()
669            .parse_array(true).start_parse_at("/skills".to_string()).max_depth(10)).unwrap();
670        let vec = result_ref.json;
671        assert_eq!(vec[0].pointer.pointer, "/skills");
672        assert_eq!(vec[0].pointer.depth, 1);
673        assert_eq!(vec[1].pointer.pointer, "/skills/0");
674        assert_eq!(vec[1].pointer.depth, 2);
675        assert_eq!(vec[2].pointer.pointer, "/skills/0/requires");
676        assert_eq!(vec[2].pointer.depth, 3);
677        assert_eq!(vec[3].pointer.pointer, "/skills/0/requires/spCostPerLevel");
678        assert_eq!(vec[3].pointer.depth, 4);
679        assert_eq!(vec[4].pointer.pointer, "/skills/0/requires/spCostPerLevel/0");
680        assert_eq!(vec[4].pointer.depth, 5);
681        assert_eq!(vec[5].pointer.pointer, "/skills/0/requires/spCostPerLevel/0/level");
682        assert_eq!(vec[5].pointer.depth, 6);
683        assert_eq!(vec[6].pointer.pointer, "/skills/0/requires/spCostPerLevel/0/value");
684        assert_eq!(vec[6].pointer.depth, 6);
685        assert_eq!(vec[7].pointer.pointer, "/skills/0/requires/spCostPerLevel/1");
686        assert_eq!(vec[7].pointer.depth, 5);
687        assert_eq!(vec[8].pointer.pointer, "/skills/0/requires/spCostPerLevel/1/level");
688        assert_eq!(vec[8].pointer.depth, 6);
689        assert_eq!(vec[9].pointer.pointer, "/skills/0/requires/spCostPerLevel/1/value");
690        assert_eq!(vec[9].pointer.depth, 6);
691
692        let mut result_ref = JSONParser::parse(json, ParseOptions::default()
693            .parse_array(true).start_parse_at("/skills".to_string()).max_depth(1)).unwrap();
694        let vec = &result_ref.json;
695        assert_eq!(vec[0].pointer.pointer, "/skills");
696        assert_eq!(vec[0].pointer.depth, 1);
697        assert_eq!(vec[1].pointer.pointer, "/skills/0");
698        assert_eq!(vec[1].pointer.depth, 2);
699        JSONParser::change_depth(&mut result_ref, ParseOptions::default().parse_array(true).start_parse_at("/skills".to_string()).max_depth(2)).unwrap();
700        let vec = &result_ref.json;
701        assert_eq!(vec[0].pointer.pointer, "/skills");
702        assert_eq!(vec[0].pointer.depth, 1);
703        assert_eq!(vec[1].pointer.pointer, "/skills/0");
704        assert_eq!(vec[1].pointer.depth, 2);
705        assert_eq!(vec[2].pointer.pointer, "/skills/0/requires");
706        assert_eq!(vec[2].pointer.depth, 3);
707        JSONParser::change_depth(&mut result_ref, ParseOptions::default().parse_array(true).start_parse_at("/skills".to_string()).max_depth(3)).unwrap();
708        let vec = &result_ref.json;
709        assert_eq!(vec[0].pointer.pointer, "/skills");
710        assert_eq!(vec[0].pointer.depth, 1);
711        assert_eq!(vec[1].pointer.pointer, "/skills/0");
712        assert_eq!(vec[1].pointer.depth, 2);
713        assert_eq!(vec[2].pointer.pointer, "/skills/0/requires");
714        assert_eq!(vec[2].pointer.depth, 3);
715        assert_eq!(vec[3].pointer.pointer, "/skills/0/requires/spCostPerLevel");
716        assert_eq!(vec[3].pointer.depth, 4);
717        JSONParser::change_depth(&mut result_ref, ParseOptions::default().parse_array(false).start_parse_at("/skills".to_string()).max_depth(4)).unwrap();
718        let vec = &result_ref.json;
719        assert_eq!(vec.len(), 4);
720        assert_eq!(vec[0].pointer.pointer, "/skills");
721        assert_eq!(vec[0].pointer.depth, 1);
722        assert_eq!(vec[1].pointer.pointer, "/skills/0");
723        assert_eq!(vec[1].pointer.depth, 2);
724        assert_eq!(vec[2].pointer.pointer, "/skills/0/requires");
725        assert_eq!(vec[2].pointer.depth, 3);
726        assert_eq!(vec[3].pointer.pointer, "/skills/0/requires/spCostPerLevel");
727        assert_eq!(vec[3].pointer.depth, 4);
728    }
729
730    #[test]
731    fn max_depth() {
732        let json = r#"{
733  "aaa": 10,
734  "skills": [
735    {
736      "description": "Basic Skill",
737      "id": 1,
738      "name": "NV_BASIC"
739    },
740    {
741      "description": "Sword Mastery",
742      "id": 1,
743      "name": "SM_SWORD",
744      "basicSkillPerLevel": [{"level": 1,"value": "Trade"}],
745      "bonusToSelf": [{"level": 1, "value": {"bonus": "MasteryDamageUsingWeaponType","value": "1hSword","value2": 4}}],
746      "requires": {"spCostPerLevel": [{"level": 1, "value": 10}, {"level": 2, "value": 20}]}
747    }
748  ]
749}"#;
750        let json = json.replace(['\n', ' '], "");
751        let json = json.as_str();
752
753        let result_ref = JSONParser::parse(json, ParseOptions::default().max_depth(1)).unwrap();
754        let vec = result_ref.json;
755        assert_eq!(vec.len(), 2);
756        // assert_eq!(result_ref.max_json_depth, 4);
757        assert_eq!(vec[0].pointer.pointer, "/aaa");
758        assert_eq!(vec[0].pointer.value_type, ValueType::Number);
759        assert_eq!(vec[1].pointer.pointer, "/skills");
760        assert_eq!(vec[1].pointer.value_type, ValueType::Array(1));
761        //
762        let mut res = JSONParser::parse(json, ParseOptions::default().max_depth(1)).unwrap();
763        JSONParser::change_depth(&mut res, ParseOptions::default().max_depth(2)).unwrap();
764        let vec = res.json;
765        assert_eq!(vec.len(), 4);
766        assert_eq!(vec[0].pointer.pointer, "/aaa");
767        assert_eq!(vec[0].pointer.value_type, ValueType::Number);
768        assert_eq!(vec[1].pointer.pointer, "/skills");
769        assert_eq!(vec[1].pointer.value_type, ValueType::Array(2));
770        assert_eq!(vec[2].pointer.pointer, "/skills/1"); // there is a swap remove
771        assert_eq!(vec[2].pointer.value_type, ValueType::Object(false, 0));
772        assert!(vec[3].value.is_some());
773        assert_eq!(vec[3].pointer.pointer, "/skills/0");
774        assert_eq!(vec[3].pointer.value_type, ValueType::Object(false, 0));
775        assert!(vec[3].value.is_some());
776
777
778        let vec = JSONParser::parse(json, ParseOptions::default().max_depth(2)).unwrap().json;
779        assert_eq!(vec.len(), 4);
780        assert_eq!(vec[0].pointer.pointer, "/aaa");
781        assert_eq!(vec[0].pointer.value_type, ValueType::Number);
782        assert_eq!(vec[1].pointer.pointer, "/skills");
783        assert_eq!(vec[1].pointer.value_type, ValueType::Array(2));
784        assert_eq!(vec[2].pointer.pointer, "/skills/0");
785        assert_eq!(vec[2].pointer.value_type, ValueType::Object(false, 0));
786        assert!(vec[3].value.is_some());
787        assert_eq!(vec[3].pointer.pointer, "/skills/1");
788        assert_eq!(vec[3].pointer.value_type, ValueType::Object(false, 0));
789        assert!(vec[3].value.is_some());
790
791        //
792        let mut res = JSONParser::parse(json, ParseOptions::default().max_depth(2)).unwrap();
793        JSONParser::change_depth(&mut res, ParseOptions::default().max_depth(3)).unwrap();
794        let vec = res.json;
795        assert_eq!(vec.len(), 13);
796        assert_eq!(vec[0].pointer.pointer, "/aaa");
797        assert_eq!(vec[0].pointer.value_type, ValueType::Number);
798        assert_eq!(vec[1].pointer.pointer, "/skills");
799        assert_eq!(vec[1].pointer.value_type, ValueType::Array(2));
800        assert_eq!(vec[2].pointer.pointer, "/skills/0");
801        assert_eq!(vec[2].pointer.value_type, ValueType::Object(true, 3));
802        assert!(vec[2].value.is_some());
803        assert_eq!(vec[4].pointer.pointer, "/skills/0/description");
804        assert_eq!(vec[4].pointer.value_type, ValueType::String);
805        assert_eq!(vec[5].pointer.pointer, "/skills/0/id");
806        assert_eq!(vec[5].pointer.value_type, ValueType::Number);
807        assert_eq!(vec[6].pointer.pointer, "/skills/0/name");
808        assert_eq!(vec[6].pointer.value_type, ValueType::String);
809        assert_eq!(vec[3].pointer.pointer, "/skills/1");
810        assert_eq!(vec[3].pointer.value_type, ValueType::Object(true, 6));
811        assert!(vec[3].value.is_some());
812        assert_eq!(vec[7].pointer.pointer, "/skills/1/description");
813        assert_eq!(vec[7].pointer.value_type, ValueType::String);
814        assert_eq!(vec[8].pointer.pointer, "/skills/1/id");
815        assert_eq!(vec[8].pointer.value_type, ValueType::Number);
816        assert_eq!(vec[9].pointer.pointer, "/skills/1/name");
817        assert_eq!(vec[9].pointer.value_type, ValueType::String);
818        assert_eq!(vec[10].pointer.pointer, "/skills/1/basicSkillPerLevel");
819        assert_eq!(vec[10].pointer.value_type, ValueType::Array(1));
820        assert_eq!(vec[11].pointer.pointer, "/skills/1/bonusToSelf");
821        assert_eq!(vec[11].pointer.value_type, ValueType::Array(1));
822        assert_eq!(vec[12].pointer.pointer, "/skills/1/requires");
823        assert_eq!(vec[12].pointer.value_type, ValueType::Object(false, 0));
824
825
826        let vec = JSONParser::parse(json, ParseOptions::default().max_depth(3)).unwrap().json;
827        assert_eq!(vec.len(), 13);
828        assert_eq!(vec[0].pointer.pointer, "/aaa");
829        assert_eq!(vec[0].pointer.value_type, ValueType::Number);
830        assert_eq!(vec[1].pointer.pointer, "/skills");
831        assert_eq!(vec[1].pointer.value_type, ValueType::Array(2));
832        assert_eq!(vec[2].pointer.pointer, "/skills/0");
833        assert_eq!(vec[2].pointer.value_type, ValueType::Object(true, 3));
834        assert!(vec[2].value.is_some());
835        assert_eq!(vec[3].pointer.pointer, "/skills/0/description");
836        assert_eq!(vec[3].pointer.value_type, ValueType::String);
837        assert_eq!(vec[4].pointer.pointer, "/skills/0/id");
838        assert_eq!(vec[4].pointer.value_type, ValueType::Number);
839        assert_eq!(vec[5].pointer.pointer, "/skills/0/name");
840        assert_eq!(vec[5].pointer.value_type, ValueType::String);
841        assert_eq!(vec[6].pointer.pointer, "/skills/1");
842        assert_eq!(vec[6].pointer.value_type, ValueType::Object(true, 6));
843        assert!(vec[6].value.is_some());
844        assert_eq!(vec[7].pointer.pointer, "/skills/1/description");
845        assert_eq!(vec[7].pointer.value_type, ValueType::String);
846        assert_eq!(vec[8].pointer.pointer, "/skills/1/id");
847        assert_eq!(vec[8].pointer.value_type, ValueType::Number);
848        assert_eq!(vec[9].pointer.pointer, "/skills/1/name");
849        assert_eq!(vec[9].pointer.value_type, ValueType::String);
850        assert_eq!(vec[10].pointer.pointer, "/skills/1/basicSkillPerLevel");
851        assert_eq!(vec[10].pointer.value_type, ValueType::Array(1));
852        assert_eq!(vec[11].pointer.pointer, "/skills/1/bonusToSelf");
853        assert_eq!(vec[11].pointer.value_type, ValueType::Array(1));
854        assert_eq!(vec[12].pointer.pointer, "/skills/1/requires");
855        assert_eq!(vec[12].pointer.value_type, ValueType::Object(false, 0));
856
857
858        let vec = JSONParser::parse(json, ParseOptions::default().max_depth(1).keep_object_raw_data(false)).unwrap().json;
859        assert_eq!(vec.len(), 2);
860        assert_eq!(vec[0].pointer.pointer, "/aaa");
861        assert_eq!(vec[0].pointer.value_type, ValueType::Number);
862        assert_eq!(vec[1].pointer.pointer, "/skills");
863        assert_eq!(vec[1].pointer.value_type, ValueType::Array(1));
864
865        let vec = JSONParser::parse(json, ParseOptions::default().max_depth(2).keep_object_raw_data(false)).unwrap().json;
866        assert_eq!(vec.len(), 4);
867        assert_eq!(vec[0].pointer.pointer, "/aaa");
868        assert_eq!(vec[0].pointer.value_type, ValueType::Number);
869        assert_eq!(vec[1].pointer.pointer, "/skills");
870        assert_eq!(vec[1].pointer.value_type, ValueType::Array(2));
871        assert_eq!(vec[2].pointer.pointer, "/skills/0");
872        assert_eq!(vec[2].pointer.value_type, ValueType::Object(false, 0));
873        assert!(vec[3].value.is_some());
874        assert_eq!(vec[3].pointer.pointer, "/skills/1");
875        assert_eq!(vec[3].pointer.value_type, ValueType::Object(false, 0));
876        assert!(vec[3].value.is_some());
877
878        let vec = JSONParser::parse(json, ParseOptions::default().max_depth(3).keep_object_raw_data(false)).unwrap().json;
879        assert_eq!(vec.len(), 13);
880        assert_eq!(vec[0].pointer.pointer, "/aaa");
881        assert_eq!(vec[0].pointer.value_type, ValueType::Number);
882        assert_eq!(vec[1].pointer.pointer, "/skills");
883        assert_eq!(vec[1].pointer.value_type, ValueType::Array(2));
884        assert_eq!(vec[2].pointer.pointer, "/skills/0");
885        assert_eq!(vec[2].pointer.value_type, ValueType::Object(true, 3));
886        assert!(vec[2].value.is_none());
887        assert_eq!(vec[3].pointer.pointer, "/skills/0/description");
888        assert_eq!(vec[3].pointer.value_type, ValueType::String);
889        assert_eq!(vec[4].pointer.pointer, "/skills/0/id");
890        assert_eq!(vec[4].pointer.value_type, ValueType::Number);
891        assert_eq!(vec[5].pointer.pointer, "/skills/0/name");
892        assert_eq!(vec[5].pointer.value_type, ValueType::String);
893        assert_eq!(vec[6].pointer.pointer, "/skills/1");
894        assert_eq!(vec[6].pointer.value_type, ValueType::Object(true, 6));
895        assert!(vec[6].value.is_none());
896        assert_eq!(vec[7].pointer.pointer, "/skills/1/description");
897        assert_eq!(vec[7].pointer.value_type, ValueType::String);
898        assert_eq!(vec[8].pointer.pointer, "/skills/1/id");
899        assert_eq!(vec[8].pointer.value_type, ValueType::Number);
900        assert_eq!(vec[9].pointer.pointer, "/skills/1/name");
901        assert_eq!(vec[9].pointer.value_type, ValueType::String);
902        assert_eq!(vec[10].pointer.pointer, "/skills/1/basicSkillPerLevel");
903        assert_eq!(vec[10].pointer.value_type, ValueType::Array(1));
904        assert_eq!(vec[11].pointer.pointer, "/skills/1/bonusToSelf");
905        assert_eq!(vec[11].pointer.value_type, ValueType::Array(1));
906        assert_eq!(vec[12].pointer.pointer, "/skills/1/requires");
907        assert_eq!(vec[12].pointer.value_type, ValueType::Object(false, 0));
908
909
910        let vec = JSONParser::parse(json, ParseOptions::default().max_depth(1).start_parse_at("/skills".to_string())).unwrap().json;
911        assert_eq!(vec.len(), 3);
912        assert_eq!(vec[0].pointer.pointer, "/skills");
913        assert_eq!(vec[0].pointer.value_type, ValueType::Array(2));
914        assert_eq!(vec[1].pointer.pointer, "/skills/0");
915        assert_eq!(vec[1].pointer.value_type, ValueType::Object(false, 0));
916        assert_eq!(vec[2].pointer.pointer, "/skills/1");
917        assert_eq!(vec[2].pointer.value_type, ValueType::Object(false, 0));
918
919        let vec = JSONParser::parse(json, ParseOptions::default().max_depth(3).start_parse_at("/skills".to_string()).parse_array(false)).unwrap().json;
920        assert_eq!(vec.len(), 13);
921        println!("{:?}", vec);
922
923
924        let mut res = JSONParser::parse(json, ParseOptions::default().start_parse_at("/skills".to_string()).max_depth(1)).unwrap();
925        JSONParser::change_depth(&mut res, ParseOptions::default().start_parse_at("/skills".to_string()).max_depth(3).parse_array(false)).unwrap();
926        let vec = res.json;
927        println!("{:?}", vec);
928        assert_eq!(vec.len(), 13);
929    }
930
931    #[test]
932    fn change_depth() {
933        let json = r#"
934        {"skills":[{"afterCastActDelay":2000,"description":"MagnumBreak","duration2":10000,"element":"Fire","damageType":"Single","hitCount":1,"id":7,"knockback":2,"maxLevel":10,"name":"SM_MAGNUM","targetType":"Self","type":"Weapon","splashAreaPerLevel":[{"area":2,"level":1},{"area":2,"level":2},{"area":2,"level":3},{"area":2,"level":4},{"area":2,"level":5},{"area":2,"level":6},{"area":2,"level":7},{"area":2,"level":8},{"area":2,"level":9},{"area":2,"level":10},{"area":4,"level":11}],"copyflags":{"plagiarism":true,"reproduce":true},"damageflags":{"splash":true},"flags":{"targetTrap":true},"requires":{"spcost":30,"hpcostPerLevel":[{"amount":20,"level":1},{"amount":20,"level":2},{"amount":19,"level":3},{"amount":19,"level":4},{"amount":18,"level":5},{"amount":18,"level":6},{"amount":17,"level":7},{"amount":17,"level":8},{"amount":16,"level":9},{"amount":16,"level":10}]},"aoesize":"5x5square1------+++--+++--+++------","dmgAtkPerLevel":[{"level":1,"value":1.2},{"level":2,"value":1.4},{"level":3,"value":1.6},{"level":4,"value":1.8},{"level":5,"value":2},{"level":6,"value":2.2},{"level":7,"value":2.4},{"level":8,"value":2.6},{"level":9,"value":2.8},{"level":10,"value":3}],"dmgOuterPerLevel":[{"level":1,"value":0.7},{"level":2,"value":0.9},{"level":3,"value":1.1},{"level":4,"value":1.3},{"level":5,"value":1.5},{"level":6,"value":1.7},{"level":7,"value":1.9},{"level":8,"value":2.1},{"level":9,"value":2.3},{"level":10,"value":2.5}],"dmgWaves":1,"knockbackPerLevel":[{"level":1,"value":2},{"level":2,"value":2},{"level":3,"value":2},{"level":4,"value":2},{"level":5,"value":2},{"level":6,"value":2},{"level":7,"value":2},{"level":8,"value":2},{"level":9,"value":2},{"level":10,"value":2}],"bonusToSelf":[{"level":1,"value":{"bonus":"AccuracyPercentage","value":10}},{"level":2,"value":{"bonus":"AccuracyPercentage","value":20}},{"level":3,"value":{"bonus":"AccuracyPercentage","value":30}},{"level":4,"value":{"bonus":"AccuracyPercentage","value":40}},{"level":5,"value":{"bonus":"AccuracyPercentage","value":50}},{"level":6,"value":{"bonus":"AccuracyPercentage","value":60}},{"level":7,"value":{"bonus":"AccuracyPercentage","value":70}},{"level":8,"value":{"bonus":"AccuracyPercentage","value":80}},{"level":9,"value":{"bonus":"AccuracyPercentage","value":90}},{"level":10,"value":{"bonus":"AccuracyPercentage","value":100}}]}]}
935        "#;
936        let mut res = JSONParser::parse(json, ParseOptions::default().start_parse_at("/skills".to_string()).parse_array(false).max_depth(1)).unwrap();
937        let vec = &res.json;
938        assert_eq!(vec.len(), 2);
939        JSONParser::change_depth(&mut res, ParseOptions::default().start_parse_at("/skills".to_string()).max_depth(2).parse_array(false)).unwrap();
940        let vec = &res.json;
941        // vec.iter().for_each(|e| println!("{} {} {}", e.pointer.pointer, e.pointer.depth, e.value.is_some()));
942        assert_eq!(vec.len(), 25);
943        JSONParser::change_depth(&mut res, ParseOptions::default().start_parse_at("/skills".to_string()).max_depth(3).parse_array(false)).unwrap();
944        let vec = &res.json;
945        // vec.iter().for_each(|(k, v)| println!("{} {} {}", k.pointer, k.depth, v.is_some()));
946        assert_eq!(vec.len(), 31);
947    }
948
949    #[test]
950    fn parse_nested_array() {
951        let json = r#"{"panels": {"a":1, "b": ["a1": 11, "tags":[],"type": "type": "dashboard"]},"annotations":{"x":{},"y": {}}}"#;
952        let mut res = JSONParser::parse(json, ParseOptions::default().parse_array(false)).unwrap();
953        let vec = &res.json;
954        // vec.iter().for_each(|v| println!("{:?} -> {:?}", v.pointer, v.value));
955    }
956    #[test]
957    fn parse_grafana_dashboard() {
958        let path = Path::new("examples/grafana.json");
959        let mut json = fs::read_to_string(path).unwrap();
960        let mut res = JSONParser::parse(json.as_str(), ParseOptions::default().start_parse_at("/panels".to_string()).parse_array(false)).unwrap();
961        let vec = &res.json;
962        vec.iter().for_each(|p| println!("{:?}", p));
963        assert_eq!(vec[res.started_parsing_at_index_start].pointer.pointer.as_str(), "/panels");
964        assert!(vec[res.started_parsing_at_index_end].pointer.pointer.as_str().starts_with("/panels"));
965        // vec.iter().for_each(|v| println!("{:?} -> {:?}", v.pointer, v.value));
966    }
967    #[test]
968    fn parse_openapi() {
969        let path = Path::new("examples/openapi.json");
970        let mut json = fs::read_to_string(path).unwrap();
971        let mut res = JSONParser::parse(json.as_str(), ParseOptions::default().start_parse_at("/info".to_string()).parse_array(false)).unwrap();
972        let vec = &res.json;
973        // vec.iter().for_each(|p| println!("{:?}", p));
974        assert_eq!(vec.len(), 10);
975        assert_eq!(vec[res.started_parsing_at_index_start].pointer.pointer.as_str(), "/info");
976        assert!(vec[res.started_parsing_at_index_end].pointer.pointer.as_str().starts_with("/info"));
977        // vec.iter().for_each(|v| println!("{:?} -> {:?}", v.pointer, v.value));
978    }
979}