graphql 1.5.10 → 1.5.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0e87f7a05371764ee8744616a781f61f103f761c
-  data.tar.gz: e8d2eafe80fbe962c1dd5c017201b82b86def0ad
+  metadata.gz: bb2841b1c8677bc9188757eca08b2f365f0e0af8
+  data.tar.gz: 12bc61f9684e3bae2a4d06c22f9378064fcf191d
 SHA512:
-  metadata.gz: b83d8c335d98f4149a6ce531b6dc61254fc96bbb5fec35beb2c0fece8eb4fff58693cd7bd48fb89511da84d69cfcec5e639b64372add0c8070c5a9c871804af0
-  data.tar.gz: ef672d60a38c0e1b5ec87af598d7ec221e36c6511ed92f72840bb32be813a0d434d9a0580d2e57e18ad8ad48f486f150d36b72399dbba347a4915686148b1c4e
+  metadata.gz: 7859ae0afed299edb29dedc59d014f057b85dde4e3547a300d312c0ba137f23cc23d6c70c664a3afd6985c3b393483aa012c8e7ba6e70e0713ad203163dbc089
+  data.tar.gz: 61ab9c38a66e013b09bec6f5865aae178110ba99b230b2a94b325ea1afef7b1bb9beb98744c52cee0d8b2c2813b377a39dbef13c920bf319cddfeef1ba2f3e07

data/lib/generators/graphql/templates/function.erb

@@ -9,7 +9,7 @@ class Functions::<%= name %> < GraphQL::Function
   # end
 
   # add arguments by type:
-  # argument :id, !GraphQL::ID_TYPE
+  # argument :id, !types.ID
 
   # Resolve function:
   def call(obj, args, ctx)

data/lib/generators/graphql/templates/schema.erb

@@ -29,6 +29,5 @@
   }
 <% end %><% if options[:batch] %>
   # GraphQL::Batch setup:
-  lazy_resolve(Promise, :sync)
-  instrument(:query, GraphQL::Batch::Setup)
+  use GraphQL::Batch
 <% end %>end

data/lib/generators/graphql/type_generator.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 require 'rails/generators/base'
 require 'graphql'
+require 'active_support'
+require 'active_support/core_ext/string/inflections'
 
 module Graphql
   module Generators
@@ -39,10 +41,10 @@ module Graphql
             when "Int", "Float", "Boolean", "String", "ID"
               "types.#{type_expression}"
             else
-              "Types::#{type_expression}Type"
+              "Types::#{type_expression.camelize}Type"
             end
           when :graphql
-            type_expression
+            type_expression.camelize
           else
             raise "Unexpected normalize mode: #{mode}"
           end

data/lib/graphql/analysis/analyze_query.rb

@@ -18,7 +18,7 @@ module GraphQL
 
       irep = query.internal_representation
 
-      irep.each do |name, op_node|
+      irep.operation_definitions.each do |name, op_node|
         reduce_node(op_node, reducer_states)
       end
 

data/lib/graphql/function.rb

@@ -18,7 +18,7 @@ module GraphQL
   #
   #     argument :id, GraphQL::ID_TYPE
   #
-  #     def resolve(obj, args, ctx)
+  #     def call(obj, args, ctx)
   #        @model.find(args.id)
   #     end
   #   end

data/lib/graphql/internal_representation.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require "graphql/internal_representation/document"
 require "graphql/internal_representation/node"
 require "graphql/internal_representation/print"
 require "graphql/internal_representation/rewrite"

data/lib/graphql/internal_representation/document.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+module GraphQL
+  module InternalRepresentation
+    class Document
+      # @return [Hash<String, Node>] Operation Nodes of this query
+      attr_reader :operation_definitions
+
+      # @return [Hash<String, Node>] Fragment definition Nodes of this query
+      attr_reader :fragment_definitions
+
+      def initialize
+        @operation_definitions = {}
+        @fragment_definitions = {}
+      end
+
+      def [](key)
+        warn "#{self.class}#[] is deprecated; use `operation_definitions[]` instead"
+        operation_definitions[key]
+      end
+
+      def each(&block)
+        warn "#{self.class}#each is deprecated; use `operation_definitions.each` instead"
+        operation_definitions.each(&block)
+      end
+    end
+  end
+end

