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

42 files changed, 655 insertions, 426 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/activerecord/lib/active_record/type/big_integer.rb b/activemodel/lib/active_model/type/big_integer.rb
index 0c72d8914f..4168cbfce7 100644
--- a/activerecord/lib/active_record/type/big_integer.rb
+++ b/activemodel/lib/active_model/type/big_integer.rb
@@ -1,6 +1,6 @@
-require 'active_record/type/integer'
+require 'active_model/type/integer'
 
-module ActiveRecord
+module ActiveModel
   module Type
     class BigInteger < Integer # :nodoc:
       private
diff --git a/activerecord/lib/active_record/type/binary.rb b/activemodel/lib/active_model/type/binary.rb
index 0baf8c63ad..a0cc45b4c3 100644
--- a/activerecord/lib/active_record/type/binary.rb
+++ b/activemodel/lib/active_model/type/binary.rb
@@ -1,4 +1,4 @@
-module ActiveRecord
+module ActiveModel
   module Type
     class Binary < Value # :nodoc:
       def type
diff --git a/activerecord/lib/active_record/type/boolean.rb b/activemodel/lib/active_model/type/boolean.rb
index f6a75512fd..c1bce98c87 100644
--- a/activerecord/lib/active_record/type/boolean.rb
+++ b/activemodel/lib/active_model/type/boolean.rb
@@ -1,6 +1,8 @@
-module ActiveRecord
+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
@@ -11,7 +13,7 @@ module ActiveRecord
         if value == ''
           nil
         else
-          !ConnectionAdapters::Column::FALSE_VALUES.include?(value)
+          !FALSE_VALUES.include?(value)
         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/activerecord/lib/active_record/type/decimal.rb b/activemodel/lib/active_model/type/decimal.rb
index f5b145230d..83a16018ea 100644
--- a/activerecord/lib/active_record/type/decimal.rb
+++ b/activemodel/lib/active_model/type/decimal.rb
@@ -1,4 +1,4 @@
-module ActiveRecord
+module ActiveModel
   module Type
     class Decimal < Value # :nodoc:
       include Helpers::Numeric
diff --git a/activerecord/lib/active_record/type/decimal_without_scale.rb b/activemodel/lib/active_model/type/decimal_without_scale.rb
index ff5559e300..129baa0c10 100644
--- a/activerecord/lib/active_record/type/decimal_without_scale.rb
+++ b/activemodel/lib/active_model/type/decimal_without_scale.rb
@@ -1,6 +1,6 @@
-require 'active_record/type/big_integer'
+require 'active_model/type/big_integer'
 
-module ActiveRecord
+module ActiveModel
   module Type
     class DecimalWithoutScale < BigInteger # :nodoc:
       def type
diff --git a/activerecord/lib/active_record/type/float.rb b/activemodel/lib/active_model/type/float.rb
index d88482b85d..0f925bc7e1 100644
--- a/activerecord/lib/active_record/type/float.rb
+++ b/activemodel/lib/active_model/type/float.rb
@@ -1,4 +1,4 @@
-module ActiveRecord
+module ActiveModel
   module Type
     class Float < Value # :nodoc:
       include Helpers::Numeric
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/activerecord/lib/active_record/type/helpers/accepts_multiparameter_time.rb b/activemodel/lib/active_model/type/helpers/accepts_multiparameter_time.rb
index be571fc1c7..fa1ccd057e 100644
--- a/activerecord/lib/active_record/type/helpers/accepts_multiparameter_time.rb
+++ b/activemodel/lib/active_model/type/helpers/accepts_multiparameter_time.rb
@@ -1,4 +1,4 @@
-module ActiveRecord
+module ActiveModel
   module Type
     module Helpers
       class AcceptsMultiparameterTime < Module # :nodoc:
@@ -17,10 +17,7 @@ module ActiveRecord
             end
             return unless values_hash[1] && values_hash[2] && values_hash[3]
             values = values_hash.sort.map(&:last)
-            ::Time.send(
-              ActiveRecord::Base.default_timezone,
-              *values
-            )
+            ::Time.send(default_timezone, *values)
           end
           private :value_from_multiparameter_assignment
         end
diff --git a/activerecord/lib/active_record/type/helpers/mutable.rb b/activemodel/lib/active_model/type/helpers/mutable.rb
index 88a9099277..4dddbe4e5e 100644
--- a/activerecord/lib/active_record/type/helpers/mutable.rb
+++ b/activemodel/lib/active_model/type/helpers/mutable.rb
@@ -1,4 +1,4 @@
-module ActiveRecord
+module ActiveModel
   module Type
     module Helpers
       module Mutable # :nodoc:
diff --git a/activerecord/lib/active_record/type/helpers/numeric.rb b/activemodel/lib/active_model/type/helpers/numeric.rb
index a755a02a59..c883010506 100644
--- a/activerecord/lib/active_record/type/helpers/numeric.rb
+++ b/activemodel/lib/active_model/type/helpers/numeric.rb
@@ -1,4 +1,4 @@
-module ActiveRecord
+module ActiveModel
   module Type
     module Helpers
       module Numeric # :nodoc:
