mongoid 6.4.8 → 7.0.0

data/lib/mongoid/association/macros.rb

@@ -0,0 +1,204 @@
+# encoding: utf-8
+module Mongoid
+  module Association
+
+    # This module contains the core macros for defining relations between
+    # documents. They can be either embedded or referenced (relational).
+    module Macros
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :embedded, instance_reader: false
+        class_attribute :embedded_relations
+        class_attribute :relations
+        self.embedded = false
+        self.embedded_relations = BSON::Document.new
+        self.relations = BSON::Document.new
+      end
+
+      # This is convenience for libraries still on the old API.
+      #
+      # @example Get the associations.
+      #   person.associations
+      #
+      # @return [ Hash ] The relations.
+      #
+      # @since 2.3.1
+      def associations
+        self.relations
+      end
+
+      module ClassMethods
+
+        # Adds the relation back to the parent document. This macro is
+        # necessary to set the references from the child back to the parent
+        # document. If a child does not define this relation calling
+        # persistence methods on the child object will cause a save to fail.
+        #
+        # @example Define the relation.
+        #
+        #   class Person
+        #     include Mongoid::Document
+        #     embeds_many :addresses
+        #   end
+        #
+        #   class Address
+        #     include Mongoid::Document
+        #     embedded_in :person
+        #   end
+        #
+        # @param [ Symbol ] name The name of the relation.
+        # @param [ Hash ] options The relation options.
+        # @param [ Proc ] block Optional block for defining extensions.
+        def embedded_in(name, options = {}, &block)
+          define_association!(__method__, name, options, &block)
+        end
+
+        # Adds the relation from a parent document to its children. The name
+        # of the relation needs to be a pluralized form of the child class
+        # name.
+        #
+        # @example Define the relation.
+        #
+        #   class Person
+        #     include Mongoid::Document
+        #     embeds_many :addresses
+        #   end
+        #
+        #   class Address
+        #     include Mongoid::Document
+        #     embedded_in :person
+        #   end
+        #
+        # @param [ Symbol ] name The name of the relation.
+        # @param [ Hash ] options The relation options.
+        # @param [ Proc ] block Optional block for defining extensions.
+        def embeds_many(name, options = {}, &block)
+          define_association!(__method__, name, options, &block)
+        end
+
+        # Adds the relation from a parent document to its child. The name
+        # of the relation needs to be a singular form of the child class
+        # name.
+        #
+        # @example Define the relation.
+        #
+        #   class Person
+        #     include Mongoid::Document
+        #     embeds_one :name
+        #   end
+        #
+        #   class Name
+        #     include Mongoid::Document
+        #     embedded_in :person
+        #   end
+        #
+        # @param [ Symbol ] name The name of the relation.
+        # @param [ Hash ] options The relation options.
+        # @param [ Proc ] block Optional block for defining extensions.
+        def embeds_one(name, options = {}, &block)
+          define_association!(__method__, name, options, &block)
+        end
+
+        # Adds a relational association from the child Document to a Document in
+        # another database or collection.
+        #
+        # @example Define the relation.
+        #
+        #   class Game
+        #     include Mongoid::Document
+        #     belongs_to :person
+        #   end
+        #
+        #   class Person
+        #     include Mongoid::Document
+        #     has_one :game
+        #   end
+        #
+        # @param [ Symbol ] name The name of the relation.
+        # @param [ Hash ] options The relation options.
+        # @param [ Proc ] block Optional block for defining extensions.
+        def belongs_to(name, options = {}, &block)
+          define_association!(__method__, name, options, &block)
+        end
+
+        # Adds a relational association from a parent Document to many
+        # Documents in another database or collection.
+        #
+        # @example Define the relation.
+        #
+        #   class Person
+        #     include Mongoid::Document
+        #     has_many :posts
+        #   end
+        #
+        #   class Game
+        #     include Mongoid::Document
+        #     belongs_to :person
+        #   end
+        #
+        # @param [ Symbol ] name The name of the relation.
+        # @param [ Hash ] options The relation options.
+        # @param [ Proc ] block Optional block for defining extensions.
+        def has_many(name, options = {}, &block)
+          define_association!(__method__, name, options, &block)
+        end
+
+        # Adds a relational many-to-many association between many of this
+        # Document and many of another Document.
+        #
+        # @example Define the relation.
+        #
+        #   class Person
+        #     include Mongoid::Document
+        #     has_and_belongs_to_many :preferences
+        #   end
+        #
+        #   class Preference
+        #     include Mongoid::Document
+        #     has_and_belongs_to_many :people
+        #   end
+        #
+        # @param [ Symbol ] name The name of the relation.
+        # @param [ Hash ] options The relation options.
+        # @param [ Proc ] block Optional block for defining extensions.
+        #
+        # @since 2.0.0.rc.1
+        def has_and_belongs_to_many(name, options = {}, &block)
+          define_association!(__method__, name, options, &block)
+        end
+
+        # Adds a relational association from the child Document to a Document in
+        # another database or collection.
+        #
+        # @example Define the relation.
+        #
+        #   class Game
+        #     include Mongoid::Document
+        #     belongs_to :person
+        #   end
+        #
+        #   class Person
+        #     include Mongoid::Document
+        #     has_one :game
+        #   end
+        #
+        # @param [ Symbol ] name The name of the relation.
+        # @param [ Hash ] options The relation options.
+        # @param [ Proc ] block Optional block for defining extensions.
+        def has_one(name, options = {}, &block)
+          define_association!(__method__, name, options, &block)
+        end
+
+        private
+
+        def define_association!(macro_name, name, options = {}, &block)
+          Association::MACRO_MAPPING[macro_name].new(self, name, options, &block).tap do |assoc|
+            assoc.setup!
+            self.relations = self.relations.merge(name => assoc)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/{relations → association}/many.rb

