Merge remote-tracking branch 'origin/master'

# Conflicts: #	public

Author: oliemansm

README.md

@@ -1,4 +1,7 @@
-# GraphQL Kickstart Documentation
+# [GraphQL Kickstart Documentation](https://www.graphql-java-kickstart.com/tools/)
 [![Build Status](https://travis-ci.org/graphql-java-kickstart/documentation.svg?branch=master)](https://travis-ci.org/graphql-java-kickstart/documentation)
 
-Documentation for GraphQL Kickstart projects.
+## Running the site locally
+1. Clone this repository
+2. Execute `brew install hugo`
+3. Execute `hugo server` in the root of the project

content/tools/_index.md

@@ -23,6 +23,6 @@ GraphQL Java Tools aims for seamless integration with Java, but works for any JV
 A few libraries exist to ease the boilerplate pain, including [GraphQL-Java's built-in schema-first wiring](http://graphql-java.readthedocs.io/en/latest/schema.html), but none (so far) do type and datafetcher discovery.
 * **Stateful Data Fetchers**: If you're using an IOC container (like Spring), it's hard to wire up datafetchers that make use of beans you've already defined without a bunch of fragile configuration. GraphQL Java Tools allows you to register "Resolvers" for any type that can bring state along and use that to resolve fields.
 * **Generated DataFetchers**: GraphQL Java Tools automatically creates data fetchers for your fields that call the appropriate method on your java class. This means all you have to do to create a new field is add the field definition to your schema and add a corresponding method on your class.
-* **Type->Class Discovery**: GraphQL Java Tools starts from your root objects (Query, Mutation) and, as it's generating data fetchers for you, starts to learn about the classes you use for a certain GraphQL type.
-* **Class Validation**: Since there aren't any compile-time checks of the type->class relationship, GraphQL Java Tools will warn you if you provide classes/types that you don't need to, as well as erroring if you use the wrong Java class for a certain GraphQL type when it builds the schema.
+* **Type → Class Discovery**: GraphQL Java Tools starts from your root objects (Query, Mutation) and, as it's generating data fetchers for you, starts to learn about the classes you use for a certain GraphQL type.
+* **Class Validation**: Since there aren't any compile-time checks of the type → class relationship, GraphQL Java Tools will warn you if you provide classes/types that you don't need to, as well as throwing errors if you use the wrong Java class for a certain GraphQL type when it builds the schema.
 * **Unit Testing**: Since your GraphQL schema is independent of your data model, this makes your classes simple and extremely testable.

content/tools/getting-started/index.md

@@ -49,7 +49,7 @@ Add the `graphql-java-tools` dependency:
 
 ## Using the latest development build
 
-Snapshot versions of the current `master` branch are availble on JFrog. Check the next snapshot version on
+Snapshot versions of the current `master` branch are available on JFrog. Check the next snapshot version on
 [Github](https://github.com/graphql-java-kickstart/graphql-java-tools/blob/master/gradle.properties)
 
 ### Build with Gradle

content/tools/schema-definition/index.md

@@ -55,7 +55,7 @@ type Author {
 ```
 
 GraphQL Java Tools will expect to be given three classes that map to the GraphQL types: `Query`, `Book`, and `Author`.
-The Data classes for Book and Author are simple:
+The Data classes for `Book` and `Author` are simple:
 
 ```java
 class Book {
@@ -81,10 +81,10 @@ class Author {
 }
 ```
 
-But what about the complex fields on `Query` and `Book`?
+What about the complex fields on `Query` and `Book`?
 These are handled by "Resolvers". Resolvers are object instances that reference the "Data Class" they resolve fields for.
 
-The BookResolver might look something like this:
+The `BookResolver` might look something like this:
 ```java
 class BookResolver implements GraphQLResolver<Book> /* This class is a resolver for the Book "Data Class" */ {
 
@@ -100,13 +100,13 @@ class BookResolver implements GraphQLResolver<Book> /* This class is a resolver
 }
 ```
 
-When given a BookResolver instance, GraphQL Java Tools first attempts to map fields to methods on the resolver before mapping them to fields or methods on the data class.
+When given a `BookResolver` instance, GraphQL Java Tools first attempts to map fields to methods on the resolver before mapping them to fields or methods on the data class.
 If there is a matching method on the resolver, the data class instance is passed as the first argument to the resolver function. This does not apply to root resolvers, since those don't have a data class to resolve for.
-An optional argument can be defined to inject the `DataFetchingEnvironment`, and must be the last argument.
+An optional parameter can be defined to inject the `DataFetchingEnvironment`, and must be the last argument.
 
 ### Root Resolvers
 
-Since the Query/Mutation/Subscription objects are root GraphQL objects, they doesn't have an associated data class. In those cases, any resolvers implementing `GraphQLQueryResolver`, `GraphQLMutationResolver`, or `GraphQLSubscriptionResolver` will be searched for methods that map to fields in their respective root types. Root resolver methods can be spread between multiple resolvers, but a simple example is below:
+Since the Query/Mutation/Subscription objects are root GraphQL objects, they don't have an associated data class. In those cases, any resolvers implementing `GraphQLQueryResolver`, `GraphQLMutationResolver`, or `GraphQLSubscriptionResolver` will be searched for methods that map to fields in their respective root types. Root resolver methods can be spread between multiple resolvers, but a simple example is below:
 ```java
 class Query implements GraphQLQueryResolver {
 
@@ -152,9 +152,7 @@ Last of all, if the data class implements`java.util.Map` then:
 1. `method get(name)`
 
 
-*Note:* All reflection discovery is done on startup, and runtime reflection method calls use [reflectasm](https://github.com/EsotericSoftware/reflectasm), which increases performance and unifies stacktraces. No more `InvocationTargetException`!
-
-*Note:* `java.util.Optional` can be used for nullable field arguments and nullable return values, and the schema parser will verify that it's not used with non-null field arguments and return values.
+<!--*Note:* `java.util.Optional` can be used for nullable field arguments and nullable return values, and the schema parser will verify that it's not used with non-null field arguments and return values.-->
 
 *Note:* Methods on `java.lang.Object` are excluded from method matching, for example a field named `class` will require a method named `getFieldClass` defined.
 
@@ -217,7 +215,7 @@ SchemaParser.newParser()
 
 ## Making the graphql-java Schema Instance
 
-After you've passed all relavant schema files/class to the parser, call `.build()` and `.makeExecutableSchema()` to get a graphql-java `GraphQLSchema`:
+After you've passed all relevant schema files/class to the parser, call `.build()` and `.makeExecutableSchema()` to get a graphql-java `GraphQLSchema`:
 
 ```java
 SchemaParser.newParser()
@@ -226,7 +224,7 @@ SchemaParser.newParser()
  .makeExecutableSchema()
 ```
 
-If you want to build the `GraphQLSchema` yourself, you can get all of the parsed objects with `parseSchemaObjects()`:
+If you want to build the `GraphQLSchema` yourself, you can get all the parsed objects with `parseSchemaObjects()`:
 
 ```java
 SchemaParser.newParser()

public

@@ -0,0 +1 @@
+www.graphql-java-kickstart.com