mongoid 6.4.8 → 7.0.0.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: b8c453904dce4061c6cd88c36e21f3514fb778b37976ffd12e985aaf80fc2b98
-  data.tar.gz: d10421a146387851daa6a9c27184b48da1cc50d96a946bce0851aa69fd56c9a5
+SHA1:
+  metadata.gz: 6f483fd6267d4f9d7cdd88cd53e8fda43b3266d5
+  data.tar.gz: a9dc77a3e44b2e719b5bc5e74c918c0d20dc964d
 SHA512:
-  metadata.gz: 6c0e672470d68faab3afc70e65524baa771801b46bbbb51b831a5cc709baf6df4ed7f0d81aed2dd5d0c3e3cf6730166da9bc8345b33577298f4438ec6c11fca3
-  data.tar.gz: 2008465437ba6eafe50235b22204df40b560b8e3bd27d064e97912c3249f5443af2ad1016c9a545d9d487abc6c1b38835624090a6d9165d06f9c4e676b561a23
+  metadata.gz: 5404ab3c5ee259a29c80848cdf90f5709cb4665945c41edbaab5c329a9bd28b5350dedc115e3e41d537043f730f1b90db8646a5d8b075c26f324c0a94f4e6b35
+  data.tar.gz: f14bad6291f3628cf3c767c55b7707d32f9fe0bb001e34bd466c66d483378752f0550666359a206afbd1f0bf3409b6fb4eb12f4b2fea0cc4cc0e83f737a50da6

data/Rakefile

@@ -1,5 +1,4 @@
 require "bundler"
-require "bundler/gem_tasks"
 Bundler.setup
 
 require "rake"
@@ -8,9 +7,6 @@ require "rspec/core/rake_task"
 $LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
 require "mongoid/version"
 
-tasks = Rake.application.instance_variable_get('@tasks')
-tasks['release:do'] = tasks.delete('release')
-
 task :gem => :build
 task :build do
   system "gem build mongoid.gemspec"
@@ -37,25 +33,3 @@ RSpec::Core::RakeTask.new('spec:progress') do |spec|
 end
 
 task :default => :spec
-
-desc "Generate all documentation"
-task :docs => 'docs:yard'
-
-namespace :docs do
-  desc "Generate yard documention"
-  task :yard do
-    out = File.join('yard-docs', Mongoid::VERSION)
-    FileUtils.rm_rf(out)
-    system "yardoc -o #{out} --title mongoid-#{Mongoid::VERSION}"
-  end
-end
-
-namespace :release do
-  task :check_private_key do
-    unless File.exist?('gem-private_key.pem')
-      raise "No private key present, cannot release"
-    end
-  end
-end
-
-task :release => ['release:check_private_key', 'release:do']

data/lib/config/locales/en.yml

@@ -91,6 +91,11 @@ en:
             expecting the option to be there, please consult the following page
             with repect to Mongoid's configuration:\n\n
             \_\_http://mongoid.org/en/mongoid/docs/installation.html"
+        invalid_dependent_strategy:
+          message: "Invalid dependent strategy: %{invalid_strategy}."
+          summary: "An invalid dependent strategy was defined for the association:
+            %{association}. The valid strategies are: %{valid_strategies}."
+          resolution: "Change the dependent strategy to one of the valid types."
         invalid_field:
           message: "Defining a field named '%{name}' is not allowed."
           summary: "Defining this field would override the method '%{name}',
@@ -196,6 +201,11 @@ en:
             allowed, and don't use these names. These include names that also
             conflict with core Ruby methods on Object, Module, Enumerable, or
             included gems that inject methods into these or Mongoid internals."
+        invalid_relation_option:
+          message: "Invalid relation option :%{option} for relation '%{name}' on class
+            %{klass}."
+          summary: "An invalid option was provided for a relation."
+          resolution: "Valid options are: %{valid_options}, make sure you use only those."
         invalid_scope:
           message: "Defining a scope of value %{value} on %{klass} is not
             allowed."
@@ -206,20 +216,6 @@ en:
             \_\_\_\_include Mongoid::Document\n
             \_\_\_\_scope :inactive, ->{ where(active: false) }\n
             \_\_end\n\n"
