graphql 2.6.11 → 2.6.13

data/lib/graphql/dataloader/async_dataloader.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   class Dataloader
@@ -23,8 +24,7 @@ module GraphQL
         create_pending_run
       end
 
-      # @api private
-      attr_reader :pending_sources
+      attr_reader :pending_sources # :nodoc:
 
       def create_pending_run
         jobs_fiber_limit, total_fiber_limit = calculate_fiber_limit
@@ -206,7 +206,7 @@ module GraphQL
 
       def run_isolated
         previous_run = current_task_run
-        prev_pending_keys = {}
+        prev_pending_keys = {} #: Hash[GraphQL::Dataloader::Source, Hash[untyped, untyped]]
         # Clear pending loads but keep already-cached records
         # in case they are useful to the given block.
         @source_cache.each do |source_class, batched_sources|
@@ -218,7 +218,7 @@ module GraphQL
           end
         end
 
-        res = nil
+        res = nil #: untyped
         create_pending_run
         @pending_run.jobs << -> { res = yield }
         run
@@ -229,6 +229,7 @@ module GraphQL
           # clear the one created in #run:
           @pending_run = nil
         end
+        prev_pending_keys = prev_pending_keys #: as !nil
         prev_pending_keys.each do |source_instance, pending|
           pending.each do |key, value|
             next if source_instance.results.key?(key)
@@ -244,16 +245,18 @@ module GraphQL
         run = @pending_run || current_task_run || raise(GraphQL::Error, "No available Run, GraphQL-Ruby internal bug")
         @pending_run = nil
         run.trace = trace
-        first_pass = true
+        first_pass = true #: bool
         trace&.begin_dataloader(self)
         fiber_vars = get_fiber_variables
-        raised_error = nil
+        raised_error = nil #: StandardError?
         jobs = run.jobs
         Sync do |_maybe_new_task|
           # Make sure there's a new task instance to hold `.graphql_...` state:
           task = Async::Task.new do |root_task|
             run.root_task = root_task
             root_task.graphql_async_dataloader_run = run
+            # Tasks inherit the spawning fiber's storage; give this run its own execution state.
+            Fiber[:__graphql_runtime_info] = nil
             set_fiber_variables(fiber_vars)
 
             while first_pass || run.running? || !jobs.empty?
@@ -289,7 +292,7 @@ module GraphQL
       private
 
       def run_queue(run, condition, mode)
-        opened_queues = false
+        opened_queues = false #: bool
 
         if condition.waiting?
           opened_queues = true

data/lib/graphql/dataloader/null_dataloader.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   class Dataloader
     # GraphQL-Ruby uses this when Dataloader isn't enabled.
     #
     # It runs execution code inline and gathers lazy objects (eg. Promises)
-    # and resolves them during {#run}.
+    # and resolves them during [run](rdoc-ref:#run).
     class NullDataloader < Dataloader
       def initialize(*)
         @lazies_at_depth = Hash.new { |h,k| h[k] = [] }
@@ -20,7 +21,7 @@ module GraphQL
       def run(trace_query_lazy: nil)
         with_trace_query_lazy(trace_query_lazy) do
           while !@lazies_at_depth.empty?
-            smallest_depth = nil
+            smallest_depth = nil #: Integer?
             @lazies_at_depth.each_key do |depth_key|
               smallest_depth ||= depth_key
               if depth_key < smallest_depth
@@ -40,7 +41,7 @@ module GraphQL
         # Reuse this instance because execution code may already have a reference to _this_ `dataloader` inside the given block.
         prev_lazies_at_depth = @lazies_at_depth
         @lazies_at_depth = @lazies_at_depth.dup.clear
-        res = nil
+        res = nil #: untyped
         append_job {
           res = yield
         }

data/lib/graphql/dataloader/request.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
+# typed: true
 module GraphQL
   class Dataloader
-    # @see Source#request which returns an instance of this
+    # See [Source#request](rdoc-ref:Source#request) which returns an instance of this
     class Request
       def initialize(source, key)
         @source = source
@@ -10,7 +11,12 @@ module GraphQL
 
       # Call this method to cause the current Fiber to wait for the results of this request.
       #
-      # @return [Object] the object loaded for `key`
+      # **Returns**
+      #
+      # - `Object` — the object loaded for `key`
+      #
+      # :call-seq:
+      #   load() -> Object
       def load
         @source.load(@key)
       end

