mongoid_heroku_stable 4.0.0

data/lib/mongoid/criteria/findable.rb

@@ -0,0 +1,179 @@
+# encoding: utf-8
+module Mongoid
+  class Criteria
+    module Findable
+
+      # Execute the criteria or raise an error if no documents found.
+      #
+      # @example Execute or raise
+      #   criteria.execute_or_raise(id)
+      #
+      # @param [ Object ] args The arguments passed.
+      #
+      # @raise [ Errors::DocumentNotFound ] If nothing returned.
+      #
+      # @return [ Document, Array<Document> ] The document(s).
+      #
+      # @since 2.0.0
+      def execute_or_raise(ids, multi)
+        result = multiple_from_map_or_db(ids)
+        check_for_missing_documents!(result, ids)
+        multi ? result : result.first
+      end
+
+      # Find the matchind document(s) in the criteria for the provided ids.
+      #
+      # @example Find by an id.
+      #   criteria.find(Moped::BSON::ObjectId.new)
+      #
+      # @example Find by multiple ids.
+      #   criteria.find([ Moped::BSON::ObjectId.new, Moped::BSON::ObjectId.new ])
+      #
+      # @param [ Array<Moped::BSON::ObjectId> ] args The ids to search for.
+      #
+      # @return [ Array<Document>, Document ] The matching document(s).
+      #
+      # @since 1.0.0
+      def find(*args)
+        ids = args.__find_args__
+        raise_invalid if ids.any?(&:nil?)
+        for_ids(ids).execute_or_raise(ids, args.multi_arged?)
+      end
+
+      # Adds a criterion to the +Criteria+ that specifies an id that must be matched.
+      #
+      # @example Add a single id criteria.
+      #   criteria.for_ids([ 1 ])
+      #
+      # @example Add multiple id criteria.
+      #   criteria.for_ids([ 1, 2 ])
+      #
+      # @param [ Array ] ids The array of ids.
+      #
+      # @return [ Criteria ] The cloned criteria.
+      def for_ids(ids)
+        ids = mongoize_ids(ids)
+        if ids.size > 1
+          send(id_finder, { _id: { "$in" => ids }})
+        else
+          send(id_finder, { _id: ids.first })
+        end
+      end
+
+      # Get the document from the identity map, and if not found hit the
+      # database.
+      #
+      # @example Get the document from the map or criteria.
+      #   criteria.from_map_or_db
+      #
+      # @return [ Document ] The found document.
+      #
+      # @since 2.2.1
+      def from_map_or_db
+        id = extract_id
+        id = klass.fields["_id"].mongoize(id) if id
+        doc = IdentityMap.get(klass, id || selector_with_type_selection)
+        return nil if doc == {}
+        doc && doc.matches?(selector) ? doc : first
+      end
+
+      # Get the documents from the identity map, and if not found hit the
+      # database.
+      #
+      # @example Get the documents from the map or criteria.
+      #   criteria.multiple_from_map_or_db(ids)
+      #
+      # @param [ ids ] The searched ids.
+      #
+      # @return [ Array<Document> ] The found documents.
+      def multiple_from_map_or_db(ids)
+        return entries if embedded?
+        ids = mongoize_ids(ids)
+        result = from_identity_map(ids)
+        ids.empty? ? result : result + from_database(ids)
+      end
+
+      private
+
+      # Get the finder used to generate the id query.
+      #
+      # @api private
+      #
+      # @example Get the id finder.
+      #   criteria.id_finder
+      #
+      # @return [ Symbol ] The name of the finder method.
+      #
+      # @since 3.1.0
+      def id_finder
+        @id_finder ||= extract_id ? :all_of : :where
+      end
+
+      # Get documents from the database only.
+      #
+      # @api private
+      #
+      # @example Get documents from the database.
+      #   criteria.from_database(ids)
+      #
+      # @param [ Array<Object> ] ids The ids to fetch with.
+      #
+      # @return [ Array<Document> ] The matching documents.
+      #
+      # @since 3.0.0
+      def from_database(ids)
+        (ids.size > 1 ? any_in(id: ids) : where(id: ids.first)).entries
+      end
+
+      # Get documents from the identity map only.
+      #
+      # @api private
+      #
+      # @example Get documents from the identity map.
+      #   criteria.from_identity_map(ids)
+      #
+      # @param [ Array<Object> ] ids The ids to fetch with.
+      #
+      # @return [ Array<Document> ] The matching documents.
+      #
+      # @since 3.0.0
+      def from_identity_map(ids)
+        result = []
+        selection = selector_with_type_selection
+        ids.reject! do |id|
+          doc = IdentityMap.get(klass, id)
+          doc && doc.matches?(selection) ? result.push(doc) : false
+        end
+        result
+      end
+
+      # Convert all the ids to their proper types.
+      #
+      # @api private
+      #
+      # @example Convert the ids.
+      #   criteria.mongoize_ids(ids)
+      #
+      # @param [ Array<Object> ] ids The ids to convert.
+      #
+      # @return [ Array<Object> ] The converted ids.
+      #
+      # @since 3.0.0
+      def mongoize_ids(ids)
+        ids.map{ |id| klass.fields["_id"].mongoize(id) }
+      end
+
+      # Convenience method of raising an invalid options error.
+      #
+      # @example Raise the error.
+      #   criteria.raise_invalid
+      #
+      # @raise [ Errors::InvalidOptions ] The error.
+      #
+      # @since 2.0.0
+      def raise_invalid
+        raise Errors::InvalidFind.new
+      end
+    end
+  end
+end

