activemodel 6.0.0

data/lib/active_model/validations/absence.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Validations
+    # == \Active \Model Absence Validator
+    class AbsenceValidator < EachValidator #:nodoc:
+      def validate_each(record, attr_name, value)
+        record.errors.add(attr_name, :present, options) if value.present?
+      end
+    end
+
+    module HelperMethods
+      # Validates that the specified attributes are blank (as defined by
+      # Object#blank?). Happens by default on save.
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_absence_of :first_name
+      #   end
+      #
+      # The first_name attribute must be in the object and it must be blank.
+      #
+      # Configuration options:
+      # * <tt>:message</tt> - A custom error message (default is: "must be blank").
+      #
+      # There is also a list of default options supported by every validator:
+      # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+.
+      # See <tt>ActiveModel::Validations#validates</tt> for more information
+      def validates_absence_of(*attr_names)
+        validates_with AbsenceValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end

data/lib/active_model/validations/acceptance.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Validations
+    class AcceptanceValidator < EachValidator # :nodoc:
+      def initialize(options)
+        super({ allow_nil: true, accept: ["1", true] }.merge!(options))
+        setup!(options[:class])
+      end
+
+      def validate_each(record, attribute, value)
+        unless acceptable_option?(value)
+          record.errors.add(attribute, :accepted, options.except(:accept, :allow_nil))
+        end
+      end
+
+      private
+
+        def setup!(klass)
+          klass.include(LazilyDefineAttributes.new(AttributeDefinition.new(attributes)))
+        end
+
+        def acceptable_option?(value)
+          Array(options[:accept]).include?(value)
+        end
+
+        class LazilyDefineAttributes < Module
+          def initialize(attribute_definition)
+            define_method(:respond_to_missing?) do |method_name, include_private = false|
+              super(method_name, include_private) || attribute_definition.matches?(method_name)
+            end
+
+            define_method(:method_missing) do |method_name, *args, &block|
+              if attribute_definition.matches?(method_name)
+                attribute_definition.define_on(self.class)
+                send(method_name, *args, &block)
+              else
+                super(method_name, *args, &block)
+              end
+            end
+          end
+        end
+
+        class AttributeDefinition
+          def initialize(attributes)
+            @attributes = attributes.map(&:to_s)
+          end
+
+          def matches?(method_name)
+            attr_name = convert_to_reader_name(method_name)
+            attributes.include?(attr_name)
+          end
+
+          def define_on(klass)
+            attr_readers = attributes.reject { |name| klass.attribute_method?(name) }
+            attr_writers = attributes.reject { |name| klass.attribute_method?("#{name}=") }
+            klass.define_attribute_methods
+            klass.attr_reader(*attr_readers)
+            klass.attr_writer(*attr_writers)
+          end
+
+          private
+            attr_reader :attributes
+
+            def convert_to_reader_name(method_name)
+              method_name.to_s.chomp("=")
+            end
+        end
+    end
+
+    module HelperMethods
+      # Encapsulates the pattern of wanting to validate the acceptance of a
+      # terms of service check box (or similar agreement).
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_acceptance_of :terms_of_service
+      #     validates_acceptance_of :eula, message: 'must be abided'
+      #   end
+      #
+      # If the database column does not exist, the +terms_of_service+ attribute
+      # is entirely virtual. This check is performed only if +terms_of_service+
+      # is not +nil+ and by default on save.
+      #
+      # Configuration options:
+      # * <tt>:message</tt> - A custom error message (default is: "must be
+      #   accepted").
+      # * <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::Validations#validates</tt> for more information.
+      def validates_acceptance_of(*attr_names)
+        validates_with AcceptanceValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end

