graphql 0.18.10 → 0.18.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e1f410073bc1513435fe5551135544b6925a01d3
-  data.tar.gz: a0d737582d9918e19891a00c88e3d6829f1cc1c8
+  metadata.gz: 1878fc3aef9f2315438da1dc338f7a6254ed83ca
+  data.tar.gz: 1f894a00b663c83b7b1bb33f2fda113dd8851f1e
 SHA512:
-  metadata.gz: 3beaf630fe3303784f85f3ae17ac89b427378ce5eeec8d7b6d7c76a6bfc699dc85e58ca87521a62b20e4b7c0c937411f0ce48cc1a40638e86b3b81991dea2964
-  data.tar.gz: 52384d58bf87b5f18fb898ce2930d91d82e537269567d3d40ab0cd31a29367355d0048d4396c6002c123ee66d8f994ff347c01e2d342ae73561bd6d04807223e
+  metadata.gz: d14b02503088c21f6795c91a8b7eccfa7ed9d7cac10f06b388368ec3a1730e32e504166da603de22c2303a952af0778d1bb8190f0620df1bbb24dd9bb23a2c88
+  data.tar.gz: 790684129a750601ce3fb2cd71455ba1c6afece4f4be047f260161436e2cfca3f01c3d2cc9dd147f3f03eeb2bdac5d3c1bcb44acd420b40c99158e23eca650e7

data/lib/graphql.rb

@@ -1,6 +1,7 @@
 require "json"
 require "set"
 require "singleton"
+require "forwardable"
 
 module GraphQL
   class Error < StandardError

data/lib/graphql/argument.rb

@@ -17,23 +17,19 @@ module GraphQL
   class Argument
     include GraphQL::Define::InstanceDefinable
     accepts_definitions :name, :type, :description, :default_value
-    lazy_defined_attr_accessor :type, :description, :default_value
+    lazy_defined_attr_accessor :type, :description, :default_value, :name
 
-    # @return [String] The name of this argument on its {GraphQL::Field} or {GraphQL::InputObjectType}
-    def name
-      ensure_defined
-      @name
-    end
-
-    attr_writer :name
+    # @!attribute name
+    #   @return [String] The name of this argument on its {GraphQL::Field} or {GraphQL::InputObjectType}
 
-    def type=(new_return_type)
+    # @param new_input_type [GraphQL::BaseType, Proc] Assign a new input type for this argument (if it's a proc, it will be called after schema initialization)
+    def type=(new_input_type)
       ensure_defined
       @clean_type = nil
-      @dirty_type = new_return_type
+      @dirty_type = new_input_type
     end
 
-    # Get the return type for this field.
+    # @return [GraphQL::BaseType] the input type for this argument
     def type
       @clean_type ||= begin
         ensure_defined

data/lib/graphql/base_type.rb

@@ -10,6 +10,12 @@ module GraphQL
 
     lazy_defined_attr_accessor :name, :description
 
+    # @!attribute name
+    #   @return [String] the name of this type, must be unique within a Schema
+
+    # @!attribute description
+    #  @return [String, nil] a description for this type
+
     # @param other [GraphQL::BaseType] compare to this object
     # @return [Boolean] are these types equivalent? (incl. non-null, list)
     def ==(other)

data/lib/graphql/boolean_type.rb

@@ -1,10 +1,7 @@
 GraphQL::BOOLEAN_TYPE = GraphQL::ScalarType.define do
-  # Everything else is nil
-  ALLOWED_INPUTS = [true, false]
-
   name "Boolean"
   description "Represents `true` or `false` values."
 
-  coerce_input -> (value) { ALLOWED_INPUTS.include?(value) ? value : nil }
+  coerce_input -> (value) { (value == true || value == false) ? value : nil }
   coerce_result -> (value) { !!value }
 end

data/lib/graphql/enum_type.rb

@@ -63,17 +63,20 @@ module GraphQL
       @values_by_value = {}
     end
 
+    # @param new_values [Array<EnumValue>] The set of values contained in this type
     def values=(new_values)
       @values_by_name = {}
       @values_by_value = {}
       new_values.each { |enum_value| add_value(enum_value) }
     end
 
+    # @param enum_value [EnumValue] A value to add to this type's set of values
     def add_value(enum_value)
       @values_by_name[enum_value.name] = enum_value
       @values_by_value[enum_value.value] = enum_value
     end
 
