mongoid 3.1.5 → 8.0.2

data/lib/mongoid/atomic.rb

@@ -1,4 +1,5 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
 require "mongoid/atomic/modifiers"
 require "mongoid/atomic/paths"
 
@@ -31,12 +32,12 @@ module Mongoid
     # @example Add the atomic pull.
     #   person.add_atomic_pull(address)
     #
-    # @param [ Document ] The embedded document to pull.
-    #
-    # @since 2.2.0
+    # @param [ Document ] document The embedded document to pull.
     def add_atomic_pull(document)
       document.flagged_for_destroy = true
-      (delayed_atomic_pulls[document.metadata_name.to_s] ||= []).push(document)
+      key = document.association_name.to_s
+      delayed_atomic_pulls[key] ||= []
+      delayed_atomic_pulls[key] << document
     end
 
     # Add an atomic unset for the document.
@@ -47,11 +48,11 @@ module Mongoid
     # @param [ Document ] document The child document.
     #
     # @return [ Array<Document> ] The children.
-    #
-    # @since 3.0.0
     def add_atomic_unset(document)
       document.flagged_for_destroy = true
-      (delayed_atomic_unsets[document.metadata_name.to_s] ||= []).push(document)
+      key = document.association_name.to_s
+      delayed_atomic_unsets[key] ||= []
+      delayed_atomic_unsets[key] << document
     end
 
     # Returns path of the attribute for modification
@@ -60,8 +61,6 @@ module Mongoid
     #   address.atomic_attribute_name(:city)
     #
     # @return [ String ] The path to the document attribute in the database
-    #
-    # @since 3.0.0
     def atomic_attribute_name(name)
       embedded? ? "#{atomic_position}.#{name}" : name
     end
@@ -72,8 +71,6 @@ module Mongoid
     #   person.atomic_array_pushes
     #
     # @return [ Hash ] The array pushes.
-    #
-    # @since 2.4.0
     def atomic_array_pushes
       @atomic_array_pushes ||= {}
     end
@@ -84,8 +81,6 @@ module Mongoid
     #   person.atomic_array_pulls
     #
     # @return [ Hash ] The array pulls.
-    #
-    # @since 2.4.0
     def atomic_array_pulls
       @atomic_array_pulls ||= {}
     end
@@ -96,8 +91,6 @@ module Mongoid
     #   person.atomic_array_add_to_sets
     #
     # @return [ Hash ] The array add_to_sets.
-    #
-    # @since 2.4.0
     def atomic_array_add_to_sets
       @atomic_array_add_to_sets ||= {}
     end
@@ -110,10 +103,10 @@ module Mongoid
     #   performed in a single operation. Conflicting modifications are
     #   detected by the 'haveConflictingMod' function in MongoDB.
     #   Examination of the code suggests that two modifications (a $set
-    #   and a $pushAll, for example) conflict if:
+    #   and a $push with $each, for example) conflict if:
     #     (1) the key paths being modified are equal.
     #     (2) one key path is a prefix of the other.
-    #   So a $set of 'addresses.0.street' will conflict with a $pushAll
+    #   So a $set of 'addresses.0.street' will conflict with a $push and $each
     #   to 'addresses', and we will need to split our update into two
     #   pieces. We do not, however, attempt to match MongoDB's logic
     #   exactly. Instead, we assume that two updates conflict if the
@@ -123,13 +116,11 @@ module Mongoid
     #   person.atomic_updates(children)
     #
     # @return [ Hash ] The updates and their modifiers.
-    #
-    # @since 2.1.0
-    def atomic_updates(use_indexes = false)
+    def atomic_updates(_use_indexes = false)
       process_flagged_destroys
       mods = Modifiers.new
       generate_atomic_updates(mods, self)
-      _children.each do |child|
+      _descendants.each do |child|
         child.process_flagged_destroys
         generate_atomic_updates(mods, child)
       end
@@ -186,10 +177,14 @@ module Mongoid
     #   document.atomic_paths
     #
     # @return [ Object ] The associated path.
-    #
-    # @since 2.1.0
     def atomic_paths
-      @atomic_paths ||= metadata ? metadata.path(self) : Atomic::Paths::Root.new(self)
+      @atomic_paths ||= begin
+        if _association
+          _association.path(self)
+        else
+          Atomic::Paths::Root.new(self)
+        end
+      end
     end
 
     # Get all the attributes that need to be pulled.
