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 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 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 panic!("End of array should not be consumed from there, json probably wrong");
121 }
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 self.lexer.consume_string_until_end_of_object(false);
226 }
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 || (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!(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!(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 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"); 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 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 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 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 }
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 }
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 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 }
979}