data/lib/graphql/dataloader/request_all.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
+# typed: true
 module GraphQL
   class Dataloader
-    # @see Source#request_all which returns an instance of this.
+    # See [Source#request_all](rdoc-ref:Source#request_all) which returns an instance of this.
     class RequestAll < Request
       def initialize(source, keys)
         @source = source
@@ -10,7 +11,12 @@ module GraphQL
 
       # Call this method to cause the current Fiber to wait for the results of this request.
       #
-      # @return [Array<Object>] One object for each of `keys`
+      # **Returns**
+      #
+      # - `Array<Object>` — One object for each of `keys`
+      #
+      # :call-seq:
+      #   load() -> Array[Object]
       def load
         @source.load_all(@keys)
       end

data/lib/graphql/dataloader/source.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   class Dataloader
     class Source
-      # Called by {Dataloader} to prepare the {Source}'s internal state
-      # @api private
-      def setup(dataloader)
+      # Called by [Dataloader](rdoc-ref:Dataloader) to prepare the [Source](rdoc-ref:Source)'s internal state
+      def setup(dataloader) # :nodoc:
         # These keys have been requested but haven't been fetched yet
         @pending = {}
         # These keys have been passed to `fetch` but haven't been finished yet
@@ -17,7 +17,12 @@ module GraphQL
 
       attr_reader :dataloader
 
-      # @return [Dataloader::Request] a pending request for a value from `key`. Call `.load` on that object to wait for the result.
+      # **Returns**
+      #
+      # - `Dataloader::Request` — a pending request for a value from `key`. Call `.load` on that object to wait for the result.
+      #
+      # :call-seq:
+      #   request(value) -> Dataloader::Request
       def request(value)
         res_key = result_key_for(value)
         add_pending_key(res_key, value)
@@ -27,25 +32,46 @@ module GraphQL
       # Implement this method to return a stable identifier if different
       # key objects should load the same data value.
       #
-      # @param value [Object] A value passed to `.request` or `.load`, for which a value will be loaded
-      # @return [Object] The key for tracking this pending data
+      # **Parameters**
+      #
+      # - `value` (`Object`) — A value passed to `.request` or `.load`, for which a value will be loaded
+      #
+      # **Returns**
+      #
+      # - `Object` — The key for tracking this pending data
+      #
+      # :call-seq:
+      #   result_key_for(Object value) -> Object
       def result_key_for(value)
         value
       end
 
-      # Implement this method if varying values given to {load} (etc) should be consolidated
-      # or normalized before being handed off to your {fetch} implementation.
+      # Implement this method if varying values given to [load](rdoc-ref:load) (etc) should be consolidated
+      # or normalized before being handed off to your [fetch](rdoc-ref:fetch) implementation.
       #
-      # This is different than {result_key_for} because _that_ method handles unification inside Dataloader's cache,
-      # but this method changes the value passed into {fetch}.
+      # This is different than [result_key_for](rdoc-ref:result_key_for) because _that_ method handles unification inside Dataloader's cache,
+      # but this method changes the value passed into [fetch](rdoc-ref:fetch).
       #
-      # @param value [Object] The value passed to {load}, {load_all}, {request}, or {request_all}
-      # @return [Object] The value given to {fetch}
+      # **Parameters**
+      #
+      # - `value` (`Object`) — The value passed to [load](rdoc-ref:load), [load_all](rdoc-ref:load_all), [request](rdoc-ref:request), or [request_all](rdoc-ref:request_all)
+      #
+      # **Returns**
+      #
+      # - `Object` — The value given to [fetch](rdoc-ref:fetch)
+      #
+      # :call-seq:
+      #   normalize_fetch_key(Object value) -> Object
       def normalize_fetch_key(value)
         value
       end
 
-      # @return [Dataloader::Request] a pending request for a values from `keys`. Call `.load` on that object to wait for the results.
+      # **Returns**
+      #
+      # - `Dataloader::Request` — a pending request for a values from `keys`. Call `.load` on that object to wait for the results.
+      #
+      # :call-seq:
+      #   request_all(values) -> Dataloader::Request
       def request_all(values)
         values.each do |v|
           res_key = result_key_for(v)
@@ -54,8 +80,16 @@ module GraphQL
         Dataloader::RequestAll.new(self, values)
       end
 
