Rename `type_cast` to `type_cast_from_database`

In some cases there is a difference between the two, we should always
be doing one or the other. For convenience, `type_cast` is still a
private method on type, so new types that do not need different behavior
don't need to implement two methods, but it has been moved to private so
it cannot be used accidentally.

12 files changed, 101 insertions, 101 deletions

diff --git a/activerecord/test/cases/adapters/mysql/mysql_adapter_test.rb b/activerecord/test/cases/adapters/mysql/mysql_adapter_test.rb
index 1699380eb3..28106d3772 100644
--- a/activerecord/test/cases/adapters/mysql/mysql_adapter_test.rb
+++ b/activerecord/test/cases/adapters/mysql/mysql_adapter_test.rb
@@ -105,7 +105,7 @@ module ActiveRecord
 
           result = @conn.exec_query('SELECT status FROM ex')
 
-          assert_equal 2, result.column_types['status'].type_cast(result.last['status'])
+          assert_equal 2, result.column_types['status'].type_cast_from_database(result.last['status'])
         end
       end
 
diff --git a/activerecord/test/cases/adapters/postgresql/array_test.rb b/activerecord/test/cases/adapters/postgresql/array_test.rb
index 1d431f1666..66750deb68 100644
--- a/activerecord/test/cases/adapters/postgresql/array_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/array_test.rb
@@ -90,9 +90,9 @@ class PostgresqlArrayTest < ActiveRecord::TestCase
   end
 
   def test_type_cast_array
-    assert_equal(['1', '2', '3'], @column.type_cast('{1,2,3}'))
-    assert_equal([], @column.type_cast('{}'))
-    assert_equal([nil], @column.type_cast('{NULL}'))
+    assert_equal(['1', '2', '3'], @column.type_cast_from_database('{1,2,3}'))
+    assert_equal([], @column.type_cast_from_database('{}'))
+    assert_equal([nil], @column.type_cast_from_database('{NULL}'))
   end
 
   def test_type_cast_integers
diff --git a/activerecord/test/cases/adapters/postgresql/bytea_test.rb b/activerecord/test/cases/adapters/postgresql/bytea_test.rb
index 3f8a5d1062..7872f91943 100644
--- a/activerecord/test/cases/adapters/postgresql/bytea_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/bytea_test.rb
@@ -33,16 +33,16 @@ class PostgresqlByteaTest < ActiveRecord::TestCase
 
     data = "\u001F\x8B"
     assert_equal('UTF-8', data.encoding.name)
-    assert_equal('ASCII-8BIT', @column.type_cast(data).encoding.name)
+    assert_equal('ASCII-8BIT', @column.type_cast_from_database(data).encoding.name)
   end
 
   def test_type_cast_binary_value
     data = "\u001F\x8B".force_encoding("BINARY")
-    assert_equal(data, @column.type_cast(data))
+    assert_equal(data, @column.type_cast_from_database(data))
   end
 
   def test_type_case_nil
-    assert_equal(nil, @column.type_cast(nil))
+    assert_equal(nil, @column.type_cast_from_database(nil))
   end
 
   def test_read_value
diff --git a/activerecord/test/cases/adapters/postgresql/connection_test.rb b/activerecord/test/cases/adapters/postgresql/connection_test.rb
index 5f84c893c0..d26cda46fa 100644
--- a/activerecord/test/cases/adapters/postgresql/connection_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/connection_test.rb
@@ -121,7 +121,7 @@ module ActiveRecord
       name = @subscriber.payloads.last[:statement_name]
       assert name
       res = @connection.exec_query("EXPLAIN (FORMAT JSON) EXECUTE #{name}(#{bindval})")
-      plan = res.column_types['QUERY PLAN'].type_cast res.rows.first.first
+      plan = res.column_types['QUERY PLAN'].type_cast_from_database res.rows.first.first
       assert_operator plan.length, :>, 0
     end
 
diff --git a/activerecord/test/cases/adapters/postgresql/hstore_test.rb b/activerecord/test/cases/adapters/postgresql/hstore_test.rb
index 3aac23a193..a25c9cb5e4 100644
--- a/activerecord/test/cases/adapters/postgresql/hstore_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/hstore_test.rb
@@ -118,11 +118,11 @@ class PostgresqlHstoreTest < ActiveRecord::TestCase
       data = "\"1\"=>\"2\""
       hash = @column.class.string_to_hstore data
       assert_equal({'1' => '2'}, hash)
