mongoid 2.8.1 → 3.0.0.rc

data/lib/mongoid/railties/database.rake

@@ -1,27 +1,27 @@
 namespace :db do
 
   unless Rake::Task.task_defined?("db:drop")
-    desc 'Drops all the collections for the database for the current Rails.env'
+    desc "Drops all the collections for the database for the current Rails.env"
     task :drop => "mongoid:drop"
   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'
+    # 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')
+      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' ]
+    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:reseed")
-    desc 'Delete data and seed'
-    task :reseed => [ 'db:drop', 'db:seed' ]
+    desc "Delete data and seed"
+    task :reseed => [ "db:drop", "db:seed" ]
   end
 
   unless Rake::Task.task_defined?("db:create")
@@ -56,26 +56,13 @@ namespace :db do
     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
-    # gets a list of the mongoid models defined in the app/models directory
-    def get_mongoid_models
-      documents = []
-      Dir.glob("app/models/**/*.rb").sort.each do |file|
-        model_path = file[0..-4].split('/')[2..-1]
-        begin
-          klass = model_path.map { |path| path.camelize }.join('::').constantize
-          if klass.ancestors.include?(Mongoid::Document) && !klass.embedded
-            documents << klass
-          end
-        rescue => e
-          # Just for non-mongoid objects that dont have the embedded
-          # attribute at the class level.
-        end
-      end
-      documents
-    end
 
-    desc 'Create the indexes defined on your mongoid models'
+    desc "Create the indexes defined on your mongoid models"
     task :create_indexes => :environment do
       engines_models_paths = Rails.application.railties.engines.map do |engine|
         engine.paths["app/models"].expanded
@@ -88,95 +75,22 @@ namespace :db do
       end
     end
 
-    def convert_ids(obj)
-      if obj.is_a?(String) && obj =~ /^[a-f0-9]{24}$/
-        BSON::ObjectId(obj)
-      elsif obj.is_a?(Array)
-        obj.map do |v|
-          convert_ids(v)
-        end
-      elsif obj.is_a?(Hash)
-        obj.each_pair do |k, v|
-          obj[k] = convert_ids(v)
-        end
-      else
-        obj
-      end
-    end
-
-    def collection_names
-      @collection_names ||= get_mongoid_models.map{ |d| d.collection.name }.uniq
-    end
-
-    desc "Convert string objectids in mongo database to ObjectID type"
-    task :objectid_convert => :environment do
-      collection_names.each do |collection_name|
-        puts "Converting #{collection_name} to use ObjectIDs"
-
-        # get old collection
-        collection = Mongoid.master.collection(collection_name)
-
-        # get new collection (a clean one)
-        collection.db["#{collection_name}_new"].drop
-        new_collection = collection.db["#{collection_name}_new"]
-
-        # convert collection documents
-        collection.find({}, :timeout => false, :sort => "_id") do |cursor|
-           cursor.each do |doc|
-            new_doc = convert_ids(doc)
-            new_collection.insert(new_doc, :safe => true)
-          end
-        end
-
-        puts "Done! Converted collection is in #{new_collection.name}\n\n"
-      end
-
-      # no errors. great! now rename _new to collection_name
-      collection_names.each do |collection_name|
-        collection = Mongoid.master.collection(collection_name)
-        new_collection = collection.db["#{collection_name}_new"]
-
-        # swap collection to _old
-        puts "Moving #{collection.name} to #{collection_name}_old"
-        collection.db["#{collection_name}_old"].drop
-
-        begin
-          collection.rename("#{collection_name}_old")
-        rescue Exception => e
-          puts "Unable to rename database #{collection_name} to #{collection_name}_old"
-          puts "reason: #{e.message}\n\n"
-        end
-
-        # swap _new to collection
-        puts "Moving #{new_collection.name} to #{collection_name}\n\n"
-
-        begin
-          new_collection.rename(collection_name)
-        rescue Exception => e
-          puts "Unable to rename database #{new_collection.name} to #{collection_name}"
-          puts "reason: #{e.message}\n\n"
-        end
+    desc "Remove the indexes defined on your mongoid models without questions!"
+    task :remove_indexes => :environment do
+      engines_models_paths = Rails.application.railties.engines.map do |engine|
+        engine.paths["app/models"].expanded
       end
