graphql-client 0.12.3 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 532760d69d3380633bfa7e7555697aa843b72fa7
-  data.tar.gz: 947e81aeea7eb9058c01b844425e4035a955a003
+SHA256:
+  metadata.gz: 1f7ced5b5ef5fb8e496d8c221867165c4629670a5f8ecf1e44f8c523e5774ae2
+  data.tar.gz: 49453ec41a714dca5774c32b24139527beb7623a8c99a2368e789f9b1443c79a
 SHA512:
-  metadata.gz: 34f989f928690406e82004b449264785395ffc00c809e70784b53284889b8c4409f1bbc3226b1ae7ac62df69b1ca8d753871f44b2545746e2b775c0a0bc263e8
-  data.tar.gz: 7f354451883ab22eefea03dea49cfe1bc848b8a6419ad9f626881a7dece1ec6922b3154a89561d5aa8ada72e9d919ecb24c529b4d13669c28ec63a7ab47d166e
+  metadata.gz: b69902cbed392a6ad77d5e124db8196439b17750ecb369fc3189a93593857f5e1cf80ade820edb5abc0e11cade056832c733726e2e4202207496d7435eb6ebfa
+  data.tar.gz: a918d43558b2f75ce3627a7dd003ba76e083b9c087f15c36e4df7e571d5eef71a4760fe929a7d6d93eb78a22b4f310c8ef75f9737a719a516c659eb70117026e

data/README.md

@@ -1,21 +1,30 @@
-# graphql-client
+# graphql-client [![Gem Version](https://badge.fury.io/rb/graphql-client.svg)](https://badge.fury.io/rb/graphql-client) [![Build Status](https://travis-ci.org/github/graphql-client.svg?branch=master)](https://travis-ci.org/github/graphql-client)
 
 GraphQL Client is a Ruby library for declaring, composing and executing GraphQL queries.
 
 ## Usage
 