@@ -198,15 +193,13 @@ module Mongoid
     #   person.atomic_pulls
     #
     # @return [ Array<Hash> ] The $pullAll operations.
-    #
-    # @since 2.2.0
     def atomic_pulls
       pulls = {}
       delayed_atomic_pulls.each_pair do |_, docs|
         path = nil
         ids = docs.map do |doc|
           path ||= doc.flag_as_destroyed
-          doc.id
+          doc._id
         end
         pulls[path] = { "_id" => { "$in" => ids }} and path = nil
       end
@@ -218,22 +211,9 @@ module Mongoid
     # @example Get the pushes.
     #   person.atomic_pushes
     #
-    # @return [ Hash ] The $pushAll operations.
-    #
-    # @since 2.1.0
+    # @return [ Hash ] The $push and $each operations.
     def atomic_pushes
-      pushable? ? { atomic_position => as_document } : {}
-    end
-
-    # Return the selector for this document to be matched exactly for use
-    # with MongoDB's $ operator.
-    #
-    # @example Get the selector.
-    #   address.atomic_selector
-    #
-    # @return [ String ] The exact selector for this document.
-    def atomic_selector
-      atomic_paths.selector
+      pushable? ? { atomic_position => as_attributes } : {}
     end
 
     # Get all the attributes that need to be set.
@@ -242,10 +222,8 @@ module Mongoid
     #   person.atomic_sets
     #
     # @return [ Hash ] The $set operations.
-    #
-    # @since 2.1.0
     def atomic_sets
-      updateable? ? setters : settable? ? { atomic_path => as_document } : {}
+      updateable? ? setters : settable? ? { atomic_path => as_attributes } : {}
     end
 
     # Get all the attributes that need to be unset.
@@ -254,8 +232,6 @@ module Mongoid
     #   person.atomic_unsets
     #
     # @return [ Array<Hash> ] The $unset operations.
-    #
-    # @since 2.2.0
     def atomic_unsets
       unsets = []
       delayed_atomic_unsets.each_pair do |name, docs|
@@ -274,8 +250,6 @@ module Mongoid
     #   person.delayed_atomic_sets
     #
     # @return [ Hash ] The delayed $sets.
-    #
-    # @since 2.3.0
     def delayed_atomic_sets
       @delayed_atomic_sets ||= {}
     end
@@ -286,8 +260,6 @@ module Mongoid
     #   document.delayed_atomic_pulls
     #
     # @return [ Hash ] name/document pairs.
-    #
-    # @since 2.3.2
     def delayed_atomic_pulls
       @delayed_atomic_pulls ||= {}
     end
@@ -298,8 +270,6 @@ module Mongoid
     #   document.delayed_atomic_unsets
     #
     # @return [ Hash ] The atomic unsets
-    #
-    # @since 3.0.0
     def delayed_atomic_unsets
       @delayed_atomic_unsets ||= {}
     end
@@ -310,8 +280,6 @@ module Mongoid
     #   document.flag_as_destroyed
     #
     # @return [ String ] The atomic path.
-    #
-    # @since 3.0.0
     def flag_as_destroyed
       self.destroyed = true
       self.flagged_for_destroy = false
@@ -324,8 +292,6 @@ module Mongoid
     #   document.flagged_destroys
     #
     # @return [ Array<Proc> ] The flagged destroys.
-    #
-    # @since 3.0.10
     def flagged_destroys
       @flagged_destroys ||= []
     end
@@ -336,13 +302,9 @@ module Mongoid
     #   document.process_flagged_destroys
     #
     # @return [ Array ] The cleared array.
-    #
-    # @since 3.0.10
     def process_flagged_destroys
       _assigning do
-        flagged_destroys.each do |block|
-          block.call
-        end
+        flagged_destroys.each(&:call)
       end
       flagged_destroys.clear
     end
@@ -356,8 +318,6 @@ module Mongoid
     #
     # @param [ Modifiers ] mods The atomic modifications.
     # @param [ Document ] doc The document to update for.
-    #
-    # @since 2.2.0
     def generate_atomic_updates(mods, doc)
       mods.unset(doc.atomic_unsets)
       mods.pull(doc.atomic_pulls)