data/lib/graphql/internal_representation/rewrite.rb

@@ -18,11 +18,17 @@ module GraphQL
 
       NO_DIRECTIVES = [].freeze
 
-      # @return [Hash<String, Node>] Roots of this query
-      attr_reader :operations
+      # @return InternalRepresentation::Document
+      attr_reader :document
 
       def initialize
-        @operations = {}
+        @document = InternalRepresentation::Document.new
+      end
+
+      # @return [Hash<String, Node>] Roots of this query
+      def operations
+        warn "#{self.class}#operations is deprecated; use `document.operation_definitions` instead"
+        document.operation_definitions
       end
 
       def validate(context)
@@ -39,14 +45,13 @@ module GraphQL
         # Array<Scope>
         scopes_stack = []
 
-        fragment_definitions = {}
         skip_nodes = Set.new
 
-        visit_op = VisitDefinition.new(context, @operations, nodes_stack, scopes_stack)
+        visit_op = VisitDefinition.new(context, @document.operation_definitions, nodes_stack, scopes_stack)
         visitor[Nodes::OperationDefinition].enter << visit_op.method(:enter)
         visitor[Nodes::OperationDefinition].leave << visit_op.method(:leave)
 
-        visit_frag = VisitDefinition.new(context, fragment_definitions, nodes_stack, scopes_stack)
+        visit_frag = VisitDefinition.new(context, @document.fragment_definitions, nodes_stack, scopes_stack)
         visitor[Nodes::FragmentDefinition].enter << visit_frag.method(:enter)
         visitor[Nodes::FragmentDefinition].leave << visit_frag.method(:leave)
 
@@ -137,7 +142,7 @@ module GraphQL
         # can be shared between its usages.
         context.on_dependency_resolve do |defn_ast_node, spread_ast_nodes, frag_ast_node|
           frag_name = frag_ast_node.name
-          fragment_node = fragment_definitions[frag_name]
+          fragment_node = @document.fragment_definitions[frag_name]
 
           if fragment_node
             spread_ast_nodes.each do |spread_ast_node|

data/lib/graphql/list_type.rb

@@ -39,25 +39,26 @@ module GraphQL
     def to_s
       "[#{of_type.to_s}]"
     end
+    alias_method :inspect, :to_s
 
     def coerce_result(value, ctx = nil)
       if ctx.nil?
         warn_deprecated_coerce("coerce_isolated_result")
         ctx = GraphQL::Query::NullContext
       end
-      Array(value).map { |item| item.nil? ? nil : of_type.coerce_result(item, ctx) }
+      ensure_array(value).map { |item| item.nil? ? nil : of_type.coerce_result(item, ctx) }
     end
 
     private
 
     def coerce_non_null_input(value, ctx)
-      Array(value).map { |item| of_type.coerce_input(item, ctx) }
+      ensure_array(value).map { |item| of_type.coerce_input(item, ctx) }
     end
 
     def validate_non_null_input(value, ctx)
       result = GraphQL::Query::InputValidationResult.new
 
-      Array(value).each_with_index do |item, index|
+      ensure_array(value).each_with_index do |item, index|
         item_result = of_type.validate_input(item, ctx)
         if !item_result.valid?
           result.merge_result!(index, item_result)
@@ -66,5 +67,9 @@ module GraphQL
 
       result
     end
+
+    def ensure_array(value)
+      value.is_a?(Array) ? value : [value]
+    end
   end
 end

data/lib/graphql/non_null_type.rb

@@ -61,5 +61,6 @@ module GraphQL
     def to_s
       "#{of_type.to_s}!"
     end
