mongoid 2.0.0.rc.6 → 2.0.0.rc.7

data/lib/mongoid/attributes/processing.rb

@@ -0,0 +1,142 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Attributes #:nodoc:
+
+    # This module contains the behavior for processing attributes.
+    module Processing
+
+      # Process the provided attributes casting them to their proper values if a
+      # field exists for them on the document. This will be limited to only the
+      # attributes provided in the suppied +Hash+ so that no extra nil values get
+      # put into the document's attributes.
+      #
+      # @example Process the attributes.
+      #   person.process(:title => "sir", :age => 40)
+      #
+      # @param [ Hash ] attrs The attributes to set.
+      #
+      # @since 2.0.0.rc.7
+      def process(attrs = nil)
+        sanitize_for_mass_assignment(attrs || {}).each_pair do |key, value|
+          next if pending_attribute?(key, value)
+          process_attribute(key, value)
+        end
+        yield self if block_given?
+        process_pending and setup_modifications
+      end
+
+      protected
+
+      # If the key provided a relation or a nested attribute, where we have to
+      # hold off on the setting of the attribute until everything else has been
+      # set?
+      #
+      # @example Is the attribute pending?
+      #   document.pending_attribute?(:name, "Durran")
+      #
+      # @param [ Synbol ] key The name of the attribute.
+      # @param [ Object ] value The value of the attribute.
+      #
+      # @return [ true, false ] True if pending, false if not.
+      #
+      # @since 2.0.0.rc.7
+      def pending_attribute?(key, value)
+        name = key.to_s
+        if relations.has_key?(name)
+          pending_relations[name] = value
+          return true
+        end
+        if nested_attributes.include?("#{name}=")
+          pending_nested[name] = value
+          return true
+        end
+        return false
+      end
+
+      # Get all the pending relations that need to be set.
+      #
+      # @example Get the pending relations.
+      #   document.pending_relations
+      #
+      # @return [ Hash ] The pending relations in key/value pairs.
+      #
+      # @since 2.0.0.rc.7
+      def pending_relations
+        @pending_relations ||= {}
+      end
+
+      # Get all the pending nested attributes that need to be set.
+      #
+      # @example Get the pending nested attributes.
+      #   document.pending_nested
+      #
+      # @return [ Hash ] The pending nested attributes in key/value pairs.
+      #
+      # @since 2.0.0.rc.7
+      def pending_nested
+        @pending_nested ||= {}
+      end
+
+      # If the attribute is dynamic, add a field for it with a type of object
+      # and then either way set the value.
+      #
+      # @example Process the attribute.
+      #   document.process_attribute(name, value)
+      #
+      # @param [ Symbol ] name The name of the field.
+      # @param [ Object ] value The value of the field.
+      #
+      # @since 2.0.0.rc.7
+      def process_attribute(name, value)
+        if Mongoid.allow_dynamic_fields && !respond_to?("#{name}=")
+          write_attribute(name, value)
+        else
+          send("#{name}=", value)
+        end
+      end
+
+      # Process all the pending nested attributes that needed to wait until
+      # ids were set to fire off.
+      #
+      # @example Process the nested attributes.
+      #   document.process_nested
+      #
+      # @since 2.0.0.rc.7
+      def process_nested
+        pending_nested.each_pair do |name, value|
+          send("#{name}=", value)
+        end
+      end
+
+      # Process all the pending items, then clear them out.
+      #
+      # @example Process the pending items.
+      #   document.process_pending
+      #
+      # @since 2.0.0.rc.7
+      def process_pending
+        process_nested and process_relations
+        pending_nested.clear and pending_relations.clear
+      end
+
+      # Process all the pending relations that needed to wait until ids were set
+      # to fire off.
+      #
+      # @example Process the relations.
+      #   document.process_relations
+      #
+      # @since 2.0.0.rc.7
+      def process_relations
+        pending_relations.each_pair do |name, value|
+          metadata = relations[name]
+          if value.is_a?(Hash)
+            metadata.nested_builder(value, {}).build(self)
+          else
+            send("#{name}=", value, :binding => true)
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/mongoid/collections.rb

@@ -18,6 +18,7 @@ module Mongoid #:nodoc
       #
       # Returns: <tt>Mongo::Collection</tt>
       def collection
+        raise Errors::InvalidCollection.new(self) if embedded? && !cyclic
         self._collection || set_collection
         add_indexes; self._collection
       end

data/lib/mongoid/components.rb

@@ -13,8 +13,8 @@ module Mongoid #:nodoc
     end
 
     include ActiveModel::Conversion