+    # @return [Hash<String => EnumValue>] `{name => value}` pairs contained in this type
     def values
       ensure_defined
       @values_by_name

data/lib/graphql/field.rb

@@ -126,37 +126,23 @@ module GraphQL
       argument: GraphQL::Define::AssignArgument
 
 
-    lazy_defined_attr_accessor :deprecation_reason, :description, :property, :hash_key, :mutation
+    lazy_defined_attr_accessor :name, :deprecation_reason, :description, :property, :hash_key, :mutation, :arguments, :complexity
 
-    # @return [<#call(obj, args,ctx)>] A proc-like object which can be called to return the field's value
+    # @!attribute [r] resolve_proc
+    #   @return [<#call(obj, args,ctx)>] A proc-like object which can be called to return the field's value
     attr_reader :resolve_proc
 
-    # @return [String] The name of this field on its {GraphQL::ObjectType} (or {GraphQL::InterfaceType})
-    def name
-      ensure_defined
-      @name
-    end
-
-    attr_writer :name
+    # @!attribute name
+    #   @return [String] The name of this field on its {GraphQL::ObjectType} (or {GraphQL::InterfaceType})
 
-    # @return [Hash<String => GraphQL::Argument>] Map String argument names to their {GraphQL::Argument} implementations
-    def arguments
-      ensure_defined
-      @arguments
-    end
-
-    attr_writer :arguments
+    # @!attribute arguments
+    #   @return [Hash<String => GraphQL::Argument>] Map String argument names to their {GraphQL::Argument} implementations
 
     # @!attribute mutation
     #   @return [GraphQL::Relay::Mutation, nil] The mutation this field was derived from, if it was derived from a mutation
 
-    # @return [Numeric, Proc] The complexity for this field (default: 1), as a constant or a proc like `-> (query_ctx, args, child_complexity) { } # Numeric`
-    def complexity
-      ensure_defined
-      @complexity
-    end
-
-    attr_writer :complexity
+    # @!attribute complexity
+    #   @return [Numeric, Proc] The complexity for this field (default: 1), as a constant or a proc like `-> (query_ctx, args, child_complexity) { } # Numeric`
 
     def initialize
       @complexity = 1
@@ -176,9 +162,12 @@ module GraphQL
       resolve_proc.call(object, arguments, context)
     end
 
-    def resolve=(resolve_proc)
+    # Provide a new callable for this field's resolve function. If `nil`,
+    # a new resolve proc will be build based on its {#name}, {#property} or {#hash_key}.
+    # @param new_resolve_proc [<#call(obj, args, ctx)>, nil]
+    def resolve=(new_resolve_proc)
       ensure_defined
-      @resolve_proc = resolve_proc || build_default_resolver
+      @resolve_proc = new_resolve_proc || build_default_resolver
     end
 
     def type=(new_return_type)

data/lib/graphql/input_object_type.rb

@@ -29,19 +29,15 @@ module GraphQL
       argument: GraphQL::Define::AssignArgument
     )
 
-    lazy_defined_attr_accessor :mutation
+    lazy_defined_attr_accessor :mutation, :arguments
+    alias :input_fields :arguments
 
     # @!attribute mutation
     #   @return [GraphQL::Relay::Mutation, nil] The mutation this field was derived from, if it was derived from a mutation
 
+    # @!attribute arguments
     # @return [Hash<String => GraphQL::Argument>] Map String argument names to their {GraphQL::Argument} implementations
-    def arguments
-      ensure_defined
-      @arguments
-    end
-    attr_writer :arguments
 
-    alias :input_fields :arguments
 
     def initialize
       @arguments = {}

data/lib/graphql/language.rb

@@ -1,3 +1,4 @@
+require "graphql/language/definition_slice"
 require "graphql/language/generation"
 require "graphql/language/lexer"
 require "graphql/language/nodes"

data/lib/graphql/language/definition_slice.rb

