graphql 2.0.14 → 2.0.32

data/lib/graphql/schema/member/build_type.rb

@@ -109,7 +109,14 @@ module GraphQL
               to_type_name(something.name)
             end
           when String
-            something.gsub(/\]\[\!/, "").split("::").last
+            if something.include?("]") ||
+                something.include?("[") ||
+                something.include?("!") ||
+                something.include?("::")
+              something.gsub(/\]\[\!/, "").split("::").last
+            else
+              something
+            end
           when GraphQL::Schema::NonNull, GraphQL::Schema::List
             to_type_name(something.unwrap)
           else
@@ -120,9 +127,10 @@ module GraphQL
         def camelize(string)
           return string if string == '_'
           return string unless string.include?("_")
-          camelized = string.split('_').map(&:capitalize).join
+          camelized = string.split('_').each(&:capitalize!).join
           camelized[0] = camelized[0].downcase
-          if (match_data = string.match(/\A(_+)/))
+          if string.start_with?("_")
+            match_data = string.match(/\A(_+)/)
             camelized = "#{match_data[0]}#{camelized}"
           end
           camelized

data/lib/graphql/schema/member/has_arguments.rb

@@ -11,6 +11,7 @@ module GraphQL
         def self.extended(cls)
           cls.extend(ArgumentClassAccessor)
           cls.include(ArgumentObjectLoader)
+          cls.extend(ClassConfigured)
         end
 
         # @see {GraphQL::Schema::Argument#initialize} for parameters
@@ -50,7 +51,7 @@ module GraphQL
               class_eval <<-RUBY, __FILE__, __LINE__ + 1
               def #{method_owner}load_#{arg_defn.keyword}(values, context = nil)
                 argument = get_argument("#{arg_defn.graphql_name}")
-                (context || self.context).schema.after_lazy(values) do |values2|
+                (context || self.context).query.after_lazy(values) do |values2|
                   GraphQL::Execution::Lazy.all(values2.map { |value| load_application_object(argument, value, context || self.context) })
                 end
               end
@@ -109,14 +110,6 @@ module GraphQL
 
         # @return [Hash<String => GraphQL::Schema::Argument] Arguments defined on this thing, keyed by name. Includes inherited definitions
         def arguments(context = GraphQL::Query::NullContext)
-          inherited_arguments = if self.is_a?(Class) && superclass.respond_to?(:arguments)
-            superclass.arguments(context)
-          elsif defined?(@resolver_class) && @resolver_class
-            @resolver_class.field_arguments(context)
-          else
-            nil
-          end
-          # Local definitions override inherited ones
           if own_arguments.any?
             own_arguments_that_apply = {}
             own_arguments.each do |name, args_entry|
@@ -125,47 +118,107 @@ module GraphQL
               end
             end
           end
+          # might be nil if there are actually no arguments
+          own_arguments_that_apply || own_arguments
+        end
 
-          if inherited_arguments
-            if own_arguments_that_apply
-              inherited_arguments.merge(own_arguments_that_apply)
-            else
-              inherited_arguments
+        module ClassConfigured
+          def inherited(child_class)
+            super
+            child_class.extend(InheritedArguments)
+          end
+
+          module InheritedArguments
+            def arguments(context = GraphQL::Query::NullContext)
+              own_arguments = super
+              inherited_arguments = superclass.arguments(context)
+
+              if own_arguments.any?
+                if inherited_arguments.any?
+                  # Local definitions override inherited ones
+                  inherited_arguments.merge(own_arguments)
+                else
+                  own_arguments
+                end
+              else
+                inherited_arguments
+              end
+            end
+
+            def all_argument_definitions
+              all_defns = {}
+              ancestors.reverse_each do |ancestor|
+                if ancestor.respond_to?(:own_arguments)
+                  all_defns.merge!(ancestor.own_arguments)
+                end
+              end
+              all_defns = all_defns.values
+              all_defns.flatten!
+              all_defns
+            end
+
+
+            def get_argument(argument_name, context = GraphQL::Query::NullContext)
+              warden = Warden.from_context(context)
+              for ancestor in ancestors
+                if ancestor.respond_to?(:own_arguments) &&
+                  (a = ancestor.own_arguments[argument_name]) &&
+                  (a = Warden.visible_entry?(:visible_argument?, a, context, warden))
+                  return a
+                end
+              end
+              nil
             end
-          else
-            # might be nil if there are actually no arguments
-            own_arguments_that_apply || own_arguments
           end
         end
 