-      # @param value [Object] A loading value which will be passed to {#fetch} if it isn't already in the internal cache.
-      # @return [Object] The result from {#fetch} for `key`. If `key` hasn't been loaded yet, the Fiber will yield until it's loaded.
+      # **Parameters**
+      #
+      # - `value` (`Object`) — A loading value which will be passed to [fetch](rdoc-ref:#fetch) if it isn't already in the internal cache.
+      #
+      # **Returns**
+      #
+      # - `Object` — The result from [fetch](rdoc-ref:#fetch) for `key`. If `key` hasn't been loaded yet, the Fiber will yield until it's loaded.
+      #
+      # :call-seq:
+      #   load(Object value) -> Object
       def load(value)
         result_key = result_key_for(value)
         if @results.key?(result_key)
@@ -67,8 +101,16 @@ module GraphQL
         end
       end
 
-      # @param values [Array<Object>] Loading keys which will be passed to `#fetch` (or read from the internal cache).
-      # @return [Object] The result from {#fetch} for `keys`. If `keys` haven't been loaded yet, the Fiber will yield until they're loaded.
+      # **Parameters**
+      #
+      # - `values` (`Array<Object>`) — Loading keys which will be passed to `#fetch` (or read from the internal cache).
+      #
+      # **Returns**
+      #
+      # - `Object` — The result from [fetch](rdoc-ref:#fetch) for `keys`. If `keys` haven't been loaded yet, the Fiber will yield until they're loaded.
+      #
+      # :call-seq:
+      #   load_all(Array[Object] values) -> Object
       def load_all(values)
         result_keys = []
         pending_keys = []
@@ -89,8 +131,17 @@ module GraphQL
       end
 
       # Subclasses must implement this method to return a value for each of `keys`
-      # @param keys [Array<Object>] keys passed to {#load}, {#load_all}, {#request}, or {#request_all}
-      # @return [Array<Object>] A loaded value for each of `keys`. The array must match one-for-one to the list of `keys`.
+      #
+      # **Parameters**
+      #
+      # - `keys` (`Array<Object>`) — keys passed to [load](rdoc-ref:#load), [load all](rdoc-ref:#load_all), [request](rdoc-ref:#request), or [request all](rdoc-ref:#request_all)
+      #
+      # **Returns**
+      #
+      # - `Array<Object>` — A loaded value for each of `keys`. The array must match one-for-one to the list of `keys`.
+      #
+      # :call-seq:
+      #   fetch(Array[Object] keys) -> Array[Object]
       def fetch(keys)
         # somehow retrieve these from the backend
         raise "Implement `#{self.class}#fetch(#{keys.inspect}) to return a record for each of the keys"
@@ -99,7 +150,13 @@ module GraphQL
       MAX_ITERATIONS = 1000
       # Wait for a batch, if there's anything to batch.
       # Then run the batch and update the cache.
-      # @return [void]
+      #
+      # **Returns**
+      #
+      # - `void`
+      #
+      # :call-seq:
+      #   sync(pending_result_keys) -> void
       def sync(pending_result_keys)
         @dataloader.queue_pending_source(self) if pending?
         @dataloader.yield(self)
@@ -114,15 +171,29 @@ module GraphQL
         nil
       end
 
-      # @return [Boolean] True if this source has any pending requests for data.
+      # **Returns**
+      #
+      # - `Boolean` — True if this source has any pending requests for data.
+      #
+      # :call-seq:
+      #   pending?() -> bool
       def pending?
         !@pending.empty?
       end
 
       # Add these key-value pairs to this source's cache
       # (future loads will use these merged values).
-      # @param new_results [Hash<Object => Object>] key-value pairs to cache in this source
-      # @return [void]
+      #
+      # **Parameters**
+      #
+      # - `new_results` (`Hash<Object => Object>`) — key-value pairs to cache in this source
+      #
+      # **Returns**
+      #
+      # - `void`
+      #
+      # :call-seq:
+      #   merge(Hash[Object, Object] new_results) -> void
       def merge(new_results)
         new_results.each do |new_k, new_v|
           key = result_key_for(new_k)
@@ -131,10 +202,12 @@ module GraphQL
         nil
       end
 
-      # Called by {GraphQL::Dataloader} to resolve and pending requests to this source.
-      # @api private
-      # @return [void]
-      def run_pending_keys
+      # Called by [GraphQL::Dataloader](rdoc-ref:GraphQL::Dataloader) to resolve and pending requests to this source.
+      #
+      # **Returns**
+      #
+      # - `void`
+      def run_pending_keys # :nodoc:
         @fetching.each_key { |k| @pending.delete(k) }
         return if @pending.empty?
         fetch_h = @pending
