omg-activemodel 8.0.0.alpha1

data/lib/active_model/type/big_integer.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "active_model/type/integer"
+
+module ActiveModel
+  module Type
+    # = Active Model \BigInteger \Type
+    #
+    # Attribute type for integers that can be serialized to an unlimited number
+    # of bytes. This type is registered under the +:big_integer+ key.
+    #
+    #   class Person
+    #     include ActiveModel::Attributes
+    #
+    #     attribute :id, :big_integer
+    #   end
+    #
+    #   person = Person.new
+    #   person.id = "18_000_000_000"
+    #
+    #   person.id # => 18000000000
+    #
+    # All casting and serialization are performed in the same way as the
+    # standard ActiveModel::Type::Integer type.
+    class BigInteger < Integer
+      def serialize_cast_value(value) # :nodoc:
+        value
+      end
+
+      private
+        def max_value
+          ::Float::INFINITY
+        end
+    end
+  end
+end

data/lib/active_model/type/binary.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Type
+    # = Active Model \Binary \Type
+    #
+    # Attribute type for representation of binary data. This type is registered
+    # under the +:binary+ key.
+    #
+    # Non-string values are coerced to strings using their +to_s+ method.
+    class Binary < Value
+      def type
+        :binary
+      end
+
+      def binary?
+        true
+      end
+
+      def cast(value)
+        if value.is_a?(Data)
+          value.to_s
+        else
+          value = super
+          value = value.b if ::String === value && value.encoding != Encoding::BINARY
+          value
+        end
+      end
+
+      def serialize(value)
+        return if value.nil?
+        Data.new(super)
+      end
+
+      def changed_in_place?(raw_old_value, value)
+        old_value = deserialize(raw_old_value)
+        old_value != value
+      end
+
+      class Data # :nodoc:
+        def initialize(value)
+          value = value.to_s
+          value = value.b unless value.encoding == Encoding::BINARY
+          @value = value
+        end
+
+        def to_s
+          @value
+        end
+        alias_method :to_str, :to_s
+
+        def hex
+          @value.unpack1("H*")
+        end
+
+        def ==(other)
+          other == to_s || super
+        end
+      end
+    end
+  end
+end

data/lib/active_model/type/boolean.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Type
+    # = Active Model \Boolean \Type
+    #
+    # A class that behaves like a boolean type, including rules for coercion of
+    # user input.
+    #
+    # - <tt>"false"</tt>, <tt>"f"</tt>, <tt>"0"</tt>, +0+ or any other value in
+    #   +FALSE_VALUES+ will be coerced to +false+.
+    # - Empty strings are coerced to +nil+.
+    # - All other values will be coerced to +true+.
+    class Boolean < Value
+      FALSE_VALUES = [
+        false, 0,
+        "0", :"0",
+        "f", :f,
+        "F", :F,
+        "false", :false,
+        "FALSE", :FALSE,
+        "off", :off,
+        "OFF", :OFF,
+      ].to_set.freeze
+
+      def type # :nodoc:
+        :boolean
+      end
+
+      def serialize(value) # :nodoc:
+        cast(value)
+      end
+
+      def serialize_cast_value(value) # :nodoc:
+        value
+      end
+
+      private
+        def cast_value(value)
+          if value == ""
+            nil
+          else
+            !FALSE_VALUES.include?(value)
+          end
+        end
+    end
+  end
+end

data/lib/active_model/type/date.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Type
+    # = Active Model \Date \Type
+    #
+    # Attribute type for date representation. It is registered under the
+    # +:date+ key.
+    #
+    #   class Person
+    #     include ActiveModel::Attributes
+    #
+    #     attribute :birthday, :date
+    #   end
+    #
+    #   person = Person.new
+    #   person.birthday = "1989-07-13"
+    #
+    #   person.birthday.class # => Date
+    #   person.birthday.year  # => 1989
+    #   person.birthday.month # => 7
+    #   person.birthday.day   # => 13
+    #
+    # String values are parsed using the ISO 8601 date format. Any other values
+    # are cast using their +to_date+ method, if it exists.
+    class Date < Value
+      include Helpers::Timezone
+      include Helpers::AcceptsMultiparameterTime.new
+
+      def type
+        :date
+      end
+
+      def type_cast_for_schema(value)
+        value.to_fs(:db).inspect
+      end
+
+      private
+        def cast_value(value)
+          if value.is_a?(::String)
+            return if value.empty?
+            fast_string_to_date(value) || fallback_string_to_date(value)
+          elsif value.respond_to?(:to_date)
+            value.to_date
+          else
+            value
+          end
+        end
+
+        ISO_DATE = /\A(\d{4})-(\d\d)-(\d\d)\z/
+        def fast_string_to_date(string)
+          if string =~ ISO_DATE
+            new_date $1.to_i, $2.to_i, $3.to_i
+          end
+        end
+
+        def fallback_string_to_date(string)
+          parts = begin
+            ::Date._parse(string, false)
+          rescue ArgumentError
+          end
+
+          new_date(*parts.values_at(:year, :mon, :mday)) if parts
+        end
+
+        def new_date(year, mon, mday)
+          unless year.nil? || (year == 0 && mon == 0 && mday == 0)
+            ::Date.new(year, mon, mday) rescue nil
+          end
+        end
+
+        def value_from_multiparameter_assignment(*)
+          time = super
+          time && new_date(time.year, time.mon, time.mday)
+        end
+    end
+  end
+end