data/lib/mongoid/criteria/inspectable.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+module Mongoid
+  class Criteria
+    module Inspectable
+
+      # Get a pretty string representation of the criteria, including the
+      # selector, options, matching count and documents for inspection.
+      #
+      # @example Inspect the criteria.
+      #   criteria.inspect
+      #
+      # @return [ String ] The inspection string.
+      #
+      # @since 1.0.0
+      def inspect
+%Q{#<Mongoid::Criteria
+  selector: #{selector.inspect}
+  options:  #{options.inspect}
+  class:    #{klass}
+  embedded: #{embedded?}>
+}
+      end
+    end
+  end
+end

data/lib/mongoid/criteria/marshalable.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+module Mongoid
+  class Criteria
+    module Marshalable
+
+      # Provides the data needed to Marshal.dump a criteria.
+      #
+      # @example Dump the criteria.
+      #   Marshal.dump(criteria)
+      #
+      # @return [ Array<Object> ] The dumped data.
+      #
+      # @since 3.0.15
+      def marshal_dump
+        data = [ klass, driver, inclusions, documents, strategy, negating ]
+        data.push(scoping_options).push(dump_hash(:selector)).push(dump_hash(:options))
+      end
+
+      # Resets the criteria object after a Marshal.load
+      #
+      # @example Load the criteria.
+      #   Marshal.load(criteria)
+      #
+      # @param [ Array ] data The raw data.
+      #
+      # @since 3.0.15
+      def marshal_load(data)
+        @scoping_options, raw_selector, raw_options = data.pop(3)
+        @klass, @driver, @inclusions, @documents, @strategy, @negating = data
+        @selector = load_hash(Origin::Selector, raw_selector)
+        @options = load_hash(Origin::Options, raw_options)
+      end
+
+      private
+
+      def dump_hash(name)
+        send(name).inject({}) do |raw, (key, value)|
+          raw[key] = value
+          raw
+        end
+      end
+
+      def load_hash(hash_class, raw)
+        hash = hash_class.new(klass.aliased_fields, klass.fields)
+        hash.merge!(raw)
+        hash
+      end
+    end
+  end
+end

data/lib/mongoid/criteria/modifiable.rb