-      assert_equal({'1' => '2'}, @column.type_cast(data))
+      assert_equal({'1' => '2'}, @column.type_cast_from_database(data))
 
-      assert_equal({}, @column.type_cast(""))
-      assert_equal({'key'=>nil}, @column.type_cast('key => NULL'))
-      assert_equal({'c'=>'}','"a"'=>'b "a b'}, @column.type_cast(%q(c=>"}", "\"a\""=>"b \"a b")))
+      assert_equal({}, @column.type_cast_from_database(""))
+      assert_equal({'key'=>nil}, @column.type_cast_from_database('key => NULL'))
+      assert_equal({'c'=>'}','"a"'=>'b "a b'}, @column.type_cast_from_database(%q(c=>"}", "\"a\""=>"b \"a b")))
     end
 
     def test_with_store_accessors
@@ -180,31 +180,31 @@ class PostgresqlHstoreTest < ActiveRecord::TestCase
     end
 
     def test_parse1
-      assert_equal({'a'=>nil,'b'=>nil,'c'=>'NuLl','null'=>'c'}, @column.type_cast('a=>null,b=>NuLl,c=>"NuLl",null=>c'))
+      assert_equal({'a'=>nil,'b'=>nil,'c'=>'NuLl','null'=>'c'}, @column.type_cast_from_database('a=>null,b=>NuLl,c=>"NuLl",null=>c'))
     end
 
     def test_parse2
-      assert_equal({" " => " "},  @column.type_cast("\\ =>\\ "))
+      assert_equal({" " => " "},  @column.type_cast_from_database("\\ =>\\ "))
     end
 
     def test_parse3
-      assert_equal({"=" => ">"},  @column.type_cast("==>>"))
+      assert_equal({"=" => ">"},  @column.type_cast_from_database("==>>"))
     end
 
     def test_parse4
-      assert_equal({"=a"=>"q=w"},   @column.type_cast('\=a=>q=w'))
+      assert_equal({"=a"=>"q=w"},   @column.type_cast_from_database('\=a=>q=w'))
     end
 
     def test_parse5
-      assert_equal({"=a"=>"q=w"},   @column.type_cast('"=a"=>q\=w'))
+      assert_equal({"=a"=>"q=w"},   @column.type_cast_from_database('"=a"=>q\=w'))
     end
 
     def test_parse6
-      assert_equal({"\"a"=>"q>w"},  @column.type_cast('"\"a"=>q>w'))
+      assert_equal({"\"a"=>"q>w"},  @column.type_cast_from_database('"\"a"=>q>w'))
     end
 
     def test_parse7
-      assert_equal({"\"a"=>"q\"w"}, @column.type_cast('\"a=>q"w'))
+      assert_equal({"\"a"=>"q\"w"}, @column.type_cast_from_database('\"a=>q"w'))
     end
 
     def test_rewrite
diff --git a/activerecord/test/cases/adapters/postgresql/json_test.rb b/activerecord/test/cases/adapters/postgresql/json_test.rb
index eab6049956..3ee8839823 100644
--- a/activerecord/test/cases/adapters/postgresql/json_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/json_test.rb
@@ -80,11 +80,11 @@ class PostgresqlJSONTest < ActiveRecord::TestCase
     data = "{\"a_key\":\"a_value\"}"
     hash = column.class.string_to_json data
     assert_equal({'a_key' => 'a_value'}, hash)
-    assert_equal({'a_key' => 'a_value'}, column.type_cast(data))
+    assert_equal({'a_key' => 'a_value'}, column.type_cast_from_database(data))
 
-    assert_equal({}, column.type_cast("{}"))
-    assert_equal({'key'=>nil}, column.type_cast('{"key": null}'))
-    assert_equal({'c'=>'}','"a"'=>'b "a b'}, column.type_cast(%q({"c":"}", "\"a\"":"b \"a b"})))
+    assert_equal({}, column.type_cast_from_database("{}"))
+    assert_equal({'key'=>nil}, column.type_cast_from_database('{"key": null}'))
+    assert_equal({'c'=>'}','"a"'=>'b "a b'}, column.type_cast_from_database(%q({"c":"}", "\"a\"":"b \"a b"})))
   end
 
   def test_rewrite
diff --git a/activerecord/test/cases/adapters/postgresql/money_test.rb b/activerecord/test/cases/adapters/postgresql/money_test.rb
index 3e33477bff..bdfeedafab 100644
--- a/activerecord/test/cases/adapters/postgresql/money_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/money_test.rb
@@ -49,10 +49,10 @@ class PostgresqlMoneyTest < ActiveRecord::TestCase
 
   def test_money_type_cast
     column = PostgresqlMoney.columns_hash['wealth']
