mongoid-pre 2.0.0.beta1

data/lib/mongoid/collections/cyclic_iterator.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Collections #:nodoc:
+    class CyclicIterator
+
+      attr_reader :counter
+
+      # Performs iteration over an array, if the array gets to the end then loop
+      # back to the first.
+      #
+      # Example:
+      #
+      # <tt>CyclicIterator.new([ first, second ])</tt>
+      def initialize(array)
+        @array, @counter = array, -1
+      end
+
+      # Get the next element in the array. If the element is the last in the
+      # array then return the first.
+      #
+      # Example:
+      #
+      # <tt>iterator.next</tt>
+      #
+      # Returns:
+      #
+      # The next element in the array.
+      def next
+        (@counter == @array.size - 1) ? @counter = 0 : @counter = @counter + 1
+        @array[@counter]
+      end
+    end
+  end
+end

data/lib/mongoid/collections/master.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Collections #:nodoc:
+    class Master
+      include Mimic
+
+      attr_reader :collection
+
+      # All read and write operations should delegate to the master connection.
+      # These operations mimic the methods on a Mongo:Collection.
+      #
+      # Example:
+      #
+      # <tt>collection.save({ :name => "Al" })</tt>
+      proxy(:collection, Operations::ALL)
+
+      # Create the new database writer. Will create a collection from the
+      # master database.
+      #
+      # Example:
+      #
+      # <tt>Master.new(master, "mongoid_people")</tt>
+      def initialize(master, name)
+        @collection = master.collection(name)
+      end
+    end
+  end
+end

data/lib/mongoid/collections/mimic.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Collections #:nodoc:
+    module Mimic #:nodoc:
+      def self.included(base)
+        base.class_eval do
+          include InstanceMethods
+          extend ClassMethods
+        end
+      end
+
+      module InstanceMethods #:nodoc:
+        # Retry the supplied operation until the reconnect time has expired,
+        # defined in the mongoid Config module.
+        #
+        # Example:
+        #
+        # <tt>master.attempt(operation)</tt>
+        def attempt(operation, start)
+          begin
+            elapsed = (Time.now - start)
+            operation.call
+          rescue Mongo::ConnectionFailure => error
+            (elapsed < Mongoid.reconnect_time) ? retry : (raise error)
+          end
+        end
+      end
+
+      module ClassMethods #:nodoc:
+        # Proxy all the supplied operations to the internal collection or target.
+        #
+        # Example:
+        #
+        # <tt>proxy Operations::ALL, :collection</tt>
+        def proxy(target, operations)
+          operations.each do |name|
+            define_method(name) do |*args|
+              operation = lambda { send(target).send(name, *args) }
+              attempt(operation, Time.now)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/collections/operations.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Collections #:nodoc:
+    module Operations #:nodoc:
+      # Constant definining all the read operations available for a
+      # Mongo:Collection. This is used in delegation.
+      READ = [
+        :[],
+        :db,
+        :count,
+        :distinct,
+        :find,
+        :find_one,
+        :group,
+        :index_information,
+        :map_reduce,
+        :mapreduce,
+        :options
+      ]
+
+      # Constant definining all the write operations available for a
+      # Mongo:Collection. This is used in delegation.
+      WRITE = [
+        :<<,
+        :create_index,
+        :drop,
+        :drop_index,
+        :drop_indexes,
+        :insert,
+        :remove,
+        :rename,
+        :save,
+        :update
+      ]
+
+      # Convenience constant for getting back all collection operations.
+      ALL = (READ + WRITE)
+      PROXIED = ALL - [ :find, :find_one, :map_reduce, :mapreduce ]
+    end
+  end
+end

