mongoid-ultra 9.0.0.0.alpha1

data/lib/mongoid/matcher/type.rb

@@ -0,0 +1,99 @@
+module Mongoid
+  module Matcher
+
+    # @see https://www.mongodb.com/docs/manual/reference/operator/query/type/
+    #
+    # @api private
+    module Type
+      module_function def matches?(exists, value, condition)
+        conditions = case condition
+        when Array
+          condition
+        when Integer
+          [condition]
+        else
+          raise Errors::InvalidQuery, "Unknown $type argument: #{condition}"
+        end
+        conditions.each do |condition|
+          if one_matches?(exists, value, condition)
+            return true
+          end
+        end
+        false
+      end
+
+      module_function def one_matches?(exists, value, condition)
+        case condition
+        when 1
+          # Double
+          Float === value
+        when 2
+          # String
+          String === value
+        when 3
+          # Object
+          Hash === value
+        when 4
+          # Array
+          Array === value
+        when 5
+          # Binary data
+          BSON::Binary === value
+        when 6
+          # Undefined
+          BSON::Undefined === value
+        when 7
+          # ObjectId
+          BSON::ObjectId === value
+        when 8
+          # Boolean
+          TrueClass === value || FalseClass === value
+        when 9
+          # Date
+          Date === value || Time === value || DateTime === value
+        when 10
+          # Null
+          exists && NilClass === value
+        when 11
+          # Regex
+          Regexp::Raw === value || ::Regexp === value
+        when 12
+          # DBPointer deprecated
+          BSON::DbPointer === value
+        when 13
+          # JavaScript
+          BSON::Code === value
+        when 14
+          # Symbol deprecated
+          Symbol === value || BSON::Symbol::Raw === value
+        when 15
+          # Javascript with code deprecated
+          BSON::CodeWithScope === value
+        when 16
+          # 32-bit int
+          BSON::Int32 === value || Integer === value && (-2**32..2**32-1).include?(value)
+        when 17
+          # Timestamp
+          BSON::Timestamp === value
+        when 18
+          # Long
+          BSON::Int64 === value ||
+            Integer === value &&
+              (-2**64..2**64-1).include?(value) &&
+              !(-2**32..2**32-1).include?(value)
+        when 19
+          # Decimal
+          BSON::Decimal128 === value
+        when -1
+          # minKey
+          BSON::MinKey === value
+        when 127
+          # maxKey
+          BSON::MaxKey === value
+        else
+          raise Errors::InvalidQuery, "Unknown $type argument: #{condition}"
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/matcher.rb

