omg-activemodel 8.0.0.alpha1

data/lib/active_model/type/value.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Type
+    # = Active Model \Value \Type
+    #
+    # The base class for all attribute types. This class also serves as the
+    # default type for attributes that do not specify a type.
+    class Value
+      include SerializeCastValue
+      attr_reader :precision, :scale, :limit
+
+      # Initializes a type with three basic configuration settings: precision,
+      # limit, and scale. The Value base class does not define behavior for
+      # these settings. It uses them for equality comparison and hash key
+      # generation only.
+      def initialize(precision: nil, limit: nil, scale: nil)
+        super()
+        @precision = precision
+        @scale = scale
+        @limit = limit
+      end
+
+      # Returns true if this type can convert +value+ to a type that is usable
+      # by the database.  For example a boolean type can return +true+ if the
+      # value parameter is a Ruby boolean, but may return +false+ if the value
+      # parameter is some other object.
+      def serializable?(value)
+        true
+      end
+
+      # Returns the unique type name as a Symbol. Subclasses should override
+      # this method.
+      def type
+      end
+
+      # Converts a value from database input to the appropriate ruby type. The
+      # return value of this method will be returned from
+      # ActiveRecord::AttributeMethods::Read#read_attribute. The default
+      # implementation just calls Value#cast.
+      #
+      # +value+ The raw input, as provided from the database.
+      def deserialize(value)
+        cast(value)
+      end
+
+      # Type casts a value from user input (e.g. from a setter). This value may
+      # be a string from the form builder, or a ruby object passed to a setter.
+      # There is currently no way to differentiate between which source it came
+      # from.
+      #
+      # The return value of this method will be returned from
+      # ActiveRecord::AttributeMethods::Read#read_attribute. See also:
+      # Value#cast_value.
+      #
+      # +value+ The raw input, as provided to the attribute setter.
+      def cast(value)
+        cast_value(value) unless value.nil?
+      end
+
+      # Casts a value from the ruby type to a type that the database knows how
+      # to understand. The returned value from this method should be a
+      # +String+, +Numeric+, +Date+, +Time+, +Symbol+, +true+, +false+, or
+      # +nil+.
+      def serialize(value)
+        value
+      end
+
+      # Type casts a value for schema dumping. This method is private, as we are
+      # hoping to remove it entirely.
+      def type_cast_for_schema(value) # :nodoc:
+        value.inspect
+      end
+
+      # These predicates are not documented, as I need to look further into
+      # their use, and see if they can be removed entirely.
+      def binary? # :nodoc:
+        false
+      end
+
+      # Determines whether a value has changed for dirty checking. +old_value+
+      # and +new_value+ will always be type-cast. Types should not need to
+      # override this method.
+      def changed?(old_value, new_value, _new_value_before_type_cast)
+        old_value != new_value
+      end
+
+      # Determines whether the mutable value has been modified since it was
+      # read. Returns +false+ by default. If your type returns an object
+      # which could be mutated, you should override this method. You will need
+      # to either:
+      #
+      # - pass +new_value+ to Value#serialize and compare it to
+      #   +raw_old_value+
+      #
+      # or
+      #
+      # - pass +raw_old_value+ to Value#deserialize and compare it to
+      #   +new_value+
+      #
+      # +raw_old_value+ The original value, before being passed to
+      # +deserialize+.
+      #
+      # +new_value+ The current value, after type casting.
+      def changed_in_place?(raw_old_value, new_value)
+        false
+      end
+
+      def value_constructed_by_mass_assignment?(_value) # :nodoc:
+        false
+      end
+
+      def force_equality?(_value) # :nodoc:
+        false
+      end
+
+      def map(value) # :nodoc:
+        yield value
+      end
+
+      def ==(other)
+        self.class == other.class &&
+          precision == other.precision &&
+          scale == other.scale &&
+          limit == other.limit
+      end
+      alias eql? ==
+
+      def hash
+        [self.class, precision, scale, limit].hash
+      end
+
+      def assert_valid_value(_)
+      end
+
+      def serialized? # :nodoc:
+        false
+      end
+
+      def mutable? # :nodoc:
+        false
+      end
+
+      def as_json(*)
+        raise NoMethodError
+      end
+
+      private
+        # Convenience method for types which do not need separate type casting
+        # behavior for user and database inputs. Called by Value#cast for
+        # values except +nil+.
+        def cast_value(value) # :doc:
+          value
+        end
+    end
+  end
+end

