Merge pull request #21533

Move ActiveRecord::Type to ActiveModel

The intention has always been to move the attributes API off of Active
Record and onto Active Model. This is the first step in that transition.
This merges the pull request (which has been squashed and rebased), with
various changes to the code to get the quality to a level which is
acceptable to merge.

Close #21533

21 files changed, 816 insertions, 0 deletions

diff --git a/activemodel/lib/active_model/type.rb b/activemodel/lib/active_model/type.rb
new file mode 100644
index 0000000000..e45354f417
--- /dev/null
+++ b/activemodel/lib/active_model/type.rb
@@ -0,0 +1,57 @@
+require 'active_model/type/helpers'
+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/decimal_without_scale'
+require 'active_model/type/float'
+require 'active_model/type/integer'
+require 'active_model/type/string'
+require 'active_model/type/text'
+require 'active_model/type/time'
+require 'active_model/type/unsigned_integer'
+
+require 'active_model/type/registry'
+
+module ActiveModel
+  module Type
+    @registry = Registry.new
+
+    class << self
+      attr_accessor :registry # :nodoc:
+      delegate :add_modifier, to: :registry
+
+      # Add a new type to the registry, allowing it to be referenced as a
+      # symbol by ActiveModel::Attributes::ClassMethods#attribute.  If your
+      # type is only meant to be used with a specific database adapter, you can
+      # do so by passing +adapter: :postgresql+. If your type has the same
+      # name as a native type for the current adapter, an exception will be
+      # raised unless you specify an +:override+ option. +override: true+ will
+      # cause your type to be used instead of the native type. +override:
+      # false+ will cause the native type to be used over yours if one exists.
+      def register(type_name, klass = nil, **options, &block)
+        registry.register(type_name, klass, **options, &block)
+      end
+
+      def lookup(*args, **kwargs) # :nodoc:
+        registry.lookup(*args, **kwargs)
+      end
+    end
+
+    register(:big_integer, Type::BigInteger, override: false)
+    register(:binary, Type::Binary, override: false)
+    register(:boolean, Type::Boolean, override: false)
+    register(:date, Type::Date, override: false)
+    register(:date_time, Type::DateTime, override: false)
+    register(:decimal, Type::Decimal, override: false)
+    register(:float, Type::Float, override: false)
+    register(:integer, Type::Integer, override: false)
+    register(:string, Type::String, override: false)
+    register(:text, Type::Text, override: false)
+    register(:time, Type::Time, override: false)
+  end
+end
diff --git a/activemodel/lib/active_model/type/big_integer.rb b/activemodel/lib/active_model/type/big_integer.rb
new file mode 100644
index 0000000000..4168cbfce7
--- /dev/null
+++ b/activemodel/lib/active_model/type/big_integer.rb
@@ -0,0 +1,13 @@
+require 'active_model/type/integer'
+
+module ActiveModel
+  module Type
+    class BigInteger < Integer # :nodoc:
+      private
+
+      def max_value
+        ::Float::INFINITY
+      end
+    end
+  end
+end
diff --git a/activemodel/lib/active_model/type/binary.rb b/activemodel/lib/active_model/type/binary.rb
new file mode 100644
index 0000000000..a0cc45b4c3
--- /dev/null
+++ b/activemodel/lib/active_model/type/binary.rb
@@ -0,0 +1,50 @@
+module ActiveModel
+  module Type
+    class Binary < Value # :nodoc:
+      def type
+        :binary
+      end
+
+      def binary?
+        true
+      end
+
+      def cast(value)
+        if value.is_a?(Data)
+          value.to_s
+        else
+          super
+        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
+        end
+
+        def to_s
+          @value
+        end
+        alias_method :to_str, :to_s
+
+        def hex
+          @value.unpack('H*')[0]
+        end
+
+        def ==(other)
+          other == to_s || super
+        end
+      end
+    end
+  end
+end
diff --git a/activemodel/lib/active_model/type/boolean.rb b/activemodel/lib/active_model/type/boolean.rb
new file mode 100644
index 0000000000..c1bce98c87
--- /dev/null
+++ b/activemodel/lib/active_model/type/boolean.rb
@@ -0,0 +1,21 @@
+module ActiveModel
+  module Type
+    class Boolean < Value # :nodoc:
+      FALSE_VALUES = [false, 0, '0', 'f', 'F', 'false', 'FALSE', 'off', 'OFF'].to_set
+
+      def type
+        :boolean
+      end
+
+      private
+
+      def cast_value(value)
+        if value == ''
+          nil
+        else
+          !FALSE_VALUES.include?(value)
+        end
+      end
+    end
+  end
+end
diff --git a/activemodel/lib/active_model/type/date.rb b/activemodel/lib/active_model/type/date.rb
new file mode 100644
index 0000000000..f74243a22c
--- /dev/null
+++ b/activemodel/lib/active_model/type/date.rb
@@ -0,0 +1,50 @@
+module ActiveModel
+  module Type
+    class Date < Value # :nodoc:
+      include Helpers::AcceptsMultiparameterTime.new
+
+      def type
+        :date
+      end
+
+      def type_cast_for_schema(value)
+        "'#{value.to_s(:db)}'"
+      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)
+        new_date(*::Date._parse(string, false).values_at(:year, :mon, :mday))
+      end
+
+      def new_date(year, mon, mday)
+        if year && year != 0
+          ::Date.new(year, mon, mday) rescue nil
+        end
+      end
+
+      def value_from_multiparameter_assignment(*)
+        time = super
+        time && time.to_date
+      end
+    end
+  end
+end
diff --git a/activemodel/lib/active_model/type/date_time.rb b/activemodel/lib/active_model/type/date_time.rb
new file mode 100644
index 0000000000..b068cfc672
--- /dev/null
+++ b/activemodel/lib/active_model/type/date_time.rb
@@ -0,0 +1,44 @@
+module ActiveModel
+  module Type
+    class DateTime < Value # :nodoc:
+      include Helpers::TimeValue
+      include Helpers::AcceptsMultiparameterTime.new(
+        defaults: { 4 => 0, 5 => 0 }
+      )
+
+      def type
+        :datetime
+      end
+
+      private
+
+      def cast_value(string)
+        return string unless string.is_a?(::String)
+        return if string.empty?
+
+        fast_string_to_time(string) || fallback_string_to_time(string)
+      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 = ::Date._parse(string)
+        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_parameter = (1..3).detect { |key| !values_hash.key?(key) }
+        if missing_parameter
+          raise ArgumentError, missing_parameter
+        end
+        super
+      end
+    end
+  end
+end
diff --git a/activemodel/lib/active_model/type/decimal.rb b/activemodel/lib/active_model/type/decimal.rb
new file mode 100644
index 0000000000..83a16018ea
--- /dev/null
+++ b/activemodel/lib/active_model/type/decimal.rb
@@ -0,0 +1,50 @@
+module ActiveModel
+  module Type
+    class Decimal < Value # :nodoc:
+      include Helpers::Numeric
+
+      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, ::String
+          BigDecimal(value, precision.to_i)
+        else
+          if value.respond_to?(:to_d)
+            value.to_d
+          else
+            cast_value(value.to_s)
+          end
+        end
+
+        scale ? casted_value.round(scale) : casted_value
+      end
+
+      def convert_float_to_big_decimal(value)
+        if precision
+          BigDecimal(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
+    end
+  end
+end
diff --git a/activemodel/lib/active_model/type/decimal_without_scale.rb b/activemodel/lib/active_model/type/decimal_without_scale.rb
new file mode 100644
index 0000000000..129baa0c10
--- /dev/null
+++ b/activemodel/lib/active_model/type/decimal_without_scale.rb
@@ -0,0 +1,11 @@
+require 'active_model/type/big_integer'
+
+module ActiveModel
+  module Type
+    class DecimalWithoutScale < BigInteger # :nodoc:
+      def type
+        :decimal
+      end
+    end
+  end
+end
diff --git a/activemodel/lib/active_model/type/float.rb b/activemodel/lib/active_model/type/float.rb
new file mode 100644
index 0000000000..0f925bc7e1
--- /dev/null
+++ b/activemodel/lib/active_model/type/float.rb
@@ -0,0 +1,25 @@
+module ActiveModel
+  module Type
+    class Float < Value # :nodoc:
+      include Helpers::Numeric
+
+      def type
+        :float
+      end
+
+      alias serialize cast
+
+      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
diff --git a/activemodel/lib/active_model/type/helpers.rb b/activemodel/lib/active_model/type/helpers.rb
new file mode 100644
index 0000000000..a805a359ab
--- /dev/null
+++ b/activemodel/lib/active_model/type/helpers.rb
@@ -0,0 +1,4 @@
+require 'active_model/type/helpers/accepts_multiparameter_time'
+require 'active_model/type/helpers/numeric'
+require 'active_model/type/helpers/mutable'
+require 'active_model/type/helpers/time_value'
diff --git a/activemodel/lib/active_model/type/helpers/accepts_multiparameter_time.rb b/activemodel/lib/active_model/type/helpers/accepts_multiparameter_time.rb
new file mode 100644
index 0000000000..fa1ccd057e
--- /dev/null
+++ b/activemodel/lib/active_model/type/helpers/accepts_multiparameter_time.rb
@@ -0,0 +1,27 @@
+module ActiveModel
+  module Type
+    module Helpers
+      class AcceptsMultiparameterTime < Module # :nodoc:
+        def initialize(defaults: {})
+          define_method(:cast) do |value|
+            if value.is_a?(Hash)
+              value_from_multiparameter_assignment(value)
+            else
+              super(value)
+            end
+          end
+
+          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.send(default_timezone, *values)
+          end
+          private :value_from_multiparameter_assignment
+        end
+      end
+    end
+  end
+end
diff --git a/activemodel/lib/active_model/type/helpers/mutable.rb b/activemodel/lib/active_model/type/helpers/mutable.rb
new file mode 100644
index 0000000000..4dddbe4e5e
--- /dev/null
+++ b/activemodel/lib/active_model/type/helpers/mutable.rb
@@ -0,0 +1,18 @@
+module ActiveModel
+  module Type
+    module Helpers
+      module Mutable # :nodoc:
+        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
+      end
+    end
+  end
+end
diff --git a/activemodel/lib/active_model/type/helpers/numeric.rb b/activemodel/lib/active_model/type/helpers/numeric.rb
new file mode 100644
index 0000000000..c883010506
--- /dev/null
+++ b/activemodel/lib/active_model/type/helpers/numeric.rb
@@ -0,0 +1,34 @@
+module ActiveModel
+  module Type
+    module Helpers
+      module Numeric # :nodoc:
+        def cast(value)
+          value = case value
+                  when true then 1
+                  when false then 0
+                  when ::String then value.presence
+                  else value
+                  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)
+        end
+
+        private
+
+        def number_to_non_number?(old_value, new_value_before_type_cast)
+          old_value != nil && non_numeric_string?(new_value_before_type_cast)
+        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.
+          value.to_s !~ /\A-?\d+\.?\d*\z/
+        end
+      end
+    end
+  end
+end
diff --git a/activemodel/lib/active_model/type/helpers/time_value.rb b/activemodel/lib/active_model/type/helpers/time_value.rb
new file mode 100644
index 0000000000..0a0e58654b
--- /dev/null
+++ b/activemodel/lib/active_model/type/helpers/time_value.rb
@@ -0,0 +1,74 @@
+require "active_support/core_ext/time/zones"
+
+module ActiveModel
+  module Type
+    module Helpers
+      module TimeValue # :nodoc:
+        def serialize(value)
+          if precision && value.respond_to?(:usec)
+            number_of_insignificant_digits = 6 - precision
+            round_power = 10 ** number_of_insignificant_digits
+            value = value.change(usec: value.usec / round_power * round_power)
+          end
+
+          if value.acts_like?(:time)
+            zone_conversion_method = is_utc? ? :getutc : :getlocal
+
+            if value.respond_to?(zone_conversion_method)
+              value = value.send(zone_conversion_method)
+            end
+          end
+
+          value
+        end
+
+        def is_utc?
+          ::Time.zone_default.nil? || ::Time.zone_default =~ 'UTC'
+        end
+
+        def default_timezone
+          if is_utc?
+            :utc
+          else
+            :local
+          end
+        end
+
+        def type_cast_for_schema(value)
+          "'#{value.to_s(:db)}'"
+        end
+
+        def user_input_in_time_zone(value)
+          value.in_time_zone
+        end
+
+        private
+
+        def new_time(year, mon, mday, hour, min, sec, microsec, offset = nil)
+          # Treat 0000-00-00 00:00:00 as nil.
+          return if year.nil? || (year == 0 && mon == 0 && mday == 0)
+
+          if offset
+            time = ::Time.utc(year, mon, mday, hour, min, sec, microsec) rescue nil
+            return unless time
+
+            time -= offset
+            is_utc? ? time : time.getlocal
+          else
+            ::Time.public_send(default_timezone, year, mon, mday, hour, min, sec, microsec) rescue nil
+          end
+        end
+
+        ISO_DATETIME = /\A(\d{4})-(\d\d)-(\d\d) (\d\d):(\d\d):(\d\d)(\.\d+)?\z/
+
+        # Doesn't handle time zones.
+        def fast_string_to_time(string)
+          if string =~ ISO_DATETIME
+            microsec = ($7.to_r * 1_000_000).to_i
+            new_time $1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i, microsec
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/activemodel/lib/active_model/type/integer.rb b/activemodel/lib/active_model/type/integer.rb
new file mode 100644
index 0000000000..2f73ede009
--- /dev/null
+++ b/activemodel/lib/active_model/type/integer.rb
@@ -0,0 +1,66 @@
+module ActiveModel
+  module Type
+    class Integer < Value # :nodoc:
+      include Helpers::Numeric
+
+      # Column storage size in bytes.
+      # 4 bytes means a MySQL int or Postgres integer as opposed to smallint etc.
+      DEFAULT_LIMIT = 4
+
+      def initialize(*)
+        super
+        @range = min_value...max_value
+      end
+
+      def type
+        :integer
+      end
+
+      def deserialize(value)
+        return if value.nil?
+        value.to_i
+      end
+
+      def serialize(value)
+        result = cast(value)
+        if result
+          ensure_in_range(result)
+        end
+        result
+      end
+
+      protected
+
+      attr_reader :range
+
+      private
+
+      def cast_value(value)
+        case value
+        when true then 1
+        when false then 0
+        else
+          value.to_i rescue nil
+        end
+      end
+
+      def ensure_in_range(value)
+        unless range.cover?(value)
+          raise RangeError, "#{value} is out of range for #{self.class} with limit #{_limit}"
+        end
+      end
+
+      def max_value
+        1 << (_limit * 8 - 1) # 8 bits per byte with one bit for sign
+      end
+
+      def min_value
+        -max_value
+      end
+
+      def _limit
+        self.limit || DEFAULT_LIMIT
+      end
+    end
+  end
+end
diff --git a/activemodel/lib/active_model/type/registry.rb b/activemodel/lib/active_model/type/registry.rb
new file mode 100644
index 0000000000..adc88eb624
--- /dev/null
+++ b/activemodel/lib/active_model/type/registry.rb
@@ -0,0 +1,64 @@
+module ActiveModel
+  # :stopdoc:
+  module Type
+    class Registry
+      def initialize
+        @registrations = []
+      end
+
+      def register(type_name, klass = nil, **options, &block)
+        block ||= proc { |_, *args| klass.new(*args) }
+        registrations << registration_klass.new(type_name, block, **options)
+      end
+
+      def lookup(symbol, *args)
+        registration = find_registration(symbol, *args)
+
+        if registration
+          registration.call(self, symbol, *args)
+        else
+          raise ArgumentError, "Unknown type #{symbol.inspect}"
+        end
+      end
+
+      protected
+
+      attr_reader :registrations
+
+      private
+
+      def registration_klass
+        Registration
+      end
+
+      def find_registration(symbol, *args)
+        registrations.find { |r| r.matches?(symbol, *args) }
+      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, **kwargs)
+        if kwargs.any? # https://bugs.ruby-lang.org/issues/10856
+          block.call(*args, **kwargs)
+        else
+          block.call(*args)
+        end
+      end
+
+      def matches?(type_name, *args, **kwargs)
+        type_name == name
+      end
+
+      protected
+
+      attr_reader :name, :block
+    end
+  end
+  # :startdoc:
+end
diff --git a/activemodel/lib/active_model/type/string.rb b/activemodel/lib/active_model/type/string.rb
new file mode 100644
index 0000000000..fd1630c751
--- /dev/null
+++ b/activemodel/lib/active_model/type/string.rb
@@ -0,0 +1,36 @@
+module ActiveModel
+  module Type
+    class String < Value # :nodoc:
+      def type
+        :string
+      end
+
+      def changed_in_place?(raw_old_value, new_value)
+        if new_value.is_a?(::String)
+          raw_old_value != new_value
+        end
+      end
+
+      def serialize(value)
+        case value
+        when ::Numeric, ActiveSupport::Duration then value.to_s
+        when ::String then ::String.new(value)
+        when true then "t"
+        when false then "f"
+        else super
+        end
+      end
+
+      private
+
+      def cast_value(value)
+        case value
+        when true then "t"
+        when false then "f"
+        # String.new is slightly faster than dup
+        else ::String.new(value.to_s)
+        end
+      end
+    end
+  end
+end
diff --git a/activemodel/lib/active_model/type/text.rb b/activemodel/lib/active_model/type/text.rb
new file mode 100644
index 0000000000..1ad04daba4
--- /dev/null
+++ b/activemodel/lib/active_model/type/text.rb
@@ -0,0 +1,11 @@
+require 'active_model/type/string'
+
+module ActiveModel
+  module Type
+    class Text < String # :nodoc:
+      def type
+        :text
+      end
+    end
+  end
+end
diff --git a/activemodel/lib/active_model/type/time.rb b/activemodel/lib/active_model/type/time.rb
new file mode 100644
index 0000000000..7101bad566
--- /dev/null
+++ b/activemodel/lib/active_model/type/time.rb
@@ -0,0 +1,42 @@
+module ActiveModel
+  module Type
+    class Time < Value # :nodoc:
+      include Helpers::TimeValue
+      include Helpers::AcceptsMultiparameterTime.new(
+        defaults: { 1 => 1970, 2 => 1, 3 => 1, 4 => 0, 5 => 0 }
+      )
+
+      def type
+        :time
+      end
+
+      def user_input_in_time_zone(value)
+        return unless value.present?
+
+        case value
+        when ::String
+          value = "2000-01-01 #{value}"
+        when ::Time
+          value = value.change(year: 2000, day: 1, month: 1)
+        end
+
+        super(value)
+      end
+
+      private
+
+      def cast_value(value)
+        return value unless value.is_a?(::String)
+        return if value.empty?
+
+        dummy_time_value = "2000-01-01 #{value}"
+
+        fast_string_to_time(dummy_time_value) || begin
+          time_hash = ::Date._parse(dummy_time_value)
+          return if time_hash[:hour].nil?
+          new_time(*time_hash.values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction))
+        end
+      end
+    end
+  end
+end
diff --git a/activemodel/lib/active_model/type/unsigned_integer.rb b/activemodel/lib/active_model/type/unsigned_integer.rb
new file mode 100644
index 0000000000..3f49f9f5f7
--- /dev/null
+++ b/activemodel/lib/active_model/type/unsigned_integer.rb
@@ -0,0 +1,15 @@
+module ActiveModel
+  module Type
+    class UnsignedInteger < Integer # :nodoc:
+      private
+
+      def max_value
+        super * 2
+      end
+
+      def min_value
+        0
+      end
+    end
+  end
+end
diff --git a/activemodel/lib/active_model/type/value.rb b/activemodel/lib/active_model/type/value.rb
new file mode 100644
index 0000000000..c7d1197d69
--- /dev/null
+++ b/activemodel/lib/active_model/type/value.rb
@@ -0,0 +1,104 @@
+module ActiveModel
+  module Type
+    class Value
+      attr_reader :precision, :scale, :limit
+
+      def initialize(precision: nil, limit: nil, scale: nil)
+        @precision = precision
+        @scale = scale
+        @limit = limit
+      end
+
+      def type # :nodoc:
+      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 ==(other)
+        self.class == other.class &&
+          precision == other.precision &&
+          scale == other.scale &&
+          limit == other.limit
+      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