Function parse_to_ast

src/parse_to_ast.rs:244–287

Parses a string containing JSONC to an AST with comments and tokens. # Example ``` use jsonc_parser::CollectOptions; use jsonc_parser::CommentCollectionStrategy; use jsonc_parser::parse_to_ast; use jsonc_parser::ParseOptions; let parse_result = parse_to_ast(r#"{ "test": 5 } // test"#, &CollectOptions { comments: CommentCollectionStrategy::Separate, // include comments in result tokens: true, //

(
  text: &'a str,
  collect_options: &CollectOptions,
  parse_options: &ParseOptions,
)

/// // ...inspect parse_result for value, tokens, and comments here...
/// ```
pub fn parse_to_ast<'a>(
  text: &'a str,
  collect_options: &CollectOptions,
  parse_options: &ParseOptions,
) -> Result<ParseResult<'a>, ParseError> {
  let mut context = Context {
    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,
    },
    current_comments: None,
    last_token_end: 0,
    range_stack: Vec::new(),
    tokens: if collect_options.tokens { Some(Vec::new()) } else { None },
    collect_comments_as_tokens: collect_options.comments == CommentCollectionStrategy::AsTokens,
    allow_comments: parse_options.allow_comments,
    allow_trailing_commas: parse_options.allow_trailing_commas,
    allow_missing_commas: parse_options.allow_missing_commas,
    allow_loose_object_property_names: parse_options.allow_loose_object_property_names,
    maximum_nesting_depth: 512,
  };
  context.scan()?;
  let value = parse_value(&mut context)?;

  if context.scan()?.is_some() {
    return Err(context.create_error(ParseErrorKind::MultipleRootJsonValues));
  }

  debug_assert!(context.range_stack.is_empty());

  Ok(ParseResult {
    comments: context.comments,
    tokens: context.tokens,
    value,
  })
}

fn parse_value<'a>(context: &mut Context<'a>) -> Result<Option<Value<'a>>, ParseError> {
  if context.range_stack.len() > context.maximum_nesting_depth {