mongoid-multi-db 3.0.0

data/lib/mongoid/persistence/operations/update.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+    module Operations #:nodoc:
+
+      # Update is a persistence command responsible for taking a document that
+      # has already been saved to the database and saving it, depending on
+      # whether or not the document has been modified.
+      #
+      # Before persisting the command will check via dirty attributes if the
+      # document has changed, if not, it will simply return true. If it has it
+      # will go through the validation steps, run callbacks, and set the changed
+      # fields atomically on the document. The underlying query resembles the
+      # following MongoDB query:
+      #
+      #   collection.update(
+      #     { "_id" : 1,
+      #     { "$set" : { "field" : "value" },
+      #     false,
+      #     false
+      #   );
+      #
+      # For embedded documents it will use the positional locator:
+      #
+      #   collection.update(
+      #     { "_id" : 1, "addresses._id" : 2 },
+      #     { "$set" : { "addresses.$.field" : "value" },
+      #     false,
+      #     false
+      #   );
+      #
+      class Update
+        include Modification, Operations
+
+        # Persist the document that is to be updated to the database. This will
+        # only write changed fields via MongoDB's $set modifier operation.
+        #
+        # @example Update the document.
+        #   Update.persist
+        #
+        # @return [ true, false ] If the save passed.
+        def persist
+          prepare do
+            unless updates.empty?
+              # @todo Durran: This is a temporary fix for #791 until we rewrite
+              # the dirty tracking to properly flag a document as changed if
+              # only embedded documents have changed.
+              if document.respond_to?(:updated_at)
+                if document.timestamping? && !document.updated_at_changed?
+                  document.updated_at = Time.now
+                end
+              end
+
+              collection.update(selector, updates, options)
+              conflicts.each_pair do |key, value|
+                collection.update(selector, { key => value }, options)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/railtie.rb

@@ -0,0 +1,126 @@
+# encoding: utf-8
+require "singleton"
+require "mongoid"
+require "mongoid/config"
+require "mongoid/railties/document"
+require "rails"
+require "rails/mongoid"
+
+module Rails #:nodoc:
+  module Mongoid #:nodoc:
+    class Railtie < Rails::Railtie #:nodoc:
+
+      # Determine which generator to use. app_generators was introduced after
+      # 3.0.0.
+      #
+      # @example Get the generators method.
+      #   railtie.generators
+      #
+      # @return [ Symbol ] The method name to use.
+      #
+      # @since 2.0.0.rc.4
+      def self.generator
+        config.respond_to?(:app_generators) ? :app_generators : :generators
+      end
+
+      config.send(generator).orm :mongoid, :migration => false
+
+      rake_tasks do
+        load "mongoid/railties/database.rake"
+      end
+
+      # Exposes Mongoid's configuration to the Rails application configuration.
+      #
+      # @example Set up configuration in the Rails app.
+      #   module MyApplication
+      #     class Application < Rails::Application
+      #       config.mongoid.logger = Logger.new($stdout, :warn)
+      #       config.mongoid.persist_in_safe_mode = true
+      #     end
+      #   end
+      config.mongoid = ::Mongoid::Config
+
+      # Initialize Mongoid. This will look for a mongoid.yml in the config
+      # directory and configure mongoid appropriately.
+      #
+      # @example mongoid.yml
+      #
+      #   development:
+      #     host: localhost
+      #     database: mongoid
+      #     slaves:
+      #       # - host: localhost
+      #         # port: 27018
+      #       # - host: localhost
+      #         # port: 27019
+      #     allow_dynamic_fields: false
+      #     parameterize_keys: false
+      #     persist_in_safe_mode: false
+      #
+      initializer "setup database" do
+        config_file = Rails.root.join("config", "mongoid.yml")
+        # @todo: Durran: Remove extra check when #1291 complete.
+        if config_file.file? &&
+          YAML.load(ERB.new(File.read(config_file)).result)[Rails.env].values.flatten.any?
+          ::Mongoid.load!(config_file)
+        end
+      end
+
+      # After initialization we will warn the user if we can't find a mongoid.yml and
+      # alert to create one.
+      initializer "warn when configuration is missing" do
+        config.after_initialize do
+          unless Rails.root.join("config", "mongoid.yml").file?
+            puts "\nMongoid config not found. Create a config file at: config/mongoid.yml"
+            puts "to generate one run: rails generate mongoid:config\n\n"
+          end
+        end
+      end
+
+      # Set the proper error types for Rails. DocumentNotFound errors should be
+      # 404s and not 500s, validation errors are 422s.
+      initializer "load http errors" do |app|
+        config.after_initialize do
+          ActionDispatch::ShowExceptions.rescue_responses.update({
+            "Mongoid::Errors::DocumentNotFound" => :not_found,
+            "Mongoid::Errors::Validations" => 422
+          })
+        end
+      end
+
+      # Due to all models not getting loaded and messing up inheritance queries
+      # and indexing, we need to preload the models in order to address this.
+      #
+      # This will happen every request in development, once in ther other
+      # environments.
+      initializer "preload all application models" do |app|
+        config.to_prepare do
+          if $rails_rake_task
+            # We previously got rid of this, however in the case where
+            # threadsafe! is enabled we must load all models so things like
+            # creating indexes works properly.
+            ::Rails::Mongoid.load_models(app)
+          else
+            ::Rails::Mongoid.preload_models(app)
+          end
+        end
+      end
+
+      # Need to include the Mongoid identity map middleware.
+      initializer "include the identity map" do |app|
+        app.config.middleware.use "Rack::Mongoid::Middleware::IdentityMap"
+      end
+
+      # Instantitate any registered observers after Rails initialization and
+      # instantiate them after being reloaded in the development environment
+      initializer "instantiate observers" do
+        config.after_initialize do
+          ::Mongoid::instantiate_observers
+          ActionDispatch::Reloader.to_prepare do
+            ::Mongoid.instantiate_observers
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/railties/database.rake

@@ -0,0 +1,182 @@
+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: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:reseed")
+    desc 'Delete data and seed'
+    task :reseed => [ '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
+
+  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'
+    task :create_indexes => :environment do
+      engines_models_paths = Rails.application.railties.engines.map do |engine|
+        engine.paths["app/models"].paths
+      end
+      root_models_paths = Rails.application.paths["app/models"]
+      models_paths = engines_models_paths.push(root_models_paths).flatten
+
+      models_paths.each do |path|
+        ::Rails::Mongoid.create_indexes("#{path}/**/*.rb")
+      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
+      end
+
+      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
+      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 }
+    end
+
+    ########
+    # TODO: lots more useful db tasks can be added here. stuff like copyDatabase, etc
+    ########
+  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,144 @@
+# 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/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/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"
+require "mongoid/relations/referenced/one"
+require "mongoid/relations/reflections"
+require "mongoid/relations/synchronization"
+require "mongoid/relations/metadata"
+require "mongoid/relations/macros"
+
+module Mongoid # :nodoc:
+
+  # 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
+
+    included do
+      attr_accessor :metadata
+    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?
+      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
+
+    # 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 == :references_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 == :references_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}")
+          remove_instance_variable("@#{name}")
+        end
+      end
+    end
+
+    module ClassMethods #:nodoc:
+
+      # 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