graphql 1.12.12 → 2.2.14

data/lib/graphql/static_validation/rules/query_root_exists_error.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class QueryRootExistsError < StaticValidation::Error
+
+      def initialize(message, path: nil, nodes: [])
+        super(message, path: path, nodes: nodes)
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+        }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "missingQueryConfiguration"
+      end
+    end
+  end
+end

data/lib/graphql/static_validation/rules/required_arguments_are_present.rb

@@ -8,7 +8,7 @@ module GraphQL
       end
 
       def on_directive(node, _parent)
-        directive_defn = context.schema.directives[node.name]
+        directive_defn = context.schema_directives[node.name]
         assert_required_args(node, directive_defn)
         super
       end
@@ -16,10 +16,12 @@ module GraphQL
       private
 
       def assert_required_args(ast_node, defn)
+        args = defn.arguments(context.query.context)
+        return if args.empty?
         present_argument_names = ast_node.arguments.map(&:name)
-        required_argument_names = defn.arguments.each_value
+        required_argument_names = context.warden.arguments(defn)
           .select { |a| a.type.kind.non_null? && !a.default_value? && context.warden.get_argument(defn, a.name) }
-          .map(&:name)
+          .map!(&:name)
 
         missing_names = required_argument_names - present_argument_names
         if missing_names.any?

data/lib/graphql/static_validation/rules/required_input_object_attributes_are_present.rb

@@ -34,16 +34,16 @@ module GraphQL
         parent_type = get_parent_type(context, parent)
         return unless parent_type && parent_type.kind.input_object?
 
-        required_fields = parent_type.arguments
-          .select{|k,v| v.type.kind.non_null?}
-          .keys
+        required_fields = context.warden.arguments(parent_type)
+          .select{ |arg| arg.type.kind.non_null? && !arg.default_value? }
+          .map!(&:graphql_name)
 
         present_fields = ast_node.arguments.map(&:name)
         missing_fields = required_fields - present_fields
 
         missing_fields.each do |missing_field|
           path = [*context.path, missing_field]
