(codegen) Move GraphQLTYpeDefinition to utils

Author: theduke

juniper_codegen/src/impl_object.rs

@@ -126,154 +126,6 @@ impl FieldAttributes {
     }
 }
 
-pub struct GraphQLTypeDefinitionFieldArg {
-    pub name: String,
-    pub description: Option<String>,
-    pub _type: syn::Type,
-}
-
-pub struct GraphQLTypeDefinitionField {
-    pub name: String,
-    pub _type: syn::Type,
-    pub description: Option<String>,
-    pub deprecation: Option<String>,
-    pub args: Vec<GraphQLTypeDefinitionFieldArg>,
-    pub resolver_code: proc_macro2::TokenStream,
-}
-
-/// Definition of a graphql type based on information extracted
-/// by various macros.
-/// The definition can be rendered to Rust code.
-pub struct GraphQLTypeDefiniton {
-    pub name: String,
-    pub _type: syn::Type,
-    pub context: Option<syn::Type>,
-    pub scalar: Option<syn::Type>,
-    pub description: Option<String>,
-    pub fields: Vec<GraphQLTypeDefinitionField>,
-}
-
-impl GraphQLTypeDefiniton {
-    fn to_tokens(&self) -> proc_macro2::TokenStream {
-        let name = &self.name;
-        let ty = &self._type;
-        let context = self
-            .context
-            .as_ref()
-            .map(|ctx| quote!( #ctx ))
-            .unwrap_or(quote!(()));
-        let scalar = self
-            .scalar
-            .as_ref()
-            .map(|s| quote!( #s ))
-            .unwrap_or(quote!(juniper::DefaultScalarValue));
-
-        let field_definitions = self.fields.iter().map(|field| {
-            let args = field.args.iter().map(|arg| {
-                let arg_type = &arg._type;
-                let arg_name = &arg.name;
-                quote! {
-                  .argument(registry.arg::<#arg_type>(#arg_name, info))
-                }
-            });
-
-            let description = match field.description.as_ref() {
-                Some(description) => quote!( .description(#description) ),
-                None => quote!(),
-            };
-
-            let deprecation = match field.deprecation.as_ref() {
-                Some(deprecation) => quote!( .deprecation(#deprecation) ),
-                None => quote!(),
-            };
-
-            let field_name = &field.name;
-
-            let _type = &field._type;
-            quote! {
-                registry
-                    .field_convert::<#_type, _, Self::Context>(#field_name, info)
-                    #(#args)*
-                    #description
-                    #deprecation
-            }
-        });
-
-        let resolve_matches = self.fields.iter().map(|field| {
-            let name = &field.name;
-            let code = &field.resolver_code;
-
-            quote!(
-                #name => {
-                    let res = #code;
-                    juniper::IntoResolvable::into(
-                        res,
-                        executor.context()
-                    )
-                        .and_then(|res| {
-                            match res {
-                                Some((ctx, r)) => executor.replaced_context(ctx).resolve_with_ctx(&(), &r),
-                                None => Ok(juniper::Value::null()),
-                            }
-                        })
-                },
-            )
-        });
-
-        let description = match self.description.as_ref() {
-            Some(description) => quote!( .description(#description) ),
-            None => quote!(),
-        };
-
-        quote!(
-            impl juniper::GraphQLType<#scalar> for #ty {
-                type Context = #context;
-                type TypeInfo = ();
-
-                fn name(_: &Self::TypeInfo) -> Option<&str> {
-                    Some(#name)
-                }
-
-                fn meta<'r>(
-                    info: &Self::TypeInfo,
-                    registry: &mut juniper::Registry<'r, #scalar>
-                ) -> juniper::meta::MetaType<'r, #scalar>
-                    where #scalar : 'r,
-                        for<'z> &'z juniper::DefaultScalarValue: juniper::ScalarRefValue<'z>,
-                {
-                    let fields = vec![
-                        #( #field_definitions ),*
-                    ];
-                    let meta = registry.build_object_type::<#ty>( info, &fields );
-                    let meta = meta # description;
-                    meta.into_meta()
-                }
-
-                #[allow(unused_variables)]
-                #[allow(unused_mut)]
-                fn resolve_field(
-                    &self,
-                    _info: &(),
-                    field: &str,
-                    args: &juniper::Arguments,
-                    executor: &juniper::Executor<Self::Context>,
-                ) -> juniper::ExecutionResult {
-                    match field {
-                        #( #resolve_matches )*
-                        _ => {
-                            panic!("Field {} not found on type {}", field, "Mutation");
-                        }
-                    }
-                }
-
-                fn concrete_type_name(&self, _: &Self::Context, _: &Self::TypeInfo) -> String {
-                    #name.to_string()
-                }
-
-            }
-        )
-    }
-}
 
 /// Generate code for the juniper::impl_object macro.
 pub fn build(args: TokenStream, body: TokenStream) -> TokenStream {
@@ -309,7 +161,7 @@ pub fn build(args: TokenStream, body: TokenStream) -> TokenStream {
 
     let target_type = *_impl.self_ty.clone();
 
-    let mut definition = GraphQLTypeDefiniton {
+    let mut definition = util::GraphQLTypeDefiniton {
         name,
         _type: target_type.clone(),
         context: impl_attrs.context,
@@ -386,7 +238,7 @@ pub fn build(args: TokenStream, body: TokenStream) -> TokenStream {
                                         .get::<#ty>(#arg_name)
                                         .expect("Argument missing - validation must have failed")
                                 ));
-                                args.push(GraphQLTypeDefinitionFieldArg {
+                                args.push(util::GraphQLTypeDefinitionFieldArg {
                                     name: arg_name,
                                     description: None,
                                     _type: ty.clone(),
@@ -407,7 +259,7 @@ pub fn build(args: TokenStream, body: TokenStream) -> TokenStream {
                     .unwrap_or(util::to_camel_case(&method_ident.to_string()));
                 let description = attrs.description.or(util::get_doc_comment(&method.attrs));
 
-                definition.fields.push(GraphQLTypeDefinitionField {
+                definition.fields.push(util::GraphQLTypeDefinitionField {
                     name,
                     _type,
                     args,

juniper_codegen/src/util.rs

@@ -248,6 +248,155 @@ pub fn is_valid_name(field_name: &str) -> bool {
     GRAPHQL_NAME_SPEC.is_match(field_name)
 }
 
+pub struct GraphQLTypeDefinitionFieldArg {
+    pub name: String,
+    pub description: Option<String>,
+    pub _type: syn::Type,
+}
+
+pub struct GraphQLTypeDefinitionField {
+    pub name: String,
+    pub _type: syn::Type,
+    pub description: Option<String>,
+    pub deprecation: Option<String>,
+    pub args: Vec<GraphQLTypeDefinitionFieldArg>,
+    pub resolver_code: proc_macro2::TokenStream,
+}
+
+/// Definition of a graphql type based on information extracted
+/// by various macros.
+/// The definition can be rendered to Rust code.
+pub struct GraphQLTypeDefiniton {
+    pub name: String,
+    pub _type: syn::Type,
+    pub context: Option<syn::Type>,
+    pub scalar: Option<syn::Type>,
+    pub description: Option<String>,
+    pub fields: Vec<GraphQLTypeDefinitionField>,
+}
+
+impl GraphQLTypeDefiniton {
+    pub fn to_tokens(&self) -> proc_macro2::TokenStream {
+        let name = &self.name;
+        let ty = &self._type;
+        let context = self
+            .context
+            .as_ref()
+            .map(|ctx| quote!( #ctx ))
+            .unwrap_or(quote!(()));
+        let scalar = self
+            .scalar
+            .as_ref()
+            .map(|s| quote!( #s ))
+            .unwrap_or(quote!(juniper::DefaultScalarValue));
+
+        let field_definitions = self.fields.iter().map(|field| {
+            let args = field.args.iter().map(|arg| {
+                let arg_type = &arg._type;
+                let arg_name = &arg.name;
+                quote! {
+                  .argument(registry.arg::<#arg_type>(#arg_name, info))
+                }
+            });
+
+            let description = match field.description.as_ref() {
+                Some(description) => quote!( .description(#description) ),
+                None => quote!(),
+            };
+
+            let deprecation = match field.deprecation.as_ref() {
+                Some(deprecation) => quote!( .deprecation(#deprecation) ),
+                None => quote!(),
+            };
+
+            let field_name = &field.name;
+
+            let _type = &field._type;
+            quote! {
+                registry
+                    .field_convert::<#_type, _, Self::Context>(#field_name, info)
+                    #(#args)*
+                    #description
+                    #deprecation
+            }
+        });
+
+        let resolve_matches = self.fields.iter().map(|field| {
+            let name = &field.name;
+            let code = &field.resolver_code;
+
+            quote!(
+                #name => {
+                    let res = #code;
+                    juniper::IntoResolvable::into(
+                        res,
+                        executor.context()
+                    )
+                        .and_then(|res| {
+                            match res {
+                                Some((ctx, r)) => executor.replaced_context(ctx).resolve_with_ctx(&(), &r),
+                                None => Ok(juniper::Value::null()),
+                            }
+                        })
+                },
+            )
+        });
+
+        let description = match self.description.as_ref() {
+            Some(description) => quote!( .description(#description) ),
+            None => quote!(),
+        };
+
+        quote!(
+            impl juniper::GraphQLType<#scalar> for #ty {
+                type Context = #context;
+                type TypeInfo = ();
+
+                fn name(_: &Self::TypeInfo) -> Option<&str> {
+                    Some(#name)
+                }
+
+                fn meta<'r>(
+                    info: &Self::TypeInfo,
+                    registry: &mut juniper::Registry<'r, #scalar>
+                ) -> juniper::meta::MetaType<'r, #scalar>
+                    where #scalar : 'r,
+                        for<'z> &'z juniper::DefaultScalarValue: juniper::ScalarRefValue<'z>,
+                {
+                    let fields = vec![
+                        #( #field_definitions ),*
+                    ];
+                    let meta = registry.build_object_type::<#ty>( info, &fields );
+                    let meta = meta # description;
+                    meta.into_meta()
+                }
+
+                #[allow(unused_variables)]
+                #[allow(unused_mut)]
+                fn resolve_field(
+                    &self,
+                    _info: &(),
+                    field: &str,
+                    args: &juniper::Arguments,
+                    executor: &juniper::Executor<Self::Context>,
+                ) -> juniper::ExecutionResult {
+                    match field {
+                        #( #resolve_matches )*
+                        _ => {
+                            panic!("Field {} not found on type {}", field, "Mutation");
+                        }
+                    }
+                }
+
+                fn concrete_type_name(&self, _: &Self::Context, _: &Self::TypeInfo) -> String {
+                    #name.to_string()
+                }
+
+            }
+        )
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::*;