inline public_send_field

Author: rmosolgo

lib/graphql/schema/field.rb

@@ -597,28 +597,85 @@ def authorized?(object, args, context)
       # @param object [GraphQL::Schema::Object] An instance of some type class, wrapping an application object
       # @param args [Hash] A symbol-keyed hash of Ruby keyword arguments. (Empty if no args)
       # @param ctx [GraphQL::Query::Context]
-      def resolve(object, args, ctx)
-        if @resolve_proc
-          raise "Can't run resolve proc for #{path} when using GraphQL::Execution::Interpreter"
-        end
+      def resolve(object, args, query_ctx)
         begin
           # Unwrap the GraphQL object to get the application object.
           application_object = object.object
 
-          Schema::Validator.validate!(validators, application_object, ctx, args)
+          Schema::Validator.validate!(validators, application_object, query_ctx, args)
 
-          ctx.schema.after_lazy(self.authorized?(application_object, args, ctx)) do |is_authorized|
+          query_ctx.schema.after_lazy(self.authorized?(application_object, args, query_ctx)) do |is_authorized|
             if is_authorized
-              public_send_field(object, args, ctx)
+              with_extensions(object, args, query_ctx) do |obj, ruby_kwargs|
+                begin
+                  method_receiver = nil
+                  method_to_call = nil
+                  if @resolver_class
+                    if obj.is_a?(GraphQL::Schema::Object)
+                      obj = obj.object
+                    end
+                    obj = @resolver_class.new(object: obj, context: query_ctx, field: self)
+                  end
+
+                  # Find a way to resolve this field, checking:
+                  #
+                  # - A method on the type instance;
+                  # - Hash keys, if the wrapped object is a hash;
+                  # - A method on the wrapped object;
+                  # - Or, raise not implemented.
+                  #
+                  if obj.respond_to?(resolver_method)
+                    method_to_call = resolver_method
+                    method_receiver = obj
+                    # Call the method with kwargs, if there are any
+                    if ruby_kwargs.any?
+                      obj.public_send(resolver_method, **ruby_kwargs)
+                    else
+                      obj.public_send(resolver_method)
+                    end
+                  elsif obj.object.is_a?(Hash)
+                    inner_object = obj.object
+                    if @dig_keys
+                      inner_object.dig(*@dig_keys)
+                    elsif inner_object.key?(@method_sym)
+                      inner_object[@method_sym]
+                    else
+                      inner_object[@method_str]
+                    end
+                  elsif obj.object.respond_to?(@method_sym)
+                    method_to_call = @method_sym
+                    method_receiver = obj.object
+                    if ruby_kwargs.any?
+                      obj.object.public_send(@method_sym, **ruby_kwargs)
+                    else
+                      obj.object.public_send(@method_sym)
+                    end
+                  else
+                    raise <<-ERR
+                  Failed to implement #{@owner.graphql_name}.#{@name}, tried:
+
+                  - `#{obj.class}##{resolver_method}`, which did not exist
+                  - `#{obj.object.class}##{@method_sym}`, which did not exist
+                  - Looking up hash key `#{@method_sym.inspect}` or `#{@method_str.inspect}` on `#{obj.object}`, but it wasn't a Hash
+
+                  To implement this field, define one of the methods above (and check for typos)
+                  ERR
+                  end
+                rescue ArgumentError
+                  assert_satisfactory_implementation(method_receiver, method_to_call, ruby_kwargs)
+                  # if the line above doesn't raise, re-raise
+                  raise
+                end
+              end
             else
-              raise GraphQL::UnauthorizedFieldError.new(object: application_object, type: object.class, context: ctx, field: self)
+              raise GraphQL::UnauthorizedFieldError.new(object: application_object, type: object.class, context: query_ctx, field: self)
             end
           end
         rescue GraphQL::UnauthorizedFieldError => err
           err.field ||= self
-          ctx.schema.unauthorized_field(err)
+          query_ctx.schema.unauthorized_field(err)
         rescue GraphQL::UnauthorizedError => err
-          ctx.schema.unauthorized_object(err)
+          query_ctx.schema.unauthorized_object(err)
         end
       rescue GraphQL::ExecutionError => err
         err
@@ -637,70 +694,6 @@ def fetch_extra(extra_name, ctx)
 
       private
 
-      def public_send_field(unextended_obj, unextended_ruby_kwargs, query_ctx)
-        with_extensions(unextended_obj, unextended_ruby_kwargs, query_ctx) do |obj, ruby_kwargs|
-          begin
-            method_receiver = nil
-            method_to_call = nil
-            if @resolver_class
-              if obj.is_a?(GraphQL::Schema::Object)
-                obj = obj.object
-              end
-              obj = @resolver_class.new(object: obj, context: query_ctx, field: self)
-            end
-
-            # Find a way to resolve this field, checking:
-            #
-            # - A method on the type instance;
-            # - Hash keys, if the wrapped object is a hash;
-            # - A method on the wrapped object;
-            # - Or, raise not implemented.
-            #
-            if obj.respond_to?(resolver_method)
-              method_to_call = resolver_method
-              method_receiver = obj
-              # Call the method with kwargs, if there are any
-              if ruby_kwargs.any?
-                obj.public_send(resolver_method, **ruby_kwargs)
-              else
-                obj.public_send(resolver_method)
-              end
-            elsif obj.object.is_a?(Hash)
-              inner_object = obj.object
-              if @dig_keys
-                inner_object.dig(*@dig_keys)
-              elsif inner_object.key?(@method_sym)
-                inner_object[@method_sym]
-              else
-                inner_object[@method_str]
-              end
-            elsif obj.object.respond_to?(@method_sym)
-              method_to_call = @method_sym
-              method_receiver = obj.object
-              if ruby_kwargs.any?
-                obj.object.public_send(@method_sym, **ruby_kwargs)
-              else
-                obj.object.public_send(@method_sym)
-              end
-            else
-              raise <<-ERR
-            Failed to implement #{@owner.graphql_name}.#{@name}, tried:
-
-            - `#{obj.class}##{resolver_method}`, which did not exist
-            - `#{obj.object.class}##{@method_sym}`, which did not exist
-            - Looking up hash key `#{@method_sym.inspect}` or `#{@method_str.inspect}` on `#{obj.object}`, but it wasn't a Hash
-
-            To implement this field, define one of the methods above (and check for typos)
-            ERR
-            end
-          rescue ArgumentError
-            assert_satisfactory_implementation(method_receiver, method_to_call, ruby_kwargs)
-            # if the line above doesn't raise, re-raise
-            raise
-          end
-        end
-      end
-
       def assert_satisfactory_implementation(receiver, method_name, ruby_kwargs)
         method_defn = receiver.method(method_name)
         unsatisfied_ruby_kwargs = ruby_kwargs.dup