diff --git a/activerecord/lib/active_record/type/helpers/time_value.rb b/activemodel/lib/active_model/type/helpers/time_value.rb
index 7eb41557cb..0a0e58654b 100644
--- a/activerecord/lib/active_record/type/helpers/time_value.rb
+++ b/activemodel/lib/active_model/type/helpers/time_value.rb
@@ -1,4 +1,6 @@
-module ActiveRecord
+require "active_support/core_ext/time/zones"
+
+module ActiveModel
   module Type
     module Helpers
       module TimeValue # :nodoc:
@@ -10,7 +12,7 @@ module ActiveRecord
           end
 
           if value.acts_like?(:time)
-            zone_conversion_method = ActiveRecord::Base.default_timezone == :utc ? :getutc : :getlocal
+            zone_conversion_method = is_utc? ? :getutc : :getlocal
 
             if value.respond_to?(zone_conversion_method)
               value = value.send(zone_conversion_method)
@@ -20,6 +22,18 @@ module ActiveRecord
           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
@@ -39,15 +53,17 @@ module ActiveRecord
             return unless time
 
             time -= offset
-            Base.default_timezone == :utc ? time : time.getlocal
+            is_utc? ? time : time.getlocal
           else
-            ::Time.public_send(Base.default_timezone, year, mon, mday, hour, min, sec, microsec) rescue nil
+            ::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 =~ ConnectionAdapters::Column::Format::ISO_DATETIME
+          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
diff --git a/activerecord/lib/active_record/type/integer.rb b/activemodel/lib/active_model/type/integer.rb
index c5040c6d3b..2f73ede009 100644
--- a/activerecord/lib/active_record/type/integer.rb
+++ b/activemodel/lib/active_model/type/integer.rb
@@ -1,4 +1,4 @@
-module ActiveRecord
+module ActiveModel
   module Type
     class Integer < Value # :nodoc:
       include Helpers::Numeric
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/activerecord/lib/active_record/type/string.rb b/activemodel/lib/active_model/type/string.rb
index 2662b7e874..fd1630c751 100644
--- a/activerecord/lib/active_record/type/string.rb
+++ b/activemodel/lib/active_model/type/string.rb
@@ -1,4 +1,4 @@
-module ActiveRecord
+module ActiveModel
   module Type
     class String < Value # :nodoc:
       def type
diff --git a/activerecord/lib/active_record/type/text.rb b/activemodel/lib/active_model/type/text.rb
index 26f980f060..1ad04daba4 100644
--- a/activerecord/lib/active_record/type/text.rb
+++ b/activemodel/lib/active_model/type/text.rb
@@ -1,6 +1,6 @@
-require 'active_record/type/string'
+require 'active_model/type/string'
 
-module ActiveRecord
+module ActiveModel
   module Type
     class Text < String # :nodoc:
       def type
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/activerecord/lib/active_record/type/unsigned_integer.rb b/activemodel/lib/active_model/type/unsigned_integer.rb
index ed3e527483..3f49f9f5f7 100644
--- a/activerecord/lib/active_record/type/unsigned_integer.rb
+++ b/activemodel/lib/active_model/type/unsigned_integer.rb
@@ -1,4 +1,4 @@
-module ActiveRecord
+module ActiveModel
   module Type
     class UnsignedInteger < Integer # :nodoc:
       private
diff --git a/activerecord/lib/active_record/type/value.rb b/activemodel/lib/active_model/type/value.rb
index 6b9d147ecc..c7d1197d69 100644
--- a/activerecord/lib/active_record/type/value.rb
+++ b/activemodel/lib/active_model/type/value.rb
@@ -1,4 +1,4 @@
-module ActiveRecord
+module ActiveModel
   module Type
     class Value
       attr_reader :precision, :scale, :limit
diff --git a/activerecord/test/cases/type/decimal_test.rb b/activemodel/test/cases/type/decimal_test.rb
index 01ee36b892..353dbf84ad 100644
--- a/activerecord/test/cases/type/decimal_test.rb
+++ b/activemodel/test/cases/type/decimal_test.rb
@@ -1,8 +1,9 @@
 require "cases/helper"
+require "active_model/type"
 
-module ActiveRecord
+module ActiveModel
   module Type
-    class DecimalTest < ActiveRecord::TestCase
+    class DecimalTest < ActiveModel::TestCase
       def test_type_cast_decimal
         type = Decimal.new
         assert_equal BigDecimal.new("0"), type.cast(BigDecimal.new("0"))