@@ -167,9 +240,17 @@ module GraphQL
       # this method to call `.to_sql` on them, thus merging `.load(...)` calls when they apply
       # to equivalent relations.
       #
-      # @param batch_args [Array<Object>]
-      # @param batch_kwargs [Hash]
-      # @return [Object]
+      # **Parameters**
+      #
+      # - `batch_args` (`Array<Object>`)
+      # - `batch_kwargs` (`Hash`)
+      #
+      # **Returns**
+      #
+      # - `Object`
+      #
+      # :call-seq:
+      #   batch_key_for(Array[Object] *batch_args, Hash **batch_kwargs) -> Object
       def self.batch_key_for(*batch_args, **batch_kwargs)
         if batch_kwargs.any? # rubocop:disable Development/NoneWithoutBlockCop
           [*batch_args, **batch_kwargs]
@@ -179,7 +260,13 @@ module GraphQL
       end
 
       # Clear any already-loaded objects for this source
-      # @return [void]
+      #
+      # **Returns**
+      #
+      # - `void`
+      #
+      # :call-seq:
+      #   clear_cache() -> void
       def clear_cache
         @results.clear
         nil
@@ -199,10 +286,15 @@ module GraphQL
       end
 
       # Reads and returns the result for the key from the internal cache, or raises an error if the result was an error
-      # @param key [Object] key passed to {#load} or {#load_all}
-      # @return [Object] The result from {#fetch} for `key`.
-      # @api private
-      def result_for(key)
+      #
+      # **Parameters**
+      #
+      # - `key` (`Object`) — key passed to [load](rdoc-ref:#load) or [load all](rdoc-ref:#load_all)
+      #
+      # **Returns**
+      #
+      # - `Object` — The result from [fetch](rdoc-ref:#fetch) for `key`.
+      def result_for(key) # :nodoc:
         if !@results.key?(key)
           raise GraphQL::InvariantError, <<-ERR
 Fetching result for a key on #{self.class} that hasn't been loaded yet (#{key.inspect}, loaded: #{@results.keys})

data/lib/graphql/dataloader.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 
 require "graphql/dataloader/null_dataloader"
 require "graphql/dataloader/request"
@@ -8,22 +9,27 @@ require "graphql/dataloader/active_record_association_source"
 require "graphql/dataloader/active_record_source"
 
 module GraphQL
-  # This plugin supports Fiber-based concurrency, along with {GraphQL::Dataloader::Source}.
+  # This plugin supports Fiber-based concurrency, along with [GraphQL::Dataloader::Source](rdoc-ref:GraphQL::Dataloader::Source).
   #
-  # @example Installing Dataloader
+  # **Examples**
   #
-  #   class MySchema < GraphQL::Schema
-  #     use GraphQL::Dataloader
-  #   end
+  # **Example: Installing Dataloader**
   #
-  # @example Waiting for batch-loaded data in a GraphQL field
+  # ```ruby
+  # class MySchema < GraphQL::Schema
+  #   use GraphQL::Dataloader
+  # end
+  # ```
   #
-  #   field :team, Types::Team, null: true
+  # **Example: Waiting for batch-loaded data in a GraphQL field**
   #
-  #   def team
-  #     dataloader.with(Sources::Record, Team).load(object.team_id)
-  #   end
+  # ```ruby
+  # field :team, Types::Team, null: true
   #
+  # def team
+  #   dataloader.with(Sources::Record, Team).load(object.team_id)
+  # end
+  # ```
   class Dataloader
     class << self
       attr_accessor :default_nonblocking, :default_fiber_limit
@@ -49,7 +55,7 @@ module GraphQL
     # then run all enqueued jobs and return the result of the block.
     def self.with_dataloading(&block)
       dataloader = self.new
-      result = nil
+      result = nil #: untyped
       dataloader.append_job {
         result = block.call(dataloader)
       }
@@ -69,7 +75,9 @@ module GraphQL
       @lazies_at_depth = Hash.new { |h, k| h[k] = [] }
     end
 
-    # @return [Integer, nil]
+    # **Returns**
+    #
+    # - `Integer, nil`
     attr_reader :fiber_limit
 
     def nonblocking?
