stonegao-mongoid 2.0.0.rc.6

data/lib/mongoid/persistence.rb

@@ -0,0 +1,237 @@
+# encoding: utf-8
+require "mongoid/persistence/command"
+require "mongoid/persistence/insert"
+require "mongoid/persistence/insert_embedded"
+require "mongoid/persistence/remove"
+require "mongoid/persistence/remove_all"
+require "mongoid/persistence/remove_embedded"
+require "mongoid/persistence/update"
+
+module Mongoid #:nodoc:
+
+  # The persistence module is a mixin to provide database accessor methods for
+  # the document. These correspond to the appropriate accessors on a
+  # mongo collection and retain the same DSL.
+  #
+  # @example Sample persistence operations.
+  #   document.insert
+  #   document.update
+  #   document.upsert
+  module Persistence
+    extend ActiveSupport::Concern
+
+    # Remove the document from the datbase with callbacks.
+    #
+    # @example Destroy a document.
+    #   document.destroy
+    #
+    # @param [ Hash ] options Options to pass to destroy.
+    #
+    # @return [ true, false ] True if successful, false if not.
+    def destroy(options = {})
+      run_callbacks(:destroy) { remove(options) }
+    end
+
+    # Insert a new document into the database. Will return the document
+    # itself whether or not the save was successful.
+    #
+    # @example Insert a document.
+    #   document.insert
+    #
+    # @param [ Hash ] options Options to pass to insert.
+    #
+    # @return [ Document ] The persisted document.
+    def insert(options = {})
+      Insert.new(self, options).persist
+    end
+
+    # Remove the document from the datbase.
+    #
+    # @example Remove the document.
+    #   document.remove
+    #
+    # @param [ Hash ] options Options to pass to remove.
+    #
+    # @return [ TrueClass ] True.
+    def remove(options = {})
+      if Remove.new(self, options).persist
+        self.destroyed = true
+        cascade!
+      end; true
+    end
+    alias :delete :remove
+
+    # Save the document - will perform an insert if the document is new, and
+    # update if not. If a validation error occurs an error will get raised.
+    #
+    # @example Save the document.
+    #   document.save!
+    #
+    # @param [ Hash ] options Options to pass to the save.
+    #
+    # @return [ true, false ] True if validation passed.
+    def save!(options = {})
+      self.class.fail_validate!(self) unless upsert; true
+    end
+
+    # Update the document in the datbase.
+    #
+    # @example Update an existing document.
+    #   document.update
+    #
+    # @param [ Hash ] options Options to pass to update.
+    #
+    # @return [ true, false ] True if succeeded, false if not.
+    def update(options = {})
+      Update.new(self, options).persist
+    end
+
+    # Update a single attribute and persist the entire document.
+    # This skips validation but fires the callbacks.
+    #
+    # @example Update the attribute.
+    #   person.update_attribute(:title, "Sir")
+    #
+    # @param [ Symbol, String ] name The name of the attribute.
+    # @param [ Object ] value The new value of the attribute.a
+    #
+    # @return [ true, false ] True if save was successfull, false if not.
+    #
+    # @since 2.0.0.rc.6
+    def update_attribute(name, value)
+      write_attribute(name, value) and save(:validate => false)
+    end
+
+    # Update the document attributes in the datbase.
+    #
+    # @example Update the document's attributes
+    #   document.update_attributes(:title => "Sir")
+    #
+    # @param [ Hash ] attributes The attributes to update.
+    #
+    # @return [ true, false ] True if validation passed, false if not.
+    def update_attributes(attributes = {})
+      write_attributes(attributes); save
+    end
+
+    # Update the document attributes in the database and raise an error if
+    # validation failed.
+    #
+    # @example Update the document's attributes.
+    #   document.update_attributes(:title => "Sir")
+    #
+    # @param [ Hash ] attributes The attributes to update.
+    #
+    # @raise [ Errors::Validations ] If validation failed.
+    #
+    # @return [ true, false ] True if validation passed.
+    def update_attributes!(attributes = {})
+      update_attributes(attributes).tap do |result|
+        self.class.fail_validate!(self) unless result
+      end
+    end
+
+    # Upsert the document - will perform an insert if the document is new, and
+    # update if not.
+    #
+    # @example Upsert the document.
+    #   document.upsert
+    #
+    # @param [ Hash ] options Options to pass to the upsert.
+    #
+    # @return [ true, false ] True is success, false if not.
+    def upsert(options = {})
+      if new_record?
+        insert(options).persisted?
+      else
+        update(options)
+      end
+    end
+    alias :save :upsert
+
+    module ClassMethods #:nodoc:
+
+      # Create a new document. This will instantiate a new document and
+      # insert it in a single call. Will always return the document
+      # whether save passed or not.
+      #
+      # @example Create a new document.
+      #   Person.create(:title => "Mr")
+      #
+      # @param [ Hash ] attributes The attributes to create with.
+      #
+      # @return [ Document ] The newly created document.
+      def create(attributes = {}, &block)
+        new(attributes, &block).tap(&:save)
+      end
+
+      # Create a new document. This will instantiate a new document and
+      # insert it in a single call. Will always return the document
+      # whether save passed or not, and if validation fails an error will be
+      # raise.
+      #
+      # @example Create a new document.
+      #   Person.create!(:title => "Mr")
+      #
+      # @param [ Hash ] attributes The attributes to create with.
+      #
+      # @return [ Document ] The newly created document.
+      def create!(attributes = {}, &block)
+        document = new(attributes, &block)
+        fail_validate!(document) if document.insert.errors.any?
+        document
+      end
+
+      # Delete all documents given the supplied conditions. If no conditions
+      # are passed, the entire collection will be dropped for performance
+      # benefits. Does not fire any callbacks.
+      #
+      # @example Delete matching documents from the collection.
+      #   Person.delete_all(:conditions => { :title => "Sir" })
+      #
+      # @example Delete all documents from the collection.
+      #   Person.delete_all
+      #
+      # @param [ Hash ] conditions Optional conditions to delete by.
+      #
+      # @return [ Integer ] The number of documents deleted.
+      def delete_all(conditions = {})
+        RemoveAll.new(
+          self,
+          { :validate => false },
+          conditions[:conditions] || {}
+        ).persist
+      end
+
+      # Delete all documents given the supplied conditions. If no conditions
+      # are passed, the entire collection will be dropped for performance
+      # benefits. Fires the destroy callbacks if conditions were passed.
+      #
+      # @example Destroy matching documents from the collection.
+      #   Person.destroy_all(:conditions => { :title => "Sir" })
+      #
+      # @example Destroy all documents from the collection.
+      #   Person.destroy_all
+      #
+      # @param [ Hash ] conditions Optional conditions to destroy by.
+      #
+      # @return [ Integer ] The number of documents destroyed.
+      def destroy_all(conditions = {})
+        documents = all(conditions)
+        documents.count.tap do
+          documents.each { |doc| doc.destroy }
+        end
+      end
+
+      # Raise an error if validation failed.
+      #
+      # @example Raise the validation error.
+      #   Person.fail_validate!(person)
+      #
+      # @param [ Document ] document The document to fail.
+      def fail_validate!(document)
+        raise Errors::Validations.new(document)
+      end
+    end
+  end
+end

