activemodel 7.0.3.1 → 6.1.7.1

data/lib/active_model/naming.rb

@@ -3,7 +3,6 @@
 require "active_support/core_ext/hash/except"
 require "active_support/core_ext/module/introspection"
 require "active_support/core_ext/module/redefine_method"
-require "active_support/core_ext/module/delegation"
 
 module ActiveModel
   class Name
@@ -154,7 +153,6 @@ module ActiveModel
     # Returns a new ActiveModel::Name instance. By default, the +namespace+
     # and +name+ option will take the namespace and name of the given class
     # respectively.
-    # Use +locale+ argument for singularize and pluralize model name.
     #
     #   module Foo
     #     class Bar
@@ -163,7 +161,7 @@ module ActiveModel
     #
     #   ActiveModel::Name.new(Foo::Bar).to_s
     #   # => "Foo::Bar"
-    def initialize(klass, namespace = nil, name = nil, locale = :en)
+    def initialize(klass, namespace = nil, name = nil)
       @name = name || klass.name
 
       raise ArgumentError, "Class name cannot be blank. You need to supply a name argument when anonymous class given" if @name.blank?
@@ -171,17 +169,16 @@ module ActiveModel
       @unnamespaced = @name.delete_prefix("#{namespace.name}::") if namespace
       @klass        = klass
       @singular     = _singularize(@name)
-      @plural       = ActiveSupport::Inflector.pluralize(@singular, locale)
-      @uncountable  = @plural == @singular
+      @plural       = ActiveSupport::Inflector.pluralize(@singular)
       @element      = ActiveSupport::Inflector.underscore(ActiveSupport::Inflector.demodulize(@name))
       @human        = ActiveSupport::Inflector.humanize(@element)
       @collection   = ActiveSupport::Inflector.tableize(@name)
       @param_key    = (namespace ? _singularize(@unnamespaced) : @singular)
       @i18n_key     = @name.underscore.to_sym
 
-      @route_key          = (namespace ? ActiveSupport::Inflector.pluralize(@param_key, locale) : @plural.dup)
-      @singular_route_key = ActiveSupport::Inflector.singularize(@route_key, locale)
-      @route_key << "_index" if @uncountable
+      @route_key          = (namespace ? ActiveSupport::Inflector.pluralize(@param_key) : @plural.dup)
+      @singular_route_key = ActiveSupport::Inflector.singularize(@route_key)
+      @route_key << "_index" if @plural == @singular
     end
 
     # Transform the model name into a more human format, using I18n. By default,
@@ -209,10 +206,6 @@ module ActiveModel
       I18n.translate(defaults.shift, **options)
     end
 
-    def uncountable?
-      @uncountable
-    end
-
     private
       def _singularize(string)
         ActiveSupport::Inflector.underscore(string).tr("/", "_")
@@ -239,7 +232,7 @@ module ActiveModel
   # is required to pass the \Active \Model Lint test. So either extending the
   # provided method below, or rolling your own is required.
   module Naming
-    def self.extended(base) # :nodoc:
+    def self.extended(base) #:nodoc:
       base.silence_redefinition_of_method :model_name
       base.delegate :model_name, to: :class
     end
@@ -286,7 +279,7 @@ module ActiveModel
     #   ActiveModel::Naming.uncountable?(Sheep) # => true
     #   ActiveModel::Naming.uncountable?(Post)  # => false
     def self.uncountable?(record_or_class)
-      model_name_from_record_or_class(record_or_class).uncountable?
+      plural(record_or_class) == singular(record_or_class)
     end
 
     # Returns string to use while generating route names. It differs for
@@ -328,7 +321,7 @@ module ActiveModel
       model_name_from_record_or_class(record_or_class).param_key
     end
 
-    def self.model_name_from_record_or_class(record_or_class) # :nodoc:
+    def self.model_name_from_record_or_class(record_or_class) #:nodoc:
       if record_or_class.respond_to?(:to_model)
         record_or_class.to_model.model_name
       else

data/lib/active_model/secure_password.rb

@@ -119,7 +119,7 @@ module ActiveModel
         #   user.authenticate_password('mUc3m00RsqyRe') # => user
         define_method("authenticate_#{attribute}") do |unencrypted_password|
           attribute_digest = public_send("#{attribute}_digest")
