Introduce an Attribute object to handle the type casting dance

There's a lot more that can be moved to these, but this felt like a good
place to introduce the object. Plans are:

- Remove all knowledge of type casting from the columns, beyond a
  reference to the cast_type
- Move type_cast_for_database to these objects
- Potentially make them mutable, introduce a state machine, and have
  dirty checking handled here as well
- Move `attribute`, `decorate_attribute`, and anything else that
  modifies types to mess with this object, not the columns hash
- Introduce a collection object to manage these, reduce allocations, and
  not require serializing the types

6 files changed, 111 insertions, 21 deletions

diff --git a/activerecord/test/cases/adapters/postgresql/composite_test.rb b/activerecord/test/cases/adapters/postgresql/composite_test.rb
index 0b48fe9af8..42c68cdae7 100644
--- a/activerecord/test/cases/adapters/postgresql/composite_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/composite_test.rb
@@ -84,7 +84,7 @@ class PostgresqlCompositeWithCustomOIDTest < ActiveRecord::TestCase
   class FullAddressType < ActiveRecord::Type::Value
     def type; :full_address end
 
-    def type_cast(value)
+    def type_cast_from_database(value)
       if value =~ /\("?([^",]*)"?,"?([^",]*)"?\)/
         FullAddress.new($1, $2)
       end
diff --git a/activerecord/test/cases/attribute_test.rb b/activerecord/test/cases/attribute_test.rb
new file mode 100644
index 0000000000..57dd2e9a5e
--- /dev/null
+++ b/activerecord/test/cases/attribute_test.rb
@@ -0,0 +1,103 @@
+require 'cases/helper'
+require 'minitest/mock'
+
+module ActiveRecord
+  class AttributeTest < ActiveRecord::TestCase
+    setup do
+      @type = MiniTest::Mock.new
+    end
+
+    teardown do
+      assert @type.verify
+    end
+
+    test "from_database + read type casts from database" do
+      @type.expect(:type_cast_from_database, 'type cast from database', ['a value'])
+      attribute = Attribute.from_database('a value', @type)
+
+      type_cast_value = attribute.value
+
+      assert_equal 'type cast from database', type_cast_value
+    end
+
+    test "from_user + read type casts from user" do
+      @type.expect(:type_cast_from_user, 'type cast from user', ['a value'])
+      attribute = Attribute.from_user('a value', @type)
+
+      type_cast_value = attribute.value
+
+      assert_equal 'type cast from user', type_cast_value
+    end
+
+    test "reading memoizes the value" do
+      @type.expect(:type_cast_from_database, 'from the database', ['whatever'])
+      attribute = Attribute.from_database('whatever', @type)
+
+      type_cast_value = attribute.value
+      second_read = attribute.value
+
+      assert_equal 'from the database', type_cast_value
+      assert_same type_cast_value, second_read
+    end
+
+    test "reading memoizes falsy values" do
+      @type.expect(:type_cast_from_database, false, ['whatever'])
+      attribute = Attribute.from_database('whatever', @type)
+
+      attribute.value
+      attribute.value
+    end
+
+    test "read_before_typecast returns the given value" do
+      attribute = Attribute.from_database('raw value', @type)
+
+      raw_value = attribute.value_before_type_cast
+
+      assert_equal 'raw value', raw_value
+    end
+
+    test "from_database + read_for_database type casts to and from database" do
+      @type.expect(:type_cast_from_database, 'read from database', ['whatever'])
+      @type.expect(:type_cast_for_database, 'ready for database', ['read from database'])
+      attribute = Attribute.from_database('whatever', @type)
+
+      type_cast_for_database = attribute.value_for_database
+
+      assert_equal 'ready for database', type_cast_for_database
+    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'])
+      attribute = Attribute.from_user('whatever', @type)
+
+      type_cast_for_database = attribute.value_for_database
+
+      assert_equal 'ready for database', type_cast_for_database
+    end
+
+    test "duping dups the value" do
+      @type.expect(:type_cast_from_database, 'type cast', ['a value'])
+      attribute = Attribute.from_database('a value', @type)
+
+      value_from_orig = attribute.value
+      value_from_clone = attribute.dup.value
+      value_from_orig << ' foo'
+
+      assert_equal 'type cast foo', value_from_orig
+      assert_equal 'type cast', value_from_clone
+    end
+
+    test "duping does not dup the value if it is not dupable" do
+      @type.expect(:type_cast_from_database, false, ['a value'])
+      attribute = Attribute.from_database('a value', @type)
+
+      assert_same attribute.value, attribute.dup.value
+    end
+
+    test "duping does not eagerly type cast if we have not yet type cast" do
+      attribute = Attribute.from_database('a value', @type)
+      attribute.dup
+    end
+  end
+end
diff --git a/activerecord/test/cases/base_test.rb b/activerecord/test/cases/base_test.rb
index dc8f25b0e7..6d1f72eb7e 100644
--- a/activerecord/test/cases/base_test.rb
+++ b/activerecord/test/cases/base_test.rb
@@ -1488,15 +1488,14 @@ class BasicsTest < ActiveRecord::TestCase
     attrs = topic.attributes.dup
     attrs.delete 'id'
 
-    typecast = Class.new {
-      def type_cast_from_database value
+    typecast = Class.new(ActiveRecord::Type::Value) {
+      def type_cast value
         "t.lo"
       end
     }
 
     types = { 'author_name' => typecast.new }
-    topic = Topic.allocate.init_with 'raw_attributes' => attrs,
-                                     'column_types' => types
+    topic = Topic.instantiate(attrs, types)
 
     assert_equal 't.lo', topic.author_name
   end
diff --git a/activerecord/test/cases/persistence_test.rb b/activerecord/test/cases/persistence_test.rb
index 7f5d0d66d3..9127101433 100644
--- a/activerecord/test/cases/persistence_test.rb
+++ b/activerecord/test/cases/persistence_test.rb
@@ -250,11 +250,9 @@ class PersistenceTest < ActiveRecord::TestCase
   end
 
   def test_create_columns_not_equal_attributes
-    topic = Topic.allocate.init_with(
-      'raw_attributes' => {
-        'title'          => 'Another New Topic',
-        'does_not_exist' => 'test'
-      }
+    topic = Topic.instantiate(
+      'title'          => 'Another New Topic',
+      'does_not_exist' => 'test'
     )
     assert_nothing_raised { topic.save }
   end
@@ -300,10 +298,7 @@ class PersistenceTest < ActiveRecord::TestCase
     topic.title = "Still another topic"
     topic.save
 
-    topic_reloaded = Topic.allocate
-    topic_reloaded.init_with(
-      'raw_attributes' => topic.attributes.merge('does_not_exist' => 'test')
-    )
+    topic_reloaded = Topic.instantiate(topic.attributes.merge('does_not_exist' => 'test'))
     topic_reloaded.title = 'A New Topic'
     assert_nothing_raised { topic_reloaded.save }
   end
diff --git a/activerecord/test/cases/serialized_attribute_test.rb b/activerecord/test/cases/serialized_attribute_test.rb
index 7d1c240638..82df0a5f08 100644
--- a/activerecord/test/cases/serialized_attribute_test.rb
+++ b/activerecord/test/cases/serialized_attribute_test.rb
@@ -36,12 +36,6 @@ class SerializedAttributeTest < ActiveRecord::TestCase
     assert_equal(myobj, topic.content)
   end
 
-  def test_serialized_attribute_init_with
-    topic = Topic.allocate
-    topic.init_with('raw_attributes' => { 'content' => '--- foo' })
-    assert_equal 'foo', topic.content
-  end
-
   def test_serialized_attribute_in_base_class
     Topic.serialize("content", Hash)
 
diff --git a/activerecord/test/cases/store_test.rb b/activerecord/test/cases/store_test.rb
index f841b1c983..e9cdf94c99 100644
--- a/activerecord/test/cases/store_test.rb
+++ b/activerecord/test/cases/store_test.rb
@@ -189,7 +189,6 @@ class StoreTest < ActiveRecord::TestCase
     assert_equal @john, loaded
 
     second_dump = YAML.dump(loaded)
-    assert_equal dumped, second_dump
     assert_equal @john, YAML.load(second_dump)
   end
 end