mongoid 3.1.7 → 4.0.0.alpha1

data/lib/mongoid/persistable/deletable.rb

@@ -0,0 +1,148 @@
+# encoding: utf-8
+module Mongoid
+  module Persistable
+
+    # Defines behaviour for persistence operations that delete documents.
+    #
+    # @since 4.0.0
+    module Deletable
+      extend ActiveSupport::Concern
+
+      # Remove the document from the database.
+      #
+      # @example Remove the document.
+      #   document.remove
+      #
+      # @param [ Hash ] options Options to pass to remove.
+      #
+      # @return [ TrueClass ] True.
+      #
+      # @since 1.0.0
+      def delete(options = {})
+        prepare_delete do
+          if embedded?
+            delete_as_embedded(options)
+          else
+            delete_as_root
+          end
+        end
+      end
+      alias :remove :delete
+
+      private
+
+      # Get the atomic deletes for the operation.
+      #
+      # @api private
+      #
+      # @example Get the atomic deletes.
+      #   document.atomic_deletes
+      #
+      # @return [ Hash ] The atomic deletes.
+      #
+      # @since 4.0.0
+      def atomic_deletes
+        { atomic_delete_modifier => { atomic_path => _index ? { "_id" => id } : true }}
+      end
+
+      # Delete the embedded document.
+      #
+      # @api private
+      #
+      # @example Delete the embedded document.
+      #   document.delete_as_embedded
+      #
+      # @param [ Hash ] options The deletion options.
+      #
+      # @return [ true ] If the operation succeeded.
+      #
+      # @since 4.0.0
+      def delete_as_embedded(options = {})
+        _parent.remove_child(self) if notifying_parent?(options)
+        if _parent.persisted?
+          selector = _parent.atomic_selector
+          _root.collection.find(selector).update(positionally(selector, atomic_deletes))
+        end
+        true
+      end
+
+      # Delete the root document.
+      #
+      # @api private
+      #
+      # @example Delete the root document.
+      #   document.delete_as_root
+      #
+      # @return [ true ] If the document was removed.
+      #
+      # @since 4.0.0
+      def delete_as_root
+        collection.find(atomic_selector).remove
+        true
+      end
+
+      # Are we needing to notify the parent document of the deletion.
+      #
+      # @api private
+      #
+      # @example Are we notifying the parent.
+      #   document.notifying_parent?(suppress: true)
+      #
+      # @param [ Hash ] options The delete options.
+      #
+      # @return [ true, false ] If the parent should be notified.
+      #
+      # @since 4.0.0
+      def notifying_parent?(options = {})
+        !options.delete(:suppress)
+      end
+
+      # Prepare the delete operation.
+      #
+      # @api private
+      #
+      # @example Prepare the delete operation.
+      #   document.prepare_delete do
+      #     collection.find(atomic_selector).remove
+      #   end
+      #
+      # @return [ Object ] The result of the block.
+      #
+      # @since 4.0.0
+      def prepare_delete
+        cascade!
+        yield(self)
+        freeze
+        self.destroyed = true
+        true
+      end
+
+      module ClassMethods
+
+        # 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({ :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.
+        #
+        # @since 1.0.0
+        def delete_all(conditions = nil)
+          selector = conditions || {}
+          selector.merge!(_type: name) if hereditary?
+          coll = collection
+          deleted = coll.find(selector).count
+          coll.find(selector).remove_all
+          deleted
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/persistable/destroyable.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+module Mongoid
+  module Persistable
+
+    # Defines behaviour for persistence operations that destroy documents.
+    #
+    # @since 4.0.0
+    module Destroyable
+      extend ActiveSupport::Concern
+
+      # Remove the document from the database 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.
+      #
+      # @since 1.0.0
+      def destroy(options = {})
+        self.flagged_for_destroy = true
+        result = run_callbacks(:destroy) { delete(options) }
+        self.flagged_for_destroy = false
+        result
+      end
+
+      module ClassMethods
+
+        # 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({ :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.
+        #
+        # @since 1.0.0
+        def destroy_all(conditions = nil)
+          selector = conditions || {}
+          documents = where(selector)
+          destroyed = documents.count
+          documents.each { |doc| doc.destroy }
+          destroyed
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/persistable/incrementable.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+module Mongoid
+  module Persistable
+
+    # Defines behaviour for $inc operations.
+    #
+    # @since 4.0.0
+    module Incrementable
+      extend ActiveSupport::Concern
+
+      # Increment the provided fields by the corresponding values. Values can
+      # be positive or negative, and if no value exists for the field it will
+      # be set with the provided value.
+      #
+      # @example Increment the fields.
+      #   document.inc(score: 10, place: 1, lives: -10)
+      #
+      # @param [ Hash ] increments The field/inc increment pairs.
+      #
+      # @return [ true, false ] If the increment succeeded.
+      #
+      # @since 4.0.0
+      def inc(increments)
+        prepare_atomic_operation do |ops|
+          process_atomic_operations(increments) do |field, value|
+            increment = value.__to_inc__
+            current = attributes[field]
+            attributes[field] = (current || 0) + increment
+            ops[atomic_attribute_name(field)] = increment
+          end
+          { "$inc" => ops }
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/persistable/logical.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+module Mongoid
+  module Persistable
+
+    # Defines behaviour for logical bitwise operations.
+    #
+    # @since 4.0.0
+    module Logical
+      extend ActiveSupport::Concern
+
+      # Performs an atomic $bit operation on the field with the provided hash
+      # of bitwise ops to execute in order.
+      #
+      # @example Execute the bitwise operations.
+      #   person.bit(age: { :and => 12 }, val: { and: 10, or: 12 })
+      #
+      # @param [ Hash ] operations The bitwise operations.
+      #
+      # @return [ true, false ] If the operation succeeded.
+      #
+      # @since 4.0.0
+      def bit(operations)
+        prepare_atomic_operation do |ops|
+          process_atomic_operations(operations) do |field, values|
+            value = attributes[field]
+            values.each do |op, val|
+              value = value & val if op.to_s == "and"
+              value = value | val if op.to_s == "or"
+            end
+            attributes[field] = value
+            ops[atomic_attribute_name(field)] = values
+          end
+          { "$bit" => ops }
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/persistable/poppable.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+module Mongoid
+  module Persistable
+
+    # Defines behaviour for $pop operations.
+    #
+    # @since 4.0.0
+    module Poppable
+      extend ActiveSupport::Concern
+
+      # Pop or shift items from arrays using the $pop operator.
+      #
+      # @example Pop items from an array.
+      #   document.pop(aliases: 1)
+      #
+      # @example Shift items in the array.
+      #   document.pop(aliases: -1)
+      #
+      # @example Multiple pops in one call.
+      #   document.pop(names: 1, aliases: 1)
+      #
+      # @param [ Hash ] pops The field/value pop operations.
+      #
+      # @return [ true, false ] If the operation succeeded.
+      #
+      # @since 4.0.0
+      def pop(pops)
+        prepare_atomic_operation do |ops|
+          process_atomic_operations(pops) do |field, value|
+            values = send(field)
+            value > 0 ? values.pop : values.shift
+            ops[atomic_attribute_name(field)] = value
+          end
+          { "$pop" => ops }
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/persistable/pullable.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+module Mongoid
+  module Persistable
+
+    # Defines behaviour for $pull and $pullAll operations.
+    #
+    # @since 4.0.0
+    module Pullable
+      extend ActiveSupport::Concern
+
+      # Pull single values from the provided arrays.
+      #
+      # @example Pull a value from the array.
+      #   document.pull(names: "Jeff", levels: 5)
+      #
+      # @note If duplicate values are found they will all be pulled.
+      #
+      # @param [ Hash ] pulls The field/value pull pairs.
+      #
+      # @return [ true, false ] If the operation succeeded.
+      #
+      # @since 4.0.0
+      def pull(pulls)
+        prepare_atomic_operation do |ops|
+          process_atomic_operations(pulls) do |field, value|
+            (send(field) || []).delete(value)
+            ops[atomic_attribute_name(field)] = value
+          end
+          { "$pull" => ops }
+        end
+      end
+
+      # Pull multiple values from the provided array fields.
+      #
+      # @example Pull values from the arrays.
+      #   document.pull_all(names: [ "Jeff", "Bob" ], levels: [ 5, 6 ])
+      #
+      # @param [ Hash ] pulls The pull all operations.
+      #
+      # @return [ true, false ] If the operation succeeded.
+      #
+      # @since 4.0.0
+      def pull_all(pulls)
+        prepare_atomic_operation do |ops|
+          process_atomic_operations(pulls) do |field, value|
+            existing = send(field) || []
+            value.each{ |val| existing.delete(val) }
+            ops[atomic_attribute_name(field)] = value
+          end
+          { "$pullAll" => ops }
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/persistable/pushable.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+module Mongoid
+  module Persistable
+
+    # Defines behaviour for $push and $addToSet operations.
+    #
+    # @since 4.0.0
+    module Pushable
+      extend ActiveSupport::Concern
+
+      # Add the single values to the arrays only if the value does not already
+      # exist in the array.
+      #
+      # @example Add the values to the sets.
+      #   document.add_to_set(names: "James", aliases: "Bond")
+      #
+      # @param [ Hash ] adds The field/value pairs to add.
+      #
+      # @return [ true, false ] If the operation succeeded.
+      #
+      # @since 4.0.0
+      def add_to_set(adds)
+        prepare_atomic_operation do |ops|
+          process_atomic_operations(adds) do |field, value|
+            existing = send(field) || (attributes[field] ||= [])
+            values = [ value ].flatten(1)
+            values.each do |val|
+              existing.push(val) unless existing.include?(val)
+            end
+            ops[atomic_attribute_name(field)] = { "$each" => values }
+          end
+          { "$addToSet" => ops }
+        end
+      end
+
+      # Push a single value or multiple values onto arrays.
+      #
+      # @example Push a single value onto arrays.
+      #   document.push(names: "James", aliases: "007")
+      #
+      # @example Push multiple values onto arrays.
+      #   document.push(names: [ "James", "Bond" ])
+      #
+      # @param [ Hash ] pushes The $push operations.
+      #
+      # @return [ true, false ] If the operation succeeded.
+      #
+      # @since 4.0.0
+      def push(pushes)
+        prepare_atomic_operation do |ops|
+          process_atomic_operations(pushes) do |field, value|
+            existing = send(field) || (attributes[field] ||= [])
+            values = [ value ].flatten(1)
+            values.each{ |val| existing.push(val) }
+            ops[atomic_attribute_name(field)] = { "$each" => values }
+          end
+          { "$push" => ops }
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/persistable/renamable.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+module Mongoid
+  module Persistable
+
+    # Defines behaviour for $rename operations.
+    #
+    # @since 4.0.0
+    module Renamable
+      extend ActiveSupport::Concern
+
+      # Rename fields from one value to another via $rename.
+      #
+      # @example Rename the fields.
+      #   document.rename(title: "salutation", name: "nombre")
+      #
+      # @note This does not work for fields in embeds many relations.
+      #
+      # @param [ Hash ] renames The rename pairs of old name/new name.
+      #
+      # @return [ true, false ] If the rename suceeded.
+      #
+      # @since 4.0.0
+      def rename(renames)
+        prepare_atomic_operation do |ops|
+          process_atomic_operations(renames) do |old_field, new_field|
+            new_name = new_field.to_s
+            attributes[new_name] = attributes.delete(old_field)
+            ops[atomic_attribute_name(old_field)] = atomic_attribute_name(new_name)
+          end
+          { "$rename" => ops }
+        end
+      end
+    end
+  end
+end