@@ -0,0 +1,29 @@
+module GraphQL
+  module Language
+    module DefinitionSlice
+      extend self
+
+      def slice(document, name)
+        definitions = {}
+        document.definitions.each { |d| definitions[d.name] = d }
+        names = find_definition_dependencies(definitions, name)
+        definitions = document.definitions.select { |d| names.include?(d.name) }
+        Nodes::Document.new(definitions: definitions)
+      end
+
+      private
+
+      def find_definition_dependencies(definitions, name)
+        names = Set.new([name])
+        visitor = Visitor.new(definitions[name])
+        visitor[Nodes::FragmentSpread] << -> (node, parent) {
+          if fragment = definitions[node.name]
+            names.merge(find_definition_dependencies(definitions, fragment.name))
+          end
+        }
+        visitor.visit
+        names
+      end
+    end
+  end
+end

data/lib/graphql/language/generation.rb

@@ -1,8 +1,19 @@
 module GraphQL
   module Language
+    # Exposes {.generate}, which turns AST nodes back into query strings.
     module Generation
       extend self
 
+      # Turn an AST node back into a string.
+      #
+      # @example Turning a document into a query
+      #    document = GraphQL.parse(query_string)
+      #    GraphQL::Language::Generation.generate(document)
+      #    # => "{ ... }"
+      #
+      # @param node [GraphQL::Language::Nodes::AbstractNode] an AST node to recursively stringify
+      # @param indent [String] Whitespace to add to each printed node
+      # @return [String] Valid GraphQL for `node`
       def generate(node, indent: "")
         case node
         when Nodes::Document

data/lib/graphql/language/nodes.rb

@@ -1,13 +1,18 @@
 module GraphQL
   module Language
     module Nodes
-      # AbstractNode creates classes who:
-      # - require their keyword arguments, throw ArgumentError if they don't match
-      # - expose accessors for keyword arguments
+      # {AbstractNode} is the base class for all nodes in a GraphQL AST.
+      #
+      # It provides some APIs for working with ASTs:
+      # - `children` returns all AST nodes attached to this one. Used for tree traversal.
+      # - `scalars` returns all scalar (Ruby) values attached to this one. Used for comparing nodes.
+      # - `to_query_string` turns an AST node into a GraphQL string
       class AbstractNode
         attr_accessor :line, :col
 
-        # @param options [Hash] Must contain all attributes defined by {required_attrs}, may also include `position_source`
+        # Initialize a node by extracting its position,
+        # then calling the class's `initialize_node` method.
+        # @param options [Hash] Initial attributes for this node
         def initialize(options={})
           if options.key?(:position_source)
             position_source = options.delete(:position_source)
@@ -25,6 +30,8 @@ module GraphQL
           raise NotImplementedError
         end
 
+        # Value equality
+        # @return [Boolean] True if `self` is equivalent to `other`
         def eql?(other)
           return true if equal?(other)
           other.is_a?(self.class) &&
@@ -32,29 +39,34 @@ module GraphQL
             other.children.eql?(self.children)
         end
 
-        # @return [GraphQL::Language::Nodes::AbstractNode] all nodes in the tree below this one
+        # @return [Array<GraphQL::Language::Nodes::AbstractNode>] all nodes in the tree below this one
         def children
           self.class.child_attributes
             .map { |attr_name| public_send(attr_name) }
             .flatten
         end
 
+        # @return [Array<Integer, Float, String, Boolean, Array>] Scalar values attached to this node
         def scalars
           self.class.scalar_attributes
             .map { |attr_name| public_send(attr_name) }
         end
 
         class << self
+          # A node subclass inherits `scalar_attributes`
+          # and `child_attributes` from its parent
           def inherited(subclass)
             subclass.scalar_attributes(*@scalar_attributes)
             subclass.child_attributes(*@child_attributes)
           end
 
+          # define `attr_names` as places where scalars may be attached to this node
           def scalar_attributes(*attr_names)
             @scalar_attributes ||= []
             @scalar_attributes += attr_names
           end
 
+          # define `attr_names` as places where child nodes may be attached to this node
           def child_attributes(*attr_names)
             @child_attributes ||= []
             @child_attributes += attr_names
@@ -70,6 +82,7 @@ module GraphQL
         end
       end
 
+      # Base class for non-null type names and list type names
       class WrapperType < AbstractNode
         attr_accessor :of_type
         scalar_attributes :of_type
@@ -83,6 +96,7 @@ module GraphQL
         end
       end
 
+      # Base class for nodes whose only value is a name (no child nodes or other scalars)
       class NameOnlyNode < AbstractNode
         attr_accessor :name
         scalar_attributes :name