diff --git a/activemodel/test/cases/type/integer_test.rb b/activemodel/test/cases/type/integer_test.rb
new file mode 100644
index 0000000000..dac922db42
--- /dev/null
+++ b/activemodel/test/cases/type/integer_test.rb
@@ -0,0 +1,108 @@
+require "cases/helper"
+require "active_model/type"
+
+module ActiveModel
+  module Type
+    class IntegerTest < ActiveModel::TestCase
+      test "simple values" do
+        type = Type::Integer.new
+        assert_equal 1, type.cast(1)
+        assert_equal 1, type.cast('1')
+        assert_equal 1, type.cast('1ignore')
+        assert_equal 0, type.cast('bad1')
+        assert_equal 0, type.cast('bad')
+        assert_equal 1, type.cast(1.7)
+        assert_equal 0, type.cast(false)
+        assert_equal 1, type.cast(true)
+        assert_nil type.cast(nil)
+      end
+
+      test "random objects cast to nil" do
+        type = Type::Integer.new
+        assert_nil type.cast([1,2])
+        assert_nil type.cast({1 => 2})
+        assert_nil type.cast(1..2)
+      end
+
+      test "casting objects without to_i" do
+        type = Type::Integer.new
+        assert_nil type.cast(::Object.new)
+      end
+
+      test "casting nan and infinity" do
+        type = Type::Integer.new
+        assert_nil type.cast(::Float::NAN)
+        assert_nil type.cast(1.0/0.0)
+      end
+
+      test "casting booleans for database" do
+        type = Type::Integer.new
+        assert_equal 1, type.serialize(true)
+        assert_equal 0, type.serialize(false)
+      end
+
+      test "changed?" do
+        type = Type::Integer.new
+
+        assert type.changed?(5, 5, '5wibble')
+        assert_not type.changed?(5, 5, '5')
+        assert_not type.changed?(5, 5, '5.0')
+        assert_not type.changed?(-5, -5, '-5')
+        assert_not type.changed?(-5, -5, '-5.0')
+        assert_not type.changed?(nil, nil, nil)
+      end
+
+      test "values below int min value are out of range" do
+        assert_raises(::RangeError) do
+          Integer.new.serialize(-2147483649)
+        end
+      end
+
+      test "values above int max value are out of range" do
+        assert_raises(::RangeError) do
+          Integer.new.serialize(2147483648)
+        end
+      end
+
+      test "very small numbers are out of range" do
+        assert_raises(::RangeError) do
+          Integer.new.serialize(-9999999999999999999999999999999)
+        end
+      end
+
+      test "very large numbers are out of range" do
+        assert_raises(::RangeError) do
+          Integer.new.serialize(9999999999999999999999999999999)
+        end
+      end
+
+      test "normal numbers are in range" do
+        type = Integer.new
+        assert_equal(0, type.serialize(0))
+        assert_equal(-1, type.serialize(-1))
+        assert_equal(1, type.serialize(1))
+      end
+
+      test "int max value is in range" do
+        assert_equal(2147483647, Integer.new.serialize(2147483647))
+      end
+
+      test "int min value is in range" do
+        assert_equal(-2147483648, Integer.new.serialize(-2147483648))
+      end
+
+      test "columns with a larger limit have larger ranges" do
+        type = Integer.new(limit: 8)
+
+        assert_equal(9223372036854775807, type.serialize(9223372036854775807))
+        assert_equal(-9223372036854775808, type.serialize(-9223372036854775808))
+        assert_raises(::RangeError) do
+          type.serialize(-9999999999999999999999999999999)
+        end
+        assert_raises(::RangeError) do
+          type.serialize(9999999999999999999999999999999)
+        end
+      end
+    end
+  end
+end
diff --git a/activemodel/test/cases/type/registry_test.rb b/activemodel/test/cases/type/registry_test.rb
new file mode 100644
index 0000000000..2a48998a62
--- /dev/null
+++ b/activemodel/test/cases/type/registry_test.rb
@@ -0,0 +1,39 @@
+require "cases/helper"
+require "active_model/type"
+
+module ActiveModel
+  class RegistryTest < ActiveModel::TestCase
+    test "a class can be registered for a symbol" do
+      registry = Type::Registry.new
+      registry.register(:foo, ::String)
+      registry.register(:bar, ::Array)
+
+      assert_equal "", registry.lookup(:foo)
+      assert_equal [], registry.lookup(:bar)
+    end
+
+    test "a block can be registered" do
+      registry = Type::Registry.new
+      registry.register(:foo) do |*args|
+        [*args, "block for foo"]
+      end
+      registry.register(:bar) do |*args|
+        [*args, "block for bar"]
+      end
+
+      assert_equal [:foo, 1, "block for foo"], registry.lookup(:foo, 1)
+      assert_equal [:foo, 2, "block for foo"], registry.lookup(:foo, 2)
+      assert_equal [:bar, 1, 2, 3, "block for bar"], registry.lookup(:bar, 1, 2, 3)
+    end
+
+    test "a reasonable error is given when no type is found" do
+      registry = Type::Registry.new
+
+      e = assert_raises(ArgumentError) do
+        registry.lookup(:foo)
+      end
+
+      assert_equal "Unknown type :foo", e.message
+    end
+  end
+end
diff --git a/activemodel/test/cases/type/string_test.rb b/activemodel/test/cases/type/string_test.rb
new file mode 100644
index 0000000000..8ec771ea42
--- /dev/null
+++ b/activemodel/test/cases/type/string_test.rb
@@ -0,0 +1,20 @@
+require "cases/helper"
+require "active_model/type"
+
+module ActiveModel
+  class StringTypeTest < ActiveModel::TestCase
+    test "type casting" do
+      type = Type::String.new
+      assert_equal "t", type.cast(true)
+      assert_equal "f", type.cast(false)
+      assert_equal "123", type.cast(123)
+    end
+
+    test "values are duped coming out" do
+      s = "foo"
+      type = Type::String.new
+      assert_not_same s, type.cast(s)
+      assert_not_same s, type.deserialize(s)
+    end
+  end
+end
diff --git a/activerecord/test/cases/type/unsigned_integer_test.rb b/activemodel/test/cases/type/unsigned_integer_test.rb
index f2c910eade..16301b3ac0 100644
--- a/activerecord/test/cases/type/unsigned_integer_test.rb
+++ b/activemodel/test/cases/type/unsigned_integer_test.rb
@@ -1,8 +1,9 @@
 require "cases/helper"
