Vulnerabilities | |||||
---|---|---|---|---|---|
Version | Suggest | Low | Medium | High | Critical |
0.8.1 | 0 | 0 | 0 | 0 | 0 |
0.8.0 | 0 | 0 | 0 | 0 | 0 |
0.7.1 | 0 | 0 | 0 | 0 | 0 |
0.7.0 | 0 | 0 | 0 | 0 | 0 |
0.6.6 | 0 | 0 | 0 | 0 | 0 |
0.6.5 | 0 | 0 | 0 | 0 | 0 |
0.6.4 | 0 | 0 | 0 | 0 | 0 |
0.6.3 | 0 | 0 | 0 | 0 | 0 |
0.6.2 | 0 | 0 | 0 | 0 | 0 |
0.6.1 | 0 | 0 | 0 | 0 | 0 |
0.6.0 | 0 | 0 | 0 | 0 | 0 |
0.5.1 | 0 | 0 | 0 | 0 | 0 |
0.5.0 | 0 | 0 | 0 | 0 | 0 |
0.4.2 | 0 | 0 | 0 | 0 | 0 |
0.4.1 | 0 | 0 | 0 | 0 | 0 |
0.4.0 | 0 | 0 | 0 | 0 | 0 |
0.3.0 | 0 | 0 | 0 | 0 | 0 |
0.2.2 | 0 | 0 | 0 | 0 | 0 |
0.2.1 | 0 | 0 | 0 | 0 | 0 |
0.2.0 | 0 | 0 | 0 | 0 | 0 |
0.1.7 | 0 | 0 | 0 | 0 | 0 |
0.1.6 | 0 | 0 | 0 | 0 | 0 |
0.1.5 | 0 | 0 | 0 | 0 | 0 |
0.1.4 | 0 | 0 | 0 | 0 | 0 |
0.1.3 | 0 | 0 | 0 | 0 | 0 |
0.1.2 | 0 | 0 | 0 | 0 | 0 |
0.1.1 | 0 | 0 | 0 | 0 | 0 |
0.1.0 | 0 | 0 | 0 | 0 | 0 |
0.0.1 | 0 | 0 | 0 | 0 | 0 |
0.8.1 - This version is safe to use because it has no known security vulnerabilities at this time. Find out if your coding project uses this component and get notified of any reported security vulnerabilities with Meterian-X Open Source Security Platform
Maintain your licence declarations and avoid unwanted licences to protect your IP the way you intended.
Apache-2.0 - Apache License 2.0RON is a simple readable data serialization format that looks similar to Rust syntax. It's designed to support all of Serde's data model, so structs, enums, tuples, arrays, generic maps, and primitive values.
GameConfig( // optional struct name
window_size: (800, 600),
window_title: "PAC-MAN",
fullscreen: false,
mouse_sensitivity: 1.4,
key_bindings: {
"up": Up,
"down": Down,
"left": Left,
"right": Right,
// Uncomment to enable WASD controls
/*
"W": Up,
"S": Down,
"A": Left,
"D": Right,
*/
},
difficulty_options: (
start_difficulty: Easy,
adaptive: false,
),
)
42
, 3.14
, 0xFF
, 0b0110
"Hello"
, "with\\escapes\n"
, r#"raw string, great for regex\."#
b"Hello"
, b"with \x65\x73\x63\x61\x70\x65\x73\n"
, br#"raw, too"#
true
, false
'e'
, '\n'
Some("string")
, Some(Some(1.34))
, None
("abc", 1.23, true)
, ()
["abc", "def"]
( foo: 1.0, bar: ( baz: "I'm nested" ) )
{ "arbitrary": "keys", "are": "allowed" }
Note: Serde's data model represents fixed-size Rust arrays as tuple (instead of as list)
RON also supports several extensions, which are documented here.
RON's formal and complete grammar is available here.
There also is a very basic, work in progress specification available on the wiki page.
{
"materials": {
"metal": {
"reflectivity": 1.0
},
"plastic": {
"reflectivity": 0.5
}
},
"entities": [
{
"name": "hero",
"material": "metal"
},
{
"name": "monster",
"material": "plastic"
}
]
}
Scene( // class name is optional
materials: { // this is a map
"metal": (
reflectivity: 1.0,
),
"plastic": (
reflectivity: 0.5,
),
},
entities: [ // this is an array
(
name: "hero",
material: "metal",
),
(
name: "monster",
material: "plastic",
),
],
)
Note the following advantages of RON over JSON:
[dependencies]
ron = "0.8"
serde = { version = "1", features = ["derive"] }
use serde::{Deserialize, Serialize};
#[derive(Debug, Deserialize, Serialize)]
struct MyStruct {
boolean: bool,
float: f32,
}
fn main() {
let x: MyStruct = ron::from_str("(boolean: true, float: 1.23)").unwrap();
println!("RON: {}", ron::to_string(&x).unwrap());
println!("Pretty RON: {}", ron::ser::to_string_pretty(
&x, ron::ser::PrettyConfig::default()).unwrap(),
);
}
Editor | Plugin |
---|---|
IntelliJ | intellij-ron |
VS Code | a5huynh/vscode-ron |
Sublime Text | RON |
Atom | language-ron |
Vim | ron-rs/ron.vim |
EMACS | emacs-ron |
RON is not designed to be a fully self-describing format (unlike JSON) and is thus not guaranteed to work when deserialize_any
is used instead of its typed alternatives. In particular, the following Serde attributes only have limited support:
#[serde(tag = "tag")]
, i.e. internally tagged enums 1
#[serde(tag = "tag", content = "content")]
, i.e. adjacently tagged enums 1
#[serde(untagged)]
, i.e. untagged enums 1
#[serde(flatten)]
, i.e. flattening of structs into maps 2
While data structures with any of these attributes should generally roundtrip through RON, some restrictions apply 3 and their textual representation may not always match your expectation:
#[serde(flatten)]
ed fields must not contain:
#[enable(explicit_struct_names)]
extension or the PrettyConfig::struct_names
settingOption
s with #[enable(implicit_some)]
must not contain any of these or a unit, unit struct, or an untagged unit variant#[enable(unwrap_variant_newtypes)]
(including Some
)ron::value::RawValue
#![enable(unwrap_variant_newtypes)]
extension is enabledron::value::RawValue
using a PrettyConfig
may add leading and trailing whitespace and comments, which the ron::value::RawValue
absorbs upon deserializationFurthermore, serde imposes the following restrictions for data to roundtrip:
#[serde(flatten)]
ed field:
#[serde(flatten)]
ed map field, which collects all unknown fields#[serde(flatten)]
ed map, they must not contain:
#[serde(flatten)]
ed fields must not contain:
i128
or u128
values#[serde(flatten)]
ed fields must not contain:
#[serde(flatten)]
ed together with other fields, must not contain:
Please file a new issue if you come across a use case which is not listed among the above restrictions but still breaks.
While RON guarantees roundtrips like Rust -> RON -> Rust for Rust types using non-deserialize_any
-based implementations, RON does not yet make any guarantees about roundtrips through ron::Value
. For instance, even when RON -> Rust works, RON -> ron::Value
-> Rust, or RON -> ron::Value
-> RON -> Rust may not work. We plan on improving ron::Value
in an upcoming version of RON, though this work is partially blocked on serde#1183.
RON is dual-licensed under Apache-2.0 and MIT.
Any contribution intentionally submitted for inclusion in the work must be provided under the same dual-license terms.
Deserialising an internally, adjacently, or un-tagged enum requires detecting serde
's internal serde::__private::de::content::Content
content type so that RON can describe the deserialised data structure in serde's internal JSON-like format. This detection only works for the automatically-derived Deserialize
impls on enums. See #451 for more details. ↩ ↩2 ↩3
Deserialising a flattened struct from a map requires that the struct's Visitor::expecting
implementation formats a string starting with "struct "
. This is the case for automatically-derived Deserialize
impls on structs. See #455 for more details. ↩
Most of these restrictions are currently blocked on serde#1183, which limits non-self-describing formats from roundtripping format-specific information through internally (or adjacently) tagged or untagged enums or #[serde(flatten)]
ed fields. ↩