Add full doctest example for the GraphQLQuery trait

Author: tomhoule

CHANGELOG.md

@@ -11,6 +11,11 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 - Implemented support for the `extensions` field on errors from the June 2018 spec (#64).
 
+### Fixed
+
+- `Location` fields on errors were not public.
+- The field names on input objects were not properly converted between snake and camel case.
+
 
 ### Changed
 

graphql_query_derive/src/inputs.rs

@@ -1,5 +1,6 @@
 use failure;
 use graphql_parser;
+use heck::SnakeCase;
 use introspection_response;
 use objects::GqlObjectField;
 use proc_macro2::{Ident, Span, TokenStream};
@@ -21,7 +22,7 @@ impl GqlInput {
         fields.sort_unstable_by(|a, b| a.name.cmp(&b.name));
         let fields = fields.iter().map(|field| {
             let ty = field.type_.to_rust(&context, "");
-            let name = Ident::new(&field.name, Span::call_site());
+            let name = Ident::new(&field.name.to_snake_case(), Span::call_site());
             quote!(pub #name: #ty)
         });
 

graphql_query_derive/src/query.rs

@@ -1,6 +1,7 @@
 use failure;
 use fragments::GqlFragment;
 use graphql_parser;
+use heck::SnakeCase;
 use proc_macro2::{Ident, Span, TokenStream};
 use schema::Schema;
 use selection::Selection;
@@ -43,7 +44,7 @@ impl QueryContext {
         let fields = self.variables.iter().map(|variable| {
             let name = &variable.name;
             let ty = variable.ty.to_rust(self, "");
-            let name = Ident::new(name, Span::call_site());
+            let name = Ident::new(&name.to_snake_case(), Span::call_site());
             quote!(pub #name: #ty)
         });
 
@@ -54,6 +55,7 @@ impl QueryContext {
 
         quote! {
             #[derive(Serialize)]
+            #[serde(rename_all = "camelCase")]
             pub struct Variables {
                 #(#fields,)*
             }

graphql_query_derive/src/schema.rs

@@ -477,7 +477,7 @@ mod tests {
 
     #[test]
     fn build_schema_works() {
-        let gql_schema = include_str!("star_wars_schema.graphql");
+        let gql_schema = include_str!("tests/star_wars_schema.graphql");
         let gql_schema = graphql_parser::parse_schema(gql_schema).unwrap();
         let built = Schema::from(gql_schema);
         assert_eq!(

graphql_query_derive/src/tests/star_wars_query.graphql

@@ -0,0 +1,6 @@
+query StarWarsQuery($episodeForHero: Episode!) {
+  hero(episode: $episodeForHero) {
+    name
+    __typename
+  }
+}

graphql_query_derive/src/star_wars_schema.graphql renamed to graphql_query_derive/src/tests/star_wars_schema.graphql

@@ -20,7 +20,52 @@ use std::collections::HashMap;
 
 /// A convenience trait that can be used to build a GraphQL request body.
 ///
-/// This will be implemented for you by codegen in the normal case.
+/// This will be implemented for you by codegen in the normal case. It is implemented on the struct you place the derive on.
+///
+/// Example:
+///
+///
+/// ```
+/// extern crate failure;
+/// #[macro_use]
+/// extern crate graphql_client;
+/// #[macro_use]
+/// extern crate serde_derive;
+/// #[macro_use]
+/// extern crate serde_json;
+/// extern crate serde;
+///
+/// #[derive(GraphQLQuery)]
+/// #[graphql(
+///   query_path = "graphql_query_derive/src/tests/star_wars_query.graphql",
+///   schema_path = "graphql_query_derive/src/tests/star_wars_schema.graphql"
+/// )]
+/// struct StarWarsQuery;
+///
+/// fn main() -> Result<(), failure::Error> {
+///     use graphql_client::GraphQLQuery;
+///
+///     let variables = star_wars_query::Variables {
+///         episode_for_hero: star_wars_query::Episode::NEWHOPE,
+///     };
+///
+///     let expected_body = json!({
+///         "query": star_wars_query::QUERY,
+///         "variables": {
+///             "episodeForHero": "NEWHOPE"
+///         },
+///     });
+///
+///     let actual_body = serde_json::to_value(
+///         StarWarsQuery::build_query(variables)
+///     )?;
+///
+///     assert_eq!(actual_body, expected_body);
+///
+///     Ok(())
+/// }
+/// ```
+/// ```
 pub trait GraphQLQuery<'de> {
     /// The shape of the variables expected by the query. This should be a generated struct most of the time.
     type Variables: serde::Serialize;
@@ -31,7 +76,7 @@ pub trait GraphQLQuery<'de> {
     fn build_query(variables: Self::Variables) -> GraphQLQueryBody<Self::Variables>;
 }
 
-/// The form in which queries are sent over HTTP in most implemnetations.
+/// The form in which queries are sent over HTTP in most implementations. This will be built using the [`GraphQLQuery`] trait normally.
 #[derive(Debug, Serialize, Deserialize)]
 pub struct GraphQLQueryBody<Variables>
 where