+require "active_model/type"
 
-module ActiveRecord
+module ActiveModel
   module Type
-    class UnsignedIntegerTest < ActiveRecord::TestCase
+    class UnsignedIntegerTest < ActiveModel::TestCase
       test "unsigned int max value is in range" do
         assert_equal(4294967295, UnsignedInteger.new.serialize(4294967295))
       end
diff --git a/activemodel/test/cases/types_test.rb b/activemodel/test/cases/types_test.rb
new file mode 100644
index 0000000000..0bb971fa39
--- /dev/null
+++ b/activemodel/test/cases/types_test.rb
@@ -0,0 +1,121 @@
+require "cases/helper"
+require "active_model/type"
+
+module ActiveModel
+  class TypesTest < ActiveModel::TestCase
+    def test_type_cast_boolean
+      type = Type::Boolean.new
+      assert type.cast('').nil?
+      assert type.cast(nil).nil?
+
+      assert type.cast(true)
+      assert type.cast(1)
+      assert type.cast('1')
+      assert type.cast('t')
+      assert type.cast('T')
+      assert type.cast('true')
+      assert type.cast('TRUE')
+      assert type.cast('on')
+      assert type.cast('ON')
+      assert type.cast(' ')
+      assert type.cast("\u3000\r\n")
+      assert type.cast("\u0000")
+      assert type.cast('SOMETHING RANDOM')
+
+      # explicitly check for false vs nil
+      assert_equal false, type.cast(false)
+      assert_equal false, type.cast(0)
+      assert_equal false, type.cast('0')
+      assert_equal false, type.cast('f')
+      assert_equal false, type.cast('F')
+      assert_equal false, type.cast('false')
+      assert_equal false, type.cast('FALSE')
+      assert_equal false, type.cast('off')
+      assert_equal false, type.cast('OFF')
+    end
+
+    def test_type_cast_float
+      type = Type::Float.new
+      assert_equal 1.0, type.cast("1")
+    end
+
+    def test_changing_float
+      type = Type::Float.new
+
+      assert type.changed?(5.0, 5.0, '5wibble')
+      assert_not type.changed?(5.0, 5.0, '5')
+      assert_not type.changed?(5.0, 5.0, '5.0')
+      assert_not type.changed?(nil, nil, nil)
+    end
+
+    def test_type_cast_binary
+      type = Type::Binary.new
+      assert_equal nil, type.cast(nil)
+      assert_equal "1", type.cast("1")
+      assert_equal 1, type.cast(1)
+    end
+
+    def test_type_cast_time
+      type = Type::Time.new
+      assert_equal nil, type.cast(nil)
+      assert_equal nil, type.cast('')
+      assert_equal nil, type.cast('ABC')
+
+      time_string = Time.now.utc.strftime("%T")
+      assert_equal time_string, type.cast(time_string).strftime("%T")
+    end
+
+    def test_type_cast_datetime_and_timestamp
+      type = Type::DateTime.new
+      assert_equal nil, type.cast(nil)
+      assert_equal nil, type.cast('')
+      assert_equal nil, type.cast('  ')
+      assert_equal nil, type.cast('ABC')
+
+      datetime_string = Time.now.utc.strftime("%FT%T")
+      assert_equal datetime_string, type.cast(datetime_string).strftime("%FT%T")
+    end
+
+    def test_type_cast_date
+      type = Type::Date.new
+      assert_equal nil, type.cast(nil)
+      assert_equal nil, type.cast('')
+      assert_equal nil, type.cast(' ')
+      assert_equal nil, type.cast('ABC')
+
+      date_string = Time.now.utc.strftime("%F")
+      assert_equal date_string, type.cast(date_string).strftime("%F")
+    end
+
+    def test_type_cast_duration_to_integer
+      type = Type::Integer.new
+      assert_equal 1800, type.cast(30.minutes)
+      assert_equal 7200, type.cast(2.hours)
+    end
+
+    def test_string_to_time_with_timezone
+      ["UTC", "US/Eastern"].each do |zone|
+        with_timezone_config default: zone do
+          type = Type::DateTime.new
+          assert_equal Time.utc(2013, 9, 4, 0, 0, 0), type.cast("Wed, 04 Sep 2013 03:00:00 EAT")
+        end
+      end
+    end
+
+    def test_type_equality
+      assert_equal Type::Value.new, Type::Value.new
+      assert_not_equal Type::Value.new, Type::Integer.new
+      assert_not_equal Type::Value.new(precision: 1), Type::Value.new(precision: 2)
+    end
+
+    private
+
+    def with_timezone_config(default:)
+      old_zone_default = ::Time.zone_default
+      ::Time.zone_default = ::Time.find_zone(default)
+      yield
+    ensure
+      ::Time.zone_default = old_zone_default
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/attribute_methods/query.rb b/activerecord/lib/active_record/attribute_methods/query.rb
index 553122a5fc..10498f4322 100644
--- a/activerecord/lib/active_record/attribute_methods/query.rb
+++ b/activerecord/lib/active_record/attribute_methods/query.rb
@@ -19,7 +19,7 @@ module ActiveRecord
             if Numeric === value || value !~ /[^0-9]/
               !value.to_i.zero?
             else
