mongoid_rails4 4.0.0

data/lib/mongoid/railties/database.rake

@@ -0,0 +1,97 @@
+namespace :db do
+
+  unless Rake::Task.task_defined?("db:drop")
+    desc "Drops all the collections for the database for the current Rails.env"
+    task :drop => "mongoid:drop"
+  end
+
+  unless Rake::Task.task_defined?("db:purge")
+    desc "Drop all collections except the system collections"
+    task :purge => "mongoid:purge"
+  end
+
+  unless Rake::Task.task_defined?("db:seed")
+    # if another ORM has defined db:seed, don"t run it twice.
+    desc "Load the seed data from db/seeds.rb"
+    task :seed => :environment do
+      seed_file = File.join(Rails.root, "db", "seeds.rb")
+      load(seed_file) if File.exist?(seed_file)
+    end
+  end
+
+  unless Rake::Task.task_defined?("db:setup")
+    desc "Create the database, and initialize with the seed data"
+    task :setup => [ "db:create", "db:mongoid:create_indexes", "db:seed" ]
+  end
+
+  unless Rake::Task.task_defined?("db:reset")
+    desc "Delete data and loads the seeds"
+    task :reset => [ "db:drop", "db:seed" ]
+  end
+
+  unless Rake::Task.task_defined?("db:create")
+    task :create => :environment do
+      # noop
+    end
+  end
+
+  unless Rake::Task.task_defined?("db:migrate")
+    task :migrate => :environment do
+      # noop
+    end
+  end
+
+  unless Rake::Task.task_defined?("db:schema:load")
+    namespace :schema do
+      task :load do
+        # noop
+      end
+    end
+  end
+
+  unless Rake::Task.task_defined?("db:test:prepare")
+    namespace :test do
+      task :prepare do
+        # noop
+      end
+    end
+  end
+
+  unless Rake::Task.task_defined?("db:create_indexes")
+    task :create_indexes => "mongoid:create_indexes"
+  end
+
+  unless Rake::Task.task_defined?("db:remove_indexes")
+    task :remove_indexes => "mongoid:remove_indexes"
+  end
+
+  namespace :mongoid do
+    desc "Create the indexes defined on your mongoid models"
+    task :create_indexes => :environment do
+      ::Rails.application.eager_load!
+      ::Rails::Mongoid.create_indexes
+    end
+
+    desc "Remove indexes that exist in the database but aren't specified on the models"
+    task :remove_undefined_indexes => :environment do
+      ::Rails.application.eager_load!
+      ::Rails::Mongoid.remove_undefined_indexes
+    end
+
+    desc "Remove the indexes defined on your mongoid models without questions!"
+    task :remove_indexes => :environment do
+      ::Rails.application.eager_load!
+      ::Rails::Mongoid.remove_indexes
+    end
+
+    desc "Drops the database for the current Rails.env"
+    task :drop => :environment do
+      ::Mongoid::Sessions.default.drop
+    end
+
+    desc "Drop all collections except the system collections"
+    task :purge => :environment do
+      ::Mongoid.purge!
+    end
+  end
+end

data/lib/mongoid/railties/document.rb

@@ -0,0 +1,12 @@
+module Mongoid
+  module Document
+    # Used in conjunction with fields_for to build a form element for the
+    # destruction of this association. Always returns false because Mongoid
+    # only supports immediate deletion of associations.
+    #
+    # See ActionView::Helpers::FormHelper::fields_for for more info.
+    def _destroy
+      false
+    end
+  end
+end

data/lib/mongoid/relations.rb

