mongoid-braxton 2.0.2

data/lib/mongoid/paths.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Paths #:nodoc:
+    extend ActiveSupport::Concern
+    included do
+      cattr_accessor :__path
+      attr_accessor :_index
+    end
+
+    # Get the insertion modifier for the document. Will be nil on root
+    # documents, $set on embeds_one, $push on embeds_many.
+    #
+    # Example:
+    #
+    # <tt>name.inserter</tt>
+    def _inserter
+      embedded? ? (embedded_many? ? "$push" : "$set") : nil
+    end
+
+    # Return the path to this +Document+ in JSON notation, used for atomic
+    # updates via $set in MongoDB.
+    #
+    # Example:
+    #
+    # <tt>address.path # returns "addresses"</tt>
+    def _path
+      _position.sub!(/\.\d+$/, '') || _position
+    end
+    alias :_pull :_path
+
+    # Returns the positional operator of this document for modification.
+    #
+    # Example:
+    #
+    # <tt>address.position</tt>
+    def _position
+      locator = _index ? (new_record? ? "" : ".#{_index}") : ""
+      embedded? ? "#{_parent._position}#{"." unless _parent._position.blank?}#{metadata.name.to_s}#{locator}" : ""
+    end
+
+    # Get the removal modifier for the document. Will be nil on root
+    # documents, $unset on embeds_one, $set on embeds_many.
+    #
+    # Example:
+    #
+    # <tt>name.remover</tt>
+    def _remover
+      embedded? ? (_index ? "$pull" : "$unset") : nil
+    end
+
+    # Return the selector for this document to be matched exactly for use
+    # with MongoDB's $ operator.
+    #
+    # Example:
+    #
+    # <tt>address.selector</tt>
+    def _selector
+      (embedded? ? _parent._selector.merge("#{_path}._id" => id) : { "_id" => id }).merge(shard_key_selector)
+    end
+  end
+end

data/lib/mongoid/persistence.rb

@@ -0,0 +1,240 @@
+# encoding: utf-8
+require "mongoid/persistence/atomic"
+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
+    include Atomic
+
+    # 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
+        attributes.freeze
+        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(options); 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) ? save(:validate => false) : true
+    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/persistence/atomic.rb

@@ -0,0 +1,88 @@
+# encoding: utf-8
+require "mongoid/persistence/atomic/operation"
+require "mongoid/persistence/atomic/add_to_set"
+require "mongoid/persistence/atomic/inc"
+require "mongoid/persistence/atomic/pull_all"
+require "mongoid/persistence/atomic/push"
+
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+
+    # This module provides the explicit atomic operations helpers on the
+    # document itself.
+    module Atomic
+
+      # Performs an atomic $addToSet of the provided value on the supplied field.
+      # If the field does not exist it will be initialized as an empty array.
+      #
+      # If the value already exists on the array it will not be added.
+      #
+      # @example Add only a unique value on the field.
+      #   person.add_to_set(:aliases, "Bond")
+      #
+      # @param [ Symbol ] field The name of the field.
+      # @param [ Object ] value The value to add.
+      # @param [ Hash ] options The mongo persistence options.
+      #
+      # @return [ Array<Object> ] The new value of the field.
+      #
+      # @since 2.0.0
+      def add_to_set(field, value, options = {})
+        AddToSet.new(self, field, value, options).persist
+      end
+
+      # Performs an atomic $inc of the provided value on the supplied
+      # field. If the field does not exist it will be initialized as
+      # the provided value.
+      #
+      # @example Increment a field.
+      #   person.inc(:score, 2)
+      #
+      # @param [ Symbol ] field The name of the field.
+      # @param [ Integer ] value The value to increment.
+      # @param [ Hash ] options The mongo persistence options.
+      #
+      # @return [ Array<Object> ] The new value of the field.
+      #
+      # @since 2.0.0
+      def inc(field, value, options = {})
+        Inc.new(self, field, value, options).persist
+      end
+
+      # Performs an atomic $pullAll of the provided value on the supplied
+      # field. If the field does not exist it will be initialized as an
+      # empty array.
+      #
+      # @example Pull the values from the field.
+      #   person.pull_all(:aliases, [ "Bond", "James" ])
+      #
+      # @param [ Symbol ] field The name of the field.
+      # @param [ Array<Object> ] value The values to pull.
+      # @param [ Hash ] options The mongo persistence options.
+      #
+      # @return [ Array<Object> ] The new value of the field.
+      #
+      # @since 2.0.0
+      def pull_all(field, value, options = {})
+        PullAll.new(self, field, value, options).persist
+      end
+
+      # Performs an atomic $push of the provided value on the supplied field. If
+      # the field does not exist it will be initialized as an empty array.
+      #
+      # @example Push a value on the field.
+      #   person.push(:aliases, "Bond")
+      #
+      # @param [ Symbol ] field The name of the field.
+      # @param [ Object ] value The value to push.
+      # @param [ Hash ] options The mongo persistence options.
+      #
+      # @return [ Array<Object> ] The new value of the field.
+      #
+      # @since 2.0.0
+      def push(field, value, options = {})
+        Push.new(self, field, value, options).persist
+      end
+    end
+  end
+end

data/lib/mongoid/persistence/atomic/add_to_set.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+    module Atomic #:nodoc:
+
+      # This class provides the ability to perform an explicit $addToSet
+      # modification on a specific field.
+      class AddToSet < Operation
+
+        # Sends the atomic $addToSet operation to the database.
+        #
+        # @example Persist the new values.
+        #   addToSet.persist
+        #
+        # @return [ Object ] The new array value.
+        #
+        # @since 2.0.0
+        def persist
+          document[field] = [] unless document[field]
+          values = document.send(field)
+          values.push(value) unless values.include?(value)
+          values.tap do
+            if document.persisted?
+              document.collection.update(document._selector, operation("$addToSet"), options)
+              document.changes.delete(field.to_s)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/persistence/atomic/inc.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+    module Atomic #:nodoc:
+
+      # This class provides atomic $inc behaviour.
+      class Inc < Operation
+
+        # Sends the atomic $inc operation to the database.
+        #
+        # @example Persist the new values.
+        #   inc.persist
+        #
+        # @return [ Object ] The new integer value.
+        #
+        # @since 2.0.0
+        def persist
+          current = document[field] || 0
+          document[field] = current + value
+          document[field].tap do
+            document.collection.update(document._selector, operation("$inc"), options)
+            document.changes.delete(field.to_s)
+          end
+        end
+      end
+    end
+  end
+end