graphql-client 0.0.18 → 0.0.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ca22da5b31b85d955d2a209f48e5767c2b953848
-  data.tar.gz: 0150a203bb5fe856b6ea6c15bd941056f86002ff
+  metadata.gz: c087161bf28d989bf274ba68bf76223ff4cc7b84
+  data.tar.gz: 3054f8552e6e6a532ebd09a15e7f5914b8dfa994
 SHA512:
-  metadata.gz: c41fc037d158823686bf372addbc0b6592a87f2e9b470f0fb7302393cc89ad42f452bcb87bfdb142887437c42438e95d20bd236045088e11077cb48dba99ee38
-  data.tar.gz: 99f425fee8b8e70e876cc8d262befa594f2a2b182cad5b4b6b27a392139e1ecf84a5c6726f0719c96292afe17053ad16060be7ea73e8d414c931315cbddd0fab
+  metadata.gz: 4044f2bf520a94bcaf5f6a918baf4daa8eb72479f7fd9de12bacfe58f40a362f57d675207ef0a25d9508113ccc3a0985c2095fa4534385ab4d33b08db2592815
+  data.tar.gz: 8d19a14603c36df798b2280432d54e5dceb98d31a1d949c10bd2ac349b82dcf559359253e10b51a3d655f3e3cf22505f1b4ea97ff4a9acdf8e1992e91c462f9b

data/lib/graphql/client.rb

@@ -1,39 +1,17 @@
 require "active_support/inflector"
 require "active_support/notifications"
 require "graphql"
+require "graphql/client/error"
 require "graphql/client/query_result"
+require "graphql/client/query"
+require "graphql/client/response"
 require "graphql/language/nodes/deep_freeze_ext"
 require "graphql/language/operation_slice"
 
 module GraphQL
   class Client
-    class Error < StandardError; end
     class ValidationError < Error; end
 
-    class ResponseError < Error
-      def initialize(definition, error)
-        @request_definition = definition
-        @locations = error["locations"]
-        super error["message"]
-      end
-    end
-
-    class ResponseErrors < Error
-      include Enumerable
-
-      attr_reader :errors
-
-      def initialize(definition, errors)
-        @request_definition = definition
-        @errors = errors.map { |error| ResponseError.new(definition, error) }
-        super @errors.map(&:message).join(", ")
-      end
-
-      def each(&block)
-        errors.each(&block)
-      end
-    end
-
     attr_reader :schema, :fetch
 
     attr_accessor :document_tracking_enabled
@@ -50,8 +28,6 @@ module GraphQL
         else
           load_schema(JSON.parse(schema))
         end
-      else
-        nil
       end
     end
 
@@ -114,34 +90,49 @@ module GraphQL
       end
 
       private
-        def query_result_class
-          @query_result_class ||= GraphQL::Client::QueryResult.wrap(definition_node, name: name)
-        end
+
+      def query_result_class
+        @query_result_class ||= GraphQL::Client::QueryResult.wrap(definition_node, name: name)
+      end
     end
 
     class OperationDefinition < Definition
       # Public: Alias for definition name.
-      alias_method :operation_name, :definition_name
+      alias operation_name definition_name
     end
 
     class FragmentDefinition < Definition
     end
 
-    def parse(str)
+    def parse(str, filename = nil, lineno = nil)
+      if filename.nil? || lineno.nil?
+        filename, lineno, = caller(1, 1).first.split(":", 3)
+        lineno = lineno.to_i
+      end
+
       definition_dependencies = Set.new
 