@@ -1,14 +1,14 @@
 # encoding: utf-8
 module Mongoid
-  module Relations
+  module Association
 
     # This is the superclass for all many to one and many to many relation
     # proxies.
-    class Many < Proxy
+    class Many < Association::Proxy
       include ::Enumerable
 
       delegate :avg, :max, :min, :sum, to: :criteria
-      delegate :length, :size, to: :target
+      delegate :length, :size, to: :_target
 
       # Is the relation empty?
       #
@@ -28,14 +28,9 @@ module Mongoid
       # @example Create and save the new document.
       #   person.posts.create(:text => "Testing")
       #
-      # @overload create(attributes = nil, options = {}, type = nil)
-      #   @param [ Hash ] attributes The attributes to create with.
-      #   @param [ Hash ] options The scoped assignment options.
-      #   @param [ Class ] type The optional type of document to create.
       #
-      # @overload create(attributes = nil, type = nil)
-      #   @param [ Hash ] attributes The attributes to create with.
-      #   @param [ Class ] type The optional type of document to create.
+      # @param [ Hash ] attributes The attributes to create with.
+      # @param [ Class ] type The optional type of document to create.
       #
       # @return [ Document ] The newly created document.
       #
@@ -45,7 +40,7 @@ module Mongoid
           attributes.map { |attrs| create(attrs, type, &block) }
         else
           doc = build(attributes, type, &block)
-          base.persisted? ? doc.save : raise_unsaved(doc)
+          _base.persisted? ? doc.save : raise_unsaved(doc)
           doc
         end
       end
@@ -57,13 +52,8 @@ module Mongoid
       # @example Create and save the new document.
       #   person.posts.create!(:text => "Testing")
       #
-      # @overload create!(attributes = nil, options = {}, type = nil)
-      #   @param [ Hash ] attributes The attributes to create with.
-      #   @param [ Class ] type The optional type of document to create.
-      #
-      # @overload create!(attributes = nil, type = nil)
-      #   @param [ Hash ] attributes The attributes to create with.
-      #   @param [ Class ] type The optional type of document to create.
+      # @param [ Hash ] attributes The attributes to create with.
+      # @param [ Class ] type The optional type of document to create.
       #
       # @raise [ Errors::Validations ] If validation failed.
       #
@@ -75,7 +65,7 @@ module Mongoid
           attributes.map { |attrs| create!(attrs, type, &block) }
         else
           doc = build(attributes, type, &block)
-          base.persisted? ? doc.save! : raise_unsaved(doc)
+          _base.persisted? ? doc.save! : raise_unsaved(doc)
           doc
         end
       end
@@ -86,13 +76,8 @@ module Mongoid
       # @example Find or create.
       #   person.posts.find_or_create_by(:title => "Testing")
       #
