mongoid_heroku_stable 4.0.0

data/lib/mongoid/matchable/lt.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+module Mongoid
+  module Matchable
+
+    # Performs less than matching.
+    class Lt < Default
+
+      # Return true if the attribute is less than the value.
+      #
+      # @example Do the values match?
+      #   matcher.matches?({ :key => 10 })
+      #
+      # @param [ Hash ] value The values to check.
+      #
+      # @return [ true, false ] If a value exists.
+      def matches?(value)
+        determine(value, :<)
+      end
+    end
+  end
+end

data/lib/mongoid/matchable/lte.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+module Mongoid
+  module Matchable
+
+    # Performs less than or equal to matching.
+    class Lte < Default
+
+      # Return true if the attribute is less than or equal to the value.
+      #
+      # @example Do the values match?
+      #   matcher.matches?({ :key => 10 })
+      #
+      # @param [ Hash ] value The values to check.
+      #
+      # @return [ true, false ] If a value exists.
+      def matches?(value)
+        determine(value, :<=)
+      end
+    end
+  end
+end

data/lib/mongoid/matchable/ne.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+module Mongoid
+  module Matchable
+
+    # Performs non-equivalency checks.
+    class Ne < Default
+
+      # Return true if the attribute and first value are not equal.
+      #
+      # @example Do the values match?
+      #   matcher.matches?({ :key => 10 })
+      #
+      # @param [ Hash ] value The values to check.
+      #
+      # @return [ true, false ] If a value exists.
+      def matches?(value)
+        @attribute != value.values.first
+      end
+    end
+  end
+end

data/lib/mongoid/matchable/nin.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+module Mongoid
+  module Matchable
+
+    # Performs not in checking.
+    class Nin < Default
+
+      # Return true if the attribute is not in the value list.
+      #
+      # @example Do the values match?
+      #   matcher.matches?({ :key => 10 })
+      #
+      # @param [ Hash ] value The values to check.
+      #
+      # @return [ true, false ] If a value exists.
+      def matches?(value)
+        Array.wrap(@attribute).none? { |e| value.values.first.include?(e) }
+      end
+    end
+  end
+end

data/lib/mongoid/matchable/or.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+module Mongoid
+  module Matchable
+
+    # Defines behavior for handling $or expressions in embedded documents.
+    class Or < Default
+
+      # Does the supplied query match the attribute?
+      #
+      # @example Does this match?
+      #   matcher.matches?("$or" => [ { field => value } ])
+      #
+      # @param [ Array ] conditions The or expression.
+      #
+      # @return [ true, false ] True if matches, false if not.
+      #
+      # @since 2.0.0.rc.7
+      def matches?(conditions)
+        conditions.each do |condition|
+          res = true
+          condition.keys.each do |k|
+            key = k
+            value = condition[k]
+            res &&= Matchable.matcher(document, key, value).matches?(value)
+            break unless res
+          end
+          return res if res
+        end
+        return false
+      end
+    end
+  end
+end

data/lib/mongoid/matchable/size.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+module Mongoid
+  module Matchable
+
+    # Performs size checking.
+    class Size < Default
+
+      # Return true if the attribute size is equal to the first value.
+      #
+      # @example Do the values match?
+      #   matcher.matches?({ :key => 10 })
+      #
+      # @param [ Hash ] value The values to check.
+      #
+      # @return [ true, false ] If a value exists.
+      def matches?(value)
+        @attribute.size == value.values.first
+      end
+    end
+  end
+end

data/lib/mongoid/persistable.rb