@@ -380,16 +340,39 @@ module Mongoid
     # @param [ Symbol ] field The optional field.
     #
     # @return [ Hash ] The atomic updates.
-    #
-    # @since 3.0.6
     def touch_atomic_updates(field = nil)
       updates = atomic_updates
-      return {} unless atomic_updates.has_key?("$set")
+      return {} unless atomic_updates.key?("$set")
       touches = {}
+      wanted_keys = %w(updated_at u_at)
+      # TODO this permits field to be passed as an empty string in which case
+      # it is ignored, get rid of this behavior.
+      if field.present?
+        wanted_keys << field.to_s
+      end
       updates["$set"].each_pair do |key, value|
-        touches.merge!({ key => value }) if key =~ /updated_at|#{field}/
+        if wanted_keys.include?(key.split('.').last)
+          touches.update(key => value)
+        end
       end
       { "$set" => touches }
     end
+
+    # Returns the $set atomic updates affecting the specified field.
+    #
+    # @param [ String ] field The field name.
+    #
+    # @api private
+    def set_field_atomic_updates(field)
+      updates = atomic_updates
+      return {} unless atomic_updates.key?("$set")
+      sets = {}
+      updates["$set"].each_pair do |key, value|
+        if key.split('.').last == field
+          sets.update(key => value)
+        end
+      end
+      { "$set" => sets }
+    end
   end
 end

