mongoid 3.1.7 → 4.0.2

data/lib/mongoid/matchable.rb

@@ -0,0 +1,152 @@
+# encoding: utf-8
+require "mongoid/matchable/default"
+require "mongoid/matchable/all"
+require "mongoid/matchable/and"
+require "mongoid/matchable/exists"
+require "mongoid/matchable/gt"
+require "mongoid/matchable/gte"
+require "mongoid/matchable/in"
+require "mongoid/matchable/lt"
+require "mongoid/matchable/lte"
+require "mongoid/matchable/ne"
+require "mongoid/matchable/nin"
+require "mongoid/matchable/or"
+require "mongoid/matchable/size"
+
+module Mongoid
+
+  # This module contains all the behavior for ruby implementations of MongoDB
+  # selectors.
+  #
+  # @since 4.0.0
+  module Matchable
+    extend ActiveSupport::Concern
+
+    # Hash lookup for the matcher for a specific operation.
+    #
+    # @since 1.0.0
+    MATCHERS = {
+      "$all" => All,
+      "$and" => And,
+      "$exists" => Exists,
+      "$gt" => Gt,
+      "$gte" => Gte,
+      "$in" => In,
+      "$lt" => Lt,
+      "$lte" => Lte,
+      "$ne" => Ne,
+      "$nin" => Nin,
+      "$or" => Or,
+      "$size" => Size
+    }.with_indifferent_access.freeze
+
+    # Determines if this document has the attributes to match the supplied
+    # MongoDB selector. Used for matching on embedded associations.
+    #
+    # @example Does the document match?
+    #   document.matches?(:title => { "$in" => [ "test" ] })
+    #
+    # @param [ Hash ] selector The MongoDB selector.
+    #
+    # @return [ true, false ] True if matches, false if not.
+    #
+    # @since 1.0.0
+    def matches?(selector)
+      selector.each_pair do |key, value|
+        if value.is_a?(Hash)
+          value.each do |item|
+            return false unless matcher(self, key, Hash[*item]).matches?(Hash[*item])
+          end
+        else
+          return false unless matcher(self, key, value).matches?(value)
+        end
+      end
+      true
+    end
+
+    private
+
+    # Get the matcher for the supplied key and value. Will determine the class
+    # name from the key.
+    #
+    # @api private
+    #
+    # @example Get the matcher.
+    #   document.matcher(:title, { "$in" => [ "test" ] })
+    #
+    # @param [ Document ] document The document to check.
+    # @param [ Symbol, String ] key The field name.
+    # @param [ Object, Hash ] The value or selector.
+    #
+    # @return [ Matcher ] The matcher.
+    #
+    # @since 2.0.0.rc.7
+    def matcher(document, key, value)
+      Matchable.matcher(document, key, value)
+    end
+
+    class << self
+
+      # Get the matcher for the supplied key and value. Will determine the class
+      # name from the key.
+      #
+      # @api private
+      #
+      # @example Get the matcher.
+      #   document.matcher(:title, { "$in" => [ "test" ] })
+      #
+      # @param [ Document ] document The document to check.
+      # @param [ Symbol, String ] key The field name.
+      # @param [ Object, Hash ] The value or selector.
+      #
+      # @return [ Matcher ] The matcher.
+      #
+      # @since 2.0.0.rc.7
+      def matcher(document, key, value)
+        if value.is_a?(Hash)
+          matcher = MATCHERS[value.keys.first]
+          if matcher
+            matcher.new(extract_attribute(document, key))
+          else
+            Default.new(extract_attribute(document, key))
+          end
+        else
+          case key.to_s
+            when "$or" then Or.new(value, document)
+            when "$and" then And.new(value, document)
+            else Default.new(extract_attribute(document, key))
+          end
+        end
+      end
+
+      private
+
+      # Extract the attribute from the key, being smarter about dot notation.
+      #
+      # @api private
+      #
+      # @example Extract the attribute.
+      #   strategy.extract_attribute(doc, "info.field")
+      #
+      # @param [ Document ] document The document.
+      # @param [ String ] key The key.
+      #
+      # @return [ Object ] The value of the attribute.
+      #
+      # @since 2.2.1
+      def extract_attribute(document, key)
+        if (key_string = key.to_s) =~ /.+\..+/
+          key_string.split('.').inject(document.as_document) do |_attribs, _key|
+            if _attribs.is_a?(::Array)
+              _attribs.map { |doc| doc.try(:[], _key) }
+            else
+              _attribs.try(:[], _key)
+            end
+          end
+        else
+          document.attributes[key_string]
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/persistable/creatable.rb