@@ -0,0 +1,189 @@
+# encoding: utf-8
+module Mongoid
+  class Criteria
+    module Modifiable
+
+      # Build a document given the selector and return it.
+      # Complex criteria, such as $in and $or operations will get ignored.
+      #
+      # @example build the document.
+      #   Person.where(:title => "Sir").build
+      #
+      # @example Build with selectors getting ignored.
+      #   Person.where(:age.gt => 5).build
+      #
+      # @return [ Document ] A non-persisted document.
+      #
+      # @since 2.0.0
+      def build(attrs = {}, &block)
+        create_document(:new, attrs, &block)
+      end
+      alias :new :build
+
+      # Create a document in the database given the selector and return it.
+      # Complex criteria, such as $in and $or operations will get ignored.
+      #
+      # @example Create the document.
+      #   Person.where(:title => "Sir").create
+      #
+      # @example Create with selectors getting ignored.
+      #   Person.where(:age.gt => 5).create
+      #
+      # @return [ Document ] A newly created document.
+      #
+      # @since 2.0.0.rc.1
+      def create(attrs = {}, &block)
+        create_document(:create, attrs, &block)
+      end
+
+      # Create a document in the database given the selector and return it.
+      # Complex criteria, such as $in and $or operations will get ignored.
+      # If validation fails, an error will be raised.
+      #
+      # @example Create the document.
+      #   Person.where(:title => "Sir").create
+      #
+      # @example Create with selectors getting ignored.
+      #   Person.where(:age.gt => 5).create
+      #
+      # @raise [ Errors::Validations ] on a validation error.
+      #
+      # @return [ Document ] A newly created document.
+      #
+      # @since 3.0.0
+      def create!(attrs = {}, &block)
+        create_document(:create!, attrs, &block)
+      end
+
+      # Find the first +Document+ given the conditions, or creates a new document
+      # with the conditions that were supplied.
+      #
+      # @example Find or create the document.
+      #   Person.find_or_create_by(:attribute => "value")
+      #
+      # @param [ Hash ] attrs The attributes to check.
+      #
+      # @return [ Document ] A matching or newly created document.
+      def find_or_create_by(attrs = {}, &block)
+        find_or(:create, attrs, &block)
+      end
+
+      # Find the first +Document+ given the conditions, or initializes a new document
+      # with the conditions that were supplied.
+      #
+      # @example Find or initialize the document.
+      #   Person.find_or_initialize_by(:attribute => "value")
+      #
+      # @param [ Hash ] attrs The attributes to check.
+      #
+      # @return [ Document ] A matching or newly initialized document.
+      def find_or_initialize_by(attrs = {}, &block)
+        find_or(:new, attrs, &block)
+      end
+
+      # Find the first +Document+, or creates a new document
+      # with the conditions that were supplied plus attributes.
+      #
+      # @example First or create the document.
+      #   Person.where(name: "Jon").first_or_create(attribute: "value")
+      #
+      # @param [ Hash ] attrs The additional attributes to add.
+      #
+      # @return [ Document ] A matching or newly created document.
+      #
+      # @since 3.1.0
+      def first_or_create(attrs = nil, &block)
+        first_or(:create, attrs, &block)
+      end
+
+      # Find the first +Document+, or creates a new document
+      # with the conditions that were supplied plus attributes and will
+      # raise an error if validation fails.
+      #
+      # @example First or create the document.
+      #   Person.where(name: "Jon").first_or_create!(attribute: "value")
+      #
+      # @param [ Hash ] attrs The additional attributes to add.
+      #
+      # @return [ Document ] A matching or newly created document.
+      #
+      # @since 3.1.0
+      def first_or_create!(attrs = nil, &block)
+        first_or(:create!, attrs, &block)
+      end
+
+      # Find the first +Document+, or initializes a new document
+      # with the conditions that were supplied plus attributes.
+      #
+      # @example First or initialize the document.
+      #   Person.where(name: "Jon").first_or_initialize(attribute: "value")
+      #
+      # @param [ Hash ] attrs The additional attributes to add.
+      #
+      # @return [ Document ] A matching or newly initialized document.
+      #
+      # @since 3.1.0
+      def first_or_initialize(attrs = nil, &block)
+        first_or(:new, attrs, &block)
+      end
+
+      private
+
+      # Create a document given the provided method and attributes from the
+      # existing selector.
+      #
+      # @api private
+      #
+      # @example Create a new document.
+      #   criteria.create_document(:new, {})
+      #
+      # @param [ Symbol ] method Either :new or :create.
+      # @param [ Hash ] attrs Additional attributes to use.
+      #
+      # @return [ Document ] The new or saved document.
+      #
+      # @since 3.0.0
+      def create_document(method, attrs = nil, &block)
+        klass.__send__(method,
+          selector.reduce(attrs || {}) do |hash, (key, value)|
+            unless key.to_s =~ /\$/ || value.is_a?(Hash)
+              hash[key] = value
+            end
+            hash
+          end, &block)
+      end
+
+      # Find the first object or create/initialize it.
+      #
+      # @api private
+      #
+      # @example Find or perform an action.
+      #   Person.find_or(:create, :name => "Dev")
+      #
+      # @param [ Symbol ] method The method to invoke.
+      # @param [ Hash ] attrs The attributes to query or set.
+      #
+      # @return [ Document ] The first or new document.
+      def find_or(method, attrs = {}, &block)
+        where(attrs).first || send(method, attrs, &block)
+      end
+
+      # Find the first document or create/initialize it.
+      #
+      # @api private
+      #
+      # @example First or perform an action.
+      #   Person.first_or(:create, :name => "Dev")
+      #
+      # @param [ Symbol ] method The method to invoke.
+      # @param [ Hash ] attrs The attributes to query or set.
+      #
+      # @return [ Document ] The first or new document.
+      #
+      # @since 3.1.0
+      def first_or(method, attrs = {}, &block)
+        first || create_document(method, attrs, &block)
+      end
+    end
+  end
+end

