grape 4.0.0 → 4.1.0

data/lib/grape/validations/attributes_iterator.rb

@@ -2,37 +2,76 @@
 
 module Grape
   module Validations
+    # Yields each value a scope's attributes are read from: the scope's params,
+    # or each element of them when the scope sits in an Array. Walking the
+    # attributes themselves is left to the validator's block.
+    #
+    # Each value comes with whether it is an element a request sent in the
+    # scope's own Array. Otherwise it is the scope's value in an element of an
+    # Array further up, where an empty one is an optional scope left out of
+    # that element, or an element of an optional scope's Array whose elements
+    # are all empty, which is passed over the same way.
     class AttributesIterator
-      # +attrs+ and +scope+ are static per validator; only +params+ varies
-      # per request, so an instance can be built once and reused (it keeps
-      # no request-derived state). Reused instances are shared across
-      # threads, so +each+ must stay free of mutable instance state.
-      def initialize(attrs, scope)
-        @attrs = attrs
+      # +scope+ is static per validator; only +params+ varies per request, so
+      # an instance can be built once and reused (it keeps no request-derived
+      # state). Reused instances are shared across threads, so +each+ must
+      # stay free of mutable instance state.
+      def initialize(scope)
         @scope = scope
         # How many times #do_each may descend into a nested array. The
         # declaration allows one level per Array-typed scope on the chain, less
         # the one +Array.wrap+ already consumes in #each. Anything deeper was
         # put there by the request, not by the declaration.
         @max_nesting = [scope.array_depth - 1, 0].max
+        @iterates_elements = scope.iterates_elements?
+        @optional = !scope.required?
       end
 
       def each(params, &)
         original_params = @scope.params(params)
+        iterates_elements = @scope.iterates_elements?
         # A scope resolves to a Hash unless the declaration nests arrays, and
         # then #do_each has nothing to do but hand it straight back: Array.wrap
         # boxes it, the loop unboxes it on its only iteration, and with no Array
         # anywhere neither the nesting descent nor the index bookkeeping
         # applies. Every validator on a flat +params+ block comes through here.
-        return yield_attributes(original_params, &) if original_params.is_a?(Hash) && !@scope.iterates_elements?
+        return yield(original_params) if original_params.is_a?(Hash) && !iterates_elements
+
+        array_params = original_params.is_a?(Array)
+        # Do not validate the content of an array scope that did not get one.
+        return if iterates_elements && !array_params
+
+        index_scope = index_scope_for(iterates_elements, array_params)
+        # No tracker means we're outside a ParamScopeTracker.track block (e.g.
+        # a unit test that invokes a validator directly). Index tracking is
+        # skipped — full_name will produce bracket-less names — but validation
+        # continues rather than crashing.
+        tracker = ParamScopeTracker.current if index_scope
 
         # because we need recursion for nested arrays
-        do_each(Array.wrap(original_params), original_params, &)
+        params_to_process = Array.wrap(original_params)
+        do_each(params_to_process, tracker, index_scope, NO_PARENT_INDICES, sent_elements?(params_to_process, NO_PARENT_INDICES), &)
       end
 
       private
 
-      def do_each(params_to_process, original_params, parent_indices = [], &block)
+      # The top-level call's parent indices; only ever read.
+      NO_PARENT_INDICES = [].freeze
+      private_constant :NO_PARENT_INDICES
+
+      # Where each element's index is recorded depends on the scope and on
+      # whether its params are an Array, never on the element, so it is
+      # settled once per #each rather than per element. A lateral scope (no
+      # @element) whose params resolved to an array hands its index to the
+      # nearest element-iterating ancestor, so full_name still produces the
+      # right bracketed index.
+      def index_scope_for(iterates_elements, array_params)
+        return @scope if iterates_elements
+
+        @scope.nearest_array_ancestor if array_params
+      end
+
+      def do_each(params_to_process, tracker, index_scope, parent_indices, sent_elements, &)
         params_to_process.each_with_index do |resource_params, index|
           # when we get arrays of arrays it means that target element located inside array
           # we need this because we want to know parent arrays indices
@@ -42,52 +81,49 @@ module Grape
           # validators see a non-hash and fail it the same way any other
           # unexpected element type does.
           if resource_params.is_a?(Array) && parent_indices.size < @max_nesting