-      str = str.gsub(/\.\.\.([a-zA-Z0-9_]+(::[a-zA-Z0-9_]+)+)/) { |m|
-        const_name = $1
+      str = str.gsub(/\.\.\.([a-zA-Z0-9_]+(::[a-zA-Z0-9_]+)+)/) do
+        match = Regexp.last_match
+        const_name = match[1]
         case fragment = ActiveSupport::Inflector.safe_constantize(const_name)
         when FragmentDefinition
           definition_dependencies.merge(fragment.document.definitions)
           "...#{fragment.definition_name}"
-        when nil
-          raise NameError, "uninitialized constant #{const_name}\n#{str}"
         else
-          raise TypeError, "expected #{const_name} to be a #{FragmentDefinition}, but was a #{fragment.class}"
+          if fragment
+            error = TypeError.new("expected #{const_name} to be a #{FragmentDefinition}, but was a #{fragment.class}")
+          else
+            error = NameError.new("uninitialized constant #{const_name}")
+          end
+
+          if filename && lineno
+            error.set_backtrace(["#{filename}:#{lineno + match.pre_match.count("\n") + 1}"] + caller)
+          end
+
+          raise error
         end
-      }
+      end
 
       doc = GraphQL.parse(str)
 
@@ -149,8 +140,7 @@ module GraphQL
         node.name ||= "__anonymous__"
       end
 
-      definition_dependencies.merge(doc.definitions)
-      document_dependencies = Language::Nodes::Document.new(definitions: definition_dependencies.to_a)
+      document_dependencies = Language::Nodes::Document.new(definitions: doc.definitions + definition_dependencies.to_a)
 
       if @schema
         rules = GraphQL::StaticValidation::ALL_RULES - [GraphQL::StaticValidation::FragmentsAreUsed]
@@ -159,7 +149,10 @@ module GraphQL
 
         errors = validator.validate(query)
         errors.fetch(:errors).each do |error|
-          raise ValidationError, error["message"] + "\n\n" + str
+          validation_line = error["locations"][0]["line"]
+          error = ValidationError.new(error["message"])
+          error.set_backtrace(["#{filename}:#{lineno + validation_line}"] + caller) if filename && lineno
+          raise error
         end
       end
 
@@ -171,12 +164,13 @@ module GraphQL
         definitions[node.name] = definition
       end
 
-      rename_node = -> (node, parent) {
-        if definition = definitions[node.name]
+      rename_node = ->(node, _parent) do
+        definition = definitions[node.name]
+        if definition
           node.extend(LazyName)
           node.name = -> { definition.definition_name }
         end
-      }
+      end
       visitor = Language::Visitor.new(doc)
       visitor[Language::Nodes::FragmentDefinition].leave << rename_node
       visitor[Language::Nodes::OperationDefinition].leave << rename_node
@@ -185,9 +179,7 @@ module GraphQL
 
       doc.deep_freeze
 
-      if document_tracking_enabled
-        self.document.definitions.concat(doc.definitions)
-      end
+      document.definitions.concat(doc.definitions) if document_tracking_enabled
 
       if definitions[nil]
         definitions[nil]
@@ -200,87 +192,15 @@ module GraphQL
       end
     end
 
-    def document
-      @document
-    end
-
-    class Response
-      attr_reader :extensions
-
-      def initialize(extensions: nil)
-        @extensions = extensions || {}
-      end
-    end
-
-    class SuccessfulResponse < Response
-      attr_reader :data
-
-      def initialize(data:, **kargs)
-        @data = data
-        super(**kargs)
-      end
-    end
-
-    class PartialResponse < SuccessfulResponse
-      attr_reader :errors
-
-      def initialize(errors:, **kargs)
-        @errors = errors
-        super(**kargs)
-      end
-    end
-
-    class FailedResponse < Response
-      attr_reader :errors
-
-      def initialize(errors:, **kargs)
-        @errors = errors
-        super(**kargs)
-      end
-    end
-
-    class Query
-      attr_reader :document, :operation_name, :variables, :context
-
-      def initialize(document, operation_name: nil, variables: {}, context: {})
-        @document = document
-        @operation_name = operation_name
-        @variables = variables
-        @context = context
-      end
-
-      def to_s
-        document.to_query_string
-      end
-
-      def operation
-        document.definitions.find { |node| node.name == operation_name }
-      end
-
-      def operation_type
-        operation.operation_type
-      end
-
-      def payload
-        {
-          document: document,
-          operation_name: operation_name,
-          operation_type: operation_type,
-          variables: variables
-        }
-      end
-    end
+    attr_reader :document
 
     def query(definition, variables: {}, context: {})