data/lib/mongoid/collections/slaves.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Collections #:nodoc:
+    class Slaves
+      include Mimic
+
+      attr_reader :iterator
+
+      # All read operations should delegate to the slave connections.
+      # These operations mimic the methods on a Mongo:Collection.
+      #
+      # Example:
+      #
+      # <tt>collection.save({ :name => "Al" })</tt>
+      proxy(:collection, Operations::READ)
+
+      # Is the collection of slaves empty or not?
+      #
+      # Return:
+      #
+      # True is the iterator is not set, false if not.
+      def empty?
+        @iterator.nil?
+      end
+
+      # Create the new database reader. Will create a collection from the
+      # slave databases and cycle through them on each read.
+      #
+      # Example:
+      #
+      # <tt>Reader.new(slaves, "mongoid_people")</tt>
+      def initialize(slaves, name)
+        unless slaves.blank?
+          @iterator = CyclicIterator.new(slaves.collect { |db| db.collection(name) })
+        end
+      end
+
+      protected
+      def collection
+        @iterator.next
+      end
+    end
+  end
+end

data/lib/mongoid/commands.rb

@@ -0,0 +1,161 @@
+# encoding: utf-8
+require "mongoid/commands/create"
+require "mongoid/commands/deletion"
+require "mongoid/commands/delete"
+require "mongoid/commands/delete_all"
+require "mongoid/commands/destroy"
+require "mongoid/commands/destroy_all"
+require "mongoid/commands/save"
+
+module Mongoid #:nodoc:
+
+  # This module is included in the +Document+ to provide all the persistence
+  # methods required on the +Document+ object and class.
+  module Commands
+    extend ActiveSupport::Concern
+    module InstanceMethods
+
+      # Delete the +Document+ from the database. This method is an optimized
+      # delete that does not force any callbacks.
+      #
+      # Example:
+      #
+      # <tt>document.delete</tt>
+      #
+      # Returns: true unless an error occurs.
+      def delete
+        Delete.execute(self)
+      end
+
+      # Destroy the +Document+. This will delete the document from the database
+      # and run the before and after destroy callbacks.
+      #
+      # Example:
+      #
+      # <tt>document.destroy</tt>
+      #
+      # Returns: true unless an error occurs.
+      def destroy
+        Destroy.execute(self)
+      end
+
+      # Save the +Document+. If the document is new, then the before and after
+      # create callbacks will get executed as well as the save callbacks.
+      # Otherwise only the save callbacks will run.
+      #
+      # Options:
+      #
+      # validate: Run validations or not. Defaults to true.
+      #
+      # Example:
+      #
+      # <tt>document.save # save with validations</tt>
+      # <tt>document.save(false) # save without validations</tt>
+      #
+      # Returns: true if validation passes, false if not.
+      def save(validate = true)
+        save = lambda { Save.execute(self, validate) }
+        new_record? ? run_callbacks(:create, &save) : save.call
+      end
+
+      # Save the +Document+, dangerously. Before and after save callbacks will
+      # get run. If validation fails an error will get raised.
+      #
+      # Example:
+      #
+      # <tt>document.save!</tt>
+      #
+      # Returns: true if validation passes
+      def save!
+        save(true) || (raise Errors::Validations.new(self.errors))
+      end
+
+      # Update the document attributes and persist the document to the
+      # database. Will delegate to save with all callbacks.
+      #
+      # Example:
+      #
+      # <tt>document.update_attributes(:title => "Test")</tt>
+      def update_attributes(attrs = {})
+        set_attributes(attrs); save
+      end
+
+      # Update the document attributes and persist the document to the
+      # database. Will delegate to save!
+      #
+      # Example:
+      #
+      # <tt>document.update_attributes!(:title => "Test")</tt>
+      def update_attributes!(attrs = {})
+        set_attributes(attrs); save!
+      end
+
+      protected
+      def set_attributes(attrs = {})
+        run_callbacks(:update) { write_attributes(attrs) }
+      end
+
+    end
+
+    module ClassMethods
+
+      # Create a new +Document+. This will instantiate a new document and save
+      # it in a single call. Will always return the document whether save
+      # passed or not.
+      #
+      # Example:
+      #
+      # <tt>Person.create(:title => "Mr")</tt>
+      #
+      # Returns: the +Document+.
+      def create(attributes = {})
+        document = new(attributes)
+        Create.execute(document)
+        document
+      end
+
+      # Create a new +Document+. This will instantiate a new document and save
+      # it in a single call. Will always return the document whether save
+      # passed or not. Will raise an error if validation fails.
+      #
+      # Example:
+      #
+      # <tt>Person.create!(:title => "Mr")</tt>
+      #
+      # Returns: the +Document+.
+      def create!(attributes = {})
+        document = Create.execute(new(attributes), true)
+        raise Errors::Validations.new(document.errors) unless document.errors.empty?
+        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:
+      #
+      # <tt>Person.delete_all(:conditions => { :title => "Sir" })</tt>
+      # <tt>Person.delete_all</tt>
+      #
+      # Returns: true or raises an error.
+      def delete_all(conditions = {})
+        DeleteAll.execute(self, conditions)
+      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:
+      #
+      # <tt>Person.destroy_all(:conditions => { :title => "Sir" })</tt>
+      # <tt>Person.destroy_all</tt>
+      #
+      # Returns: true or raises an error.
+      def destroy_all(conditions = {})
+        DestroyAll.execute(self, conditions)
+      end
+    end
+  end
+end