data/lib/active_model/type.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "active_model/type/helpers"
+require "active_model/type/serialize_cast_value"
+require "active_model/type/value"
+
+require "active_model/type/big_integer"
+require "active_model/type/binary"
+require "active_model/type/boolean"
+require "active_model/type/date"
+require "active_model/type/date_time"
+require "active_model/type/decimal"
+require "active_model/type/float"
+require "active_model/type/immutable_string"
+require "active_model/type/integer"
+require "active_model/type/string"
+require "active_model/type/time"
+
+require "active_model/type/registry"
+
+module ActiveModel
+  module Type
+    @registry = Registry.new
+
+    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)
+      end
+
+      def lookup(...) # :nodoc:
+        registry.lookup(...)
+      end
+
+      def default_value # :nodoc:
+        @default_value ||= Value.new
+      end
+    end
+
+    register(:big_integer, Type::BigInteger)
+    register(:binary, Type::Binary)
+    register(:boolean, Type::Boolean)
+    register(:date, Type::Date)
+    register(:datetime, Type::DateTime)
+    register(:decimal, Type::Decimal)
+    register(:float, Type::Float)
+    register(:immutable_string, Type::ImmutableString)
+    register(:integer, Type::Integer)
+    register(:string, Type::String)
+    register(:time, Type::Time)
+  end
+end

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#present?).
+      #
+      #   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 ActiveModel::Validations::ClassMethods#validates 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,113 @@
+# 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)
+          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
+      # 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+.
+      #
+      # 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 ActiveModel::Validations::ClassMethods#validates 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,119 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Validations
+    # = Active \Model \Validation \Callbacks
+    #
+    # Provides an interface for any class to have ClassMethods#before_validation and
+    # ClassMethods#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!
+
+          set_options_for_callback(options)
+
+          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
+
+          set_options_for_callback(options)
+
+          set_callback(:validation, :after, *args, options, &block)
+        end
+
+        private
+          def set_options_for_callback(options)
+            if options.key?(:on)
+              options[:on] = Array(options[:on])
+              options[:if] = [
+                ->(o) {
+                  options[:on].intersect?(Array(o.validation_context))
+                },
+                *options[:if]
+              ]
+            end
+          end
+      end
+
+    private
+      # Override 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_model/validations/resolve_value"
+require "active_support/core_ext/range"
+
+module ActiveModel
+  module Validations
+    module Clusivity # :nodoc:
+      include ResolveValue
+
+      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 = resolve_value(record, delimiter)
+
+        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
+
+      # 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.begin || enumerable.end
+          when Numeric, Time, DateTime, Date
+            :cover?
+          else
+            :include?
+          end
+        else
+          :include?
+        end
+      end
+    end
+  end
+end

data/lib/active_model/validations/comparability.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Validations
+    module Comparability # :nodoc:
+      COMPARE_CHECKS = { greater_than: :>, greater_than_or_equal_to: :>=,
+        equal_to: :==, less_than: :<, less_than_or_equal_to: :<=,
+        other_than: :!= }.freeze
+
+      def error_options(value, option_value)
+        options.except(*COMPARE_CHECKS.keys).merge!(
+          count: option_value,
+          value: value
+        )
+      end
+    end
+  end
+end

data/lib/active_model/validations/comparison.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "active_model/validations/comparability"
+require "active_model/validations/resolve_value"
+
+module ActiveModel
+  module Validations
+    class ComparisonValidator < EachValidator # :nodoc:
+      include Comparability
+      include ResolveValue
+
+      def check_validity!
+        unless options.keys.intersect?(COMPARE_CHECKS.keys)
+          raise ArgumentError, "Expected one of :greater_than, :greater_than_or_equal_to, "\
+          ":equal_to, :less_than, :less_than_or_equal_to, or :other_than option to be supplied."
+        end
+      end
+
+      def validate_each(record, attr_name, value)
+        options.slice(*COMPARE_CHECKS.keys).each do |option, raw_option_value|
+          option_value = resolve_value(record, raw_option_value)
+
+          if value.nil? || value.blank?
+            return record.errors.add(attr_name, :blank, **error_options(value, option_value))
+          end
+
+          unless value.public_send(COMPARE_CHECKS[option], option_value)
+            record.errors.add(attr_name, option, **error_options(value, option_value))
+          end
+        rescue ArgumentError => e
+          record.errors.add(attr_name, e.message)
+        end
+      end
+    end
+
+    module HelperMethods
+      # Validates the value of a specified attribute fulfills all
+      # defined comparisons with another value, proc, or attribute.
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_comparison_of :value, greater_than: 'the sum of its parts'
+      #   end
+      #
+      # Configuration options:
+      # * <tt>:message</tt> - A custom error message (default is: "failed comparison").
+      # * <tt>:greater_than</tt> - Specifies the value must be greater than the
+      #   supplied value. The default error message for this option is _"must be
+      #   greater than %{count}"_.
+      # * <tt>:greater_than_or_equal_to</tt> - Specifies the value must be
+      #   greater than or equal to the supplied value. The default error message
+      #   for this option is _"must be greater than or equal to %{count}"_.
+      # * <tt>:equal_to</tt> - Specifies the value must be equal to the supplied
+      #   value. The default error message for this option is _"must be equal to
+      #   %{count}"_.
+      # * <tt>:less_than</tt> - Specifies the value must be less than the
+      #   supplied value. The default error message for this option is _"must be
+      #   less than %{count}"_.
+      # * <tt>:less_than_or_equal_to</tt> - Specifies the value must be less
+      #   than or equal to the supplied value. The default error message for
+      #   this option is _"must be less than or equal to %{count}"_.
+      # * <tt>:other_than</tt> - Specifies the value must not be equal to the
+      #   supplied value. The default error message for this option is _"must be
+      #   other than %{count}"_.
+      #
+      # 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.
+      #
+      # The validator requires at least one of the following checks to be supplied.
+      # Each will accept a proc, value, or a symbol which corresponds to a method:
+      #
+      # * <tt>:greater_than</tt>
+      # * <tt>:greater_than_or_equal_to</tt>
+      # * <tt>:equal_to</tt>
+      # * <tt>:less_than</tt>
+      # * <tt>:less_than_or_equal_to</tt>
+      # * <tt>:other_than</tt>
+      #
+      # For example:
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_comparison_of :birth_date, less_than_or_equal_to: -> { Date.today }
+      #     validates_comparison_of :preferred_name, other_than: :given_name, allow_nil: true
+      #   end
+      def validates_comparison_of(*attr_names)
+        validates_with ComparisonValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end