data/lib/active_model/type/date_time.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Type
+    # = Active Model \DateTime \Type
+    #
+    # Attribute type to represent dates and times. It is registered under the
+    # +:datetime+ key.
+    #
+    #   class Event
+    #     include ActiveModel::Attributes
+    #
+    #     attribute :start, :datetime
+    #   end
+    #
+    #   event = Event.new
+    #   event.start = "Wed, 04 Sep 2013 03:00:00 EAT"
+    #
+    #   event.start.class # => Time
+    #   event.start.year  # => 2013
+    #   event.start.month # => 9
+    #   event.start.day   # => 4
+    #   event.start.hour  # => 3
+    #   event.start.min   # => 0
+    #   event.start.sec   # => 0
+    #   event.start.zone  # => "EAT"
+    #
+    # String values are parsed using the ISO 8601 datetime format. Partial
+    # time-only formats are also accepted.
+    #
+    #   event.start = "06:07:08+09:00"
+    #   event.start.utc # => 1999-12-31 21:07:08 UTC
+    #
+    # The degree of sub-second precision can be customized when declaring an
+    # attribute:
+    #
+    #   class Event
+    #     include ActiveModel::Attributes
+    #
+    #     attribute :start, :datetime, precision: 4
+    #   end
+    class DateTime < Value
+      include Helpers::Timezone
+      include Helpers::AcceptsMultiparameterTime.new(
+        defaults: { 4 => 0, 5 => 0 }
+      )
+      include Helpers::TimeValue
+
+      def type
+        :datetime
+      end
+
+      private
+        def cast_value(value)
+          return apply_seconds_precision(value) unless value.is_a?(::String)
+          return if value.empty?
+
+          fast_string_to_time(value) || fallback_string_to_time(value)
+        end
+
+        # '0.123456' -> 123456
+        # '1.123456' -> 123456
+        def microseconds(time)
+          time[:sec_fraction] ? (time[:sec_fraction] * 1_000_000).to_i : 0
+        end
+
+        def fallback_string_to_time(string)
+          time_hash = begin
+            ::Date._parse(string)
+          rescue ArgumentError
+          end
+          return unless time_hash
+
+          time_hash[:sec_fraction] = microseconds(time_hash)
+
+          new_time(*time_hash.values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction, :offset))
+        end
+
+        def value_from_multiparameter_assignment(values_hash)
+          missing_parameters = [1, 2, 3].delete_if { |key| values_hash.key?(key) }
+          unless missing_parameters.empty?
+            raise ArgumentError, "Provided hash #{values_hash} doesn't contain necessary keys: #{missing_parameters}"
+          end
+          super
+        end
+    end
+  end
+end

data/lib/active_model/type/decimal.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "bigdecimal/util"
+
+module ActiveModel
+  module Type
+    # = Active Model \Decimal \Type
+    #
+    # Attribute type for decimal, high-precision floating point numeric
+    # representation. It is registered under the +:decimal+ key.
+    #
+    #   class BagOfCoffee
+    #     include ActiveModel::Attributes
+    #
+    #     attribute :weight, :decimal
+    #   end
+    #
+    # Numeric instances are converted to BigDecimal instances. Any other objects
+    # are cast using their +to_d+ method, except for blank strings, which are
+    # cast to +nil+. If a +to_d+ method is not defined, the object is converted
+    # to a string using +to_s+, which is then cast using +to_d+.
+    #
+    #   bag = BagOfCoffee.new
+    #
+    #   bag.weight = 0.01
+    #   bag.weight # => 0.1e-1
+    #
+    #   bag.weight = "0.01"
+    #   bag.weight # => 0.1e-1
+    #
+    #   bag.weight = ""
+    #   bag.weight # => nil
+    #
+    #   bag.weight = :arbitrary
+    #   bag.weight # => nil (the result of `.to_s.to_d`)
+    #
+    # Decimal precision defaults to 18, and can be customized when declaring an
+    # attribute:
+    #
+    #   class BagOfCoffee
+    #     include ActiveModel::Attributes
+    #
+    #     attribute :weight, :decimal, precision: 24
+    #   end
+    class Decimal < Value
+      include Helpers::Numeric
+      BIGDECIMAL_PRECISION = 18
+
+      def type
+        :decimal
+      end
+
+      def type_cast_for_schema(value)
+        value.to_s.inspect
+      end
+
+      private
+        def cast_value(value)
+          casted_value = \
+            case value
+            when ::Float
+              convert_float_to_big_decimal(value)
+            when ::Numeric
+              BigDecimal(value, precision || BIGDECIMAL_PRECISION)
+            when ::String
+              begin
+                value.to_d
+              rescue ArgumentError
+                BigDecimal(0)
+              end
+            else
+              if value.respond_to?(:to_d)
+                value.to_d
+              else
+                cast_value(value.to_s)
+              end
+            end
+
+          apply_scale(casted_value)
+        end
+
+        def convert_float_to_big_decimal(value)
+          if precision
+            BigDecimal(apply_scale(value), float_precision)
+          else
+            value.to_d
+          end
+        end
+
+        def float_precision
+          if precision.to_i > ::Float::DIG + 1
+            ::Float::DIG + 1
+          else
+            precision.to_i
+          end
+        end
+
+        def apply_scale(value)
+          if scale
+            value.round(scale)
+          else
+            value
+          end
+        end
+    end
+  end
+end

