Implement deriving arbitrary traits on ResponseData

Author: tomhoule

examples/example_module/src/lib.rs

@@ -11,6 +11,7 @@ use custom_scalars::*;
 #[derive(GraphQLQuery)]
 #[graphql(
     schema_path = "../github/src/schema.graphql",
-    query_path = "../github/src/query_1.graphql"
+    query_path = "../github/src/query_1.graphql",
+    response_derives = "Debug",
 )]
 pub struct ExampleModule;

examples/github/src/main.rs

@@ -32,7 +32,8 @@ type DateTime = String;
 #[derive(GraphQLQuery)]
 #[graphql(
     schema_path = "src/schema.graphql",
-    query_path = "src/query_1.graphql"
+    query_path = "src/query_1.graphql",
+    response_derives = "Debug",
 )]
 struct Query1;
 

graphql_client_cli/src/main.rs

@@ -15,7 +15,8 @@ use structopt::StructOpt;
 #[derive(GraphQLQuery)]
 #[graphql(
     schema_path = "src/introspection_schema.graphql",
-    query_path = "src/introspection_query.graphql"
+    query_path = "src/introspection_query.graphql",
+    response_derives = "Serialize",
 )]
 struct IntrospectionQuery;
 

graphql_query_derive/src/attributes.rs