-      # @overload find_or_create_by(attributes = nil, type = nil)
-      #   @param [ Hash ] attributes The attributes to search or create with.
-      #   @param [ Class ] type The optional type of document to create.
-      #
-      # @overload find_or_create_by(attributes = nil, type = nil)
-      #   @param [ Hash ] attributes The attributes to search or create with.
-      #   @param [ Class ] type The optional type of document to create.
+      #  @param [ Hash ] attrs The attributes to search or create with.
+      #  @param [ Class ] type The optional type of document to create.
       #
       # @return [ Document ] An existing document or newly created one.
       def find_or_create_by(attrs = {}, type = nil, &block)
@@ -105,13 +90,8 @@ module Mongoid
       # @example Find or create.
       #   person.posts.find_or_create_by!(:title => "Testing")
       #
-      # @overload find_or_create_by!(attributes = nil, type = nil)
-      #   @param [ Hash ] attributes The attributes to search or create with.
-      #   @param [ Class ] type The optional type of document to create.
-      #
-      # @overload find_or_create_by!(attributes = nil, type = nil)
-      #   @param [ Hash ] attributes The attributes to search or create with.
-      #   @param [ Class ] type The optional type of document to create.
+      # @param [ Hash ] attrs The attributes to search or create with.
+      # @param [ Class ] type The optional type of document to create.
       #
       # @raise [ Errors::Validations ] If validation failed.
       #
@@ -126,13 +106,8 @@ module Mongoid
       # @example Find or initialize.
       #   person.posts.find_or_initialize_by(:title => "Test")
       #
-      # @overload find_or_initialize_by(attributes = {}, type = nil)
-      #   @param [ Hash ] attributes The attributes to search or initialize with.
-      #   @param [ Class ] type The optional subclass to build.
-      #
-      # @overload find_or_initialize_by(attributes = {}, type = nil)
-      #   @param [ Hash ] attributes The attributes to search or initialize with.
-      #   @param [ Class ] type The optional subclass to build.
+      # @param [ Hash ] attrs The attributes to search or initialize with.
+      # @param [ Class ] type The optional subclass to build.
       #
       # @return [ Document ] An existing document or newly instantiated one.
       def find_or_initialize_by(attrs = {}, type = nil, &block)
@@ -157,6 +132,7 @@ module Mongoid
       #   relation.respond_to?(:name)
       #
       # @param [ Symbol ] name The method name.
+      # @param [ true, false ] include_private Whether to include private methods.
       #
       # @return [ true, false ] If the proxy responds to the method.
       #
@@ -195,7 +171,7 @@ module Mongoid
       #
       # @since 2.0.0.rc.6
       def serializable_hash(options = {})
-        target.map { |document| document.serializable_hash(options) }
+        _target.map { |document| document.serializable_hash(options) }
       end
 
       # Get a criteria for the embedded documents without the default scoping
@@ -213,8 +189,8 @@ module Mongoid
 
       private
 
-      def _session
-        base.send(:_session)
+      def session
+        _base.send(:session)
       end
 
       # Find the first object given the supplied attributes or create/initialize it.
@@ -222,14 +198,8 @@ module Mongoid
       # @example Find or create|initialize.
       #   person.addresses.find_or(:create, :street => "Bond")
       #
-      # @overload find_or(method, attributes = {}, type = nil)
-      #   @param [ Symbol ] method The method name, create or new.
-      #   @param [ Hash ] attributes The attributes to search or build with.
-      #   @param [ Class ] type The optional subclass to build.
-      #
-      # @overload find_or(attributes = {}, type = nil)
       #   @param [ Symbol ] method The method name, create or new.
-      #   @param [ Hash ] attributes The attributes to search or build with.
+      #   @param [ Hash ] attrs The attributes to search or build with.
       #   @param [ Class ] type The optional subclass to build.
       #
       # @return [ Document ] A matching document or a new/created one.

data/lib/mongoid/{relations → association}/marshalable.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 module Mongoid
-  module Relations
+  module Association
     module Marshalable
 
       # Provides the data needed to Marshal.dump a relation proxy.
@@ -12,7 +12,7 @@ module Mongoid
       #
       # @since 3.0.15
       def marshal_dump
-        [ base, target, __metadata ]
+        [ _base, _target, _association ]
       end
 
       # Takes the provided data and sets it back on the proxy.
@@ -20,12 +20,14 @@ module Mongoid
       # @example Load the proxy.
       #   Marshal.load(proxy)
       #