-            do_each(resource_params, original_params, [index] + parent_indices, &block)
+            nested_indices = [index] + parent_indices
+            do_each(resource_params, tracker, index_scope, nested_indices, sent_elements?(resource_params, nested_indices), &)
             next
           end
 
-          if @scope.iterates_elements?
-            next unless original_params.is_a?(Array) # do not validate content of array if it isn't array
+          store_indices(tracker, index_scope, index, parent_indices) if tracker
+          yield resource_params, sent_elements unless skip?(resource_params)
+        end
+      end
 
-            store_indices(@scope, index, parent_indices)
-          elsif original_params.is_a?(Array)
-            # Lateral scope (no @element) whose params resolved to an array —
-            # delegate index tracking to the nearest element-iterating ancestor
-            # so that full_name produces the correct bracketed index.
-            target = @scope.nearest_array_ancestor
-            store_indices(target, index, parent_indices) if target
-          end
+      # Whether +values+, reached through +parent_indices+, are elements of the
+      # scope's own Array that were sent. An optional scope's Array whose
+      # elements are all empty is passed over, as the scope itself is when it
+      # is left out (see ParamsScope#should_validate?, which answers that for
+      # the Array at the root). Checked once per Array rather than per element.
+      def sent_elements?(values, parent_indices)
+        @iterates_elements && parent_indices.size == @max_nesting && !(@optional && values.all? { |value| empty?(value) })
+      end
 
-          yield_attributes(resource_params, &block)
-        end
+      # Primitives like Integers and Booleans don't respond to +empty?+.
+      def empty?(value)
+        value.respond_to?(:empty?) ? value.empty? : value.nil?
       end
 
-      def store_indices(target_scope, index, parent_indices)
-        # No tracker means we're outside a ParamScopeTracker.track block (e.g.
-        # a unit test that invokes a validator directly). Index tracking is
-        # skipped — full_name will produce bracket-less names — but validation
-        # continues rather than crashing.
-        tracker = ParamScopeTracker.current or return
-        parent_scope = target_scope.parent
+      # Each parent index belongs to the next element-iterating scope up the
+      # chain, which a Hash scope may sit below. There is always one:
+      # +parent_indices+ holds at most +array_depth - 1+ entries, and
+      # +target_scope+ has that many iterating ancestors.
+      def store_indices(tracker, target_scope, index, parent_indices)
+        parent_scope = target_scope.nearest_array_ancestor
         parent_indices.each do |parent_index|
-          break unless parent_scope
-
           tracker.store_index(parent_scope, parent_index)
-          parent_scope = parent_scope.parent
+          parent_scope = parent_scope.nearest_array_ancestor
         end
         tracker.store_index(target_scope, index)
       end
 
-      def yield_attributes(_resource_params)
-        raise NotImplementedError
-      end
-
       # This is a special case so that we can ignore trees where option
       # values are missing lower down. Unfortunately we can't remove this
       # at the parameter parsing stage as they are required to ensure
       # the correct indexing is maintained
       def skip?(val)
-        val == Grape::DSL::Parameters::EmptyOptionalValue
+        ParamsScope::EmptyOptionalValue.equal?(val)
       end
     end
   end

data/lib/grape/validations/coerce_options.rb

@@ -6,7 +6,7 @@ module Grape
     # by {ValidationsSpec#coerce_options} from the parsed +type+/+coerce_with+/
     # +coerce_message+ declaration — never written by the user — and consumed
     # by {ParamsScope#check_coerce_with} / {ParamsScope#validate_coerce} and by
-    # {Validators::Validators::CoerceValidator} (which receives it as its
+    # {Validators::CoerceValidator} (which receives it as its
     # +options+ argument).
     #
     # All three fields may be +nil+ (e.g. a remountable API evaluated on its

data/lib/grape/validations/params_documentation.rb

@@ -17,26 +17,34 @@ module Grape
       private
 
       def extract_details(spec)
-        details = {}
-        details[:required] = spec.required?
+        details = { required: spec.required? }
         details[:type] = TypeCache[spec.coerce_type] if spec.coerce_type
+        add_value_details(details, spec)
+        add_raw_details(details, spec.raw)
+        details
+      end
+
+      # The values the declaration accepts, rejects and defaults to.
+      def add_value_details(details, spec)
         details[:values] = spec.values if spec.values
         details[:except_values] = spec.except_values if spec.except_values
         details[:default] = spec.default unless spec.default.nil?