+    alias_method :inspect, :to_s
   end
 end

data/lib/graphql/query.rb

@@ -27,7 +27,7 @@ module GraphQL
       end
     end
 
-    attr_reader :schema, :document, :context, :fragments, :operations, :root_value, :query_string, :warden, :provided_variables
+    attr_reader :schema, :document, :context, :fragments, :operations, :root_value, :query_string, :warden, :provided_variables, :operation_name
 
     # Prepare query `query_string` on `schema`
     # @param schema [GraphQL::Schema]
@@ -83,13 +83,17 @@ module GraphQL
       @ast_variables = []
       @mutation = false
       operation_name_error = nil
+      @operation_name = nil
+
       if @operations.any?
-        @selected_operation = find_operation(@operations, operation_name)
-        if @selected_operation.nil?
+        selected_operation = find_operation(@operations, operation_name)
+        if selected_operation.nil?
           operation_name_error = GraphQL::Query::OperationNameMissingError.new(operation_name)
         else
-          @ast_variables = @selected_operation.variables
-          @mutation = @selected_operation.operation_type == "mutation"
+          @operation_name = selected_operation.name
+          @ast_variables = selected_operation.variables
+          @mutation = selected_operation.operation_type == "mutation"
+          @selected_operation = selected_operation
         end
       end
 
@@ -155,7 +159,7 @@ module GraphQL
     end
 
     def irep_selection
-      @selection ||= internal_representation[selected_operation.name]
+      @selection ||= internal_representation.operation_definitions[selected_operation.name]
     end
 
     # Node-level cache for calculating arguments. Used during execution and query analysis.

data/lib/graphql/schema.rb

@@ -399,9 +399,10 @@ module GraphQL
     # Create schema from an IDL schema.
     # @param definition_string [String] A schema definition string
     # @param default_resolve [<#call(type, field, obj, args, ctx)>] A callable for handling field resolution
+    # @param parser [Object] An object for handling definition string parsing (must respond to `parse`)
     # @return [GraphQL::Schema] the schema described by `document`
-    def self.from_definition(string, default_resolve: BuildFromDefinition::DefaultResolve)
-      GraphQL::Schema::BuildFromDefinition.from_definition(string, default_resolve: default_resolve)
+    def self.from_definition(string, default_resolve: BuildFromDefinition::DefaultResolve, parser: BuildFromDefinition::DefaultParser)
+      GraphQL::Schema::BuildFromDefinition.from_definition(string, default_resolve: default_resolve, parser: parser)
     end
 
     # Error that is raised when [#Schema#from_definition] is passed an invalid schema definition string.

data/lib/graphql/schema/build_from_definition.rb

@@ -3,12 +3,15 @@ module GraphQL
   class Schema
     module BuildFromDefinition
       class << self
-        def from_definition(definition_string, default_resolve:)
-          document = GraphQL::parse(definition_string)
+        def from_definition(definition_string, default_resolve:, parser: DefaultParser)
+          document = parser.parse(definition_string)
           Builder.build(document, default_resolve: default_resolve)
         end
       end
 
+      # @api private
+      DefaultParser = GraphQL::Language::Parser
+
       # @api private
       module DefaultResolve
         def self.call(type, field, obj, args, ctx)

data/lib/graphql/static_validation/definition_dependencies.rb

@@ -12,17 +12,19 @@ module GraphQL
       end
 
       def initialize
+        @node_paths = {}
+
         # { name => node } pairs for fragments
         @fragment_definitions = {}
 
         # This tracks dependencies from fragment to Node where it was used
-        # { frag_name => [dependent_node, dependent_node]}
+        # { fragment_definition_node => [dependent_node, dependent_node]}
         @dependent_definitions = Hash.new { |h, k| h[k] = Set.new }
 
         # First-level usages of spreads within definitions
         # (When a key has an empty list as its value,
         #  we can resolve that key's depenedents)