@@ -96,11 +110,17 @@ module GraphQL
         end
       end
 
-
+      # A key-value pair for a field's inputs
       class Argument < AbstractNode
         attr_accessor :name, :value
         scalar_attributes :name, :value
 
+        # @!attribute name
+        #   @return [String] the key for this argument
+
+        # @!attribute value
+        #   @return [String, Float, Integer, Boolean, Array, InputObject] The value passed for this key
+
         def initialize_node(name: nil, value: nil)
           @name = name
           @value = value
@@ -122,22 +142,42 @@ module GraphQL
         end
       end
 
+      # This is the AST root for normal queries
+      #
+      # @example Deriving a document by parsing a string
+      #   document = GraphQL.parse(query_string)
+      #
+      # @example Creating a string from a document
+      #   document.to_query_string
+      #   # { ... }
+      #
       class Document < AbstractNode
         attr_accessor :definitions
         child_attributes :definitions
 
+        # @!attribute definitions
+        #   @return [Array<OperationDefinition, FragmentDefinition>] top-level GraphQL units: operations or fragments
         def initialize_node(definitions: [])
           @definitions = definitions
         end
+
+        def slice_definition(name)
+          GraphQL::Language::DefinitionSlice.slice(self, name)
+        end
       end
 
+      # An enum value. The string is available as {#name}.
       class Enum < NameOnlyNode; end
 
+      # A single selection in a GraphQL query.
       class Field < AbstractNode
         attr_accessor :name, :alias, :arguments, :directives, :selections
         scalar_attributes :name, :alias
         child_attributes :arguments, :directives, :selections
 
+        # @!attribute selections
+        #   @return [Array<Nodes::Field>] Selections on this object (or empty array if this is a scalar field)
+
         def initialize_node(name: nil, arguments: [], directives: [], selections: [], **kwargs)
           @name = name
           # oops, alias is a keyword:
@@ -148,11 +188,17 @@ module GraphQL
         end
       end
 
+      # A reusable fragment, defined at document-level.
       class FragmentDefinition < AbstractNode
         attr_accessor :name, :type, :directives, :selections
         scalar_attributes :name, :type
         child_attributes :directives, :selections
 
+        # @!attribute name
+        #   @return [String] the identifier for this fragment, which may be applied with `...#{name}`
+
+        # @!attribute type
+        #   @return [String] the type condition for this fragment (name of type which it may apply to)
         def initialize_node(name: nil, type: nil, directives: [], selections: [])
           @name = name
           @type = type
@@ -161,22 +207,30 @@ module GraphQL
         end
       end
 
+      # Application of a named fragment in a selection
       class FragmentSpread < AbstractNode
         attr_accessor :name, :directives
         scalar_attributes :name
         child_attributes :directives
 
+        # @!attribute name
+        #   @return [String] The identifier of the fragment to apply, corresponds with {FragmentDefinition#name}
+
         def initialize_node(name: nil, directives: [])
           @name = name
           @directives = directives
         end
       end
 
+      # An unnamed fragment, defined directly in the query with `... {  }`
       class InlineFragment < AbstractNode
         attr_accessor :type, :directives, :selections
         scalar_attributes :type
         child_attributes :directives, :selections
 
+        # @!attribute type
+        #   @return [String, nil] Name of the type this fragment applies to, or `nil` if this fragment applies to any type
+
         def initialize_node(type: nil, directives: [], selections: [])
           @type = type
           @directives = directives
@@ -184,14 +238,19 @@ module GraphQL
         end
       end
 
+      # A collection of key-value inputs which may be a field argument
       class InputObject < AbstractNode
         attr_accessor :arguments
         child_attributes :arguments
 
+        # @!attribute arguments
+        #   @return [Array<Nodes::Argument>] A list of key-value pairs inside this input object
+
         def initialize_node(arguments: [])
           @arguments = arguments
         end
 
+        # @return [Hash<String, Any>] Recursively turn this input object into a Ruby Hash
         def to_h(options={})
           arguments.inject({}) do |memo, pair|
             v = pair.value
@@ -202,15 +261,32 @@ module GraphQL
       end
 
 
-
+      # A list type definition, denoted with `[...]` (used for variable type definitions)
       class ListType < WrapperType; end
