Schema now implements MakeSchema

schemars/src/lib.rs

@@ -1,8 +1,8 @@
-pub mod generator;
+pub mod gen;
 pub mod make_schema;
 pub mod schema;
 
-pub use generator::SchemaGenerator;
 pub use schema::{Schema, SchemaObject, SchemaRef};
+pub use make_schema::MakeSchema;
 
 pub use schemars_derive::*;

schemars/src/main.rs

@@ -1,52 +1,11 @@
-use schemars::MakeSchema;
+use schemars::*;
-use serde::{Deserialize, Serialize};
 use serde_json::Result;
 
-#[derive(Serialize, Deserialize, Debug, MakeSchema)]
-#[serde(rename_all = "camelCase")]
-enum TodoStatus {
-    Backlog,
-    InProgress,
-    Done,
-    Archived,
-}
-
-#[derive(Serialize, Deserialize, Debug, MakeSchema)]
-#[serde(rename_all = "camelCase")]
-struct Todo {
-    id: u64,
-    title: String,
-    description: Option<String>,
-    status: TodoStatus,
-    assigned_to: Vec<User>,
-}
-
-#[derive(Serialize, Deserialize, Debug, MakeSchema)]
-#[serde(rename_all = "camelCase")]
-struct User {
-    id: u64,
-    username: String,
-}
-
 fn main() -> Result<()> {
-    let gen = schemars::SchemaGenerator::new();
+    let gen = gen::SchemaGenerator::new();
-    let schema = gen.into_root_schema_for::<Todo>();
+    let schema = gen.into_root_schema_for::<Schema>();
     let json = serde_json::to_string_pretty(&schema)?;
     println!("{}", json);
 
-    /*let todo = Todo {
-        id: 42,
-        title: "Learn Rust".to_owned(),
-        description: Option::None,
-        status: TodoStatus::InProgress,
-        assigned_to: vec![User {
-            id: 1248,
-            username: "testuser".to_owned(),
-        }],
-    };
-
-    let t = serde_json::to_string(&todo)?;
-    println!("{}", t);*/
-
     Ok(())
 }

schemars/src/make_schema.rs

@@ -1,4 +1,4 @@
-use crate::generator::SchemaGenerator;
+use crate::gen::SchemaGenerator;
 use crate::schema::*;
 use serde_json::json;
 use std::collections::BTreeMap as Map;
@@ -225,7 +225,7 @@ macro_rules! map_impl {
         impl $($desc)+
         where
             K: Into<String>,
-            T: MakeSchema,
+            V: MakeSchema,
         {
             no_ref_schema!();
 
@@ -246,8 +246,8 @@ macro_rules! map_impl {
     };
 }
 
-map_impl!(<K, T: Ord> MakeSchema for std::collections::BTreeMap<K, T>);
+map_impl!(<K: Ord, V> MakeSchema for std::collections::BTreeMap<K, V>);
-map_impl!(<K, T: Eq + core::hash::Hash, H: core::hash::BuildHasher> MakeSchema for std::collections::HashMap<K, T, H>);
+map_impl!(<K: Eq + core::hash::Hash, V, H: core::hash::BuildHasher> MakeSchema for std::collections::HashMap<K, V, H>);
 
 ////////// OPTION //////////
 

schemars/src/schema.rs

@@ -1,10 +1,12 @@
+use crate as schemars;
+use schemars::MakeSchema;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use std::collections::BTreeMap as Map;
 
 // TODO use serde_json::Map (or some other wrapper) instead of BTreeMap to ensure preserve_order is possible
 
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, MakeSchema)]
 #[serde(untagged)]
 pub enum Schema {
     Bool(bool),
@@ -30,13 +32,13 @@ impl From<SchemaRef> for Schema {
     }
 }
 
-#[derive(Serialize, Deserialize, Debug, Default, Clone, PartialEq)]
+#[derive(Serialize, Deserialize, Debug, Default, Clone, PartialEq, MakeSchema)]
 pub struct SchemaRef {
     #[serde(rename = "$ref")]
     pub reference: String,
 }
 
-#[derive(Serialize, Deserialize, Debug, Default, Clone, PartialEq)]
+#[derive(Serialize, Deserialize, Debug, Default, Clone, PartialEq, MakeSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct SchemaObject {
     #[serde(rename = "$schema", skip_serializing_if = "Option::is_none")]
@@ -71,7 +73,7 @@ pub struct SchemaObject {
     pub extensions: Map<String, Value>,
 }
 
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, MakeSchema)]
 #[serde(rename_all = "camelCase")]
 pub enum InstanceType {
     Null,
@@ -83,7 +85,7 @@ pub enum InstanceType {
     Integer,
 }
 
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, MakeSchema)]
 #[serde(untagged)]
 pub enum SingleOrVec<T> {
     Single(Box<T>),

schemars_derive/src/lib.rs

@@ -9,11 +9,13 @@ use proc_macro2::{Span, TokenStream};
 use serde_derive_internals::ast::{Container, Data, Field, Style, Variant};
 use serde_derive_internals::{Ctxt, Derive};
 use syn::spanned::Spanned;
-use syn::DeriveInput;
+use syn::{DeriveInput, GenericParam, Generics};
 
 #[proc_macro_derive(MakeSchema, attributes(schemars, serde))]
 pub fn derive_make_schema(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
-    let input = parse_macro_input!(input as DeriveInput);
+    let mut input = parse_macro_input!(input as DeriveInput);
+    // TODO is mutating the input really the best way to do this?
+    add_trait_bounds(&mut input.generics);
     let ctxt = Ctxt::new();
     let cont = Container::from_ast(&ctxt, &input, Derive::Deserialize);
     if let Err(e) = ctxt.check() {
@@ -31,8 +33,8 @@ pub fn derive_make_schema(input: proc_macro::TokenStream) -> proc_macro::TokenSt
 
     let impl_block = quote! {
         #[automatically_derived]
-        impl #impl_generics schemars::make_schema::MakeSchema for #name #ty_generics #where_clause {
+        impl #impl_generics schemars::MakeSchema for #name #ty_generics #where_clause {
-            fn make_schema(gen: &mut schemars::SchemaGenerator) -> schemars::Schema {
+            fn make_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::Schema {
                 #schema
             }
         };
@@ -40,6 +42,14 @@ pub fn derive_make_schema(input: proc_macro::TokenStream) -> proc_macro::TokenSt
     proc_macro::TokenStream::from(impl_block)
 }
 
+fn add_trait_bounds(generics: &mut Generics) {
+    for param in &mut generics.params {
+        if let GenericParam::Type(ref mut type_param) = *param {
+            type_param.bounds.push(parse_quote!(schemars::MakeSchema));
+        }
+    }
+}
+
 fn wrap_schema_fields(schema_contents: TokenStream) -> TokenStream {
     quote! {
         schemars::SchemaObject {