mongoid 9.0.7 → 9.0.9

data/lib/mongoid/pluckable.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Mongoid
+  # Provides shared behavior for any document with "pluck" functionality.
+  #
+  # @api private
+  module Pluckable
+    extend ActiveSupport::Concern
+
+    private
+
+    # Prepares the field names for plucking by normalizing them to their
+    # database field names. Also prepares a projection hash if requested.
+    def prepare_pluck(field_names, document_class: klass, prepare_projection: false)
+      normalized_field_names = []
+      projection = {}
+
+      field_names.each do |f|
+        db_fn = document_class.database_field_name(f)
+        normalized_field_names.push(db_fn)
+
+        next unless prepare_projection
+
+        cleaned_name = document_class.cleanse_localized_field_names(f)
+        canonical_name = document_class.database_field_name(cleaned_name)
+        projection[canonical_name] = true
+      end
+
+      { field_names: normalized_field_names, projection: projection }
+    end
+
+    # Plucks the given field names from the given documents.
+    def pluck_from_documents(documents, field_names, document_class: klass)
+      documents.reduce([]) do |plucked, doc|
+        values = field_names.map { |name| extract_value(doc, name.to_s, document_class) }
+        plucked << ((values.size == 1) ? values.first : values)
+      end
+    end
+
+    # Fetch the element from the given hash and demongoize it using the
+    # given field. If the obj is an array, map over it and call this method
+    # on all of its elements.
+    #
+    # @param [ Hash | Array<Hash> ] obj The hash or array of hashes to fetch from.
+    # @param [ String ] key The key to fetch from the hash.
+    # @param [ Field ] field The field to use for demongoization.
+    #
+    # @return [ Object ] The demongoized value.
+    def fetch_and_demongoize(obj, key, field)
+      if obj.is_a?(Array)
+        obj.map { |doc| fetch_and_demongoize(doc, key, field) }
+      else
+        value = obj.try(:fetch, key, nil)
+        field ? field.demongoize(value) : value.class.demongoize(value)
+      end
+    end
+
+    # Extracts the value for the given field name from the given attribute
+    # hash.
+    #
+    # @param [ Hash ] attrs The attributes hash.
+    # @param [ String ] field_name The name of the field to extract.
+    #
+    # @return [ Object ] The value for the given field name
+    def extract_value(attrs, field_name, document_class)
+      i = 1
+      num_meths = field_name.count('.') + 1
+      curr = attrs.dup
+
+      document_class.traverse_association_tree(field_name) do |meth, obj, is_field|
+        field = obj if is_field
+
+        # use the correct document class to check for localized fields on
+        # embedded documents.
+        document_class = obj.klass if obj.respond_to?(:klass)
+
+        is_translation = false
+        # If no association or field was found, check if the meth is an
+        # _translations field.
+        if obj.nil? && (tr = meth.match(/(.*)_translations\z/)&.captures&.first)
+          is_translation = true
+          meth = document_class.database_field_name(tr)
+        end
+
+        curr = descend(i, curr, meth, field, num_meths, is_translation)
+
+        i += 1
+      end
+      curr
+    end
+
+    # Descend one level in the attribute hash.
+    #
+    # @param [ Integer ] part The current part index.
+    # @param [ Hash | Array<Hash> ] current The current level in the attribute hash.
+    # @param [ String ] method_name The method name to descend to.
+    # @param [ Field|nil ] field The field to use for demongoization.
+    # @param [ Boolean ] is_translation Whether the method is an _translations field.
+    # @param [ Integer ] part_count The total number of parts in the field name.
+    #
+    # @return [ Object ] The value at the next level.
+    #
+    # rubocop:disable Metrics/ParameterLists
+    def descend(part, current, method_name, field, part_count, is_translation)
+      # 1. If curr is an array fetch from all elements in the array.
+      # 2. If the field is localized, and is not an _translations field
+      #    (_translations fields don't show up in the fields hash).
+      #    - If this is the end of the methods, return the translation for
+      #      the current locale.
+      #    - Otherwise, return the whole translations hash so the next method
+      #      can select the language it wants.
+      # 3. If the meth is an _translations field, do not demongoize the
+      #    value so the full hash is returned.
+      # 4. Otherwise, fetch and demongoize the value for the key meth.
+      if current.is_a? Array
+        res = fetch_and_demongoize(current, method_name, field)
+        res.empty? ? nil : res
+      elsif !is_translation && field&.localized?
+        if part < part_count
+          current.try(:fetch, method_name, nil)
+        else
+          fetch_and_demongoize(current, method_name, field)
+        end
+      elsif is_translation
+        current.try(:fetch, method_name, nil)
+      else
+        fetch_and_demongoize(current, method_name, field)
+      end
+    end
+    # rubocop:enable Metrics/ParameterLists
+  end
+end