-        def all_argument_definitions
-          if self.is_a?(Class)
-            all_defns = {}
-            ancestors.reverse_each do |ancestor|
-              if ancestor.respond_to?(:own_arguments)
-                all_defns.merge!(ancestor.own_arguments)
+        module FieldConfigured
+          def arguments(context = GraphQL::Query::NullContext)
+            own_arguments = super
+            if defined?(@resolver_class) && @resolver_class
+              inherited_arguments = @resolver_class.field_arguments(context)
+              if own_arguments.any?
+                if inherited_arguments.any?
+                  inherited_arguments.merge(own_arguments)
+                else
+                  own_arguments
+                end
+              else
+                inherited_arguments
               end
+            else
+              own_arguments
             end
-          elsif defined?(@resolver_class) && @resolver_class
-            all_defns = {}
-            @resolver_class.all_field_argument_definitions.each do |arg_defn|
-              key = arg_defn.graphql_name
-              case (current_value = all_defns[key])
-              when nil
-                all_defns[key] = arg_defn
-              when Array
-                current_value << arg_defn
-              when GraphQL::Schema::Argument
-                all_defns[key] = [current_value, arg_defn]
-              else
-                raise "Invariant: Unexpected argument definition, #{current_value.class}: #{current_value.inspect}"
+          end
+
+          def all_argument_definitions
+            if defined?(@resolver_class) && @resolver_class
+              all_defns = {}
+              @resolver_class.all_field_argument_definitions.each do |arg_defn|
+                key = arg_defn.graphql_name
+                case (current_value = all_defns[key])
+                when nil
+                  all_defns[key] = arg_defn
+                when Array
+                  current_value << arg_defn
+                when GraphQL::Schema::Argument
+                  all_defns[key] = [current_value, arg_defn]
+                else
+                  raise "Invariant: Unexpected argument definition, #{current_value.class}: #{current_value.inspect}"
+                end
               end
+              all_defns.merge!(own_arguments)
+              all_defns = all_defns.values
+              all_defns.flatten!
+              all_defns
+            else
+              super
             end
-            all_defns.merge!(own_arguments)
-          else
-            all_defns = own_arguments
           end
-          all_defns = all_defns.values
+        end
+
+        def all_argument_definitions
+          all_defns = own_arguments.values
           all_defns.flatten!
           all_defns
         end
@@ -173,22 +226,11 @@ module GraphQL
         # @return [GraphQL::Schema::Argument, nil] Argument defined on this thing, fetched by name.
         def get_argument(argument_name, context = GraphQL::Query::NullContext)
           warden = Warden.from_context(context)
-          if !self.is_a?(Class)
-            if (arg_config = own_arguments[argument_name]) && (visible_arg = Warden.visible_entry?(:visible_argument?, arg_config, context, warden))
-              visible_arg
-            elsif defined?(@resolver_class) && @resolver_class
-              @resolver_class.get_field_argument(argument_name, context)
-            else
-              nil
-            end
+          if (arg_config = own_arguments[argument_name]) && (visible_arg = Warden.visible_entry?(:visible_argument?, arg_config, context, warden))
+            visible_arg
+          elsif defined?(@resolver_class) && @resolver_class
+            @resolver_class.get_field_argument(argument_name, context)
           else
-            for ancestor in ancestors
-              if ancestor.respond_to?(:own_arguments) &&
-                (a = ancestor.own_arguments[argument_name]) &&
-                (a = Warden.visible_entry?(:visible_argument?, a, context, warden))
-                return a
-              end
-            end
             nil
           end
         end
@@ -209,7 +251,7 @@ module GraphQL
         # @return [Interpreter::Arguments, Execution::Lazy<Interpeter::Arguments>]
         def coerce_arguments(parent_object, values, context, &block)
           # Cache this hash to avoid re-merging it
-          arg_defns = self.arguments(context)
+          arg_defns = context.warden.arguments(self)
           total_args_count = arg_defns.size
 
           finished_args = nil
@@ -223,7 +265,7 @@ module GraphQL
               argument_values = {}
               resolved_args_count = 0
               raised_error = false
-              arg_defns.each do |arg_name, arg_defn|
+              arg_defns.each do |arg_defn|
                 context.dataloader.append_job do
                   begin
                     arg_defn.coerce_into_values(parent_object, values, context, argument_values)
@@ -265,7 +307,12 @@ module GraphQL
         # but not for directives.
         # TODO apply static validations on schema definitions?
         def validate_directive_argument(arg_defn, value)
-          if arg_defn.owner.is_a?(Class) && arg_defn.owner < GraphQL::Schema::Directive
+          # this is only implemented on directives.
+          nil
+        end
+
+        module HasDirectiveArguments
+          def validate_directive_argument(arg_defn, value)
             if value.nil? && arg_defn.type.non_null?
               raise ArgumentError, "#{arg_defn.path} is required, but no value was given"
             end
@@ -273,9 +320,11 @@ module GraphQL
         end
 
         def arguments_statically_coercible?