-    include ActiveModel::Naming
     include ActiveModel::MassAssignmentSecurity
+    include ActiveModel::Naming
     include ActiveModel::Serializers::JSON
     include ActiveModel::Serializers::Xml
     include Mongoid::Atomicity

data/lib/mongoid/config.rb

@@ -129,7 +129,6 @@ module Mongoid #:nodoc
     # @return [ Logger ] The newly set logger.
     def logger=(logger)
       @logger = logger
-      @master.connection.instance_variable_set(:@logger, logger)
     end
 
     # Sets whether the times returned from the database use the ruby or

data/lib/mongoid/contexts/mongo.rb

@@ -20,7 +20,12 @@ module Mongoid #:nodoc:
       #
       # A +Hash+ with field values as keys, counts as values
       def aggregate
-        klass.collection.group(options[:fields], selector, { :count => 0 }, Javascript.aggregate, true)
+        klass.collection.group(
+          :key => options[:fields],
+          :cond => selector,
+          :initial => { :count => 0 },
+          :reduce => Javascript.aggregate
+        )
       end
 
       # Get the average value for the supplied field.
@@ -141,10 +146,10 @@ module Mongoid #:nodoc:
       # A +Hash+ with field values as keys, arrays of documents as values.
       def group
         klass.collection.group(
-          options[:fields],
-          selector,
-          { :group => [] },
-          Javascript.group
+          :key => options[:fields],
+          :cond => selector,
+          :initial => { :group => [] },
+          :reduce => Javascript.group
         ).collect do |docs|
           docs["group"] = docs["group"].collect do |attrs|
             Mongoid::Factory.build(klass, attrs)
@@ -287,10 +292,9 @@ module Mongoid #:nodoc:
       # and sum. Will gsub the field name in the supplied reduce function.
       def grouped(start, field, reduce)
         collection = klass.collection.group(
-          nil,
-          selector,
-          { start => "start" },
-          reduce.gsub("[field]", field)
+          :cond => selector,
+          :initial => { start => "start" },
+          :reduce => reduce.gsub("[field]", field)
         )
         collection.empty? ? nil : collection.first[start.to_s]
       end

data/lib/mongoid/criteria.rb

@@ -195,6 +195,18 @@ module Mongoid #:nodoc:
     end
     alias :to_ary :to_a
 
+    # Needed to properly get a criteria back as json
+    #
+    # @example Get the criteria as json.
+    #   Person.where(:title => "Sir").as_json
+    #
+    # @param [ Hash ] options Options to pass through to the serializer.
+    #
+    # @return [ String ] The JSON string.
+    def as_json(options = nil)
+      entries.as_json(options)
+    end
+
     class << self
 
       # Encaspulates the behavior of taking arguments and parsing them into a
@@ -297,6 +309,7 @@ module Mongoid #:nodoc:
     def initialize_copy(other)
       @selector = other.selector.dup
       @options = other.options.dup
+      @context = nil
     end
 
     # Update the selector setting the operator on the value for each key in the
@@ -307,7 +320,8 @@ module Mongoid #:nodoc:
     # <tt>criteria.update_selector({ :field => "value" }, "$in")</tt>
     def update_selector(attributes, operator)
       clone.tap do |crit|
-        attributes.each do |key, value|
+        converted = BSON::ObjectId.convert(klass, attributes || {})
+        converted.each do |key, value|
           unless crit.selector[key]
             crit.selector[key] = { operator => value }
           else

data/lib/mongoid/criterion/inclusion.rb

@@ -50,26 +50,50 @@ module Mongoid #:nodoc:
       def any_of(*args)
         clone.tap do |crit|
           criterion = @selector["$or"] || []
-          expanded = args.collect(&:expand_complex_criteria)
+          converted = BSON::ObjectId.convert(klass, args.flatten)
+          expanded = converted.collect(&:expand_complex_criteria)
           crit.selector["$or"] = criterion.concat(expanded)
         end
       end
       alias :or :any_of
 
-      # Using the existing criteria, find a document by a single id, multiple
-      # ids, or using a conditions hash.
+      # Find the matchind document in the criteria, either based on id or
+      # conditions.
       #
-      # @example Find a single document by id.
-      #   Person.where(:title => "Sir").find(id)
+      # @todo Durran: DRY up duplicated code in a few places.
       #
-      # @example Find multiple documents by ids.
-      #   Person.where(:title => "Sir").find([ id_one, id_two ])
+      # @example Find by an id.
+      #   criteria.find(BSON::ObjectId.new)
       #
-      # @return [ Document, Array<Document> ] The matching document(s).
+      # @example Find by multiple ids.
+      #   criteria.find([ BSON::ObjectId.new, BSON::ObjectId.new ])
       #