data/lib/mongoid/railties/bson_object_id_serializer.rb

@@ -33,6 +33,13 @@ module Mongoid
         def deserialize(string)
           BSON::ObjectId.from_string(string)
         end
+
+        # Returns the klass this serializer handles.
+        #
+        # @return [ BSON::ObjectId ] The class this serializer handles.
+        def klass
+          BSON::ObjectId
+        end
       end
     end
   end

data/lib/mongoid/reloadable.rb

@@ -17,6 +17,12 @@ module Mongoid
       reloaded = _reload
       check_for_deleted_document!(reloaded)
 
+      # In an instance where we create a new document, but set the ID to an existing one,
+      #   when the document is reloaded, we want to set new_record to false.
+      #   This is necessary otherwise saving will fail, as it will try to insert the document,
+      #   instead of attempting to update the existing document.
+      @new_record = false unless reloaded.nil? || reloaded.empty?
+
       reset_object!(reloaded)
 
       run_callbacks(:find) unless _find_callbacks.empty?

data/lib/mongoid/traversable.rb

@@ -131,7 +131,6 @@ module Mongoid
       # @param [ String ] value The discriminator key to set.
       #
       # @api private
-      # rubocop:disable Metrics/AbcSize
       def discriminator_key=(value)
         raise Errors::InvalidDiscriminatorKeyTarget.new(self, superclass) if hereditary?
 
@@ -159,7 +158,6 @@ module Mongoid
         default_proc = -> { self.class.discriminator_value }
         field(discriminator_key, default: default_proc, type: String)
       end
-      # rubocop:enable Metrics/AbcSize
 
       # Returns the discriminator key.
       #

data/lib/mongoid/version.rb

@@ -5,5 +5,5 @@ module Mongoid
   #
   # Note that this file is automatically updated via `rake candidate:create`.
   # Manual changes to this file will be overwritten by that rake task.
-  VERSION = '9.0.7'
+  VERSION = '9.0.9'
 end

data/spec/integration/associations/embeds_many_spec.rb

@@ -3,6 +3,24 @@
 
 require 'spec_helper'
 
+module EmbedsManySpec
+  class Post
+    include Mongoid::Document
+    field :title, type: String
+    embeds_many :comments, class_name: 'EmbedsManySpec::Comment', as: :container
+    accepts_nested_attributes_for :comments
+  end
+
+  class Comment
+    include Mongoid::Document
+    field :content, type: String
+    validates :content, presence: true
+    embedded_in :container, polymorphic: true
+    embeds_many :comments, class_name: 'EmbedsManySpec::Comment', as: :container
+    accepts_nested_attributes_for :comments
+  end
+end
+
 describe 'embeds_many associations' do
 
   context 're-associating the same object' do
@@ -201,6 +219,47 @@ describe 'embeds_many associations' do
         include_examples 'persists correctly'
       end
     end
+
+    context 'including duplicates in the assignment' do
+      let(:canvas) do
+        Canvas.create!(shapes: [Shape.new])
+      end
+
+      shared_examples 'persists correctly' do
+        it 'persists correctly' do
+          canvas.shapes.length.should eq 2
+          _canvas = Canvas.find(canvas.id)
+          _canvas.shapes.length.should eq 2
+        end
+      end
+
+      context 'via assignment operator' do
+        before do
+          canvas.shapes = [ canvas.shapes.first, Shape.new, canvas.shapes.first ]
+          canvas.save!
+        end
+
+        include_examples 'persists correctly'
+      end
+
+      context 'via attributes=' do
+        before do
+          canvas.attributes = { shapes: [ canvas.shapes.first, Shape.new, canvas.shapes.first ] }
+          canvas.save!
+        end
+
+        include_examples 'persists correctly'
+      end
+
+      context 'via assign_attributes' do
+        before do
+          canvas.assign_attributes(shapes: [ canvas.shapes.first, Shape.new, canvas.shapes.first ])
+          canvas.save!
+        end
+
+        include_examples 'persists correctly'
+      end
+    end
   end
 
   context 'when an anonymous class defines an embeds_many association' do
@@ -217,4 +276,55 @@ describe 'embeds_many associations' do
       expect(klass.new.addresses.build).to be_a Address
     end
   end