-          attribute_digest.present? && BCrypt::Password.new(attribute_digest).is_password?(unencrypted_password) && self
+          BCrypt::Password.new(attribute_digest).is_password?(unencrypted_password) && self
         end
 
         alias_method :authenticate, :authenticate_password if attribute == :password

data/lib/active_model/serialization.rb

@@ -123,7 +123,7 @@ module ActiveModel
     #   user.serializable_hash(include: { notes: { only: 'title' }})
     #   # => {"name" => "Napoleon", "notes" => [{"title"=>"Battle of Austerlitz"}]}
     def serializable_hash(options = nil)
-      attribute_names = attribute_names_for_serialization
+      attribute_names = attributes.keys
 
       return serializable_attributes(attribute_names) if options.blank?
 
@@ -149,10 +149,6 @@ module ActiveModel
     end
 
     private
-      def attribute_names_for_serialization
-        attributes.keys
-      end
-
       # Hook method defining how an attribute value should be retrieved for
       # serialization. By default this is assumed to be an instance named after
       # the attribute. Override this method in subclasses should you need to
@@ -181,7 +177,7 @@ module ActiveModel
       #   +association+ - name of the association
       #   +records+     - the association record(s) to be serialized
       #   +opts+        - options for the association records
-      def serializable_add_includes(options = {}) # :nodoc:
+      def serializable_add_includes(options = {}) #:nodoc:
         return unless includes = options[:include]
 
         unless includes.is_a?(Hash)

data/lib/active_model/translation.rb

@@ -17,12 +17,12 @@ module ActiveModel
   #
   # This also provides the required class methods for hooking into the
   # Rails internationalization API, including being able to define a
-  # class-based +i18n_scope+ and +lookup_ancestors+ to find translations in
+  # class based +i18n_scope+ and +lookup_ancestors+ to find translations in
   # parent classes.
   module Translation
     include ActiveModel::Naming
 
-    # Returns the +i18n_scope+ for the class. Override if you want custom lookup.
+    # Returns the +i18n_scope+ for the class. Overwrite if you want custom lookup.
     def i18n_scope
       :activemodel
     end

data/lib/active_model/type/date.rb

@@ -11,7 +11,7 @@ module ActiveModel
       end
 
       def type_cast_for_schema(value)
-        value.to_fs(:db).inspect
+        value.to_s(:db).inspect
       end
 
       private

data/lib/active_model/type/helpers/numeric.rb

@@ -25,18 +25,10 @@ module ActiveModel
         end
 
         def changed?(old_value, _new_value, new_value_before_type_cast) # :nodoc:
-          (super || number_to_non_number?(old_value, new_value_before_type_cast)) &&
-            !equal_nan?(old_value, new_value_before_type_cast)
+          super || number_to_non_number?(old_value, new_value_before_type_cast)
         end
 
         private
-          def equal_nan?(old_value, new_value)
-            (old_value.is_a?(::Float) || old_value.is_a?(BigDecimal)) &&
-              old_value.nan? &&
-              old_value.instance_of?(new_value.class) &&
-              new_value.nan?
-          end
-
           def number_to_non_number?(old_value, new_value_before_type_cast)
             old_value != nil && non_numeric_string?(new_value_before_type_cast.to_s)
           end

data/lib/active_model/type/helpers/time_value.rb

@@ -12,9 +12,9 @@ module ActiveModel
 
           if value.acts_like?(:time)
             if is_utc?
-              value = value.getutc if !value.utc?
+              value = value.getutc if value.respond_to?(:getutc) && !value.utc?
             else
-              value = value.getlocal
+              value = value.getlocal if value.respond_to?(:getlocal)
             end
           end
 
@@ -36,7 +36,7 @@ module ActiveModel
         end
 
         def type_cast_for_schema(value)
-          value.to_fs(:db).inspect
+          value.to_s(:db).inspect
         end
 
         def user_input_in_time_zone(value)

data/lib/active_model/type/integer.rb

@@ -30,10 +30,7 @@ module ActiveModel
 
       def serializable?(value)
         cast_value = cast(value)
-        in_range?(cast_value) || begin
-          yield cast_value if block_given?
-          false
-        end
+        in_range?(cast_value) && super
       end
 
       private

data/lib/active_model/type/registry.rb

@@ -1,38 +1,68 @@
 # frozen_string_literal: true
 
 module ActiveModel
+  # :stopdoc:
   module Type
-    class Registry # :nodoc:
+    class Registry
       def initialize
-        @registrations = {}
+        @registrations = []
       end
 