+      end
 
-        length = spec.raw[:length]
+      # What the declaration's own options document beyond its validations:
+      # the +length+ bounds, the description and the +documentation+ Hash.
+      def add_raw_details(details, raw)
+        length = raw[:length]
         if length.is_a?(Hash)
           details[:min_length] = length[:min] if length.key?(:min)
           details[:max_length] = length[:max] if length.key?(:max)
         end
 
-        desc = spec.raw[:desc] || spec.raw[:description]
+        desc = raw[:desc] || raw[:description]
         details[:desc] = desc if desc
 
-        documentation = spec.raw[:documentation]
+        documentation = raw[:documentation]
         details[:documentation] = documentation if documentation
-
-        details
       end
 
       class TypeCache < Grape::Util::Cache

data/lib/grape/validations/params_scope.rb

@@ -5,10 +5,35 @@ module Grape
     class ParamsScope
       attr_reader :parent, :type, :nearest_array_ancestor, :array_depth, :full_path
 
+      # The elements a +given+ scope narrowed its Array params down to during
+      # this request (see #meets_dependency?). Only a scope with a dependency
+      # ever stores any, so every other scope answers without the fiber-storage
+      # and tracker lookups -- which #params pays on each nested resolution,
+      # twice per validator, on every request.
       def qualifying_params
+        return unless @dependent_on
+
         ParamScopeTracker.current&.qualifying_params(self)
       end
 
+      # @param params [Hash] initial hash of parameters
+      # @return hash of parameters relevant for the current scope
+      # @api private
+      # Only a +given+ scope ever stores qualifying params, and a scope on an
+      # independent chain has none above it (see #independent?), so the
+      # lookup and the +presence+ test that follows it are skipped -- both of
+      # them, at every level, on every call.
+      def params(params)
+        scoped = if @parent.nil?
+                   params
+                 elsif @independent
+                   @parent.params(params)
+                 else
+                   @parent.qualifying_params.presence || @parent.params(params)
+                 end
+        @element ? map_params(scoped, @element) : scoped
+      end
+
       include Grape::DSL::Parameters
       include Grape::Validations::ParamsDocumentation
 
@@ -19,6 +44,19 @@ module Grape
 
       SPECIAL_JSON = [JSON, Array[JSON]].freeze
 
+      # What {#validated_params} returns for a scope that should not be
+      # validated. A plain +false+ would be indistinguishable from params of
+      # that value, which +map_params+ can hand back for an element a request
+      # set to +false+.
+      NOT_VALIDATED = Object.new.freeze
+      private_constant :NOT_VALIDATED
+
+      # What {#params} hands back for an element of an Array that left an
+      # optional scope out, in place of that scope's params. Dropping the
+      # element instead would shift the indices the errors name, so it stays,
+      # and AttributesIterator and the validators pass over it.
+      EmptyOptionalValue = Object.new.freeze
+
       class Attr
         attr_reader :key, :scope
 
@@ -50,7 +88,7 @@ module Grape
       end
 
       # Open up a new ParamsScope, allowing parameter definitions per
-      #   Grape::DSL::Params.
+      #   Grape::DSL::Parameters.
       # @param api [API] the API endpoint to modify
       # @param element [Symbol] the element that contains this scope; for
       #   this to be relevant, parent must be set
@@ -59,10 +97,10 @@ module Grape
       # @param parent [ParamsScope] the scope containing this scope
       # @param optional [Boolean] whether or not this scope needs to have
       #   any parameters set or not
-      # @param type [Class] a type meant to govern this scope (deprecated)
-      # @param type [Hash] group options for this scope
-      # @param dependent_on [Symbol] if present, this scope should only
-      #   validate if this param is present in the parent scope
+      # @param type [Class] a type meant to govern this scope
+      # @param group [Hash] group options for this scope
+      # @param dependent_on [Array<Symbol, Hash>] if present, this scope should
+      #   only validate if these params are present in the parent scope
       # @yield the instance context, open for parameter definitions
       def initialize(api:, element: nil, element_renamed: nil, parent: nil, optional: false, type: nil, group: nil, dependent_on: nil, &block)
         @element          = element
@@ -73,6 +111,9 @@ module Grape
         @type             = type
         @group            = group
         @dependent_on     = dependent_on
