activemodel 4.2.0 → 6.1.0

data/lib/active_model/validations/acceptance.rb

@@ -1,25 +1,82 @@
-module ActiveModel
+# frozen_string_literal: true
 
+module ActiveModel
   module Validations
     class AcceptanceValidator < EachValidator # :nodoc:
       def initialize(options)
-        super({ allow_nil: true, accept: "1" }.merge!(options))
+        super({ allow_nil: true, accept: ["1", true] }.merge!(options))
         setup!(options[:class])
       end
 
       def validate_each(record, attribute, value)
-        unless value == options[:accept]
-          record.errors.add(attribute, :accepted, options.except(:accept, :allow_nil))
+        unless acceptable_option?(value)
+          record.errors.add(attribute, :accepted, **options.except(:accept, :allow_nil))
         end
       end
 
       private
-      def setup!(klass)
-        attr_readers = attributes.reject { |name| klass.attribute_method?(name) }
-        attr_writers = attributes.reject { |name| klass.attribute_method?("#{name}=") }
-        klass.send(:attr_reader, *attr_readers)
-        klass.send(:attr_writer, *attr_writers)
-      end
+        def setup!(klass)
+          define_attributes = LazilyDefineAttributes.new(attributes)
+          klass.include(define_attributes) unless klass.included_modules.include?(define_attributes)
+        end
+
+        def acceptable_option?(value)
+          Array(options[:accept]).include?(value)
+        end
+
+        class LazilyDefineAttributes < Module
+          def initialize(attributes)
+            @attributes = attributes.map(&:to_s)
+          end
+
+          def included(klass)
+            @lock = Mutex.new
+            mod = self
+
+            define_method(:respond_to_missing?) do |method_name, include_private = false|
+              mod.define_on(klass)
+              super(method_name, include_private) || mod.matches?(method_name)
+            end
+
+            define_method(:method_missing) do |method_name, *args, &block|
+              mod.define_on(klass)
+              if mod.matches?(method_name)
+                send(method_name, *args, &block)
+              else
+                super(method_name, *args, &block)
+              end
+            end
+          end
+
+          def matches?(method_name)
+            attr_name = method_name.to_s.chomp("=")
+            attributes.any? { |name| name == attr_name }
+          end
+
+          def define_on(klass)
+            @lock&.synchronize do
+              return unless @lock
+
+              attr_readers = attributes.reject { |name| klass.attribute_method?(name) }
+              attr_writers = attributes.reject { |name| klass.attribute_method?("#{name}=") }
+
+              attr_reader(*attr_readers)
+              attr_writer(*attr_writers)
+
+              remove_method :respond_to_missing?
+              remove_method :method_missing
+
+              @lock = nil
+            end
+          end
+
+          def ==(other)
+            self.class == other.class && attributes == other.attributes
+          end
+
+          protected
+            attr_reader :attributes
+        end
     end
 
     module HelperMethods
@@ -38,15 +95,16 @@ module ActiveModel
       # Configuration options:
       # * <tt>:message</tt> - A custom error message (default is: "must be
       #   accepted").
-      # * <tt>:accept</tt> - Specifies value that is considered accepted.
-      #   The default value is a string "1", which makes it easy to relate to
-      #   an HTML checkbox. This should be set to +true+ if you are validating
+      # * <tt>:accept</tt> - Specifies a value that is considered accepted.
+      #   Also accepts an array of possible values. The default value is
+      #   an array ["1", true], which makes it easy to relate to an HTML
+      #   checkbox. This should be set to, or include, +true+ if you are validating
       #   a database column, since the attribute is typecast from "1" to +true+
       #   before validation.
       #
       # There is also a list of default options supported by every validator:
       # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+.
-      # See <tt>ActiveModel::Validation#validates</tt> 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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveModel
   module Validations
     # == Active \Model \Validation \Callbacks
@@ -15,22 +17,20 @@ module ActiveModel
     #     after_validation  :do_stuff_after_validation
     #   end
     #
-    # Like other <tt>before_*</tt> callbacks if +before_validation+ returns
-    # +false+ then <tt>valid?</tt> will not be called.
+    # Like other <tt>before_*</tt> callbacks if +before_validation+ throws
+    # +:abort+ then <tt>valid?</tt> will not be called.
     module Callbacks
       extend ActiveSupport::Concern
 
       included do
         include ActiveSupport::Callbacks
         define_callbacks :validation,