@@ -0,0 +1,29 @@
+use failure;
+use syn;
+
+pub(crate) fn extract_attr(ast: &syn::DeriveInput, attr: &str) -> Result<String, failure::Error> {
+    let attributes = &ast.attrs;
+    let attribute = attributes
+        .iter()
+        .find(|attr| {
+            let path = &attr.path;
+            quote!(#path).to_string() == "graphql"
+        }).ok_or_else(|| format_err!("The graphql attribute is missing"))?;
+    if let syn::Meta::List(items) = &attribute
+        .interpret_meta()
+        .expect("Attribute is well formatted")
+    {
+        for item in items.nested.iter() {
+            if let syn::NestedMeta::Meta(syn::Meta::NameValue(name_value)) = item {
+                let syn::MetaNameValue { ident, lit, .. } = name_value;
+                if ident == attr {
+                    if let syn::Lit::Str(lit) = lit {
+                        return Ok(lit.value());
+                    }
+                }
+            }
+        }
+    }
+
+    Err(format_err!("attribute not found"))?
+}

graphql_query_derive/src/codegen.rs

@@ -11,8 +11,14 @@ pub(crate) fn response_for_query(
     schema: schema::Schema,
     query: query::Document,
     selected_operation: String,
+    additional_derives: Option<String>,
 ) -> Result<TokenStream, failure::Error> {
     let mut context = QueryContext::new(schema);
+
+    if let Some(derives) = additional_derives {
+        context.ingest_additional_derives(&derives).unwrap();
+    }
+
     let mut definitions = Vec::new();
     let mut operations: Vec<Operation> = Vec::new();
 
@@ -77,7 +83,11 @@ pub(crate) fn response_for_query(
             .unwrap()
     };
 
-    let enum_definitions = context.schema.enums.values().map(|enm| enm.to_rust());
+    let enum_definitions = context
+        .schema
+        .enums
+        .values()
+        .map(|enm| enm.to_rust(&context));
     let fragment_definitions: Result<Vec<TokenStream>, _> = context
         .fragments
         .values()
@@ -101,6 +111,8 @@ pub(crate) fn response_for_query(
         .map(|s| s.to_rust())
         .collect();
 
+    let response_derives = context.response_derives();
+
     Ok(quote! {
         type Boolean = bool;
         type Float = f64;
@@ -119,7 +131,7 @@ pub(crate) fn response_for_query(
 
         #variables_struct
 
-        #[derive(Debug, Serialize, Deserialize)]
+        #response_derives
         #[serde(rename_all = "camelCase")]
         pub struct ResponseData {
             #(#response_data_fields,)*

graphql_query_derive/src/enums.rs

@@ -16,7 +16,8 @@ pub struct GqlEnum {
 }
 
 impl GqlEnum {
-    pub fn to_rust(&self) -> TokenStream {
+    pub(crate) fn to_rust(&self, query_context: &::query::QueryContext) -> TokenStream {
+        let derives = query_context.response_enum_derives();
         let variant_names: Vec<TokenStream> = self
             .variants
             .iter()
@@ -42,7 +43,7 @@ impl GqlEnum {
         let name = name_ident.clone();
 
         quote! {
-            #[derive(Debug)]
+            #derives
             pub enum #name {
                 #(#variant_names,)*
                 Other(String),

graphql_query_derive/src/fragments.rs

@@ -11,13 +11,14 @@ pub struct GqlFragment {
 
 impl GqlFragment {
     pub(crate) fn to_rust(&self, context: &QueryContext) -> Result<TokenStream, ::failure::Error> {
+        let derives = context.response_derives();
         let name_ident = Ident::new(&self.name, Span::call_site());
         let object = context.schema.objects.get(&self.on).expect("oh, noes");
         let field_impls = object.field_impls_for_selection(context, &self.selection, &self.name)?;
         let fields = object.response_fields_for_selection(context, &self.selection, &self.name)?;
 
         Ok(quote!{
-            #[derive(Debug, Deserialize, Serialize)]
+            #derives
             pub struct #name_ident {
                 #(#fields,)*
             }

graphql_query_derive/src/interfaces.rs

@@ -33,6 +33,7 @@ impl GqlInterface {
         prefix: &str,
     ) -> Result<TokenStream, failure::Error> {
         let name = Ident::new(&prefix, Span::call_site());
+        let derives = query_context.response_derives();
 
         selection
             .extract_typename()
@@ -78,13 +79,13 @@ impl GqlInterface {
         let attached_enum_name = Ident::new(&format!("{}On", name), Span::call_site());
         let (attached_enum, last_object_field) = if !union_variants.is_empty() {
             let attached_enum = quote! {
-                #[derive(Deserialize, Debug, Serialize)]
+                #derives
                 #[serde(tag = "__typename")]
                 pub enum #attached_enum_name {
                     #(#union_variants,)*
                 }
             };
-            let last_object_field = quote!(#[serde(flatten)] on: #attached_enum_name,);
+            let last_object_field = quote!(#[serde(flatten)] pub on: #attached_enum_name,);
             (attached_enum, last_object_field)
         } else {
             (quote!(), quote!())
@@ -98,7 +99,7 @@ impl GqlInterface {
 
             #attached_enum
 
-            #[derive(Debug, Serialize, Deserialize)]
+            #derives
             pub struct #name {
                 #(#object_fields,)*
                 #last_object_field

graphql_query_derive/src/lib.rs

@@ -1,4 +1,4 @@
-#![recursion_limit = "128"]
+#![recursion_limit = "512"]
 
 #[macro_use]
 extern crate failure;
@@ -16,6 +16,7 @@ extern crate quote;
 
 use proc_macro2::TokenStream;
 
+mod attributes;
 mod codegen;
 mod constants;
 mod enums;
@@ -77,8 +78,9 @@ fn impl_gql_query(input: &syn::DeriveInput) -> Result<TokenStream, failure::Erro
     let cargo_manifest_dir =
         ::std::env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR env variable is defined");
 
-    let query_path = extract_attr(input, "query_path")?;
-    let schema_path = extract_attr(input, "schema_path")?;
+    let query_path = attributes::extract_attr(input, "query_path")?;
+    let schema_path = attributes::extract_attr(input, "schema_path")?;
+    let response_derives = attributes::extract_attr(input, "response_derives").ok();
 
     // We need to qualify the query with the path to the crate it is part of
     let query_path = format!("{}/{}", cargo_manifest_dir, query_path);
@@ -108,7 +110,8 @@ fn impl_gql_query(input: &syn::DeriveInput) -> Result<TokenStream, failure::Erro
 
     let module_name = Ident::new(&input.ident.to_string().to_snake_case(), Span::call_site());
     let struct_name = &input.ident;
-    let schema_output = codegen::response_for_query(schema, query, input.ident.to_string())?;
+    let schema_output =
+        codegen::response_for_query(schema, query, input.ident.to_string(), response_derives)?;
 
     let result = quote!(
         pub mod #module_name {
@@ -139,30 +142,3 @@ fn impl_gql_query(input: &syn::DeriveInput) -> Result<TokenStream, failure::Erro
 
     Ok(result)
 }
-
-fn extract_attr(ast: &syn::DeriveInput, attr: &str) -> Result<String, failure::Error> {
-    let attributes = &ast.attrs;
-    let attribute = attributes
-        .iter()
-        .find(|attr| {
-            let path = &attr.path;
-            quote!(#path).to_string() == "graphql"
-        }).ok_or_else(|| format_err!("The graphql attribute is missing"))?;
-    if let syn::Meta::List(items) = &attribute
-        .interpret_meta()
-        .expect("Attribute is well formatted")
-    {
-        for item in items.nested.iter() {
-            if let syn::NestedMeta::Meta(syn::Meta::NameValue(name_value)) = item {
-                let syn::MetaNameValue { ident, lit, .. } = name_value;
-                if ident == attr {
-                    if let syn::Lit::Str(lit) = lit {
-                        return Ok(lit.value());
-                    }
-                }
-            }
-        }
-    }
-
-    Err(format_err!("attribute not found"))?
-}

graphql_query_derive/src/objects.rs

@@ -67,14 +67,15 @@ impl GqlObject {
         selection: &Selection,
         prefix: &str,
     ) -> Result<TokenStream, failure::Error> {
+        let derives = query_context.response_derives();
         let name = Ident::new(prefix, Span::call_site());
         let fields = self.response_fields_for_selection(query_context, selection, prefix)?;
         let field_impls = self.field_impls_for_selection(query_context, selection, &prefix)?;
         let description = self.description.as_ref().map(|desc| quote!(#[doc = #desc]));
         Ok(quote! {
             #(#field_impls)*
 
-            #[derive(Debug, Serialize, Deserialize)]
+            #derives
             #[serde(rename_all = "camelCase")]
             #description
             pub struct #name {

graphql_query_derive/src/query.rs

@@ -1,16 +1,19 @@
 use failure;
 use fragments::GqlFragment;
 use operations::Operation;
+use proc_macro2::Span;
 use proc_macro2::TokenStream;
 use schema::Schema;
 use selection::Selection;
 use std::collections::BTreeMap;
+use syn::Ident;
 
 /// This holds all the information we need during the code generation phase.
 pub(crate) struct QueryContext {
     pub fragments: BTreeMap<String, GqlFragment>,
     pub schema: Schema,
     pub selected_operation: Option<Operation>,
+    response_derives: Vec<Ident>,
 }
 
 impl QueryContext {
@@ -20,6 +23,7 @@ impl QueryContext {
             fragments: BTreeMap::new(),
             schema,
             selected_operation: None,
+            response_derives: vec![Ident::new("Deserialize", Span::call_site())],
         }
     }
 
@@ -30,6 +34,7 @@ impl QueryContext {
             fragments: BTreeMap::new(),
             schema: Schema::new(),
             selected_operation: None,
+            response_derives: vec![Ident::new("Deserialize", Span::call_site())],
         }
     }
 
@@ -51,4 +56,100 @@ impl QueryContext {
             Ok(quote!())
         }
     }
+
+    pub(crate) fn ingest_additional_derives(
+        &mut self,
+        attribute_value: &str,
+    ) -> Result<(), failure::Error> {
+        if self.response_derives.len() > 1 {
+            return Err(format_err!(
+                "ingest_additional_derives should only be called once"
+            ));
+        }
+
+        self.response_derives.extend(
+            attribute_value
+                .split(',')
+                .map(|s| s.trim())
+                .map(|s| Ident::new(s, Span::call_site())),
+        );
+        Ok(())
+    }
+
+    pub(crate) fn response_derives(&self) -> TokenStream {
+        let derives = &self.response_derives;
+
+        quote! {
+            #[derive( #(#derives),* )]
+        }
+    }
+
+    pub(crate) fn response_enum_derives(&self) -> TokenStream {
+        let enum_derives: Vec<_> = self
+            .response_derives
+            .iter()
+            .filter(|derive| {
+                !derive.to_string().contains("erialize")
+                    && !derive.to_string().contains("Deserialize")
+            }).collect();
+
+        if enum_derives.len() > 0 {
+            quote! {
+                #[derive( #(#enum_derives),* )]
+            }
+        } else {
+            quote!()
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn response_derives_ingestion_works() {
+        let mut context = QueryContext::new_empty();
+
+        context
+            .ingest_additional_derives("PartialEq, PartialOrd, Serialize")
+            .unwrap();
+
+        assert_eq!(
+            context.response_derives().to_string(),
+            "# [ derive ( Deserialize , PartialEq , PartialOrd , Serialize ) ]"
+        );
+    }
+
+    #[test]
+    fn response_enum_derives_does_not_produce_empty_list() {
+        let context = QueryContext::new_empty();
+        assert_eq!(context.response_enum_derives().to_string(), "");
+    }
+
+    #[test]
+    fn response_enum_derives_works() {
+        let mut context = QueryContext::new_empty();
+
+        context
+            .ingest_additional_derives("PartialEq, PartialOrd, Serialize")
+            .unwrap();
+
+        assert_eq!(
+            context.response_enum_derives().to_string(),
+            "# [ derive ( PartialEq , PartialOrd ) ]"
+        );
+    }
+
+    #[test]
+    fn response_derives_fails_when_called_twice() {
+        let mut context = QueryContext::new_empty();
+
+        assert!(
+            context
+                .ingest_additional_derives("PartialEq, PartialOrd")
+                .is_ok()
+        );
+        assert!(context.ingest_additional_derives("Serialize").is_err());
+    }
 }