@@ -0,0 +1,162 @@
+# encoding: utf-8
+require "mongoid/relations/accessors"
+require "mongoid/relations/auto_save"
+require "mongoid/relations/cascading"
+require "mongoid/relations/constraint"
+require "mongoid/relations/conversions"
+require "mongoid/relations/counter_cache"
+require "mongoid/relations/cyclic"
+require "mongoid/relations/proxy"
+require "mongoid/relations/bindings"
+require "mongoid/relations/builders"
+require "mongoid/relations/many"
+require "mongoid/relations/one"
+require "mongoid/relations/options"
+require "mongoid/relations/polymorphic"
+require "mongoid/relations/targets/enumerable"
+require "mongoid/relations/embedded/in"
+require "mongoid/relations/embedded/many"
+require "mongoid/relations/embedded/one"
+require "mongoid/relations/referenced/in"
+require "mongoid/relations/referenced/many"
+require "mongoid/relations/referenced/many_to_many"
+require "mongoid/relations/referenced/one"
+require "mongoid/relations/reflections"
+require "mongoid/relations/synchronization"
+require "mongoid/relations/touchable"
+require "mongoid/relations/metadata"
+require "mongoid/relations/macros"
+
+module Mongoid
+
+  # All classes and modules under the relations namespace handle the
+  # functionality that has to do with embedded and referenced (relational)
+  # associations.
+  module Relations
+    extend ActiveSupport::Concern
+    include Accessors
+    include AutoSave
+    include Cascading
+    include Cyclic
+    include Builders
+    include Macros
+    include Polymorphic
+    include Reflections
+    include Synchronization
+    include Touchable
+    include CounterCache
+
+    attr_accessor :metadata
+
+    # 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?
+      metadata && metadata.macro == :embeds_many
+    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?
+      metadata && metadata.macro == :embeds_one
+    end
+
+    # Get the metadata name for this document. If no metadata was defined
+    # will raise an error.
+    #
+    # @example Get the metadata name.
+    #   document.metadata_name
+    #
+    # @raise [ Errors::NoMetadata ] If no metadata is present.
+    #
+    # @return [ Symbol ] The metadata name.
+    #
+    # @since 3.0.0
+    def metadata_name
+      raise Errors::NoMetadata.new(self.class.name) unless metadata
+      metadata.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?
+      metadata && metadata.macro == :has_many
+    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?
+      metadata && metadata.macro == :has_one
+    end
+
+    # Convenience method for iterating through the loaded relations and
+    # reloading them.
+    #
+    # @example Reload the relations.
+    #   document.reload_relations
+    #
+    # @return [ Hash ] The relations 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
+
+    module ClassMethods
+
+      # This is convenience for librarys still on the old API.
+      #
+      # @example Get the associations.
+      #   Person.associations
+      #
+      # @return [ Hash ] The relations.
+      #
+      # @since 2.3.1
+      def associations
+        self.relations
+      end
+    end
+  end
+end

data/lib/mongoid/relations/accessors.rb