+        # See #independent?. Settled here because a scope's block may declare
+        # children, and each of them asks its parent.
+        @independent      = !dependent_on && (parent.nil? || parent.independent?)
         # Must be an ivar: push_declared_params is dispatched on self during
         # instance_eval, so local variables from initialize are unreachable.
         # configure_declared_params consumes it and clears @declared_params to nil.
@@ -97,23 +138,35 @@ module Grape
       # @return [Boolean] whether or not this entire scope needs to be
       #   validated
       def should_validate?(parameters)
+        return !NOT_VALIDATED.equal?(validated_params(parameters)) if @independent
+
         scoped_params = params(parameters)
 
-        return false if @optional && (scoped_params.blank? || all_element_blank?(scoped_params))
+        return false if @optional && (Grape::Util::Scrub.blank?(scoped_params) || all_element_blank?(scoped_params))
         return false unless meets_dependency?(scoped_params, parameters)
-        return true if @parent.nil?
 
+        # Past the +@independent+ return, this scope or one above it is a
+        # +given+ scope, and a +given+ scope is always nested: there is a parent.
         @parent.should_validate?(parameters)
       end
 
+      # Whether this scope and every scope above it declare no dependency, so
+      # #should_validate? has nothing to ask but whether each of them was given
+      # params -- and +qualifying_params+, which only a +given+ scope ever
+      # stores, cannot stand in for any of them.
+      # @return [Boolean]
+      def independent?
+        @independent
+      end
+
       def meets_dependency?(params, request_params)
         return true unless @dependent_on
-        return false if @parent.present? && !@parent.meets_dependency?(@parent.params(request_params), request_params)
+        return false if @parent && !@parent.meets_dependency?(@parent.params(request_params), request_params)
 
         if params.is_a?(Array)
           filtered = params.flatten.filter { |param| meets_dependency?(param, request_params) }
           ParamScopeTracker.current&.store_qualifying_params(self, filtered)
-          return filtered.present?
+          return !filtered.empty?
         end
 
         meets_hash_dependency?(params)
@@ -121,7 +174,7 @@ module Grape
 
       def attr_meets_dependency?(params)
         return true unless @dependent_on
-        return false if @parent.present? && !@parent.attr_meets_dependency?(params)
+        return false if @parent && !@parent.attr_meets_dependency?(params)
 
         meets_hash_dependency?(params)
       end
@@ -135,7 +188,7 @@ module Grape
             key, callable = dependency.first
             callable.call(params[key])
           else
-            params[dependency].present?
+            !Grape::Util::Scrub.blank?(params[dependency])
           end
         end
       end
@@ -166,6 +219,23 @@ module Grape
         !@parent
       end
 
+      # Whether #should_validate? answers true for every request: this scope
+      # and each of its ancestors is required and depends on nothing, so
+      # neither the params nor the parent chain have anything to say.
+      # @return [Boolean]
+      def always_validated?
+        !@optional && validated_when_given?
+      end
+
+      # Whether #should_validate? has nothing to ask but whether this scope's
+      # own params were given: it depends on no other param, and every scope
+      # above it is always validated. A required scope like that is then
+      # always validated, an optional one whenever its params are there.
+      # @return [Boolean]
+      def validated_when_given?
+        !@dependent_on && (@parent.nil? || @parent.always_validated?)
+      end
+
       # A nested scope is contained in one of its parent's elements.
       # @return [Boolean] whether or not this scope is nested
       def nested?
@@ -198,6 +268,29 @@ module Grape
 
       protected
 
+      # This scope's params, once it and every scope above it has been found
+      # worth validating; NOT_VALIDATED as soon as one of them is not.
+      #
+      # Only for an independent chain (see #independent?), where every scope
+      # answers from its own params alone: each one is then resolved from the
+      # one above rather than from the root, so the walk costs one +map_params+
+      # per scope instead of one per scope per level. Nothing here has a side
+      # effect, so checking from the root down rather than from here up reaches
+      # the same answer.
+      def validated_params(parameters)
+        if @parent
+          scoped = @parent.validated_params(parameters)
+          return scoped if NOT_VALIDATED.equal?(scoped)
+
+          scoped = map_params(scoped, @element) if @element
+        else
+          scoped = parameters
+        end
+        return NOT_VALIDATED if @optional && (Grape::Util::Scrub.blank?(scoped) || all_element_blank?(scoped))
+
+        scoped
+      end
+
       # Adds a parameter declaration to our list of validations.
       # @param attrs [Array] (see Grape::DSL::Parameters#requires)
       # +declared_params_scope+ is the scope an attribute is recorded against.
