Extract union variant codegen to utility function

We are going to use it for interfaces

Author: tomhoule

graphql_query_derive/src/constants.rs

@@ -5,3 +5,7 @@ pub const TYPENAME_FIELD: &'static str = "__typename";
 pub fn string_type() -> Ident {
     Ident::new("String", Span::call_site())
 }
+
+pub fn float_type() -> Ident {
+    Ident::new("Float", Span::call_site())
+}

graphql_query_derive/src/selection.rs

@@ -1,3 +1,4 @@
+use constants::*;
 use graphql_parser::query::SelectionSet;
 
 #[derive(Debug, PartialEq)]
@@ -24,9 +25,26 @@ pub enum SelectionItem {
     InlineFragment(SelectionInlineFragment),
 }
 
+impl SelectionItem {
+    pub fn as_typename(&self) -> Option<&SelectionField> {
+        if let SelectionItem::Field(f) = self {
+            if f.name == TYPENAME_FIELD {
+                return Some(f);
+            }
+        }
+        None
+    }
+}
+
 #[derive(Debug, PartialEq)]
 pub struct Selection(pub Vec<SelectionItem>);
 
+impl Selection {
+    pub fn extract_typename(&self) -> Option<&SelectionField> {
+        self.0.iter().filter_map(|f| f.as_typename()).next()
+    }
+}
+
 impl<'a> ::std::convert::From<&'a SelectionSet> for Selection {
     fn from(selection_set: &SelectionSet) -> Selection {
         use graphql_parser::query::Selection;

graphql_query_derive/src/unions.rs

@@ -17,31 +17,14 @@ enum UnionError {
     MissingTypename { union_name: String },
 }
 
-impl GqlUnion {
-    pub fn response_for_selection(
-        &self,
-        query_context: &QueryContext,
-        selection: &Selection,
-        prefix: &str,
-    ) -> Result<TokenStream, failure::Error> {
-        let struct_name = Ident::new(prefix, Span::call_site());
-        let mut children_definitions: Vec<TokenStream> = Vec::new();
-
-        let typename_field = selection.0.iter().find(|f| {
-            if let SelectionItem::Field(f) = f {
-                f.name == TYPENAME_FIELD
-            } else {
-                false
-            }
-        });
+pub fn union_variants(
+    selection: &Selection,
+    query_context: &QueryContext,
+    prefix: &str,
+) -> Result<(Vec<TokenStream>, Vec<TokenStream>), failure::Error> {
+    let mut children_definitions = Vec::new();
 
-        if typename_field.is_none() {
-            Err(UnionError::MissingTypename {
-                union_name: prefix.into(),
-            })?;
-        }
-
-        let variants: Result<Vec<TokenStream>, failure::Error> = selection
+    let variants: Result<Vec<TokenStream>, failure::Error> = selection
             .0
             .iter()
             // ignore __typename
@@ -98,7 +81,29 @@ impl GqlUnion {
             })
             .collect();
 
-        let variants = variants?;
+    let variants = variants?;
+
+    Ok((variants, children_definitions))
+}
+
+impl GqlUnion {
+    pub fn response_for_selection(
+        &self,
+        query_context: &QueryContext,
+        selection: &Selection,
+        prefix: &str,
+    ) -> Result<TokenStream, failure::Error> {
+        let struct_name = Ident::new(prefix, Span::call_site());
+
+        let typename_field = selection.extract_typename();
+
+        if typename_field.is_none() {
+            Err(UnionError::MissingTypename {
+                union_name: prefix.into(),
+            })?;
+        }
+
+        let (variants, children_definitions) = union_variants(selection, query_context, prefix)?;
 
         Ok(quote!{
             #(#children_definitions)*