`type_cast_for_database` -> `serialize`

14 files changed, 46 insertions, 46 deletions

diff --git a/activerecord/test/cases/adapters/postgresql/array_test.rb b/activerecord/test/cases/adapters/postgresql/array_test.rb
index eaab9ad685..f7552842cc 100644
--- a/activerecord/test/cases/adapters/postgresql/array_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/array_test.rb
@@ -206,7 +206,7 @@ class PostgresqlArrayTest < ActiveRecord::TestCase
     x = PgArray.create!(tags: tags)
     x.reload
 
-    assert_equal x.tags_before_type_cast, PgArray.type_for_attribute('tags').type_cast_for_database(tags)
+    assert_equal x.tags_before_type_cast, PgArray.type_for_attribute('tags').serialize(tags)
   end
 
   def test_quoting_non_standard_delimiters
@@ -214,8 +214,8 @@ class PostgresqlArrayTest < ActiveRecord::TestCase
     comma_delim = OID::Array.new(ActiveRecord::Type::String.new, ',')
     semicolon_delim = OID::Array.new(ActiveRecord::Type::String.new, ';')
 
-    assert_equal %({"hello,",world;}), comma_delim.type_cast_for_database(strings)
-    assert_equal %({hello,;"world;"}), semicolon_delim.type_cast_for_database(strings)
+    assert_equal %({"hello,",world;}), comma_delim.serialize(strings)
+    assert_equal %({hello,;"world;"}), semicolon_delim.serialize(strings)
   end
 
   def test_mutate_array
diff --git a/activerecord/test/cases/adapters/postgresql/cidr_test.rb b/activerecord/test/cases/adapters/postgresql/cidr_test.rb
index 54b679d3ab..6cb11d17b4 100644
--- a/activerecord/test/cases/adapters/postgresql/cidr_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/cidr_test.rb
@@ -10,14 +10,14 @@ module ActiveRecord
           ip = IPAddr.new("255.0.0.0/8")
           ip2 = IPAddr.new("127.0.0.1")
 
-          assert_equal "255.0.0.0/8", type.type_cast_for_database(ip)
-          assert_equal "127.0.0.1/32", type.type_cast_for_database(ip2)
+          assert_equal "255.0.0.0/8", type.serialize(ip)
+          assert_equal "127.0.0.1/32", type.serialize(ip2)
         end
 
         test "casting does nothing with non-IPAddr objects" do
           type = OID::Cidr.new
 
-          assert_equal "foo", type.type_cast_for_database("foo")
+          assert_equal "foo", type.serialize("foo")
         end
       end
     end
diff --git a/activerecord/test/cases/adapters/postgresql/composite_test.rb b/activerecord/test/cases/adapters/postgresql/composite_test.rb
index 360f03667e..14c81f8afb 100644
--- a/activerecord/test/cases/adapters/postgresql/composite_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/composite_test.rb
@@ -93,7 +93,7 @@ class PostgresqlCompositeWithCustomOIDTest < ActiveRecord::TestCase
       value
     end
 
-    def type_cast_for_database(value)
+    def serialize(value)
       return if value.nil?
       "(#{value.city},#{value.street})"
     end
diff --git a/activerecord/test/cases/adapters/postgresql/hstore_test.rb b/activerecord/test/cases/adapters/postgresql/hstore_test.rb
index 562296b7f5..1dad61b476 100644
--- a/activerecord/test/cases/adapters/postgresql/hstore_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/hstore_test.rb
@@ -165,19 +165,19 @@ if ActiveRecord::Base.connection.supports_extensions?
     end
 
     def test_gen1
-      assert_equal(%q(" "=>""), @type.type_cast_for_database({' '=>''}))
+      assert_equal(%q(" "=>""), @type.serialize({' '=>''}))
     end
 
     def test_gen2
-      assert_equal(%q(","=>""), @type.type_cast_for_database({','=>''}))
+      assert_equal(%q(","=>""), @type.serialize({','=>''}))
     end
 
     def test_gen3
-      assert_equal(%q("="=>""), @type.type_cast_for_database({'='=>''}))
+      assert_equal(%q("="=>""), @type.serialize({'='=>''}))
     end
 
     def test_gen4
-      assert_equal(%q(">"=>""), @type.type_cast_for_database({'>'=>''}))
+      assert_equal(%q(">"=>""), @type.serialize({'>'=>''}))
     end
 
     def test_parse1
diff --git a/activerecord/test/cases/adapters/postgresql/quoting_test.rb b/activerecord/test/cases/adapters/postgresql/quoting_test.rb
index 60baacf67a..e4420d9d13 100644
--- a/activerecord/test/cases/adapters/postgresql/quoting_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/quoting_test.rb
@@ -30,13 +30,13 @@ module ActiveRecord
         def test_quote_range
           range = "1,2]'; SELECT * FROM users; --".."a"
           type = OID::Range.new(Type::Integer.new, :int8range)
-          assert_equal "'[1,0]'", @conn.quote(type.type_cast_for_database(range))
+          assert_equal "'[1,0]'", @conn.quote(type.serialize(range))
         end
 
         def test_quote_bit_string
           value = "'); SELECT * FROM users; /*\n01\n*/--"
           type = OID::Bit.new