+
+  context 'with deeply nested trees' do
+    let(:post) { EmbedsManySpec::Post.create!(title: 'Post') }
+    let(:child) { post.comments.create!(content: 'Child') }
+
+    # creating grandchild will cascade to create the other documents
+    let!(:grandchild) { child.comments.create!(content: 'Grandchild') }
+
+    let(:updated_parent_title) { 'Post Updated' }
+    let(:updated_grandchild_content) { 'Grandchild Updated' }
+
+    context 'with nested attributes' do
+      let(:attributes) do
+        {
+          title: updated_parent_title,
+          comments_attributes: [
+            {
+              # no change for comment1
+              _id: child.id,
+              comments_attributes: [
+                {
+                  _id: grandchild.id,
+                  content: updated_grandchild_content,
+                }
+              ]
+            }
+          ]
+        }
+      end
+
+      context 'when the grandchild is invalid' do
+        let(:updated_grandchild_content) { '' } # invalid value
+
+        it 'will not save the parent' do
+          expect(post.update(attributes)).to be_falsey
+          expect(post.errors).not_to be_empty
+          expect(post.reload.title).not_to eq(updated_parent_title)
+          expect(grandchild.reload.content).not_to eq(updated_grandchild_content)
+        end
+      end
+
+      context 'when the grandchild is valid' do
+        it 'will save the parent' do
+          expect(post.update(attributes)).to be_truthy
+          expect(post.errors).to be_empty
+          expect(post.reload.title).to eq(updated_parent_title)
+          expect(grandchild.reload.content).to eq(updated_grandchild_content)
+        end
+      end
+    end
+  end
 end

data/spec/integration/associations/has_and_belongs_to_many_spec.rb

@@ -23,6 +23,38 @@ module HabtmSpec
     include Mongoid::Document
     field :file, type: String
   end
+
+  class Item
+    include Mongoid::Document
+
+    field :title, type: String
+
+    has_and_belongs_to_many :colors, class_name: 'HabtmSpec::Color', inverse_of: :items
+
+    accepts_nested_attributes_for :colors
+  end
+
+  class Beam
+    include Mongoid::Document
+
+    field :name, type: String
+    validates :name, presence: true
+
+    has_and_belongs_to_many :colors, class_name: 'HabtmSpec::Color', inverse_of: :beams
+
+    accepts_nested_attributes_for :colors
+  end
+
+  class Color
+    include Mongoid::Document
+
+    field :name, type: String
+    
+    has_and_belongs_to_many :items, class_name: 'HabtmSpec::Item', inverse_of: :colors
+    has_and_belongs_to_many :beams, class_name: 'HabtmSpec::Beam', inverse_of: :colors
+
+    accepts_nested_attributes_for :items, :beams
+  end
 end
 
 describe 'has_and_belongs_to_many associations' do
@@ -59,4 +91,53 @@ describe 'has_and_belongs_to_many associations' do
       expect { image_block.save! }.not_to raise_error
     end
   end
+
+  context 'with deeply nested trees' do
+    let(:item) { HabtmSpec::Item.create!(title: 'Item') }
+    let(:beam) { HabtmSpec::Beam.create!(name: 'Beam') }
+    let!(:color) { HabtmSpec::Color.create!(name: 'Red', items: [ item ], beams: [ beam ]) }
+
+    let(:updated_item_title) { 'Item Updated' }
+    let(:updated_beam_name) { 'Beam Updated' }
+
+    context 'with nested attributes' do
+      let(:attributes) do
+        {
+          title: updated_item_title,
+          colors_attributes: [
+            {
+              # no change for color
+              _id: color.id,
+              beams_attributes: [
+                {
+                  _id: beam.id,
+                  name: updated_beam_name,
+                }
+              ]
+            }
+          ]
+        }
+      end
+
+      context 'when the beam is invalid' do
+        let(:updated_beam_name) { '' } # invalid value
+
+        it 'will not save the parent' do
+          expect(item.update(attributes)).to be_falsey
+          expect(item.errors).not_to be_empty
+          expect(item.reload.title).not_to eq(updated_item_title)
+          expect(beam.reload.name).not_to eq(updated_beam_name)
+        end
+      end
+
+      context 'when the beam is valid' do
+        it 'will save the parent' do
+          expect(item.update(attributes)).to be_truthy
+          expect(item.errors).to be_empty
+          expect(item.reload.title).to eq(updated_item_title)
+          expect(beam.reload.name).to eq(updated_beam_name)
+        end
+      end
+    end
+  end
 end

data/spec/integration/associations/has_many_spec.rb