-                         terminator: ->(_,result) { result == false },
                          skip_after_callbacks_if_terminated: true,
                          scope: [:kind, :name]
       end
 
       module ClassMethods
-        # Defines a callback that will get called right before validation
-        # happens.
+        # Defines a callback that will get called right before validation.
         #
         #   class Person
         #     include ActiveModel::Validations
@@ -54,19 +54,21 @@ module ActiveModel
         #   person.valid? # => true
         #   person.name   # => "bob"
         def before_validation(*args, &block)
-          options = args.last
-          if options.is_a?(Hash) && options[:on]
-            options[:if] = Array(options[:if])
+          options = args.extract_options!
+
+          if options.key?(:on)
+            options = options.dup
             options[:on] = Array(options[:on])
+            options[:if] = Array(options[:if])
             options[:if].unshift ->(o) {
-              options[:on].include? o.validation_context
+              !(options[:on] & Array(o.validation_context)).empty?
             }
           end
-          set_callback(:validation, :before, *args, &block)
+
+          set_callback(:validation, :before, *args, options, &block)
         end
 
-        # Defines a callback that will get called right after validation
-        # happens.
+        # Defines a callback that will get called right after validation.
         #
         #   class Person
         #     include ActiveModel::Validations
@@ -94,22 +96,24 @@ module ActiveModel
         #   person.status # => true
         def after_validation(*args, &block)
           options = args.extract_options!
+          options = options.dup
           options[:prepend] = true
-          options[:if] = Array(options[:if])
-          if options[:on]
+
+          if options.key?(:on)
             options[:on] = Array(options[:on])
+            options[:if] = Array(options[:if])
             options[:if].unshift ->(o) {
-              options[:on].include? o.validation_context
+              !(options[:on] & Array(o.validation_context)).empty?
             }
           end
-          set_callback(:validation, :after, *(args << options), &block)
+
+          set_callback(:validation, :after, *args, options, &block)
         end
       end
 
-    protected
-
+    private
       # Overwrite run validations to include callbacks.
-      def run_validations! #:nodoc:
+      def run_validations!
         _run_validation_callbacks { super }
       end
     end

data/lib/active_model/validations/clusivity.rb

@@ -1,4 +1,6 @@
-require 'active_support/core_ext/range'
+# frozen_string_literal: true
+
+require "active_support/core_ext/range"
 
 module ActiveModel
   module Validations
@@ -13,31 +15,35 @@ module ActiveModel
       end
 
     private
-
       def include?(record, value)
         members = if delimiter.respond_to?(:call)
-                    delimiter.call(record)
-                  elsif delimiter.respond_to?(:to_sym)
-                    record.send(delimiter)
-                  else
-                    delimiter
-                  end
+          delimiter.call(record)
+        elsif delimiter.respond_to?(:to_sym)
+          record.send(delimiter)
+        else
+          delimiter
+        end
 
-        members.send(inclusion_method(members), value)
+        if value.is_a?(Array)
+          value.all? { |v| members.public_send(inclusion_method(members), v) }
+        else
+          members.public_send(inclusion_method(members), value)
+        end
       end
 
       def delimiter
         @delimiter ||= options[:in] || options[:within]
       end
 
-      # In Ruby 1.9 <tt>Range#include?</tt> on non-number-or-time-ish ranges checks all
+      # After Ruby 2.2, <tt>Range#include?</tt> on non-number-or-time-ish ranges checks all
       # possible values in the range for equality, which is slower but more accurate.
       # <tt>Range#cover?</tt> uses the previous logic of comparing a value with the range
-      # endpoints, which is fast but is only accurate on Numeric, Time, or DateTime ranges.
+      # endpoints, which is fast but is only accurate on Numeric, Time, Date,
+      # or DateTime ranges.
       def inclusion_method(enumerable)
         if enumerable.is_a? Range
           case enumerable.first
-          when Numeric, Time, DateTime
+          when Numeric, Time, DateTime, Date
             :cover?
           else
             :include?

data/lib/active_model/validations/confirmation.rb

@@ -1,29 +1,40 @@
-module ActiveModel
+# frozen_string_literal: true
 
+module ActiveModel
   module Validations
     class ConfirmationValidator < EachValidator # :nodoc:
       def initialize(options)