data/lib/active_model/validations/callbacks.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Validations
+    # == Active \Model \Validation \Callbacks
+    #
+    # Provides an interface for any class to have +before_validation+ and
+    # +after_validation+ callbacks.
+    #
+    # First, include ActiveModel::Validations::Callbacks from the class you are
+    # creating:
+    #
+    #   class MyModel
+    #     include ActiveModel::Validations::Callbacks
+    #
+    #     before_validation :do_stuff_before_validation
+    #     after_validation  :do_stuff_after_validation
+    #   end
+    #
+    # 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,
+                         skip_after_callbacks_if_terminated: true,
+                         scope: [:kind, :name]
+      end
+
+      module ClassMethods
+        # Defines a callback that will get called right before validation.
+        #
+        #   class Person
+        #     include ActiveModel::Validations
+        #     include ActiveModel::Validations::Callbacks
+        #
+        #     attr_accessor :name
+        #
+        #     validates_length_of :name, maximum: 6
+        #
+        #     before_validation :remove_whitespaces
+        #
+        #     private
+        #
+        #     def remove_whitespaces
+        #       name.strip!
+        #     end
+        #   end
+        #
+        #   person = Person.new
+        #   person.name = '  bob  '
+        #   person.valid? # => true
+        #   person.name   # => "bob"
+        def before_validation(*args, &block)
+          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] & Array(o.validation_context)).empty?
+            }
+          end
+
+          set_callback(:validation, :before, *args, options, &block)
+        end
+
+        # Defines a callback that will get called right after validation.
+        #
+        #   class Person
+        #     include ActiveModel::Validations
+        #     include ActiveModel::Validations::Callbacks
+        #
+        #     attr_accessor :name, :status
+        #
+        #     validates_presence_of :name
+        #
+        #     after_validation :set_status
+        #
+        #     private
+        #
+        #     def set_status
+        #       self.status = errors.empty?
+        #     end
+        #   end
+        #
+        #   person = Person.new
+        #   person.name = ''
+        #   person.valid? # => false
+        #   person.status # => false
+        #   person.name = 'bob'
+        #   person.valid? # => true
+        #   person.status # => true
+        def after_validation(*args, &block)
+          options = args.extract_options!
+          options = options.dup
+          options[:prepend] = true
+
+          if options.key?(:on)
+            options[:on] = Array(options[:on])
+            options[:if] = Array(options[:if])
+            options[:if].unshift ->(o) {
+              !(options[:on] & Array(o.validation_context)).empty?
+            }
+          end
+
+          set_callback(:validation, :after, *args, options, &block)
+        end
+      end
+
+    private
+
+      # Overwrite run validations to include callbacks.
+      def run_validations!
+        _run_validation_callbacks { super }
+      end
+    end
+  end
+end

data/lib/active_model/validations/clusivity.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/range"
+
+module ActiveModel
+  module Validations
+    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"
+
+      def check_validity!
+        unless delimiter.respond_to?(:include?) || delimiter.respond_to?(:call) || delimiter.respond_to?(:to_sym)
+          raise ArgumentError, ERROR_MESSAGE
+        end
+      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
+
+        members.send(inclusion_method(members), value)
+      end
+
+      def delimiter
+        @delimiter ||= options[:in] || options[:within]
+      end
+
+      # 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, Date,
+      # or DateTime ranges.
+      def inclusion_method(enumerable)
+        if enumerable.is_a? Range
+          case enumerable.first
+          when Numeric, Time, DateTime, Date
+            :cover?
+          else
+            :include?
+          end
+        else
+          :include?
+        end
+      end
+    end
+  end
+end

