Initial commit

Author: ucarion

.gitignore

@@ -0,0 +1,3 @@
+/target
+**/*.rs.bk
+Cargo.lock

Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "jtd"
+version = "0.1.0"
+authors = ["JSON Type Definition Contributors"]
+edition = "2018"
+
+[dependencies]
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"

fuzz/.gitignore

@@ -0,0 +1,4 @@
+
+target
+corpus
+artifacts

fuzz/Cargo.toml

@@ -0,0 +1,24 @@
+
+[package]
+name = "jtd-fuzz"
+version = "0.0.0"
+authors = ["Automatically generated"]
+publish = false
+edition = "2018"
+
+[package.metadata]
+cargo-fuzz = true
+
+[dependencies]
+libfuzzer-sys = "0.3"
+
+[dependencies.jtd]
+path = ".."
+
+# Prevent this from interfering with workspaces
+[workspace]
+members = ["."]
+
+[[bin]]
+name = "fuzz_target_1"
+path = "fuzz_targets/fuzz_target_1.rs"

fuzz/fuzz_targets/fuzz_target_1.rs

@@ -0,0 +1,6 @@
+#![no_main]
+use libfuzzer_sys::fuzz_target;
+
+fuzz_target!(|data: &[u8]| {
+    // fuzzed code goes here
+});

src/form.rs

@@ -0,0 +1,63 @@
+use crate::schema::Schema;
+use std::collections::HashMap;
+use std::collections::HashSet;
+
+pub enum Form {
+    Empty(Empty),
+    Type(Type),
+    Enum(Enum),
+    Elements(Elements),
+    Properties(Properties),
+    Values(Values),
+    Discriminator(Discriminator),
+}
+
+pub struct Empty {}
+
+pub struct Type {
+    pub nullable: bool,
+    pub type_value: TypeValue,
+}
+
+pub enum TypeValue {
+    Boolean,
+    Float32,
+    Float64,
+    Int8,
+    Uint8,
+    Int16,
+    Uint16,
+    Int32,
+    Uint32,
+    String,
+    Timestamp,
+}
+
+pub struct Enum {
+    pub nullable: bool,
+    pub values: HashSet<String>,
+}
+
+pub struct Elements {
+    pub nullable: bool,
+    pub schema: Box<Schema>,
+}
+
+pub struct Properties {
+    pub nullable: bool,
+    pub required: HashMap<String, Schema>,
+    pub optional: HashMap<String, Schema>,
+    pub additional: bool,
+    pub has_required: bool,
+}
+
+pub struct Values {
+    pub nullable: bool,
+    pub schema: Box<Schema>,
+}
+
+pub struct Discriminator {
+    pub nullable: bool,
+    pub tag: String,
+    pub mapping: HashMap<String, Schema>,
+}

src/lib.rs

@@ -0,0 +1,14 @@
+pub mod form;
+pub mod schema;
+pub mod serde;
+
+pub use form::Form;
+pub use schema::Schema;
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn it_works() {
+        assert_eq!(2 + 2, 4);
+    }
+}

src/schema.rs

@@ -0,0 +1,7 @@
+use crate::form::Form;
+use std::collections::HashMap;
+
+pub struct Schema {
+    pub definitions: HashMap<String, Schema>,
+    pub form: Form,
+}

src/serde.rs

@@ -0,0 +1,164 @@
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct Schema {
+    pub definitions: Option<HashMap<String, Schema>>,
+    pub nullable: Option<bool>,
+    pub type_: Option<String>,
+    pub enum_: Option<Vec<String>>,
+    pub elements: Option<Box<Schema>>,
+    pub properties: Option<HashMap<String, Schema>>,
+    pub optional_properties: Option<HashMap<String, Schema>>,
+    pub values: Option<Box<Schema>>,
+    pub discriminator: Option<Discriminator>,
+}
+
+#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Eq)]
+pub struct Discriminator {
+    pub tag: String,
+    pub mapping: HashMap<String, Schema>,
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::json;
+
+    #[test]
+    fn parse_empty() {
+        assert_eq!(
+            super::Schema::default(),
+            serde_json::from_value(json!({})).unwrap()
+        );
+    }
+
+    #[test]
+    fn parse_partial() {
+        assert_eq!(
+            super::Schema {
+                nullable: Some(true),
+                optional_properties: Some(
+                    vec![(
+                        "foo".to_owned(),
+                        super::Schema {
+                            type_: Some("uint32".to_owned()),
+                            ..Default::default()
+                        }
+                    )]
+                    .into_iter()
+                    .collect()
+                ),
+                ..Default::default()
+            },
+            serde_json::from_value(json!({
+                "optionalProperties": {
+                    "foo": {
+                        "type": "uint32",
+                    },
+                },
+                "nullable": true,
+            }))
+            .unwrap()
+        );
+    }
+
+    #[test]
+    fn parse_full() {
+        assert_eq!(
+            super::Schema {
+                definitions: Some(
+                    vec![(
+                        "foo".to_owned(),
+                        super::Schema {
+                            type_: Some("uint32".to_owned()),
+                            ..Default::default()
+                        }
+                    )]
+                    .into_iter()
+                    .collect()
+                ),
+                nullable: Some(true),
+                type_: Some("uint32".to_owned()),
+                enum_: Some(vec!["foo".to_owned(), "bar".to_owned()]),
+                elements: Some(Box::new(super::Schema {
+                    type_: Some("uint32".to_owned()),
+                    ..Default::default()
+                })),
+                properties: Some(
+                    vec![(
+                        "foo".to_owned(),
+                        super::Schema {
+                            type_: Some("uint32".to_owned()),
+                            ..Default::default()
+                        }
+                    )]
+                    .into_iter()
+                    .collect()
+                ),
+                optional_properties: Some(
+                    vec![(
+                        "foo".to_owned(),
+                        super::Schema {
+                            type_: Some("uint32".to_owned()),
+                            ..Default::default()
+                        }
+                    )]
+                    .into_iter()
+                    .collect()
+                ),
+                values: Some(Box::new(super::Schema {
+                    type_: Some("uint32".to_owned()),
+                    ..Default::default()
+                })),
+                discriminator: Some(super::Discriminator {
+                    tag: "foo".to_owned(),
+                    mapping: vec![(
+                        "foo".to_owned(),
+                        super::Schema {
+                            type_: Some("uint32".to_owned()),
+                            ..Default::default()
+                        }
+                    )]
+                    .into_iter()
+                    .collect(),
+                }),
+            },
+            serde_json::from_value(json!({
+                "definitions": {
+                    "foo": {
+                        "type": "uint32",
+                    },
+                },
+                "nullable": true,
+                "type": "uint32",
+                "enum": ["foo", "bar"],
+                "elements": {
+                    "type": "uint32",
+                },
+                "properties": {
+                    "foo": {
+                        "type": "uint32",
+                    },
+                },
+                "optionalProperties": {
+                    "foo": {
+                        "type": "uint32",
+                    },
+                },
+                "values": {
+                    "type": "uint32",
+                },
+                "discriminator": {
+                    "tag": "foo",
+                    "mapping": {
+                        "foo": {
+                            "type": "uint32",
+                        },
+                    },
+                },
+            }))
+            .unwrap()
+        );
+    }
+}