+      # @param [ Array<Object> ] data The data to set on the proxy.
+      #
       # @return [ Array<Object> ] The loaded data.
       #
       # @since 3.0.15
       def marshal_load(data)
-        @base, @target, @__metadata = data
-        extend_proxy(__metadata.extension) if __metadata.extension?
+        @_base, @_target, @_association = data
+        extend_proxy(_association.extension) if _association.extension
       end
     end
   end

data/lib/mongoid/association/nested/many.rb

@@ -0,0 +1,200 @@
+# encoding: utf-8
+module Mongoid
+  module Association
+    module Nested
+      class Many
+        include Buildable
+
+        # Builds the relation depending on the attributes and the options
+        # passed to the macro.
+        #
+        # This attempts to perform 3 operations, either one of an update of
+        # the existing relation, a replacement of the relation with a new
+        # document, or a removal of the relation.
+        #
+        # @example Build the nested attrs.
+        #   many.build(person)
+        #
+        # @param [ Document ] parent The parent document of the relation.
+        # @param [ Hash ] options The options.
+        #
+        # @return [ Array ] The attributes.
+        def build(parent, options = {})
+          @existing = parent.send(association.name)
+          if over_limit?(attributes)
+            raise Errors::TooManyNestedAttributeRecords.new(existing, options[:limit])
+          end
+          attributes.each do |attrs|
+            if attrs.is_a?(::Hash)
+              process_attributes(parent, attrs.with_indifferent_access)
+            else
+              process_attributes(parent, attrs[1].with_indifferent_access)
+            end
+          end
+        end
+
+        # Create the new builder for nested attributes on one-to-many
+        # relations.
+        #
+        # @example Initialize the builder.
+        #   Many.new(association, attributes, options)
+        #
+        # @param [ Association ] association The association metadata.
+        # @param [ Hash ] attributes The attributes hash to attempt to set.
+        # @param [ Hash ] options The options defined.
+        def initialize(association, attributes, options = {})
+          if attributes.respond_to?(:with_indifferent_access)
+            @attributes = attributes.with_indifferent_access.sort do |a, b|
+              a[0].to_i <=> b[0].to_i
+            end
+          else
+            @attributes = attributes
+          end
+          @association = association
+          @options = options
+          @class_name = options[:class_name] ? options[:class_name].constantize : association.klass
+        end
+
+        private
+
+        # Can the existing relation potentially be deleted?
+        #
+        # @example Is the document destroyable?
+        #   destroyable?({ :_destroy => "1" })
+        #
+        # @param [ Hash ] attributes The attributes to pull the flag from.
+        #
+        # @return [ true, false ] If the relation can potentially be deleted.
+        def destroyable?(attributes)
+          destroy = attributes.delete(:_destroy)
+          Nested::DESTROY_FLAGS.include?(destroy) && allow_destroy?
+        end
+
+        # Are the supplied attributes of greater number than the supplied
+        # limit?
+        #
+        # @example Are we over the set limit?
+        #   builder.over_limit?({ "street" => "Bond" })
+        #
+        # @param [ Hash ] attributes The attributes being set.
+        #
+        # @return [ true, false ] If the attributes exceed the limit.
+        def over_limit?(attributes)
+          limit = options[:limit]
+          limit ? attributes.size > limit : false
+        end
+
+        # Process each set of attributes one at a time for each potential
+        # new, existing, or ignored document.
+        #
+        # @api private
+        #
+        # @example Process the attributes
+        #   builder.process_attributes({ "id" => 1, "street" => "Bond" })
+        #
+        # @param [ Document ] parent The parent document.
+        # @param [ Hash ] attrs The single document attributes to process.
+        #
+        # @since 2.0.0
+        def process_attributes(parent, attrs)
+          return if reject?(parent, attrs)
+          if id = attrs.extract_id
+            update_nested_relation(parent, id, attrs)
+          else
+            existing.push(Factory.build(@class_name, attrs)) unless destroyable?(attrs)
+          end
+        end
+
+        # Destroy the child document, needs to do some checking for embedded
+        # relations and delay the destroy in case parent validation fails.
+        #
+        # @api private
+        #
+        # @example Destroy the child.
+        #   builder.destroy(parent, relation, doc)
+        #
+        # @param [ Document ] parent The parent document.
+        # @param [ Proxy ] relation The relation proxy.
+        # @param [ Document ] doc The doc to destroy.
+        #
+        # @since 3.0.10
+        def destroy(parent, relation, doc)
+          doc.flagged_for_destroy = true
+          if !doc.embedded? || parent.new_record?
+            destroy_document(relation, doc)
+          else
+            parent.flagged_destroys.push(-> { destroy_document(relation, doc) })
+          end
+        end
+
+        # Destroy the document.
+        #
+        # @api private
+        #
+        # @example Destroy the document.
+        #   builder.destroy_document(relation, doc)
+        #
+        # @param [ Proxy ] relation The relation proxy.
+        # @param [ Document ] doc The document to delete.
+        #
+        # @since 3.0.10
+        def destroy_document(relation, doc)
+          relation.delete(doc)
+          doc.destroy unless doc.embedded? || doc.destroyed?
+        end
+
+        # Update the document.
+        #
+        # @api private
+        #
+        # @example Update the document.
+        #   builder.update_document(doc, {}, options)
+        #
+        # @param [ Document ] doc The document to update.
+        # @param [ Hash ] attrs The attributes.
+        #
+        # @since 3.0.10
+        def update_document(doc, attrs)
+          attrs.delete_id
+          if association.embedded?
+            doc.assign_attributes(attrs)
+          else
+            doc.update_attributes(attrs)
+          end
+        end
+
+        # Update nested relation.
+        #
+        # @api private
+        #
+        # @example Update nested relation.
+        #   builder.update_nested_relation(parent, id, attrs)
+        #
+        # @param [ Document ] parent The parent document.
+        # @param [ String, BSON::ObjectId ] id of the related document.
+        # @param [ Hash ] attrs The single document attributes to process.
+        #
+        # @since 6.0.0
+        def update_nested_relation(parent, id, attrs)
+          first = existing.first
+          converted = first ? convert_id(first.class, id) : id
+
+          if existing.where(id: converted).exists?
+            # document exists in relation
+            doc = existing.find(converted)
+            if destroyable?(attrs)
+              destroy(parent, existing, doc)
+            else
+              update_document(doc, attrs)
+            end
+          else
+            # push existing document to relation
+            doc = existing.unscoped.find(converted)
+            update_document(doc, attrs)
+            existing.push(doc) unless destroyable?(attrs)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/association/nested/nested_buildable.rb

