graphql_java_gen 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a3088c3fd787e2d815792f8bb8f6a0b3fe414829
+  data.tar.gz: 1058513015d8fe05d201f7e72ef5f3a007a94b8a
+SHA512:
+  metadata.gz: a3d82e27f2ca1cfbf3a7b7c082a5a75d631607f32f1d6bc2e7fdb54840ed023814ce81c8fe4d6e65bf4576a0c28bb1eadbb988aecb8593362935fa2603648e18
+  data.tar.gz: 1c040d36778c54054772af31b651ac30db8aef05f77812c158e51cbcf33ab98b171d942d1aaf1837439a84de2dcbeefab0063a6e43eb2455e40b666d5ff86d79

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Shopify
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,119 @@
+# GraphQLJavaGen
+
+Generate code for a specific GraphQL schema that provides query
+builders and response classes.
+
+## Installation
+
+The code generator requires ruby version 2.1 or later.
+
+It is recommended to use [bundler](http://bundler.io/) to install
+the code generators ruby package.
+
+Until this project is released, it is recommended to include it into
+a project as a git submodule.
+
+    $ git submodule https://github.com/Shopify/graphql_java_gen.git
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'graphql_java_gen', path: 'graphql_java_gen'
+```
+
+And then execute:
+
+    $ bundle
+
+The generated code depends on the com.shopify.graphql.support package
+which is in the support directory of this repo. Create a symlink to
+include that project in a [gradle multi-project build
+](https://docs.gradle.org/current/userguide/multi_project_builds.html)
+
+    $ ln -s graphql_java_gen/support GraphQLSupport
+
+## Usage
+
+Create a script that generates the code for a GraphQL API
+
+```ruby
+require 'graphql_java_gen'
+require 'graphql_schema'
+require 'json'
+
+introspection_result = File.read("graphql_schema.json")
+schema = GraphQLSchema.new(JSON.parse(introspection_result))
+
+GraphQLJavaGen.new(schema,
+  package_name: "com.example.MyApp",
+  nest_under: 'ExampleSchema',
+  custom_scalars: [
+    GraphQLJavaGen::Scalar.new(
+      type_name: 'Decimal',
+      java_type: 'BigDecimal',
+      deserialize_expr: ->(expr) { "new BigDecimal(jsonAsString(#{expr}, key))" },
+      imports: ['java.math.BigDecimal'],
+    ),
+  ]
+).save("#{Dir.pwd}/../MyApp/src/main/java/com/example/MyApp/ExampleSchema.java")
+```
+
+That generated code depends on the com.shopify.graphql.support package.
+
+The generated code includes a query builder that can be used to create a GraphQL
+query in a type-safe manner.
+
+```java
+String queryString = ExampleSchema.query(query -> query
+    .user(user -> user
+        .firstName()
+        .lastName()
+    )
+).toString();
+```
+
+The generated code also includes response classes that will deserialize the response
+and provide methods for accessing the field data with it already coerced to the
+correct type.
+
+```java
+ExampleSchema.QueryResponse response = ExampleSchema.QueryResponse.fromJson(responseJson);
+if (!response.getErrors().isEmpty()) {
+    for (Error error : response.getErrors()) {
+        System.err.println("GraphQL error: " + error.message());
+    }
+}
+if (data != null) {
+    ExampleSchema.User user = data.getUser();
+    System.out.println("user.firstName() + " " + user.lastName());
+}
+```
+
+## Lambda Expressions
+
+The java 8 lambda expressions feature is essential for having a
+nice syntax for the query builder. This feature is also available
+for Android apps by using the
+[Jack toolchain](https://source.android.com/source/jack.html).
+
+If an older version of java must be used, then
+[retrolambda](https://github.com/orfjackal/retrolambda) can be used
+to backport this feature to java 5-7.
+
+## Development
+
+After checking out the repo, run `bundle` to install ruby dependencies.
+Then, run `rake test` to run the tests.
+
+To install this gem onto your local machine, run `bundle exec rake
+install` or reference it from a Gemfile using the path option
+(e.g. `gem 'graphql_java_gen', path: '~/src/graphql_java_gen'`).
+
+## Contributing
+
+See our [contributing guidelines](CONTRIBUTING.md) for more information.
+
+## License
+
+The gem is available as open source under the terms of the
+[MIT License](http://opensource.org/licenses/MIT).

data/codegen/lib/graphql_java_gen.rb

@@ -0,0 +1,263 @@
+require 'graphql_java_gen/version'
+require 'graphql_java_gen/reformatter'
+require 'graphql_java_gen/scalar'
+require 'graphql_java_gen/annotation'
+
+require 'erb'
+require 'set'
+
+class GraphQLJavaGen
+  attr_reader :schema, :package_name, :scalars, :imports, :script_name, :schema_name
+
+  def initialize(schema,
+    package_name:, nest_under:, script_name: 'graphql_java_gen gem',
+    custom_scalars: [], custom_annotations: []
+  )
+    @schema = schema
+    @schema_name = nest_under
+    @script_name = script_name
+    @package_name = package_name
+    @scalars = (BUILTIN_SCALARS + custom_scalars).reduce({}) { |hash, scalar| hash[scalar.type_name] = scalar; hash }
+    @scalars.default_proc = ->(hash, key) { DEFAULT_SCALAR }
+    @annotations = custom_annotations
+    @imports = (@scalars.values.map(&:imports) + @annotations.map(&:imports)).flatten.sort.uniq
+  end
+
+  def save(path)
+    File.write(path, generate)
+  end
+
+  def generate
+    reformat(TEMPLATE_ERB.result(binding))
+  end
+
+  private
+
+  class << self
+    private
+
+    def erb_for(template_filename)
+      erb = ERB.new(File.read(template_filename))
+      erb.filename = template_filename
+      erb
+    end
+  end
+
+  TEMPLATE_ERB = erb_for(File.expand_path("../graphql_java_gen/templates/APISchema.java.erb", __FILE__))
+  private_constant :TEMPLATE_ERB
+
+  DEFAULT_SCALAR = Scalar.new(
+    type_name: nil,
+    java_type: 'String',
+    deserialize_expr: ->(expr) { "jsonAsString(#{expr}, key)" },
+  )
+  private_constant :DEFAULT_SCALAR
+
+  BUILTIN_SCALARS = [
+    Scalar.new(
+      type_name: 'Int',
+      java_type: 'int',
+      deserialize_expr: ->(expr) { "jsonAsInteger(#{expr}, key)" },
+    ),
+    Scalar.new(
+      type_name: 'Float',
+      java_type: 'double',
+      deserialize_expr: ->(expr) { "jsonAsDouble(#{expr}, key)" },
+    ),
+    Scalar.new(
+      type_name: 'String',
+      java_type: 'String',
+      deserialize_expr: ->(expr) { "jsonAsString(#{expr}, key)" },
+    ),
+    Scalar.new(
+      type_name: 'Boolean',
+      java_type: 'boolean',
+      deserialize_expr: ->(expr) { "jsonAsBoolean(#{expr}, key)" },
+    ),
+    Scalar.new(
+      type_name: 'ID',
+      java_type: 'ID',
+      deserialize_expr: ->(expr) { "new ID(jsonAsString(#{expr}, key))" },
+      imports: ['com.shopify.graphql.support.ID'],
+    ),
+  ]
+  private_constant :BUILTIN_SCALARS
+
+  # From: http://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html
+  RESERVED_WORDS = [
+    "abstract", "assert", "boolean", "break", "byte", "case", "catch", "char", "class", "const", "continue", "default", "do", "double", "else", "enum", "extends", "final", "finally", "float",
+    "for", "goto", "if", "implements", "import", "instanceof", "int", "interface", "long", "native", "new", "package", "private", "protected", "public", "return", "short", "static", "strictfp", "super",
+    "switch", "synchronized", "this", "throw", "throws", "transient", "try", "void", "volatile", "while"
+  ]
+  private_constant :RESERVED_WORDS
+
+  def escape_reserved_word(word)
+    return word unless RESERVED_WORDS.include?(word)
+    "#{word}Value"
+  end
+
+  def reformat(code)
+    Reformatter.new(indent: " " * 4).reformat(code)
+  end
+
+  def java_input_type(type, non_null: false)
+    case type.kind
+    when "NON_NULL"
+      java_input_type(type.of_type, non_null: true)
+    when "SCALAR"
+      non_null ? scalars[type.name].non_nullable_type : scalars[type.name].nullable_type
+    when 'LIST'
+      "List<#{java_input_type(type.of_type.unwrap_non_null)}>"
+    when 'INPUT_OBJECT', 'ENUM'
+      type.name
+    else
+      raise NotImplementedError, "Unhandled #{type.kind} input type"
+    end
+  end
+
+  def java_output_type(type)
+    type = type.unwrap_non_null
+    case type.kind
+    when "SCALAR"
+      scalars[type.name].nullable_type
+    when 'LIST'
+      "List<#{java_output_type(type.of_type)}>"
+    when 'ENUM', 'OBJECT', 'INTERFACE', 'UNION'
+      type.name
+    else
+      raise NotImplementedError, "Unhandled #{type.kind} response type"
+    end
+  end
+
+  def generate_build_input_code(expr, type, depth: 1)
+    type = type.unwrap_non_null
+    case type.kind
+    when 'SCALAR'
+      if ['Int', 'Float', 'Boolean'].include?(type.name)
+        "_queryBuilder.append(#{expr});"
+      else
+        "Query.appendQuotedString(_queryBuilder, #{expr}.toString());"
+      end
+    when 'ENUM'
+      "_queryBuilder.append(#{expr}.toString());"
+    when 'LIST'
+      item_type = type.of_type
+      <<-JAVA
+        _queryBuilder.append('[');
+
+        String listSeperator#{depth} = "";
+        for (#{java_input_type(item_type)} item#{depth} : #{expr}) {
+          _queryBuilder.append(listSeperator#{depth});
+          listSeperator#{depth} = ",";
+          #{generate_build_input_code("item#{depth}", item_type, depth: depth + 1)}
+        }
+        _queryBuilder.append(']');
+      JAVA
+    when 'INPUT_OBJECT'
+      "#{expr}.appendTo(_queryBuilder);"
+    else
+      raise NotImplementedError, "Unexpected #{type.kind} argument type"
+    end
+  end
+
+  def generate_build_output_code(expr, type, depth: 1, non_null: false, &block)
+    if type.non_null?
+      return generate_build_output_code(expr, type.of_type, depth: depth, non_null: true, &block)
+    end
+
+    statements = ""
+    unless non_null
+      optional_name = "optional#{depth}"
+      generate_build_output_code(expr, type, depth: depth, non_null: true) do |item_statements, item_expr|
+        statements = <<-JAVA
+          #{java_output_type(type)} #{optional_name} = null;
+          if (!#{expr}.isJsonNull()) {
+            #{item_statements}
+            #{optional_name} = #{item_expr};
+          }
+        JAVA
+      end
+      return yield statements, optional_name
+    end
+
+    expr = case type.kind
+    when 'SCALAR'
+      scalars[type.name].deserialize(expr)
+    when 'LIST'
+      list_name = "list#{depth}"
+      element_name = "element#{depth}"
+      generate_build_output_code(element_name, type.of_type, depth: depth + 1) do |item_statements, item_expr|
+        statements = <<-JAVA
+          #{java_output_type(type)} #{list_name} = new ArrayList<>();
+          for (JsonElement #{element_name} : jsonAsArray(#{expr}, key)) {
+            #{item_statements}
+            #{list_name}.add(#{item_expr});
+          }
+        JAVA
+      end
+      list_name
+    when 'OBJECT'
+      "new #{type.name}(jsonAsObject(#{expr}, key))"
+    when 'INTERFACE', 'UNION'
+      "Unknown#{type.name}.create(jsonAsObject(#{expr}, key))"
+    when 'ENUM'
+       "#{type.name}.fromGraphQl(jsonAsString(#{expr}, key))"
+    else
+      raise NotImplementedError, "Unexpected #{type.kind} argument type"
+    end
+    yield statements, expr
+  end
+
+  def java_arg_defs(field, skip_optional: false)
+    defs = []
+    field.required_args.each do |arg|
+      defs << "#{java_input_type(arg.type)} #{escape_reserved_word(arg.camelize_name)}"
+    end
+    unless field.optional_args.empty? || skip_optional
+      defs << "#{field.classify_name}ArgumentsDefinition argsDef"
+    end
+    if field.subfields?
+      defs << "#{field.type.unwrap.name}QueryDefinition queryDef"
+    end
+    defs.join(', ')
+  end
+
+  def java_required_arg_defs(field)
+    defs = []
+    field.required_args.each do |arg|
+      defs << "#{java_input_type(arg.type)} #{escape_reserved_word(arg.camelize_name)}"
+    end
+    unless field.optional_args.empty?
+      defs << "#{field.classify_name}ArgumentsDefinition argsDef"
+    end
+    if field.subfields?
+      defs << "#{field.type.unwrap.classify_name}QueryDefinition queryDef"
+    end
+    defs.join(', ')
+  end
+
+  def java_arg_expresions_with_empty_optional_args(field)
+    expressions = field.required_args.map { |arg| escape_reserved_word(arg.camelize_name) }
+    expressions << "args -> {}"
+    if field.subfields?
+      expressions << "queryDef"
+    end
+    expressions.join(', ')
+  end
+
+  def java_implements(type)
+    return "implements #{type.name} " unless type.object?
+    return "" if type.interfaces.empty?
+    "implements #{type.interfaces.map{ |interface| interface.name }.join(', ')} "
+  end
+
+  def java_annotations(field)
+    @annotations.map do |annotation|
+      "@#{annotation.name}" if annotation.annotate?(field)
+    end.compact.join("\n")
+  end
+
+  def type_names_set
+    @type_names_set ||= schema.types.map(&:name).to_set
+  end
+end

data/codegen/lib/graphql_java_gen/annotation.rb

@@ -0,0 +1,15 @@
+class GraphQLJavaGen
+  class Annotation
+    attr_reader :name, :imports
+
+    def initialize(name, imports: [], &block)
+      @name = name
+      @imports = imports
+      @condition = block
+    end
+
+    def annotate?(field)
+      @condition.call(field)
+    end
+  end
+end

data/codegen/lib/graphql_java_gen/reformatter.rb

@@ -0,0 +1,43 @@
+class GraphQLJavaGen
+  # Reformat code that uses curly brace blocks
+  class Reformatter
+    INDENT_START_CHARS = ["{", "("]
+    INDENT_END_CHARS = ["}", ")"]
+
+    def initialize(indent: "\t")
+      @indent = indent
+    end
+
+    def reformat(code)
+      output = ""
+      indent_level = 0
+      squeeze_newlines = true
+
+      code.lines.each do |line|
+        stripped_line = line.strip
+
+        if INDENT_END_CHARS.include?(stripped_line[0])
+          indent_level -= 1
+          # no blank lines immediately preceding end of block
+          output.rstrip!
+          output << "\n"
+        end
+
+        if stripped_line.empty?
+          output << "\n" unless squeeze_newlines
+          squeeze_newlines = true
+        else
+          output << @indent * indent_level << line.lstrip
+          squeeze_newlines = false
+        end
+
+        if INDENT_START_CHARS.include?(stripped_line[-1])
+          indent_level += 1
+          # no blank lines following start of block
+          squeeze_newlines = true
+        end
+      end
+      output
+    end
+  end
+end

data/codegen/lib/graphql_java_gen/scalar.rb

@@ -0,0 +1,33 @@
+class GraphQLJavaGen
+  class Scalar
+    attr_reader :type_name, :imports
+
+    WRAPPER_OBJECT = {
+      'int' => 'Integer',
+      'long' => 'Long',
+      'double' => 'Double',
+      'boolean' => 'Boolean',
+    }
+    WRAPPER_OBJECT.default_proc = ->(_, key) { key }
+    private_constant :WRAPPER_OBJECT
+
+    def initialize(type_name:, java_type:, deserialize_expr:, imports: [])
+      @type_name = type_name
+      @java_type = java_type
+      @deserialize_expr = deserialize_expr
+      @imports = imports
+    end
+
+    def nullable_type
+      WRAPPER_OBJECT[@java_type]
+    end
+
+    def non_nullable_type
+      @java_type
+    end
+
+    def deserialize(expr)
+      @deserialize_expr.call(expr)
+    end
+  end
+end

data/codegen/lib/graphql_java_gen/templates/APISchema.java.erb

@@ -0,0 +1,369 @@
+// Generated from <%= script_name %>
+
+package <%= package_name %>;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.shopify.graphql.support.AbstractResponse;
+import com.shopify.graphql.support.Arguments;
+import com.shopify.graphql.support.Error;
+import com.shopify.graphql.support.Query;
+import com.shopify.graphql.support.SchemaViolationError;
+import com.shopify.graphql.support.TopLevelResponse;
+<% imports.each do |import| %>
+  import <%= import %>;
+<% end %>
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public class <%= schema_name %> {
+    <% [[:query, schema.query_root_name], [:mutation, schema.mutation_root_name]].each do |operation_type, root_name| %>
+        <% next unless schema.mutation_root_name %>
+        public static <%= root_name %>Query <%= operation_type %>(<%= root_name %>QueryDefinition queryDef) {
+            StringBuilder queryString = new StringBuilder("<%= operation_type unless operation_type == :query %>{");
+            <%= root_name %>Query query = new <%= root_name %>Query(queryString);
+            queryDef.define(query);
+            queryString.append('}');
+            return query;
+        }
+
+        public static class <%= operation_type.capitalize %>Response {
+            private TopLevelResponse response;
+            private <%= root_name %> data;
+
+            public <%= operation_type.capitalize %>Response(TopLevelResponse response) throws SchemaViolationError {
+                this.response = response;
+                this.data = response.getData() != null ? new <%= root_name %>(response.getData()) : null;
+            }
+
+            public <%= root_name %> getData() {
+                return data;
+            }
+
+            public List<Error> getErrors() {
+                return response.getErrors();
+            }
+
+            public String toJson() {
+                return new Gson().toJson(response);
+            }
+
+            public String prettyPrintJson() {
+              final Gson gson = new GsonBuilder().setPrettyPrinting().create();
+              return gson.toJson(response);
+            }
+
+            public static <%= operation_type.capitalize %>Response fromJson(String json) throws SchemaViolationError {
+                final TopLevelResponse response = new Gson().fromJson(json, TopLevelResponse.class);
+                return new <%= operation_type.capitalize %>Response(response);
+            }
+        }
+    <% end %>
+
+    <% schema.types.reject{ |type| type.name.start_with?('__') || type.scalar? }.each do |type| %>
+        <% case type.kind when 'OBJECT', 'INTERFACE', 'UNION' %>
+            public interface <%= type.name %>QueryDefinition {
+                void define(<%= type.name %>Query _queryBuilder);
+            }
+
+            public static class <%= type.name %>Query extends Query<<%= type.name %>Query> {
+                <%= type.name %>Query(StringBuilder _queryBuilder) {
+                    super(_queryBuilder);
+                    <% if type.object? && type.implement?("Node") %>
+                        startField("id");
+                    <% end %>
+                    <% unless type.object? %>
+                        startField("__typename");
+                    <% end %>
+                }
+
+                <% type.fields.each do |field| %>
+                    <% next if field.name == "id" && type.object? && type.implement?("Node") %>
+                    <% unless field.optional_args.empty? %>
+                        public class <%= field.classify_name %>Arguments extends Arguments {
+                            <%= field.classify_name %>Arguments(StringBuilder _queryBuilder) {
+                                super(_queryBuilder, <%= !!field.required_args.empty? %>);
+                            }
+
+                            <% field.optional_args.each do |arg| %>
+                                public <%= field.classify_name %>Arguments <%= escape_reserved_word(arg.camelize_name) %>(<%= java_input_type(arg.type) %> value) {
+                                    if (value != null) {
+                                        startArgument("<%= arg.name %>");
+                                        <%= generate_build_input_code('value', arg.type) %>
+                                    }
+                                    return this;
+                                }
+                            <% end %>
+                        }
+
+                        public interface <%= field.classify_name %>ArgumentsDefinition {
+                            void define(<%= field.classify_name %>Arguments args);
+                        }
+
+                        public <%= type.name %>Query <%= escape_reserved_word(field.camelize_name) %>(<%= java_arg_defs(field, skip_optional: true) %>) {
+                            return <%= escape_reserved_word(field.camelize_name) %>(<%= java_arg_expresions_with_empty_optional_args(field) %>);
+                        }
+                    <% end %>
+
+                    public <%= type.name %>Query <%= escape_reserved_word(field.camelize_name) %>(<%= java_arg_defs(field) %>) {
+                        startField("<%= field.name %>");
+                        <% unless field.args.empty? %>
+                            <% if field.required_args.empty? %>
+                                <%= field.classify_name %>Arguments args = new <%= field.classify_name %>Arguments(_queryBuilder);
+                                argsDef.define(args);
+                                <%= field.classify_name %>Arguments.end(args);
+                            <% else %>
+                                <% field.required_args.each_with_index do |arg, i| %>
+                                  _queryBuilder.append("<%= i == 0 ? "(" : "," %><%= arg.name %>:");
+                                  <%= generate_build_input_code(escape_reserved_word(arg.camelize_name), arg.type) %>
+                                <% end %>
+                                <% unless field.optional_args.empty? %>
+                                    argsDef.define(new <%= field.classify_name %>Arguments(_queryBuilder));
+                                <% end %>
+                                _queryBuilder.append(')');
+                            <% end %>
+                        <% end %>
+                        <% if field.subfields? %>
+                            _queryBuilder.append('{');
+                            queryDef.define(new <%= field.type.unwrap.name %>Query(_queryBuilder));
+                            _queryBuilder.append('}');
+                        <% end %>
+                        return this;
+                    }
+                <% end %>
+                <% unless type.object? %>
+                    <% type.possible_types.each do |possible_type| %>
+                        public <%= type.name %>Query on<%= possible_type.name %>(<%= possible_type.name %>QueryDefinition queryDef) {
+                            startInlineFragment("<%= possible_type.name %>");
+                            queryDef.define(new <%= possible_type.name %>Query(_queryBuilder));
+                            _queryBuilder.append('}');
+                            return this;
+                        }
+                    <% end %>
+                <% end %>
+
+                <% if schema.root_name?(type.name) %>
+                  public String toString() {
+                      return _queryBuilder.toString();
+                  }
+                <% end %>
+            }
+
+            <% unless type.object? %>
+                public interface <%= type.name %> {
+                    String getGraphQlTypeName();
+                    <% type.fields.each do |field| %>
+                        <%= java_output_type(field.type) %> get<%= field.classify_name %>();
+                    <% end %>
+                }
+            <% end %>
+
+            <% class_name = type.object? ? type.name : "Unknown#{type.name}" %>
+            public static class <%= class_name %> extends AbstractResponse<<%= class_name %>> <%= java_implements(type) %>{
+                public <%= class_name %>() {
+                }
+
+                public <%= class_name %>(JsonObject fields) throws SchemaViolationError {
+                  for (Map.Entry<String, JsonElement> field : fields.entrySet()) {
+                    String key = field.getKey();
+                    String fieldName = getFieldName(key);
+                    switch (fieldName) {
+                      <% type.fields.each do |field| %>
+                        case "<%= field.name %>": {
+                          <% generate_build_output_code("field.getValue()", field.type) do |statements, expr| %>
+                            <%= statements %>
+                            responseData.put(key, <%= expr %>);
+                          <% end %>
+                          break;
+                        }
+                      <% end %>
+                      case "__typename": {
+                        responseData.put(key, jsonAsString(field.getValue(), key));
+                        break;
+                      }
+                      default: {
+                        throw new SchemaViolationError(this, key, field.getValue());
+                      }
+                    }
+                  }
+                }
+
+                <% if type.object? && type.implement?("Node") %>
+                    public <%= class_name %>(<%= scalars['ID'].non_nullable_type %> id) {
+                      this();
+                      optimisticData.put("id", id);
+                    }
+                <% end %>
+
+                <% if type_names_set.include?('Node') %>
+                  public List<Node> getNodes() {
+                    List<Node> children = new ArrayList<>();
+                    <% if type.object? && type.implement?("Node") %>
+                      children.add(this);
+                    <% end %>
+                    <% type.fields.each do |field| %>
+                      <% next unless field.type.unwrap.object? %>
+                      if (get<%= field.classify_name %>() != null) {
+                        <% if field.type.unwrap_non_null.kind == 'LIST' %>
+                            for (<%= java_output_type(field.type.unwrap) %> elem: get<%= field.classify_name %>()) {
+                              children.addAll(elem.getNodes());
+                            }
+                        <% else %>
+                            children.addAll(get<%= field.classify_name %>().getNodes());
+                        <% end %>
+                      }
+                    <% end %>
+                    return children;
+                  }
+                <% end %>
+
+                <% if type.object? %>
+                    public String getGraphQlTypeName() {
+                        return "<%= type.name %>";
+                    }
+                <% else %>
+                    public static <%= type.name %> create(JsonObject fields) throws SchemaViolationError {
+                        String typeName = fields.getAsJsonPrimitive("__typename").getAsString();
+                        switch (typeName) {
+                            <% type.possible_types.each do |possible_type| %>
+                                case "<%= possible_type.name %>": {
+                                    return new <%= possible_type.name %>(fields);
+                                }
+                            <% end %>
+                            default: {
+                                return new <%= class_name %>(fields);
+                            }
+                        }
+                    }
+
+                    public String getGraphQlTypeName() {
+                        return (String) get("__typename");
+                    }
+                <% end %>
+
+                <% type.fields.each do |field| %>
+                    <%= java_annotations(field) %>
+                    public <%= java_output_type(field.type) %> get<%= field.classify_name %>() {
+                      return (<%= java_output_type(field.type) %>) get("<%= field.name %>");
+                    }
+
+                    <% next if field.name == "id" && type.object? && type.implement?("Node") %>
+                    public <%= class_name %> set<%= field.classify_name %>(<%= java_output_type(field.type) %> arg) {
+                      optimisticData.put("<%= field.name %>", arg);
+                      return this;
+                    }
+                <% end %>
+
+                  public boolean unwrapsToObject(String key) {
+                    switch (key) {
+                      <% type.fields.each do |field| %>
+                        case "<%= field.name %>": return <%= field.type.unwrap.object? %>;
+                      <% end %>
+                      default: return false;
+                    }
+                  }
+            }
+        <% when 'INPUT_OBJECT' %>
+            public static class <%= type.name %> implements Serializable {
+                <% type.required_input_fields.each do |field| %>
+                  private <%= java_input_type(field.type) %> <%= escape_reserved_word(field.camelize_name) %>;
+                <% end %>
+                <% type.optional_input_fields.each do |field| %>
+                  private <%= java_input_type(field.type) %> <%= escape_reserved_word(field.camelize_name) %>;
+                <% end %>
+
+                <% unless type.required_input_fields.empty? %>
+                  public <%= type.name %>(<%= type.required_input_fields.map{ |field| "#{java_input_type(field.type)} #{escape_reserved_word(field.camelize_name)}" }.join(', ') %>) {
+                      <% type.required_input_fields.each do |field| %>
+                          this.<%= escape_reserved_word(field.camelize_name) %> = <%= escape_reserved_word(field.camelize_name) %>;
+                      <% end %>
+                  }
+                <% end %>
+
+                <% type.required_input_fields.each do |field| %>
+                  public <%= java_input_type(field.type) %> get<%= field.classify_name %>() {
+                      return <%= escape_reserved_word(field.camelize_name) %>;
+                  }
+
+                  public <%= type.name %> set<%= field.classify_name %>(<%= java_input_type(field.type) %> <%= escape_reserved_word(field.camelize_name) %>) {
+                      this.<%= escape_reserved_word(field.camelize_name) %> = <%= escape_reserved_word(field.camelize_name) %>;
+                      return this;
+                  }
+                <% end %>
+                <% type.optional_input_fields.each do |field| %>
+                  public <%= java_input_type(field.type) %> get<%= field.classify_name %>() {
+                      return <%= escape_reserved_word(field.camelize_name) %>;
+                  }
+
+                  public <%= type.name %> set<%= field.classify_name %>(<%= java_input_type(field.type) %> <%= escape_reserved_word(field.camelize_name) %>) {
+                      this.<%= escape_reserved_word(field.camelize_name) %> = <%= escape_reserved_word(field.camelize_name) %>;
+                      return this;
+                  }
+                <% end %>
+
+                public void appendTo(StringBuilder _queryBuilder) {
+                  String separator = "";
+                  _queryBuilder.append('{');
+                  <% type.required_input_fields.each do |field| %>
+                    _queryBuilder.append(separator);
+                    separator = ",";
+                    _queryBuilder.append("<%= field.name %>:");
+                    <%= generate_build_input_code(escape_reserved_word(field.camelize_name), field.type) %>
+                  <% end %>
+                  <% type.optional_input_fields.each do |field| %>
+                    if (<%= escape_reserved_word(field.camelize_name) %> != null) {
+                      _queryBuilder.append(separator);
+                      separator = ",";
+                      _queryBuilder.append("<%= field.name %>:");
+                      <%= generate_build_input_code(escape_reserved_word(field.camelize_name), field.type) %>
+                    }
+                  <% end %>
+                  _queryBuilder.append('}');
+                }
+            }
+        <% when 'ENUM' %>
+            public enum <%= type.name %> {
+              <% type.enum_values.each do |value| %>
+                <%= value.upcase_name %>,
+              <% end %>
+              UNKNOWN_VALUE;
+
+              public static <%= type.name %> fromGraphQl(String value) {
+                if (value == null) {
+                  return null;
+                }
+
+                switch (value) {
+                  <% type.enum_values.each do |value| %>
+                    case "<%= value.name %>": {
+                      return <%= value.upcase_name %>;
+                    }
+                  <% end %>
+                    default: {
+                      return UNKNOWN_VALUE;
+                    }
+                }
+              }
+              public String toString() {
+                switch (this) {
+                  <% type.enum_values.each do |value| %>
+                    case <%= value.upcase_name %>: {
+                      return "<%= value.name %>";
+                    }
+                  <% end %>
+                    default: {
+                      return "";
+                    }
+                }
+              }
+            }
+        <% else %>
+            <% raise NotImplementedError, "unhandled #{type.kind} type #{type.name}" %>
+        <% end %>
+    <% end %>
+}

data/codegen/lib/graphql_java_gen/version.rb

@@ -0,0 +1,3 @@
+class GraphQLJavaGen
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: graphql_java_gen
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dylan Thacker-Smith
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-02-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: graphql_schema
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.10'
+- !ruby/object:Gem::Dependency
+  name: graphql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: Generates java code based on the GraphQL schema to provide type-safe
+  API for building GraphQL queries and using their responses.
+email:
+- gems@shopify.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- codegen/lib/graphql_java_gen.rb
+- codegen/lib/graphql_java_gen/annotation.rb
+- codegen/lib/graphql_java_gen/reformatter.rb
+- codegen/lib/graphql_java_gen/scalar.rb
+- codegen/lib/graphql_java_gen/templates/APISchema.java.erb
+- codegen/lib/graphql_java_gen/version.rb
+homepage: https://github.com/Shopify/graphql_java_gen
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- codegen/lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.10
+signing_key: 
+specification_version: 4
+summary: GraphQL java client code generator
+test_files: []