chhean-mongoid 2.0.1.beta1

data/lib/mongoid/persistence/insert.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+    # Insert is a persistence command responsible for taking a document that
+    # has not been saved to the database and saving it.
+    #
+    # The underlying query resembles the following MongoDB query:
+    #
+    #   collection.insert(
+    #     { "_id" : 1, "field" : "value" },
+    #     false
+    #   );
+    class Insert < Command
+      # Insert the new document in the database. This delegates to the standard
+      # MongoDB collection's insert command.
+      #
+      # Example:
+      #
+      # <tt>Insert.persist</tt>
+      #
+      # Returns:
+      #
+      # The +Document+, whether the insert succeeded or not.
+      def persist
+        return @document if @validate && !@document.valid?
+        @document.run_callbacks(:create) do
+          @document.run_callbacks(:save) do
+            if insert
+              @document.new_record = false
+              @document.move_changes
+            end
+          end
+        end; @document
+      end
+
+      protected
+      # Insert the document into the database.
+      def insert
+        if @document.embedded?
+          Persistence::InsertEmbedded.new(@document, @validate).persist
+        else
+          @collection.insert(@document.raw_attributes, @options)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/persistence/insert_embedded.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+    # Insert is a persistence command responsible for taking a document that
+    # has not been saved to the database and saving it. This specific class
+    # handles the case when the document is embedded in another.
+    #
+    # The underlying query resembles the following MongoDB query:
+    #
+    #   collection.insert(
+    #     { "_id" : 1, "field" : "value" },
+    #     false
+    #   );
+    class InsertEmbedded < Command
+      # Insert the new document in the database. If the document's parent is a
+      # new record, we will call save on the parent, otherwise we will $push
+      # the document onto the parent.
+      #
+      # Example:
+      #
+      # <tt>Insert.persist</tt>
+      #
+      # Returns:
+      #
+      # The +Document+, whether the insert succeeded or not.
+      def persist
+        parent = @document._parent
+        if parent.new_record?
+          parent.insert
+        else
+          update = { @document._inserter => { @document._position => @document.raw_attributes } }
+          @collection.update(parent._selector, update, @options.merge(:multi => false))
+        end
+        @document.new_record = false; @document
+      end
+    end
+  end
+end

data/lib/mongoid/persistence/remove.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+    # Remove is a persistence command responsible for deleting a document from
+    # the database.
+    #
+    # The underlying query resembles the following MongoDB query:
+    #
+    #   collection.remove(
+    #     { "_id" : 1 },
+    #     false
+    #   );
+    class Remove < Command
+      # Remove the document from the database: delegates to the MongoDB
+      # collection remove method.
+      #
+      # Example:
+      #
+      # <tt>Remove.persist</tt>
+      #
+      # Returns:
+      #
+      # +true+ if success, +false+ if not.
+      def persist
+        remove
+      end
+
+      protected
+      # Remove the document from the database.
+      def remove
+        if @document.embedded?
+          Persistence::RemoveEmbedded.new(@document, @validate).persist
+        else
+          @collection.remove({ :_id => @document.id }, @options)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/persistence/remove_all.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+    # Remove is a persistence command responsible for deleting a document from
+    # the database.
+    #
+    # The underlying query resembles the following MongoDB query:
+    #
+    #   collection.remove(
+    #     { "field" : value },
+    #     false
+    #   );
+    class RemoveAll < Command
+      # Remove the document from the database: delegates to the MongoDB
+      # collection remove method.
+      #
+      # Example:
+      #
+      # <tt>Remove.persist</tt>
+      #
+      # Returns:
+      #
+      # +true+ if success, +false+ if not.
+      def persist
+        remove
+      end
+
+      protected
+      # Remove the document from the database.
+      def remove
+        count = @collection.find(@selector.merge(:_type => @klass.name)).count
+        @collection.remove(@selector, @options)
+        count
+      end
+    end
+  end
+end

data/lib/mongoid/persistence/remove_embedded.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+    # Remove is a persistence command responsible for deleting a document from
+    # the database.
+    #
+    # The underlying query resembles the following MongoDB query:
+    #
+    #   collection.remove(
+    #     { "_id" : 1 },
+    #     false
+    #   );
+    class RemoveEmbedded < Command
+      # Insert the new document in the database. If the document's parent is a
+      # new record, we will call save on the parent, otherwise we will $push
+      # the document onto the parent.
+      #
+      # Remove the document from the database. If the parent is a new record,
+      # it will get removed in Ruby only. If the parent is not a new record
+      # then either an $unset or $set will occur, depending if it's an
+      # embeds_one or embeds_many.
+      #
+      # Example:
+      #
+      # <tt>RemoveEmbedded.persist</tt>
+      #
+      # Returns:
+      #
+      # +true+ or +false+, depending on if the removal passed.
+      def persist
+        parent = @document._parent
+        parent.remove(@document)
+        unless parent.new_record?
+          update = { @document._remover => removal_selector }
+          @collection.update(parent._selector, update, @options.merge(:multi => false))
+        end; true
+      end
+
+      protected
+      # Get the value to pass to the removal modifier.
+      def setter
+        @document._index ? @document.id : true
+      end
+
+      def removal_selector
+        @document._index ? { @document._pull => { "_id" => @document.id } } : { @document._path => setter }
+      end
+    end
+  end
+end