-              return false if ActiveRecord::ConnectionAdapters::Column::FALSE_VALUES.include?(value)
+              return false if ActiveModel::Type::Boolean::FALSE_VALUES.include?(value)
               !value.blank?
             end
           elsif value.respond_to?(:zero?)
diff --git a/activerecord/lib/active_record/connection_adapters/column.rb b/activerecord/lib/active_record/connection_adapters/column.rb
index 8222811e0c..5e31efec4a 100644
--- a/activerecord/lib/active_record/connection_adapters/column.rb
+++ b/activerecord/lib/active_record/connection_adapters/column.rb
@@ -5,13 +5,6 @@ module ActiveRecord
   module ConnectionAdapters
     # An abstract definition of a column in a table.
     class Column
-      FALSE_VALUES = [false, 0, '0', 'f', 'F', 'false', 'FALSE', 'off', 'OFF'].to_set
-
-      module Format
-        ISO_DATE = /\A(\d{4})-(\d\d)-(\d\d)\z/
-        ISO_DATETIME = /\A(\d{4})-(\d\d)-(\d\d) (\d\d):(\d\d):(\d\d)(\.\d+)?\z/
-      end
-
       attr_reader :name, :null, :sql_type_metadata, :default, :default_function, :collation
 
       delegate :precision, :scale, :limit, :type, :sql_type, to: :sql_type_metadata, allow_nil: true
diff --git a/activerecord/lib/active_record/type.rb b/activerecord/lib/active_record/type.rb
index 53f3b53bec..28ab07e868 100644
--- a/activerecord/lib/active_record/type.rb
+++ b/activerecord/lib/active_record/type.rb
@@ -1,27 +1,18 @@
-require 'active_record/type/helpers'
-require 'active_record/type/value'
+require 'active_model/type'
+
+require 'active_record/type/internal/abstract_json'
+require 'active_record/type/internal/timezone'
 
-require 'active_record/type/big_integer'
-require 'active_record/type/binary'
-require 'active_record/type/boolean'
 require 'active_record/type/date'
 require 'active_record/type/date_time'
-require 'active_record/type/decimal'
-require 'active_record/type/decimal_without_scale'
-require 'active_record/type/float'
-require 'active_record/type/integer'
-require 'active_record/type/serialized'
-require 'active_record/type/string'
-require 'active_record/type/text'
 require 'active_record/type/time'
-require 'active_record/type/unsigned_integer'
 
+require 'active_record/type/serialized'
 require 'active_record/type/adapter_specific_registry'
+
 require 'active_record/type/type_map'
 require 'active_record/type/hash_lookup_type_map'
 
-require 'active_record/type/internal/abstract_json'
-
 module ActiveRecord
   module Type
     @registry = AdapterSpecificRegistry.new
@@ -53,6 +44,18 @@ module ActiveRecord
       end
     end
 
+    BigInteger = ActiveModel::Type::BigInteger
+    Binary = ActiveModel::Type::Binary
+    Boolean = ActiveModel::Type::Boolean
+    Decimal = ActiveModel::Type::Decimal
+    DecimalWithoutScale = ActiveModel::Type::DecimalWithoutScale
+    Float = ActiveModel::Type::Float
+    Integer = ActiveModel::Type::Integer
+    String = ActiveModel::Type::String
+    Text = ActiveModel::Type::Text
+    UnsignedInteger = ActiveModel::Type::UnsignedInteger
+    Value = ActiveModel::Type::Value
+
     register(:big_integer, Type::BigInteger, override: false)
     register(:binary, Type::Binary, override: false)
     register(:boolean, Type::Boolean, override: false)
diff --git a/activerecord/lib/active_record/type/adapter_specific_registry.rb b/activerecord/lib/active_record/type/adapter_specific_registry.rb
index 5f71b3cb94..d440eac619 100644
--- a/activerecord/lib/active_record/type/adapter_specific_registry.rb
+++ b/activerecord/lib/active_record/type/adapter_specific_registry.rb
@@ -1,35 +1,24 @@
+require 'active_model/type/registry'
+
 module ActiveRecord
   # :stopdoc:
   module Type