-      # @since 2.0.0.rc.1
+      # @example Conditionally find all matching documents.
+      #   criteria.find(:all, :conditions => { :title => "Sir" })
+      #
+      # @example Conditionally find the first document.
+      #   criteria.find(:first, :conditions => { :title => "Sir" })
+      #
+      # @example Conditionally find the last document.
+      #   criteria.find(:last, :conditions => { :title => "Sir" })
+      #
+      # @param [ Symbol, BSON::ObjectId, Array<BSON::ObjectId> ] arg The
+      #   argument to search with.
+      # @param [ Hash ] options The options to search with.
+      #
+      # @return [ Document, Criteria ] The matching document(s).
       def find(*args)
-        id_criteria(*args)
+        raise Errors::InvalidOptions.new(
+          :calling_document_find_with_nil_is_invalid, {}
+        ) if args[0].nil?
+        type, criteria = Criteria.parse!(klass, embedded, *args)
+        criteria.merge(self) if criteria.is_a?(Criteria)
+        case type
+        when :first then return criteria.one
+        when :last then return criteria.last
+        else
+          return criteria
+        end
       end
 
       # Adds a criterion to the +Criteria+ that specifies values where any can
@@ -117,7 +141,8 @@ module Mongoid #:nodoc:
         clone.tap do |crit|
           selector = case selector
             when String then {"$where" => selector}
-            else selector ? selector.expand_complex_criteria : {}
+            else
+              BSON::ObjectId.convert(klass, selector || {}).expand_complex_criteria
           end
 
           selector.each_pair do |key, value|

data/lib/mongoid/criterion/inspection.rb

@@ -13,7 +13,9 @@ module Mongoid #:nodoc:
       def inspect
         "#<Mongoid::Criteria\n" <<
         "  selector: #{selector.inspect},\n" <<
-        "  options:  #{options.inspect}>\n"
+        "  options:  #{options.inspect},\n" <<
+        "  class:    #{klass},\n" <<
+        "  embedded: #{embedded}>\n"
       end
     end
   end

data/lib/mongoid/criterion/optional.rb

@@ -106,12 +106,12 @@ module Mongoid #:nodoc:
         ids.flatten!
         if ids.size > 1
           any_in(
-            :_id => ::BSON::ObjectId.cast!(klass, ids, klass.primary_key.nil?)
+            :_id => ::BSON::ObjectId.convert(klass, ids)
           )
         else
           clone.tap do |crit|
             crit.selector[:_id] =
-              ::BSON::ObjectId.cast!(klass, ids.first, klass.primary_key.nil?)
+              ::BSON::ObjectId.convert(klass, ids.first)
           end
         end
       end

data/lib/mongoid/dirty.rb

@@ -102,6 +102,7 @@ module Mongoid #:nodoc:
     #
     # <tt>person.move_changes</tt>
     def move_changes
+      @validated = false
       @previous_modifications = modifications.dup
       @modifications = {}
     end

data/lib/mongoid/document.rb

@@ -117,8 +117,8 @@ module Mongoid #:nodoc:
       process(attrs) do |document|
         yield self if block_given?
         identify
-        run_callbacks(:initialize) { document }
       end
+      run_callbacks(:initialize) { self }
     end
 
     # Return the attributes hash.
@@ -147,9 +147,10 @@ module Mongoid #:nodoc:
         raise Errors::DocumentNotFound.new(self.class, id) if reloaded.nil?
       end
       @attributes = {}.merge(reloaded || {})
+      reset_modifications
       tap do
         relations.keys.each do |name|
-          if relation_exists?(name)
+          if instance_variable_defined?("@#{name}")
             remove_instance_variable("@#{name}")
           end
         end
@@ -189,15 +190,15 @@ module Mongoid #:nodoc:
     # the current document.
     #
     # @example Get the full hierarchy.
-    #   person.to_hash
+    #   person.as_document
     #
     # @return [ Hash ] A hash of all attributes in the hierarchy.
-    def to_hash
+    def as_document
       attributes = @attributes
       attributes.tap do |attrs|
         relations.select { |name, meta| meta.embedded? }.each do |name, meta|
           relation = send(name, false, :continue => false)
-          attrs[name] = relation.to_hash unless relation.blank?
+          attrs[name] = relation.as_document unless relation.blank?
         end
       end
     end
@@ -248,6 +249,11 @@ module Mongoid #:nodoc:
       def _types
         @_type ||= [descendants + [self]].flatten.uniq.map(&:to_s)
       end