-        # { string => [node, node ...] }
+        # { definition_node => [node, node ...] }
         @immediate_dependencies = Hash.new { |h, k| h[k] = Set.new }
       end
 
@@ -38,8 +40,19 @@ module GraphQL
         # this node is the one who depends on it
         current_parent = nil
 
+        visitor[GraphQL::Language::Nodes::Document] << ->(node, prev_node) {
+          node.definitions.each do |definition|
+            case definition
+            when GraphQL::Language::Nodes::OperationDefinition
+            when GraphQL::Language::Nodes::FragmentDefinition
+              @fragment_definitions[definition.name] = definition
+            end
+          end
+        }
+
         visitor[GraphQL::Language::Nodes::OperationDefinition] << ->(node, prev_node) {
-          current_parent = NodeWithPath.new(node, context.path)
+          @node_paths[node] = NodeWithPath.new(node, context.path)
+          current_parent = node
         }
 
         visitor[GraphQL::Language::Nodes::OperationDefinition].leave << ->(node, prev_node) {
@@ -47,7 +60,8 @@ module GraphQL
         }
 
         visitor[GraphQL::Language::Nodes::FragmentDefinition] << ->(node, prev_node) {
-          current_parent = @fragment_definitions[node.name] = NodeWithPath.new(node, context.path)
+          @node_paths[node] = NodeWithPath.new(node, context.path)
+          current_parent = node
         }
 
         visitor[GraphQL::Language::Nodes::FragmentDefinition].leave << ->(node, prev_node) {
@@ -55,9 +69,11 @@ module GraphQL
         }
 
         visitor[GraphQL::Language::Nodes::FragmentSpread] << ->(node, prev_node) {
+          @node_paths[node] = NodeWithPath.new(node, context.path)
+
           # Track both sides of the dependency
-          @dependent_definitions[node.name] << current_parent
-          @immediate_dependencies[current_parent.name] << NodeWithPath.new(node, context.path)
+          @dependent_definitions[@fragment_definitions[node.name]] << current_parent
+          @immediate_dependencies[current_parent] << node
         }
       end
 
@@ -113,40 +129,39 @@ module GraphQL
         # determine them at the end. This way, we can treat fragments with the
         # same name as if they were the same name. If _any_ of the fragments
         # with that name has a dependency, we record it.
-        independent_fragment_names = @fragment_definitions.each_key.select { |name| !@immediate_dependencies.key?(name) }
+        independent_fragment_nodes = @fragment_definitions.values - @immediate_dependencies.keys
 
-        while fragment_name = independent_fragment_names.pop
+        while fragment_node = independent_fragment_nodes.pop
           loops += 1
           if loops > max_loops
             raise("Resolution loops exceeded the number of definitions; infinite loop detected.")
           end
-          fragment_node = @fragment_definitions[fragment_name]
           # Since it's independent, let's remove it from here.
           # That way, we can use the remainder to identify cycles
-          @immediate_dependencies.delete(fragment_name)
-          fragment_usages = @dependent_definitions[fragment_name]
+          @immediate_dependencies.delete(fragment_node)
+          fragment_usages = @dependent_definitions[fragment_node]
           if fragment_usages.none?
             # If we didn't record any usages during the visit,
             # then this fragment is unused.
-            dependency_map.unused_dependencies << fragment_node
+            dependency_map.unused_dependencies << @node_paths[fragment_node]
           else
             fragment_usages.each do |definition_node|
               # Register the dependency AND second-order dependencies
               dependency_map[definition_node] << fragment_node
               dependency_map[definition_node].concat(dependency_map[fragment_node])
               # Since we've regestered it, remove it from our to-do list
-              deps = @immediate_dependencies[definition_node.name]
+              deps = @immediate_dependencies[definition_node]
               # Can't find a way to _just_ delete from `deps` and return the deleted entries
-              removed, remaining = deps.partition { |spread| spread.name == fragment_name }
-              @immediate_dependencies[definition_node.name] = remaining
+              removed, remaining = deps.partition { |spread| spread.name == fragment_node.name }
+              @immediate_dependencies[definition_node] = remaining
               if block_given?
                 yield(definition_node, removed, fragment_node)
               end