data/lib/mongoid/attributes/dynamic.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Attributes
+
+    # This module contains the behavior for dynamic attributes.
+    module Dynamic
+      extend ActiveSupport::Concern
+
+      # Override respond_to? so it responds properly for dynamic attributes.
+      #
+      # @example Does this object respond to the method?
+      #   person.respond_to?(:title)
+      #
+      # @param [ Array ] name The name of the method.
+      # @param [ true | false ] include_private
+      #
+      # @return [ true | false ] True if it does, false if not.
+      def respond_to?(name, include_private = false)
+        super || (
+          attributes &&
+          attributes.has_key?(name.to_s.reader)
+        )
+      end
+
+      # Define a reader method for a dynamic attribute.
+      #
+      # @api private
+      #
+      # @example Define a reader method.
+      #   model.define_dynamic_reader(:field)
+      #
+      # @param [ String ] name The name of the field.
+      def define_dynamic_reader(name)
+        return unless name.valid_method_name?
+
+        class_eval do
+          define_method(name) do
+            attribute_will_change!(name)
+            read_raw_attribute(name)
+          end
+        end
+      end
+
+      # Define a reader method for a dynamic attribute before type cast.
+      #
+      # @api private
+      #
+      # @example Define a reader method for an attribute.
+      #   model.define_dynamic_before_type_cast_reader(:field)
+      #
+      # @param [ String ] name The name of the field.
+      def define_dynamic_before_type_cast_reader(name)
+        class_eval do
+          define_method("#{name}_before_type_cast") do
+            attribute_will_change!(name)
+            read_attribute_before_type_cast(name)
+          end
+        end
+      end
+
+      # Define a writer method for a dynamic attribute.
+      #
+      # @api private
+      #
+      # @example Define a writer method.
+      #   model.define_dynamic_writer(:field)
+      #
+      # @param [ String ] name The name of the field.
+      def define_dynamic_writer(name)
+        return unless name.valid_method_name?
+
+        class_eval do
+          define_method("#{name}=") do |value|
+            write_attribute(name, value)
+          end
+        end
+      end
+
+      # If the attribute is dynamic, add a field for it with a type of object
+      # and set the value.
+      #
+      # @example Process the attribute.
+      #   document.process_attribute(name, value)
+      #
+      # @param [ Symbol ] name The name of the field.
+      # @param [ Object ] value The value of the field.
+      def process_attribute(name, value)
+        responds = respond_to?("#{name}=")
+        if !responds
+          write_attribute(name, value)
+        else
+          send("#{name}=", value)
+        end
+      end
+
+      # Get an array of inspected dynamic fields for the document.
+      #
+      # @example Inspect the dynamic fields.
+      #   document.inspect_dynamic_fields
+      #
+      # @return [ String ] An array of pretty printed dynamic field values.
+      def inspect_dynamic_fields
+        keys = attributes.keys - fields.keys - relations.keys - ["_id", self.class.discriminator_key]
+        return keys.map do |name|
+          "#{name}: #{attributes[name].inspect}"
+        end
+      end
+
+      # Used for allowing accessor methods for dynamic attributes.
+      #
+      # @api private
+      #
+      # @example Call through method_missing.
+      #   document.method_missing(:test)
+      #
+      # @param [ String | Symbol ] name The name of the method.
+      # @param [ Array ] args The arguments to the method.
+      #
+      # @return [ Object ] The result of the method call.
+      def method_missing(name, *args)
+        attr = name.to_s
+        return super unless attributes.has_key?(attr.reader)
+        if attr.writer?
+          getter = attr.reader
+          define_dynamic_writer(getter)
+          write_attribute(getter, args.first)
+        elsif attr.before_type_cast?
+          define_dynamic_before_type_cast_reader(attr.reader)
+          attribute_will_change!(attr.reader)
+          read_attribute_before_type_cast(attr.reader)
+        else
+          getter = attr.reader
+          define_dynamic_reader(getter)
+          attribute_will_change!(attr.reader)
+          read_raw_attribute(getter)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/attributes/nested.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Attributes
+
+    # Defines behavior around that lovel Rails feature nested attributes.
+    module Nested
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :nested_attributes
+        self.nested_attributes = {}
+      end
+
+      module ClassMethods
+
+        REJECT_ALL_BLANK_PROC = ->(attributes){
+          attributes.all? { |key, value| key == '_destroy' || value.blank? }
+        }
+
+        # Used when needing to update related models from a parent association. Can
+        # be used on embedded or referenced associations.
+        #
+        # @example Defining nested attributes.
+        #
+        #   class Person
+        #     include Mongoid::Document
+        #
+        #     embeds_many :addresses
+        #     embeds_one :game
+        #     references_many :posts
+        #
+        #     accepts_nested_attributes_for :addresses, :game, :posts
+        #   end
+        #
+        # @param [ Array<Symbol> | Hash ] args A list of association names, followed
+        #   by a hash of options.
+        #
+        # @option *args [ true | false ] :allow_destroy Can deletion occur?
+        # @option *args [ Proc | Symbol ] :reject_if Block or symbol pointing
+        #   to a class method to reject documents with.
+        # @option *args [ Integer ] :limit The max number to create.
+        # @option *args [ true | false ] :update_only Only update existing docs.
+        # @option *args [ true | false ] :autosave Whether autosave should be enabled on the
+        #   association. Note that since the default is true, setting autosave to nil will still
+        #   enable it.
+        def accepts_nested_attributes_for(*args)
+          options = args.extract_options!.dup
+          options[:autosave] = true if options[:autosave].nil?
+
+          options[:reject_if] = REJECT_ALL_BLANK_PROC if options[:reject_if] == :all_blank
+          args.each do |name|
+            meth = "#{name}_attributes="
+            self.nested_attributes["#{name}_attributes"] = meth
+            association = relations[name.to_s]
+            raise Errors::NestedAttributesMetadataNotFound.new(self, name) unless association
+            autosave_nested_attributes(association) if options[:autosave]
+
+            re_define_method(meth) do |attrs|
+              _assigning do
+                if association.polymorphic? and association.inverse_type
+                  options = options.merge!(:class_name => self.send(association.inverse_type))
+                end
+                association.nested_builder(attrs, options).build(self)
+              end
+            end
+          end
+        end
+
+        private
+
+        # Add the autosave information for the nested association.
+        #
+        # @api private
+        #
+        # @example Add the autosave if appropriate.
+        #   Person.autosave_nested_attributes(metadata)
+        #
+        # @param [ Association ] association The existing association metadata.
+        def autosave_nested_attributes(association)
+          # In order for the autosave functionality to work properly, the association needs to be
+          # marked as autosave despite the fact that the option isn't present. Because the method
+          # Association#autosave? is implemented by checking the autosave option, this is the most
+          # straightforward way to mark it.
+          if association.autosave? || (association.options[:autosave].nil? && !association.embedded?)
+            association.options[:autosave] = true
+            Association::Referenced::AutoSave.define_autosave!(association)
+          end
+        end
+      end
+    end
+  end
+end