@@ -0,0 +1,189 @@
+# encoding: utf-8
+module Mongoid
+  module Persistable
+
+    # Defines behaviour for persistence operations that create new documents.
+    #
+    # @since 4.0.0
+    module Creatable
+      extend ActiveSupport::Concern
+
+      # 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.
+      #
+      # @since 1.0.0
+      def insert(options = {})
+        prepare_insert(options) do
+          if embedded?
+            insert_as_embedded
+          else
+            insert_as_root
+          end
+        end
+      end
+
+      private
+
+      # Get the atomic insert for embedded documents, either a push or set.
+      #
+      # @api private
+      #
+      # @example Get the inserts.
+      #   document.inserts
+      #
+      # @return [ Hash ] The insert ops.
+      #
+      # @since 2.1.0
+      def atomic_inserts
+        { atomic_insert_modifier => { atomic_position => as_document }}
+      end
+
+      # Insert the embedded document.
+      #
+      # @api private
+      #
+      # @example Insert the document as embedded.
+      #   document.insert_as_embedded
+      #
+      # @return [ Document ] The document.
+      #
+      # @since 4.0.0
+      def insert_as_embedded
+        raise Errors::NoParent.new(self.class.name) unless _parent
+        if _parent.new_record?
+          _parent.insert
+        else
+          selector = _parent.atomic_selector
+          _root.collection.find(selector).update(positionally(selector, atomic_inserts))
+        end
+      end
+
+      # Insert the root document.
+      #
+      # @api private
+      #
+      # @example Insert the document as root.
+      #   document.insert_as_root
+      #
+      # @return [ Document ] The document.
+      #
+      # @since 4.0.0
+      def insert_as_root
+        collection.insert(as_document)
+      end
+
+      # Post process an insert, which sets the new record attribute to false
+      # and flags all the children as persisted.
+      #
+      # @api private
+      #
+      # @example Post process the insert.
+      #   document.post_process_insert
+      #
+      # @return [ true ] true.
+      #
+      # @since 4.0.0
+      def post_process_insert
+        self.new_record = false
+        flag_children_persisted
+        true
+      end
+
+      # Prepare the insert for execution. Validates and runs callbacks, etc.
+      #
+      # @api private
+      #
+      # @example Prepare for insertion.
+      #   document.prepare_insert do
+      #     collection.insert(as_document)
+      #   end
+      #
+      # @param [ Hash ] options The options.
+      #
+      # @return [ Document ] The document.
+      #
+      # @since 4.0.0
+      def prepare_insert(options = {})
+        return self if performing_validations?(options) &&
+          invalid?(options[:context] || :create)
+        result = run_callbacks(:save) do
+          run_callbacks(:create) do
+            yield(self)
+            post_process_insert
+          end
+        end
+        post_process_persist(result, options) and self
+      end
+
+      module ClassMethods
+
+        # 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")
+        #
+        # @example Create multiple new documents.
+        #   Person.create({ title: "Mr" }, { title: "Mrs" })
+        #
+        # @param [ Hash, Array ] attributes The attributes to create with, or an
+        #   Array of multiple attributes for multiple documents.
+        #
+        # @return [ Document, Array<Document> ] The newly created document(s).
+        #
+        # @since 1.0.0
+        def create(attributes = nil, &block)
+          _creating do
+            if attributes.is_a?(::Array)
+              attributes.map { |attrs| create(attrs, &block) }
+            else
+              doc = new(attributes, &block)
+              doc.save
+              doc
+            end
+          end
+        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")
+        #
+        # @example Create multiple new documents.
+        #   Person.create!({ title: "Mr" }, { title: "Mrs" })
+        #
+        # @param [ Hash, Array ] attributes The attributes to create with, or an
+        #   Array of multiple attributes for multiple documents.
+        # @param [ Hash ] options A mass-assignment protection options. Supports
+        #   :as and :without_protection
+        #
+        # @return [ Document, Array<Document> ] The newly created document(s).
+        #
+        # @since 1.0.0
+        def create!(attributes = nil, &block)
+          _creating do
+            if attributes.is_a?(::Array)
+              attributes.map { |attrs| create!(attrs, &block) }
+            else
+              doc = new(attributes, &block)
+              doc.fail_due_to_validation! unless doc.insert.errors.empty?
+              doc.fail_due_to_callback!(:create!) if doc.new_record?
+              doc
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/persistable/deletable.rb

@@ -0,0 +1,149 @@
+# 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 = {})
+        raise Errors::ReadonlyDocument.new(self.class) if readonly?
+        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,60 @@
+# 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 = nil)
+        raise Errors::ReadonlyDocument.new(self.class) if readonly?
+        self.flagged_for_destroy = true
+        result = run_callbacks(:destroy) { delete(options || {}) }
+        self.flagged_for_destroy = false
+        result
+      end
+
+      def destroy!(options = {})
+        destroy || raise(Errors::DocumentNotDestroyed.new(id, self.class))
+      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