data/lib/mongoid/criteria/scopable.rb

@@ -0,0 +1,158 @@
+# encoding: utf-8
+module Mongoid
+  class Criteria
+    module Scopable
+
+      # Applies the default scope to the criteria.
+      #
+      # @example Apply the default scope.
+      #   criteria.apply_default_scope
+      #
+      # @return [ Criteria ] The criteria.
+      #
+      # @since 3.0.0
+      def apply_default_scope
+        klass.without_default_scope do
+          merge!(klass.default_scoping.call)
+        end
+        self.scoping_options = true, false
+      end
+
+      # Given another criteria, remove the other criteria's scoping from this
+      # criteria.
+      #
+      # @example Remove the scoping.
+      #   criteria.remove_scoping(other)
+      #
+      # @param [ Criteria ] other The other criteria.
+      #
+      # @return [ Criteria ] The criteria with scoping removed.
+      #
+      # @since 3.0.0
+      def remove_scoping(other)
+        if other
+          reject_matching(other, :selector, :options)
+          other.inclusions.each do |meta|
+            inclusions.delete_one(meta)
+          end
+        end
+        self
+      end
+
+      # Forces the criteria to be scoped, unless its inside an unscoped block.
+      #
+      # @example Force the criteria to be scoped.
+      #   criteria.scoped(skip: 10)
+      #
+      # @param [ Hash ] options Additional query options.
+      #
+      # @return [ Criteria ] The scoped criteria.
+      #
+      # @since 3.0.0
+      def scoped(options = nil)
+        crit = clone
+        crit.options.merge!(options || {})
+        if klass.default_scopable? && !scoped?
+          crit.apply_default_scope
+        end
+        crit
+      end
+
+      # Has the criteria had the default scope applied?
+      #
+      # @example Is the default scope applied?
+      #   criteria.scoped?
+      #
+      # @return [ true, false ] If the default scope is applied.
+      #
+      # @since 3.0.0
+      def scoped?
+        !!(defined?(@scoped) ? @scoped : nil)
+      end
+
+      # Clears all scoping from the criteria.
+      #
+      # @example Clear all scoping from the criteria.
+      #   criteria.unscoped
+      #
+      # @return [ Criteria ] The unscoped criteria.
+      #
+      # @since 3.0.0
+      def unscoped
+        crit = clone
+        unless unscoped?
+          crit.scoping_options = false, true
+          crit.selector.clear; crit.options.clear
+        end
+        crit
+      end
+
+      # Is the criteria unscoped?
+      #
+      # @example Is the criteria unscoped?
+      #   criteria.unscoped?
+      #
+      # @return [ true, false ] If the criteria is force unscoped.
+      #
+      # @since 3.0.0
+      def unscoped?
+        !!(defined?(@unscoped) ? @unscoped : nil)
+      end
+
+      # Get the criteria scoping options, as a pair (scoped, unscoped).
+      #
+      # @example Get the scoping options.
+      #   criteria.scoping_options
+      #
+      # @return [ Array ] Scoped, unscoped.
+      #
+      # @since 3.0.0
+      def scoping_options
+        [ (defined?(@scoped) ? @scoped : nil), (defined?(@unscoped) ? @unscoped : nil) ]
+      end
+
+      # Set the criteria scoping options, as a pair (scoped, unscoped).
+      #
+      # @example Set the scoping options.
+      #   criteria.scoping_options = true, false
+      #
+      # @param [ Array ] options Scoped, unscoped.
+      #
+      # @return [ Array ] The new scoping options.
+      #
+      # @since 3.0.0
+      def scoping_options=(options)
+        @scoped, @unscoped = options
+      end
+
+      # Get the criteria with the default scope applied, if the default scope
+      # is able to be applied. Cases in which it cannot are: If we are in an
+      # unscoped block, if the criteria is already forced unscoped, or the
+      # default scope has already been applied.
+      #
+      # @example Get the criteria with the default scope.
+      #   criteria.with_default_scope
+      #
+      # @return [ Criteria ] The criteria.
+      #
+      # @since 3.0.0
+      def with_default_scope
+        crit = clone
+        if klass.default_scopable? && !unscoped? && !scoped?
+          crit.apply_default_scope
+        end
+        crit
+      end
+
+      private
+
+      def reject_matching(other, *methods)
+        methods.each do |method|
+          send(method).reject! do |key, value|
+            other.send(method).has_key?(key) && other.send(method)[key] == value
+          end
+        end
+      end
+    end
+  end
+end