@@ -0,0 +1,299 @@
+# encoding: utf-8
+module Mongoid
+  module Relations
+
+    # 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 }, metadata)
+      #
+      # @param [ String, Symbol ] name The name of the relation.
+      # @param [ Hash, Moped::BSON::ObjectId ] object The id or attributes to use.
+      # @param [ Metadata ] metadata The relation's metadata.
+      # @param [ true, false ] building If we are in a build operation.
+      #
+      # @return [ Proxy ] The relation.
+      #
+      # @since 2.0.0.rc.1
+      def __build__(name, object, metadata)
+        relation = create_relation(object, metadata)
+        set_relation(name, relation)
+      end
+
+      # Create a relation from an object and metadata.
+      #
+      # @example Create the relation.
+      #   person.create_relation(document, metadata)
+      #
+      # @param [ Document, Array<Document ] object The relation target.
+      # @param [ Metadata ] metadata The relation metadata.
+      #
+      # @return [ Proxy ] The relation.
+      #
+      # @since 2.0.0.rc.1
+      def create_relation(object, metadata)
+        type = @attributes[metadata.inverse_type]
+        target = metadata.builder(self, object).build(type)
+        target ? metadata.relation.new(self, target, metadata) : nil
+      end
+
+      # Determines if the relation exists or not.
+      #
+      # @example Does the relation exist?
+      #   person.relation_exists?(:people)
+      #
+      # @param [ String ] name The name of the relation to check.
+      #
+      # @return [ true, false ] True if set and not nil, false if not.
+      #
+      # @since 2.0.0.rc.1
+      def relation_exists?(name)
+        ivar(name)
+      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, metadata)
+      #
+      # @param [ Symbol ] name The name of the relation.
+      # @param [ Metadata ] metadata The relation metadata.
+      # @param [ true, false ] reload If the relation is to be reloaded.
+      #
+      # @return [ Proxy ] The relation.
+      #
+      # @since 3.0.16
+      def get_relation(name, metadata, reload = false)
+        variable = "@_#{name}"
+        value = if instance_variable_defined?(variable) && !reload
+          instance_variable_get(variable)
+        else
+          _building do
+            _loading do
+              __build__(name, attributes[metadata.key], metadata)
+            end
+          end
+        end
+        if value.nil? && metadata.autobuilding? && !without_autobuild?
+          send("build_#{name}")
+        else
+          value
+        end
+      end
+
+      # @todo: Durran: Refactor before release, but this fixes the issue with
+      # the extra queries.
+      def get_relation_for_set(name, metadata, object)
+        variable = "@_#{name}"
+        value = if instance_variable_defined?(variable)
+          instance_variable_get(variable)
+        else
+          _building do
+            _loading do
+              if needs_no_database_query?(object, metadata)
+                __build__(name, object, metadata)
+              else
+                __build__(name, attributes[metadata.key], metadata)
+              end
+            end
+          end
+        end
+      end
+
+      def needs_no_database_query?(object, metadata)
+        object.is_a?(Document) && !object.embedded? &&
+          object.id == attributes[metadata.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
+
+      module ClassMethods
+
+        # Adds the existence check for relations.
+        #
+        # @example Add the existence check.
+        #   Person.existence_check(:name, meta)
+        #
+        # @example Check if a relation exists.
+        #   person = Person.new
+        #   person.has_game?
+        #   person.game?
+        #
+        # @param [ String, Symbol ] name The name of the relation.
+        # @param [ Metadata ] The metadata.
+        #
+        # @return [ Class ] The model being set up.
+        #
+        # @since 3.0.0
+        def existence_check(name, metadata)
+          module_eval <<-END
+            def #{name}?
+              without_autobuild { !__send__(:#{name}).blank? }
+            end
+            alias :has_#{name}? :#{name}?
+          END
+          self
+        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.getter("addresses", metadata)
+        #
+        # @param [ String, Symbol ] name The name of the relation.
+        # @param [ Metadata ] metadata The metadata for the relation.
+        #
+        # @return [ Class ] The class being set up.
+        #
+        # @since 2.0.0.rc.1
+        def getter(name, metadata)
+          re_define_method(name) do |reload = false|
+            get_relation(name, metadata, reload)
+          end
+          self
+        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.ids_getter("addresses", metadata)
+        #
+        # @param [ String, Symbol ] name The name of the relation.
+        # @param [ Metadata] metadata The metadata for the relation.
+        #
+        # @return [ Class ] The class being set up.
+        def ids_getter(name, metadata)
+          ids_method = "#{name.to_s.singularize}_ids"
+          re_define_method(ids_method) do
+            send(name).only(:id).map(&:id)
+          end
+          self
+        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.setter("addresses", metadata)
+        #
+        # @param [ String, Symbol ] name The name of the relation.
+        # @param [ Metadata ] metadata The metadata for the relation.
+        #
+        # @return [ Class ] The class being set up.
+        #
+        # @since 2.0.0.rc.1
+        def setter(name, metadata)
+          re_define_method("#{name}=") do |object|
+            without_autobuild do
+              if metadata.many?
+                set_relation(name, get_relation(name, metadata).substitute(object.substitutable))
+              elsif value = get_relation_for_set(name, metadata, object)
+                set_relation(name, value.substitute(object.substitutable))
+              else
+                __build__(name, object.substitutable, metadata)
+              end
+            end
+          end
+          self
+        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.ids_setter("addesses", metadata)
+        #
+        #  @param [ String, Symbol ] name The name of the relation.
+        #  @param [ Metadata ] metadata The metadata for the relation.
+        #
+        #  @return [ Class ] The class being set up.
+        def ids_setter(name, metadata)
+          ids_method = "#{name.to_s.singularize}_ids="
+          re_define_method(ids_method) do |ids|
+            send(metadata.setter, metadata.klass.find(ids.reject(&:blank?)))
+          end
+          self
+        end
+      end
+    end
+  end
+end