data/lib/mongoid/persistence/update.rb

@@ -0,0 +1,63 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Persistence #: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 < Command
+      # Persist the document that is to be updated to the database. This will
+      # only write changed fields via MongoDB's $set modifier operation.
+      #
+      # Example:
+      #
+      # <tt>Update.persist</tt>
+      #
+      # Returns:
+      #
+      # +true+ or +false+, depending on validation.
+      def persist
+        return false if validate && !@document.valid?
+        @document.run_callbacks(:save) do
+          @document.run_callbacks(:update) do
+            if update
+              @document.move_changes
+            else
+              return false
+            end
+          end
+        end; true
+      end
+
+      protected
+      # Update the document in the database atomically.
+      def update
+        if @document.changed?
+          @collection.update(@document._selector, { "$set" => @document.setters }, @options.merge(:multi => false))
+        end; true
+      end
+    end
+  end
+end

data/lib/mongoid/railtie.rb

@@ -0,0 +1,54 @@
+require "rails"
+module Rails #:nodoc:
+  module Mongoid #:nodoc:
+    class Railtie < Rails::Railtie #:nodoc:
+
+      # do we want a custom log subscriber for mongoid?
+      # log_subscriber :mongoid, ::Mongoid::Railties::LogSubscriber.new
+
+      rake_tasks do
+        load "mongoid/railties/database.rake"
+      end
+
+      # 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
+
+      initializer "verify that mongoid is configured" do
+        config.after_initialize do
+          begin
+            ::Mongoid.master
+          rescue ::Mongoid::Errors::InvalidDatabase => e
+            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: script/rails generate mongoid:config\n\n"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/railties/database.rake

@@ -0,0 +1,37 @@
+namespace :db do
+
+  desc 'Drops all the collections for the database for the current Rails.env'
+  task :drop => :environment do
+    Mongoid.master.collections.each{|col| col.drop unless col.name == 'system.users' }
+  end
+
+  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
+
+  desc 'Create the database, and initialize with the seed data'
+  task :setup => [ 'db:create', 'db:seed' ]
+
+  desc 'Delete data and seed'
+  task :reseed => [ 'db:drop', 'db:seed' ]
+
+  task :create => :environment do
+    # noop
+  end
+
+  task :migrate => :environment do
+    # noop
+  end
+
+  namespace :schema do
+    task :load do
+      # noop
+    end
+  end
+
+  ########
+  # TODO: lots more useful db tasks can be added here. stuff like copyDatabase, etc
+  ########
+end

data/lib/mongoid/scope.rb

@@ -0,0 +1,75 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  class Scope #:nodoc:
+
+    delegate :scopes, :to => :parent
+
+    attr_reader :parent, :conditions
+
+    # If the other is a scope then compare the parent and conditions, otherwise
+    # if its enumerable collect and compare.
+    def ==(other)
+      case other
+      when Scope
+        @parent == other.parent && @conditions == other.conditions
+      when Enumerable
+        @collection ||= entries
+        return (@collection == other)
+      else
+        return false
+      end
+    end
+
+    # Create the new +Scope+. If a block is passed in, this Scope will extend
+    # the block.
+    #
+    # Options:
+    #
+    # parent: The class the scope belongs to, or a parent +Scope+.
+    # conditions: A +Hash+ of conditions.
+    #
+    # Example:
+    #
+    #   Mongoid::Scope.new(Person, { :title => "Sir" }) do
+    #     def knighted?
+    #       title == "Sir"
+    #     end
+    #   end
+    def initialize(parent, conditions, &block)
+      @parent, @conditions = parent, conditions
+      extend Module.new(&block) if block_given?
+    end
+
+    # Return the class for the +Scope+. This will be the parent if the parent
+    # is a class, otherwise will be nil.
+    def klass
+      @klass ||= @parent unless @parent.is_a?(Scope)
+    end
+
+    # Chaining is supported through method_missing. If a scope is already
+    # defined with the method name the call will be passed there, otherwise it
+    # will be passed to the target or parent.
+    def method_missing(name, *args, &block)
+      if scopes.include?(name)
+        scopes[name].call(self, *args)
+      elsif klass
+        target.send(name, *args, &block)
+      else
+        @parent.fuse(@conditions); @parent.send(name, *args, &block)
+      end
+    end
+
+    # The +Scope+ must respond like a +Criteria+ object. If this is a parent
+    # criteria delegate to the target, otherwise bubble up to the parent.
+    def respond_to?(name)
+      super || (klass ? target.respond_to?(name) : @parent.respond_to?(name))
+    end
+
+    # Returns the target criteria if it has already been set or creates a new
+    # criteria from the parent class.
+    def target
+      @target ||= klass.criteria.fuse(@conditions)
+    end
+  end
+end
+