-      def initialize_copy(other)
+      def initialize_dup(other)
         @registrations = @registrations.dup
         super
       end
 
-      def register(type_name, klass = nil, &block)
+      def register(type_name, klass = nil, **options, &block)
         unless block_given?
           block = proc { |_, *args| klass.new(*args) }
           block.ruby2_keywords if block.respond_to?(:ruby2_keywords)
         end
-        registrations[type_name] = block
+        registrations << registration_klass.new(type_name, block, **options)
       end
 
       def lookup(symbol, *args)
-        registration = registrations[symbol]
+        registration = find_registration(symbol, *args)
 
         if registration
-          registration.call(symbol, *args)
+          registration.call(self, symbol, *args)
         else
           raise ArgumentError, "Unknown type #{symbol.inspect}"
         end
       end
-      ruby2_keywords(:lookup)
+      ruby2_keywords(:lookup) if respond_to?(:ruby2_keywords, true)
 
       private
         attr_reader :registrations
+
+        def registration_klass
+          Registration
+        end
+
+        def find_registration(symbol, *args, **kwargs)
+          registrations.find { |r| r.matches?(symbol, *args, **kwargs) }
+        end
+    end
+
+    class Registration
+      # Options must be taken because of https://bugs.ruby-lang.org/issues/10856
+      def initialize(name, block, **)
+        @name = name
+        @block = block
+      end
+
+      def call(_registry, *args)
+        block.call(*args)
+      end
+      ruby2_keywords(:call) if respond_to?(:ruby2_keywords, true)
+
+      def matches?(type_name, *args, **kwargs)
+        type_name == name
+      end
+
+      private
+        attr_reader :name, :block
     end
   end
+  # :startdoc:
 end

data/lib/active_model/type/time.rb

@@ -33,7 +33,7 @@ module ActiveModel
           return apply_seconds_precision(value) unless value.is_a?(::String)
           return if value.empty?
 
-          dummy_time_value = value.sub(/\A\d{4}-\d\d-\d\d(?:T|\s)|/, "2000-01-01 ")
+          dummy_time_value = value.sub(/\A(\d\d\d\d-\d\d-\d\d |)/, "2000-01-01 ")
 
           fast_string_to_time(dummy_time_value) || begin
             time_hash = ::Date._parse(dummy_time_value)

data/lib/active_model/type.rb

@@ -24,15 +24,15 @@ module ActiveModel
     class << self
       attr_accessor :registry # :nodoc:
 
-      # Add a new type to the registry, allowing it to be referenced as a
-      # symbol by {attribute}[rdoc-ref:Attributes::ClassMethods#attribute].
-      def register(type_name, klass = nil, &block)
-        registry.register(type_name, klass, &block)
+      # Add a new type to the registry, allowing it to be gotten through ActiveModel::Type#lookup
+      def register(type_name, klass = nil, **options, &block)
+        registry.register(type_name, klass, **options, &block)
       end
 
-      def lookup(...) # :nodoc:
-        registry.lookup(...)
+      def lookup(*args) # :nodoc:
+        registry.lookup(*args)
       end
+      ruby2_keywords(:lookup) if respond_to?(:ruby2_keywords, true)
 
       def default_value # :nodoc:
         @default_value ||= Value.new

data/lib/active_model/validations/absence.rb

@@ -3,7 +3,7 @@
 module ActiveModel
   module Validations
     # == \Active \Model Absence Validator
-    class AbsenceValidator < EachValidator # :nodoc:
+    class AbsenceValidator < EachValidator #:nodoc:
       def validate_each(record, attr_name, value)
         record.errors.add(attr_name, :present, **options) if value.present?
       end
@@ -24,7 +24,7 @@ module ActiveModel
       #
       # There is also a list of default options supported by every validator:
       # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+.
-      # See ActiveModel::Validations::ClassMethods#validates for more information.
+      # See <tt>ActiveModel::Validations#validates</tt> for more information
       def validates_absence_of(*attr_names)
         validates_with AbsenceValidator, _merge_attributes(attr_names)
       end

data/lib/active_model/validations/acceptance.rb

@@ -104,7 +104,7 @@ module ActiveModel
       #
       # There is also a list of default options supported by every validator:
       # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+.
-      # See ActiveModel::Validations::ClassMethods#validates for more information.
+      # See <tt>ActiveModel::Validations#validates</tt> for more information.
       def validates_acceptance_of(*attr_names)
         validates_with AcceptanceValidator, _merge_attributes(attr_names)
       end