-    class AdapterSpecificRegistry
-      def initialize
-        @registrations = []
-      end
-
-      def register(type_name, klass = nil, **options, &block)
-        block ||= proc { |_, *args| klass.new(*args) }
-        registrations << Registration.new(type_name, block, **options)
+    class AdapterSpecificRegistry < ActiveModel::Type::Registry
+      def add_modifier(options, klass, **args)
+        registrations << DecorationRegistration.new(options, klass, **args)
       end
 
-      def lookup(symbol, *args)
-        registration = registrations
-          .select { |r| r.matches?(symbol, *args) }
-          .max
+      private
 
-        if registration
-          registration.call(self, symbol, *args)
-        else
-          raise ArgumentError, "Unknown type #{symbol.inspect}"
-        end
+      def registration_klass
+        Registration
       end
 
-      def add_modifier(options, klass, **args)
-        registrations << DecorationRegistration.new(options, klass, **args)
+      def find_registration(symbol, *args)
+        registrations
+          .select { |registration| registration.matches?(symbol, *args) }
+          .max
       end
-
-      protected
-
-      attr_reader :registrations
     end
 
     class Registration
@@ -137,6 +126,5 @@ module ActiveRecord
 
   class TypeConflictError < StandardError
   end
-
   # :startdoc:
 end
diff --git a/activerecord/lib/active_record/type/date.rb b/activerecord/lib/active_record/type/date.rb
index 3ceab59ebb..ccafed054e 100644
--- a/activerecord/lib/active_record/type/date.rb
+++ b/activerecord/lib/active_record/type/date.rb
@@ -1,49 +1,7 @@
 module ActiveRecord
   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
-
-      def fast_string_to_date(string)
-        if string =~ ConnectionAdapters::Column::Format::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
+    class Date < ActiveModel::Type::Date
+      include Internal::Timezone
     end
   end
 end
diff --git a/activerecord/lib/active_record/type/date_time.rb b/activerecord/lib/active_record/type/date_time.rb
index a5199959b9..1fb9380ecd 100644
--- a/activerecord/lib/active_record/type/date_time.rb
+++ b/activerecord/lib/active_record/type/date_time.rb
@@ -1,44 +1,7 @@
 module ActiveRecord
   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
+    class DateTime < ActiveModel::Type::DateTime
+      include Internal::Timezone
     end
   end
 end
diff --git a/activerecord/lib/active_record/type/helpers.rb b/activerecord/lib/active_record/type/helpers.rb
deleted file mode 100644
index 634d417d13..0000000000
--- a/activerecord/lib/active_record/type/helpers.rb
+++ /dev/null
@@ -1,4 +0,0 @@
-require 'active_record/type/helpers/accepts_multiparameter_time'
-require 'active_record/type/helpers/numeric'
-require 'active_record/type/helpers/mutable'
-require 'active_record/type/helpers/time_value'
diff --git a/activerecord/lib/active_record/type/internal/abstract_json.rb b/activerecord/lib/active_record/type/internal/abstract_json.rb
index 963a8245d0..097d1bd363 100644
--- a/activerecord/lib/active_record/type/internal/abstract_json.rb
+++ b/activerecord/lib/active_record/type/internal/abstract_json.rb
@@ -1,8 +1,8 @@
 module ActiveRecord
   module Type
     module Internal # :nodoc:
-      class AbstractJson < Type::Value # :nodoc:
-        include Type::Helpers::Mutable
+      class AbstractJson < ActiveModel::Type::Value # :nodoc:
+        include ActiveModel::Type::Helpers::Mutable
 
         def type
           :json
diff --git a/activerecord/lib/active_record/type/internal/timezone.rb b/activerecord/lib/active_record/type/internal/timezone.rb
new file mode 100644
index 0000000000..947e06158a
--- /dev/null
+++ b/activerecord/lib/active_record/type/internal/timezone.rb
@@ -0,0 +1,15 @@
+module ActiveRecord
+  module Type
+    module Internal
+      module Timezone
+        def is_utc?
+          ActiveRecord::Base.default_timezone == :utc
+        end
+
+        def default_timezone
+          ActiveRecord::Base.default_timezone
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/type/serialized.rb b/activerecord/lib/active_record/type/serialized.rb
index ea3e0d6a45..203a395415 100644
--- a/activerecord/lib/active_record/type/serialized.rb
+++ b/activerecord/lib/active_record/type/serialized.rb
@@ -1,7 +1,7 @@
 module ActiveRecord
   module Type
-    class Serialized < DelegateClass(Type::Value) # :nodoc:
-      include Helpers::Mutable
+    class Serialized < DelegateClass(ActiveModel::Type::Value) # :nodoc:
+      include ActiveModel::Type::Helpers::Mutable
 
       attr_reader :subtype, :coder
 
