fuga_json_seq_parser/
json.rs

1// SAX style JSON parser
2// Copyright 2022 Kenta Ida 
3// SPDX-License-Identifier: MIT
4
5use core::fmt::Display;
6
7use embedded_io::{blocking::Read, Io};
8use heapless::Vec;
9use nom::{
10    branch::alt,
11    bytes::complete::{escaped, is_not, tag},
12    character::complete::{char, one_of},
13    combinator::{cut, map, peek, value, opt},
14    error::{context, ContextError, ErrorKind, ParseError},
15    number::complete::recognize_float_or_exceptions,
16    sequence::{preceded, terminated, pair},
17    IResult,
18};
19
20#[derive(Clone, Copy, Debug, PartialEq)]
21pub enum JsonNode<'a> {
22    StartMap,
23    EndMap,
24    StartArray,
25    EndArray,
26    Key(JsonScalarValue<'a>),
27    Value(JsonScalarValue<'a>),
28}
29
30
31#[cfg_attr(doc, aquamarine::aquamarine)]
32/// ```mermaid
33/// stateDiagram-v2
34/// Start --> End: EOF
35/// Start --> MapStart: '{'
36/// Start --> ArrayStart: '['
37/// MapStart --> MapKey
38/// MapKey --> Pop: '}'
39/// MapKey --> KeyDelimiter: (scalar)
40/// KeyDelimiter --> MapValue: ':'
41/// MapValue --> MapStart: '{'
42/// MapValue --> ArrayStart: '['
43/// MapValue --> MapPairDelimiter: (scalar)
44/// MapPairDelimiter --> Pop: '}'
45/// MapPairDelimiter --> MapKey: ','
46/// ArrayStart --> ArrayValue
47/// ArrayValue --> MapStart: '{'
48/// ArrayValue --> ArrayStart: '['
49/// ArrayValue --> Pop: ']'
50/// ArrayValue --> ArrayValueDelimiter: (scalar)
51/// ArrayValueDelimiter --> Pop: ']'
52/// ArrayValueDelimiter --> ArrayValue: ','
53/// Pop --> (top of state stack)
54/// ```
55#[derive(Clone, Copy, Debug)]
56enum ParserState {
57    Start,
58    StartContinueString,
59    End,
60    MapStart,
61    MapKey,
62    KeyDelimiter,
63    MapValue,
64    MapValueContinueString,
65    MapPairDelimiter,
66    ArrayStart,
67    ArrayValue,
68    ArrayValueContinueString,
69    ArrayValueDelimiter,
70    Pop,
71}
72
73pub struct Parser<const BUFFER_SIZE: usize, const MAX_DEPTH: usize> {
74    state: ParserState,
75    buffer: Vec<u8, BUFFER_SIZE>,
76    state_stack: Vec<ParserState, MAX_DEPTH>,
77    bytes_remaining: Option<usize>,
78    string_offset: usize,
79}
80
81fn from_utf8_possible(bytes: &[u8]) -> (usize, &str) {
82    for length in (0..=bytes.len()).rev() {
83        if let Ok(s) = core::str::from_utf8(&bytes[..length]) {
84            return (length, s);
85        }
86    }
87    (0, "")
88}
89
90fn escaped_str<'a, E: ParseError<&'a str>>(i: &'a str) -> IResult<&'a str, &'a str, E> {
91    escaped(is_not("\"\\"), '\\', one_of("\"n\\"))(i)
92}
93
94fn json_string<'a, E: ParseError<&'a str> + ContextError<&'a str>>(
95    i: &'a str,
96) -> IResult<&'a str, (&'a str, bool), E> {
97    context(
98        "string",
99        preceded(
100            char('\"'), 
101            pair(map(opt(escaped_str), |r| r.unwrap_or("")), map(opt(char('\"')), |r| r.is_some()))
102        ),
103    )(i)
104}
105fn json_string_continuing<'a, E: ParseError<&'a str> + ContextError<&'a str>>(
106    i: &'a str,
107) -> IResult<&'a str, (&'a str, bool), E> {
108    context(
109        "string",
110        pair(escaped_str, map(opt(char('\"')), |r| r.is_some())),
111    )(i)
112}
113fn json_null<'a, E: ParseError<&'a str>>(input: &'a str) -> IResult<&'a str, (), E> {
114    value((), tag("null"))(input)
115}
116fn json_boolean<'a, E: ParseError<&'a str>>(input: &'a str) -> IResult<&'a str, bool, E> {
117    alt((value(true, tag("true")), value(false, tag("false"))))(input)
118}
119
120#[derive(Clone, Copy, Debug, PartialEq)]
121pub enum JsonScalarValue<'a> {
122    Null,
123    Boolean(bool),
124    String(&'a str),
125    ContinuingString(&'a str, usize, bool),
126    Number(JsonNumber),
127}
128impl<'a> Display for JsonScalarValue<'a> {
129    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
130        match self {
131            Self::Null => write!(f, "null"),
132            Self::Boolean(v) => write!(f, "{}", v),
133            Self::String(v) => write!(f, "\"{}\"", v),
134            Self::ContinuingString(v, offset, terminated) => match (offset, terminated) {
135                (0, false) => write!(f, "\"{}", v),
136                (0, true) => write!(f, "\"{}\"", v),
137                (_, false) => write!(f, "{}", v),
138                (_, true) => write!(f, "{}\"", v),
139            },
140            Self::Number(v) => write!(f, "{}", v),
141        }
142    }
143}
144
145#[derive(Clone, Copy, Debug, PartialEq)]
146pub enum JsonNumber {
147    I32(i32),
148    U32(u32),
149    I64(i64),
150    U64(u64),
151    F32(f32),
152    F64(f64),
153}
154impl Display for JsonNumber {
155    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
156        match self {
157            Self::I32(n) => write!(f, "{}", n),
158            Self::U32(n) => write!(f, "{}", n),
159            Self::I64(n) => write!(f, "{}", n),
160            Self::U64(n) => write!(f, "{}", n),
161            Self::F32(n) => write!(f, "{}", n),
162            Self::F64(n) => write!(f, "{}", n),
163        }
164    }
165}
166
167impl JsonNumber {
168    pub fn try_parse(s: &str) -> Result<JsonNumber, ()> {
169        s.parse::<i32>()
170            .map(|v| JsonNumber::I32(v))
171            .or_else(|_| s.parse::<u32>().map(|v| JsonNumber::U32(v)))
172            .or_else(|_| s.parse::<i64>().map(|v| JsonNumber::I64(v)))
173            .or_else(|_| s.parse::<u64>().map(|v| JsonNumber::U64(v)))
174            .or_else(|_| s.parse::<f32>().map(|v| JsonNumber::F32(v)))
175            .or_else(|_| s.parse::<f64>().map(|v| JsonNumber::F64(v)))
176            .map_err(|_| ())
177    }
178}
179
180impl Into<f32> for JsonNumber {
181    fn into(self) -> f32 {
182        match self {
183            Self::I32(n) => n as f32,
184            Self::U32(n) => n as f32,
185            Self::I64(n) => n as f32,
186            Self::U64(n) => n as f32,
187            Self::F32(n) => n as f32,
188            Self::F64(n) => n as f32,
189        }
190    }
191}
192impl Into<f64> for JsonNumber {
193    fn into(self) -> f64 {
194        match self {
195            Self::I32(n) => n as f64,
196            Self::U32(n) => n as f64,
197            Self::I64(n) => n as f64,
198            Self::U64(n) => n as f64,
199            Self::F32(n) => n as f64,
200            Self::F64(n) => n as f64,
201        }
202    }
203}
204
205fn json_scalar_value<'a, E: ParseError<&'a str> + ContextError<&'a str>>(
206    _is_eof: bool,
207) -> impl FnMut(&'a str) -> IResult<&'a str, JsonScalarValue, E> {
208    alt((
209        map(json_string, |(s, terminated)| if terminated { JsonScalarValue::String(s) } else { JsonScalarValue::ContinuingString(s, 0, false) }),
210        map(json_boolean, |b| JsonScalarValue::Boolean(b)),
211        map(json_null, |_| JsonScalarValue::Null),
212        terminated(
213            |i| {
214                recognize_float_or_exceptions(i).and_then(|p| {
215                    JsonNumber::try_parse(p.1)
216                        .map(|n| (p.0, JsonScalarValue::Number(n)))
217                        .or(Err(nom::Err::Failure(E::from_error_kind(
218                            i,
219                            ErrorKind::Float,
220                        ))))
221                })
222            },
223            peek(one_of(",]} \t\n\0")),
224        ),
225    ))
226}
227
228#[derive(Debug)]
229pub enum ParserError<InputError, CallbackError> {
230    InputError(InputError),
231    Fail(nom::error::ErrorKind),
232    Callback(CallbackError),
233    ValueTooLong,
234}
235impl<InputError, CallbackError> From<InputError> for ParserError<InputError, CallbackError> {
236    fn from(err: InputError) -> Self {
237        Self::InputError(err)
238    }
239}
240
241pub enum ParserCallbackAction {
242    Nothing,
243    End,
244}
245
246impl<const BUFFER_SIZE: usize, const MAX_DEPTH: usize> Parser<BUFFER_SIZE, MAX_DEPTH> {
247    pub const fn new() -> Self {
248        Self {
249            state: ParserState::Start,
250            buffer: Vec::new(),
251            state_stack: Vec::new(),
252            bytes_remaining: None,
253            string_offset: 0,
254        }
255    }
256
257    pub fn set_bytes_remaining(&mut self, bytes_remaining: Option<usize>) {
258        self.bytes_remaining = bytes_remaining;
259    }
260
261    pub fn parse<I: Read, F, CallbackError>(
262        &mut self,
263        reader: &mut I,
264        mut callback: F,
265    ) -> Result<bool, ParserError<I::Error, CallbackError>>
266    where
267        F: for<'node> FnMut(JsonNode<'node>) -> Result<ParserCallbackAction, CallbackError>,
268    {
269        loop {
270            // Fill buffer.
271            let bytes_in_buffer = self.buffer.len();
272            unsafe {
273                let capacity = self.buffer.capacity();
274                self.buffer.set_len(capacity);
275            }
276            let bytes_written = reader.read(&mut self.buffer[bytes_in_buffer..])?;
277            unsafe { self.buffer.set_len(bytes_in_buffer + bytes_written) };
278
279            // Update number of bytes remaining in the stream.
280            self.bytes_remaining = self
281                .bytes_remaining
282                .and_then(|bytes_remaining| Some(bytes_remaining - bytes_written));
283            // Checks if all data in the stream is read into the buffer or not.
284            let is_eof = match self.bytes_remaining {
285                Some(0) => true,
286                Some(_) => {
287                    if !self.buffer.is_full() && bytes_written == 0 {
288                        // Some bytes remaining in the stream, but at this time there are no new data.
289                        break Ok(false);
290                    }
291                    false
292                },
293                _ => bytes_written == 0,    // If the stream length is indeterminate, check number of bytes read to detect end of stream. 
294            };
295            // Put EOF marker at the last of the buffer if there are no data exists in the stream.
296            if is_eof && !self.buffer.is_full() {
297                match self.buffer.last() {
298                    Some(0) => {}
299                    _ => {
300                        self.buffer.push(0).unwrap();
301                    }
302                }
303            }
304
305            // Check if currently in the middle of continuing string or not.
306            let is_string_continuing = match &self.state {
307                ParserState::StartContinueString => true,
308                ParserState::MapValueContinueString => true,
309                ParserState::ArrayValueContinueString => true,
310                _ => false,
311            };
312
313            let (_bytes_consumed, input) = from_utf8_possible(&self.buffer);
314            // Trim the first whitespaces in the buffer if current state is not the middle of continuing string.
315            let trimmed = if is_string_continuing { input } else { input.trim_start() };
316
317            // Trim whitespaces and retry to refill the buffer.
318            if input.len() != trimmed.len() {
319                // Consume trimmed bytes
320                let bytes_consumed = input.as_bytes().len() - trimmed.as_bytes().len();
321                let buffer_len = self.buffer.len();
322                if bytes_consumed > 0 {
323                    // Discard the consumed data from the buffer.
324                    self.buffer.copy_within(bytes_consumed..buffer_len, 0);
325                    self.buffer.truncate(buffer_len - bytes_consumed);
326                }
327                break Ok(false);
328            }
329            let result: IResult<_, _, (&str, ErrorKind)> = match self.state {
330                ParserState::Start => alt((
331                    // Initial state.
332                    value((ParserState::End, None), char('\0')),
333                    value((ParserState::MapStart, None), char('{')),
334                    value((ParserState::ArrayStart, None), char('[')),
335                    map(json_scalar_value(is_eof), |v| {
336                        let next_state = match &v {
337                            JsonScalarValue::ContinuingString(_, _, _) => ParserState::StartContinueString,
338                            _ => ParserState::Start,
339                        };
340                        (next_state, Some(v))
341                    }),
342                ))(trimmed),
343                ParserState::StartContinueString => map(json_string_continuing, |(s, terminated)| (if terminated { ParserState::Start } else { ParserState::StartContinueString }, Some(JsonScalarValue::ContinuingString(s, self.string_offset, terminated))))(trimmed),
344                ParserState::MapStart => Ok((trimmed, (ParserState::MapKey, None))),
345                ParserState::MapKey => alt((
346                    // Map key
347                    value((ParserState::Pop, None), char('}')), // end of map.
348                    map(cut(json_scalar_value(is_eof)), |v| {
349                        (ParserState::KeyDelimiter, Some(v))
350                    }),
351                ))(trimmed),
352                ParserState::KeyDelimiter =>
353                // Map key is processed, waiting key-value delimiter ':'
354                {
355                    value((ParserState::MapValue, None), char(':'))(trimmed)
356                }
357                ParserState::MapValue => alt((
358                    // Map value
359                    value((ParserState::MapStart, None), char('{')),
360                    value((ParserState::ArrayStart, None), char('[')),
361                    map(json_scalar_value(is_eof), |v| {
362                        let next_state = match &v {
363                            JsonScalarValue::ContinuingString(_, _, _) => ParserState::MapValueContinueString,
364                            _ => ParserState::MapPairDelimiter,
365                        };
366                        (next_state, Some(v))
367                    }),
368                ))(trimmed),
369                ParserState::MapValueContinueString => map(json_string_continuing, |(s, terminated)| (if terminated { ParserState::MapPairDelimiter } else { ParserState::MapValueContinueString }, Some(JsonScalarValue::ContinuingString(s, self.string_offset, terminated))))(trimmed),
370                ParserState::MapPairDelimiter => alt((
371                    value((ParserState::Pop, None), char('}')),
372                    value((ParserState::MapKey, None), char(',')),
373                ))(trimmed),
374                ParserState::ArrayStart => Ok((trimmed, (ParserState::ArrayValue, None))),
375                ParserState::ArrayValue => alt((
376                    value((ParserState::MapStart, None), char('{')),
377                    value((ParserState::ArrayStart, None), char('[')),
378                    value((ParserState::Pop, None), char(']')),
379                    map(json_scalar_value(is_eof), |v| {
380                        let next_state = match &v {
381                            JsonScalarValue::ContinuingString(_, _, _) => ParserState::ArrayValueContinueString,
382                            _ => ParserState::ArrayValueDelimiter,
383                        };
384                        (next_state, Some(v))
385                    }),
386                ))(trimmed),
387                ParserState::ArrayValueContinueString => map(json_string_continuing, |(s, terminated)| (if terminated { ParserState::ArrayValueDelimiter } else { ParserState::ArrayValueContinueString }, Some(JsonScalarValue::ContinuingString(s, self.string_offset, terminated))))(trimmed),
388                ParserState::ArrayValueDelimiter => alt((
389                    value((ParserState::Pop, None), char(']')),
390                    value((ParserState::ArrayValue, None), char(',')),
391                ))(trimmed),
392                ParserState::Pop => {
393                    let state = self.state_stack.pop().unwrap();
394                    Ok((trimmed, (state, None)))
395                }
396                ParserState::End => {
397                    break Ok(true);
398                }
399            };
400            match result {
401                Ok((remaining, (new_state, value))) => {
402                    let callback_result = match (self.state, new_state) {
403                        (state, ParserState::ArrayStart) => {
404                            let pop_state = match state {
405                                ParserState::ArrayValue => ParserState::ArrayValueDelimiter,
406                                ParserState::MapValue => ParserState::MapPairDelimiter,
407                                state => state,
408                            };
409                            self.state_stack.push(pop_state).unwrap();
410                            callback(JsonNode::StartArray)
411                        }
412                        (state, ParserState::MapStart) => {
413                            let pop_state = match state {
414                                ParserState::ArrayValue => ParserState::ArrayValueDelimiter,
415                                ParserState::MapValue => ParserState::MapPairDelimiter,
416                                state => state,
417                            };
418                            self.state_stack.push(pop_state).unwrap();
419                            callback(JsonNode::StartMap)
420                        }
421                        (ParserState::ArrayValue, ParserState::Pop) => callback(JsonNode::EndArray),
422                        (ParserState::ArrayValueDelimiter, ParserState::Pop) => {
423                            callback(JsonNode::EndArray)
424                        }
425                        (ParserState::MapKey, ParserState::Pop) => callback(JsonNode::EndMap),
426                        (ParserState::MapPairDelimiter, ParserState::Pop) => {
427                            callback(JsonNode::EndMap)
428                        }
429                        (ParserState::MapKey, _) => callback(JsonNode::Key(value.unwrap())),
430                        (_, _) => {
431                            match value {
432                                Some(JsonScalarValue::ContinuingString(string, offset, terminatd)) => {
433                                    // If the value is continuing string, store current offset in string.
434                                    self.string_offset = offset + string.len();
435                                    callback(JsonNode::Value(JsonScalarValue::ContinuingString(string, offset, terminatd)))
436                                },
437                                Some(value) => callback(JsonNode::Value(value)),
438                                _ => Ok(ParserCallbackAction::Nothing),
439                            }
440                        }
441                    };
442                    self.state = new_state;
443                    let bytes_consumed = input.as_bytes().len() - remaining.as_bytes().len();
444                    let buffer_len = self.buffer.len();
445                    if bytes_consumed > 0 {
446                        // Discard the consumed data from the buffer.
447                        self.buffer.copy_within(bytes_consumed..buffer_len, 0);
448                        self.buffer.truncate(buffer_len - bytes_consumed);
449                    }
450                    match callback_result {
451                        Ok(ParserCallbackAction::Nothing) => {}
452                        Ok(ParserCallbackAction::End) => {
453                            self.state = ParserState::End;
454                        }
455                        Err(err) => {
456                            break Err(ParserError::Callback(err));
457                        }
458                    }
459                    continue;
460                }
461                Err(err) => {
462                    match err {
463                        nom::Err::Error((_, kind)) => break Err(ParserError::Fail(kind)),
464                        nom::Err::Failure((_, kind)) => break Err(ParserError::Fail(kind)),
465                        nom::Err::Incomplete(_) => break Err(ParserError::Fail(nom::error::ErrorKind::Eof)),
466                    }
467                }
468            }
469        }
470    }
471}
472
473pub struct BufferReader<'a> {
474    buffer: &'a [u8],
475    position: usize,
476}
477impl<'a> BufferReader<'a> {
478    pub const fn new(buffer: &'a [u8]) -> Self {
479        Self {
480            buffer,
481            position: 0,
482        }
483    }
484}
485impl<'a> Io for BufferReader<'a> {
486    type Error = core::convert::Infallible;
487}
488impl<'a> Read for BufferReader<'a> {
489    fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
490        let bytes_remaining = self.buffer.len() - self.position;
491        let bytes_to_read = bytes_remaining.min(buf.len());
492        buf[..bytes_to_read]
493            .copy_from_slice(&self.buffer[self.position..self.position + bytes_to_read]);
494        self.position += bytes_to_read;
495        Ok(bytes_to_read)
496    }
497}
498
499pub type DefaultParserCallbackResult = Result<ParserCallbackAction, core::convert::Infallible>;
500
501#[cfg(test)]
502mod test {
503    use super::*;
504
505    fn setup_parser<const BUFFER_SIZE: usize, const MAX_DEPTH: usize>(
506        input: &'static str,
507    ) -> (Parser<BUFFER_SIZE, MAX_DEPTH>, BufferReader<'static>) {
508        let mut parser = Parser::new();
509        parser.set_bytes_remaining(Some(input.as_bytes().len())); // In order to parse single number literal correctly, the parser must know about the position of the EOF to detect end of number.
510        (parser, BufferReader::new(input.as_bytes()))
511    }
512    #[test]
513    fn test_parser_empty_string() {
514        let (mut parser, mut input) = setup_parser::<20, 4>("    \"\"");
515        let mut expected = [JsonNode::Value(JsonScalarValue::String(""))].into_iter();
516        for _ in 0..10 {
517            if parser
518                .parse(&mut input, |node| {
519                    assert_eq!(Some(node), expected.next());
520                    Result::<_, core::convert::Infallible>::Ok(ParserCallbackAction::Nothing)
521                })
522                .expect("Parser must not fail.")
523            {
524                break;
525            }
526        }
527        assert_eq!(None, expected.next()); // All expected numbers are detected.
528    }
529    #[test]
530    fn test_parser_single_string() {
531        let (mut parser, mut input) = setup_parser::<20, 4>("    \"    hogeほげ\"");
532        let mut expected = [JsonNode::Value(JsonScalarValue::String("    hogeほげ"))].into_iter();
533        for _ in 0..10 {
534            if parser
535                .parse(&mut input, |node| {
536                    assert_eq!(Some(node), expected.next());
537                    Result::<_, core::convert::Infallible>::Ok(ParserCallbackAction::Nothing)
538                })
539                .expect("Parser must not fail.")
540            {
541                break;
542            }
543        }
544        assert_eq!(None, expected.next()); // All expected numbers are detected.
545    }
546    #[test]
547    fn test_parser_single_continuing_string() {
548        let (mut parser, mut input) = setup_parser::<9, 4>("    \"    hogeほげ\"");
549        // The parser buffer can stores 9 bytes, so the buffer actually contains "    hoge" and the first byte of "ほ", 
550        // but it fails to decode because remaining bytes of "ほ" is not in the buffer.
551        // So the parser returns two ContinuingString below.
552        let mut expected = [
553            JsonNode::Value(JsonScalarValue::ContinuingString("    hoge", 0, false)),
554            JsonNode::Value(JsonScalarValue::ContinuingString("ほげ", 8, true)),
555        ].into_iter();
556        for _ in 0..10 {
557            if parser
558                .parse(&mut input, |node| {
559                    assert_eq!(Some(node), expected.next());
560                    Result::<_, core::convert::Infallible>::Ok(ParserCallbackAction::Nothing)
561                })
562                .expect("Parser must not fail.")
563            {
564                break;
565            }
566        }
567        assert_eq!(None, expected.next()); // All expected numbers are detected.
568    }
569    #[test]
570    fn test_parser_single_null() {
571        let (mut parser, mut input) = setup_parser::<128, 4>("  null");
572        parser
573            .parse(&mut input, |node| match node {
574                JsonNode::Value(JsonScalarValue::Null) => {
575                    DefaultParserCallbackResult::Ok(ParserCallbackAction::Nothing)
576                }
577                v => panic!("unexpected JSON node - {:?}", v),
578            })
579            .expect("Parser must not fail.");
580    }
581    #[test]
582    fn test_parser_single_number() {
583        let (mut parser, mut input) = setup_parser::<128, 4>("123.0");
584        parser
585            .parse(&mut input, |node| match node {
586                JsonNode::Value(JsonScalarValue::Number(JsonNumber::F32(123.0))) => {
587                    DefaultParserCallbackResult::Ok(ParserCallbackAction::Nothing)
588                }
589                v => panic!("unexpected JSON node - {:?}", v),
590            })
591            .expect("Parser must not fail.");
592    }
593    #[test]
594    fn test_parser_empty_map() {
595        let (mut parser, mut input) = setup_parser::<128, 4>("{}");
596        let mut expected = [JsonNode::StartMap, JsonNode::EndMap].into_iter();
597        parser
598            .parse(&mut input, |node| {
599                assert_eq!(Some(node), expected.next());
600                DefaultParserCallbackResult::Ok(ParserCallbackAction::Nothing)
601            })
602            .expect("Parser must not fail.");
603        assert_eq!(None, expected.next()); // All expected numbers are detected.
604    }
605    #[test]
606    fn test_parser_empty_array() {
607        let (mut parser, mut input) = setup_parser::<128, 4>("[]");
608        let mut expected = [JsonNode::StartArray, JsonNode::EndArray].into_iter();
609        parser
610            .parse(&mut input, |node| {
611                assert_eq!(Some(node), expected.next());
612                DefaultParserCallbackResult::Ok(ParserCallbackAction::Nothing)
613            })
614            .expect("Parser must not fail.");
615        assert_eq!(None, expected.next()); // All expected numbers are detected.
616    }
617
618    #[test]
619    fn test_parser_nested_array() {
620        let (mut parser, mut input) = setup_parser::<6, 4>(
621            "[[  ],
622            [[]]]",
623        );
624        let mut expected = [
625            JsonNode::StartArray,
626            JsonNode::StartArray,
627            JsonNode::EndArray,
628            JsonNode::StartArray,
629            JsonNode::StartArray,
630            JsonNode::EndArray,
631            JsonNode::EndArray,
632            JsonNode::EndArray,
633        ]
634        .into_iter();
635        for _ in 0..10 {
636            if parser
637                .parse(&mut input, |node| {
638                    assert_eq!(Some(node), expected.next());
639                    DefaultParserCallbackResult::Ok(ParserCallbackAction::Nothing)
640                })
641                .expect("Parser must not fail.")
642            {
643                break;
644            }
645        }
646        assert_eq!(None, expected.next()); // All expected numbers are detected.
647    }
648    #[test]
649    fn test_parser_array_single_string() {
650        let (mut parser, mut input) = setup_parser::<6, 4>(
651            "[  \t
652         \"hoge\"]",
653        );
654        let mut expected = [
655            JsonNode::StartArray,
656            JsonNode::Value(JsonScalarValue::String("hoge")),
657            JsonNode::EndArray,
658        ]
659        .into_iter();
660        for _ in 0..10 {
661            if parser
662                .parse(&mut input, |node| {
663                    assert_eq!(Some(node), expected.next());
664                    DefaultParserCallbackResult::Ok(ParserCallbackAction::Nothing)
665                })
666                .expect("Parser must not fail.")
667            {
668                break;
669            }
670        }
671        assert_eq!(None, expected.next()); // All expected numbers are detected.
672    }
673    #[test]
674    fn test_parser_array_multiple_values() {
675        let (mut parser, mut input) = setup_parser::<8, 4>(
676            "[  \t
677         \"hoge\",-10.0, true, null, 
678         \"  fuga\"]",
679        );
680        let mut expected = [
681            JsonNode::StartArray,
682            JsonNode::Value(JsonScalarValue::String("hoge")),
683            JsonNode::Value(JsonScalarValue::Number(JsonNumber::F32(-10.0))),
684            JsonNode::Value(JsonScalarValue::Boolean(true)),
685            JsonNode::Value(JsonScalarValue::Null),
686            JsonNode::Value(JsonScalarValue::String("  fuga")),
687            JsonNode::EndArray,
688        ]
689        .into_iter();
690        for _ in 0..10 {
691            if parser
692                .parse(&mut input, |node| {
693                    assert_eq!(Some(node), expected.next());
694                    DefaultParserCallbackResult::Ok(ParserCallbackAction::Nothing)
695                })
696                .expect("Parser must not fail.")
697            {
698                break;
699            }
700        }
701        assert_eq!(None, expected.next()); // All expected numbers are detected.
702    }
703
704    #[test]
705    fn test_parser_map_multiple_values() {
706        let (mut parser, mut input) = setup_parser::<8, 4>(
707            "{  \t
708         \"hoge\":-10.0, true: null, 
709         \"  fuga\": \"piyo\"}",
710        );
711        let mut expected = [
712            JsonNode::StartMap,
713            JsonNode::Key(JsonScalarValue::String("hoge")),
714            JsonNode::Value(JsonScalarValue::Number(JsonNumber::F32(-10.0))),
715            JsonNode::Key(JsonScalarValue::Boolean(true)),
716            JsonNode::Value(JsonScalarValue::Null),
717            JsonNode::Key(JsonScalarValue::String("  fuga")),
718            JsonNode::Value(JsonScalarValue::String("piyo")),
719            JsonNode::EndMap,
720        ]
721        .into_iter();
722        for _ in 0..10 {
723            if parser
724                .parse(&mut input, |node| {
725                    assert_eq!(Some(node), expected.next());
726                    DefaultParserCallbackResult::Ok(ParserCallbackAction::Nothing)
727                })
728                .expect("Parser must not fail.")
729            {
730                break;
731            }
732        }
733        assert_eq!(None, expected.next()); // All expected numbers are detected.
734    }
735
736    #[test]
737    fn test_parser_nested_map_array() {
738        let (mut parser, mut input) = setup_parser::<8, 4>(
739            "{\"array\":[], \"array2\":[[1, 2,], 3], \"map\": {\"nested\": null}}",
740        );
741        let mut expected = [
742            JsonNode::StartMap,
743            JsonNode::Key(JsonScalarValue::String("array")),
744            JsonNode::StartArray,
745            JsonNode::EndArray,
746            JsonNode::Key(JsonScalarValue::String("array2")),
747            JsonNode::StartArray,
748            JsonNode::StartArray,
749            JsonNode::Value(JsonScalarValue::Number(JsonNumber::I32(1))),
750            JsonNode::Value(JsonScalarValue::Number(JsonNumber::I32(2))),
751            JsonNode::EndArray,
752            JsonNode::Value(JsonScalarValue::Number(JsonNumber::I32(3))),
753            JsonNode::EndArray,
754            JsonNode::Key(JsonScalarValue::String("map")),
755            JsonNode::StartMap,
756            JsonNode::Key(JsonScalarValue::String("nested")),
757            JsonNode::Value(JsonScalarValue::Null),
758            JsonNode::EndMap,
759            JsonNode::EndMap,
760        ]
761        .into_iter();
762        for _ in 0..10 {
763            if parser
764                .parse(&mut input, |node| {
765                    assert_eq!(Some(node), expected.next());
766                    DefaultParserCallbackResult::Ok(ParserCallbackAction::Nothing)
767                })
768                .expect("Parser must not fail.")
769            {
770                break;
771            }
772        }
773        assert_eq!(None, expected.next()); // All expected numbers are detected.
774    }
775}
fuga_json_seq_parser/json.rs

fuga_json_seq_parser/
json.rs