-          return @arguments_statically_coercible if defined?(@arguments_statically_coercible)
-
-          @arguments_statically_coercible = all_argument_definitions.all?(&:statically_coercible?)
+          if defined?(@arguments_statically_coercible) && !@arguments_statically_coercible.nil?
+            @arguments_statically_coercible
+          else
+            @arguments_statically_coercible = all_argument_definitions.all?(&:statically_coercible?)
+          end
         end
 
         module ArgumentClassAccessor
@@ -316,7 +365,7 @@ module GraphQL
           end
 
           def authorize_application_object(argument, id, context, loaded_application_object)
-            context.schema.after_lazy(loaded_application_object) do |application_object|
+            context.query.after_lazy(loaded_application_object) do |application_object|
               if application_object.nil?
                 err = GraphQL::LoadApplicationObjectFailedError.new(argument: argument, id: id, object: application_object)
                 load_application_object_failed(err)
@@ -324,7 +373,7 @@ module GraphQL
               # Double-check that the located object is actually of this type
               # (Don't want to allow arbitrary access to objects this way)
               maybe_lazy_resolve_type = context.schema.resolve_type(argument.loads, application_object, context)
-              context.schema.after_lazy(maybe_lazy_resolve_type) do |resolve_type_result|
+              context.query.after_lazy(maybe_lazy_resolve_type) do |resolve_type_result|
                 if resolve_type_result.is_a?(Array) && resolve_type_result.size == 2
                   application_object_type, application_object = resolve_type_result
                 else
@@ -339,7 +388,7 @@ module GraphQL
                   # This object was loaded successfully
                   # and resolved to the right type,
                   # now apply the `.authorized?` class method if there is one
-                  context.schema.after_lazy(application_object_type.authorized?(application_object, context)) do |authed|
+                  context.query.after_lazy(application_object_type.authorized?(application_object, context)) do |authed|
                     if authed
                       application_object
                     else
@@ -366,7 +415,7 @@ module GraphQL
           end
         end
 
-        NO_ARGUMENTS = {}.freeze
+        NO_ARGUMENTS =  GraphQL::EmptyObjects::EMPTY_HASH
         def own_arguments
           @own_arguments || NO_ARGUMENTS
         end

data/lib/graphql/schema/member/has_ast_node.rb

@@ -3,6 +3,16 @@ module GraphQL
   class Schema
     class Member
       module HasAstNode
+        def self.extended(child_cls)
+          super
+          child_cls.ast_node = nil
+        end
+
+        def inherited(child_cls)
+          super
+          child_cls.ast_node = nil
+        end
+
         # If this schema was parsed from a `.graphql` file (or other SDL),
         # this is the AST node that defined this part of the schema.
         def ast_node(new_ast_node = nil)
@@ -14,6 +24,8 @@ module GraphQL
             nil
           end
         end
+
+        attr_writer :ast_node
       end
     end
   end

data/lib/graphql/schema/member/has_deprecation_reason.rb

@@ -5,17 +5,16 @@ module GraphQL
     class Member
       module HasDeprecationReason
         # @return [String, nil] Explains why this member was deprecated (if present, this will be marked deprecated in introspection)
-        def deprecation_reason
-          dir = self.directives.find { |d| d.is_a?(GraphQL::Schema::Directive::Deprecated) }
-          dir && dir.arguments[:reason] # rubocop:disable Development/ContextIsPassedCop -- definition-related
-        end
+        attr_reader :deprecation_reason
 
         # Set the deprecation reason for this member, or remove it by assigning `nil`
         # @param text [String, nil]
         def deprecation_reason=(text)
+          @deprecation_reason = text
           if text.nil?
             remove_directive(GraphQL::Schema::Directive::Deprecated)
           else
+            # This removes a previously-attached directive, if there is one:
             directive(GraphQL::Schema::Directive::Deprecated, reason: text)
           end
         end

data/lib/graphql/schema/member/has_directives.rb

@@ -4,6 +4,16 @@ module GraphQL
   class Schema
     class Member
       module HasDirectives
+        def self.extended(child_cls)
+          super
+          child_cls.module_exec { self.own_directives = nil }
+        end
+
+        def inherited(child_cls)
+          super
+          child_cls.own_directives = nil
+        end
+
         # Create an instance of `dir_class` for `self`, using `options`.
         #
         # It removes a previously-attached instance of `dir_class`, if there is one.
@@ -11,8 +21,7 @@ module GraphQL
         # @return [void]
         def directive(dir_class, **options)
           @own_directives ||= []
-          remove_directive(dir_class) unless dir_class.repeatable?
-          @own_directives << dir_class.new(self, **options)
+          HasDirectives.add_directive(self, @own_directives, dir_class, options)
           nil
         end
 