data/lib/active_model/type/float.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/try"
+
+module ActiveModel
+  module Type
+    # = Active Model \Float \Type
+    #
+    # Attribute type for floating point numeric values. It is registered under
+    # the +:float+ key.
+    #
+    #   class BagOfCoffee
+    #     include ActiveModel::Attributes
+    #
+    #     attribute :weight, :float
+    #   end
+    #
+    # Values are cast using their +to_f+ method, except for the following
+    # strings:
+    #
+    # - Blank strings are cast to +nil+.
+    # - <tt>"Infinity"</tt> is cast to +Float::INFINITY+.
+    # - <tt>"-Infinity"</tt> is cast to <tt>-Float::INFINITY</tt>.
+    # - <tt>"NaN"</tt> is cast to +Float::NAN+.
+    #
+    #   bag = BagOfCoffee.new
+    #
+    #   bag.weight = "0.25"
+    #   bag.weight # => 0.25
+    #
+    #   bag.weight = ""
+    #   bag.weight # => nil
+    #
+    #   bag.weight = "NaN"
+    #   bag.weight # => Float::NAN
+    class Float < Value
+      include Helpers::Numeric
+
+      def type
+        :float
+      end
+
+      def type_cast_for_schema(value)
+        return "::Float::NAN" if value.try(:nan?)
+        case value
+        when ::Float::INFINITY then "::Float::INFINITY"
+        when -::Float::INFINITY then "-::Float::INFINITY"
+        else super
+        end
+      end
+
+      private
+        def cast_value(value)
+          case value
+          when ::Float then value
+          when "Infinity" then ::Float::INFINITY
+          when "-Infinity" then -::Float::INFINITY
+          when "NaN" then ::Float::NAN
+          else value.to_f
+          end
+        end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Type
+    module Helpers # :nodoc: all
+      class AcceptsMultiparameterTime < Module
+        module InstanceMethods
+          def serialize(value)
+            serialize_cast_value(cast(value))
+          end
+
+          def serialize_cast_value(value)
+            value
+          end
+
+          def cast(value)
+            if value.is_a?(Hash)
+              value_from_multiparameter_assignment(value)
+            else
+              super(value)
+            end
+          end
+
+          def assert_valid_value(value)
+            if value.is_a?(Hash)
+              value_from_multiparameter_assignment(value)
+            else
+              super(value)
+            end
+          end
+
+          def value_constructed_by_mass_assignment?(value)
+            value.is_a?(Hash)
+          end
+        end
+
+        def initialize(defaults: {})
+          include InstanceMethods
+
+          define_method(:value_from_multiparameter_assignment) do |values_hash|
+            defaults.each do |k, v|
+              values_hash[k] ||= v
+            end
+            return unless values_hash[1] && values_hash[2] && values_hash[3]
+            values = values_hash.sort.map!(&:last)
+            ::Time.public_send(default_timezone, *values)
+          end
+          private :value_from_multiparameter_assignment
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Type
+    module Helpers # :nodoc: all
+      module Mutable
+        def cast(value)
+          deserialize(serialize(value))
+        end
+
+        # +raw_old_value+ will be the `_before_type_cast` version of the
+        # value (likely a string). +new_value+ will be the current, type
+        # cast value.
+        def changed_in_place?(raw_old_value, new_value)
+          raw_old_value != serialize(new_value)
+        end
+
+        def mutable? # :nodoc:
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Type
+    module Helpers # :nodoc: all
+      module Numeric
+        def serialize(value)
+          cast(value)
+        end
+
+        def serialize_cast_value(value)
+          value
+        end
+
+        def cast(value)
+          # Checks whether the value is numeric. Spaceship operator
+          # will return nil if value is not numeric.
+          value = if value <=> 0
+            value
+          else
+            case value
+            when true then 1
+            when false then 0
+            else value.presence
+            end
+          end
+
+          super(value)
+        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)
+        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 && !new_value_before_type_cast.is_a?(::Numeric) &&
+              non_numeric_string?(new_value_before_type_cast.to_s)
+          end
+
+          def non_numeric_string?(value)
+            # 'wibble'.to_i will give zero, we want to make sure
+            # that we aren't marking int zero to string zero as
+            # changed.
+            !NUMERIC_REGEX.match?(value)
+          end
+
+          NUMERIC_REGEX = /\A\s*[+-]?\d/
+          private_constant :NUMERIC_REGEX
+      end
+    end
+  end
+end