-    assert_equal(12345678.12, column.type_cast("$12,345,678.12"))
-    assert_equal(12345678.12, column.type_cast("$12.345.678,12"))
-    assert_equal(-1.15, column.type_cast("-$1.15"))
-    assert_equal(-2.25, column.type_cast("($2.25)"))
+    assert_equal(12345678.12, column.type_cast_from_user("$12,345,678.12"))
+    assert_equal(12345678.12, column.type_cast_from_user("$12.345.678,12"))
+    assert_equal(-1.15, column.type_cast_from_user("-$1.15"))
+    assert_equal(-2.25, column.type_cast_from_user("($2.25)"))
   end
 
   def test_schema_dumping
diff --git a/activerecord/test/cases/attribute_decorators_test.rb b/activerecord/test/cases/attribute_decorators_test.rb
index 416eb650f6..35393753a2 100644
--- a/activerecord/test/cases/attribute_decorators_test.rb
+++ b/activerecord/test/cases/attribute_decorators_test.rb
@@ -12,11 +12,11 @@ module ActiveRecord
         super(delegate)
       end
 
-      def type_cast(value)
+      def type_cast_from_user(value)
         "#{super} #{@decoration}"
       end
 
-      alias type_cast_from_user type_cast
+      alias type_cast_from_database type_cast_from_user
     end
 
     setup do
diff --git a/activerecord/test/cases/base_test.rb b/activerecord/test/cases/base_test.rb
index fad51f4924..dc8f25b0e7 100644
--- a/activerecord/test/cases/base_test.rb
+++ b/activerecord/test/cases/base_test.rb
@@ -1489,7 +1489,7 @@ class BasicsTest < ActiveRecord::TestCase
     attrs.delete 'id'
 
     typecast = Class.new {
-      def type_cast value
+      def type_cast_from_database value
         "t.lo"
       end
     }
diff --git a/activerecord/test/cases/connection_adapters/type_lookup_test.rb b/activerecord/test/cases/connection_adapters/type_lookup_test.rb
index 3958c3bfff..d5c1dc1e5d 100644
--- a/activerecord/test/cases/connection_adapters/type_lookup_test.rb
+++ b/activerecord/test/cases/connection_adapters/type_lookup_test.rb
@@ -85,7 +85,7 @@ module ActiveRecord
           cast_type = @connection.type_map.lookup(type)
 
           assert_equal :decimal, cast_type.type
-          assert_equal 2, cast_type.type_cast(2.1)
+          assert_equal 2, cast_type.type_cast_from_user(2.1)
         end
       end
 
diff --git a/activerecord/test/cases/reflection_test.rb b/activerecord/test/cases/reflection_test.rb
index 70d52634f7..c6e73f78cc 100644
--- a/activerecord/test/cases/reflection_test.rb
+++ b/activerecord/test/cases/reflection_test.rb
@@ -95,7 +95,7 @@ class ReflectionTest < ActiveRecord::TestCase
     column = @first.column_for_attribute("attribute_that_doesnt_exist")
     object = Object.new
 
-    assert_equal object, column.type_cast(object)
+    assert_equal object, column.type_cast_from_database(object)
     assert_equal object, column.type_cast_from_user(object)
     assert_equal object, column.type_cast_for_database(object)
   end
diff --git a/activerecord/test/cases/types_test.rb b/activerecord/test/cases/types_test.rb
index 5d5f442d3a..731f8cfba3 100644
--- a/activerecord/test/cases/types_test.rb
+++ b/activerecord/test/cases/types_test.rb
@@ -6,141 +6,141 @@ module ActiveRecord
     class TypesTest < ActiveRecord::TestCase
       def test_type_cast_boolean
         type = Type::Boolean.new
-        assert type.type_cast('').nil?
-        assert type.type_cast(nil).nil?
-
-        assert type.type_cast(true)
-        assert type.type_cast(1)
-        assert type.type_cast('1')
-        assert type.type_cast('t')
-        assert type.type_cast('T')
-        assert type.type_cast('true')
-        assert type.type_cast('TRUE')
-        assert type.type_cast('on')
-        assert type.type_cast('ON')
+        assert type.type_cast_from_user('').nil?
+        assert type.type_cast_from_user(nil).nil?
+
+        assert type.type_cast_from_user(true)
+        assert type.type_cast_from_user(1)
+        assert type.type_cast_from_user('1')
+        assert type.type_cast_from_user('t')
+        assert type.type_cast_from_user('T')
+        assert type.type_cast_from_user('true')
+        assert type.type_cast_from_user('TRUE')
+        assert type.type_cast_from_user('on')
+        assert type.type_cast_from_user('ON')
 
         # explicitly check for false vs nil
