Crate json5 

JSON5 is a superset of JSON with an expanded syntax including some productions from ECMAScript 5.1. It aims to be easier to write and maintain by hand (e.g. for config files). It is not intended to be used for machine-to-machine communication, for which you’d be better served by serde-rs/json.

In particular, JSON5 allows comments, trailing commas, object keys without quotes, single quoted strings, hexadecimal numbers, multi-line strings…

{
  // comments
  unquoted: 'and you can quote me on that',
  singleQuotes: 'I can use "double quotes" here',
  lineBreaks: "Look, Mom! \
No \\n's!",
  hexadecimal: 0xdecaf,
  leadingDecimalPoint: .8675309, andTrailing: 8675309.,
  positiveSign: +1,
  trailingComma: 'in objects', andIn: ['arrays',],
  "backwardsCompatible": "with JSON",
}

This crate provides functions for deserializing JSON5 text into a Rust datatype and for serializing a Rust datatype as JSON5 text, both via the Serde framework.

Deserialization

Implementing serde::Deserialize on your type will allow you to parse JSON5 text into a value of that type with from_str.

use serde_derive::Deserialize;

#[derive(Debug, PartialEq, Deserialize)]
struct Config<'a> {
    foo: u32,
    bar: &'a str,
}

let config: Config = json5::from_str("
  {
    // Note unquoted keys, comments, and trailing commas.
    foo: 42,
    bar: 'baz',
  }
")?;

assert_eq!(config, Config{ foo: 42, bar: "baz" });

There are many ways to customize the deserialization (e.g. deserializing camelCase field names into a struct with snake_case fields). See the Serde docs, especially the Attributes, Custom serialization, and Examples sections.

Serialization

Similarly, implementing serde::Serialize on a Rust type allows you to produce a JSON5 serialization of values of that type with to_string or to_writer. The serializer will omit quotes around object keys where possible and will indent nested objects and arrays, but is otherwise fairly basic.

use serde_derive::Serialize;

#[derive(Serialize)]
struct Config<'a> {
    foo: u32,
    bar: &'a str,
}

let config = Config {
    foo: 42,
    bar: "baz",
};

assert_eq!(&json5::to_string(&config)?, "{
  foo: 42,
  bar: \"baz\",
}");

There are many ways to customize the serialization (e.g. serializing snake_case struct fields as camelCase). See the Serde docs, especially the Attributes, Custom serialization and Examples sections.

Byte arrays

All the types of the Serde data model are supported. Byte arrays are encoded as hex strings. e.g.

use serde_bytes::{Bytes, ByteBuf};

let s = json5::to_string(&Bytes::new(b"JSON5"))?;
assert_eq!(&s, "\"4a534f4e35\"");
assert_eq!(json5::from_str::<ByteBuf>(&s)?, ByteBuf::from("JSON5"));

Structs

Deserializer

A deserializer that knows how to parse JSON5 and map it on to types implementing Deserialize.

Error

An error serializing or deserializing JSON5.

Position

The line and column that an error occured.

Serializer

A serializer that knows how to serialize types implementing Serialize as JSON5.

Enums

ErrorCode

A code identifying an error originating within this crate.

Functions

from_str

Parse a JSON5 string and map it to a type implementing Deserialize.

to_string

Serialize a type implementing Serialize to a JSON5 string.

to_writer

Serialize a type implementing Serialize to JSON5 and write it to the given writer.