@@ -0,0 +1,207 @@
+# encoding: utf-8
+require "mongoid/persistable/creatable"
+require "mongoid/persistable/deletable"
+require "mongoid/persistable/destroyable"
+require "mongoid/persistable/incrementable"
+require "mongoid/persistable/logical"
+require "mongoid/persistable/poppable"
+require "mongoid/persistable/pullable"
+require "mongoid/persistable/pushable"
+require "mongoid/persistable/renamable"
+require "mongoid/persistable/savable"
+require "mongoid/persistable/settable"
+require "mongoid/persistable/updatable"
+require "mongoid/persistable/upsertable"
+require "mongoid/persistable/unsettable"
+
+module Mongoid
+
+  # Contains general behaviour for persistence operations.
+  #
+  # @since 2.0.0
+  module Persistable
+    extend ActiveSupport::Concern
+    include Creatable
+    include Deletable
+    include Destroyable
+    include Incrementable
+    include Logical
+    include Poppable
+    include Positional
+    include Pullable
+    include Pushable
+    include Renamable
+    include Savable
+    include Settable
+    include Updatable
+    include Upsertable
+    include Unsettable
+
+    # Execute operations atomically (in a single database call) for everything
+    # that would happen inside the block.
+    #
+    # @example Execute the operations atomically.
+    #   document.atomically do
+    #     document.set(name: "Tool").inc(likes: 10)
+    #   end
+    #
+    # @return [ true, false ] If the operation succeeded.
+    #
+    # @since 4.0.0
+    def atomically
+      begin
+        @atomic_updates_to_execute = {}
+        yield(self) if block_given?
+        persist_atomic_operations(@atomic_updates_to_execute)
+        true
+      ensure
+        @atomic_updates_to_execute = nil
+      end
+    end
+
+    # Raise an error if validation failed.
+    #
+    # @example Raise the validation error.
+    #   Person.fail_due_to_validation!(person)
+    #
+    # @param [ Document ] document The document to fail.
+    #
+    # @raise [ Errors::Validations ] The validation error.
+    #
+    # @since 4.0.0
+    def fail_due_to_validation!
+      raise Errors::Validations.new(self)
+    end
+
+    # Raise an error if a callback failed.
+    #
+    # @example Raise the callback error.
+    #   Person.fail_due_to_callback!(person, :create!)
+    #
+    # @param [ Document ] document The document to fail.
+    # @param [ Symbol ] method The method being called.
+    #
+    # @raise [ Errors::Callback ] The callback error.
+    #
+    # @since 4.0.0
+    def fail_due_to_callback!(method)
+      raise Errors::Callback.new(self.class, method)
+    end
+
+    private
+
+    # Are we executing an atomically block on the current document?
+    #
+    # @api private
+    #
+    # @example Are we executing atomically?
+    #   document.executing_atomically?
+    #
+    # @return [ true, false ] If we are current executing atomically.
+    #
+    # @since 4.0.0
+    def executing_atomically?
+      !@atomic_updates_to_execute.nil?
+    end
+
+    # Post process the persistence operation.
+    #
+    # @api private
+    #
+    # @example Post process the persistence operation.
+    #   document.post_process_persist(true)
+    #
+    # @param [ Object ] result The result of the operation.
+    # @param [ Hash ] options The options.
+    #
+    # @return [ true ] true.
+    #
+    # @since 4.0.0
+    def post_process_persist(result, options = {})
+      post_persist unless result == false
+      errors.clear unless performing_validations?(options)
+      true
+    end
+
+    # Prepare an atomic persistence operation. Yields an empty hash to be sent
+    # to the update.
+    #
+    # @api private
+    #
+    # @example Prepare the atomic operation.
+    #   document.prepare_atomic_operation do |coll, selector, opts|
+    #     ...
+    #   end
+    #
+    # @return [ Object ] The result of the operation.
+    #
+    # @since 4.0.0
+    def prepare_atomic_operation
+      # @todo: Check if the document is persisted here.
+      operations = yield({})
+      persist_or_delay_atomic_operation(operations)
+      self
+    end
+
+    # Process the atomic operations - this handles the common behaviour of
+    # iterating through each op, getting the aliased field name, and removing
+    # appropriate dirty changes.
+    #
+    # @api private
+    #
+    # @example Process the atomic operations.
+    #   document.process_atomic_operations(pulls) do |field, value|
+    #     ...
+    #   end
+    #
+    # @param [ Hash ] operations The atomic operations.
+    #
+    # @return [ Hash ] The operations.
+    #
+    # @since 4.0.0
+    def process_atomic_operations(operations)
+      operations.each do |field, value|
+        normalized = database_field_name(field)
+        yield(normalized, value)
+        remove_change(normalized)
+      end
+    end
+
+    # If we are in an atomically block, add the operations to the delayed group,
+    # otherwise persist immediately.
+    #
+    # @api private
+    #
+    # @example Persist immediately or delay the operations.
+    #   document.persist_or_delay_atomic_operation(ops)
+    #
+    # @param [ Hash ] operation The operation.
+    #
+    # @since 4.0.0
+    def persist_or_delay_atomic_operation(operation)
+      if executing_atomically?
+        operation.each do |(name, hash)|
+          @atomic_updates_to_execute[name] ||= {}
+          @atomic_updates_to_execute[name].merge!(hash)
+        end
+      else
+        persist_atomic_operations(operation)
+      end
+    end
+
+    # Persist the atomic operations.
+    #
+    # @api private
+    #
+    # @example Persist the atomic operations.
+    #   persist_atomic_operations(ops)
+    #
+    # @param [ Hash ] operations The atomic operations.
+    #
+    # @since 4.0.0
+    def persist_atomic_operations(operations)
+      selector = atomic_selector
+      _root.collection.find(selector).update(positionally(selector, operations))
+    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)
+        IdentityMap.set(self)
+      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?(: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