jsonprima 0.3.0

RFC 8259 compliant JSON validator in Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

use crate::error::{Error, ErrorType};
use crate::json::{ParseTokens, StackTokens, JSON};
use crate::scanner::Scanner;

// Helper macro to test if the next entry in scanner
// match expected_character.
macro_rules! next {
  ($json_document:ident, $scanner:ident, $expected_character:expr, $index_start:expr) => {
    let result = $scanner
      .next()
      .ok_or_else(|| {
        // No more graphemes to parse.
        let err = Error::new(ErrorType::E104, $index_start, $scanner.current().index + 1);

        $json_document.errors.push(err);
        ()
      })
      .and_then(|(next_index, next_character)| {
        if next_character != $expected_character {
          // Invalid character in literal name.
          let err = Error::new(ErrorType::E105, $index_start, next_index + 1);
          $json_document.errors.push(err);
          Err(())
        } else {
          Ok(())
        }
      });

    if result.is_err() {
      return result;
    }
  };
}

fn validate(json_document: &mut JSON, scanner: &mut Scanner) -> Result<(), ()> {
  // Save the position of the first character.
  // This will help us set a range that will highlight the whole incorrect value
  // in case of an error.
  //
  // Example:
  //
  // ```rust
  // // Invalid `falsA` root value in JSON document.
  // let text: &str = "falsA";
  // let errors = jsonprima::validate(&text);
  // println!("{:#?}", errors); // => [("E104", 0, 5)]
  // ```
  let index_start = scanner.current().index;

  next!(json_document, scanner, 'a', index_start);
  next!(json_document, scanner, 'l', index_start);
  next!(json_document, scanner, 's', index_start);
  next!(json_document, scanner, 'e', index_start);

  // If none of the macro invocations returned error,
  // we have successfully validate the value.
  json_document.last_parsed_token = Some(ParseTokens::False);

  Ok(())
}

pub fn validate_false(json_document: &mut JSON, scanner: &mut Scanner) -> Result<(), ()> {
  match &json_document.last_parsed_token {
    Some(last_parsed_token) => match last_parsed_token {
      ParseTokens::BeginArray => validate(json_document, scanner),

      ParseTokens::ValueSeparator => {
        if json_document.stack.last().unwrap() == &StackTokens::BeginObject {
          // Invalid use of false as object name.
          let last_parsed_index = scanner.current().index;
          let err = Error::new(ErrorType::E139, last_parsed_index, last_parsed_index + 1);
          json_document.errors.push(err);

          Err(())
        } else {
          validate(json_document, scanner)
        }
      }

      ParseTokens::BeginObject => {
        // Invalid use of false as object name.
        let last_parsed_index = scanner.current().index;
        let err = Error::new(ErrorType::E139, last_parsed_index, last_parsed_index + 1);
        json_document.errors.push(err);

        Err(())
      }

      ParseTokens::NameSeparator => {
        json_document.stack.pop();
        json_document.object_has_valid_member = true;

        validate(json_document, scanner)
      }

      // Illegal character "f" after structural token. Expected comma or colon.
      _ => {
        let last_parsed_index = scanner.current().index;
        let err = Error::new(ErrorType::E107, last_parsed_index, last_parsed_index + 1);
        json_document.errors.push(err);

        Err(())
      }
    },

    None => {
      json_document.root_value_parsed = true;
      validate(json_document, scanner)
    }
  }
}