-          missing_field_type = parent_type.arguments[missing_field].type
+          missing_field_type = context.warden.get_argument(parent_type, missing_field).type
           add_error(RequiredInputObjectAttributesArePresentError.new(
             "Argument '#{missing_field}' on InputObject '#{parent_type.to_type_signature}' is required. Expected type #{missing_field_type.to_type_signature}",
             argument_name: missing_field,

data/lib/graphql/static_validation/rules/unique_directives_per_location.rb

@@ -34,13 +34,19 @@ module GraphQL
         used_directives = {}
         node.directives.each do |ast_directive|
           directive_name = ast_directive.name
-          if used_directives[directive_name]
-            add_error(GraphQL::StaticValidation::UniqueDirectivesPerLocationError.new(
-              "The directive \"#{directive_name}\" can only be used once at this location.",
-              nodes: [used_directives[directive_name], ast_directive],
-              directive: directive_name,
-            ))
-          else
+          if (first_node = used_directives[directive_name])
+            @directives_are_unique_errors_by_first_node ||= {}
+            err = @directives_are_unique_errors_by_first_node[first_node] ||= begin
+              error = GraphQL::StaticValidation::UniqueDirectivesPerLocationError.new(
+                "The directive \"#{directive_name}\" can only be used once at this location.",
+                nodes: [used_directives[directive_name]],
+                directive: directive_name,
+              )
+              add_error(error)
+              error
+            end
+            err.nodes << ast_directive
+          elsif !((dir_defn = context.schema_directives[directive_name]) && dir_defn.repeatable?)
             used_directives[directive_name] = ast_directive
           end
         end

data/lib/graphql/static_validation/rules/variable_default_values_are_correctly_typed.rb

@@ -23,7 +23,7 @@ module GraphQL
                 problems = validation_result.problems
                 first_problem = problems && problems.first
                 if first_problem
-                  error_message = first_problem["message"]
+                  error_message = first_problem["explanation"]
                 end
 
                 error_message ||= "Default value for $#{node.name} doesn't match type #{type.to_type_signature}"

data/lib/graphql/static_validation/rules/variable_usages_are_allowed.rb

@@ -22,15 +22,15 @@ module GraphQL
         node_values = node_values.select { |value| value.is_a? GraphQL::Language::Nodes::VariableIdentifier }
 
         if node_values.any?
-          arguments = case parent
+          argument_owner = case parent
           when GraphQL::Language::Nodes::Field
-            context.field_definition.arguments
+            context.field_definition
           when GraphQL::Language::Nodes::Directive
-            context.directive_definition.arguments
+            context.directive_definition
           when GraphQL::Language::Nodes::InputObject
             arg_type = context.argument_definition.type.unwrap
             if arg_type.kind.input_object?
-              arguments = arg_type.arguments
+              arg_type
             else
               # This is some kind of error
               nil
@@ -43,7 +43,7 @@ module GraphQL
             var_defn_ast = @declared_variables[node_value.name]
             # Might be undefined :(
             # VariablesAreUsedAndDefined can't finalize its search until the end of the document.
-            var_defn_ast && arguments && validate_usage(arguments, node, var_defn_ast)
+            var_defn_ast && argument_owner && validate_usage(argument_owner, node, var_defn_ast)
           end
         end
         super
@@ -51,7 +51,7 @@ module GraphQL
 
       private
 
-      def validate_usage(arguments, arg_node, ast_var)
+      def validate_usage(argument_owner, arg_node, ast_var)
         var_type = context.schema.type_from_ast(ast_var.type, context: context)
         if var_type.nil?
           return
@@ -65,9 +65,15 @@ module GraphQL
           end
         end
 
-        arg_defn = arguments[arg_node.name]
+        arg_defn = context.warden.get_argument(argument_owner, arg_node.name)
         arg_defn_type = arg_defn.type
 
+        # If the argument is non-null, but it was given a default value,
+        # then treat it as nullable in practice, see https://github.com/rmosolgo/graphql-ruby/issues/3793
+        if arg_defn_type.non_null? && arg_defn.default_value?
+          arg_defn_type = arg_defn_type.of_type
+        end
+
         var_inner_type = var_type.unwrap
         arg_inner_type = arg_defn_type.unwrap
 

data/lib/graphql/static_validation/validation_context.rb

@@ -8,21 +8,23 @@ module GraphQL
     # It provides access to the schema & fragments which validators may read from.
     #
     # It holds a list of errors which each validator may add to.
-    #
-    # It also provides limited access to the {TypeStack} instance,
-    # which tracks state as you climb in and out of different fields.
     class ValidationContext
       extend Forwardable
 
       attr_reader :query, :errors, :visitor,
-        :on_dependency_resolve_handlers
+        :on_dependency_resolve_handlers,
+        :max_errors, :warden, :schema
+
 
-      def_delegators :@query, :schema, :document, :fragments, :operations, :warden
+      def_delegators :@query, :document, :fragments, :operations
 
-      def initialize(query, visitor_class)
+      def initialize(query, visitor_class, max_errors)
         @query = query
+        @warden = query.warden
+        @schema = query.schema
         @literal_validator = LiteralValidator.new(context: query.context)
         @errors = []
+        @max_errors = max_errors || Float::INFINITY
         @on_dependency_resolve_handlers = []
         @visitor = visitor_class.new(document, self)
       end
@@ -38,6 +40,14 @@ module GraphQL
       def validate_literal(ast_value, type)
         @literal_validator.validate(ast_value, type)
       end
+
+      def too_many_errors?
+        @errors.length >= @max_errors
+      end
+
+      def schema_directives
+        @schema_directives ||= schema.directives
+      end
     end
   end
 end

data/lib/graphql/static_validation/validator.rb

@@ -24,35 +24,26 @@ module GraphQL
       # @param query [GraphQL::Query]
       # @param validate [Boolean]
       # @param timeout [Float] Number of seconds to wait before aborting validation. Any positive number may be used, including Floats to specify fractional seconds.
+      # @param max_errors [Integer] Maximum number of errors before aborting validation. Any positive number will limit the number of errors. Defaults to nil for no limit.
       # @return [Array<Hash>]
-      def validate(query, validate: true, timeout: nil)
-        query.trace("validate", { validate: validate, query: query }) do
-          can_skip_rewrite = query.context.interpreter? && query.schema.using_ast_analysis? && query.schema.is_a?(Class)
-          errors = if validate == false && can_skip_rewrite
+      def validate(query, validate: true, timeout: nil, max_errors: nil)
+        query.current_trace.validate(validate: validate, query: query) do
+          begin_t = Time.now
+          errors = if validate == false
             []
           else
             rules_to_use = validate ? @rules : []
-            visitor_class = BaseVisitor.including_rules(rules_to_use, rewrite: !can_skip_rewrite)
+            visitor_class = BaseVisitor.including_rules(rules_to_use)
 
-            context = GraphQL::StaticValidation::ValidationContext.new(query, visitor_class)
+            context = GraphQL::StaticValidation::ValidationContext.new(query, visitor_class, max_errors)
 
             begin
               # CAUTION: Usage of the timeout module makes the assumption that validation rules are stateless Ruby code that requires no cleanup if process was interrupted. This means no blocking IO calls, native gems, locks, or `rescue` clauses that must be reached.
               # A timeout value of 0 or nil will execute the block without any timeout.
               Timeout::timeout(timeout) do
-                # Attach legacy-style rules.
-                # Only loop through rules if it has legacy-style rules
-                unless (legacy_rules = rules_to_use - GraphQL::StaticValidation::ALL_RULES).empty?
-                  legacy_rules.each do |rule_class_or_module|
-                    if rule_class_or_module.method_defined?(:validate)
-                      GraphQL::Deprecation.warn "Legacy validator rules will be removed from GraphQL-Ruby 2.0, use a module instead (see the built-in rules: https://github.com/rmosolgo/graphql-ruby/tree/master/lib/graphql/static_validation/rules)"
-                      GraphQL::Deprecation.warn "  -> Legacy validator: #{rule_class_or_module}"
-                      rule_class_or_module.new.validate(context)
-                    end
-                  end
+                catch(:too_many_validation_errors) do
+                  context.visitor.visit
                 end
-
-                context.visitor.visit
               end
             rescue Timeout::Error
               handle_timeout(query, context)
@@ -61,22 +52,15 @@ module GraphQL
             context.errors
           end
 
-          irep = if errors.empty? && context
-            # Only return this if there are no errors and validation was actually run
-            context.visitor.rewrite_document
-          else
-            nil
-          end
-
           {
+            remaining_timeout: timeout ? (timeout - (Time.now - begin_t)) : nil,
             errors: errors,
-            irep: irep,
           }
         end
       rescue GraphQL::ExecutionError => e
         {
+          remaining_timeout: nil,
           errors: [e],
-          irep: nil,
         }
       end
 

data/lib/graphql/static_validation.rb

@@ -1,13 +1,11 @@
 # frozen_string_literal: true
 require "graphql/static_validation/error"
 require "graphql/static_validation/definition_dependencies"
-require "graphql/static_validation/type_stack"
 require "graphql/static_validation/validator"
 require "graphql/static_validation/validation_context"
 require "graphql/static_validation/validation_timeout_error"
 require "graphql/static_validation/literal_validator"
 require "graphql/static_validation/base_visitor"
-require "graphql/static_validation/no_validate_visitor"
 
 rules_glob = File.expand_path("../static_validation/rules/*.rb", __FILE__)
 Dir.glob(rules_glob).each do |file|
@@ -15,5 +13,4 @@ Dir.glob(rules_glob).each do |file|
 end
 
 require "graphql/static_validation/all_rules"
-require "graphql/static_validation/default_visitor"
 require "graphql/static_validation/interpreter_visitor"

data/lib/graphql/string_encoding_error.rb

@@ -1,10 +1,20 @@
 # frozen_string_literal: true
 module GraphQL
   class StringEncodingError < GraphQL::RuntimeTypeError
-    attr_reader :string
-    def initialize(str)
+    attr_reader :string, :field, :path
+    def initialize(str, context:)
       @string = str
-      super("String \"#{str}\" was encoded as #{str.encoding}! GraphQL requires an encoding compatible with UTF-8.")
+      @field = context[:current_field]
+      @path = context[:current_path]
+      message = "String #{str.inspect} was encoded as #{str.encoding}".dup
+      if @path
+        message << " @ #{@path.join(".")}"
+      end
+      if @field
+        message << " (#{@field.path})"
+      end
+      message << ". GraphQL requires an encoding compatible with UTF-8."
+      super(message)
     end
   end
 end

data/lib/graphql/subscriptions/action_cable_subscriptions.rb

@@ -35,7 +35,7 @@ module GraphQL
     #       }
     #
     #       result = MySchema.execute(
-    #         query: query,
+    #         query,
     #         context: context,
     #         variables: variables,
     #         operation_name: operation_name
@@ -91,10 +91,24 @@ module GraphQL
         # A per-process map of subscriptions to deliver.
         # This is provided by Rails, so let's use it
         @subscriptions = Concurrent::Map.new
-        @events = Concurrent::Map.new { |h, k| h[k] = Concurrent::Map.new { |h2, k2| h2[k2] = Concurrent::Array.new } }
+        @events = Concurrent::Map.new do |h, k|
+          h.compute_if_absent(k) do
+            Concurrent::Map.new do |h2, k2|
+              h2.compute_if_absent(k2) { Concurrent::Array.new }
+            end
+          end
+        end
         @action_cable = action_cable
         @action_cable_coder = action_cable_coder
         @serializer = serializer
+        @serialize_with_context = case @serializer.method(:load).arity
+        when 1
+          false
+        when 2
+          true
+        else
+          raise ArgumentError, "#{@serializer} must repond to `.load` accepting one or two arguments"
+        end
         @transmit_ns = namespace
         super
       end
@@ -110,7 +124,8 @@ module GraphQL
       # This subscription was re-evaluated.
       # Send it to the specific stream where this client was waiting.
       def deliver(subscription_id, result)
-        payload = { result: result.to_h, more: true }
+        has_more = !result.context.namespace(:subscriptions)[:final_update]
+        payload = { result: result.to_h, more: has_more }
         @action_cable.server.broadcast(stream_subscription_name(subscription_id), payload)
       end
 
@@ -119,7 +134,13 @@ module GraphQL
       # It will receive notifications when events come in
       # and re-evaluate the query locally.
       def write_subscription(query, events)
-        channel = query.context.fetch(:channel)
+        unless (channel = query.context[:channel])
+          raise GraphQL::Error, "This GraphQL Subscription client does not support the transport protocol expected"\
+            "by the backend Subscription Server implementation (graphql-ruby ActionCableSubscriptions in this case)."\
+            "Some official client implementation including Apollo (https://graphql-ruby.org/javascript_client/apollo_subscriptions.html), "\
+            "Relay Modern (https://graphql-ruby.org/javascript_client/relay_subscriptions.html#actioncable)."\
+            "GraphiQL via `graphiql-rails` may not work out of box (#1051)."
+        end
         subscription_id = query.context[:subscription_id] ||= build_id
         stream = stream_subscription_name(subscription_id)
         channel.stream_from(stream)
@@ -154,12 +175,14 @@ module GraphQL
               # so just run it once, then deliver the result to every subscriber
               first_event = events.first
               first_subscription_id = first_event.context.fetch(:subscription_id)
-              object ||= @serializer.load(message)
+              object ||= load_action_cable_message(message, first_event.context)
               result = execute_update(first_subscription_id, first_event, object)
-              # Having calculated the result _once_, send the same payload to all subscribers
-              events.each do |event|
-                subscription_id = event.context.fetch(:subscription_id)
-                deliver(subscription_id, result)
+              if !result.nil?
+                # Having calculated the result _once_, send the same payload to all subscribers
+                events.each do |event|
+                  subscription_id = event.context.fetch(:subscription_id)
+                  deliver(subscription_id, result)
+                end
               end
             end
           end
@@ -167,6 +190,18 @@ module GraphQL
         end
       end
 
+      # This is called to turn an ActionCable-broadcasted string (JSON)
+      # into a query-ready application object.
+      # @param message [String] n ActionCable-broadcasted string (JSON)
+      # @param context [GraphQL::Query::Context] the context of the first event for a given subscription fingerprint
+      def load_action_cable_message(message, context)
+        if @serialize_with_context
+          @serializer.load(message, context)
+        else
+          @serializer.load(message)
+        end
+      end
+
       # Return the query from "storage" (in memory)
       def read_subscription(subscription_id)
         query = @subscriptions[subscription_id]
@@ -188,6 +223,8 @@ module GraphQL
       # The channel was closed, forget about it.
       def delete_subscription(subscription_id)
         query = @subscriptions.delete(subscription_id)
+        # In case this came from the server, tell the client to unsubscribe:
+        @action_cable.server.broadcast(stream_subscription_name(subscription_id), { more: false })
         # This can be `nil` when `.trigger` happens inside an unsubscribed ActionCable channel,
         # see https://github.com/rmosolgo/graphql-ruby/issues/2478
         if query

data/lib/graphql/subscriptions/default_subscription_resolve_extension.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 module GraphQL
   class Subscriptions
-    class DefaultSubscriptionResolveExtension < GraphQL::Subscriptions::SubscriptionRoot::Extension
+    class DefaultSubscriptionResolveExtension < GraphQL::Schema::FieldExtension
       def resolve(context:, object:, arguments:)
         has_override_implementation = @field.resolver ||
           object.respond_to?(@field.resolver_method)
@@ -16,6 +16,43 @@ module GraphQL
           yield(object, arguments)
         end
       end
+
+      def after_resolve(value:, context:, object:, arguments:, **rest)
+        if value.is_a?(GraphQL::ExecutionError)
+          value
+        elsif (events = context.namespace(:subscriptions)[:events])
+          # This is the first execution, so gather an Event
+          # for the backend to register:
+          event = Subscriptions::Event.new(
+            name: field.name,
+            arguments: arguments_without_field_extras(arguments: arguments),
+            context: context,
+            field: field,
+          )
+          events << event
+          value
+        elsif context.query.subscription_topic == Subscriptions::Event.serialize(
+            field.name,
+            arguments_without_field_extras(arguments: arguments),
+            field,
+            scope: (field.subscription_scope ? context[field.subscription_scope] : nil),
+          )
+          # This is a subscription update. The resolver returned `skip` if it should be skipped,
+          # or else it returned an object to resolve the update.
+          value
+        else
+          # This is a subscription update, but this event wasn't triggered.
+          context.skip
+        end
+      end
+
+      private
+
+      def arguments_without_field_extras(arguments:)
+        arguments.dup.tap do |event_args|
+          field.extras.each { |k| event_args.delete(k) }
+        end
+      end
     end
   end
 end

data/lib/graphql/subscriptions/event.rb

@@ -9,7 +9,7 @@ module GraphQL
       # @return [String] Corresponds to the Subscription root field name
       attr_reader :name
 
-      # @return [GraphQL::Query::Arguments]
+      # @return [GraphQL::Execution::Interpreter::Arguments]
       attr_reader :arguments
 
       # @return [GraphQL::Query::Context]
@@ -23,32 +23,24 @@ module GraphQL
         @arguments = arguments
         @context = context
         field ||= context.field
-        scope_val = scope || (context && field.subscription_scope && context[field.subscription_scope])
+        scope_key = field.subscription_scope
+        scope_val = scope || (context && scope_key && context[scope_key])
+        if scope_key &&
+            (subscription = field.resolver) &&
+            (subscription.respond_to?(:subscription_scope_optional?)) &&
+            !subscription.subscription_scope_optional? &&
+            scope_val.nil?
+          raise Subscriptions::SubscriptionScopeMissingError, "#{field.path} (#{subscription}) requires a `scope:` value to trigger updates (Set `subscription_scope ..., optional: true` to disable this requirement)"
+        end
 
-        @topic = self.class.serialize(name, arguments, field, scope: scope_val)
+        @topic = self.class.serialize(name, arguments, field, scope: scope_val, context: context)
       end
 
       # @return [String] an identifier for this unit of subscription
-      def self.serialize(name, arguments, field, scope:)
-        normalized_args = case arguments
-        when GraphQL::Query::Arguments
-          arguments
-        when Hash
-          if field.is_a?(GraphQL::Schema::Field)
-            stringify_args(field, arguments)
-          else
-            GraphQL::Query::LiteralInput.from_arguments(
-              arguments,
-              field,
-              nil,
-            )
-          end
-        else
-          raise ArgumentError, "Unexpected arguments: #{arguments}, must be Hash or GraphQL::Arguments"
-        end
-
-        sorted_h = stringify_args(field, normalized_args.to_h)
-        Serialize.dump_recursive([scope, name, sorted_h])
+      def self.serialize(_name, arguments, field, scope:, context: GraphQL::Query::NullContext.instance)
+        subscription = field.resolver || GraphQL::Schema::Subscription
+        normalized_args = stringify_args(field, arguments.to_h, context)
+        subscription.topic_for(arguments: normalized_args, field: field, scope: scope)
       end
 
       # @return [String] a logical identifier for this event. (Stable when the query is broadcastable.)
@@ -69,37 +61,83 @@ module GraphQL
 
       class << self
         private
-        def stringify_args(arg_owner, args)
+
+        # This method does not support cyclic references in the Hash,
+        # nor does it support Hashes whose keys are not sortable
+        # with respect to their peers ( cases where a <=> b might throw an error )
+        def deep_sort_hash_keys(hash_to_sort)
+          raise ArgumentError.new("Argument must be a Hash") unless hash_to_sort.is_a?(Hash)
+          hash_to_sort.keys.sort.map do |k|
+            if hash_to_sort[k].is_a?(Hash)
+              [k, deep_sort_hash_keys(hash_to_sort[k])]
+            elsif hash_to_sort[k].is_a?(Array)
+              [k, deep_sort_array_hashes(hash_to_sort[k])]
+            else
+              [k, hash_to_sort[k]]
+            end
+          end.to_h
+        end
+
+        def deep_sort_array_hashes(array_to_inspect)
+          raise ArgumentError.new("Argument must be an Array") unless array_to_inspect.is_a?(Array)
+          array_to_inspect.map do |v|
+            if v.is_a?(Hash)
+              deep_sort_hash_keys(v)
+            elsif v.is_a?(Array)
+              deep_sort_array_hashes(v)
+            else
+              v
+            end
+          end
+        end
+
+        def stringify_args(arg_owner, args, context)
+          arg_owner = arg_owner.respond_to?(:unwrap) ? arg_owner.unwrap : arg_owner # remove list and non-null wrappers
           case args
           when Hash
             next_args = {}
             args.each do |k, v|
               arg_name = k.to_s
               camelized_arg_name = GraphQL::Schema::Member::BuildType.camelize(arg_name)
-              arg_defn = get_arg_definition(arg_owner, camelized_arg_name)
-
-              if arg_defn
-                normalized_arg_name = camelized_arg_name
+              arg_defn = get_arg_definition(arg_owner, camelized_arg_name, context)
+              arg_defn ||= get_arg_definition(arg_owner, arg_name, context)
+              normalized_arg_name = arg_defn.graphql_name
+              arg_base_type = arg_defn.type.unwrap
+              # In the case where the value being emitted is seen as a "JSON"
+              # type, treat the value as one atomic unit of serialization
+              is_json_definition = arg_base_type && arg_base_type <= GraphQL::Types::JSON
+              if is_json_definition
+                sorted_value = if v.is_a?(Hash)
+                  deep_sort_hash_keys(v)
+                elsif v.is_a?(Array)
+                  deep_sort_array_hashes(v)
+                else
+                  v
+                end
+                next_args[normalized_arg_name] = sorted_value.respond_to?(:to_json) ? sorted_value.to_json : sorted_value
               else
-                normalized_arg_name = arg_name
-                arg_defn = get_arg_definition(arg_owner, normalized_arg_name)
+                next_args[normalized_arg_name] = stringify_args(arg_base_type, v, context)
               end
-
-              next_args[normalized_arg_name] = stringify_args(arg_defn.type, v)
             end
             # Make sure they're deeply sorted
             next_args.sort.to_h
           when Array
-            args.map { |a| stringify_args(arg_owner, a) }
+            args.map { |a| stringify_args(arg_owner, a, context) }
           when GraphQL::Schema::InputObject
-            stringify_args(arg_owner, args.to_h)
+            stringify_args(arg_owner, args.to_h, context)
           else
-            args
+            if arg_owner.is_a?(Class) && arg_owner < GraphQL::Schema::Enum
+              # `prepare:` may have made the value something other than
+              # a defined value of this enum -- use _that_ in this case.
+              arg_owner.coerce_isolated_input(args) || args
+            else
+              args
+            end
           end
         end
 
-        def get_arg_definition(arg_owner, arg_name)
-          arg_owner.arguments[arg_name] || arg_owner.arguments.each_value.find { |v| v.keyword.to_s == arg_name }
+        def get_arg_definition(arg_owner, arg_name, context)
+          arg_owner.get_argument(arg_name, context) || arg_owner.arguments(context).each_value.find { |v| v.keyword.to_s == arg_name }
         end
       end
     end