graphql 1.5.4 → 1.5.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eacb69bcf39a028dc32debd2a0f266a6f920fd3d
-  data.tar.gz: 921436c519b6b6b8aff3e4dc03845f8d6108a275
+  metadata.gz: ef472807dc31f5d5bc215491e5c4a512d853b517
+  data.tar.gz: 151d4556ac7c07a270e37e40a71616dfad89129b
 SHA512:
-  metadata.gz: b8e1d965b82383e8cee0423fa06b7f20ea5fde13bedb8e9cd2316686c7f7e72dd409a55667b81ea9f0e502906bee45e7957cbdd79c44e96618a405bebf81fc98
-  data.tar.gz: 56c92576bee82ce626d332df1070079579c02007ad78718831301de4c815a6d61c57a17464e71498d9e6a4c51412e80de50e2090aca40fed8266b282b6c12a58
+  metadata.gz: 825fdd6d9aac63cf8904e1a52be462499286063ccab8799497affabf52d1a0b8b2afe090e5fef84a564c087803ca4b4b38d4dc7fa898e145047e749aa1d0e12c
+  data.tar.gz: 43c0d734ac9014bd7df9f9e26e70052e62f2ae0d7a84b59642622e2786ffd806fbc076638411ce4621b2dd355c7479ac05c7e9fed8993701126611c8ebe428d6

data/lib/graphql/define/instance_definable.rb

@@ -116,18 +116,7 @@ module GraphQL
       def define(**kwargs, &block)
         # make sure the previous definition_proc was executed:
         ensure_defined
-
-        method_names = self.class.ensure_defined_method_names
-        @pending_methods = method_names.map { |n| self.class.instance_method(n) }
-        self.singleton_class.class_eval do
-          method_names.each do |method_name|
-            define_method(method_name) { |*args, &block|
-              ensure_defined
-              self.send(method_name, *args, &block)
-            }
-          end
-        end
-
+        stash_dependent_methods
         @pending_definition = Definition.new(kwargs, block)
         nil
       end
@@ -156,31 +145,67 @@ module GraphQL
       # @return [void]
       def ensure_defined
         if @pending_definition
-
           defn = @pending_definition
           @pending_definition = nil
 
-          pending_methods = @pending_methods
-          self.singleton_class.class_eval {
-            pending_methods.each do |method|
-              define_method(method.name, method)
-            end
-          }
-          @pending_methods = nil
+          revive_dependent_methods
 
-          defn_proxy = DefinedObjectProxy.new(self)
-          # Apply definition from `define(...)` kwargs
-          defn.define_keywords.each do |keyword, value|
-            defn_proxy.public_send(keyword, value)
-          end
-          # and/or apply definition from `define { ... }` block
-          if defn.define_proc
-            defn_proxy.instance_eval(&defn.define_proc)
+          begin
+            defn_proxy = DefinedObjectProxy.new(self)
+            # Apply definition from `define(...)` kwargs
+            defn.define_keywords.each do |keyword, value|
+              defn_proxy.public_send(keyword, value)
+            end
+            # and/or apply definition from `define { ... }` block
+            if defn.define_proc
+              defn_proxy.instance_eval(&defn.define_proc)
+            end
+          rescue StandardError
+            # The definition block failed to run, so make this object pending again:
+            stash_dependent_methods
+            @pending_definition = defn
+            raise
           end
+        end
+        nil
+      end
 
+      # Take the pending methods and put them back on this object's singleton class.
+      # This reverts the process done by {#stash_dependent_methods}
+      # @return [void]
+      def revive_dependent_methods
+        pending_methods = @pending_methods
+        self.singleton_class.class_eval {
+          pending_methods.each do |method|
+            define_method(method.name, method)
+          end
+        }
+        @pending_methods = nil
+      end
 
+      # Find the method names which were declared as definition-dependent,
+      # then grab the method definitions off of this object's class
+      # and store them for later.
+      #
+      # Then make a dummy method for each of those method names which:
+      #
+      # - Triggers the pending definition, if there is one
+      # - Calls the same method again.
+      #
+      # It's assumed that {#ensure_defined} will put the original method definitions
+      # back in place with {#revive_dependent_methods}.
+      # @return [void]
+      def stash_dependent_methods
+        method_names = self.class.ensure_defined_method_names
+        @pending_methods = method_names.map { |n| self.class.instance_method(n) }
+        self.singleton_class.class_eval do
+          method_names.each do |method_name|
+            define_method(method_name) { |*args, &block|
+              ensure_defined
+              self.send(method_name, *args, &block)
+            }
+          end
         end