-              if remaining.none? && definition_node.node.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
+              if remaining.none? && definition_node.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
                 # If all of this definition's dependencies have
                 # been resolved, we can now resolve its
                 # own dependents.
-                independent_fragment_names << definition_node.name
+                independent_fragment_nodes << definition_node
               end
             end
           end
@@ -155,21 +170,20 @@ module GraphQL
         # If any dependencies were _unmet_
         # (eg, spreads with no corresponding definition)
         # then they're still in there
-        @immediate_dependencies.each do |defn_name, deps|
+        @immediate_dependencies.each do |defn_node, deps|
           deps.each do |spread|
             if @fragment_definitions[spread.name].nil?
-              defn_node = @fragment_definitions[defn_name]
-              dependency_map.unmet_dependencies[defn_node] << spread
+              dependency_map.unmet_dependencies[@node_paths[defn_node]] << @node_paths[spread]
               deps.delete(spread)
             end
           end
           if deps.none?
-            @immediate_dependencies.delete(defn_name)
+            @immediate_dependencies.delete(defn_node)
           end
         end
 
         # Anything left in @immediate_dependencies is cyclical
-        cyclical_nodes = @immediate_dependencies.keys.map { |n| @fragment_definitions[n] }
+        cyclical_nodes = @immediate_dependencies.keys.map { |n| @node_paths[n] }
         # @immediate_dependencies also includes operation names, but we don't care about
         # those. They became nil when we looked them up on `@fragment_definitions`, so remove them.
         cyclical_nodes.compact!

data/lib/graphql/static_validation/validator.rb

@@ -33,8 +33,8 @@ module GraphQL
 
         context.visitor.visit
         # Post-validation: allow validators to register handlers on rewritten query nodes
-        rewrite_result = rewrite.operations
-        GraphQL::InternalRepresentation::Visit.visit_each_node(rewrite_result, context.each_irep_node_handlers)
+        rewrite_result = rewrite.document
+        GraphQL::InternalRepresentation::Visit.visit_each_node(rewrite_result.operation_definitions, context.each_irep_node_handlers)
 
         {
           errors: context.errors,

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "1.5.10"
+  VERSION = "1.5.11"
 end

data/spec/generators/graphql/function_generator_spec.rb

@@ -20,7 +20,7 @@ class Functions::FindRecord < GraphQL::Function
   # end
 
   # add arguments by type:
-  # argument :id, !GraphQL::ID_TYPE
+  # argument :id, !types.ID
 
   # Resolve function:
   def call(obj, args, ctx)

data/spec/generators/graphql/install_generator_spec.rb

@@ -178,8 +178,7 @@ DummySchema = GraphQL::Schema.define do
   }
 
   # GraphQL::Batch setup:
-  lazy_resolve(Promise, :sync)
-  instrument(:query, GraphQL::Batch::Setup)
+  use GraphQL::Batch
 end
 RUBY
 end

data/spec/generators/graphql/object_generator_spec.rb

@@ -30,6 +30,15 @@ RUBY
     end
   end
 
+  test "it generates classifed file" do
+    run_generator(["page"])
+    assert_file "app/graphql/types/page_type.rb", <<-RUBY
+Types::PageType = GraphQL::ObjectType.define do
+  name "Page"
+end
+RUBY
+  end
+
   test "it makes Relay nodes" do
     run_generator(["Page", "--node"])
     assert_file "app/graphql/types/page_type.rb", <<-RUBY

data/spec/graphql/internal_representation/rewrite_spec.rb

@@ -104,7 +104,7 @@ describe GraphQL::InternalRepresentation::Rewrite do
     }
 
     it "groups selections by object types which they apply to" do