-        super
+        super({ case_sensitive: true }.merge!(options))
         setup!(options[:class])
       end
 
       def validate_each(record, attribute, value)
-        if (confirmed = record.send("#{attribute}_confirmation")) && (value != confirmed)
-          human_attribute_name = record.class.human_attribute_name(attribute)
-          record.errors.add(:"#{attribute}_confirmation", :confirmation, options.merge(attribute: human_attribute_name))
+        unless (confirmed = record.public_send("#{attribute}_confirmation")).nil?
+          unless confirmation_value_equal?(record, attribute, value, confirmed)
+            human_attribute_name = record.class.human_attribute_name(attribute)
+            record.errors.add(:"#{attribute}_confirmation", :confirmation, **options.except(:case_sensitive).merge!(attribute: human_attribute_name))
+          end
         end
       end
 
       private
-      def setup!(klass)
-        klass.send(:attr_reader, *attributes.map do |attribute|
-          :"#{attribute}_confirmation" unless klass.method_defined?(:"#{attribute}_confirmation")
-        end.compact)
+        def setup!(klass)
+          klass.attr_reader(*attributes.map do |attribute|
+            :"#{attribute}_confirmation" unless klass.method_defined?(:"#{attribute}_confirmation")
+          end.compact)
 
-        klass.send(:attr_writer, *attributes.map do |attribute|
-          :"#{attribute}_confirmation" unless klass.method_defined?(:"#{attribute}_confirmation=")
-        end.compact)
-      end
+          klass.attr_writer(*attributes.map do |attribute|
+            :"#{attribute}_confirmation" unless klass.method_defined?(:"#{attribute}_confirmation=")
+          end.compact)
+        end
+
+        def confirmation_value_equal?(record, attribute, value, confirmed)
+          if !options[:case_sensitive] && value.is_a?(String)
+            value.casecmp(confirmed) == 0
+          else
+            value == confirmed
+          end
+        end
     end
 
     module HelperMethods
@@ -55,10 +66,12 @@ module ActiveModel
       # Configuration options:
       # * <tt>:message</tt> - A custom error message (default is: "doesn't match
       #   <tt>%{translated_attribute_name}</tt>").
+      # * <tt>:case_sensitive</tt> - Looks for an exact match. Ignored by
+      #   non-text columns (+true+ by default).
       #
       # There is also a list of default options supported by every validator:
       # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+.
-      # See <tt>ActiveModel::Validation#validates</tt> 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

@@ -1,14 +1,15 @@
+# frozen_string_literal: true
+
 require "active_model/validations/clusivity"
 
 module ActiveModel
-
   module Validations
     class ExclusionValidator < EachValidator # :nodoc:
       include Clusivity
 
       def validate_each(record, attribute, value)
         if include?(record, value)
-          record.errors.add(attribute, :exclusion, options.except(:in, :within).merge!(value: value))
+          record.errors.add(attribute, :exclusion, **options.except(:in, :within).merge!(value: value))
         end
       end
     end
@@ -29,7 +30,9 @@ 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 range the test is performed with
+      #   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>
       #   <tt>Range#cover?</tt>, otherwise with <tt>include?</tt>.
       # * <tt>:message</tt> - Specifies a custom error message (default is: "is
@@ -37,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 <tt>ActiveModel::Validation#validates</tt> 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

@@ -1,14 +1,15 @@
-module ActiveModel
+# frozen_string_literal: true
 
+module ActiveModel
   module Validations
     class FormatValidator < EachValidator # :nodoc:
       def validate_each(record, attribute, value)
         if options[:with]
           regexp = option_call(record, :with)
-          record_error(record, attribute, :with, value) if value.to_s !~ regexp
+          record_error(record, attribute, :with, value) unless regexp.match?(value.to_s)
         elsif options[:without]
           regexp = option_call(record, :without)
-          record_error(record, attribute, :without, value) if value.to_s =~ regexp
+          record_error(record, attribute, :without, value) if regexp.match?(value.to_s)
         end
       end
 
@@ -22,34 +23,33 @@ module ActiveModel
       end
 
       private
+        def option_call(record, name)
+          option = options[name]
+          option.respond_to?(:call) ? option.call(record) : option
+        end
 