data/lib/mongoid/railtie.rb

@@ -0,0 +1,129 @@
+# 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.reconnect_time = 10
+      #     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
+      #
+      #   defaults: &defaults
+      #     host: localhost
+      #     slaves:
+      #       # - host: localhost
+      #         # port: 27018
+      #       # - host: localhost
+      #         # port: 27019
+      #     allow_dynamic_fields: false
+      #     parameterize_keys: false
+      #     persist_in_safe_mode: false
+      #
+      #   development:
+      #     <<: *defaults
+      #     database: mongoid
+      initializer "setup database" do
+        config_file = Rails.root.join("config", "mongoid.yml")
+        if config_file.file?
+          settings = YAML.load(ERB.new(config_file.read).result)[Rails.env]
+          ::Mongoid.from_hash(settings) if settings.present?
+        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
+
+      # 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
+          ::Rails::Mongoid.load_models(app) unless $rails_rake_task
+        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
+
+      # When workers are forked in passenger and unicorn, we need to reconnect
+      # to the database to all the workers do not share the same connection.
+      initializer "reconnect to master if application is preloaded" do
+        config.after_initialize do
+
+          # Unicorn clears the START_CTX when a worker is forked, so if we have
+          # data in START_CTX then we know we're being preloaded. Unicorn does
+          # not provide application-level hooks for executing code after the
+          # process has forked, so we reconnect lazily.
+          if defined?(Unicorn) && !Unicorn::HttpServer::START_CTX.empty?
+            ::Mongoid.reconnect!(false)
+          end
+
+          # Passenger provides the :starting_worker_process event for executing
+          # code after it has forked, so we use that and reconnect immediately.
+          if defined?(PhusionPassenger)
+            PhusionPassenger.on_event(:starting_worker_process) do |forked|
+              if forked
+                ::Mongoid.reconnect!
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/railties/database.rake