-      unless fetch
-        raise Error, "client network fetching not configured"
-      end
+      raise Error, "client network fetching not configured" unless fetch
 
       query = Query.new(definition.document,
-        operation_name: definition.operation_name,
-        variables: variables,
-        context: context
-      )
+                        operation_name: definition.operation_name,
+                        variables: variables,
+                        context: context)
 
       result = ActiveSupport::Notifications.instrument("query.graphql", query.payload) do
         fetch.call(query)
@@ -316,11 +236,10 @@ module GraphQL
       fetch.call(IntrospectionQuery)
     end
 
-    private
-      module LazyName
-        def name
-          @name.call
-        end
+    module LazyName
+      def name
+        @name.call
       end
+    end
   end
 end

data/lib/graphql/client/error.rb

@@ -0,0 +1,5 @@
+module GraphQL
+  class Client
+    class Error < StandardError; end
+  end
+end

data/lib/graphql/client/erubis.rb

@@ -2,12 +2,36 @@ require "action_view"
 
 module GraphQL
   class Client
+    # 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::Erubis
+    #
     class Erubis < ActionView::Template::Handlers::Erubis
-      def self.extract_graphql_sections(src)
-        src.scan(/<%graphql([^%]+)%>/).flatten.first
+      # Public: Extract GraphQL section from ERB template.
+      #
+      # src - String ERB text
+      #
+      # Returns String GraphQL query and line number or nil or no section was
+      # defined.
+      def self.extract_graphql_section(src)
+        query_string = src.scan(/<%graphql([^%]+)%>/).flatten.first
+        if query_string
+          return query_string, Regexp.last_match.pre_match.count("\n") + 1
+        end
       end
 
-      # Ignore static <%graphql sections
+      # Internal: Extend Rails' Erubis handler to simply ignore <%graphql
+      # sections.
       def convert_input(src, input)
         input = input.gsub(/<%graphql/, "<%#")
         super(src, input)

data/lib/graphql/client/http.rb

@@ -4,19 +4,55 @@ require "uri"
 
 module GraphQL
   class Client
+    # Public: Basic HTTP network adapter.
+    #
+    #   GraphQL::Client::Client.new(
+    #     fetch: GraphQL::Client::HTTP.new("http://graphql-swapi.parseapp.com/")
+    #   )
+    #
+    # Assumes GraphQL endpoint follows the express-graphql endpoint conventions.
+    #   https://github.com/graphql/express-graphql#http-usage
+    #
+    # Production applications should consider implementing there own network
+    # adapter. This class exists for trivial stock usage and allows for minimal
+    # request header configuration.
     class HTTP
-      attr_reader :uri
-
-      # GraphQL::Client::HTTP.new("http://graphql-swapi.parseapp.com/")
+      # Public: Create HTTP adapter instance for a single GraphQL endpoint.
+      #
+      #   GraphQL::Client::HTTP.new("http://graphql-swapi.parseapp.com/") do
+      #     def headers(query)
+      #       { "User-Agent": "My Client" }
+      #     end
+      #   end
+      #
+      # uri - String endpoint URI
+      # block - Optional block to configure class
       def initialize(uri, &block)
-        @uri = ::URI.parse(uri)
+        @uri = URI.parse(uri)
         class_eval(&block) if block_given?
       end
 
-      def headers(query)
+      # Public: Parsed endpoint URI
+      #
+      # Returns URI.
+      attr_reader :uri
+
+      # Public: Extension point for subclasses to set custom request headers.
+      #
+      # query - The GraphQL::Client::Query being sent
+      #
+      # Returns Hash of String header names and values.
+      def headers(_)
         {}
       end
 