+### Installation
+
+Add `graphql-client` to your Gemfile and then run `bundle install`.
+
+```ruby
+# Gemfile
+gem 'graphql-client'
+```
+
 ### Configuration
 
 Sample configuration for a GraphQL Client to query from the [SWAPI GraphQL Wrapper](https://github.com/graphql/swapi-graphql).
 
-``` ruby
+```ruby
 require "graphql/client"
 require "graphql/client/http"
 
 # Star Wars API example wrapper
 module SWAPI
   # Configure GraphQL endpoint using the basic HTTP network adapter.
-  HTTP = GraphQL::Client::HTTP.new("http://graphql-swapi.parseapp.com/") do
+  HTTP = GraphQL::Client::HTTP.new("https://example.com/graphql") do
     def headers(context)
       # Optionally set any HTTP headers
       { "User-Agent": "My Client" }
@@ -42,7 +51,7 @@ If you haven't already, [familiarize yourself with the GraphQL query syntax](htt
 
 This client library encourages all GraphQL queries to be declared statically and assigned to a Ruby constant.
 
-``` ruby
+```ruby
 HeroNameQuery = SWAPI::Client.parse <<-'GRAPHQL'
   query {
     hero {
@@ -51,6 +60,7 @@ HeroNameQuery = SWAPI::Client.parse <<-'GRAPHQL'
   }
 GRAPHQL
 ```
+
 Queries can reference variables that are passed in at query execution time.
 
 ```ruby
@@ -65,7 +75,7 @@ GRAPHQL
 
 Fragments are declared similarly.
 
-``` ruby
+```ruby
 HumanFragment = SWAPI::Client.parse <<-'GRAPHQL'
   fragment on Human {
     name
@@ -76,7 +86,7 @@ GRAPHQL
 
 To include a fragment in a query, reference the fragment by constant.
 
-``` ruby
+```ruby
 HeroNameQuery = SWAPI::Client.parse <<-'GRAPHQL'
   {
     luke: human(id: "1000") {
@@ -91,7 +101,7 @@ GRAPHQL
 
 This works for namespaced constants.
 
-``` ruby
+```ruby
 module Hero
   Query = SWAPI::Client.parse <<-'GRAPHQL'
     {
@@ -112,7 +122,7 @@ end
 
 Pass the reference of a parsed query definition to `GraphQL::Client#query`. Data is returned back in a wrapped `GraphQL::Client::Schema::ObjectType` struct that provides Ruby-ish accessors.
 
-``` ruby
+```ruby
 result = SWAPI::Client.query(Hero::Query)
 
 # The raw data is Hash of JSON values
@@ -121,18 +131,20 @@ result = SWAPI::Client.query(Hero::Query)
 # The wrapped result allows to you access data with Ruby methods
 result.data.luke.home_planet
 ```
-`GraphQL::Client#query` also accepts variables and context parameters that can be leveraged by the underlying network executor. 
 
-``` ruby
+`GraphQL::Client#query` also accepts variables and context parameters that can be leveraged by the underlying network executor.
+
+```ruby
 result = SWAPI::Client.query(Hero::HeroFromEpisodeQuery, variables: {episode: "JEDI"}, context: {user_id: current_user_id})
 ```
+
 ### Rails ERB integration
 
 If you're using Ruby on Rails ERB templates, theres a ERB extension that allows static queries to be defined in the template itself.
 
 In standard Ruby you can simply assign queries and fragments to constants and they'll be available throughout the app. However, the contents of an ERB template is compiled into a Ruby method, and methods can't assign constants. So a new ERB tag was extended to declare static sections that include a GraphQL query.
 
-``` erb
+```erb
 <%# app/views/humans/human.html.erb %>
 <%graphql
   fragment HumanFragment on Human {
@@ -161,7 +173,7 @@ These `<%graphql` sections are simply ignored at runtime but make their definiti
 
 Add `graphql-client` to your app's Gemfile:
 
-``` ruby
+```ruby
 gem 'graphql-client'
 ```
 

data/lib/graphql/client/definition.rb

@@ -14,39 +14,68 @@ module GraphQL
     #
     # Definitions MUST be assigned to a constant.
     class Definition < Module
-      def self.for(irep_node:, **kargs)
-        case irep_node.ast_node
+      def self.for(ast_node:, **kargs)
+        case ast_node
         when Language::Nodes::OperationDefinition
-          OperationDefinition.new(irep_node: irep_node, **kargs)
+          OperationDefinition.new(ast_node: ast_node, **kargs)
         when Language::Nodes::FragmentDefinition
-          FragmentDefinition.new(irep_node: irep_node, **kargs)
+          FragmentDefinition.new(ast_node: ast_node, **kargs)
         else
-          raise TypeError, "expected node to be a definition type, but was #{irep_node.ast_node.class}"
+          raise TypeError, "expected node to be a definition type, but was #{ast_node.class}"
         end
       end
 
-      def initialize(client:, document:, irep_node:, source_location:)
+      def initialize(client:, document:, source_document:, ast_node:, source_location:)
         @client = client
         @document = document
-        @definition_node = irep_node.ast_node
+        @source_document = source_document
+        @definition_node = ast_node
         @source_location = source_location
-        @schema_class = client.types.define_class(self, irep_node, irep_node.return_type)
+
+        definition_type = case ast_node
+        when GraphQL::Language::Nodes::OperationDefinition
+          case ast_node.operation_type
+          when "mutation"
+            @client.schema.mutation
+          when "subscription"
+            @client.schema.subscription
+          when "query", nil
+            @client.schema.query
+          else
+            raise "Unexpected operation_type: #{ast_node.operation_type}"
+          end
+        when GraphQL::Language::Nodes::FragmentDefinition
+          @client.schema.types[ast_node.type.name]
+        else
+          raise "Unexpected ast_node: #{ast_node}"
+        end
+
+        @schema_class = client.types.define_class(self, [ast_node], definition_type)
+
+        # Clear cache only needed during initialization
+        @indexes = nil
       end
 
       # Internal: Get associated owner GraphQL::Client instance.
       attr_reader :client
 
-      # Internal root schema class for defintion. Returns
+      # Internal root schema class for definition. Returns
       # GraphQL::Client::Schema::ObjectType or
       # GraphQL::Client::Schema::PossibleTypes.
       attr_reader :schema_class
 
-      # Internal: Get underlying operation or fragment defintion AST node for
+      # Internal: Get underlying operation or fragment definition AST node for
       # definition.
       #
       # Returns OperationDefinition or FragmentDefinition object.
       attr_reader :definition_node
 
+      # Internal: Get original document that created this definition, without
+      # any additional dependencies.
+      #
+      # Returns GraphQL::Language::Nodes::Document.
+      attr_reader :source_document
+
       # Public: Global name of definition in client document.
       #
       # Returns a GraphQL safe name of the Ruby constant String.
@@ -82,9 +111,9 @@ module GraphQL
         when GraphQL::Client::Schema::PossibleTypes
           case obj
           when NilClass
-            nil
+            obj
           else
-            schema_class.cast(obj.to_h, obj.errors)
+            cast_object(obj)
           end
         when GraphQL::Client::Schema::ObjectType
           case obj
@@ -93,14 +122,7 @@ module GraphQL
           when Hash
             schema_class.new(obj, errors)
           else
-            if obj.class.is_a?(GraphQL::Client::Schema::ObjectType)
-              unless obj.class._spreads.include?(definition_node.name)
-                raise TypeError, "#{definition_node.name} is not included in #{obj.class.source_definition.name}"
-              end
-              schema_class.cast(obj.to_h, obj.errors)
-            else
-              raise TypeError, "unexpected #{obj.class}"
-            end
+            cast_object(obj)
           end
         else
           raise TypeError, "unexpected #{schema_class}"
@@ -119,9 +141,26 @@ module GraphQL
       end
 
       private
+
+        def cast_object(obj)
+          if obj.class.is_a?(GraphQL::Client::Schema::ObjectType)
+            unless obj.class._spreads.include?(definition_node.name)
+              raise TypeError, "#{definition_node.name} is not included in #{obj.class.source_definition.name}"
+            end
+            schema_class.cast(obj.to_h, obj.errors)
+          else
+            raise TypeError, "unexpected #{obj.class}"
+          end
+        end
+
+        EMPTY_SET = Set.new.freeze
+
         def index_spreads(visitor)
           spreads = {}
-          on_node = ->(node, _parent) { spreads[node] = Set.new(flatten_spreads(node).map(&:name)) }
+          on_node = ->(node, _parent) do
+            node_spreads = flatten_spreads(node).map(&:name)
+            spreads[node] = node_spreads.empty? ? EMPTY_SET : Set.new(node_spreads).freeze
+          end
 
           visitor[GraphQL::Language::Nodes::Field] << on_node
           visitor[GraphQL::Language::Nodes::FragmentDefinition] << on_node

data/lib/graphql/client/erb.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+require "action_view"
+
+module GraphQL
+  class Client
+    begin
+      require "action_view/template/handlers/erb/erubi"
+    rescue LoadError
+      require "graphql/client/erubis_enhancer"
+
+      # Public: Extended Erubis implementation that supports GraphQL static
+      # query sections.
+      #
+      #   <%graphql
+      #     query GetVersion {
+      #       version
+      #     }
+      #   %>
+      #   <%= data.version %>
+      #
+      # Configure ActionView's default ERB implementation to use this class.
+      #
+      #   ActionView::Template::Handlers::ERB.erb_implementation = GraphQL::Client::Erubis
+      #
+      class ERB < ActionView::Template::Handlers::Erubis
+        include ErubisEnhancer
+      end
+    else
+      require "graphql/client/erubi_enhancer"
+
+      # Public: Extended Erubis implementation that supports GraphQL static
+      # query sections.
+      #
+      #   <%graphql
+      #     query GetVerison {
+      #       version
+      #     }
+      #   %>
+      #   <%= data.version %>
+      #
+      # Configure ActionView's default ERB implementation to use this class.
+      #
+      #   ActionView::Template::Handlers::ERB.erb_implementation = GraphQL::Client::Erubi
+      #
+      class ERB < ActionView::Template::Handlers::ERB::Erubi
+        include ErubiEnhancer
+      end
+    end
+  end
+end

data/lib/graphql/client/erubis.rb

@@ -1,30 +1,8 @@
 # frozen_string_literal: true
-require "action_view"
-require "graphql/client/erubis_enhancer"
+require "graphql/client/erb"
 
 module GraphQL
   class Client
-    # Ignore deprecation errors loading AV Erubis
-    ActiveSupport::Deprecation.silence do
-      ActionView::Template::Handlers::Erubis
-    end
-
-    # Public: Extended Erubis implementation that supports GraphQL static
-    # query sections.
-    #
-    #   <%graphql
-    #     query GetVersion {
-    #       version
-    #     }
-    #   %>
-    #   <%= data.version %>
-    #
-    # Configure ActionView's default ERB implementation to use this class.
-    #
-    #   ActionView::Template::Handlers::ERB.erb_implementation = GraphQL::Client::Erubis
-    #
-    class Erubis < ActionView::Template::Handlers::Erubis
-      include ErubisEnhancer
-    end
+    Erubis = GraphQL::Client::ERB
   end
 end

data/lib/graphql/client/query_typename.rb

@@ -13,33 +13,84 @@ module GraphQL
       # document - GraphQL::Language::Nodes::Document to modify
       # schema - Optional Map of GraphQL::Language::Nodes::Node to GraphQL::Type
       #
-      # Returns nothing.
-      def self.insert_typename_fields(document, types: {})
-        on_selections = ->(node, _parent) do
-          type = types[node]
-
-          if node.selections.any?
-            case type && type.unwrap
-            when NilClass, GraphQL::InterfaceType, GraphQL::UnionType
-              names = node_flatten_selections(node.selections).map { |s| s.respond_to?(:name) ? s.name : nil }
+      # Returns the document with `__typename` added to it
+      if GraphQL::Language::Nodes::AbstractNode.method_defined?(:merge)
+        # GraphQL 1.9 introduces a new visitor class
+        # and doesn't expose writer methods for node attributes.
+        # So, use the node mutation API instead.
+        class InsertTypenameVisitor < GraphQL::Language::Visitor
+          def initialize(document, types:)
+            @types = types
+            super(document)
+          end
+
+          def add_typename(node, parent)
+            type = @types[node]
+            type = type && type.unwrap
+
+            if (node.selections.any? && (type.nil? || type.is_a?(GraphQL::InterfaceType) || type.is_a?(GraphQL::UnionType))) ||
+              (node.selections.none? && type.is_a?(GraphQL::ObjectType))
+              names = QueryTypename.node_flatten_selections(node.selections).map { |s| s.respond_to?(:name) ? s.name : nil }
               names = Set.new(names.compact)
 
-              unless names.include?("__typename")
-                node.selections = [GraphQL::Language::Nodes::Field.new(name: "__typename")] + node.selections
+              if names.include?("__typename")
+                yield(node, parent)
+              else
+                node_with_typename = node.merge(selections: [GraphQL::Language::Nodes::Field.new(name: "__typename")] + node.selections)
+                yield(node_with_typename, parent)
               end
+            else
+              yield(node, parent)
             end
-          elsif type && type.unwrap.is_a?(GraphQL::ObjectType)
-            node.selections = [GraphQL::Language::Nodes::Field.new(name: "__typename")]
+          end
+
+          def on_operation_definition(node, parent)
+            add_typename(node, parent) { |n, p| super(n, p) }
+          end
+
+          def on_field(node, parent)
+            add_typename(node, parent) { |n, p| super(n, p) }
+          end
+
+          def on_fragment_definition(node, parent)
+            add_typename(node, parent) { |n, p| super(n, p) }
           end
         end
 
-        visitor = GraphQL::Language::Visitor.new(document)
-        visitor[GraphQL::Language::Nodes::Field].leave << on_selections
-        visitor[GraphQL::Language::Nodes::FragmentDefinition].leave << on_selections
-        visitor[GraphQL::Language::Nodes::OperationDefinition].leave << on_selections
-        visitor.visit
+        def self.insert_typename_fields(document, types: {})
+          visitor = InsertTypenameVisitor.new(document, types: types)
+          visitor.visit
+          visitor.result
+        end
+
+      else
+        def self.insert_typename_fields(document, types: {})
+          on_selections = ->(node, _parent) do
+            type = types[node]
+
+            if node.selections.any?
+              case type && type.unwrap
+              when NilClass, GraphQL::InterfaceType, GraphQL::UnionType
+                names = node_flatten_selections(node.selections).map { |s| s.respond_to?(:name) ? s.name : nil }
+                names = Set.new(names.compact)
 
-        nil
+                unless names.include?("__typename")
+                  node.selections = [GraphQL::Language::Nodes::Field.new(name: "__typename")] + node.selections
+                end
+              end
+            elsif type && type.unwrap.is_a?(GraphQL::ObjectType)
+              node.selections = [GraphQL::Language::Nodes::Field.new(name: "__typename")]
+            end
+          end
+
+          visitor = GraphQL::Language::Visitor.new(document)
+          visitor[GraphQL::Language::Nodes::Field].leave << on_selections
+          visitor[GraphQL::Language::Nodes::FragmentDefinition].leave << on_selections
+          visitor[GraphQL::Language::Nodes::OperationDefinition].leave << on_selections
+          visitor.visit
+
+          document
+        end
       end
 
       def self.node_flatten_selections(selections)

data/lib/graphql/client/railtie.rb

@@ -22,8 +22,8 @@ module GraphQL
       end
 
       initializer "graphql.configure_erb_implementation" do |_app|
-        require "graphql/client/erubis"
-        ActionView::Template::Handlers::ERB.erb_implementation = GraphQL::Client::Erubis
+        require "graphql/client/erb"
+        ActionView::Template::Handlers::ERB.erb_implementation = GraphQL::Client::ERB
       end
 
       initializer "graphql.configure_views_namespace" do |app|

data/lib/graphql/client/schema/enum_type.rb

@@ -9,6 +9,34 @@ module GraphQL
       class EnumType < Module
         include BaseType
 
+        class EnumValue < String
+          def initialize(obj, enum_value, enum)
+            super(obj)
+            @enum_value = enum_value
+            @enum = enum
+          end
+
+          def respond_to_missing?(method_name, include_private = false)
+            if method_name[-1] == "?" && @enum.include?(method_name[0..-2])
+              true
+            else
+              super
+            end
+          end
+
+          def method_missing(method_name, *args)
+            if method_name[-1] == "?"
+              queried_value = method_name[0..-2]
+              if @enum.include?(queried_value)
+                raise ArgumentError, "wrong number of arguments (given #{args.size}, expected 0)" unless args.empty?
+                return @enum_value == queried_value
+              end
+            end
+
+            super
+          end
+        end
+
         # Internal: Construct enum wrapper from another GraphQL::EnumType.
         #
         # type - GraphQL::EnumType instance
@@ -21,22 +49,18 @@ module GraphQL
           @values = {}
 
           all_values = type.values.keys
+          comparison_set = all_values.map { |s| -s.downcase }.to_set
 
           all_values.each do |value|
-            str = value.dup
-            all_values.each do |v|
-              str.define_singleton_method("#{v.downcase}?") { false }
-            end
-            str.define_singleton_method("#{value.downcase}?") { true }
-            str.freeze
+            str = EnumValue.new(-value, -value.downcase, comparison_set).freeze
             const_set(value, str) if value =~ /^[A-Z]/
-            @values[str] = str
+            @values[str.to_s] = str
           end
 
           @values.freeze
         end
 
-        def define_class(definition, irep_node)
+        def define_class(definition, ast_nodes)
           self
         end
 

data/lib/graphql/client/schema/interface_type.rb

@@ -20,10 +20,12 @@ module GraphQL
           PossibleTypes.new(type, types)
         end
 
-        def define_class(definition, irep_node)
-          new(irep_node.typed_children.keys.map { |ctype|
-            schema_module.get_class(ctype.name).define_class(definition, irep_node)
-          })
+        def define_class(definition, ast_nodes)
+          possible_type_names = definition.client.schema.possible_types(type).map(&:graphql_name)
+          possible_types = possible_type_names.map { |concrete_type_name|
+            schema_module.get_class(concrete_type_name).define_class(definition, ast_nodes)
+          }
+          new(possible_types)
         end
       end
     end

data/lib/graphql/client/schema/object_type.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-
 require "active_support/inflector"
 require "graphql/client/error"
 require "graphql/client/errors"
@@ -20,34 +19,83 @@ module GraphQL
           end
         end
 
-        def define_class(definition, irep_node)
-          fields = irep_node.typed_children[type].inject({}) { |h, (field_name, field_irep_node)|
-            if definition.indexes[:definitions][field_irep_node.ast_node] == definition.definition_node
-              h[field_name.to_sym] = schema_module.define_class(definition, field_irep_node, field_irep_node.definition.type)
+        def define_class(definition, ast_nodes)
+          # First, gather all the ast nodes representing a certain selection, by name.
+          # We gather AST nodes into arrays so that multiple selections can be grouped, for example:
+          #
+          #   {
+          #     f1 { a b }
+          #     f1 { b c }
+          #   }
+          #
+          # should be treated like `f1 { a b c }`
+          field_nodes = {}
+          ast_nodes.each do |ast_node|
+            ast_node.selections.each do |selected_ast_node|
+              gather_selections(field_nodes, definition, selected_ast_node)
             end
-            h
-          }
+          end
 
-          Class.new(self) do
-            define_fields(fields)
+          # After gathering all the nodes by name, prepare to create methods and classes for them.
+          field_classes = {}
+          field_nodes.each do |result_name, field_ast_nodes|
+            # `result_name` might be an alias, so make sure to get the proper name
+            field_name = field_ast_nodes.first.name
+            field_definition = definition.client.schema.get_field(type.name, field_name)
+            field_return_type = field_definition.type
+            field_classes[result_name.to_sym] = schema_module.define_class(definition, field_ast_nodes, field_return_type)
+          end
 
-            if definition.client.enforce_collocated_callers
-              keys = fields.keys.map { |key| ActiveSupport::Inflector.underscore(key) }
-              Client.enforce_collocated_callers(self, keys, definition.source_location[0])
-            end
+          klass = Class.new(self)
+          klass.define_fields(field_classes)
+          klass.instance_variable_set(:@source_definition, definition)
+          klass.instance_variable_set(:@_spreads, definition.indexes[:spreads][ast_nodes.first])
+
+          if definition.client.enforce_collocated_callers
+            keys = field_classes.keys.map { |key| ActiveSupport::Inflector.underscore(key) }
+            Client.enforce_collocated_callers(klass, keys, definition.source_location[0])
+          end
+
+          klass
+        end
 
-            class << self
-              attr_reader :source_definition
-              attr_reader :_spreads
+        PREDICATE_CACHE = Hash.new { |h, name|
+          h[name] = -> { @data[name] ? true : false }
+        }
+
+        METHOD_CACHE = Hash.new { |h, key|
+          h[key] = -> {
+            name = key.to_s
+            type = self.class::FIELDS[key]
+            @casted_data.fetch(name) do
+              @casted_data[name] = type.cast(@data[name], @errors.filter_by_path(name))
             end
+          }
+        }
 
-            @source_definition = definition
-            @_spreads = definition.indexes[:spreads][irep_node.ast_node]
+        MODULE_CACHE = Hash.new do |h, fields|
+          h[fields] = Module.new do
+            fields.each do |name|
+              GraphQL::Client::Schema::ObjectType.define_cached_field(name, self)
+            end
           end
         end
 
+        FIELDS_CACHE = Hash.new { |h, k| h[k] = k }
+
         def define_fields(fields)
-          fields.each { |name, type| define_field(name, type) }
+          const_set :FIELDS, FIELDS_CACHE[fields]
+          mod = MODULE_CACHE[fields.keys.sort]
+          include mod
+        end
+
+        def self.define_cached_field(name, ctx)
+          key = name
+          name = -name.to_s
+          method_name = ActiveSupport::Inflector.underscore(name)
+
+          ctx.send(:define_method, method_name, &METHOD_CACHE[key])
+          ctx.send(:define_method, "#{method_name}?", &PREDICATE_CACHE[name])
         end
 
         def define_field(name, type)
@@ -75,9 +123,67 @@ module GraphQL
             raise InvariantError, "expected value to be a Hash, but was #{value.class}"
           end
         end
+
+        private
+
+        # Given an AST selection on this object, gather it into `fields` if it applies.
+        # If it's a fragment, continue recursively checking the selections on the fragment.
+        def gather_selections(fields, definition, selected_ast_node)
+          case selected_ast_node
+          when GraphQL::Language::Nodes::InlineFragment
+            continue_selection = if selected_ast_node.type.nil?
+              true
+            else
+              schema = definition.client.schema
+              type_condition = schema.types[selected_ast_node.type.name]
+              applicable_types = schema.possible_types(type_condition)
+              # continue if this object type is one of the types matching the fragment condition
+              applicable_types.include?(type)
+            end
+
+            if continue_selection
+              selected_ast_node.selections.each do |next_selected_ast_node|
+                gather_selections(fields, definition, next_selected_ast_node)
+              end
+            end
+          when GraphQL::Language::Nodes::FragmentSpread
+            fragment_definition = definition.document.definitions.find do |defn|
+              defn.is_a?(GraphQL::Language::Nodes::FragmentDefinition) && defn.name == selected_ast_node.name
+            end
+
+            schema = definition.client.schema
+            type_condition = schema.types[fragment_definition.type.name]
+            applicable_types = schema.possible_types(type_condition)
+            # continue if this object type is one of the types matching the fragment condition
+            continue_selection = applicable_types.include?(type)
+
+            if continue_selection
+              fragment_definition.selections.each do |next_selected_ast_node|
+                gather_selections(fields, definition, next_selected_ast_node)
+              end
+            end
+          when GraphQL::Language::Nodes::Field
+            operation_definition_for_field = definition.indexes[:definitions][selected_ast_node]
+            # Ignore fields defined in other documents.
+            if definition.source_document.definitions.include?(operation_definition_for_field)
+              field_method_name = selected_ast_node.alias || selected_ast_node.name
+              ast_nodes = fields[field_method_name] ||= []
+              ast_nodes << selected_ast_node
+            end
+          else
+            raise "Unexpected selection node: #{selected_ast_node}"
+          end
+        end
       end
 
       class ObjectClass
+        module ClassMethods
+          attr_reader :source_definition
+          attr_reader :_spreads
+        end
+
+        extend ClassMethods
+
         def initialize(data = {}, errors = Errors.new)
           @data = data
           @casted_data = {}

data/lib/graphql/client/schema/possible_types.rb

@@ -41,7 +41,7 @@ module GraphQL
             if type = possible_types[typename]
               type.cast(value, errors)
             else
-              raise InvariantError, "expected value to be one of (#{possible_types.keys.join(", ")}), but was #{typename}"
+              raise InvariantError, "expected value to be one of (#{possible_types.keys.join(", ")}), but was #{typename.inspect}"
             end
           when NilClass
             nil

data/lib/graphql/client/schema/scalar_type.rb

@@ -19,7 +19,7 @@ module GraphQL
           @type = type
         end
 
-        def define_class(definition, irep_node)
+        def define_class(definition, ast_nodes)
           self
         end
 

data/lib/graphql/client/schema/union_type.rb

@@ -20,10 +20,12 @@ module GraphQL
           PossibleTypes.new(type, types)
         end
 
-        def define_class(definition, irep_node)
-          new(irep_node.typed_children.keys.map { |ctype|
-            schema_module.get_class(ctype.name).define_class(definition, irep_node)
-          })
+        def define_class(definition, ast_nodes)
+          possible_type_names = definition.client.schema.possible_types(type).map(&:graphql_name)
+          possible_types = possible_type_names.map { |concrete_type_name|
+            schema_module.get_class(concrete_type_name).define_class(definition, ast_nodes)
+          }
+          new(possible_types)
         end
       end
     end

data/lib/graphql/client/schema.rb

@@ -15,23 +15,25 @@ module GraphQL
   class Client
     module Schema
       module ClassMethods
-        def define_class(definition, irep_node, type)
-          type_klass = case type
+        def define_class(definition, ast_nodes, type)
+          type_class = case type
           when GraphQL::NonNullType
-            define_class(definition, irep_node, type.of_type).to_non_null_type
+            define_class(definition, ast_nodes, type.of_type).to_non_null_type
           when GraphQL::ListType
-            define_class(definition, irep_node, type.of_type).to_list_type
+            define_class(definition, ast_nodes, type.of_type).to_list_type
           else
-            get_class(type.name).define_class(definition, irep_node)
+            get_class(type.name).define_class(definition, ast_nodes)
           end
 
-          irep_node.ast_node.directives.inject(type_klass) do |klass, directive|
-            if directive = self.directives[directive.name.to_sym]
-              directive.new(klass)
-            else
-              klass
+          ast_nodes.each do |ast_node|
+            ast_node.directives.each do |directive|
+              if directive = self.directives[directive.name.to_sym]
+                type_class = directive.new(type_class)
+              end
             end
           end
+
+          type_class
         end
 
         def get_class(type_name)
@@ -50,6 +52,13 @@ module GraphQL
           const_set(class_name, klass)
         end
 
+        DIRECTIVES = { include: IncludeDirective,
+                       skip: SkipDirective }.freeze
+
+        def directives
+          DIRECTIVES
+        end
+
         private
 
         def normalize_type_name(type_name)
@@ -61,10 +70,6 @@ module GraphQL
         mod = Module.new
         mod.extend ClassMethods
 
-        mod.define_singleton_method :schema do
-          schema
-        end
-
         cache = {}
         schema.types.each do |name, type|
           next if name.start_with?("__")
@@ -74,11 +79,6 @@ module GraphQL
           end
         end
 
-        directives = {}
-        mod.define_singleton_method(:directives) { directives }
-        directives[:include] = IncludeDirective
-        directives[:skip] = SkipDirective
-
         mod
       end
 

data/lib/graphql/client.rb

@@ -12,8 +12,8 @@ require "graphql/client/operation_definition"
 require "graphql/client/query_typename"
 require "graphql/client/response"
 require "graphql/client/schema"
-require "graphql/language/nodes/deep_freeze_ext"
 require "json"
+require "delegate"
 
 module GraphQL
   # GraphQL Client helps build and execute queries against a GraphQL backend.
@@ -67,9 +67,9 @@ module GraphQL
       end
     end
 
-    IntrospectionDocument = GraphQL.parse(GraphQL::Introspection::INTROSPECTION_QUERY).deep_freeze
+    IntrospectionDocument = GraphQL.parse(GraphQL::Introspection::INTROSPECTION_QUERY)
 
-    def self.dump_schema(schema, io = nil)
+    def self.dump_schema(schema, io = nil, context: {})
       unless schema.respond_to?(:execute)
         raise TypeError, "expected schema to respond to #execute(), but was #{schema.class}"
       end
@@ -78,7 +78,7 @@ module GraphQL
         document: IntrospectionDocument,
         operation_name: "IntrospectionQuery",
         variables: {},
-        context: {}
+        context: context
       ).to_h
 
       if io
@@ -120,13 +120,21 @@ module GraphQL
 
       definition_dependencies = Set.new
 
+      # Replace Ruby constant reference with GraphQL fragment names,
+      # while populating `definition_dependencies` with
+      # GraphQL Fragment ASTs which this operation depends on
       str = str.gsub(/\.\.\.([a-zA-Z0-9_]+(::[a-zA-Z0-9_]+)*)/) do
         match = Regexp.last_match
         const_name = match[1]
 
         if str.match(/fragment\s*#{const_name}/)
+          # It's a fragment _definition_, not a fragment usage
           match[0]
         else
+          # It's a fragment spread, so we should load the fragment
+          # which corresponds to the spread.
+          # We depend on ActiveSupport to either find the already-loaded
+          # constant, or to load the constant by name
           begin
             fragment = ActiveSupport::Inflector.constantize(const_name)
           rescue NameError
@@ -135,6 +143,10 @@ module GraphQL
 
           case fragment
           when FragmentDefinition
+            # We found the fragment definition that this fragment spread belongs to.
+            # So, register the AST of this fragment in `definition_dependencies`
+            # and update the query string to valid GraphQL syntax,
+            # replacing the Ruby constant
             definition_dependencies.merge(fragment.document.definitions)
             "...#{fragment.definition_name}"
           else
@@ -157,10 +169,17 @@ module GraphQL
       doc = GraphQL.parse(str)
 
       document_types = DocumentTypes.analyze_types(self.schema, doc).freeze
-      QueryTypename.insert_typename_fields(doc, types: document_types)
+      doc = QueryTypename.insert_typename_fields(doc, types: document_types)
 
       doc.definitions.each do |node|
-        node.name ||= "__anonymous__"
+        if node.name.nil?
+          if node.respond_to?(:merge) # GraphQL 1.9 +
+            node_with_name = node.merge(name: "__anonymous__")
+            doc = doc.replace_child(node, node_with_name)
+          else
+            node.name = "__anonymous__"
+          end
+        end
       end
 
       document_dependencies = Language::Nodes::Document.new(definitions: doc.definitions + definition_dependencies.to_a)
@@ -183,39 +202,34 @@ module GraphQL
 
       definitions = {}
       doc.definitions.each do |node|
-        irep_node = case node
-        when GraphQL::Language::Nodes::OperationDefinition
-          errors[:irep].operation_definitions[node.name]
-        when GraphQL::Language::Nodes::FragmentDefinition
-          errors[:irep].fragment_definitions[node.name]
-        else
-          raise TypeError, "unexpected #{node.class}"
-        end
-
-        node.name = nil if node.name == "__anonymous__"
         sliced_document = Language::DefinitionSlice.slice(document_dependencies, node.name)
         definition = Definition.for(
           client: self,
-          irep_node: irep_node,
+          ast_node: node,
           document: sliced_document,
+          source_document: doc,
           source_location: source_location
         )
         definitions[node.name] = definition
       end
 
       name_hook = RenameNodeHook.new(definitions)
-      visitor = Language::Visitor.new(doc)
+      visitor = Language::Visitor.new(document_dependencies)
       visitor[Language::Nodes::FragmentDefinition].leave << name_hook.method(:rename_node)
       visitor[Language::Nodes::OperationDefinition].leave << name_hook.method(:rename_node)
       visitor[Language::Nodes::FragmentSpread].leave << name_hook.method(:rename_node)
       visitor.visit
 
-      doc.deep_freeze
-
-      document.definitions.concat(doc.definitions) if document_tracking_enabled
+      if document_tracking_enabled
+        if @document.respond_to?(:merge) # GraphQL 1.9+
+          @document = @document.merge(definitions: @document.definitions + doc.definitions)
+        else
+          @document.definitions.concat(doc.definitions)
+        end
+      end
 
-      if definitions[nil]
-        definitions[nil]
+      if definitions["__anonymous__"]
+        definitions["__anonymous__"]
       else
         Module.new do
           definitions.each do |name, definition|
@@ -234,7 +248,7 @@ module GraphQL
         definition = @definitions[node.name]
         if definition
           node.extend(LazyName)
-          node.name = -> { definition.definition_name }
+          node._definition = definition
         end
       end
     end
@@ -357,8 +371,10 @@ module GraphQL
     # name to point to a lazily defined Proc instead of a static string.
     module LazyName
       def name
-        @name.call
+        @_definition.definition_name
       end
+
+      attr_writer :_definition
     end
 
     private

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-client
 version: !ruby/object:Gem::Version
-  version: 0.12.3
+  version: 0.15.0
 platform: ruby
 authors:
 - GitHub
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-05 00:00:00.000000000 Z
+date: 2019-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -17,9 +17,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -27,23 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '6.0'
 - !ruby/object:Gem::Dependency
   name: graphql
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '1.8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '1.8'
 - !ruby/object:Gem::Dependency
   name: actionpack
   requirement: !ruby/object:Gem::Requirement
@@ -51,9 +45,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 3.2.22
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '6.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -61,9 +52,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 3.2.22
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '6.0'
 - !ruby/object:Gem::Dependency
   name: erubi
   requirement: !ruby/object:Gem::Requirement
@@ -126,28 +114,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: '0.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: '0.10'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.49'
+        version: '0.55'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.49'
+        version: '0.55'
 description: A Ruby library for declaring, composing and executing GraphQL queries
 email: engineering@github.com
 executables: []
@@ -161,6 +149,7 @@ files:
 - lib/graphql/client/definition.rb
 - lib/graphql/client/definition_variables.rb
 - lib/graphql/client/document_types.rb
+- lib/graphql/client/erb.rb
 - lib/graphql/client/error.rb
 - lib/graphql/client/errors.rb
 - lib/graphql/client/erubi_enhancer.rb
@@ -188,7 +177,6 @@ files:
 - lib/graphql/client/schema/skip_directive.rb
 - lib/graphql/client/schema/union_type.rb
 - lib/graphql/client/view_module.rb
-- lib/graphql/language/nodes/deep_freeze_ext.rb
 - lib/rubocop/cop/graphql/heredoc.rb
 - lib/rubocop/cop/graphql/overfetch.rb
 homepage: https://github.com/github/graphql-client
@@ -210,8 +198,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: GraphQL Client

data/lib/graphql/language/nodes/deep_freeze_ext.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-require "graphql"
-
-module GraphQL
-  module Language
-    module Nodes
-      # :nodoc:
-      class AbstractNode
-        # Public: Freeze entire Node tree
-        #
-        # Returns self Node.
-        def deep_freeze
-          children.each(&:deep_freeze)
-          scalars.each { |s| s && s.freeze }
-          freeze
-          self
-        end
-      end
-    end
-  end
-end