Support for #[schemars(crate = "...")] (#80)

schemars_derive/src/attr/mod.rs

@@ -11,6 +11,10 @@ use syn::Meta::{List, NameValue};
 use syn::MetaNameValue;
 use syn::NestedMeta::{Lit, Meta};
 
+// FIXME using the same struct for containers+variants+fields means that
+//  with/schema_with are accepted (but ignored) on containers, and
+//  repr/crate_name are accepted (but ignored) on variants and fields etc.
+
 #[derive(Debug, Default)]
 pub struct Attrs {
     pub with: Option<WithAttr>,
@@ -19,6 +23,7 @@ pub struct Attrs {
     pub deprecated: bool,
     pub examples: Vec<syn::Path>,
     pub repr: Option<syn::Type>,
+    pub crate_name: Option<syn::Path>,
 }
 
 #[derive(Debug)]
@@ -123,6 +128,16 @@ impl Attrs {
                     }
                 }
 
+                Meta(NameValue(m)) if m.path.is_ident("crate") => {
+                    if let Ok(p) = parse_lit_into_path(errors, attr_type, "crate", &m.lit) {
+                        if self.crate_name.is_some() {
+                            duplicate_error(m)
+                        } else {
+                            self.crate_name = Some(p)
+                        }
+                    }
+                }
+
                 _ if ignore_errors => {}
 
                 Meta(meta_item) => {

schemars_derive/src/lib.rs

@@ -13,6 +13,7 @@ mod schema_exprs;
 
 use ast::*;
 use proc_macro2::TokenStream;
+use syn::spanned::Spanned;
 
 #[proc_macro_derive(JsonSchema, attributes(schemars, serde))]
 pub fn derive_json_schema_wrapper(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
@@ -39,6 +40,11 @@ fn derive_json_schema(
     attr::process_serde_attrs(&mut input)?;
 
     let cont = Container::from_ast(&input)?;
+    let crate_alias = cont.attrs.crate_name.as_ref().map(|path| {
+        quote_spanned! {path.span()=>
+            use #path as schemars;
+        }
+    });
 
     let type_name = &cont.ident;
     let (impl_generics, ty_generics, where_clause) = cont.generics.split_for_impl();
@@ -47,6 +53,7 @@ fn derive_json_schema(
         let (ty, type_def) = schema_exprs::type_for_schema(transparent_field, 0);
         return Ok(quote! {
             const _: () = {
+                #crate_alias
                 #type_def
 
                 #[automatically_derived]
@@ -121,16 +128,20 @@ fn derive_json_schema(
     };
 
     Ok(quote! {
-        #[automatically_derived]
-        #[allow(unused_braces)]
-        impl #impl_generics schemars::JsonSchema for #type_name #ty_generics #where_clause {
-            fn schema_name() -> std::string::String {
-                #schema_name
-            }
+        const _: () = {
+            #crate_alias
 
-            fn json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
-                #schema_expr
-            }
+            #[automatically_derived]
+            #[allow(unused_braces)]
+            impl #impl_generics schemars::JsonSchema for #type_name #ty_generics #where_clause {
+                fn schema_name() -> std::string::String {
+                    #schema_name
+                }
+
+                fn json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
+                    #schema_expr
+                }
+            };
         };
     })
 }