+      # Public: Make an HTTP request for GraphQL query.
+      #
+      # Implements Client's "fetch" adapter interface.
+      #
+      # query - The GraphQL::Client::Query being sent
+      #
+      # Returns { "data" => ... , "errors" => ... } Hash.
       def call(query)
         http = Net::HTTP.new(uri.host, uri.port)
         http.use_ssl = uri.scheme == "https"

data/lib/graphql/client/log_subscriber.rb

@@ -2,13 +2,33 @@ require "active_support/log_subscriber"
 
 module GraphQL
   class Client
+    # Public: Logger for "*.graphql" notification events.
+    #
+    # Logs GraphQL queries to Rails logger.
+    #
+    #   QUERY (123ms) UsersController::ShowQuery
+    #   MUTATION (456ms) UsersController::UpdateMutation
+    #
+    # Enable GraphQL Client query logging.
+    #
+    #   require "graphql/client/log_subscriber"
+    #   GraphQL::Client::LogSubscriber.attach_to :graphql
+    #
     class LogSubscriber < ActiveSupport::LogSubscriber
       def query(event)
-        info { "#{event.payload[:name]} (#{event.duration.round(1)}ms) #{event.payload[:operation_name].gsub("__", "::")}" }
-        debug { event.payload[:document].to_query_string }
+        # TODO: Colorize output
+        info do
+          [
+            event.payload[:operation_type].upcase,
+            "(#{event.duration.round(1)}ms)",
+            event.payload[:operation_name].gsub("__", "::")
+          ].join(" ")
+        end
+
+        debug do
+          event.payload[:document].to_query_string
+        end
       end
     end
   end
 end
-
-GraphQL::Client::LogSubscriber.attach_to :graphql

data/lib/graphql/client/query.rb

@@ -0,0 +1,65 @@
+module GraphQL
+  class Client
+    class Query
+      # Internal: Construct Query.
+      #
+      # Avoid creating queries with this constructor, perfer using Client#query.
+      #
+      # document - A parsed GraphQL::Language::Nodes::Document of the query
+      # operation_name - String operation to execute
+      # variables - Hash of variables to execute with the operation
+      # context - Hash of metadata to pass to network adapter
+      def initialize(document, operation_name: nil, variables: {}, context: {})
+        @document = document
+        @operation_name = operation_name
+        @variables = variables
+        @context = context
+      end
+
+      # Public: A parsed GraphQL::Language::Nodes::Document of the query.
+      attr_reader :document
+
+      # Public: String name of operation to execute.
+      attr_reader :operation_name
+
+      # Public: Hash of variables to execute with the operation.
+      attr_reader :variables
+
+      # Public: Hash of contextual metadata.
+      attr_reader :context
+
+      # Public: Serialized query string
+      #
+      # Returns String.
+      def to_s
+        document.to_query_string
+      end
+
+      # Public: Get operation definition node.
+      #
+      # Returns GraphQL::Language::Nodes::OperationDefinition.
+      def operation
+        document.definitions.find { |node| node.name == operation_name }
+      end
+
+      # Public: Query operation type
+      #
+      # Returns "query", "mutation" or "subscription".
+      def operation_type
+        operation.operation_type
+      end
+
+      # Internal: Payload object to pass to ActiveSupport::Notifications.
+      #
+      # Returns Hash.
+      def payload
+        {
+          document: document,
+          operation_name: operation_name,
+          operation_type: operation_type,
+          variables: variables
+        }
+      end
+    end
+  end
+end

data/lib/graphql/client/query_result.rb

@@ -42,9 +42,7 @@ module GraphQL
 
             # Convert GraphQL camelcase to snake case: commitComments -> commit_comments
             field_alias = ActiveSupport::Inflector.underscore(field)
-            if field != field_alias
-              send :alias_method, field_alias, field
-            end
+            send :alias_method, field_alias, field if field != field_alias
 
             class_eval <<-RUBY, __FILE__, __LINE__
               def #{field_alias}?
@@ -52,15 +50,14 @@ module GraphQL
               end
             RUBY
 