-        invalid_session_use:
-          message: "A session was attempted to be used with a model whose client cannot use
-            that session."
-          summary: "Sessions are started via driver clients (Model#mongo_client) and, in most cases, driver
-            clients are shared across models. When different models have their own clients, a session cannot
-            be obtained via one model and used for operations on another model."
-          resolution: "Only execute operations on the model class or instances of the model through which
-            the session was created. Otherwise, ensure that all models on which operations are executed
-            in the session block share the same driver client. For example, a model may have a different
-            client specified in its 'store_in' options.\n\n"
-        invalid_session_nesting:
-          message: "A session was started while another session was being used."
-          summary: "Sessions cannot be nested. Only one session can be used in a thread at once."
-          resolution: "Only use one session at a time; sessions cannot be nested."
         invalid_storage_options:
           message: "Invalid options passed to %{klass}.store_in: %{options}."
           summary: "The :store_in macro takes only a hash of parameters with
@@ -466,13 +462,6 @@ en:
             with the already defined method %{model_name}, or set the
             configuration option Mongoid.scope_overwrite_exception to false,
             which is its default. In this case a warning will be logged."
-        sessions_not_supported:
-          message: "Sessions are not supported by the connected server(s)."
-          summary: "A session was attempted to be used with a MongoDB server version
-            that doesn't support sessions. Sessions are supported in MongoDB
-            server versions 3.6 and higher."
-          resolution: "Verify that all servers in your deployment are at least
-            version 3.6 or don't attempt to use sessions with older server versions."
         taken:
           "is already taken"
         too_many_nested_attribute_records:
@@ -494,6 +483,13 @@ en:
             attributes hash, and is raised instead of getting a NoMethodError."
           resolution: "You can include Mongoid::Attributes::Dynamic if you
             expect to be writing values for undefined fields often."
+        unknown_model:
+          message: "Attempted to instantiate an object of the unknown Model '%{klass}'."
+          summary: "A document with the value '%{value}' at the key '_type' was used to
+            instantiate a model object but Mongoid cannot find this Class."
+          resolution: "The _type field is a reserved one used by Mongoid to determine the
+            class for instantiating an object. Please don't save data in this field or ensure
+            that any values in this field correspond to valid Models."
         unsaved_document:
           message: "Attempted to save %{document} before the parent %{base}."
           summary: "You cannot call create or create! through the

data/lib/mongoid.rb

@@ -42,7 +42,7 @@ module Mongoid
   PLATFORM_DETAILS = "mongoid-#{VERSION}".freeze
 
   # The minimum MongoDB version supported.
-  MONGODB_VERSION = "2.6.0"
+  MONGODB_VERSION = "2.4.0"
 
   # Sets the Mongoid configuration options. Best used by passing a block.
   #
@@ -101,5 +101,5 @@ module Mongoid
   #   Mongoid.database = Mongo::Connection.new.db("test")
   #
   # @since 1.0.0
-  delegate(*(Config.public_instance_methods(false) - [ :logger=, :logger ]), to: Config)
+  delegate(*(Config.public_instance_methods(false) - [ :logger=, :logger ] << { to: Config }))
 end

data/lib/mongoid/association.rb