+
+      # Set the i18n scope to overwrite ActiveModel.
+      def i18n_scope
+        :mongoid
+      end
     end
   end
 end

data/lib/mongoid/extensions/integer/conversions.rb

@@ -6,8 +6,8 @@ module Mongoid #:nodoc:
         def set(value)
           return nil if value.blank?
           begin
-            Integer(value)
-          rescue ArgumentError => e
+            value.to_s =~ /\./ ? Float(value) : Integer(value)
+          rescue
             value
           end
         end

data/lib/mongoid/extensions/object_id/conversions.rb

@@ -2,8 +2,21 @@
 module Mongoid #:nodoc:
   module Extensions #:nodoc:
     module ObjectId #:nodoc:
-      module Conversions #:nodoc:
 
+      # Provides conversions to and from BSON::ObjectIds and Strings, Arrays,
+      # and Hashes.
+      module Conversions
+
+        # Set the BSON::ObjectId value.
+        #
+        # @example Set the value.
+        #   BSON::ObjectId.set("4c52c439931a90ab29000003")
+        #
+        # @param [ String, BSON::ObjectId ] value The value to set.
+        #
+        # @return [ BSON::ObjectId ] The set value.
+        #
+        # @since 1.0
         def set(value)
           if value.is_a?(::String)
             BSON::ObjectId.from_string(value) unless value.blank?
@@ -12,41 +25,58 @@ module Mongoid #:nodoc:
           end
         end
 
+        # Get the BSON::ObjectId value.
+        #
+        # @example Get the value.
+        #   BSON::ObjectId.set(BSON::ObjectId.new)
+        #
+        # @param [ BSON::ObjectId ] value The value to get.
+        #
+        # @return [ BSON::ObjectId ] The value.
+        #
+        # @since 1.0
         def get(value)
           value
         end
 
-        # If the document is using BSON::ObjectIds the convert the argument to
-        # either an object id or an array of them if the supplied argument is an
-        # Array. Otherwise just return.
-        #
-        # Options:
-        #  args: A +String+ or an +Array+ convert to +BSON::ObjectId+
-        #  cast: A +Boolean+ define if we can or not cast to BSON::ObjectId.
-        #        If false, we use the default type of args
-        #
-        # Example:
-        #
-        # <tt>Mongoid.cast_ids!("4ab2bc4b8ad548971900005c", true)</tt>
-        # <tt>Mongoid.cast_ids!(["4ab2bc4b8ad548971900005c"])</tt>
-        #
-        # Returns:
-        #
-        # If using object ids:
-        #   An +Array+ of +BSON::ObjectId+ of each element if params is an +Array+
-        #   A +BSON::ObjectId+ from params if params is +String+
-        # Otherwise:
-        #   <tt>args</tt>
-        def cast!(klass, args, cast = true)
-          if !klass.using_object_ids? || args.is_a?(::BSON::ObjectId) || !cast
-            return args
-          end
-          if args.is_a?(::String)
-            ::BSON::ObjectId(args)
-          elsif args.is_a?(::Array)
-            args.map{ |a|
-              a.is_a?(::BSON::ObjectId) ? a : ::BSON::ObjectId(a)
-            }
+        # Convert the supplied arguments to object ids based on the class
+        # settings.
+        #
+        # @example Convert a string to an object id
+        #   BSON::ObjectId.convert(Person, "4c52c439931a90ab29000003")
+        #
+        # @example Convert an array of strings to object ids.
+        #   BSON::ObjectId.convert(Person, [ "4c52c439931a90ab29000003" ])
+        #
+        # @example Convert a hash of id strings to object ids.
+        #   BSON::ObjectId.convert(Person, { :_id => "4c52c439931a90ab29000003" })
+        #
+        # @param [ Class ] klass The class to convert the ids for.
+        # @param [ Object, Array, Hash ] args The object to convert.
+        #
+        # @raise BSON::InvalidObjectId If using object ids and passed bad
+        #   strings.
+        #
+        # @return [ BSON::ObjectId, Array, Hash ] The converted object ids.
+        #
+        # @since 2.0.0.rc.7
+        def convert(klass, args)
+          return args if args.is_a?(BSON::ObjectId) || !klass.using_object_ids?
+          case args
+          when ::String
+            BSON::ObjectId.from_string(args)
+          when ::Array
+            args.map do |arg|
+              convert(klass, arg)
+            end
+          when ::Hash
+            args.tap do |hash|
+              args.each_pair do |key, value|
+                begin
+                  args[key] = convert(klass, value)
+                rescue BSON::InvalidObjectId; end
+              end
+            end
           else
             args
           end