-            if field == "edges"
-              class_eval <<-RUBY, __FILE__, __LINE__
+            next unless field == "edges"
+            class_eval <<-RUBY, __FILE__, __LINE__
                 def each_node
                   return enum_for(:each_node) unless block_given?
                   edges.each { |edge| yield edge.node }
                   self
                 end
-              RUBY
-            end
+            RUBY
           end
 
           assigns = fields.map do |field, type|
@@ -85,12 +82,12 @@ module GraphQL
         end
       end
 
-      def self.source_node
-        @source_node
+      class << self
+        attr_reader :source_node
       end
 
-      def self.fields
-        @fields
+      class << self
+        attr_reader :fields
       end
 
       def self.name
@@ -98,7 +95,7 @@ module GraphQL
       end
 
       def self.inspect
-        "#<#{self.name} fields=#{@fields.keys.inspect}>"
+        "#<#{name} fields=#{@fields.keys.inspect}>"
       end
 
       def self.cast(obj)
@@ -110,9 +107,9 @@ module GraphQL
         when QueryResult
           spreads = Set.new(self.spreads(obj.class.source_node).map(&:name))
 
-          if !spreads.include?(self.source_node.name)
-            message = "couldn't cast #{obj.inspect} to #{self.inspect}\n\n"
-            suggestion = "\n  ...#{name || "YourFragment"} # SUGGESTION"
+          unless spreads.include?(source_node.name)
+            message = "couldn't cast #{obj.inspect} to #{inspect}\n\n"
+            suggestion = "\n  ...#{name || 'YourFragment'} # SUGGESTION"
             message << GraphQL::Language::Generation.generate(obj.class.source_node).sub(/\n}$/, "#{suggestion}\n}")
             raise TypeError, message
           end
@@ -122,7 +119,7 @@ module GraphQL
         when NilClass
           nil
         else
-          raise TypeError, "#{obj.class}"
+          raise TypeError, obj.class.to_s
         end
       end
 
@@ -150,7 +147,7 @@ module GraphQL
       end
 
       def self.|(other)
-        new_fields = self.fields.dup
+        new_fields = fields.dup
         other.fields.each do |name, value|
           if new_fields[name]
             new_fields[name] |= value
@@ -159,14 +156,14 @@ module GraphQL
           end
         end
         # TODO: Picking first source node seems error prone
-        define(name: self.name, source_node: self.source_node, fields: new_fields)
+        define(name: self.name, source_node: source_node, fields: new_fields)
       end
 
       attr_reader :data
-      alias_method :to_h, :data
+      alias to_h data
 
       def inspect
