feat: add more conditional parse options

Author: dsherret

README.md

@@ -90,6 +90,9 @@ let json_value = parse_to_value(text, &ParseOptions {
   allow_comments: false,
   allow_loose_object_property_names: false,
   allow_trailing_commas: false,
+  allow_single_quoted_strings: false,
+  allow_hexadecimal_numbers: false,
+  allow_unary_plus_numbers: false,
 })?;
 ```
 

src/errors.rs

@@ -13,9 +13,12 @@ pub enum ParseErrorKind {
   ExpectedDigitFollowingNegativeSign,
   ExpectedPlusMinusOrDigitInNumberLiteral,
   ExpectedStringObjectProperty,
+  HexadecimalNumbersNotAllowed,
   MultipleRootJsonValues,
+  SingleQuotedStringsNotAllowed,
   String(ParseStringErrorKind),
   TrailingCommasNotAllowed,
+  UnaryPlusNumbersNotAllowed,
   UnexpectedCloseBrace,
   UnexpectedCloseBracket,
   UnexpectedColon,
@@ -53,13 +56,22 @@ impl std::fmt::Display for ParseErrorKind {
       ExpectedStringObjectProperty => {
         write!(f, "Expected string for object property")
       }
+      HexadecimalNumbersNotAllowed => {
+        write!(f, "Hexadecimal numbers are not allowed")
+      }
       MultipleRootJsonValues => {
         write!(f, "Text cannot contain more than one JSON value")
       }
+      SingleQuotedStringsNotAllowed => {
+        write!(f, "Single-quoted strings are not allowed")
+      }
       String(kind) => kind.fmt(f),
       TrailingCommasNotAllowed => {
         write!(f, "Trailing commas are not allowed")
       }
+      UnaryPlusNumbersNotAllowed => {
+        write!(f, "Unary plus on numbers is not allowed")
+      }
       UnexpectedCloseBrace => {
         write!(f, "Unexpected close brace")
       }

src/parse_to_ast.rs

@@ -6,6 +6,7 @@ use super::ast::*;
 use super::common::Range;
 use super::errors::*;
 use super::scanner::Scanner;
+use super::scanner::ScannerOptions;
 use super::tokens::Token;
 use super::tokens::TokenAndRange;
 
@@ -14,11 +15,25 @@ use super::tokens::TokenAndRange;
 /// next token start or end of the file.
 pub type CommentMap<'a> = HashMap<usize, Rc<Vec<Comment<'a>>>>;
 
+/// Strategy for handling comments during parsing.
+///
+/// This enum determines how comments in the JSON/JSONC input are collected
+/// and represented in the resulting abstract syntax tree (AST).
 #[derive(Default, Debug, PartialEq, Clone)]
 pub enum CommentCollectionStrategy {
+  /// Comments are not collected and are effectively ignored during parsing.
   #[default]
   Off,
+  /// Comments are collected and stored separately from the main AST structure.
+  ///
+  /// When this strategy is used, comments are placed in a [`CommentMap`] where
+  /// the key is the previous token end or start of file, or the next token start
+  /// or end of file.
   Separate,
+  /// Comments are collected and treated as tokens within the AST.
+  ///
+  /// When this strategy is used, comments appear alongside other tokens in the
+  /// token stream when `tokens: true` is set in [`CollectOptions`].
   AsTokens,
 }
 
@@ -40,6 +55,12 @@ pub struct ParseOptions {
   pub allow_loose_object_property_names: bool,
   /// Allow trailing commas on object literal and array literal values (defaults to `true`).
   pub allow_trailing_commas: bool,
+  /// Allow single-quoted strings (defaults to `true`).
+  pub allow_single_quoted_strings: bool,
+  /// Allow hexadecimal numbers like 0xFF (defaults to `true`).
+  pub allow_hexadecimal_numbers: bool,
+  /// Allow unary plus sign on numbers like +42 (defaults to `true`).
+  pub allow_unary_plus_numbers: bool,
 }
 
 impl Default for ParseOptions {
@@ -48,6 +69,9 @@ impl Default for ParseOptions {
       allow_comments: true,
       allow_loose_object_property_names: true,
       allow_trailing_commas: true,
+      allow_single_quoted_strings: true,
+      allow_hexadecimal_numbers: true,
+      allow_unary_plus_numbers: true,
     }
   }
 }
@@ -218,7 +242,14 @@ pub fn parse_to_ast<'a>(
   parse_options: &ParseOptions,
 ) -> Result<ParseResult<'a>, ParseError> {
   let mut context = Context {
-    scanner: Scanner::new(text),
+    scanner: Scanner::new(
+      text,
+      &ScannerOptions {
+        allow_single_quoted_strings: parse_options.allow_single_quoted_strings,
+        allow_hexadecimal_numbers: parse_options.allow_hexadecimal_numbers,
+        allow_unary_plus_numbers: parse_options.allow_unary_plus_numbers,
+      },
+    ),
     comments: match collect_options.comments {
       CommentCollectionStrategy::Separate => Some(Default::default()),
       CommentCollectionStrategy::Off | CommentCollectionStrategy::AsTokens => None,
@@ -503,6 +534,30 @@ mod tests {
     );
   }
 
+  #[test]
+  fn strict_should_error_single_quoted_string() {
+    assert_has_strict_error(
+      r#"{ "key": 'value' }"#,
+      "Single-quoted strings are not allowed on line 1 column 10",
+    );
+  }
+
+  #[test]
+  fn strict_should_error_hexadecimal_number() {
+    assert_has_strict_error(
+      r#"{ "key": 0xFF }"#,
+      "Hexadecimal numbers are not allowed on line 1 column 10",
+    );
+  }
+
+  #[test]
+  fn strict_should_error_unary_plus_number() {
+    assert_has_strict_error(
+      r#"{ "key": +42 }"#,
+      "Unary plus on numbers is not allowed on line 1 column 10",
+    );
+  }
+
   #[track_caller]
   fn assert_has_strict_error(text: &str, message: &str) {
     let result = parse_to_ast(
@@ -512,6 +567,9 @@ mod tests {
         allow_comments: false,
         allow_loose_object_property_names: false,
         allow_trailing_commas: false,
+        allow_single_quoted_strings: false,
+        allow_hexadecimal_numbers: false,
+        allow_unary_plus_numbers: false,
       },
     );
     match result {

src/scanner.rs

@@ -14,13 +14,37 @@ pub struct Scanner<'a> {
   char_buffer: Vec<char>,
   current_token: Option<Token<'a>>,
   file_text: &'a str,
+  allow_single_quoted_strings: bool,
+  allow_hexadecimal_numbers: bool,
+  allow_unary_plus_numbers: bool,
 }
 
 const CHAR_BUFFER_MAX_SIZE: usize = 6;
 
+/// Options for the scanner.
+#[derive(Debug)]
+pub struct ScannerOptions {
+  /// Allow single-quoted strings (defaults to `true`).
+  pub allow_single_quoted_strings: bool,
+  /// Allow hexadecimal numbers like 0xFF (defaults to `true`).
+  pub allow_hexadecimal_numbers: bool,
+  /// Allow unary plus sign on numbers like +42 (defaults to `true`).
+  pub allow_unary_plus_numbers: bool,
+}
+
+impl Default for ScannerOptions {
+  fn default() -> Self {
+    Self {
+      allow_single_quoted_strings: true,
+      allow_hexadecimal_numbers: true,
+      allow_unary_plus_numbers: true,
+    }
+  }
+}
+
 impl<'a> Scanner<'a> {
-  /// Creates a new scanner based on the provided text.
-  pub fn new(file_text: &'a str) -> Scanner<'a> {
+  /// Creates a new scanner with specific options.
+  pub fn new(file_text: &'a str, options: &ScannerOptions) -> Scanner<'a> {
     let mut char_iter = file_text.chars();
     let mut char_buffer = Vec::with_capacity(CHAR_BUFFER_MAX_SIZE);
     let current_char = char_iter.next();
@@ -35,6 +59,9 @@ impl<'a> Scanner<'a> {
       char_buffer,
       current_token: None,
       file_text,
+      allow_single_quoted_strings: options.allow_single_quoted_strings,
+      allow_hexadecimal_numbers: options.allow_hexadecimal_numbers,
+      allow_unary_plus_numbers: options.allow_unary_plus_numbers,
     }
   }
 
@@ -72,7 +99,14 @@ impl<'a> Scanner<'a> {
           self.move_next_char();
           Ok(Token::Colon)
         }
-        '\'' | '"' => self.parse_string(),
+        '\'' => {
+          if self.allow_single_quoted_strings {
+            self.parse_string()
+          } else {
+            Err(self.create_error_for_current_token(ParseErrorKind::SingleQuotedStringsNotAllowed))
+          }
+        }
+        '"' => self.parse_string(),
         '/' => match self.peek_char() {
           Some('/') => Ok(self.parse_comment_line()),
           Some('*') => self.parse_comment_block(),
@@ -154,8 +188,13 @@ impl<'a> Scanner<'a> {
   fn parse_number(&mut self) -> Result<Token<'a>, ParseError> {
     let start_byte_index = self.byte_index;
 
-    // handle unary plus or minus
-    if self.is_negative_sign() || self.is_positive_sign() {
+    // handle unary plus and unary minus
+    if self.is_positive_sign() {
+      if !self.allow_unary_plus_numbers {
+        return Err(self.create_error_for_current_token(ParseErrorKind::UnaryPlusNumbersNotAllowed));
+      }
+      self.move_next_char();
+    } else if self.is_negative_sign() {
       self.move_next_char();
     }
 
@@ -164,6 +203,10 @@ impl<'a> Scanner<'a> {
 
       // check for hexadecimal literal (0x or 0X)
       if matches!(self.current_char(), Some('x') | Some('X')) {
+        if !self.allow_hexadecimal_numbers {
+          return Err(self.create_error_for_current_token(ParseErrorKind::HexadecimalNumbersNotAllowed));
+        }
+
         self.move_next_char();
 
         // must have at least one hex digit
@@ -625,7 +668,7 @@ mod tests {
   }
 
   fn assert_has_tokens(text: &str, tokens: Vec<Token>) {
-    let mut scanner = Scanner::new(text);
+    let mut scanner = Scanner::new(text, &Default::default());
     let mut scanned_tokens = Vec::new();
 
     loop {
@@ -640,7 +683,7 @@ mod tests {
   }
 
   fn assert_has_error(text: &str, message: &str) {
-    let mut scanner = Scanner::new(text);
+    let mut scanner = Scanner::new(text, &Default::default());
     let mut error_message = String::new();
 
     loop {