data/lib/active_model/validations/callbacks.rb

@@ -112,7 +112,7 @@ module ActiveModel
       end
 
     private
-      # Override run_validations! to include callbacks.
+      # Overwrite run validations to include callbacks.
       def run_validations!
         _run_validation_callbacks { super }
       end

data/lib/active_model/validations/clusivity.rb

@@ -4,7 +4,7 @@ require "active_support/core_ext/range"
 
 module ActiveModel
   module Validations
-    module Clusivity # :nodoc:
+    module Clusivity #:nodoc:
       ERROR_MESSAGE = "An object with the method #include? or a proc, lambda or symbol is required, " \
                       "and must be supplied as the :in (or :within) option of the configuration hash"
 

data/lib/active_model/validations/confirmation.rb

@@ -19,13 +19,13 @@ module ActiveModel
 
       private
         def setup!(klass)
-          klass.attr_reader(*attributes.filter_map do |attribute|
+          klass.attr_reader(*attributes.map do |attribute|
             :"#{attribute}_confirmation" unless klass.method_defined?(:"#{attribute}_confirmation")
-          end)
+          end.compact)
 
-          klass.attr_writer(*attributes.filter_map do |attribute|
+          klass.attr_writer(*attributes.map do |attribute|
             :"#{attribute}_confirmation" unless klass.method_defined?(:"#{attribute}_confirmation=")
-          end)
+          end.compact)
         end
 
         def confirmation_value_equal?(record, attribute, value, confirmed)
@@ -71,7 +71,7 @@ module ActiveModel
       #
       # There is also a list of default options supported by every validator:
       # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+.
-      # See ActiveModel::Validations::ClassMethods#validates for more information.
+      # See <tt>ActiveModel::Validations#validates</tt> for more information
       def validates_confirmation_of(*attr_names)
         validates_with ConfirmationValidator, _merge_attributes(attr_names)
       end

data/lib/active_model/validations/exclusion.rb

@@ -29,8 +29,8 @@ module ActiveModel
       #
       # Configuration options:
       # * <tt>:in</tt> - An enumerable object of items that the value shouldn't
-      #   be part of. This can be supplied as a proc, lambda, or symbol which returns an
-      #   enumerable. If the enumerable is a numerical, time, or datetime range the test
+      #   be part of. This can be supplied as a proc, lambda or symbol which returns an
+      #   enumerable. If the enumerable is a numerical, time or datetime range the test
       #   is performed with <tt>Range#cover?</tt>, otherwise with <tt>include?</tt>. When
       #   using a proc or lambda the instance under validation is passed as an argument.
       # * <tt>:within</tt> - A synonym(or alias) for <tt>:in</tt>
@@ -40,7 +40,7 @@ module ActiveModel
       #
       # There is also a list of default options supported by every validator:
       # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+.
-      # See ActiveModel::Validations::ClassMethods#validates for more information.
+      # See <tt>ActiveModel::Validations#validates</tt> for more information
       def validates_exclusion_of(*attr_names)
         validates_with ExclusionValidator, _merge_attributes(attr_names)
       end

data/lib/active_model/validations/format.rb

@@ -104,7 +104,7 @@ module ActiveModel
       #
       # There is also a list of default options supported by every validator:
       # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+.
-      # See ActiveModel::Validations::ClassMethods#validates for more information.
+      # See <tt>ActiveModel::Validations#validates</tt> for more information
       def validates_format_of(*attr_names)
         validates_with FormatValidator, _merge_attributes(attr_names)
       end

data/lib/active_model/validations/inclusion.rb

@@ -28,8 +28,8 @@ module ActiveModel
       #
       # Configuration options:
       # * <tt>:in</tt> - An enumerable object of available items. This can be
-      #   supplied as a proc, lambda, or symbol which returns an enumerable. If the
-      #   enumerable is a numerical, time, or datetime range the test is performed
+      #   supplied as a proc, lambda or symbol which returns an enumerable. If the
+      #   enumerable is a numerical, time or datetime range the test is performed
       #   with <tt>Range#cover?</tt>, otherwise with <tt>include?</tt>. When using
       #   a proc or lambda the instance under validation is passed as an argument.
       # * <tt>:within</tt> - A synonym(or alias) for <tt>:in</tt>