-        ivars = (self.class.fields.keys).map { |sym| "#{sym}=#{instance_variable_get("@#{sym}").inspect}" }
+        ivars = self.class.fields.keys.map { |sym| "#{sym}=#{instance_variable_get("@#{sym}").inspect}" }
         buf = "#<#{self.class.name}"
         buf << " " << ivars.join(" ") if ivars.any?
         buf << ">"
@@ -178,6 +175,10 @@ module GraphQL
       rescue NoMethodError => e
         raise NoMethodError, "undefined method `#{e.name}' for #{inspect}"
       end
+
+      def respond_to_missing?(*args)
+        super
+      end
     end
   end
 end

data/lib/graphql/client/railtie.rb

@@ -1,6 +1,5 @@
 require "graphql"
 require "graphql/client"
-require "graphql/client/log_subscriber"
 require "rails/railtie"
 
 module GraphQL
@@ -11,12 +10,17 @@ module GraphQL
 
       # Eager load leaky dependency to workaround AS::Dependencies unloading issues
       #   https://github.com/rmosolgo/graphql-ruby/pull/240
-      initializer "graphql.eager_load_hack" do |app|
+      initializer "graphql.eager_load_hack" do |_app|
         require "graphql"
         GraphQL::BOOLEAN_TYPE.name
       end
 
-      initializer "graphql.configure_erb_implementation" do |app|
+      initializer "graphql.configure_log_subscriber" do |_app|
+        require "graphql/client/log_subscriber"
+        GraphQL::Client::LogSubscriber.attach_to :graphql
+      end
+
+      initializer "graphql.configure_erb_implementation" do |_app|
         require "graphql/client/erubis"
         ActionView::Template::Handlers::ERB.erb_implementation = GraphQL::Client::Erubis
       end
@@ -27,11 +31,13 @@ module GraphQL
         path = app.paths["app/views"].first
         client = config.graphql.client
 
-        Object.const_set(:Views, Module.new {
+        config.watchable_dirs[path] = [:erb]
+
+        Object.const_set(:Views, Module.new do
           extend GraphQL::Client::ViewModule
           self.path = path
           self.client = client
-        })
+        end)
       end
     end
   end

data/lib/graphql/client/response.rb

@@ -0,0 +1,87 @@
+require "graphql/client/error"
+
+module GraphQL
+  class Client
+    # Public: Abstract base class for GraphQL responses.
+    #
+    #   https://facebook.github.io/graphql/#sec-Response-Format
+    class Response
+      # Public: Hash of server specific extension metadata.
+      attr_reader :extensions
+
+      # Internal: Initialize base class.
+      def initialize(extensions: nil)
+        @extensions = extensions || {}
+      end
+    end
+
+    class SuccessfulResponse < Response
+      # Public: Wrapped QueryResult of data returned from the server.
+      #
+      #   https://facebook.github.io/graphql/#sec-Data
+      #
+      # Returns instance of QueryResult subclass.
+      attr_reader :data
+
+      # Internal: Initialize SuccessfulResponse.
+      def initialize(data:, **kargs)
+        @data = data
+        super(**kargs)
+      end
+    end
+
+    class PartialResponse < SuccessfulResponse
+      # Public: Get partial failures from response.
+      #
+      #   https://facebook.github.io/graphql/#sec-Errors
+      #
+      # Returns ResponseErrors collection object.
+      attr_reader :errors
+
+      # Internal: Initialize PartialResponse.
+      def initialize(errors:, **kargs)
+        @errors = errors
+        super(**kargs)
+      end
+    end
+
+    class FailedResponse < Response
+      # Public: Get errors from response.
+      #
+      #   https://facebook.github.io/graphql/#sec-Errors
+      #
+      # Returns ResponseErrors collection object.
+      attr_reader :errors
+
+      # Internal: Initialize FailedResponse.
+      def initialize(errors:, **kargs)
+        @errors = errors
+        super(**kargs)
+      end
+    end
+
+    class ResponseError < Error
+      def initialize(definition, error)
+        @request_definition = definition
+        @locations = error["locations"]
+        super error["message"]
+      end
+    end
+
+    class ResponseErrors < Error
+      include Enumerable
+
+      attr_reader :errors
+
+      def initialize(definition, errors)
+        @request_definition = definition
+        @errors = errors.map { |error| ResponseError.new(definition, error) }
+        super @errors.map(&:message).join(", ")
+      end
+
+      def each(&block)
+        errors.each(&block)
+      end
+    end
+  end
+end

data/lib/graphql/client/view_module.rb

@@ -20,17 +20,14 @@ module GraphQL
       #
       # Returns nothing.
       def eager_load!
-        return unless File.directory?(self.path)
+        return unless File.directory?(path)
 
-        Dir.entries(self.path).each do |entry|
+        Dir.entries(path).each do |entry|
           next if entry == "." || entry == ".."
           name = entry.sub(/(\.\w+)+$/, "").camelize.to_sym
           if ViewModule.valid_constant_name?(name) && loadable_const_defined?(name)
             mod = const_get(name, false)
             mod.eager_load!
-          else
-            # Ignore template names that don't camelize to safe constants:
-            #   404, foo-dash
           end
         end
 
@@ -97,7 +94,7 @@ module GraphQL
       # Returns String absolute path to file, otherwise nil.
       def const_path(name)
         pathname = ActiveSupport::Inflector.underscore(name.to_s)
-        Dir[File.join(self.path, "{#{pathname},_#{pathname}}{/,.*}")].map { |fn| File.expand_path(fn) }.first
+        Dir[File.join(path, "{#{pathname},_#{pathname}}{/,.*}")].map { |fn| File.expand_path(fn) }.first
       end
 
       # Internal: Initialize new module for constant name and load ERB statics.
@@ -115,13 +112,12 @@ module GraphQL
 
         if File.extname(path) == ".erb"
           contents = File.read(path)
-          query = GraphQL::Client::Erubis.extract_graphql_sections(contents)
-          # TODO: Use generic client parser
-          mod = client.parse(query) if query
+          query, lineno = GraphQL::Client::Erubis.extract_graphql_section(contents)
+          mod = client.parse(query, path, lineno) if query
         end
 
         mod.extend(ViewModule)
-        mod.client = self.client
+        mod.client = client
         mod.path = path
         mod
       end
@@ -132,7 +128,9 @@ module GraphQL
       #
       # Returns module or raises NameError if missing.
       def const_missing(name)
-        if path = const_path(name)
+        path = const_path(name)
+
+        if path
           mod = load_module(path)
           const_set(name, mod)
           mod.unloadable

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

@@ -9,9 +9,7 @@ module GraphQL
         # Returns self Node.
         def deep_freeze
           self.class.child_attributes.each do |attr_name|
-            public_send(attr_name).freeze.each do |node|
-              node.deep_freeze
-            end
+            public_send(attr_name).freeze.each(&:deep_freeze)
           end
           freeze
         end

data/lib/graphql/language/operation_slice.rb

@@ -16,7 +16,7 @@ module GraphQL
         seen = Set.new([operation_name])
         stack = [operation_name]
 
-        while stack.length > 0
+        until stack.empty?
           name = stack.pop
           names = find_definition_fragment_spreads(document, name)
           seen.merge(names)
@@ -28,12 +28,12 @@ module GraphQL
 
       def self.find_definition_fragment_spreads(document, definition_name)
         definition = document.definitions.find { |node| node.name == definition_name }
-        raise "missing definition: #{definition_name}" if !definition
+        raise "missing definition: #{definition_name}" unless definition
         spreads = Set.new
         visitor = Visitor.new(definition)
-        visitor[Nodes::FragmentSpread].enter << -> (node, parent) {
+        visitor[Nodes::FragmentSpread].enter << -> (node, _parent) do
           spreads << node.name
-        }
+        end
         visitor.visit
         spreads
       end

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: graphql-client
 version: !ruby/object:Gem::Version
-  version: 0.0.18
+  version: 0.0.19
 platform: ruby
 authors:
 - GitHub
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-10 00:00:00.000000000 Z
+date: 2016-09-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: actionpack
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -31,7 +31,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '6.0'
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: graphql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+- !ruby/object:Gem::Dependency
+  name: actionpack
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -40,7 +54,7 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '6.0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -51,47 +65,47 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '6.0'
 - !ruby/object:Gem::Dependency
-  name: graphql
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.18'
-  type: :runtime
+        version: '5.9'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.18'
+        version: '5.9'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.9'
+        version: '11.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.9'
+        version: '11.2'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '11.2'
+        version: '0.42'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '11.2'
+        version: '0.42'
 description: "???"
 email: engineering@github.com
 executables: []
@@ -100,11 +114,14 @@ extra_rdoc_files: []
 files:
 - LICENSE
 - lib/graphql/client.rb
+- lib/graphql/client/error.rb
 - lib/graphql/client/erubis.rb
 - lib/graphql/client/http.rb
 - lib/graphql/client/log_subscriber.rb
+- lib/graphql/client/query.rb
 - lib/graphql/client/query_result.rb
 - lib/graphql/client/railtie.rb
+- lib/graphql/client/response.rb
 - lib/graphql/client/view_module.rb
 - lib/graphql/language/nodes/deep_freeze_ext.rb
 - lib/graphql/language/operation_slice.rb