@@ -0,0 +1,115 @@
+module Mongoid
+
+  # @api private
+  module Matcher
+
+    # Extracts field values in the document at the specified key.
+    #
+    # The document can be a Hash or a model instance.
+    #
+    # The key is a valid MongoDB dot notation key. The following use cases are
+    # supported:
+    #
+    # - Simple field traversal (`foo`) - retrieves the field `foo` in the
+    #   current document.
+    # - Hash/embedded document field traversal (`foo.bar`) - retrieves the
+    #   field `foo` in the current document, then retrieves the field `bar`
+    #   from the value of `foo`. Each path segment could descend into an
+    #   embedded document or a hash field.
+    # - Array element retrieval (`foo.N`) - retrieves the Nth array element
+    #   from the field `foo` which must be an array. N must be a non-negative
+    #   integer.
+    # - Array traversal (`foo.bar`) - if `foo` is an array field, and
+    #   the elements of `foo` are hashes or embedded documents, this returns
+    #   an array of values of the `bar` field in each of the hashes in the
+    #   `foo` array.
+    #
+    # This method can return an individual field value in some document
+    # or an array of values from multiple documents. The array can be returned
+    # because a field value in the specified path is an array of primitive
+    # values (e.g. integers) or because a field value in the specified path
+    # is an array of documents (e.g. a one-to-many embedded association),
+    # in which case the leaf value may be a scalar for each individual document.
+    # If the leaf value is an array and a one-to-many association was traversed,
+    # the return value will be an array of arrays. Note that an individual
+    # field value can also be an array and this case is indistinguishable
+    # from and behaves identically to association traversal for the purposes
+    # of, for example, subsequent array element retrieval.
+    #
+    # @param [ Document | Hash ] document The document to extract from.
+    # @param [ String ] key The key path to extract.
+    #
+    # @return [ Object | Array ] Field value or values.
+    module_function def extract_attribute(document, key)
+      if document.respond_to?(:as_attributes, true)
+        # If a document has hash fields, as_attributes would keep those fields
+        # as Hash instances which do not offer indifferent access.
+        # Convert to BSON::Document to get indifferent access on hash fields.
+        document = BSON::Document.new(document.send(:as_attributes))
+      end
+
+      current = [document]
+
+      key.to_s.split('.').each do |field|
+        new = []
+        current.each do |doc|
+          case doc
+          when Hash
+            if doc.key?(field)
+              new << doc[field]
+            end
+          when Array
+            if (index = field.to_i).to_s == field
+              if doc.length > index
+                new << doc[index]
+              end
+            end
+            doc.each do |subdoc|
+              if Hash === subdoc
+                if subdoc.key?(field)
+                  new << subdoc[field]
+                end
+              end
+            end
+          end
+        end
+        current = new
+        break if current.empty?
+      end
+
+      current
+    end
+  end
+end
+
+require 'mongoid/matcher/all'
+require 'mongoid/matcher/and'
+require 'mongoid/matcher/bits'
+require 'mongoid/matcher/bits_all_clear'
+require 'mongoid/matcher/bits_all_set'
+require 'mongoid/matcher/bits_any_clear'
+require 'mongoid/matcher/bits_any_set'
+require 'mongoid/matcher/elem_match'
+require 'mongoid/matcher/elem_match_expression'
+require 'mongoid/matcher/eq'
+require 'mongoid/matcher/eq_impl'
+require 'mongoid/matcher/eq_impl_with_regexp'
+require 'mongoid/matcher/exists'
+require 'mongoid/matcher/expression'
+require 'mongoid/matcher/field_expression'
+require 'mongoid/matcher/gt'
+require 'mongoid/matcher/gte'
+require 'mongoid/matcher/in'
+require 'mongoid/matcher/lt'
+require 'mongoid/matcher/lte'
+require 'mongoid/matcher/mod'
+require 'mongoid/matcher/ne'
+require 'mongoid/matcher/nin'
+require 'mongoid/matcher/nor'
+require 'mongoid/matcher/not'
+require 'mongoid/matcher/or'
+require 'mongoid/matcher/regex'
+require 'mongoid/matcher/size'
+require 'mongoid/matcher/type'
+require 'mongoid/matcher/expression_operator'
+require 'mongoid/matcher/field_operator'

