MONGOID-5404 Populate attributes_before_type_cast on read from database (#5347)

* MONGOID-5222 update attributes_before_typecast on read

* MONGOID-5222 fix test

* MONGOID-5404 change abtc to function like rails

* MONGOID-5404 add a release note

* MONGOID-5404 update tests

* MONGOID-5404 fix docs

Author: neilshweky

docs/release-notes/mongoid-8.0.txt

@@ -600,3 +600,26 @@ returns ``true``:
     b.name == "Depeche Mode"
   end
   # => #<Band _id: 62c58e383282a4cbe82bd74b, name: "Depeche Mode">
+
+
+Changes to the ``attributes_before_type_cast`` Hash
+---------------------------------------------------
+
+The ``attributes_before_type_cast`` hash has been changed to function more like
+ActiveRecord:
+
+  - On instantiation of a new model (without parameters), the
+    ``attributes_before_type_cast`` hash has the same contents as the
+    ``attributes`` hash. If parameters are passed to the initializer, those
+    values will be stored in the ``attributes_before_type_cast`` hash before
+    they are ``mongoized``.
+  - When assigning a value to the model, the ``mongoized`` value (i.e. when
+    assiging '1' to an Integer field, it is ``mongoized`` to 1) is stored in
+    the ``attributes`` hash, whereas the raw value (i.e. '1') is stored in the
+    ``attributes_before_type_cast`` hash.
+  - When saving, creating (i.e. using the ``create!`` method), or reloading the
+    model, the ``attributes_before_type_cast`` hash is reset to have the same
+    contents as the ``attributes`` hash.
+  - When reading a document from the database, the ``attributes_before_type_cast``
+    hash contains the attributes as they appear in the database, as opposed to
+    their ``demongoized`` form.

lib/mongoid/attributes.rb

@@ -86,12 +86,25 @@ def has_attribute_before_type_cast?(name)
     def read_attribute(name)
       field = fields[name.to_s]
       raw = read_raw_attribute(name)
-      # Keep this code consistent with Mongoid::Fields.create_field_getter
+      process_raw_attribute(name.to_s, raw, field)
+    end
+    alias :[] :read_attribute
+
+
+    # Process the raw attribute values just read from the documents attributes.
+    #
+    # @param [ String ] name The name of the attribute to get.
+    # @param [ Object ] raw The raw attribute value.
+    # @param [ Field | nil ] field The field to use for demongoization or nil.
+    #
+    # @return [ Object ] The value of the attribute.
+    #
+    # @api private
+    def process_raw_attribute(name, raw, field)
       value = field ? field.demongoize(raw) : raw
-      attribute_will_change!(name.to_s) if value.resizable?
+      attribute_will_change!(name) if value.resizable?
       value
     end
-    alias :[] :read_attribute
 
     # Read a value from the attributes before type cast. If the value has not
     # yet been assigned then this will return the attribute's existing value

lib/mongoid/changeable.rb

@@ -82,6 +82,7 @@ def move_changes
     #   document.post_persist
     def post_persist
       reset_persisted_descendants
+      reset_attributes_before_type_cast
       move_changes
     end
 
@@ -248,6 +249,10 @@ def reset_attribute_to_default!(attr)
       end
     end
 
+    def reset_attributes_before_type_cast
+      @attributes_before_type_cast = @attributes.dup
+    end
+
     module ClassMethods
 
       private

lib/mongoid/document.rb

@@ -224,6 +224,7 @@ def construct_document(attrs = nil, execute_callbacks: true)
         process_attributes(attrs) do
           yield(self) if block_given?
         end
+        @attributes_before_type_cast = @attributes.merge(attributes_before_type_cast)
 
         if execute_callbacks
           apply_post_processed_defaults
@@ -318,6 +319,10 @@ def instantiate_document(attrs = nil, selected_fields = nil, execute_callbacks:
         doc = allocate
         doc.__selected_fields = selected_fields
         doc.instance_variable_set(:@attributes, attributes)
+        # TODO: remove the to_h when the legacy_attributes flag is removed.
+        # The to_h ensures that we don't accidentally make attributes_before_type_cast
+        # a BSON::Document.
+        doc.instance_variable_set(:@attributes_before_type_cast, attributes&.to_h.dup)
 
         if execute_callbacks
           doc.apply_defaults

lib/mongoid/fields.rb

@@ -636,10 +636,7 @@ def create_field_getter(name, meth, field)
             if lazy_settable?(field, raw)
               write_attribute(name, field.eval_default(self))
             else
-              # Keep this code consistent with Mongoid::Attributes#read_attribute
-              value = field.demongoize(raw)
-              attribute_will_change!(name) if value.resizable?
-              value
+              process_raw_attribute(name.to_s, raw, field)
             end
           end
         end

lib/mongoid/reloadable.rb

@@ -27,7 +27,7 @@ def reload
         raise Errors::DocumentNotFound.new(self.class, _id, shard_keys)
       end
       @attributes = reloaded
-      @attributes_before_type_cast = {}
+      @attributes_before_type_cast = @attributes.dup
       @changed_attributes = {}
       @previous_changes = {}
       @previous_attributes = {}

spec/mongoid/attributes_spec.rb

@@ -1266,8 +1266,8 @@
 
     context "before the attribute has been assigned" do
 
-      it "returns false" do
-        expect(person.has_attribute_before_type_cast?(:age)).to be false
+      it "returns true" do
+        expect(person.has_attribute_before_type_cast?(:age)).to be true
       end
     end
 

spec/mongoid/fields_spec.rb

@@ -588,6 +588,142 @@
         expect(person.age_before_type_cast).to eq("old")
       end
     end
+
+    context "when reloading" do
+
+      let(:product) do
+        Product.create!(price: '1')
+      end
+
+      before do
+        product.reload
+      end
+
+      it "resets the attributes_before_type_cast to the attributes hash" do
+        expect(product.attributes_before_type_cast).to eq(product.attributes)
+      end
+
+      it "the *_before_type_cast method returns the demongoized value" do
+        expect(product.price_before_type_cast).to eq(1)
+      end
+    end
+
+    context "when reloading and writing a demongoizable value" do
+
+      let(:product) do
+        Product.create!.tap do |product|
+          Product.collection.update_one({ _id: product.id }, { :$set => { price: '1' }})
+        end
+      end
+
+      before do
+        product.reload
+      end
+
+      it "resets the attributes_before_type_cast to the attributes hash" do
+        expect(product.attributes_before_type_cast).to eq(product.attributes)
+      end
+
+      it "the *_before_type_cast method returns the mongoized value" do
+        expect(product.price_before_type_cast).to eq('1')
+      end
+    end
+
+    context "when reading from the db" do
+
+      let(:product) do
+        Product.create!(price: '1')
+      end
+
+      let(:from_db) do
+        Product.find(product.id)
+      end
+
+      it "resets the attributes_before_type_cast to the attributes hash" do
+        expect(from_db.attributes_before_type_cast).to eq(from_db.attributes)
+      end
+
+      it "the *_before_type_cast method returns the demongoized value" do
+        expect(from_db.price_before_type_cast).to eq(1)
+      end
+    end
+
+    context "when reading from the db after writing a demongoizable value" do
+
+      let(:product) do
+        Product.create!.tap do |product|
+          Product.collection.update_one({ _id: product.id }, { :$set => { price: '1' }})
+        end
+      end
+
+      let(:from_db) do
+        Product.find(product.id)
+      end
+
+      it "resets the attributes_before_type_cast to the attributes hash" do
+        expect(from_db.attributes_before_type_cast).to eq(from_db.attributes)
+      end
+
+      it "the *_before_type_cast method returns the mongoized value" do
+        expect(from_db.price_before_type_cast).to eq('1')
+      end
+    end
+
+    context "when making a new model" do
+
+      context "when using new with no options" do
+        let(:product) { Product.new }
+
+        it "sets the attributes_before_type_cast to the attributes hash" do
+          expect(product.attributes_before_type_cast).to eq(product.attributes)
+        end
+      end
+
+      context "when using new with options" do
+        let(:product) { Product.new(price: '1') }
+
+        let(:abtc) do
+          product.attributes.merge('price' => '1')
+        end
+
+        it "has the attributes before type cast" do
+          expect(product.attributes_before_type_cast).to eq(abtc)
+        end
+      end
+
+      context "when persisting the model" do
+        let(:product) { Product.new(price: '1') }
+
+        let(:abtc) do
+          product.attributes.merge('price' => '1')
+        end
+
+        before do
+          expect(product.attributes_before_type_cast).to eq(abtc)
+          product.save!
+        end
+
+        it "resets the attributes_before_type_cast to the attributes" do
+          expect(product.attributes_before_type_cast).to eq(product.attributes)
+        end
+      end
+
+      context "when using create! without options" do
+        let(:product) { Product.create! }
+
+        it "resets the attributes_before_type_cast to the attributes" do
+          expect(product.attributes_before_type_cast).to eq(product.attributes)
+        end
+      end
+
+      context "when using create! with options" do
+        let(:product) { Product.create!(price: '1') }
+
+        it "resets the attributes_before_type_cast to the attributes" do
+          expect(product.attributes_before_type_cast).to eq(product.attributes)
+        end
+      end
+    end
   end
 
   describe "#setter=" do
@@ -741,6 +877,22 @@
         end
       end
     end
+
+    context "when the field needs to be mongoized" do
+
+      before do
+        product.price = "1"
+        product.save!
+      end
+
+      it "mongoizes the value" do
+        expect(product.price).to eq(1)
+      end
+
+      it "stores the value in the mongoized form" do
+        expect(product.attributes_before_type_cast["price"]).to eq(1)
+      end
+    end
   end
 
   describe "#defaults" do

spec/mongoid/reloadable_spec.rb

@@ -103,7 +103,7 @@
       end
 
       it "resets attributes_before_type_cast" do
-        expect(person.attributes_before_type_cast).to be_empty
+        expect(person.attributes_before_type_cast).to eq(person.attributes)
       end
     end