@@ -38,7 +38,7 @@ module ActiveModel
       #
       # There is also a list of default options supported by every validator:
       # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+.
-      # See ActiveModel::Validations::ClassMethods#validates for more information.
+      # See <tt>ActiveModel::Validations#validates</tt> for more information
       def validates_inclusion_of(*attr_names)
         validates_with InclusionValidator, _merge_attributes(attr_names)
       end

data/lib/active_model/validations/length.rb

@@ -117,8 +117,8 @@ module ActiveModel
       #   <tt>too_long</tt>/<tt>too_short</tt>/<tt>wrong_length</tt> message.
       #
       # There is also a list of default options supported by every validator:
-      # +:if+, +:unless+, +:on+, and +:strict+.
-      # See ActiveModel::Validations::ClassMethods#validates for more information.
+      # +:if+, +:unless+, +:on+ and +:strict+.
+      # See <tt>ActiveModel::Validations#validates</tt> for more information
       def validates_length_of(*attr_names)
         validates_with LengthValidator, _merge_attributes(attr_names)
       end

data/lib/active_model/validations/numericality.rb

@@ -1,34 +1,27 @@
 # frozen_string_literal: true
 
-require "active_model/validations/comparability"
 require "bigdecimal/util"
 
 module ActiveModel
   module Validations
     class NumericalityValidator < EachValidator # :nodoc:
-      include Comparability
+      CHECKS = { greater_than: :>, greater_than_or_equal_to: :>=,
+                 equal_to: :==, less_than: :<, less_than_or_equal_to: :<=,
+                 odd: :odd?, even: :even?, other_than: :!= }.freeze
 
-      RANGE_CHECKS = { in: :in? }
-      NUMBER_CHECKS = { odd: :odd?, even: :even? }
-
-      RESERVED_OPTIONS = COMPARE_CHECKS.keys + NUMBER_CHECKS.keys + RANGE_CHECKS.keys + [:only_integer]
+      RESERVED_OPTIONS = CHECKS.keys + [:only_integer]
 
       INTEGER_REGEX = /\A[+-]?\d+\z/
 
       HEXADECIMAL_REGEX = /\A[+-]?0[xX]/
 
       def check_validity!
-        options.slice(*COMPARE_CHECKS.keys).each do |option, value|
+        keys = CHECKS.keys - [:odd, :even]
+        options.slice(*keys).each do |option, value|
           unless value.is_a?(Numeric) || value.is_a?(Proc) || value.is_a?(Symbol)
             raise ArgumentError, ":#{option} must be a number, a symbol or a proc"
           end
         end
-
-        options.slice(*RANGE_CHECKS.keys).each do |option, value|
-          unless value.is_a?(Range)
-            raise ArgumentError, ":#{option} must be a range"
-          end
-        end
       end
 
       def validate_each(record, attr_name, value, precision: Float::DIG, scale: nil)
@@ -44,18 +37,23 @@ module ActiveModel
 
         value = parse_as_number(value, precision, scale)
 
-        options.slice(*RESERVED_OPTIONS).each do |option, option_value|
-          if NUMBER_CHECKS.include?(option)
-            unless value.to_i.public_send(NUMBER_CHECKS[option])
+        options.slice(*CHECKS.keys).each do |option, option_value|
+          case option
+          when :odd, :even
+            unless value.to_i.public_send(CHECKS[option])
               record.errors.add(attr_name, option, **filtered_options(value))
             end
-          elsif RANGE_CHECKS.include?(option)
-            unless value.public_send(RANGE_CHECKS[option], option_value)
-              record.errors.add(attr_name, option, **filtered_options(value).merge!(count: option_value))
+          else
+            case option_value
+            when Proc
+              option_value = option_value.call(record)
+            when Symbol
+              option_value = record.send(option_value)
             end
-          elsif COMPARE_CHECKS.include?(option)
-            option_value = option_as_number(record, option_value, precision, scale)
-            unless value.public_send(COMPARE_CHECKS[option], option_value)
+
+            option_value = parse_as_number(option_value, precision, scale)
+
+            unless value.public_send(CHECKS[option], option_value)
               record.errors.add(attr_name, option, **filtered_options(value).merge!(count: option_value))
             end
           end
@@ -63,10 +61,6 @@ module ActiveModel
       end
 
     private
-      def option_as_number(record, option_value, precision, scale)
-        parse_as_number(option_value(record, option_value), precision, scale)
-      end
-
       def parse_as_number(raw_value, precision, scale)
         if raw_value.is_a?(Float)
           parse_float(raw_value, precision, scale)