data/lib/mongoid/commands/create.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Commands
+    class Create
+      # Performs a create of the supplied Document, with the necessary
+      # callbacks. It then delegates to the Save command.
+      #
+      # Options:
+      #
+      # doc: A new +Document+ that is going to be persisted.
+      #
+      # Returns: +Document+.
+      def self.execute(doc, validate = true)
+        doc.run_callbacks(:create) { Save.execute(doc, validate) }
+        doc
+      end
+    end
+  end
+end

data/lib/mongoid/commands/delete.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Commands
+    class Delete
+      extend Deletion
+      # Performs a delete of the supplied +Document+ without any callbacks.
+      #
+      # Options:
+      #
+      # doc: A new +Document+ that is going to be deleted.
+      def self.execute(doc)
+        doc.destroyed = true if delete(doc)
+      end
+    end
+  end
+end

data/lib/mongoid/commands/delete_all.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Commands
+    class DeleteAll
+      # Performs a delete of the all the +Documents+ that match the criteria
+      # supplied.
+      #
+      # Options:
+      #
+      # params: A set of conditions to find the +Documents+ by.
+      # klass: The class of the +Document+ to execute the find on.
+      #
+      # Example:
+      #
+      # <tt>DeleteAll.execute(Person, :conditions => { :field => "value" })</tt>
+      def self.execute(klass, params = {})
+        safe = Mongoid.persist_in_safe_mode
+        collection = klass.collection
+        selector = (params[:conditions] || {}).merge(:_type => klass.name)
+        matching = collection.find(selector).count
+        collection.remove(selector, :safe => safe) ? matching : 0
+      end
+    end
+  end
+end

data/lib/mongoid/commands/deletion.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  module Commands #:nodoc
+    module Deletion #:nodoc
+      # If the +Document+ has a parent, delete it from the parent's attributes,
+      # otherwise delete it from it's collection.
+      def delete(doc)
+        parent = doc._parent
+        if parent
+          parent.remove(doc)
+          parent.save
+        else
+          doc.collection.remove(:_id => doc.id)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/commands/destroy.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Commands
+    class Destroy
+      extend Deletion
+      # Performs a destroy of the supplied +Document+, with the necessary
+      # callbacks. It then deletes the record from the collection.
+      #
+      # Options:
+      #
+      # doc: A new +Document+ that is going to be destroyed.
+      def self.execute(doc)
+        doc.run_callbacks(:destroy) { doc.destroyed = true if delete(doc) }
+      end
+    end
+  end
+end