@@ -214,6 +307,28 @@ module Grape
 
       private
 
+      def map_params(params, element, is_array: false)
+        case params
+        when Array
+          params.map do |el|
+            map_params(el, element, is_array: true)
+          end
+        when Hash
+          params[element] || missing_element(is_array)
+        when EmptyOptionalValue
+          EmptyOptionalValue
+        else
+          {}
+        end
+      end
+
+      # What a Hash without the element maps to: EmptyOptionalValue for an
+      # optional scope's element of an Array, which the validators pass over,
+      # and an empty Hash otherwise.
+      def missing_element(is_array)
+        @optional && is_array ? EmptyOptionalValue : {}
+      end
+
       def build_full_path
         return @parent.full_path + [@element] if nested?
         return @parent.full_path if lateral?
@@ -249,10 +364,7 @@ module Grape
 
           requires(field, **field_opts)
         end
-        optional_fields.each do |field|
-          field_opts = using[field]
-          optional(field, **field_opts) if field_opts
-        end
+        declare_optional_fields(optional_fields, using)
       end
 
       def require_optional_fields(context, using:, except: nil)
@@ -261,7 +373,13 @@ module Grape
           except_fields = Array.wrap(except)
           optional_fields.delete_if { |f| except_fields.include?(f) }
         end
-        optional_fields.each do |field|
+        declare_optional_fields(optional_fields, using)
+      end
+
+      # Each of +fields+ as optional, with its options in +using+; one +using+
+      # does not hold is left out.
+      def declare_optional_fields(fields, using)
+        fields.each do |field|
           field_opts = using[field]
           optional(field, **field_opts) if field_opts
         end
@@ -277,13 +395,15 @@ module Grape
       # @yield parameter scope
       def new_scope(element, type:, as:, optional: false, &)
         # A group needs a type: it says whether the nested params sit under one
-        # object or repeat in a list, and without it the `type || Array` below
-        # would quietly pick one. Checked here for `requires` and `optional`
-        # alike — `new_scope` is only reached from their block branch.
-        if element
-          raise Grape::Exceptions::MissingGroupType if type.nil?
-          raise Grape::Exceptions::UnsupportedGroupType unless Grape::Validations::Types.group?(type)
-        end
+        # object or repeat in a list, and nothing else could decide it. Checked
+        # here for `requires` and `optional` alike — `new_scope` is only reached
+        # from their block branch.
+        raise Grape::Exceptions::MissingGroupType if type.nil?
+        raise Grape::Exceptions::UnsupportedGroupType unless Grape::Validations::Types.group?(type)
+
+        # The block declares the keys of each element, so an element has to be
+        # a Hash. +Array[JSON]+ checks that when it parses the elements.
+        validate('hash_elements', {}, [element], false, {}) if type == Array
 
         self.class.new(
           api: @api,
@@ -291,7 +411,7 @@ module Grape
           element_renamed: as,
           parent: self,
           optional:,
-          type: type || Array,
+          type:,
           group: @group,
           &
         )
@@ -299,8 +419,8 @@ module Grape
 
       # Returns a new parameter scope, not nested under any current-level param
       # but instead at the same level as the current scope.