@@ -161,7 +155,7 @@ module ActiveModel
       # Configuration options:
       # * <tt>:message</tt> - A custom error message (default is: "is not a number").
       # * <tt>:only_integer</tt> - Specifies whether the value has to be an
-      #   integer (default is +false+).
+      #   integer, e.g. an integral value (default is +false+).
       # * <tt>:allow_nil</tt> - Skip validation if attribute is +nil+ (default is
       #   +false+). Notice that for Integer and Float columns empty strings are
       #   converted to +nil+.
@@ -179,11 +173,10 @@ module ActiveModel
       #   supplied value.
       # * <tt>:odd</tt> - Specifies the value must be an odd number.
       # * <tt>:even</tt> - Specifies the value must be an even number.
-      # * <tt>:in</tt> - Check that the value is within a range.
       #
       # There is also a list of default options supported by every validator:
       # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+ .
-      # See ActiveModel::Validations::ClassMethods#validates for more information.
+      # See <tt>ActiveModel::Validations#validates</tt> for more information
       #
       # The following checks can also be supplied with a proc or a symbol which
       # corresponds to a method:

data/lib/active_model/validations/presence.rb

@@ -30,7 +30,7 @@ module ActiveModel
       #
       # There is also a list of default options supported by every validator:
       # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+.
-      # See ActiveModel::Validations::ClassMethods#validates for more information.
+      # See <tt>ActiveModel::Validations#validates</tt> for more information
       def validates_presence_of(*attr_names)
         validates_with PresenceValidator, _merge_attributes(attr_names)
       end

data/lib/active_model/validations/validates.rb

@@ -78,14 +78,14 @@ module ActiveModel
       #   or an array of symbols. (e.g. <tt>on: :create</tt> or
       #   <tt>on: :custom_validation_context</tt> or
       #   <tt>on: [:create, :custom_validation_context]</tt>)
-      # * <tt>:if</tt> - Specifies a method, proc, or string to call to determine
+      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine
       #   if the validation should occur (e.g. <tt>if: :allow_validation</tt>,
       #   or <tt>if: Proc.new { |user| user.signup_step > 2 }</tt>). The method,
       #   proc or string should return or evaluate to a +true+ or +false+ value.
-      # * <tt>:unless</tt> - Specifies a method, proc, or string to call to determine
+      # * <tt>:unless</tt> - Specifies a method, proc or string to call to determine
       #   if the validation should not occur (e.g. <tt>unless: :skip_validation</tt>,
       #   or <tt>unless: Proc.new { |user| user.signup_step <= 2 }</tt>). The
-      #   method, proc, or string should return or evaluate to a +true+ or
+      #   method, proc or string should return or evaluate to a +true+ or
       #   +false+ value.
       # * <tt>:allow_nil</tt> - Skip validation if the attribute is +nil+.
       # * <tt>:allow_blank</tt> - Skip validation if the attribute is blank.

data/lib/active_model/validations/with.rb

@@ -51,16 +51,16 @@ module ActiveModel
       #   or an array of symbols. (e.g. <tt>on: :create</tt> or
       #   <tt>on: :custom_validation_context</tt> or
       #   <tt>on: [:create, :custom_validation_context]</tt>)
-      # * <tt>:if</tt> - Specifies a method, proc, or string to call to determine
+      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine
       #   if the validation should occur (e.g. <tt>if: :allow_validation</tt>,
       #   or <tt>if: Proc.new { |user| user.signup_step > 2 }</tt>).
-      #   The method, proc, or string should return or evaluate to a +true+ or
+      #   The method, proc or string should return or evaluate to a +true+ or
       #   +false+ value.
-      # * <tt>:unless</tt> - Specifies a method, proc, or string to call to
+      # * <tt>:unless</tt> - Specifies a method, proc or string to call to
       #   determine if the validation should not occur
       #   (e.g. <tt>unless: :skip_validation</tt>, or
       #   <tt>unless: Proc.new { |user| user.signup_step <= 2 }</tt>).
-      #   The method, proc, or string should return or evaluate to a +true+ or
+      #   The method, proc or string should return or evaluate to a +true+ or
       #   +false+ value.
       # * <tt>:strict</tt> - Specifies whether validation should be strict.
       #   See <tt>ActiveModel::Validations#validates!</tt> for more information.