Fix fragments on unions

tomhoule · tomhoule · commit 8a2a29e7108d · 2019-01-05T12:51:40.000+01:00
diff --git a/graphql_client/tests/input_object_variables.rs b/graphql_client/tests/input_object_variables.rs
@@ -15,7 +15,7 @@ pub struct InputObjectVariablesQuery;
 
 #[test]
 fn input_object_variables_query_variables_struct() {
-    input_object_variables_query::Variables {
+    let _ = input_object_variables_query::Variables {
         msg: Some(input_object_variables_query::Message {
             content: None,
             to: Some(input_object_variables_query::Recipient {
diff --git a/graphql_client/tests/interfaces.rs b/graphql_client/tests/interfaces.rs
@@ -103,6 +103,7 @@ fn fragment_in_interface() {
                     name: "Audrey Lorde".to_string(),
                     public_status: PublicStatus {
                         display_name: false,
+                        on: PublicStatusOn::Person,
                     },
                     on: InterfaceWithFragmentQueryEverythingOn::Person(
                         InterfaceWithFragmentQueryEverythingOnPerson {
@@ -112,21 +113,28 @@ fn fragment_in_interface() {
                 },
                 InterfaceWithFragmentQueryEverything {
                     name: "Laïka".to_string(),
-                    public_status: PublicStatus { display_name: true },
+                    public_status: PublicStatus {
+                        display_name: true,
+                        on: PublicStatusOn::Dog
+                    },
                     on: InterfaceWithFragmentQueryEverythingOn::Dog(
                         InterfaceWithFragmentQueryEverythingOnDog { is_good_dog: true }
                     )
                 },
                 InterfaceWithFragmentQueryEverything {
                     name: "Mozilla".to_string(),
                     public_status: PublicStatus {
-                        display_name: false
+                        display_name: false,
+                        on: PublicStatusOn::Organization
                     },
                     on: InterfaceWithFragmentQueryEverythingOn::Organization,
                 },
                 InterfaceWithFragmentQueryEverything {
                     name: "Norbert".to_string(),
-                    public_status: PublicStatus { display_name: true },
+                    public_status: PublicStatus {
+                        display_name: true,
+                        on: PublicStatusOn::Dog
+                    },
                     on: InterfaceWithFragmentQueryEverythingOn::Dog(
                         InterfaceWithFragmentQueryEverythingOnDog { is_good_dog: true }
                     ),
diff --git a/graphql_client/tests/introspection.rs b/graphql_client/tests/introspection.rs
@@ -14,12 +14,9 @@ extern crate serde_json;
 pub struct IntrospectionQuery;
 
 #[test]
-fn introspection_schema() {
-    ()
-}
+fn introspection_schema() {}
 
-const INTROSPECTION_RESPONSE: &'static str =
-    include_str!("./introspection/introspection_response.json");
+const INTROSPECTION_RESPONSE: &str = include_str!("./introspection/introspection_response.json");
 
 #[test]
 fn leading_underscores_are_preserved() {
diff --git a/graphql_client/tests/operation_selection.rs b/graphql_client/tests/operation_selection.rs
@@ -41,8 +41,8 @@ pub struct Unrelated;
 )]
 pub struct SelectedOperation;
 
-const HEIGHTS_RESPONSE: &'static str = r##"{"mountainHeight": 224, "buildingHeight": 12}"##;
-const ECHO_RESPONSE: &'static str = r##"{"echo": "tiramisù"}"##;
+const HEIGHTS_RESPONSE: &str = r##"{"mountainHeight": 224, "buildingHeight": 12}"##;
+const ECHO_RESPONSE: &str = r##"{"echo": "tiramisù"}"##;
 
 #[test]
 fn operation_selection_works() {
diff --git a/graphql_client/tests/scalar_variables.rs b/graphql_client/tests/scalar_variables.rs
@@ -14,7 +14,7 @@ pub struct ScalarVariablesQuery;
 
 #[test]
 fn scalar_variables_query_variables_struct() {
-    scalar_variables_query::Variables {
+    let _ = scalar_variables_query::Variables {
         msg: "hello".to_string(),
         reps: Some(32),
     };
diff --git a/graphql_client/tests/union_query.rs b/graphql_client/tests/union_query.rs
@@ -57,22 +57,25 @@ fn fragment_on_union() {
     let expected = fragment_on_union::ResponseData {
         names: Some(vec![
             fragment_on_union::FragmentOnUnionNames::Person(
-                fragment_on_union::MyQueryNamesOnPerson {
+                fragment_on_union::FragmentOnUnionNamesOnPerson {
                     first_name: "Audrey".to_string(),
-                    last_name: Some("Lorde".to_string()),
                 },
             ),
-            fragment_on_union::FragmentOnUnionNames::Dog(fragment_on_union::MyQueryNamesOnDog {
-                name: "Laïka".to_string(),
-            }),
+            fragment_on_union::FragmentOnUnionNames::Dog(
+                fragment_on_union::FragmentOnUnionNamesOnDog {
+                    name: "Laïka".to_string(),
+                },
+            ),
             fragment_on_union::FragmentOnUnionNames::Organization(
-                fragment_on_union::MyQueryNamesOnOrganization {
+                fragment_on_union::FragmentOnUnionNamesOnOrganization {
                     title: "Mozilla".to_string(),
                 },
             ),
-            fragment_on_union::MyQueryNames::Dog(fragment_on_union::MyQueryNamesOnDog {
-                name: "Norbert".to_string(),
-            }),
+            fragment_on_union::FragmentOnUnionNames::Dog(
+                fragment_on_union::FragmentOnUnionNamesOnDog {
+                    name: "Norbert".to_string(),
+                },
+            ),
         ]),
     };
 
diff --git a/graphql_client_cli/src/generate.rs b/graphql_client_cli/src/generate.rs
@@ -2,13 +2,13 @@ use failure;
 use graphql_client_codegen::*;
 use std::fs::File;
 use std::io::Write as IoWrite;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use syn;
 
 #[allow(clippy::too_many_arguments)]
 pub fn generate_code(
     query_path: PathBuf,
-    schema_path: PathBuf,
+    schema_path: &Path,
     module_name: String,
     selected_operation: Option<String>,
     additional_derives: Option<String>,
@@ -47,7 +47,7 @@ pub fn generate_code(
         module_visibility,
     };
 
-    let gen = generate_module_token_stream(query_path, schema_path, Some(options))?;
+    let gen = generate_module_token_stream(query_path, &schema_path, Some(options))?;
 
     let mut file = File::create(output.clone())?;
 
diff --git a/graphql_client_cli/src/main.rs b/graphql_client_cli/src/main.rs
@@ -96,7 +96,7 @@ fn main() -> Result<(), failure::Error> {
             output,
         } => generate::generate_code(
             query_path,
-            schema_path,
+            &schema_path,
             module_name,
             selected_operation,
             additional_derives,
diff --git a/graphql_client_codegen/src/codegen.rs b/graphql_client_codegen/src/codegen.rs
@@ -60,7 +60,7 @@ pub(crate) fn response_for_query(
                     GqlFragment {
                         name: &fragment.name,
                         selection: Selection::from(&fragment.selection_set),
-                        on: on,
+                        on,
                         is_required: false.into(),
                     },
                 );
diff --git a/graphql_client_codegen/src/field_type.rs b/graphql_client_codegen/src/field_type.rs
@@ -83,10 +83,7 @@ impl<'schema> ::std::convert::From<&'schema graphql_parser::schema::Type> for Fi
     }
 }
 
-fn from_schema_type_inner<'schema>(
-    inner: &'schema graphql_parser::schema::Type,
-    non_null: bool,
-) -> FieldType<'schema> {
+fn from_schema_type_inner(inner: &graphql_parser::schema::Type, non_null: bool) -> FieldType {
     match inner {
         graphql_parser::schema::Type::ListType(inner) => {
             let inner = from_schema_type_inner(&*inner, false);
diff --git a/graphql_client_codegen/src/fragments.rs b/graphql_client_codegen/src/fragments.rs
@@ -17,7 +17,7 @@ pub(crate) struct GqlFragment<'query> {
 }
 
 impl<'query> GqlFragment<'query> {
-    /// Generate all the Rust code required by the fragment's selection.
+    /// Generate all the Rust code required by the fragment's object selection.
     pub(crate) fn to_rust(&self, context: &QueryContext) -> Result<TokenStream, ::failure::Error> {
         if let Some(obj) = context.schema.objects.get(&self.on) {
             obj.response_for_selection(context, &self.selection, &self.name)
diff --git a/graphql_client_codegen/src/inputs.rs b/graphql_client_codegen/src/inputs.rs
@@ -182,20 +182,14 @@ mod tests {
         .collect();
 
         let mut schema = ::schema::Schema::new();
-        schema.inputs.insert(cat.name.clone(), cat);
+        schema.inputs.insert(cat.name, cat);
         let mut context = QueryContext::new_empty(&schema);
         context.ingest_additional_derives("Clone").unwrap();
 
         assert_eq!(
             format!(
                 "{}",
-                context
-                    .schema
-                    .inputs
-                    .get("Cat")
-                    .unwrap()
-                    .to_rust(&context)
-                    .unwrap()
+                context.schema.inputs["Cat"].to_rust(&context).unwrap()
             ),
             expected
         );
diff --git a/graphql_client_codegen/src/interfaces.rs b/graphql_client_codegen/src/interfaces.rs
@@ -1,3 +1,4 @@
+use crate::constants::TYPENAME_FIELD;
 use failure;
 use objects::GqlObjectField;
 use proc_macro2::{Ident, Span, TokenStream};
@@ -37,7 +38,7 @@ impl<'schema> GqlInterface<'schema> {
                 .iter()
                 // Only keep what we can handle
                 .filter(|f| match f {
-                    SelectionItem::Field(f) => f.name != "__typename",
+                    SelectionItem::Field(f) => f.name != TYPENAME_FIELD,
                     SelectionItem::FragmentSpread(SelectionFragmentSpread { fragment_name }) => {
                         // only if the fragment refers to the interface’s own fields (to take into account type-refining fragments)
                         let fragment = query_context
@@ -157,8 +158,9 @@ impl<'schema> GqlInterface<'schema> {
         let union_selection = self.union_selection(&selection, &query_context);
 
         let (mut union_variants, union_children, used_variants) =
-            union_variants(&union_selection, query_context, prefix)?;
+            union_variants(&union_selection, query_context, prefix, &self.name)?;
 
+        // Add the non-selected variants to the generated enum's variants.
         union_variants.extend(
             self.implemented_by
                 .iter()
@@ -170,19 +172,20 @@ impl<'schema> GqlInterface<'schema> {
         );
 
         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! {
-                #derives
-                #[serde(tag = "__typename")]
-                pub enum #attached_enum_name {
-                    #(#union_variants,)*
-                }
+        let (attached_enum, last_object_field) =
+            if selection.extract_typename(query_context).is_some() {
+                let attached_enum = quote! {
+                    #derives
+                    #[serde(tag = "__typename")]
+                    pub enum #attached_enum_name {
+                        #(#union_variants,)*
+                    }
+                };
+                let last_object_field = quote!(#[serde(flatten)] pub on: #attached_enum_name,);
+                (attached_enum, last_object_field)
+            } else {
+                (quote!(), quote!())
             };
-            let last_object_field = quote!(#[serde(flatten)] pub on: #attached_enum_name,);
-            (attached_enum, last_object_field)
-        } else {
-            (quote!(), quote!())
-        };
 
         Ok(quote! {
 
@@ -238,7 +241,7 @@ mod tests {
         let iface = GqlInterface {
             description: None,
             implemented_by: HashSet::new(),
-            name: "MyInterface".into(),
+            name: "MyInterface",
             fields: vec![],
             is_required: Cell::new(true),
         };
diff --git a/graphql_client_codegen/src/lib.rs b/graphql_client_codegen/src/lib.rs
@@ -82,7 +82,7 @@ pub struct GraphQLClientDeriveOptions {
 /// Generates the code for a Rust module given a query, a schema and options.
 pub fn generate_module_token_stream(
     query_path: std::path::PathBuf,
-    schema_path: std::path::PathBuf,
+    schema_path: &std::path::Path,
     options: Option<GraphQLClientDeriveOptions>,
 ) -> Result<TokenStream, failure::Error> {
     let options = options.unwrap();
@@ -126,7 +126,7 @@ pub fn generate_module_token_stream(
     // Check the schema cache.
     let schema_string: String = {
         let mut lock = SCHEMA_CACHE.lock().expect("schema cache is poisoned");
-        match lock.entry(schema_path.clone()) {
+        match lock.entry(schema_path.to_path_buf()) {
             ::std::collections::hash_map::Entry::Occupied(o) => o.get().clone(),
             ::std::collections::hash_map::Entry::Vacant(v) => {
                 let schema_string = read_file(v.key())?;
diff --git a/graphql_client_codegen/src/operations.rs b/graphql_client_codegen/src/operations.rs
@@ -92,44 +92,6 @@ impl<'query> Operation<'query> {
     }
 }
 
-// impl ::std::convert::From<OperationDefinition> for Operation<'query> {
-//     fn from(definition: OperationDefinition) -> Operation<'query> {
-//         match definition {
-//             OperationDefinition::Query(q) => Operation {
-//                 name: q.name.expect("unnamed operation"),
-//                 operation_type: OperationType::Query,
-//                 variables: q
-//                     .variable_definitions
-//                     .iter()
-//                     .map(|v| v.clone().into())
-//                     .collect(),
-//                 selection: (&q.selection_set).into(),
-//             },
-//             OperationDefinition::Mutation(m) => Operation {
-//                 name: m.name.expect("unnamed operation"),
-//                 operation_type: OperationType::Mutation,
-//                 variables: m
-//                     .variable_definitions
-//                     .iter()
-//                     .map(|v| v.clone().into())
-//                     .collect(),
-//                 selection: (&m.selection_set).into(),
-//             },
-//             OperationDefinition::Subscription(s) => Operation {
-//                 name: s.name.expect("unnamed operation"),
-//                 operation_type: OperationType::Subscription,
-//                 variables: s
-//                     .variable_definitions
-//                     .iter()
-//                     .map(|v| v.clone().into())
-//                     .collect(),
-//                 selection: (&s.selection_set).into(),
-//             },
-//             OperationDefinition::SelectionSet(_) => panic!(SELECTION_SET_AT_ROOT),
-//         }
-//     }
-// }
-
 impl<'query> ::std::convert::From<&'query OperationDefinition> for Operation<'query> {
     fn from(definition: &'query OperationDefinition) -> Operation<'query> {
         match *definition {
diff --git a/graphql_client_codegen/src/schema.rs b/graphql_client_codegen/src/schema.rs
diff --git a/graphql_client_codegen/src/selectable.rs b/graphql_client_codegen/src/selectable.rs
diff --git a/graphql_client_codegen/src/selection.rs b/graphql_client_codegen/src/selection.rs
diff --git a/graphql_client_codegen/src/shared.rs b/graphql_client_codegen/src/shared.rs
diff --git a/graphql_client_codegen/src/tests/github.rs b/graphql_client_codegen/src/tests/github.rs
diff --git a/graphql_client_codegen/src/unions.rs b/graphql_client_codegen/src/unions.rs
diff --git a/graphql_query_derive/src/lib.rs b/graphql_query_derive/src/lib.rs

Original file line number	Diff line number	Diff line change
`@@ -83,10 +83,7 @@ impl<'schema> ::std::convert::From<&'schema graphql_parser::schema::Type> for Fi`
`83`	`83`	`}`
`84`	`84`	`}`
`85`	`85`
`86`		`-fn from_schema_type_inner<'schema>(`
`87`		`- inner: &'schema graphql_parser::schema::Type,`
`88`		`- non_null: bool,`
`89`		`-) -> FieldType<'schema> {`
	`86`	`+fn from_schema_type_inner(inner: &graphql_parser::schema::Type, non_null: bool) -> FieldType {`
`90`	`87`	`match inner {`
`91`	`88`	`graphql_parser::schema::Type::ListType(inner) => {`
`92`	`89`	`let inner = from_schema_type_inner(&*inner, false);`