-      doc = rewrite_result["getPlant"]
+      doc = rewrite_result.operation_definitions["getPlant"]
       assert_equal nil, doc.definition
 
       plant_scoped_selection = doc.scoped_children[schema.types["Query"]]["plant"]
@@ -126,7 +126,7 @@ describe GraphQL::InternalRepresentation::Rewrite do
     end
 
     it "tracks parent nodes" do
-      doc = rewrite_result["getPlant"]
+      doc = rewrite_result.operation_definitions["getPlant"]
       assert_equal nil, doc.parent
 
       plant_selection = doc.typed_children[schema.types["Query"]]["plant"]
@@ -171,7 +171,7 @@ describe GraphQL::InternalRepresentation::Rewrite do
     }
 
     it "applies directives from all contexts" do
-      doc = rewrite_result["getPlant"]
+      doc = rewrite_result.operation_definitions["getPlant"]
       plant_selection = doc.typed_children[schema.types["Query"]]["plant"]
       leaf_type_selection = plant_selection.typed_children[schema.types["Nut"]]["leafType"]
       # Only unskipped occurrences in the AST
@@ -208,7 +208,7 @@ describe GraphQL::InternalRepresentation::Rewrite do
     }
 
     it "applies spreads to their parents only" do
-      doc = rewrite_result[nil]
+      doc = rewrite_result.operation_definitions[nil]
       plant_selection = doc.typed_children[schema.types["Query"]]["plant"]
       nut_habitat_selections = plant_selection.typed_children[schema.types["Nut"]]["habitats"].typed_children[schema.types["Habitat"]]
       assert_equal ["averageWeight", "residentName", "seasons"], nut_habitat_selections.keys.sort
@@ -286,4 +286,42 @@ describe GraphQL::InternalRepresentation::Rewrite do
       end
     end
   end
+
+  describe "fragment definition without query" do
+    let(:query_string) {
+      <<-GRAPHQL
+      fragment NutFields on Nut {
+        leafType
+        ... TreeFields
+      }
+
+      fragment TreeFields on Tree {
+        habitats {
+          ... HabitatFields
+        }
+      }
+
+      fragment HabitatFields on Habitat {
+        seasons
+      }
+      GRAPHQL
+    }
+
+    let(:validator) {
+      rules = GraphQL::StaticValidation::ALL_RULES - [
+        GraphQL::StaticValidation::FragmentsAreUsed
+      ]
+      GraphQL::StaticValidation::Validator.new(schema: schema, rules: rules)
+    }
+
+    it "tracks fragment definitions without operation" do
+      doc = rewrite_result.fragment_definitions["NutFields"]
+
+      assert doc.typed_children[schema.types["Nut"]]["leafType"]
+
+      assert nut_selections = doc.typed_children[schema.types["Nut"]]
+      habitats_selections = nut_selections["habitats"].typed_children[schema.types["Habitat"]]
+      assert_equal ["seasons"], habitats_selections.keys
+    end
+  end
 end

data/spec/graphql/list_type_spec.rb

@@ -8,6 +8,10 @@ describe GraphQL::ListType do
     assert_equal([1.0, 2.0, 3.0].inspect, float_list.coerce_isolated_input([1, 2, 3]).inspect)
   end
 
+  it "converts items that are not lists into lists" do
+    assert_equal([1.0].inspect, float_list.coerce_isolated_input(1.0).inspect)
+  end
+
   describe "validate_input with bad input" do
     let(:bad_num) { "bad_num" }
     let(:result) { float_list.validate_isolated_input([bad_num, 2.0, 3.0]) }
@@ -30,4 +34,20 @@ describe GraphQL::ListType do
       assert_equal(actual, expected)
     end
   end
+
+  describe "list of input objects" do
+    let(:input_object) do
+      GraphQL::InputObjectType.define do
+        name "SomeInputObjectType"
+        argument :float, !types.Float
+      end
+    end
+
+    let(:input_object_list) { input_object.to_list_type }
+
+    it "converts hashes into lists of hashes" do
+      hash = { 'float' => 1.0 }
+      assert_equal([hash].inspect, input_object_list.coerce_isolated_input(hash).map(&:to_h).inspect)
+    end
+  end
 end