+
+      # A non-null type definition, denoted with `...!` (used for variable type definitions)
       class NonNullType < WrapperType; end
 
+      # A query, mutation or subscription.
+      # May be anonymous or named.
+      # May be explicitly typed (eg `mutation { ... }`) or implicitly a query (eg `{ ... }`).
       class OperationDefinition < AbstractNode
         attr_accessor :operation_type, :name, :variables, :directives, :selections
         scalar_attributes :operation_type, :name
         child_attributes :variables, :directives, :selections
 
+        # @!attribute variables
+        #   @return [Array<VariableDefinition>] Variable definitions for this operation
+
+        # @!attribute selections
+        #   @return [Array<Field>] Root-level fields on this operation
+
+        # @!attribute operation_type
+        #   @return [String, nil] The root type for this operation, or `nil` for implicit `"query"`
+
+        # @!attribute name
+        #   @return [String, nil] The name for this operation, or `nil` if unnamed
+
         def initialize_node(operation_type: nil, name: nil, variables: [], directives: [], selections: [])
           @operation_type = operation_type
           @name = name
@@ -220,12 +296,23 @@ module GraphQL
         end
       end
 
+      # A type name, used for variable definitions
       class TypeName < NameOnlyNode; end
 
+      # An operation-level query variable
       class VariableDefinition < AbstractNode
         attr_accessor :name, :type, :default_value
         scalar_attributes :name, :type, :default_value
 
+        # @!attribute default_value
+        #   @return [String, Integer, Float, Boolean, Array] A Ruby value to use if no other value is provided
+
+        # @!attribute type
+        #   @return [TypeName, NonNullType, ListType] The expected type of this value
+
+        # @!attribute name
+        #   @return [String] The identifier for this variable, _without_ `$`
+
         def initialize_node(name: nil, type: nil, default_value: nil)
           @name = name
           @type = type
@@ -233,9 +320,9 @@ module GraphQL
         end
       end
 
+      # Usage of a variable in a query. Name does _not_ include `$`.
       class VariableIdentifier < NameOnlyNode; end
 
-
       class SchemaDefinition < AbstractNode
         attr_accessor :query, :mutation, :subscription
         scalar_attributes :query, :mutation, :subscription

data/lib/graphql/language/token.rb

@@ -1,7 +1,11 @@
 module GraphQL
   module Language
+    # Emitted by the lexer and passed to the parser.
+    # Contains type, value and position data.
     class Token
+      # @return [Symbol] The kind of token this is
       attr_reader :name
+
       def initialize(value:, name:, line:, col:)
         @name = name
         @value = value

data/lib/graphql/schema.rb

@@ -57,7 +57,7 @@ module GraphQL
       :query, :mutation, :subscription,
       :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
       :max_depth, :max_complexity,
-      :orphan_types,
+      :orphan_types, :node_identification,
       :query_analyzers, :middleware
 
 
@@ -67,22 +67,16 @@ module GraphQL
 
     attr_reader :directives, :static_validator
 
-    # @return [GraphQL::Relay::GlobalNodeIdentification] the node identification instance for this schema, when using Relay
-    def node_identification
-      ensure_defined
-      @node_identification
-    end
+    # @!attribute node_identification
+    #   @return [GraphQL::Relay::GlobalNodeIdentification] the node identification instance for this schema, when using Relay
 
     def node_identification=(new_node_ident)
       new_node_ident.schema = self
       @node_identification = new_node_ident
     end
 
-    # @return [Array<#call>] Middlewares suitable for MiddlewareChain, applied to fields during execution
-    def middleware
-      ensure_defined
-      @middleware
-    end
+    # @!attribute [r] middleware
+    #   @return [Array<#call>] Middlewares suitable for MiddlewareChain, applied to fields during execution
 
     # @param query [GraphQL::ObjectType]  the query root for the schema
     # @param mutation [GraphQL::ObjectType] the mutation root for the schema

data/lib/graphql/static_validation/rules/fields_are_defined_on_type.rb

@@ -23,7 +23,7 @@ module GraphQL
 
         field =  parent_type.get_field(ast_field.name)
         if field.nil?