@@ -126,4 +126,60 @@ describe 'has_many associations' do
       end
     end
   end
+
+  context 'with deeply nested trees' do
+    let(:post) { HmmPost.create!(title: 'Post') }
+    let(:child) { post.comments.create!(title: 'Child') }
+
+    # creating grandchild will cascade to create the other documents
+    let!(:grandchild) { child.comments.create!(title: 'Grandchild') }
+
+    let(:updated_parent_title) { 'Post Updated' }
+    let(:updated_grandchild_title) { 'Grandchild Updated' }
+
+    context 'with nested attributes' do
+      let(:attributes) do
+        {
+          title: updated_parent_title,
+          comments_attributes: [
+            {
+              # no change for comment1
+              _id: child.id,
+              comments_attributes: [
+                {
+                  _id: grandchild.id,
+                  title: updated_grandchild_title,
+                  num: updated_grandchild_num,
+                }
+              ]
+            }
+          ]
+        }
+      end
+
+      context 'when the grandchild is invalid' do
+        let(:updated_grandchild_num) { -1 } # invalid value
+
+        it 'will not save the parent' do
+          expect(post.update(attributes)).to be_falsey
+          expect(post.errors).not_to be_empty
+          expect(post.reload.title).not_to eq(updated_parent_title)
+          expect(grandchild.reload.title).not_to eq(updated_grandchild_title)
+          expect(grandchild.num).not_to eq(updated_grandchild_num)
+        end
+      end
+
+      context 'when the grandchild is valid' do
+        let(:updated_grandchild_num) { 1 }
+
+        it 'will save the parent' do
+          expect(post.update(attributes)).to be_truthy
+          expect(post.errors).to be_empty
+          expect(post.reload.title).to eq(updated_parent_title)
+          expect(grandchild.reload.title).to eq(updated_grandchild_title)
+          expect(grandchild.num).to eq(updated_grandchild_num)
+        end
+      end
+    end
+  end
 end

data/spec/integration/associations/has_one_spec.rb

@@ -224,7 +224,7 @@ describe 'has_one associations' do
     end
 
     context "when explicitly setting the foreign key" do
-      let(:comment2) { HomComment.new(post_id: post.id, content: "2") }
+      let(:comment2) { HomComment.new(container_id: post.id, container_type: post.class.name, content: "2") }
 
       it "persists the new comment" do
         post.comment = comment1
@@ -264,10 +264,62 @@ describe 'has_one associations' do
 
     it "does not overwrite the original value" do
       pending "MONGOID-3999"
-      p1 = comment.post
+      p1 = comment.container
       expect(p1.title).to eq("post 1")
-      comment.post = post2
+      comment.container = post2
       expect(p1.title).to eq("post 1")
     end
   end
+
+  context 'with deeply nested trees' do
+    let(:post) { HomPost.create!(title: 'Post') }
+    let(:child) { post.create_comment(content: 'Child') }
+
+    # creating grandchild will cascade to create the other documents
+    let!(:grandchild) { child.create_comment(content: 'Grandchild') }
+
+    let(:updated_parent_title) { 'Post Updated' }
+    let(:updated_grandchild_content) { 'Grandchild Updated' }
+
+    context 'with nested attributes' do
+      let(:attributes) do
+        {
+          title: updated_parent_title,
+          comment_attributes: {
+            # no change for child
+            _id: child.id,
+            comment_attributes: {
+              _id: grandchild.id,
+              content: updated_grandchild_content,
+              num: updated_grandchild_num,
+            }
+          }
+        }
+      end
+
+      context 'when the grandchild is invalid' do
+        let(:updated_grandchild_num) { -1 } # invalid value
+
+        it 'will not save the parent' do
+          expect(post.update(attributes)).to be_falsey
+          expect(post.errors).not_to be_empty
+          expect(post.reload.title).not_to eq(updated_parent_title)
+          expect(grandchild.reload.content).not_to eq(updated_grandchild_content)
+          expect(grandchild.num).not_to eq(updated_grandchild_num)
+        end
+      end
+
+      context 'when the grandchild is valid' do
+        let(:updated_grandchild_num) { 1 }
+
+        it 'will save the parent' do
+          expect(post.update(attributes)).to be_truthy
+          expect(post.errors).to be_empty
+          expect(post.reload.title).to eq(updated_parent_title)
+          expect(grandchild.reload.content).to eq(updated_grandchild_content)
+          expect(grandchild.num).to eq(updated_grandchild_num)
+        end
+      end
+    end
+  end
 end