data/lib/mongoid/persistable/creatable.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Persistable
+
+    # Defines behavior for persistence operations that create new documents.
+    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.
+      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.
+      def atomic_inserts
+        { atomic_insert_modifier => { atomic_position => as_attributes }}
+      end
+
+      # Insert the embedded document.
+      #
+      # @api private
+      #
+      # @example Insert the document as embedded.
+      #   document.insert_as_embedded
+      #
+      # @return [ Document ] The document.
+      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_one(
+              positionally(selector, atomic_inserts),
+              session: _session)
+        end
+      end
+
+      # Insert the root document.
+      #
+      # @api private
+      #
+      # @example Insert the document as root.
+      #   document.insert_as_root
+      #
+      # @return [ Document ] The document.
+      def insert_as_root
+        collection.insert_one(as_attributes, session: _session)
+      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.
+      def post_process_insert
+        self.new_record = false
+        flag_descendants_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.
+      def prepare_insert(options = {})
+        raise Errors::ReadonlyDocument.new(self.class) if readonly? && !Mongoid.legacy_readonly
+        return self if performing_validations?(options) &&
+          invalid?(options[:context] || :create)
+        run_callbacks(:commit, with_children: true, skip_if: -> { in_transaction? }) do
+          run_callbacks(:save, with_children: false) do
+            run_callbacks(:create, with_children: false) do
+              run_callbacks(:persist_parent, with_children: false) do
+                _mongoid_run_child_callbacks(:save) do
+                  _mongoid_run_child_callbacks(:create) do
+                    result = yield(self)
+                    if !result.is_a?(Document) || result.errors.empty?
+                      post_process_insert
+                      post_process_persist(result, options)
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+        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).
+        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.
+        #
+        # @return [ Document | Array<Document> ] The newly created document(s).
+        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,136 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Persistable
+
+    # Defines behavior for persistence operations that delete documents.
+    module Deletable
+      extend ActiveSupport::Concern
+
+      # Remove the document from the database.
+      #
+      # @example Remove the document.
+      #   document.remove
+      #
+      # @param [ Hash ] options The options.
+      # @option options [ true | false ] :persist Whether to persist
+      #   the delete action.
+      # @option options [ true | false ] :suppress Whether to update
+      #   the parent document in-memory when deleting an embedded document.
+      #
+      # @return [ TrueClass ] True.
+      def delete(options = {})
+        prepare_delete do
+          unless options[:persist] == false
+            if embedded?
+              delete_as_embedded(options)
+            else
+              delete_as_root
+            end
+          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.
+      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.
+      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_one(
+              positionally(selector, atomic_deletes),
+              session: _session)
+        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.
+      def delete_as_root
+        collection.find(atomic_selector).delete_one(session: _session)
+        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.
+      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 [ true ] If the object was deleted successfully.
+      def prepare_delete
+        raise Errors::ReadonlyDocument.new(self.class) if readonly?
+        yield(self)
+        freeze
+        self.destroyed = 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.
+        def delete_all(conditions = {})
+          selector = hereditary? ? conditions.merge(discriminator_key.to_sym => discriminator_value) : conditions
+          where(selector).delete
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/persistable/destroyable.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Persistable
+
+    # Defines behavior for persistence operations that destroy documents.
+    module Destroyable
+      extend ActiveSupport::Concern
+
+      # Remove the document from the database with callbacks.
+      #
+      # @example Destroy a document.
+      #   document.destroy
+      #
+      # @param [ Hash ] options The options.
+      # @option options [ true | false ] :persist Whether to persist
+      #   the delete action. Callbacks will still be run even if false.
+      # @option options [ true | false ] :suppress Whether to update
+      #   the parent document in-memory when deleting an embedded document.
+      #
+      # @return [ true | false ] True if successful, false if not.
+      def destroy(options = nil)
+        raise Errors::ReadonlyDocument.new(self.class) if readonly?
+        self.flagged_for_destroy = true
+        result = run_callbacks(:commit, skip_if: -> { in_transaction? }) do
+          run_callbacks(:destroy) do
+            if catch(:abort) { apply_destroy_dependencies! }
+              delete(options || {}).tap do |res|
+                if res && in_transaction?
+                  Threaded.add_modified_document(_session, self)
+                end
+              end
+            else
+              false
+            end
+          end
+        end
+        self.flagged_for_destroy = false
+        result
+      end
+
+      # Remove the document from the database with callbacks. Raises
+      # an error if the document is not destroyed.
+      #
+      # @example Destroy a document.
+      #   document.destroy!
+      #
+      # @param [ Hash ] options The options.
+      # @option options [ true | false ] :persist Whether to persist
+      #   the delete action. Callbacks will still be run even if false.
+      # @option options [ true | false ] :suppress Whether to update
+      #   the parent document in-memory when deleting an embedded document.
+      #
+      # @return [ true ] Always true.
+      def destroy!(options = {})
+        destroy(options) || 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.
+        def destroy_all(conditions = nil)
+          where(conditions || {}).destroy
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/persistable/incrementable.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Persistable
+
+    # Defines behavior for $inc operations.
+    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 [ Document ] The document.
+      def inc(increments)
+        prepare_atomic_operation do |ops|
+          process_atomic_operations(increments) do |field, value|
+            increment = value.__to_inc__
+            current = attributes[field]
+            new_value = (current || 0) + increment
+            process_attribute field, new_value if executing_atomically?
+            attributes[field] = new_value
+            ops[atomic_attribute_name(field)] = increment
+          end
+          { "$inc" => ops } unless ops.empty?
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/persistable/logical.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Persistable
+
+    # Defines behavior for logical bitwise operations.
+    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 [ Document ] The document.
+      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
+            process_attribute field, value if executing_atomically?
+            attributes[field] = value
+            ops[atomic_attribute_name(field)] = values
+          end
+          { "$bit" => ops } unless ops.empty?
+        end
+      end
+    end
+  end
+end