-          context.errors << message("Field '#{ast_field.name}' doesn't exist on type '#{parent_type.name}'", parent, context: context)
+          context.errors << message("Field '#{ast_field.name}' doesn't exist on type '#{parent_type.name}'", ast_field, context: context)
           return GraphQL::Language::Visitor::SKIP
         end
       end

data/lib/graphql/version.rb

@@ -1,3 +1,3 @@
 module GraphQL
-  VERSION = "0.18.10"
+  VERSION = "0.18.11"
 end

data/spec/graphql/language/definition_slice_spec.rb

@@ -0,0 +1,225 @@
+require "spec_helper"
+
+describe GraphQL::Language::DefinitionSlice do
+  let(:document) { GraphQL::Language::Parser.parse(query_string) }
+
+  describe "anonymous query with no dependencies" do
+    let(:query_string) {%|
+      {
+        version
+      }
+    |}
+
+    it "is already the smallest slice" do
+      assert_equal document.to_query_string,
+        document.slice_definition(nil).to_query_string
+    end
+  end
+
+  describe "anonymous mutation with no dependencies" do
+    let(:query_string) {%|
+      mutation {
+        ping {
+          message
+        }
+      }
+    |}
+
+    it "is already the smallest slice" do
+      assert_equal document.to_query_string,
+        document.slice_definition(nil).to_query_string
+    end
+  end
+
+  describe "anonymous fragment with no dependencies" do
+    let(:query_string) {%|
+      fragment on User {
+        name
+      }
+    |}
+
+    it "is already the smallest slice" do
+      assert_equal document.to_query_string,
+        document.slice_definition(nil).to_query_string
+    end
+  end
+
+  describe "named query with no dependencies" do
+    let(:query_string) {%|
+      query getVersion {
+        version
+      }
+    |}
+
+    it "is already the smallest slice" do
+      assert_equal document.to_query_string,
+        document.slice_definition("getVersion").to_query_string
+    end
+  end
+
+  describe "named fragment with no dependencies" do
+    let(:query_string) {%|
+      fragment profileFields on User {
+        firstName
+        lastName
+      }
+    |}
+
+    it "is already the smallest slice" do
+      assert_equal document.to_query_string,
+        document.slice_definition("profileFields").to_query_string
+    end
+  end
+
+  describe "document with multiple queries but no subdependencies" do
+    let(:query_string) {%|
+      query getVersion {
+        version
+      }
+
+      query getTime {
+        time
+      }
+    |}
+
+    it "returns just the query definition" do
+      assert_equal GraphQL::Language::Nodes::Document.new(definitions: [document.definitions[0]]).to_query_string,
+        document.slice_definition("getVersion").to_query_string
+      assert_equal GraphQL::Language::Nodes::Document.new(definitions: [document.definitions[1]]).to_query_string,
+        document.slice_definition("getTime").to_query_string
+    end
+  end
+
+  describe "document with multiple fragments but no subdependencies" do
+    let(:query_string) {%|
+      fragment profileFields on User {
+        firstName
+        lastName
+      }
+
+      fragment avatarFields on User {
+        avatarURL(size: 80)
+      }
+    |}
+
+    it "returns just the fragment definition" do
+      assert_equal GraphQL::Language::Nodes::Document.new(definitions: [document.definitions[0]]).to_query_string,
+        document.slice_definition("profileFields").to_query_string
+      assert_equal GraphQL::Language::Nodes::Document.new(definitions: [document.definitions[1]]).to_query_string,
+        document.slice_definition("avatarFields").to_query_string
+    end
+  end
+
+  describe "query with missing spread" do
+    let(:query_string) {%|
+      query getUser {
+        viewer {
+          ...profileFields
+        }
+      }
+    |}
+
+    it "is ignored" do
+      assert_equal document.to_query_string,
+        document.slice_definition("getUser").to_query_string
+    end
+  end
+
+  describe "query and fragment subdependency" do
+    let(:query_string) {%|
+      query getUser {
+        viewer {
+          ...profileFields
+        }
+      }
+
+      fragment profileFields on User {
+        firstName
+        lastName
+      }
+    |}
+
+    it "returns query and fragment dependency" do
+      assert_equal document.to_query_string,
+        document.slice_definition("getUser").to_query_string
+    end
+  end
+
+  describe "query and fragment nested subdependencies" do
+    let(:query_string) {%|
+      query getUser {
+        viewer {
+          ...viewerInfo
+        }
+      }
+
+      fragment viewerInfo on User {
+        ...profileFields
+      }
+
+      fragment profileFields on User {
+        firstName
+        lastName
+        ...avatarFields
+      }
+
+      fragment avatarFields on User {
+        avatarURL(size: 80)
+      }
+    |}
+
+    it "returns query and all fragment dependencies" do
+      assert_equal document.to_query_string,
+        document.slice_definition("getUser").to_query_string
+    end
+  end
+
+  describe "fragment subdependency referenced multiple times" do
+    let(:query_string) {%|
+      query getUser {
+        viewer {
+          ...viewerInfo
+          ...moreViewerInfo
+        }
+      }
+
+      fragment viewerInfo on User {
+        ...profileFields
+      }
+
+      fragment moreViewerInfo on User {
+        ...profileFields
+      }
+
+      fragment profileFields on User {
+        firstName
+        lastName
+      }
+    |}
+
+    it "is only returned once" do
+      assert_equal document.to_query_string,
+        document.slice_definition("getUser").to_query_string
+    end
+  end
+
+  describe "query and unused fragment" do
+    let(:query_string) {%|
+      query getUser {
+        viewer {
+          id
+        }
+      }
+
+      fragment profileFields on User {
+        firstName
+        lastName
+      }
+    |}
+
+    it "returns just the query definition" do
+      assert_equal GraphQL::Language::Nodes::Document.new(definitions: [document.definitions[0]]).to_query_string,
+        document.slice_definition("getUser").to_query_string
+    end
+  end
+end