@@ -0,0 +1,171 @@
+namespace :db do
+
+  if not Rake::Task.task_defined?("db:drop")
+    desc 'Drops all the collections for the database for the current Rails.env'
+    task :drop => :environment do
+      Mongoid.master.collections.select {|c| c.name !~ /system/ }.each(&:drop)
+    end
+  end
+
+  if not 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
+
+  if not 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
+
+  if not Rake::Task.task_defined?("db:reseed")
+    desc 'Delete data and seed'
+    task :reseed => [ 'db:drop', 'db:seed' ]
+  end
+
+  if not Rake::Task.task_defined?("db:create")
+    task :create => :environment do
+      # noop
+    end
+  end
+
+  if not Rake::Task.task_defined?("db:migrate")
+    task :migrate => :environment do
+      # noop
+    end
+  end
+
+  if not Rake::Task.task_defined?("db:schema:load")
+    namespace :schema do
+      task :load do
+        # noop
+      end
+    end
+  end
+
+  if not Rake::Task.task_defined?("db:test:prepare")
+    namespace :test do
+      task :prepare do
+        # noop
+      end
+    end
+  end
+
+  if not 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(&:classify).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
+      ::Rails::Mongoid.index_children(get_mongoid_models)
+    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 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
+
+    ########
+    # 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/accessors.rb

@@ -0,0 +1,157 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+
+    # 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, 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, options = {})
+        relation = create_relation(object, metadata)
+        set(name, relation).tap do |relation|
+          relation.load!(options) if relation && options[:eager]
+        end
+      end
+
+      # Return the options passed to the builders.
+      #
+      # @example Get the options.
+      #   person.configurables(document, :continue => true)
+      #
+      # @param [ Array ] args The arguments to check.
+      #
+      # @return [ Hash ] The options.
+      #
+      # @since 2.0.0.rc.1
+      def options(args)
+        Mongoid.binding_defaults.merge(args.extract_options!)
+      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(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
+
+      # 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(name, relation)
+        instance_variable_set("@#{name}", relation)
+      end
+
+      module ClassMethods #:nodoc:
+
+        # 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)
+          tap do
+            define_method(name) do |*args|
+              reload, variable = args.first, "@#{name}"
+              options = options(args)
+              if instance_variable_defined?(variable) && !reload
+                instance_variable_get(variable)
+              else
+                build(
+                  name,
+                  @attributes[metadata.key],
+                  metadata,
+                  options.merge(:binding => true, :eager => metadata.embedded?)
+                )
+              end
+            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.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)
+          tap do
+            define_method("#{name}=") do |*args|
+              object, options = args.first, options(args)
+              variable = "@#{name}"
+              if relation_exists?(name) && !object.is_a?(Hash)
+                set(name, ivar(name).substitute(object, options))
+              else
+                build(name, object, metadata, options.merge(:eager => true))
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end