@@ -79,7 +87,12 @@ module GraphQL
     # This is called before the fiber is spawned, from the parent context (i.e. from
     # the thread or fiber that it is scheduled from).
     #
-    # @return [Hash<Symbol, Object>] Current fiber-local variables
+    # **Returns**
+    #
+    # - `Hash<Symbol, Object>` — Current fiber-local variables
+    #
+    # :call-seq:
+    #   get_fiber_variables() -> Hash[Symbol, Object]
     def get_fiber_variables
       fiber_vars = {}
       Thread.current.keys.each do |fiber_var_key|
@@ -92,8 +105,16 @@ module GraphQL
     #
     # This is called within the fiber, right after it is spawned.
     #
-    # @param vars [Hash<Symbol, Object>] Fiber-local variables from {get_fiber_variables}
-    # @return [void]
+    # **Parameters**
+    #
+    # - `vars` (`Hash<Symbol, Object>`) — Fiber-local variables from [get_fiber_variables](rdoc-ref:get_fiber_variables)
+    #
+    # **Returns**
+    #
+    # - `void`
+    #
+    # :call-seq:
+    #   set_fiber_variables(Hash[Symbol, Object] vars) -> void
     def set_fiber_variables(vars)
       vars.each { |k, v| Thread.current[k] = v }
       nil
@@ -106,12 +127,17 @@ module GraphQL
 
     # Get a Source instance from this dataloader, for calling `.load(...)` or `.request(...)` on.
     #
-    # @param source_class [Class<GraphQL::Dataloader::Source]
-    # @param batch_parameters [Array<Object>]
-    # @return [GraphQL::Dataloader::Source] An instance of {source_class}, initialized with `self, *batch_parameters`,
-    #   and cached for the lifetime of this {Multiplex}.
+    # **Parameters**
+    #
+    # - `source_class` (`Class<GraphQL::Dataloader::Source>`) — The source class to load
+    # - `batch_parameters` (`Array<Object>`)
+    #
+    # **Returns**
+    #
+    # - `GraphQL::Dataloader::Source` — An instance of [source_class](rdoc-ref:source_class), initialized with `self, *batch_parameters`, and cached for the lifetime of this [Multiplex](rdoc-ref:Multiplex).
     if (RUBY_ENGINE == "ruby" && RUBY_VERSION < "3") || RUBY_ENGINE == "truffleruby" # truffle-ruby wasn't doing well with the implementation below
-      def with(source_class, *batch_args)
+      # `define_method` so that Sorbet doesn't see this as a conflicting definition of `#with`
+      define_method(:with) do |source_class, *batch_args|
         batch_key = source_class.batch_key_for(*batch_args)
         @source_cache[source_class][batch_key] ||= begin
           source = source_class.new(*batch_args)
@@ -133,7 +159,12 @@ module GraphQL
     #
     # Dataloader will resume the fiber after the requested data has been loaded (by another Fiber).
     #
-    # @return [void]
+    # **Returns**
+    #
+    # - `void`
+    #
+    # :call-seq:
+    #   yield(source:) -> void
     def yield(source = Fiber[:__graphql_current_dataloader_source])
       trace = Fiber[:__graphql_current_multiplex]&.current_trace
       trace&.dataloader_fiber_yield(source)
@@ -142,24 +173,28 @@ module GraphQL
       nil
     end
 
-    # @api private Nothing to see here
-    def append_job(callable = nil, &job)
+    def append_job(callable = nil, &job) # :nodoc:
       # Given a block, queue it up to be worked through when `#run` is called.
       # (If the dataloader is already running, then a Fiber will pick this up later.)
       @pending_jobs.push(callable || job)
       nil
     end
 
-    # @api private
-    def queue_pending_source(source)
+    def queue_pending_source(source) # :nodoc:
       if @pending_source_set.add?(source)
         @pending_sources << source
       end
       nil
     end
 
-    # Clear any already-loaded objects from {Source} caches
-    # @return [void]
+    # Clear any already-loaded objects from [Source](rdoc-ref:Source) caches
+    #
+    # **Returns**
+    #
+    # - `void`
+    #
+    # :call-seq:
+    #   clear_cache() -> void
     def clear_cache
       @source_cache.each do |_source_class, batched_sources|
         batched_sources.each_value(&:clear_cache)
@@ -185,7 +220,7 @@ module GraphQL
       end
 
       @pending_jobs = []