data/spec/graphql/static_validation/rules/fields_are_defined_on_type_spec.rb

@@ -26,6 +26,21 @@ describe GraphQL::StaticValidation::FieldsAreDefinedOnType do
     assert_equal(expected_errors, error_messages)
   end
 
+  describe "on objects" do
+    let(:query_string) { "query getStuff { notDefinedField }"}
+
+    it "finds invalid fields" do
+      expected_errors = [
+        {
+          "message"=>"Field 'notDefinedField' doesn't exist on type 'Query'",
+          "locations"=>[{"line"=>1, "column"=>18}],
+          "path"=>["query getStuff", "notDefinedField"],
+        }
+      ]
+      assert_equal(expected_errors, errors)
+    end
+  end
+
   describe "on interfaces" do
     let(:query_string) { "query getStuff { favoriteEdible { amountThatILikeIt } }"}
 
@@ -33,7 +48,7 @@ describe GraphQL::StaticValidation::FieldsAreDefinedOnType do
       expected_errors = [
         {
           "message"=>"Field 'amountThatILikeIt' doesn't exist on type 'Edible'",
-          "locations"=>[{"line"=>1, "column"=>18}],
+          "locations"=>[{"line"=>1, "column"=>35}],
           "path"=>["query getStuff", "favoriteEdible", "amountThatILikeIt"],
         }
       ]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 0.18.10
+  version: 0.18.11
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-09 00:00:00.000000000 Z
+date: 2016-09-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: codeclimate-test-reporter
@@ -304,6 +304,7 @@ files:
 - lib/graphql/introspection/typename_field.rb
 - lib/graphql/invalid_null_error.rb
 - lib/graphql/language.rb
+- lib/graphql/language/definition_slice.rb
 - lib/graphql/language/generation.rb
 - lib/graphql/language/lexer.rb
 - lib/graphql/language/lexer.rl
@@ -413,6 +414,7 @@ files:
 - spec/graphql/introspection/introspection_query_spec.rb
 - spec/graphql/introspection/schema_type_spec.rb
 - spec/graphql/introspection/type_type_spec.rb
+- spec/graphql/language/definition_slice_spec.rb
 - spec/graphql/language/equality_spec.rb
 - spec/graphql/language/generation_spec.rb
 - spec/graphql/language/nodes_spec.rb
@@ -524,6 +526,7 @@ test_files:
 - spec/graphql/introspection/introspection_query_spec.rb
 - spec/graphql/introspection/schema_type_spec.rb
 - spec/graphql/introspection/type_type_spec.rb
+- spec/graphql/language/definition_slice_spec.rb
 - spec/graphql/language/equality_spec.rb
 - spec/graphql/language/generation_spec.rb
 - spec/graphql/language/nodes_spec.rb