-          assert_equal nil, @conn.quote(type.type_cast_for_database(value))
+          assert_equal nil, @conn.quote(type.serialize(value))
         end
       end
     end
diff --git a/activerecord/test/cases/adapters/postgresql/type_lookup_test.rb b/activerecord/test/cases/adapters/postgresql/type_lookup_test.rb
index 4506e874bc..c0907b8f21 100644
--- a/activerecord/test/cases/adapters/postgresql/type_lookup_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/type_lookup_test.rb
@@ -18,8 +18,8 @@ class PostgresqlTypeLookupTest < ActiveRecord::TestCase
     bigint_array = @connection.type_map.lookup(1016, -1, "bigint[]")
     big_array = [123456789123456789]
 
-    assert_raises(RangeError) { int_array.type_cast_for_database(big_array) }
-    assert_equal "{123456789123456789}", bigint_array.type_cast_for_database(big_array)
+    assert_raises(RangeError) { int_array.serialize(big_array) }
+    assert_equal "{123456789123456789}", bigint_array.serialize(big_array)
   end
 
   test "range types correctly respect registration of subtypes" do
@@ -27,7 +27,7 @@ class PostgresqlTypeLookupTest < ActiveRecord::TestCase
     bigint_range = @connection.type_map.lookup(3926, -1, "int8range")
     big_range = 0..123456789123456789
 
-    assert_raises(RangeError) { int_range.type_cast_for_database(big_range) }
-    assert_equal "[0,123456789123456789]", bigint_range.type_cast_for_database(big_range)
+    assert_raises(RangeError) { int_range.serialize(big_range) }
+    assert_equal "[0,123456789123456789]", bigint_range.serialize(big_range)
   end
 end
diff --git a/activerecord/test/cases/adapters/sqlite3/quoting_test.rb b/activerecord/test/cases/adapters/sqlite3/quoting_test.rb
index c1d9b7c273..243f65df98 100644
--- a/activerecord/test/cases/adapters/sqlite3/quoting_test.rb
+++ b/activerecord/test/cases/adapters/sqlite3/quoting_test.rb
@@ -87,7 +87,7 @@ module ActiveRecord
           value = "hello".encode('ascii-8bit')
           type = Type::String.new
 
-          assert_equal "'hello'", @conn.quote(type.type_cast_for_database(value))
+          assert_equal "'hello'", @conn.quote(type.serialize(value))
         end
       end
     end
diff --git a/activerecord/test/cases/attribute_test.rb b/activerecord/test/cases/attribute_test.rb
index 7b20fcf3e4..3b888950e2 100644
--- a/activerecord/test/cases/attribute_test.rb
+++ b/activerecord/test/cases/attribute_test.rb
@@ -59,22 +59,22 @@ module ActiveRecord
 
     test "from_database + read_for_database type casts to and from database" do
       @type.expect(:deserialize, 'read from database', ['whatever'])
-      @type.expect(:type_cast_for_database, 'ready for database', ['read from database'])
+      @type.expect(:serialize, 'ready for database', ['read from database'])
       attribute = Attribute.from_database(nil, 'whatever', @type)
 
-      type_cast_for_database = attribute.value_for_database
+      serialize = attribute.value_for_database
 
-      assert_equal 'ready for database', type_cast_for_database
+      assert_equal 'ready for database', serialize
     end
 
     test "from_user + read_for_database type casts from the user to the database" do
       @type.expect(:type_cast_from_user, 'read from user', ['whatever'])
-      @type.expect(:type_cast_for_database, 'ready for database', ['read from user'])
+      @type.expect(:serialize, 'ready for database', ['read from user'])
       attribute = Attribute.from_user(nil, 'whatever', @type)
 
-      type_cast_for_database = attribute.value_for_database
+      serialize = attribute.value_for_database
 
-      assert_equal 'ready for database', type_cast_for_database
+      assert_equal 'ready for database', serialize
     end
 
     test "duping dups the value" do
diff --git a/activerecord/test/cases/dirty_test.rb b/activerecord/test/cases/dirty_test.rb
index c2573ac72b..6d8076f3fd 100644
--- a/activerecord/test/cases/dirty_test.rb
+++ b/activerecord/test/cases/dirty_test.rb
@@ -623,13 +623,13 @@ class DirtyTest < ActiveRecord::TestCase
     end
   end
 
-  test "defaults with type that implements `type_cast_for_database`" do
+  test "defaults with type that implements `serialize`" do
     type = Class.new(ActiveRecord::Type::Value) do
       def type_cast(value)
         value.to_i
       end
 
-      def type_cast_for_database(value)
+      def serialize(value)
         value.to_s
       end
     end
diff --git a/activerecord/test/cases/reflection_test.rb b/activerecord/test/cases/reflection_test.rb
index 488ef8e2c0..206189350f 100644
--- a/activerecord/test/cases/reflection_test.rb
+++ b/activerecord/test/cases/reflection_test.rb
@@ -94,7 +94,7 @@ class ReflectionTest < ActiveRecord::TestCase
 
     assert_equal object, type.deserialize(object)
     assert_equal object, type.type_cast_from_user(object)