data/lib/active_model/validations/confirmation.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Validations
+    class ConfirmationValidator < EachValidator # :nodoc:
+      def initialize(options)
+        super({ case_sensitive: true }.merge!(options))
+        setup!(options[:class])
+      end
+
+      def validate_each(record, attribute, value)
+        unless (confirmed = record.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.attr_reader(*attributes.map do |attribute|
+            :"#{attribute}_confirmation" unless klass.method_defined?(:"#{attribute}_confirmation")
+          end.compact)
+
+          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
+      # Encapsulates the pattern of wanting to validate a password or email
+      # address field with a confirmation.
+      #
+      #   Model:
+      #     class Person < ActiveRecord::Base
+      #       validates_confirmation_of :user_name, :password
+      #       validates_confirmation_of :email_address,
+      #                                 message: 'should match confirmation'
+      #     end
+      #
+      #   View:
+      #     <%= password_field "person", "password" %>
+      #     <%= password_field "person", "password_confirmation" %>
+      #
+      # The added +password_confirmation+ attribute is virtual; it exists only
+      # as an in-memory attribute for validating the password. To achieve this,
+      # the validation adds accessors to the model for the confirmation
+      # attribute.
+      #
+      # NOTE: This check is performed only if +password_confirmation+ is not
+      # +nil+. To require confirmation, make sure to add a presence check for
+      # the confirmation attribute:
+      #
+      #   validates_presence_of :password_confirmation, if: :password_changed?
+      #
+      # 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::Validations#validates</tt> for more information
+      def validates_confirmation_of(*attr_names)
+        validates_with ConfirmationValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end

data/lib/active_model/validations/exclusion.rb

@@ -0,0 +1,49 @@
+# 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))
+        end
+      end
+    end
+
+    module HelperMethods
+      # Validates that the value of the specified attribute is not in a
+      # particular enumerable object.
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_exclusion_of :username, in: %w( admin superuser ), message: "You don't belong here"
+      #     validates_exclusion_of :age, in: 30..60, message: 'This site is only for under 30 and over 60'
+      #     validates_exclusion_of :format, in: %w( mov avi ), message: "extension %{value} is not allowed"
+      #     validates_exclusion_of :password, in: ->(person) { [person.username, person.first_name] },
+      #                            message: 'should not be the same as your username or first name'
+      #     validates_exclusion_of :karma, in: :reserved_karmas
+      #   end
+      #
+      # 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
+      #   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
+      #   reserved").
+      #
+      # There is also a list of default options supported by every validator:
+      # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+.
+      # See <tt>ActiveModel::Validations#validates</tt> for more information
+      def validates_exclusion_of(*attr_names)
+        validates_with ExclusionValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end

data/lib/active_model/validations/format.rb

@@ -0,0 +1,114 @@
+# 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
+        elsif options[:without]
+          regexp = option_call(record, :without)
+          record_error(record, attribute, :without, value) if regexp.match?(value.to_s)
+        end
+      end
+
+      def check_validity!
+        unless options.include?(:with) ^ options.include?(:without)  # ^ == xor, or "exclusive or"
+          raise ArgumentError, "Either :with or :without must be supplied (but not both)"
+        end
+
+        check_options_validity :with
+        check_options_validity :without
+      end
+
+      private
+
+        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 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
+          end
+        end
+
+        def regexp_using_multiline_anchors?(regexp)
+          source = regexp.source
+          source.start_with?("^") || (source.end_with?("$") && !source.end_with?("\\$"))
+        end
+    end
+
+    module HelperMethods
+      # Validates whether the value of the specified attribute is of the correct
+      # form, going by the regular expression provided. You can require that the
+      # attribute matches the regular expression:
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_format_of :email, with: /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\z/i, on: :create
+      #   end
+      #
+      # Alternatively, you can require that the specified attribute does _not_
+      # match the regular expression:
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_format_of :email, without: /NOSPAM/
+      #   end
+      #
+      # You can also provide a proc or lambda which will determine the regular
+      # expression that will be used to validate the attribute.
+      #
+      #   class Person < ActiveRecord::Base
+      #     # Admin can have number as a first letter in their screen name
+      #     validates_format_of :screen_name,
+      #                         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
+      # 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
+      # the <tt>multiline: true</tt> option in case you use any of these two
+      # anchors in the provided regular expression. In most cases, you should be
+      # using <tt>\A</tt> and <tt>\z</tt>.
+      #
+      # You must pass either <tt>:with</tt> or <tt>:without</tt> as an option.
+      # In addition, both must be a regular expression or a proc or lambda, or
+      # else an exception will be raised.
+      #
+      # Configuration options:
+      # * <tt>:message</tt> - A custom error message (default is: "is invalid").
+      # * <tt>:with</tt> - Regular expression that if the attribute matches will
+      #   result in a successful validation. This can be provided as a proc or
+      #   lambda returning regular expression which will be called at runtime.
+      # * <tt>:without</tt> - Regular expression that if the attribute does not
+      #   match will result in a successful validation. This can be provided as
+      #   a proc or lambda returning regular expression which will be called at
+      #   runtime.
+      # * <tt>:multiline</tt> - Set to true if your regular expression contains
+      #   anchors that match the beginning or end of lines as opposed to the
+      #   beginning or end of the string. These anchors are <tt>^</tt> and <tt>$</tt>.
+      #
+      # There is also a list of default options supported by every validator:
+      # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+.
+      # See <tt>ActiveModel::Validations#validates</tt> for more information
+      def validates_format_of(*attr_names)
+        validates_with FormatValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end