-        nil
       end
 
       class Definition

data/lib/graphql/enum_type.rb

@@ -85,7 +85,6 @@ module GraphQL
       self.values = other.values.values
     end
 
-
     # @param new_values [Array<EnumValue>] The set of values contained in this type
     def values=(new_values)
       @values_by_name = {}

data/lib/graphql/execution/execute.rb

@@ -72,22 +72,22 @@ module GraphQL
 
         result = if query.schema.lazy?(raw_value)
           field.prepare_lazy(raw_value, arguments, field_ctx).then { |inner_value|
-            continue_resolve_field(selection, parent_type, field, inner_value, field_ctx)
+            continue_resolve_field(owner, selection, parent_type, field, inner_value, field_ctx)
           }
         elsif raw_value.is_a?(GraphQL::Execution::Lazy)
           # It came from a connection resolve, assume it was already instrumented
           raw_value.then { |inner_value|
-            continue_resolve_field(selection, parent_type, field, inner_value, field_ctx)
+            continue_resolve_field(owner, selection, parent_type, field, inner_value, field_ctx)
           }
         else
-          continue_resolve_field(selection, parent_type, field, raw_value, field_ctx)
+          continue_resolve_field(owner, selection, parent_type, field, raw_value, field_ctx)
         end
 
         case result
         when PROPAGATE_NULL, GraphQL::Execution::Lazy, SelectionResult
           FieldResult.new(
             owner: owner,
-            field: field,
+            type: field.type,
             value: result,
           )
         else
@@ -95,7 +95,7 @@ module GraphQL
         end
       end
 
-      def continue_resolve_field(selection, parent_type, field, raw_value, field_ctx)
+      def continue_resolve_field(owner, selection, parent_type, field, raw_value, field_ctx)
         query = field_ctx.query
 
         case raw_value
@@ -115,6 +115,7 @@ module GraphQL
         end
 
         resolve_value(
+          owner,
           parent_type,
           field,
           field.type,
@@ -124,7 +125,7 @@ module GraphQL
         )
       end
 
-      def resolve_value(parent_type, field_defn, field_type, value, selection, field_ctx)
+      def resolve_value(owner, parent_type, field_defn, field_type, value, selection, field_ctx)
         if value.nil?
           if field_type.kind.non_null?
             type_error = GraphQL::InvalidNullError.new(parent_type, field_defn, value)
@@ -146,7 +147,7 @@ module GraphQL
           when GraphQL::TypeKinds::ENUM
             field_type.coerce_result(value, field_ctx.query.warden)
           when GraphQL::TypeKinds::LIST
-            wrapped_type = field_type.of_type
+            inner_type = field_type.of_type
             i = 0
             result = []
             value.each do |inner_value|
@@ -157,20 +158,24 @@ module GraphQL
                 field: field_defn,
               )
 