diff --git a/activerecord/lib/active_record/type/time.rb b/activerecord/lib/active_record/type/time.rb
index 19a10021bc..70988d84ff 100644
--- a/activerecord/lib/active_record/type/time.rb
+++ b/activerecord/lib/active_record/type/time.rb
@@ -1,42 +1,8 @@
 module ActiveRecord
   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
+    class Time < ActiveModel::Type::Time
+      include Internal::Timezone
     end
   end
 end
+
diff --git a/activerecord/lib/active_record/type/type_map.rb b/activerecord/lib/active_record/type/type_map.rb
index 8ce36cc9af..81d7ed39bb 100644
--- a/activerecord/lib/active_record/type/type_map.rb
+++ b/activerecord/lib/active_record/type/type_map.rb
@@ -57,7 +57,7 @@ module ActiveRecord
       end
 
       def default_value
-        @default_value ||= Value.new
+        @default_value ||= ActiveModel::Type::Value.new
       end
     end
   end
diff --git a/activerecord/test/cases/type/integer_test.rb b/activerecord/test/cases/type/integer_test.rb
index 0dcdbd0667..c0932d5357 100644
--- a/activerecord/test/cases/type/integer_test.rb
+++ b/activerecord/test/cases/type/integer_test.rb
@@ -4,112 +4,12 @@ require "models/company"
 module ActiveRecord
   module Type
     class IntegerTest < ActiveRecord::TestCase
-      test "simple values" do
-        type = Type::Integer.new
-        assert_equal 1, type.cast(1)
-        assert_equal 1, type.cast('1')
-        assert_equal 1, type.cast('1ignore')
-        assert_equal 0, type.cast('bad1')
-        assert_equal 0, type.cast('bad')
-        assert_equal 1, type.cast(1.7)
-        assert_equal 0, type.cast(false)
-        assert_equal 1, type.cast(true)
-        assert_nil type.cast(nil)
-      end
-
-      test "random objects cast to nil" do
-        type = Type::Integer.new
-        assert_nil type.cast([1,2])
-        assert_nil type.cast({1 => 2})
-        assert_nil type.cast(1..2)
-      end
-
       test "casting ActiveRecord models" do
         type = Type::Integer.new
         firm = Firm.create(:name => 'Apple')
         assert_nil type.cast(firm)
       end
 
-      test "casting objects without to_i" do
-        type = Type::Integer.new
-        assert_nil type.cast(::Object.new)
-      end
-
-      test "casting nan and infinity" do
-        type = Type::Integer.new
-        assert_nil type.cast(::Float::NAN)
-        assert_nil type.cast(1.0/0.0)
-      end
-
-      test "casting booleans for database" do
-        type = Type::Integer.new
-        assert_equal 1, type.serialize(true)
-        assert_equal 0, type.serialize(false)
-      end
-
-      test "changed?" do
-        type = Type::Integer.new
-
-        assert type.changed?(5, 5, '5wibble')
-        assert_not type.changed?(5, 5, '5')
-        assert_not type.changed?(5, 5, '5.0')
-        assert_not type.changed?(-5, -5, '-5')
-        assert_not type.changed?(-5, -5, '-5.0')
-        assert_not type.changed?(nil, nil, nil)
-      end
-
-      test "values below int min value are out of range" do
-        assert_raises(::RangeError) do
-          Integer.new.serialize(-2147483649)
-        end
-      end
-
-      test "values above int max value are out of range" do
-        assert_raises(::RangeError) do
-          Integer.new.serialize(2147483648)
-        end
-      end
-
-      test "very small numbers are out of range" do
-        assert_raises(::RangeError) do
-          Integer.new.serialize(-9999999999999999999999999999999)
-        end
-      end
-
-      test "very large numbers are out of range" do
-        assert_raises(::RangeError) do
-          Integer.new.serialize(9999999999999999999999999999999)
-        end
-      end
-
-      test "normal numbers are in range" do
-        type = Integer.new
-        assert_equal(0, type.serialize(0))
-        assert_equal(-1, type.serialize(-1))
-        assert_equal(1, type.serialize(1))
-      end
-
-      test "int max value is in range" do
-        assert_equal(2147483647, Integer.new.serialize(2147483647))
-      end
-
-      test "int min value is in range" do
-        assert_equal(-2147483648, Integer.new.serialize(-2147483648))
-      end
-
-      test "columns with a larger limit have larger ranges" do
-        type = Integer.new(limit: 8)
-
-        assert_equal(9223372036854775807, type.serialize(9223372036854775807))
-        assert_equal(-9223372036854775808, type.serialize(-9223372036854775808))
-        assert_raises(::RangeError) do
-          type.serialize(-9999999999999999999999999999999)
-        end
-        assert_raises(::RangeError) do
-          type.serialize(9999999999999999999999999999999)
-        end
-      end
-
       test "values which are out of range can be re-assigned" do
         klass = Class.new(ActiveRecord::Base) do
           self.table_name = 'posts'
diff --git a/activerecord/test/cases/type/string_test.rb b/activerecord/test/cases/type/string_test.rb
index 56e9bf434d..6fe6d46711 100644
--- a/activerecord/test/cases/type/string_test.rb
+++ b/activerecord/test/cases/type/string_test.rb
@@ -2,20 +2,6 @@ require 'cases/helper'
 
 module ActiveRecord
   class StringTypeTest < ActiveRecord::TestCase