data/spec/graphql/query/executor_spec.rb

@@ -58,6 +58,27 @@ describe GraphQL::Query::Executor do
     end
   end
 
+  describe "operation and fragment defintions of the same name" do
+    let(:query_string) { %|
+      query Cheese { cheese(id: 1) { ...Cheese } }
+      query MoreCheese { cheese(id: 2) { ...Cheese } }
+      fragment Cheese on Cheese { flavor }
+    |}
+
+    let(:operation_name) { "Cheese" }
+
+    it "runs the named operation" do
+      expected = {
+        "data" => {
+          "cheese" => {
+            "flavor" => "Brie"
+          }
+        }
+      }
+      assert_equal(expected, result)
+    end
+  end
+
 
   describe "execution order" do
     let(:query_string) {%|

data/spec/graphql/query_spec.rb

@@ -57,6 +57,32 @@ describe GraphQL::Query do
     end
   end
 
+  describe "operation_name" do
+    describe "when provided" do
+      let(:query_string) { <<-GRAPHQL
+        query q1 { cheese(id: 1) { flavor } }
+        query q2 { cheese(id: 2) { flavor } }
+      GRAPHQL
+      }
+      let(:operation_name) { "q2" }
+
+      it "returns the provided name" do
+        assert_equal "q2", query.operation_name
+      end
+    end
+
+    describe "when inferred" do
+      let(:query_string) { <<-GRAPHQL
+        query q3 { cheese(id: 3) { flavor } }
+      GRAPHQL
+      }
+
+      it "returns the inferred name" do
+        assert_equal "q3", query.operation_name
+      end
+    end
+  end
+
   describe "when passed a document instance" do
     let(:query) { GraphQL::Query.new(
       schema,
@@ -529,4 +555,14 @@ describe GraphQL::Query do
       assert_equal([nil], expected_args.first['id'])
     end
   end
+
+  describe '#internal_representation' do
+    it "includes all definition roots" do
+      assert_kind_of GraphQL::InternalRepresentation::Node, query.internal_representation.operation_definitions["getFlavor"]
+      assert_kind_of GraphQL::InternalRepresentation::Node, query.internal_representation.fragment_definitions["cheeseFields"]
+      assert_kind_of GraphQL::InternalRepresentation::Node, query.internal_representation.fragment_definitions["edibleFields"]
+      assert_kind_of GraphQL::InternalRepresentation::Node, query.internal_representation.fragment_definitions["milkFields"]
+      assert_kind_of GraphQL::InternalRepresentation::Node, query.internal_representation.fragment_definitions["dairyFields"]
+    end
+  end
 end

data/spec/graphql/schema/build_from_definition_spec.rb

@@ -813,5 +813,21 @@ SCHEMA
         assert_equal(result.to_json, '{"data":{"allTodos":[{"text":"Pay the bills.","from_context":null},{"text":"Buy Milk","from_context":"bar"}]}}')
       end
     end
+
+    describe "custom parser behavior" do
+      module BadParser
+        ParseError = Class.new(StandardError)
+
+        def self.parse(string)
+          raise ParseError
+        end
+      end
+
+      it 'accepts a parser callable' do
+        assert_raises(BadParser::ParseError) do
+          GraphQL::Schema.from_definition(schema_defn, parser: BadParser)
+        end
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.5.10
+  version: 1.5.11
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-25 00:00:00.000000000 Z
+date: 2017-05-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -362,6 +362,7 @@ files:
 - lib/graphql/int_type.rb
 - lib/graphql/interface_type.rb
 - lib/graphql/internal_representation.rb
+- lib/graphql/internal_representation/document.rb
 - lib/graphql/internal_representation/node.rb
 - lib/graphql/internal_representation/print.rb
 - lib/graphql/internal_representation/rewrite.rb