-      # @param dependent_on [Symbol] if given, specifies that this scope should
-      #   only validate if this parameter from the above scope is present
+      # @param dependent_on [Array<Symbol, Hash>] if given, this scope only
+      #   validates if these parameters from the above scope are present
       # @yield parameter scope
       def new_lateral_scope(dependent_on:, &)
         self.class.new(
@@ -348,6 +468,23 @@ module Grape
         (iterates_elements? ? 1 : 0) + (@parent&.array_depth || 0)
       end
 
+      def validates(attrs, validations, required: false)
+        spec = ValidationsSpec.from(declared_validations(validations, required))
+
+        document_params(attrs, spec)
+
+        # Presence runs first — `required` is forwarded to every subsequent
+        # validator (some short-circuit on it).
+        validate_presence(spec, attrs)
+
+        # Coerce runs second — later validators see the typed value.
+        validate_coerce(spec, attrs)
+
+        spec.validator_entries.each do |type, options|
+          validate(type, options, attrs, spec.required?, spec.shared_opts)
+        end
+      end
+
       # +required+ is the DSL's own signal — +requires+ passes true, +optional+
       # false. It used to travel as a +:presence+ key that +requires+ wrote into
       # the caller's option Hash, which is why a user-supplied +presence:+ was
@@ -359,27 +496,15 @@ module Grape
       # A +presence:+ supplied by an API still decides the outcome exactly as it
       # used to — deprecated rather than dropped, so nothing changes under an
       # API that relies on it until the key is ignored outright.
-      def validates(attrs, validations, required: false)
+      def declared_validations(validations, required)
         if validations.key?(:presence)
           Grape.deprecator.warn('Passing a `presence` option is deprecated and it will be ignored in a future release. Declare the parameter with `requires` to make it required, `optional` to make it optional.')
         end
 
         declared = required ? validations.merge(presence: { value: true, message: validations[:message] }) : validations
-        declared = declared.merge(oneof: collected_oneof(declared)) if declared.key?(:oneof)
-        spec = ValidationsSpec.from(declared)
-
-        document_params(attrs, spec)
-
-        # Presence runs first — `required` is forwarded to every subsequent
-        # validator (some short-circuit on it).
-        validate_presence(spec, attrs)
-
-        # Coerce runs second — later validators see the typed value.
-        validate_coerce(spec, attrs)
+        return declared unless declared.key?(:oneof)
 
-        spec.validator_entries.each do |type, options|
-          validate(type, options, attrs, spec.required?, spec.shared_opts)
-        end
+        declared.merge(oneof: collected_oneof(declared))
       end
 
       # Enforce correct usage of :coerce_with on a CoerceOptions.
@@ -425,7 +550,7 @@ module Grape
         raise ArgumentError, 'oneof: requires type: Hash' unless validations[:type] == Hash
 
         variants = validations[:oneof]
-        raise ArgumentError, 'oneof: must be a non-empty Array of blocks' unless variants.is_a?(Array) && variants.any?
+        raise ArgumentError, 'oneof: must be a non-empty Array of blocks' if !variants.is_a?(Array) || variants.empty?
         raise ArgumentError, 'oneof: each variant must be a Proc' unless variants.all?(Proc)
 
         variants.map { |block| OneofCollector.collect(block) }
@@ -443,8 +568,16 @@ module Grape
         @api.inheritable_setting.add_validation(validator_instance)
       end
 
+      # Only ever asked about params that are not blank (see #should_validate?
+      # and #validated_params), and a Hash that is not blank is never all
+      # blank: what +all?+ yields for it is a [key, value] pair, an Array of
+      # two, which +blank?+ is false for. Asking anyway walked the Hash and
+      # built one of those Arrays per entry, for every optional Hash scope of
+      # every request.
       def all_element_blank?(scoped_params)
-        scoped_params.respond_to?(:all?) && scoped_params.all?(&:blank?)
+        return false if scoped_params.is_a?(::Hash)
+
+        scoped_params.respond_to?(:all?) && scoped_params.all? { |element| Grape::Util::Scrub.blank?(element) }
       end
     end
   end

data/lib/grape/validations/types/custom_type_coercer.rb

@@ -10,7 +10,7 @@ module Grape
       # there are any problems parsing the string.
       #
       # Alternately an optional +method+ may be supplied (see the
-      # +coerce_with+ option of {Grape::Dsl::Parameters#requires}).
+      # +coerce_with+ option of {Grape::DSL::Parameters#requires}).
       # This may be any class or object implementing +parse+ or +call+,
       # with the same contract as described above.
       #
@@ -53,8 +53,7 @@ module Grape
 
         # Coerces the given value.
         #
-        # @param value [String] value to be coerced, in grape
-        #   this should always be a string.
+        # @param val [Object] value to be coerced
         # @return [Object] the coerced result
         def call(val)
           coerced_val = @method.call(val)

data/lib/grape/validations/types/custom_type_collection_coercer.rb

@@ -4,7 +4,7 @@ module Grape
   module Validations
     module Types
       # See {CustomTypeCoercer} for details on types
-      # that will be supported by this by this coercer.
+      # that will be supported by this coercer.
       # This coercer works in the same way as +CustomTypeCoercer+
       # except that it expects to receive an array of strings to
       # coerce and will return an array (or optionally, a set)