-        assert_equal false, type.type_cast(false)
-        assert_equal false, type.type_cast(0)
-        assert_equal false, type.type_cast('0')
-        assert_equal false, type.type_cast('f')
-        assert_equal false, type.type_cast('F')
-        assert_equal false, type.type_cast('false')
-        assert_equal false, type.type_cast('FALSE')
-        assert_equal false, type.type_cast('off')
-        assert_equal false, type.type_cast('OFF')
-        assert_equal false, type.type_cast(' ')
-        assert_equal false, type.type_cast("\u3000\r\n")
-        assert_equal false, type.type_cast("\u0000")
-        assert_equal false, type.type_cast('SOMETHING RANDOM')
+        assert_equal false, type.type_cast_from_user(false)
+        assert_equal false, type.type_cast_from_user(0)
+        assert_equal false, type.type_cast_from_user('0')
+        assert_equal false, type.type_cast_from_user('f')
+        assert_equal false, type.type_cast_from_user('F')
+        assert_equal false, type.type_cast_from_user('false')
+        assert_equal false, type.type_cast_from_user('FALSE')
+        assert_equal false, type.type_cast_from_user('off')
+        assert_equal false, type.type_cast_from_user('OFF')
+        assert_equal false, type.type_cast_from_user(' ')
+        assert_equal false, type.type_cast_from_user("\u3000\r\n")
+        assert_equal false, type.type_cast_from_user("\u0000")
+        assert_equal false, type.type_cast_from_user('SOMETHING RANDOM')
       end
 
       def test_type_cast_string
         type = Type::String.new
-        assert_equal "1", type.type_cast(true)
-        assert_equal "0", type.type_cast(false)
-        assert_equal "123", type.type_cast(123)
+        assert_equal "1", type.type_cast_from_user(true)
+        assert_equal "0", type.type_cast_from_user(false)
+        assert_equal "123", type.type_cast_from_user(123)
       end
 
       def test_type_cast_integer
         type = Type::Integer.new
-        assert_equal 1, type.type_cast(1)
-        assert_equal 1, type.type_cast('1')
-        assert_equal 1, type.type_cast('1ignore')
-        assert_equal 0, type.type_cast('bad1')
-        assert_equal 0, type.type_cast('bad')
-        assert_equal 1, type.type_cast(1.7)
-        assert_equal 0, type.type_cast(false)
-        assert_equal 1, type.type_cast(true)
-        assert_nil type.type_cast(nil)
+        assert_equal 1, type.type_cast_from_user(1)
+        assert_equal 1, type.type_cast_from_user('1')
+        assert_equal 1, type.type_cast_from_user('1ignore')
+        assert_equal 0, type.type_cast_from_user('bad1')
+        assert_equal 0, type.type_cast_from_user('bad')
+        assert_equal 1, type.type_cast_from_user(1.7)
+        assert_equal 0, type.type_cast_from_user(false)
+        assert_equal 1, type.type_cast_from_user(true)
+        assert_nil type.type_cast_from_user(nil)
       end
 
       def test_type_cast_non_integer_to_integer
         type = Type::Integer.new
-        assert_nil type.type_cast([1,2])
-        assert_nil type.type_cast({1 => 2})
-        assert_nil type.type_cast((1..2))
+        assert_nil type.type_cast_from_user([1,2])
+        assert_nil type.type_cast_from_user({1 => 2})
+        assert_nil type.type_cast_from_user((1..2))
       end
 
       def test_type_cast_activerecord_to_integer
         type = Type::Integer.new
         firm = Firm.create(:name => 'Apple')
-        assert_nil type.type_cast(firm)
+        assert_nil type.type_cast_from_user(firm)
       end
 
       def test_type_cast_object_without_to_i_to_integer
         type = Type::Integer.new
-        assert_nil type.type_cast(Object.new)
+        assert_nil type.type_cast_from_user(Object.new)
       end
 
       def test_type_cast_nan_and_infinity_to_integer
         type = Type::Integer.new
-        assert_nil type.type_cast(Float::NAN)
-        assert_nil type.type_cast(1.0/0.0)
+        assert_nil type.type_cast_from_user(Float::NAN)
+        assert_nil type.type_cast_from_user(1.0/0.0)
       end
 
       def test_type_cast_float
         type = Type::Float.new