-    assert_equal object, type.type_cast_for_database(object)
+    assert_equal object, type.serialize(object)
   end
 
   def test_reflection_klass_for_nested_class_name
diff --git a/activerecord/test/cases/relation_test.rb b/activerecord/test/cases/relation_test.rb
index f149457315..9353be1ba7 100644
--- a/activerecord/test/cases/relation_test.rb
+++ b/activerecord/test/cases/relation_test.rb
@@ -259,7 +259,7 @@ module ActiveRecord
         "type cast from database"
       end
 
-      def type_cast_for_database(value)
+      def serialize(value)
         raise value unless value == "value from user"
         "type cast for database"
       end
diff --git a/activerecord/test/cases/type/integer_test.rb b/activerecord/test/cases/type/integer_test.rb
index 1e836f2142..a767c73cf2 100644
--- a/activerecord/test/cases/type/integer_test.rb
+++ b/activerecord/test/cases/type/integer_test.rb
@@ -43,8 +43,8 @@ module ActiveRecord
 
       test "casting booleans for database" do
         type = Type::Integer.new
-        assert_equal 1, type.type_cast_for_database(true)
-        assert_equal 0, type.type_cast_for_database(false)
+        assert_equal 1, type.serialize(true)
+        assert_equal 0, type.serialize(false)
       end
 
       test "changed?" do
@@ -60,53 +60,53 @@ module ActiveRecord
 
       test "values below int min value are out of range" do
         assert_raises(::RangeError) do
-          Integer.new.type_cast_for_database(-2147483649)
+          Integer.new.serialize(-2147483649)
         end
       end
 
       test "values above int max value are out of range" do
         assert_raises(::RangeError) do
-          Integer.new.type_cast_for_database(2147483648)
+          Integer.new.serialize(2147483648)
         end
       end
 
       test "very small numbers are out of range" do
         assert_raises(::RangeError) do
-          Integer.new.type_cast_for_database(-9999999999999999999999999999999)
+          Integer.new.serialize(-9999999999999999999999999999999)
         end
       end
 
       test "very large numbers are out of range" do
         assert_raises(::RangeError) do
-          Integer.new.type_cast_for_database(9999999999999999999999999999999)
+          Integer.new.serialize(9999999999999999999999999999999)
         end
       end
 
       test "normal numbers are in range" do
         type = Integer.new
-        assert_equal(0, type.type_cast_for_database(0))
-        assert_equal(-1, type.type_cast_for_database(-1))
-        assert_equal(1, type.type_cast_for_database(1))
+        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.type_cast_for_database(2147483647))
+        assert_equal(2147483647, Integer.new.serialize(2147483647))
       end
 
       test "int min value is in range" do
-        assert_equal(-2147483648, Integer.new.type_cast_for_database(-2147483648))
+        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.type_cast_for_database(9223372036854775807))
-        assert_equal(-9223372036854775808, type.type_cast_for_database(-9223372036854775808))
+        assert_equal(9223372036854775807, type.serialize(9223372036854775807))
+        assert_equal(-9223372036854775808, type.serialize(-9223372036854775808))
         assert_raises(::RangeError) do
-          type.type_cast_for_database(-9999999999999999999999999999999)
+          type.serialize(-9999999999999999999999999999999)
         end
         assert_raises(::RangeError) do
-          type.type_cast_for_database(9999999999999999999999999999999)
+          type.serialize(9999999999999999999999999999999)
         end
       end
 
diff --git a/activerecord/test/cases/type/unsigned_integer_test.rb b/activerecord/test/cases/type/unsigned_integer_test.rb
index 4b8e2fb518..f2c910eade 100644
--- a/activerecord/test/cases/type/unsigned_integer_test.rb
+++ b/activerecord/test/cases/type/unsigned_integer_test.rb
@@ -4,12 +4,12 @@ module ActiveRecord
   module Type
     class UnsignedIntegerTest < ActiveRecord::TestCase
       test "unsigned int max value is in range" do
-        assert_equal(4294967295, UnsignedInteger.new.type_cast_for_database(4294967295))
+        assert_equal(4294967295, UnsignedInteger.new.serialize(4294967295))
       end
 
       test "minus value is out of range" do
         assert_raises(::RangeError) do
-          UnsignedInteger.new.type_cast_for_database(-1)
+          UnsignedInteger.new.serialize(-1)
         end
       end
     end
diff --git a/activerecord/test/cases/types_test.rb b/activerecord/test/cases/types_test.rb
index 34b6f2e8a5..870d348928 100644
--- a/activerecord/test/cases/types_test.rb
+++ b/activerecord/test/cases/types_test.rb
@@ -110,7 +110,7 @@ module ActiveRecord
 
       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.type_cast_for_database(*)
+        def type_which_cannot_go_to_the_database.serialize(*)
           raise
         end
         klass = Class.new(ActiveRecord::Base) do