mongoid 3.0.23 → 3.1.0

data/lib/mongoid/criterion/findable.rb

@@ -0,0 +1,179 @@
+# encoding: utf-8
+module Mongoid
+  module Criterion
+    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/criterion/modifiable.rb

@@ -0,0 +1,191 @@
+# encoding: utf-8
+module Mongoid
+  module Criterion
+    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 = nil)
+        document = first || create_document(method, attrs)
+        yield(document) if block_given?
+        document
+      end
+    end
+  end
+end

data/lib/mongoid/criterion/scoping.rb

@@ -31,12 +31,7 @@ module Mongoid
       # @since 3.0.0
       def remove_scoping(other)
         if other
-          selector.reject! do |key, value|
-            other.selector.has_key?(key) && other.selector[key] == value
-          end
-          options.reject! do |key, value|
-            other.options.has_key?(key) && other.options[key] == value
-          end
+          reject_matching(other, :selector, :options)
           other.inclusions.each do |meta|
             inclusions.delete_one(meta)
           end
@@ -148,6 +143,16 @@ module Mongoid
         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

data/lib/mongoid/document.rb

@@ -10,62 +10,8 @@ module Mongoid
     attr_accessor :criteria_instance_id
     attr_reader :new_record
 
-    # Default comparison is via the string version of the id.
-    #
-    # @example Compare two documents.
-    #   person <=> other_person
-    #
-    # @param [ Document ] other The document to compare with.
-    #
-    # @return [ Integer ] -1, 0, 1.
-    #
-    # @since 1.0.0
-    def <=>(other)
-      attributes["_id"].to_s <=> other.attributes["_id"].to_s
-    end
-
-    # Performs equality checking on the document ids. For more robust
-    # equality checking please override this method.
-    #
-    # @example Compare for equality.
-    #   document == other
-    #
-    # @param [ Document, Object ] other The other object to compare with.
-    #
-    # @return [ true, false ] True if the ids are equal, false if not.
-    #
-    # @since 1.0.0
-    def ==(other)
-      self.class == other.class &&
-        attributes["_id"] == other.attributes["_id"]
-    end
-
-    # Performs class equality checking.
-    #
-    # @example Compare the classes.
-    #   document === other
-    #
-    # @param [ Document, Object ] other The other object to compare with.
-    #
-    # @return [ true, false ] True if the classes are equal, false if not.
-    #
-    # @since 1.0.0
-    def ===(other)
-      other.class == Class ? self.class === other : self == other
-    end
-
-    # Delegates to ==. Used when needing checks in hashes.
-    #
-    # @example Perform equality checking.
-    #   document.eql?(other)
-    #
-    # @param [ Document, Object ] other The object to check against.
-    #
-    # @return [ true, false ] True if equal, false if not.
-    #
-    # @since 1.0.0
-    def eql?(other)
-      self == (other)
+    included do
+      Mongoid.register_model(self)
     end
 
     # Freezes the internal attributes of the document.
@@ -143,12 +89,15 @@ module Mongoid
       _building do
         @new_record = true
         @attributes ||= {}
+        @attributes_before_type_cast ||= {}
         options ||= {}
         apply_pre_processed_defaults
         process_attributes(attrs, options[:as] || :default, !options[:without_protection]) do
           yield(self) if block_given?
         end
         apply_post_processed_defaults
+        # @todo: #2586: Need to have access to parent document in these
+        #   callbacks.
         run_callbacks(:initialize) unless _initialize_callbacks.empty?
       end
     end
@@ -336,9 +285,11 @@ module Mongoid
         doc = allocate
         doc.criteria_instance_id = criteria_instance_id
         doc.instance_variable_set(:@attributes, attributes)
+        doc.instance_variable_set(:@attributes_before_type_cast, {})
         doc.apply_defaults
         IdentityMap.set(doc) unless _loading_revision?
         yield(doc) if block_given?
+        doc.run_callbacks(:find) unless doc._find_callbacks.empty?
         doc.run_callbacks(:initialize) unless doc._initialize_callbacks.empty?
         doc
       end