Add docs on enum variants

Author: tomhoule

graphql_query_derive/src/enums.rs

@@ -2,32 +2,47 @@ use proc_macro2::{Ident, Span, TokenStream};
 
 pub const ENUMS_PREFIX: &str = "";
 
+#[derive(Debug, PartialEq)]
+pub struct EnumVariant {
+    pub description: Option<String>,
+    pub name: String,
+}
+
 #[derive(Debug, PartialEq)]
 pub struct GqlEnum {
     pub description: Option<String>,
     pub name: String,
-    pub variants: Vec<String>,
+    pub variants: Vec<EnumVariant>,
 }
 
 impl GqlEnum {
     pub fn to_rust(&self) -> TokenStream {
-        let variants: Vec<Ident> = self
+        let variant_names: Vec<TokenStream> = self
             .variants
             .iter()
-            .map(|v| Ident::new(v, Span::call_site()))
+            .map(|v| {
+                let name = Ident::new(&v.name, Span::call_site());
+                let description = &v.description;
+                let description = description.as_ref().map(|d| quote!(#[doc = #d]));
+                quote!(#description #name)
+            })
             .collect();
-        let variants = &variants;
+        let variant_names = &variant_names;
         let name_ident = Ident::new(&format!("{}{}", ENUMS_PREFIX, self.name), Span::call_site());
-        let constructors: Vec<_> = variants.iter().map(|v| quote!(#name_ident::#v)).collect();
+        let constructors: Vec<_> = variant_names
+            .iter()
+            .map(|v| quote!(#name_ident::#v))
+            .collect();
         let constructors = &constructors;
-        let variant_str = &self.variants;
+        let variant_str: Vec<String> = self.variants.iter().map(|v| v.name.clone()).collect();
+        let variant_str = &variant_str;
 
         let name = name_ident.clone();
 
         quote! {
             #[derive(Debug)]
             pub enum #name {
-                #(#variants,)*
+                #(#variant_names,)*
                 Other(String),
             }
 

graphql_query_derive/src/schema.rs

@@ -1,4 +1,4 @@
-use enums::GqlEnum;
+use enums::{EnumVariant, GqlEnum};
 use failure;
 use field_type::FieldType;
 use fragments::GqlFragment;
@@ -269,7 +269,14 @@ impl ::std::convert::From<graphql_parser::schema::Document> for Schema {
                             GqlEnum {
                                 name: enm.name.clone(),
                                 description: enm.description,
-                                variants: enm.values.iter().map(|v| v.name.clone()).collect(),
+                                variants: enm
+                                    .values
+                                    .iter()
+                                    .map(|v| EnumVariant {
+                                        description: v.description.clone(),
+                                        name: v.name.clone(),
+                                    })
+                                    .collect(),
                             },
                         );
                     }
@@ -355,12 +362,17 @@ impl ::std::convert::From<::introspection_response::IntrospectionResponse> for S
 
             match ty.kind {
                 Some(__TypeKind::ENUM) => {
-                    let variants: Vec<String> = ty
+                    let variants: Vec<EnumVariant> = ty
                         .enum_values
                         .clone()
                         .expect("enum variants")
                         .iter()
-                        .map(|t| t.clone().map(|t| t.name.expect("enum variant name")))
+                        .map(|t| {
+                            t.clone().map(|t| EnumVariant {
+                                description: t.description,
+                                name: t.name.expect("enum variant name"),
+                            })
+                        })
                         .filter_map(|t| t)
                         .collect();
                     let mut enm = GqlEnum {

graphql_query_derive/src/tests/github.rs

@@ -37,8 +37,8 @@ fn ast_from_graphql_and_json_produce_the_same_schema() {
     {
         assert_eq!(json_name, gql_name);
         assert_eq!(
-            HashSet::<&String>::from_iter(json_value.variants.iter()),
-            HashSet::<&String>::from_iter(gql_value.variants.iter()),
+            HashSet::<&String>::from_iter(json_value.variants.iter().map(|v| &v.name)),
+            HashSet::<&String>::from_iter(gql_value.variants.iter().map(|v| &v.name)),
         );
     }
 }