@@ -20,78 +29,89 @@ module GraphQL
         # @param dir_class [Class<GraphQL::Schema::Directive>]
         # @return [viod]
         def remove_directive(dir_class)
-          @own_directives && @own_directives.reject! { |d| d.is_a?(dir_class) }
+          HasDirectives.remove_directive(@own_directives, dir_class)
           nil
         end
 
-        NO_DIRECTIVES = [].freeze
-
         def directives
-          case self
-          when Class
-            inherited_directives = if superclass.respond_to?(:directives)
-              superclass.directives
-            else
-              NO_DIRECTIVES
-            end
-            if inherited_directives.any? && @own_directives
-              dirs = []
-              merge_directives(dirs, inherited_directives)
-              merge_directives(dirs, @own_directives)
-              dirs
-            elsif @own_directives
-              @own_directives
-            elsif inherited_directives.any?
-              inherited_directives
-            else
-              NO_DIRECTIVES
-            end
-          when Module
-            dirs = nil
-            self.ancestors.reverse_each do |ancestor|
-              if ancestor.respond_to?(:own_directives) &&
-                  (anc_dirs = ancestor.own_directives).any?
+          HasDirectives.get_directives(self, @own_directives, :directives)
+        end
+
+        class << self
+          def add_directive(schema_member, directives, directive_class, directive_options)
+            remove_directive(directives, directive_class) unless directive_class.repeatable?
+            directives << directive_class.new(schema_member, **directive_options)
+          end
+
+          def remove_directive(directives, directive_class)
+            directives && directives.reject! { |d| d.is_a?(directive_class) }
+          end
+
+          def get_directives(schema_member, directives, directives_method)
+            case schema_member
+            when Class
+              inherited_directives = if schema_member.superclass.respond_to?(directives_method)
+                get_directives(schema_member.superclass, schema_member.superclass.public_send(directives_method), directives_method)
+              else
+                GraphQL::EmptyObjects::EMPTY_ARRAY
+              end
+              if inherited_directives.any? && directives
+                dirs = []
+                merge_directives(dirs, inherited_directives)
+                merge_directives(dirs, directives)
+                dirs
+              elsif directives
+                directives
+              elsif inherited_directives.any?
+                inherited_directives
+              else
+                GraphQL::EmptyObjects::EMPTY_ARRAY
+              end
+            when Module
+              dirs = nil
+              schema_member.ancestors.reverse_each do |ancestor|
+                if ancestor.respond_to?(:own_directives) &&
+                    (anc_dirs = ancestor.own_directives).any?
+                  dirs ||= []
+                  merge_directives(dirs, anc_dirs)
+                end
+              end
+              if directives
                 dirs ||= []
-                merge_directives(dirs, anc_dirs)
+                merge_directives(dirs, directives)
               end
+              dirs || GraphQL::EmptyObjects::EMPTY_ARRAY
+            when HasDirectives
+              directives || GraphQL::EmptyObjects::EMPTY_ARRAY
+            else
+              raise "Invariant: how could #{schema_member} not be a Class, Module, or instance of HasDirectives?"
             end
-            if own_directives
-              dirs ||= []
-              merge_directives(dirs, own_directives)
-            end
-            dirs || NO_DIRECTIVES
-          when HasDirectives
-            @own_directives || NO_DIRECTIVES
-          else
-            raise "Invariant: how could #{self} not be a Class, Module, or instance of HasDirectives?"
           end
-        end
-
-        protected
-
-        def own_directives
-          @own_directives
-        end
 
-        private
+          private
 
-        # Modify `target` by adding items from `dirs` such that:
-        # - Any name conflict is overriden by the incoming member of `dirs`
-        # - Any other member of `dirs` is appended
-        # @param target [Array<GraphQL::Schema::Directive>]
-        # @param dirs [Array<GraphQL::Schema::Directive>]
-        # @return [void]
-        def merge_directives(target, dirs)
-          dirs.each do |dir|
-            if (idx = target.find_index { |d| d.graphql_name == dir.graphql_name })
-              target.slice!(idx)
-              target.insert(idx, dir)
-            else
-              target << dir
+          # Modify `target` by adding items from `dirs` such that:
+          # - Any name conflict is overriden by the incoming member of `dirs`
+          # - Any other member of `dirs` is appended
+          # @param target [Array<GraphQL::Schema::Directive>]
+          # @param dirs [Array<GraphQL::Schema::Directive>]
+          # @return [void]
+          def merge_directives(target, dirs)
+            dirs.each do |dir|
+              if (idx = target.find_index { |d| d.graphql_name == dir.graphql_name })
+                target.slice!(idx)
+                target.insert(idx, dir)
+              else
+                target << dir
+              end
             end
+            nil
           end
-          nil
         end
+
+        protected
+
+        attr_accessor :own_directives
       end
     end
   end