-      res = nil
+      res = nil #: untyped
       # Make sure the block is inside a Fiber, so it can `Fiber.yield`
       append_job {
         res = yield
@@ -195,7 +230,8 @@ module GraphQL
     ensure
       @pending_jobs = prev_queue
       @lazies_at_depth = prev_lazies_at_depth
-      prev_pending_keys.each do |source_instance, pending|
+      prev_pending_keys #: as !nil
+        .each do |source_instance, pending|
         pending.each do |key, value|
           next if source_instance.results.key?(key)
 
@@ -205,7 +241,12 @@ module GraphQL
       end
     end
 
-    # @param trace_query_lazy [nil, Execution::Multiplex]
+    # **Parameters**
+    #
+    # - `trace_query_lazy` (`nil, Execution::Multiplex`)
+    #
+    # :call-seq:
+    #   run(nil | Execution::Multiplex trace_query_lazy:)
     def run(trace_query_lazy: nil)
       trace = Fiber[:__graphql_current_multiplex]&.current_trace
       jobs_fiber_limit, total_fiber_limit = calculate_fiber_limit
@@ -213,7 +254,7 @@ module GraphQL
       next_job_fibers = []
       source_fibers = []
       next_source_fibers = []
-      first_pass = true
+      first_pass = true #: bool
       manager = spawn_fiber do
         trace&.begin_dataloader(self)
         while first_pass || !job_fibers.empty?
@@ -255,14 +296,15 @@ module GraphQL
       f.resume
     end
 
-    # @api private
-    def lazy_at_depth(depth, lazy)
+    def lazy_at_depth(depth, lazy) # :nodoc:
       @lazies_at_depth[depth] << lazy
     end
 
     def spawn_fiber
       fiber_vars = get_fiber_variables
       Fiber.new(blocking: !@nonblocking) do
+        # Fibers inherit the spawning fiber's storage; give each one its own execution state.
+        Fiber[:__graphql_runtime_info] = nil
         set_fiber_variables(fiber_vars)
         yield
       ensure
@@ -271,11 +313,20 @@ module GraphQL
     end
 
     # Pre-warm the Dataloader cache with ActiveRecord objects which were loaded elsewhere.
-    # These will be used by {Dataloader::ActiveRecordSource}, {Dataloader::ActiveRecordAssociationSource} and their helper
+    # These will be used by [Dataloader::ActiveRecordSource](rdoc-ref:Dataloader::ActiveRecordSource), [Dataloader::ActiveRecordAssociationSource](rdoc-ref:Dataloader::ActiveRecordAssociationSource) and their helper
     # methods, `dataload_record` and `dataload_association`.
-    # @param records [Array<ActiveRecord::Base>] Already-loaded records to warm the cache with
-    # @param index_by [Symbol] The attribute to use as the cache key. (Should match `find_by:` when using {ActiveRecordSource})
-    # @return [void]
+    #
+    # **Parameters**
+    #
+    # - `records` (`Array<ActiveRecord::Base>`) — Already-loaded records to warm the cache with
+    # - `index_by` (`Symbol`) — The attribute to use as the cache key. (Should match `find_by:` when using [ActiveRecordSource](rdoc-ref:ActiveRecordSource))
+    #
+    # **Returns**
+    #
+    # - `void`
+    #
+    # :call-seq:
+    #   merge_records(Array[ActiveRecord::Base] records, Symbol index_by:) -> void
     def merge_records(records, index_by: :id)
       records_by_class = Hash.new { |h, k| h[k] = {} }
       records.each do |r|
@@ -315,11 +366,11 @@ module GraphQL
       join_queues(job_fibers, next_job_fibers)
 
       while (!source_fibers.empty? || !@pending_sources.empty?)
-        while (f = source_fibers.shift || (((job_fibers.size + source_fibers.size + next_source_fibers.size + next_job_fibers.size) < total_fiber_limit) && spawn_source_fiber(trace)))
-          if f.alive?
-            finished = run_fiber(f)
-            if !finished
-              next_source_fibers << f
+        while (source_f = source_fibers.shift || (((job_fibers.size + source_fibers.size + next_source_fibers.size + next_job_fibers.size) < total_fiber_limit) && spawn_source_fiber(trace)))
+          if source_f.alive?
+            source_finished = run_fiber(source_f)
+            if !source_finished
+              next_source_fibers << source_f
             end
           end
         end