-      def option_call(record, name)
-        option = options[name]
-        option.respond_to?(:call) ? option.call(record) : option
-      end
-
-      def record_error(record, attribute, name, value)
-        record.errors.add(attribute, :invalid, options.except(name).merge!(value: value))
-      end
+        def record_error(record, attribute, name, value)
+          record.errors.add(attribute, :invalid, **options.except(name).merge!(value: value))
+        end
 
-      def check_options_validity(name)
-        if option = options[name]
-          if option.is_a?(Regexp)
-            if options[:multiline] != true && regexp_using_multiline_anchors?(option)
-              raise ArgumentError, "The provided regular expression is using multiline anchors (^ or $), " \
-              "which may present a security risk. Did you mean to use \\A and \\z, or forgot to add the " \
-              ":multiline => true option?"
+        def check_options_validity(name)
+          if option = options[name]
+            if option.is_a?(Regexp)
+              if options[:multiline] != true && regexp_using_multiline_anchors?(option)
+                raise ArgumentError, "The provided regular expression is using multiline anchors (^ or $), " \
+                "which may present a security risk. Did you mean to use \\A and \\z, or forgot to add the " \
+                ":multiline => true option?"
+              end
+            elsif !option.respond_to?(:call)
+              raise ArgumentError, "A regular expression or a proc or lambda must be supplied as :#{name}"
             end
-          elsif !option.respond_to?(:call)
-            raise ArgumentError, "A regular expression or a proc or lambda must be supplied as :#{name}"
           end
         end
-      end
 
-      def regexp_using_multiline_anchors?(regexp)
-        source = regexp.source
-        source.start_with?("^") || (source.end_with?("$") && !source.end_with?("\\$"))
-      end
+        def regexp_using_multiline_anchors?(regexp)
+          source = regexp.source
+          source.start_with?("^") || (source.end_with?("$") && !source.end_with?("\\$"))
+        end
     end
 
     module HelperMethods
@@ -77,7 +77,7 @@ module ActiveModel
       #                         with: ->(person) { person.admin? ? /\A[a-z0-9][a-z0-9_\-]*\z/i : /\A[a-z][a-z0-9_\-]*\z/i }
       #   end
       #
-      # Note: use <tt>\A</tt> and <tt>\Z</tt> to match the start and end of the
+      # Note: use <tt>\A</tt> and <tt>\z</tt> to match the start and end of the
       # string, <tt>^</tt> and <tt>$</tt> match the start/end of a line.
       #
       # Due to frequent misuse of <tt>^</tt> and <tt>$</tt>, you need to pass
@@ -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 <tt>ActiveModel::Validation#validates</tt> 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/helper_methods.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Validations
+    module HelperMethods # :nodoc:
+      private
+        def _merge_attributes(attr_names)
+          options = attr_names.extract_options!.symbolize_keys
+          attr_names.flatten!
+          options[:attributes] = attr_names
+          options
+        end
+    end
+  end
+end

data/lib/active_model/validations/inclusion.rb

@@ -1,14 +1,15 @@
+# frozen_string_literal: true
+
 require "active_model/validations/clusivity"
 
 module ActiveModel
-
   module Validations
     class InclusionValidator < EachValidator # :nodoc:
       include Clusivity
 
       def validate_each(record, attribute, value)
         unless include?(record, value)
-          record.errors.add(attribute, :inclusion, options.except(:in, :within).merge!(value: value))
+          record.errors.add(attribute, :inclusion, **options.except(:in, :within).merge!(value: value))
         end
       end
     end
@@ -18,7 +19,7 @@ module ActiveModel
       # particular enumerable object.
       #
       #   class Person < ActiveRecord::Base
-      #     validates_inclusion_of :gender, in: %w( m f )
+      #     validates_inclusion_of :role, in: %w( admin contributor )
       #     validates_inclusion_of :age, in: 0..99
       #     validates_inclusion_of :format, in: %w( jpg gif png ), message: "extension %{value} is not included in the list"
       #     validates_inclusion_of :states, in: ->(person) { STATES[person.country] }
@@ -28,16 +29,16 @@ 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 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.
+      #   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>
       # * <tt>:message</tt> - Specifies a custom error message (default is: "is
       #   not included in the list").
       #
       # There is also a list of default options supported by every validator:
       # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+.
-      # See <tt>ActiveModel::Validation#validates</tt> 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