-    test "type casting" do
-      type = Type::String.new
-      assert_equal "t", type.cast(true)
-      assert_equal "f", type.cast(false)
-      assert_equal "123", type.cast(123)
-    end
-
-    test "values are duped coming out" do
-      s = "foo"
-      type = Type::String.new
-      assert_not_same s, type.cast(s)
-      assert_not_same s, type.deserialize(s)
-    end
-
     test "string mutations are detected" do
       klass = Class.new(Base)
       klass.table_name = 'authors'
diff --git a/activerecord/test/cases/types_test.rb b/activerecord/test/cases/types_test.rb
index 9b1859c2ce..81fcf04a27 100644
--- a/activerecord/test/cases/types_test.rb
+++ b/activerecord/test/cases/types_test.rb
@@ -3,111 +3,6 @@ require "cases/helper"
 module ActiveRecord
   module ConnectionAdapters
     class TypesTest < ActiveRecord::TestCase
-      def test_type_cast_boolean
-        type = Type::Boolean.new
-        assert type.cast('').nil?
-        assert type.cast(nil).nil?
-
-        assert type.cast(true)
-        assert type.cast(1)
-        assert type.cast('1')
-        assert type.cast('t')
-        assert type.cast('T')
-        assert type.cast('true')
-        assert type.cast('TRUE')
-        assert type.cast('on')
-        assert type.cast('ON')
-        assert type.cast(' ')
-        assert type.cast("\u3000\r\n")
-        assert type.cast("\u0000")
-        assert type.cast('SOMETHING RANDOM')
-
-        # explicitly check for false vs nil
-        assert_equal false, type.cast(false)
-        assert_equal false, type.cast(0)
-        assert_equal false, type.cast('0')
-        assert_equal false, type.cast('f')
-        assert_equal false, type.cast('F')
-        assert_equal false, type.cast('false')
-        assert_equal false, type.cast('FALSE')
-        assert_equal false, type.cast('off')
-        assert_equal false, type.cast('OFF')
-      end
-
-      def test_type_cast_float
-        type = Type::Float.new
-        assert_equal 1.0, type.cast("1")
-      end
-
-      def test_changing_float
-        type = Type::Float.new
-
-        assert type.changed?(5.0, 5.0, '5wibble')
-        assert_not type.changed?(5.0, 5.0, '5')
-        assert_not type.changed?(5.0, 5.0, '5.0')
-        assert_not type.changed?(nil, nil, nil)
-      end
-
-      def test_type_cast_binary
-        type = Type::Binary.new
-        assert_equal nil, type.cast(nil)
-        assert_equal "1", type.cast("1")
-        assert_equal 1, type.cast(1)
-      end
-
-      def test_type_cast_time
-        type = Type::Time.new
-        assert_equal nil, type.cast(nil)
-        assert_equal nil, type.cast('')
-        assert_equal nil, type.cast('ABC')
-
-        time_string = Time.now.utc.strftime("%T")
-        assert_equal time_string, type.cast(time_string).strftime("%T")
-      end
-
-      def test_type_cast_datetime_and_timestamp
-        type = Type::DateTime.new
-        assert_equal nil, type.cast(nil)
-        assert_equal nil, type.cast('')
-        assert_equal nil, type.cast('  ')
-        assert_equal nil, type.cast('ABC')
-
-        datetime_string = Time.now.utc.strftime("%FT%T")
-        assert_equal datetime_string, type.cast(datetime_string).strftime("%FT%T")
-      end
-
-      def test_type_cast_date
-        type = Type::Date.new
-        assert_equal nil, type.cast(nil)
-        assert_equal nil, type.cast('')
-        assert_equal nil, type.cast(' ')
-        assert_equal nil, type.cast('ABC')
-
-        date_string = Time.now.utc.strftime("%F")
-        assert_equal date_string, type.cast(date_string).strftime("%F")
-      end
-
-      def test_type_cast_duration_to_integer
-        type = Type::Integer.new
-        assert_equal 1800, type.cast(30.minutes)
-        assert_equal 7200, type.cast(2.hours)
-      end
-
-      def test_string_to_time_with_timezone
-        [:utc, :local].each do |zone|
-          with_timezone_config default: zone do
-            type = Type::DateTime.new
-            assert_equal Time.utc(2013, 9, 4, 0, 0, 0), type.cast("Wed, 04 Sep 2013 03:00:00 EAT")
-          end
-        end
-      end
-
-      def test_type_equality
-        assert_equal Type::Value.new, Type::Value.new
-        assert_not_equal Type::Value.new, Type::Integer.new
-        assert_not_equal Type::Value.new(precision: 1), Type::Value.new(precision: 2)
-      end
-
       def test_attributes_which_are_invalid_for_database_can_still_be_reassigned
         type_which_cannot_go_to_the_database = Type::Value.new
         def type_which_cannot_go_to_the_database.serialize(*)