+      root_models_paths = Rails.application.paths["app/models"]
+      models_paths = engines_models_paths.push(root_models_paths).flatten
 
-      puts "DONE! Run `rake db:mongoid:cleanup_old_collections` to remove old collections"
-    end
-
-    desc "Clean up old collections backed up by objectid_convert"
-    task :cleanup_old_collections => :environment do
-      collection_names.each do |collection_name|
-        collection = Mongoid.master.collection(collection_name)
-        collection.db["#{collection.name}_old"].drop
+      models_paths.each do |path|
+        ::Rails::Mongoid.remove_indexes("#{path}/**/*.rb")
       end
     end
 
     desc "Drops the database for the current Rails.env"
     task :drop => :environment do
-      Mongoid.master.collections.select {|c| c.name !~ /system/ }.each { |c| c.drop }
+      ::Mongoid::Sessions.default.drop
     end
-
-    ########
-    # TODO: lots more useful db tasks can be added here. stuff like copyDatabase, etc
-    ########
   end
-
 end

data/lib/mongoid/relations.rb

@@ -13,11 +13,9 @@ require "mongoid/relations/one"
 require "mongoid/relations/options"
 require "mongoid/relations/polymorphic"
 require "mongoid/relations/targets/enumerable"
-require "mongoid/relations/embedded/atomic"
 require "mongoid/relations/embedded/in"
 require "mongoid/relations/embedded/many"
 require "mongoid/relations/embedded/one"
-require "mongoid/relations/referenced/batch"
 require "mongoid/relations/referenced/in"
 require "mongoid/relations/referenced/many"
 require "mongoid/relations/referenced/many_to_many"
@@ -28,7 +26,7 @@ require "mongoid/relations/touchable"
 require "mongoid/relations/metadata"
 require "mongoid/relations/macros"
 
-module Mongoid # :nodoc:
+module Mongoid
 
   # All classes and modules under the relations namespace handle the
   # functionality that has to do with embedded and referenced (relational)
@@ -94,7 +92,7 @@ module Mongoid # :nodoc:
     #
     # @since 2.0.0.rc.1
     def referenced_many?
-      metadata && metadata.macro == :references_many
+      metadata && metadata.macro == :has_many
     end
 
     # Determine if the document is part of an references_one relation.
@@ -106,7 +104,7 @@ module Mongoid # :nodoc:
     #
     # @since 2.0.0.rc.1
     def referenced_one?
-      metadata && metadata.macro == :references_one
+      metadata && metadata.macro == :has_one
     end
 
     # Convenience method for iterating through the loaded relations and
@@ -128,7 +126,7 @@ module Mongoid # :nodoc:
       end
     end
 
-    module ClassMethods #:nodoc:
+    module ClassMethods
 
       # This is convenience for librarys still on the old API.
       #

data/lib/mongoid/relations/accessors.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
-module Mongoid # :nodoc:
-  module Relations #:nodoc:
+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
@@ -12,7 +12,7 @@ module Mongoid # :nodoc:
       # document is nil, then sets the relation on this document.
       #
       # @example Build the relation.
-      #   person.build(:addresses, { :id => 1 }, metadata)
+      #   person.__build__(:addresses, { :id => 1 }, metadata)
       #
       # @param [ String, Symbol ] name The name of the relation.
       # @param [ Hash, BSON::ObjectId ] object The id or attributes to use.
@@ -22,7 +22,7 @@ module Mongoid # :nodoc:
       # @return [ Proxy ] The relation.
       #
       # @since 2.0.0.rc.1
-      def build(name, object, metadata)
+      def __build__(name, object, metadata)
         relation = create_relation(object, metadata)
         set_relation(name, relation)
       end
@@ -74,7 +74,64 @@ module Mongoid # :nodoc:
         instance_variable_set("@#{name}", relation)
       end
 