@@ -0,0 +1,150 @@
+require 'mongoid/association/accessors'
+require 'mongoid/association/builders'
+require 'mongoid/association/bindable'
+require 'mongoid/association/depending'
+require 'mongoid/association/proxy'
+require 'mongoid/association/touchable'
+
+require 'mongoid/association/many'
+require 'mongoid/association/one'
+require 'mongoid/association/relatable'
+require 'mongoid/association/nested'
+require 'mongoid/association/referenced'
+require 'mongoid/association/embedded'
+require 'mongoid/association/macros'
+
+require 'mongoid/association/reflections'
+require 'mongoid/association/eager_loadable'
+
+module Mongoid
+  module Association
+    extend ActiveSupport::Concern
+    include Embedded::Cyclic
+    include Referenced::AutoSave
+    include Referenced::CounterCache
+    include Referenced::Syncable
+    include Accessors
+    include Depending
+    include Builders
+    include Macros
+    include Reflections
+
+    # Map the macros to their corresponding Association classes.
+    #
+    # @return [ Hash ] The mapping from macros to their Association class.
+    #
+    # @since 7.0
+    MACRO_MAPPING = {
+        embeds_one: Association::Embedded::EmbedsOne,
+        embeds_many: Association::Embedded::EmbedsMany,
+        embedded_in: Association::Embedded::EmbeddedIn,
+        has_one: Association::Referenced::HasOne,
+        has_many: Association::Referenced::HasMany,
+        has_and_belongs_to_many: Association::Referenced::HasAndBelongsToMany,
+        belongs_to: Association::Referenced::BelongsTo,
+    }.freeze
+
+    attr_accessor :_association
+
+    included do
+      class_attribute :polymorphic
+      self.polymorphic = false
+    end
+
+    # Determine if the document itself is embedded in another document via the
+    # proper channels. (If it has a parent document.)
+    #
+    # @example Is the document embedded?
+    #   address.embedded?
+    #
+    # @return [ true, false ] True if the document has a parent document.
+    #
+    # @since 2.0.0.rc.1
+    def embedded?
+      @embedded ||= (cyclic ? _parent.present? : self.class.embedded?)
+    end
+
+    # Determine if the document is part of an embeds_many relation.
+    #
+    # @example Is the document in an embeds many?
+    #   address.embedded_many?
+    #
+    # @return [ true, false ] True if in an embeds many.
+    #
+    # @since 2.0.0.rc.1
+    def embedded_many?
+      _association && _association.is_a?(Association::Embedded::EmbedsMany)
+    end
+
+    # Determine if the document is part of an embeds_one relation.
+    #
+    # @example Is the document in an embeds one?
+    #   address.embedded_one?
+    #
+    # @return [ true, false ] True if in an embeds one.
+    #
+    # @since 2.0.0.rc.1
+    def embedded_one?
+      _association && _association.is_a?(Association::Embedded::EmbedsOne)
+    end
+
+    # Get the association name for this document. If no association was defined
+    #   an error will be raised.
+    #
+    # @example Get the association name.
+    #   document.association_name
+    #
+    # @raise [ Errors::NoMetadata ] If no association metadata is present.
+    #
+    # @return [ Symbol ] The association name.
+    #
+    # @since 3.0.0
+    def association_name
+      raise Errors::NoMetadata.new(self.class.name) unless _association
+      _association.name
+    end
+
+    # Determine if the document is part of an references_many relation.
+    #
+    # @example Is the document in a references many?
+    #   post.referenced_many?
+    #
+    # @return [ true, false ] True if in a references many.
+    #
+    # @since 2.0.0.rc.1
+    def referenced_many?
+      _association && _association.is_a?(Association::Referenced::HasMany)
+    end
+
+    # Determine if the document is part of an references_one relation.
+    #
+    # @example Is the document in a references one?
+    #   address.referenced_one?
+    #
+    # @return [ true, false ] True if in a references one.
+    #
+    # @since 2.0.0.rc.1
+    def referenced_one?
+      _association && _association.is_a?(Association::Referenced::HasOne)
+    end
+
+    # Convenience method for iterating through the loaded relations and
+    # reloading them.
+    #
+    # @example Reload the relations.
+    #   document.reload_relations
+    #
+    # @return [ Hash ] The association metadata.
+    #
+    # @since 2.1.6
+    def reload_relations
+      relations.each_pair do |name, meta|
+        if instance_variable_defined?("@_#{name}")
+          if _parent.nil? || instance_variable_get("@_#{name}") != _parent
+            remove_instance_variable("@_#{name}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/association/accessors.rb

@@ -0,0 +1,339 @@
+# encoding: utf-8
+module Mongoid
+  module Association
+
+    # This module contains all the behaviour related to accessing relations
+    # through the getters and setters, and how to delegate to builders to
+    # create new ones.
+    module Accessors
+      extend ActiveSupport::Concern
+
+      # Builds the related document and creates the relation unless the
+      # document is nil, then sets the relation on this document.
+      #
+      # @example Build the relation.
+      #   person.__build__(:addresses, { :_id => 1 }, association)
+      #
+      # @param [ String, Symbol ] name The name of the relation.
+      # @param [ Hash, BSON::ObjectId ] object The id or attributes to use.
+      # @param [ Association ] association The association metadata.
+      #
+      # @return [ Proxy ] The relation.
+      #
+      # @since 2.0.0.rc.1
+      def __build__(name, object, association)
+        relation = create_relation(object, association)
+        set_relation(name, relation)
+      end
+
+      # Create a relation from an object and association.
+      #
+      # @example Create the relation.
+      #   person.create_relation(document, association)
+      #
+      # @param [ Document, Array<Document> ] object The relation target.
+      # @param [ Association ] association The association metadata.
+      #
+      # @return [ Proxy ] The relation.
+      #
+      # @since 2.0.0.rc.1
+      def create_relation(object, association)
+        type = @attributes[association.inverse_type]
+        target = association.build(self, object, type)
+        target ? association.create_relation(self, target) : nil
+      end
+
+      # Resets the criteria inside the relation proxy. Used by many-to-many
+      # relations to keep the underlying ids array in sync.
+      #
+      # @example Reset the relation criteria.
+      #   person.reset_relation_criteria(:preferences)
+      #
+      # @param [ Symbol ] name The name of the relation.
+      #
+      # @since 3.0.14
+      def reset_relation_criteria(name)
+        if instance_variable_defined?("@_#{name}")
+          send(name).reset_unloaded
+        end
+      end
+
+      # Set the supplied relation to an instance variable on the class with the
+      # provided name. Used as a helper just for code cleanliness.
+      #
+      # @example Set the proxy on the document.
+      #   person.set(:addresses, addresses)
+      #
+      # @param [ String, Symbol ] name The name of the relation.
+      # @param [ Proxy ] relation The relation to set.
+      #
+      # @return [ Proxy ] The relation.
+      #
+      # @since 2.0.0.rc.1
+      def set_relation(name, relation)
+        instance_variable_set("@_#{name}", relation)
+      end
+
+      private
+
+      # Get the relation. Extracted out from the getter method to avoid
+      # infinite recursion when overriding the getter.
+      #
+      # @api private
+      #
+      # @example Get the relation.
+      #   document.get_relation(:name, association)
+      #
+      # @param [ Symbol ] name The name of the relation.
+      # @param [ Association ] association The association metadata.
+      # @param [ Object ] object The object used to build the relation.
+      # @param [ true, false ] reload If the relation is to be reloaded.
+      #
+      # @return [ Proxy ] The relation.
+      #
+      # @since 3.0.16
+      def get_relation(name, association, object, reload = false)
+        if !reload && (value = ivar(name)) != false
+          value
+        else
+          _building do
+            _loading do
+              if object && needs_no_database_query?(object, association)
+                __build__(name, object, association)
+              else
+                __build__(name, attributes[association.key], association)
+              end
+            end
+          end
+        end
+      end
+
+      def needs_no_database_query?(object, association)
+        object.is_a?(Document) && !object.embedded? &&
+            object._id == attributes[association.key]
+      end
+
+      # Is the current code executing without autobuild functionality?
+      #
+      # @example Is autobuild disabled?
+      #   document.without_autobuild?
+      #
+      # @return [ true, false ] If autobuild is disabled.
+      #
+      # @since 3.0.0
+      def without_autobuild?
+        Threaded.executing?(:without_autobuild)
+      end
+
+      # Yield to the block with autobuild functionality turned off.
+      #
+      # @example Execute without autobuild.
+      #   document.without_autobuild do
+      #     document.name
+      #   end
+      #
+      # @return [ Object ] The result of the yield.
+      #
+      # @since 3.0.0
+      def without_autobuild
+        Threaded.begin_execution("without_autobuild")
+        yield
+      ensure
+        Threaded.exit_execution("without_autobuild")
+      end
+
+      # Parse out the attributes and the options from the args passed to a
+      # build_ or create_ methods.
+      #
+      # @example Parse the args.
+      #   doc.parse_args(:name => "Joe")
+      #
+      # @param [ Array ] args The arguments.
+      #
+      # @return [ Array<Hash> ] The attributes and options.
+      #
+      # @since 2.3.4
+      def parse_args(*args)
+        [args.first || {}, args.size > 1 ? args[1] : {}]
+      end
+
+      # Adds the existence check for relations.
+      #
+      # @example Add the existence check.
+      #   Person.define_existence_check!(association)
+      #
+      # @example Check if a relation exists.
+      #   person = Person.new
+      #   person.has_game?
+      #   person.game?
+      #
+      # @param [ Association ] association The association.
+      #
+      # @return [ Class ] The model being set up.
+      #
+      # @since 3.0.0
+      def self.define_existence_check!(association)
+        name = association.name
+        association.inverse_class.tap do |klass|
+          klass.module_eval <<-END, __FILE__, __LINE__ + 1
+              def #{name}?
+                without_autobuild { !__send__(:#{name}).blank? }
+              end
+              alias :has_#{name}? :#{name}?
+          END
+        end
+      end
+
+      # Defines the getter for the relation. Nothing too special here: just
+      # return the instance variable for the relation if it exists or build
+      # the thing.
+      #
+      # @example Set up the getter for the relation.
+      #   Person.define_getter!(association)
+      #
+      # @param [ Association ] association The association metadata for the relation.
+      #
+      # @return [ Class ] The class being set up.
+      #
+      # @since 2.0.0.rc.1
+      def self.define_getter!(association)
+        name = association.name
+        association.inverse_class.tap do |klass|
+          klass.re_define_method(name) do |reload = false|
+            value = get_relation(name, association, nil, reload)
+            if value.nil? && association.autobuilding? && !without_autobuild?
+              value = send("build_#{name}")
+            end
+            value
+          end
+        end
+      end
+
+      # Defines the getter for the ids of documents in the relation. Should
+      # be specify only for referenced many relations.
+      #
+      # @example Set up the ids getter for the relation.
+      #   Person.define_ids_getter!(association)
+      #
+      # @param [ Association ] association The association metadata for the relation.
+      #
+      # @return [ Class ] The class being set up.
+      def self.define_ids_getter!(association)
+        ids_method = "#{association.name.to_s.singularize}_ids"
+        association.inverse_class.tap do |klass|
+          klass.re_define_method(ids_method) do
+            send(association.name).only(:id).map(&:id)
+          end
+        end
+      end
+
+      # Defines the setter for the relation. This does a few things based on
+      # some conditions. If there is an existing association, a target
+      # substitution will take place, otherwise a new relation will be
+      # created with the supplied target.
+      #
+      # @example Set up the setter for the relation.
+      #   Person.define_setter!(association)
+      #
+      # @param [ Association ] association The association metadata for the relation.
+      #
+      # @return [ Class ] The class being set up.
+      #
+      # @since 2.0.0.rc.1
+      def self.define_setter!(association)
+        name = association.name
+        association.inverse_class.tap do |klass|
+          klass.re_define_method("#{name}=") do |object|
+            without_autobuild do
+              if value = get_relation(name, association, object)
+                if value.respond_to?(:substitute)
+                  set_relation(name, value.substitute(object.substitutable))
+                else
+                  value = __build__(name, value, association)
+                  set_relation(name, value.substitute(object.substitutable))
+                end
+              else
+                __build__(name, object.substitutable, association)
+              end
+            end
+          end
+        end
+      end
+
+      # Defines the setter method that allows you to set documents
+      # in this relation by their ids. The defined setter, finds
+      # documents with given ids and invokes regular relation setter
+      # with found documents. Ids setters should be defined only for
+      # referenced many relations.
+      #
+      # @example Set up the id_setter for the relation.
+      #   Person.define_ids_setter!(association)
+      #
+      #  @param [ Association ] association The association for the relation.
+      #
+      #  @return [ Class ] The class being set up.
+      def self.define_ids_setter!(association)
+        ids_method = "#{association.name.to_s.singularize}_ids="
+        association.inverse_class.tap do |klass|
+          klass.re_define_method(ids_method) do |ids|
+            send(association.setter, association.relation_class.find(ids.reject(&:blank?)))
+          end
+        end
+      end
+
+      # Defines a builder method for an embeds_one relation. This is
+      # defined as #build_name.
+      #
+      # @example
+      #   Person.define_builder!(association)
+      #
+      # @param [ Association ] association The association for the relation.
+      #
+      # @return [ Class ] The class being set up.
+      #
+      # @since 2.0.0.rc.1
+      def self.define_builder!(association)
+        name = association.name
+        association.inverse_class.tap do |klass|
+          klass.re_define_method("build_#{name}") do |*args|
+            attributes, _options = parse_args(*args)
+            document = Factory.build(association.relation_class, attributes)
+            _building do
+              child = send("#{name}=", document)
+              child.run_callbacks(:build)
+              child
+            end
+          end
+        end
+      end
+
+      # Defines a creator method for an embeds_one relation. This is
+      # defined as #create_name. After the object is built it will
+      # immediately save.
+      #
+      # @example
+      #   Person.define_creator!(association)
+      #
+      # @param [ Association ] association The association for the relation.
+      #
+      # @return [ Class ] The class being set up.
+      #
+      # @since 2.0.0.rc.1
+      def self.define_creator!(association)
+        name = association.name
+        association.inverse_class.tap do |klass|
+          klass.re_define_method("create_#{name}") do |*args|
+            attributes, _options = parse_args(*args)
+            document = Factory.build(association.klass, attributes)
+            doc = _assigning do
+              send("#{name}=", document)
+            end
+            doc.save
+            save if new_record? && association.stores_foreign_key?
+            doc
+          end
+        end
+      end
+    end
+  end
+end