@@ -0,0 +1,72 @@
+module Mongoid
+  module Association
+    module Nested
+      module Buildable
+
+        attr_accessor :attributes, :existing, :association, :options
+
+        # Determines if destroys are allowed for this document.
+        #
+        # @example Do we allow a destroy?
+        #   builder.allow_destroy?
+        #
+        # @return [ true, false ] True if the allow destroy option was set.
+        #
+        # @since 2.0.0.rc.1
+        def allow_destroy?
+          options[:allow_destroy] || false
+        end
+
+        # Returns the reject if option defined with the macro.
+        #
+        # @example Is there a reject proc?
+        #   builder.reject?
+        #
+        # @param [ Document ] document The parent document of the relation
+        # @param [ Hash ] attrs The attributes to check for rejection.
+        #
+        # @return [ true, false ] True and call proc or method if rejectable, false if not.
+        #
+        # @since 2.0.0.rc.1
+        def reject?(document, attrs)
+          case callback = options[:reject_if]
+            when Symbol
+              document.method(callback).arity == 0 ? document.send(callback) : document.send(callback, attrs)
+            when Proc
+              callback.call(attrs)
+            else
+              false
+          end
+        end
+
+        # Determines if only updates can occur. Only valid for one-to-one
+        # relations.
+        #
+        # @example Is this update only?
+        #   builder.update_only?
+        #
+        # @return [ true, false ] True if the update_only option was set.
+        #
+        # @since 2.0.0.rc.1
+        def update_only?
+          options[:update_only] || false
+        end
+
+        # Convert an id to its appropriate type.
+        #
+        # @example Convert the id.
+        #   builder.convert_id(Person, "4d371b444835d98b8b000010")
+        #
+        # @param [ Class ] klass The class we're trying to convert for.
+        # @param [ String ] id The id, usually coming from the form.
+        #
+        # @return [ BSON::ObjectId, String, Object ] The converted id.
+        #
+        # @since 2.0.0.rc.6
+        def convert_id(klass, id)
+          klass.using_object_ids? ? BSON::ObjectId.mongoize(id) : id
+        end
+      end
+    end
+  end
+end