-      module ClassMethods #:nodoc:
+      private
+
+      # 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("without_autobuild")
+        yield
+      ensure
+        Threaded.exit("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 { !#{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
@@ -90,22 +147,43 @@ module Mongoid # :nodoc:
         #
         # @since 2.0.0.rc.1
         def getter(name, metadata)
-          tap do
-            define_method(name) do |*args|
-              reload, variable = args.first, "@#{name}"
-              if instance_variable_defined?(variable) && !reload
-                instance_variable_get(variable)
-              else
-                _building do
-                  _loading do
-                    build(name, attributes[metadata.key], metadata)
-                  end
-                end
+          re_define_method(name) do |*args|
+            reload, variable = args.first, "@#{name}"
+            value = if instance_variable_defined?(variable) && !reload
+              instance_variable_get(variable)
+            else
+              _building do
+                _loading { __build__(name, attributes[metadata.key], metadata) }
               end
             end
+            if value.nil? && metadata.autobuilding? && !without_autobuild?
+              send("build_#{name}")
+            else
+              value
+            end
+          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
@@ -121,16 +199,38 @@ module Mongoid # :nodoc:
         #
         # @since 2.0.0.rc.1
         def setter(name, metadata)
-          tap do
-            define_method("#{name}=") do |object|
+          re_define_method("#{name}=") do |object|
+            without_autobuild do
               if relation_exists?(name) || metadata.many? ||
                 (object.blank? && send(name))
                 set_relation(name, send(name).substitute(object.substitutable))
               else
-                build(name, object.substitutable, metadata)
+                __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))
+          end
+          self
         end
       end
     end

data/lib/mongoid/relations/auto_save.rb

@@ -1,13 +1,50 @@
 # encoding: utf-8
-module Mongoid # :nodoc:
-  module Relations #:nodoc:
+module Mongoid
+  module Relations
 
     # This module contains the behaviour for auto-saving relations in
     # different collections.
     module AutoSave
       extend ActiveSupport::Concern
 
-      module ClassMethods #:nodoc:
+      included do
+        class_attribute :autosaved_relations
+        self.autosaved_relations = []
+      end
+
+      # Used to prevent infinite loops in associated autosaves.
+      #
+      # @example Is the document autosaved?
+      #   document.autosaved?
+      #
+      # @return [ true, false ] Has the document already been autosaved?
+      #
+      # @since 3.0.0
+      def autosaved?
+        Threaded.autosaved?(self)
+      end
+
+      # Begin the associated autosave.
+      #
+      # @example Begin autosave.
+      #   document.begin_autosave
+      #
+      # @since 3.0.0
+      def begin_autosave
+        Threaded.begin_autosave(self)
+      end
+
+      # Exit the associated autosave.
+      #
+      # @example Exit autosave.
+      #   document.exit_autosave
+      #
+      # @since 3.0.0
+      def exit_autosave
+        Threaded.exit_autosave(self)
+      end
+
+      module ClassMethods
 
         # Set up the autosave behaviour for references many and references one
         # relations. When the option is set to true, these relations will get
@@ -21,17 +58,34 @@ module Mongoid # :nodoc:
         #
         # @since 2.0.0.rc.1
         def autosave(metadata)
-          if metadata.autosave?
-            set_callback :save, :after do |document|
+          if metadata.autosave? && autosavable?(metadata)
+            autosaved_relations.push(metadata.name)
+            set_callback :save, :after, unless: :autosaved? do |document|
+              begin_autosave
               relation = document.send(metadata.name)
               if relation
                 (relation.do_or_do_not(:in_memory) || Array.wrap(relation)).each do |doc|
                   doc.save
                 end
               end
+              exit_autosave
             end
           end
         end
+
+        # Can the autosave be added?
+        #
+        # @example Can the autosave be added?
+        #   Person.autosavable?(metadata)
+        #
+        # @param [ Metadata ] metadata The relation metadata.
+        #
+        # @return [ true, false ] If the autosave is able to be added.
+        #
+        # @since 3.0.0
+        def autosavable?(metadata)
+          !autosaved_relations.include?(metadata.name) && !metadata.embedded?
+        end
       end
     end
   end