-        assert_equal 1.0, type.type_cast("1")
+        assert_equal 1.0, type.type_cast_from_user("1")
       end
 
       def test_type_cast_decimal
         type = Type::Decimal.new
-        assert_equal BigDecimal.new("0"), type.type_cast(BigDecimal.new("0"))
-        assert_equal BigDecimal.new("123"), type.type_cast(123.0)
-        assert_equal BigDecimal.new("1"), type.type_cast(:"1")
+        assert_equal BigDecimal.new("0"), type.type_cast_from_user(BigDecimal.new("0"))
+        assert_equal BigDecimal.new("123"), type.type_cast_from_user(123.0)
+        assert_equal BigDecimal.new("1"), type.type_cast_from_user(:"1")
       end
 
       def test_type_cast_binary
         type = Type::Binary.new
-        assert_equal nil, type.type_cast(nil)
-        assert_equal "1", type.type_cast("1")
-        assert_equal 1, type.type_cast(1)
+        assert_equal nil, type.type_cast_from_user(nil)
+        assert_equal "1", type.type_cast_from_user("1")
+        assert_equal 1, type.type_cast_from_user(1)
       end
 
       def test_type_cast_time
         type = Type::Time.new
-        assert_equal nil, type.type_cast(nil)
-        assert_equal nil, type.type_cast('')
-        assert_equal nil, type.type_cast('ABC')
+        assert_equal nil, type.type_cast_from_user(nil)
+        assert_equal nil, type.type_cast_from_user('')
+        assert_equal nil, type.type_cast_from_user('ABC')
 
         time_string = Time.now.utc.strftime("%T")
-        assert_equal time_string, type.type_cast(time_string).strftime("%T")
+        assert_equal time_string, type.type_cast_from_user(time_string).strftime("%T")
       end
 
       def test_type_cast_datetime_and_timestamp
         type = Type::DateTime.new
-        assert_equal nil, type.type_cast(nil)
-        assert_equal nil, type.type_cast('')
-        assert_equal nil, type.type_cast('  ')
-        assert_equal nil, type.type_cast('ABC')
+        assert_equal nil, type.type_cast_from_user(nil)
+        assert_equal nil, type.type_cast_from_user('')
+        assert_equal nil, type.type_cast_from_user('  ')
+        assert_equal nil, type.type_cast_from_user('ABC')
 
         datetime_string = Time.now.utc.strftime("%FT%T")
-        assert_equal datetime_string, type.type_cast(datetime_string).strftime("%FT%T")
+        assert_equal datetime_string, type.type_cast_from_user(datetime_string).strftime("%FT%T")
       end
 
       def test_type_cast_date
         type = Type::Date.new
-        assert_equal nil, type.type_cast(nil)
-        assert_equal nil, type.type_cast('')
-        assert_equal nil, type.type_cast(' ')
-        assert_equal nil, type.type_cast('ABC')
+        assert_equal nil, type.type_cast_from_user(nil)
+        assert_equal nil, type.type_cast_from_user('')
+        assert_equal nil, type.type_cast_from_user(' ')
+        assert_equal nil, type.type_cast_from_user('ABC')
 
         date_string = Time.now.utc.strftime("%F")
-        assert_equal date_string, type.type_cast(date_string).strftime("%F")
+        assert_equal date_string, type.type_cast_from_user(date_string).strftime("%F")
       end
 
       def test_type_cast_duration_to_integer
         type = Type::Integer.new
-        assert_equal 1800, type.type_cast(30.minutes)
-        assert_equal 7200, type.type_cast(2.hours)
+        assert_equal 1800, type.type_cast_from_user(30.minutes)
+        assert_equal 7200, type.type_cast_from_user(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.type_cast("Wed, 04 Sep 2013 03:00:00 EAT")
+            assert_equal Time.utc(2013, 9, 4, 0, 0, 0), type.type_cast_from_user("Wed, 04 Sep 2013 03:00:00 EAT")
           end
         end
       end
@@ -149,7 +149,7 @@ module ActiveRecord
         def test_binary_encoding
           type = SQLite3Binary.new
           utf8_string = "a string".encode(Encoding::UTF_8)
-          type_cast = type.type_cast(utf8_string)
+          type_cast = type.type_cast_from_user(utf8_string)
 
           assert_equal Encoding::ASCII_8BIT, type_cast.encoding
         end