-              result << resolve_value(
+              inner_result = resolve_value(
+                owner,
                 parent_type,
                 field_defn,
-                wrapped_type,
+                inner_type,
                 inner_value,
                 selection,
                 inner_ctx,
               )
+
+              result << GraphQL::Execution::FieldResult.new(type: inner_type, owner: owner, value: inner_result)
               i += 1
             end
             result
           when GraphQL::TypeKinds::NON_NULL
             wrapped_type = field_type.of_type
             inner_value = resolve_value(
+              owner,
               parent_type,
               field_defn,
               wrapped_type,
@@ -196,6 +201,7 @@ module GraphQL
               PROPAGATE_NULL
             else
               resolve_value(
+                owner,
                 parent_type,
                 field_defn,
                 resolved_type,

data/lib/graphql/execution/field_result.rb

@@ -7,14 +7,11 @@ module GraphQL
       # @return [Any, Lazy] the GraphQL-ready response value, or a {Lazy} instance
       attr_reader :value
 
-      # @return [GraphQL::Field] The field which resolved this value
-      attr_reader :field
-
       # @return [SelectionResult] The result object that this field belongs to
       attr_reader :owner
 
-      def initialize(field:, value:, owner:)
-        @field = field
+      def initialize(type:, value:, owner:)
+        @type = type
         @owner = owner
         self.value = value
       end
@@ -35,7 +32,7 @@ module GraphQL
         end
 
         if new_value == GraphQL::Execution::Execute::PROPAGATE_NULL
-          if field.type.kind.non_null?
+          if @type.kind.non_null?
             @owner.propagate_null
           else
             @value = nil

data/lib/graphql/execution/lazy/lazy_method_map.rb

@@ -1,22 +1,27 @@
 # frozen_string_literal: true
+require 'thread'
+begin
+  require 'concurrent'
+rescue LoadError
+  # no problem, we'll fallback to our own map
+end
+
 module GraphQL
   module Execution
     class Lazy
       # {GraphQL::Schema} uses this to match returned values to lazy resolution methods.
       # Methods may be registered for classes, they apply to its subclasses also.
       # The result of this lookup is cached for future resolutions.
+      # Instances of this class are thread-safe.
       # @api private
       # @see {Schema#lazy?} looks up values from this map
       class LazyMethodMap
-        def initialize
-          @storage = Hash.new do |h, value_class|
-            registered_superclass = h.each_key.find { |lazy_class| value_class < lazy_class }
-            if registered_superclass.nil?
-              h[value_class] = nil
-            else
-              h[value_class] = h[registered_superclass]
-            end
-          end
+        def initialize(use_concurrent: defined?(Concurrent::Map))
+          @storage = use_concurrent ? Concurrent::Map.new : ConcurrentishMap.new
+        end
+
+        def initialize_copy(other)
+          @storage = other.storage.dup
         end
 
         # @param lazy_class [Class] A class which represents a lazy value (subclasses may also be used)
@@ -28,11 +33,60 @@ module GraphQL
         # @param value [Object] an object which may have a `lazy_value_method` registered for its class or superclasses
         # @return [Symbol, nil] The `lazy_value_method` for this object, or nil
         def get(value)
-          @storage[value.class]
+          @storage.compute_if_absent(value.class) { find_superclass_method(value.class) }
         end
 
-        def each
-          @storage.each { |k, v| yield(k,v) }
+        protected
+
+        attr_reader :storage
+
+        private
+
+        def find_superclass_method(value_class)
+          @storage.each { |lazy_class, lazy_value_method|
+            return lazy_value_method if value_class < lazy_class
+          }
+          nil
+        end
+
+        # Mock the Concurrent::Map API
+        class ConcurrentishMap
+          extend Forwardable
+          # Technically this should be under the mutex too,
+          # but I know it's only used when the lock is already acquired.
+          def_delegators :@storage, :each, :size
+
+          def initialize
+            @semaphore = Mutex.new
+            # Access to this hash must always be managed by the mutex
+            # since it may be modified at runtime
+            @storage = {}
+          end
+
+          def []=(key, value)
+            @semaphore.synchronize {
+              @storage[key] = value
+            }
+          end
+
+          def compute_if_absent(key)
+            @semaphore.synchronize {
+              @storage.fetch(key) { @storage[key] = yield }
+            }
+          end
+
+          def initialize_copy(other)
+            @semaphore = Mutex.new
+            @storage = other.copy_storage
+          end
+
+          protected
+
+          def copy_storage
+            @semaphore.synchronize {
+              @storage.dup
+            }
+          end
         end
       end
     end

data/lib/graphql/language.rb

@@ -12,7 +12,21 @@ module GraphQL
   module Language
     # @api private
     def self.serialize(value)
-      JSON.generate(value, quirks_mode: true)
+      if value.is_a?(Hash)
+        serialized_hash = value.map do |k, v|
+          "#{k}:#{serialize v}"
+        end.join(",")
+
+        "{#{serialized_hash}}"
+      elsif value.is_a?(Array)
+        serialized_array = value.map do |v|
+          serialize v
+        end.join(",")
+
+        "[#{serialized_array}]"
+      else
+        JSON.generate(value, quirks_mode: true)
+      end
     end
   end
 end

data/lib/graphql/language/nodes.rb

@@ -268,10 +268,26 @@ module GraphQL
         def to_h(options={})
           arguments.inject({}) do |memo, pair|
             v = pair.value
-            memo[pair.name] = v.is_a?(InputObject) ? v.to_h : v
+            memo[pair.name] = serialize_value_for_hash v
             memo
           end
         end
+
+        private
+
+        def serialize_value_for_hash(value)
+          if value.is_a? InputObject
+            value.to_h
+          elsif value.is_a? Array
+            value.map do |v|
+              serialize_value_for_hash v
+            end
+          elsif value.is_a? NullValue
+            nil
+          else
+            value
+          end
+        end
       end
 
 

data/lib/graphql/language/parser.rb

@@ -1383,7 +1383,7 @@ module_eval(<<'.,.,', 'parser.y', 258)
 
 module_eval(<<'.,.,', 'parser.y', 267)
   def _reduce_106(val, _values, result)
-     return make_node(:SchemaDefinition, val[2]) 
+     return make_node(:SchemaDefinition, position_source: val[0], **val[2]) 
     result
   end
 .,.,
@@ -1418,14 +1418,14 @@ module_eval(<<'.,.,', 'parser.y', 274)
 
 module_eval(<<'.,.,', 'parser.y', 284)
   def _reduce_116(val, _values, result)
-     return make_node(:ScalarTypeDefinition, name: val[1], directives: val[2], description: get_description(val[0])) 
+     return make_node(:ScalarTypeDefinition, name: val[1], directives: val[2], description: get_description(val[0]), position_source: val[0]) 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'parser.y', 288)
   def _reduce_117(val, _values, result)
-            return make_node(:ObjectTypeDefinition, name: val[1], interfaces: val[2], directives: val[3], fields: val[5], description: get_description(val[0]))
+            return make_node(:ObjectTypeDefinition, name: val[1], interfaces: val[2], directives: val[3], fields: val[5], description: get_description(val[0]), position_source: val[0])
       
     result
   end
@@ -1505,7 +1505,7 @@ module_eval(<<'.,.,', 'parser.y', 315)
 
 module_eval(<<'.,.,', 'parser.y', 319)
   def _reduce_128(val, _values, result)
-            return make_node(:InterfaceTypeDefinition, name: val[1], directives: val[2], fields: val[4], description: get_description(val[0]))
+            return make_node(:InterfaceTypeDefinition, name: val[1], directives: val[2], fields: val[4], description: get_description(val[0]), position_source: val[0])
       
     result
   end
@@ -1527,7 +1527,7 @@ module_eval(<<'.,.,', 'parser.y', 324)
 
 module_eval(<<'.,.,', 'parser.y', 328)
   def _reduce_131(val, _values, result)
-            return make_node(:UnionTypeDefinition, name: val[1], directives: val[2], types: val[4], description: get_description(val[0]))
+            return make_node(:UnionTypeDefinition, name: val[1], directives: val[2], types: val[4], description: get_description(val[0]), position_source: val[0])
       
     result
   end
@@ -1535,7 +1535,7 @@ module_eval(<<'.,.,', 'parser.y', 328)
 
 module_eval(<<'.,.,', 'parser.y', 333)
   def _reduce_132(val, _values, result)
-             return make_node(:EnumTypeDefinition, name: val[1], directives: val[2], values: val[4], description: get_description(val[0]))
+             return make_node(:EnumTypeDefinition, name: val[1], directives: val[2], values: val[4], description: get_description(val[0]), position_source: val[0])
       
     result
   end
@@ -1543,7 +1543,7 @@ module_eval(<<'.,.,', 'parser.y', 333)
 
 module_eval(<<'.,.,', 'parser.y', 338)
   def _reduce_133(val, _values, result)
-            return make_node(:InputObjectTypeDefinition, name: val[1], directives: val[2], fields: val[4], description: get_description(val[0]))
+            return make_node(:InputObjectTypeDefinition, name: val[1], directives: val[2], fields: val[4], description: get_description(val[0]), position_source: val[0])
       
     result
   end
@@ -1551,7 +1551,7 @@ module_eval(<<'.,.,', 'parser.y', 338)
 
 module_eval(<<'.,.,', 'parser.y', 343)
   def _reduce_134(val, _values, result)
-            return make_node(:DirectiveDefinition, name: val[2], arguments: val[3], locations: val[5], description: get_description(val[0]))
+            return make_node(:DirectiveDefinition, name: val[2], arguments: val[3], locations: val[5], description: get_description(val[0]), position_source: val[0])
       
     result
   end