mongoid 3.1.6 → 4.0.0

data/lib/mongoid/relations/auto_save.rb

@@ -7,11 +7,6 @@ module Mongoid
     module AutoSave
       extend ActiveSupport::Concern
 
-      included do
-        class_attribute :autosaved_relations
-        self.autosaved_relations = []
-      end
-
       # Used to prevent infinite loops in associated autosaves.
       #
       # @example Is the document autosaved?
@@ -44,15 +39,8 @@ module Mongoid
       #   document.changed_for_autosave?
       #
       # @since 3.1.3
-      def changed_for_autosave?
-        new_record? || changed? || marked_for_destruction?
-      end
-
-      # Returns the relation, if it exists
-      #
-      # @since 3.1.3
-      def relation_changed_for_autosave(metadata)
-        ivar(metadata.name) if self.class.autosaved_relations.include?(metadata.name)
+      def changed_for_autosave?(doc)
+        doc.new_record? || doc.changed? || doc.marked_for_destruction?
       end
 
       module ClassMethods
@@ -68,39 +56,30 @@ module Mongoid
         #
         # @since 2.0.0.rc.1
         def autosave(metadata)
-          if metadata.autosave? && autosavable?(metadata)
-            autosaved_relations.push(metadata.name)
-            set_callback :save, :after, unless: :autosaved? do |document|
-              # @todo: Durran: Remove with Rails 4 after callback termination.
+          if metadata.autosave? && !metadata.embedded?
+            save_method = :"autosave_documents_for_#{metadata.name}"
+            define_method(save_method) do
+
               if before_callback_halted?
                 self.before_callback_halted = false
               else
                 __autosaving__ do
-                  if document.changed_for_autosave? || relation = document.relation_changed_for_autosave(metadata)
-                    relation = document.__send__(metadata.name) unless relation
-                    (relation.do_or_do_not(:in_memory) || Array.wrap(relation)).each do |doc|
-                      doc.save
-                    end if relation
+                  if relation = ivar(metadata.name)
+                    options = persistence_options || {}
+                    if :belongs_to == metadata.macro
+                      relation.with(options).save if changed_for_autosave?(relation)
+                    else
+                      Array(relation).each { |d| d.with(options).save if changed_for_autosave?(d) }
+                    end
                   end
                 end
               end
             end
+
+            after_save save_method, unless: :autosaved?
           end
         end
 
-        # Can the autosave be added?
-        #
-        # @example Can the autosave be added?
-        #   Person.autosavable?(metadata)
-        #
-        # @param [ Metadata ] metadata The relation metadata.
-        #
-        # @return [ true, false ] If the autosave is able to be added.
-        #
-        # @since 3.0.0
-        def autosavable?(metadata)
-          !autosaved_relations.include?(metadata.name) && !metadata.embedded?
-        end
       end
     end
   end

data/lib/mongoid/relations/binding.rb

@@ -157,27 +157,6 @@ module Mongoid
         end
       end
 
-      # Bind the inverse of field, when in a polymorphic relation.
-      #
-      # @api private
-      #
-      # @example Bind the inverse of field.
-      #   binding.bind_inverse_of_field(doc)
-      #
-      # @param [ Document ] doc The document to bind.
-      # @param [ String ] name The name of the relation.
-      #
-      # @since 3.0.0
-      def bind_inverse_of_field(doc, name)
-        if metadata.inverse_field_bindable?
-          if inverse_metadata = metadata.inverse_metadata(doc)
-            if setter = inverse_metadata.inverse_of_field_setter
-              doc.you_must(setter, name)
-            end
-          end
-        end
-      end
-
       # Bind the provided document with the base from the parent relation.
       #
       # @api private
@@ -193,7 +172,6 @@ module Mongoid
         bind_foreign_key(doc, record_id(base))
         bind_polymorphic_type(doc, base.class.name)
         bind_inverse(doc, base)
-        bind_inverse_of_field(doc, metadata.name)
       end
 
       def record_id(base)
@@ -215,7 +193,7 @@ module Mongoid
       def set_base_metadata
         inverse_metadata = metadata.inverse_metadata(target)
         if inverse_metadata != metadata && !inverse_metadata.nil?
-          base.metadata = inverse_metadata
+          base.__metadata = inverse_metadata
         end
       end
 
@@ -234,7 +212,6 @@ module Mongoid
         bind_foreign_key(doc, nil)
         bind_polymorphic_type(doc, nil)
         bind_inverse(doc, nil)
-        bind_inverse_of_field(doc, nil)
       end
     end
   end

data/lib/mongoid/relations/bindings/embedded/in.rb

@@ -24,7 +24,7 @@ module Mongoid
           #
           # @since 2.0.0.rc.1
           def bind_one
-            base.metadata = metadata.inverse_metadata(target) unless base.metadata
+            base.__metadata = metadata.inverse_metadata(target) unless base.__metadata
             base.parentize(target)
             binding do
               if base.embedded_many?

data/lib/mongoid/relations/bindings/embedded/many.rb

@@ -23,9 +23,7 @@ module Mongoid
           def bind_one(doc)
             doc.parentize(base)
             binding do
-              unless metadata.versioned?
-                doc.do_or_do_not(metadata.inverse_setter(target), base)
-              end
+              doc.do_or_do_not(metadata.inverse_setter(target), base)
             end
           end
 

data/lib/mongoid/relations/bindings/referenced/in.rb

@@ -25,11 +25,10 @@ module Mongoid
               bind_polymorphic_inverse_type(base, target.class.name)
               if inverse = metadata.inverse(target)
                 if set_base_metadata
-                  bind_inverse_of_field(base, base.metadata_name)
                   if base.referenced_many?
-                    target.__send__(inverse).push(base) unless Mongoid.using_identity_map?
+                    target.__send__(inverse).push(base)
                   else
-                    target.do_or_do_not(metadata.inverse_setter(target), base)
+                    target.set_relation(inverse, base)
                   end
                 end
               end
@@ -47,18 +46,14 @@ module Mongoid
           def unbind_one
             binding do
               inverse = metadata.inverse(target)
-              if !inverse && metadata.inverse_of_field
-                inverse = base.__send__(metadata.inverse_of_field)
-              end
               bind_foreign_key(base, nil)
               bind_polymorphic_inverse_type(base, nil)
-              bind_inverse_of_field(base, nil)
               if inverse
                 set_base_metadata
                 if base.referenced_many?
                   target.__send__(inverse).delete(base)
                 else
-                  target.__send__("#{inverse}=", nil)
+                  target.set_relation(inverse, nil)
                 end
               end
             end

data/lib/mongoid/relations/bindings/referenced/many_to_many.rb

@@ -20,7 +20,9 @@ module Mongoid
             binding do
               inverse_keys = doc.you_must(metadata.inverse_foreign_key)
               if inverse_keys
-                inverse_keys.push(inverse_record_id(doc))
+                unless inverse_keys.include?(inverse_record_id(doc))
+                  inverse_keys.push(inverse_record_id(doc))
+                end
                 doc.reset_relation_criteria(metadata.inverse)
               end
               base.synced[metadata.foreign_key] = true

data/lib/mongoid/relations/builder.rb

@@ -17,7 +17,7 @@ module Mongoid
       #
       # @param [ Document ] base The base document.
       # @param [ Metdata ] metadata The metadata for the relation.
-      # @param [ Hash, Moped::BSON::ObjectId ] object The attributes to build from or
+      # @param [ Hash, BSON::ObjectId ] object The attributes to build from or
       #   id to query with.
       #
       # @since 2.0.0.rc.1

data/lib/mongoid/relations/builders/nested_attributes/many.rb

@@ -16,7 +16,6 @@ module Mongoid
           #   many.build(person)
           #
           # @param [ Document ] parent The parent document of the relation.
-          # @param [ Hash ] options The mass assignment options.
           #
           # @return [ Array ] The attributes.
           def build(parent, options = {})
@@ -25,10 +24,10 @@ module Mongoid
               raise Errors::TooManyNestedAttributeRecords.new(existing, options[:limit])
             end
             attributes.each do |attrs|
-              if attrs.respond_to?(:with_indifferent_access)
-                process_attributes(parent, attrs.with_indifferent_access, options)
+              if attrs.is_a?(::Hash)
+                process_attributes(parent, attrs.with_indifferent_access)
               else
-                process_attributes(parent, attrs[1].with_indifferent_access, options)
+                process_attributes(parent, attrs[1].with_indifferent_access)
               end
             end
           end
@@ -93,10 +92,9 @@ module Mongoid
           #
           # @param [ Document ] parent The parent document.
           # @param [ Hash ] attrs The single document attributes to process.
-          # @param [ Hash ] options the mass assignment options.
           #
           # @since 2.0.0
-          def process_attributes(parent, attrs, options)
+          def process_attributes(parent, attrs)
             return if reject?(parent, attrs)
             if id = attrs.extract_id
               first = existing.first
@@ -105,10 +103,10 @@ module Mongoid
               if destroyable?(attrs)
                 destroy(parent, existing, doc)
               else
-                update_document(doc, attrs, options)
+                update_document(doc, attrs)
               end
             else
-              existing.push(Factory.build(metadata.klass, attrs, options)) unless destroyable?(attrs)
+              existing.push(Factory.build(metadata.klass, attrs)) unless destroyable?(attrs)
             end
           end
 
@@ -127,7 +125,7 @@ module Mongoid
           # @since 3.0.10
           def destroy(parent, relation, doc)
             doc.flagged_for_destroy = true
-            if !doc.embedded? || parent.new_record? || doc.paranoid?
+            if !doc.embedded? || parent.new_record?
               destroy_document(relation, doc)
             else
               parent.flagged_destroys.push(->{ destroy_document(relation, doc) })
@@ -159,15 +157,14 @@ module Mongoid
           #
           # @param [ Document ] doc The document to update.
           # @param [ Hash ] attrs The attributes.
-          # @param [ Hash ] options The options.
           #
           # @since 3.0.10
-          def update_document(doc, attrs, options)
+          def update_document(doc, attrs)
             attrs.delete_id
             if metadata.embedded?
-              doc.assign_attributes(attrs, options)
+              doc.assign_attributes(attrs)
             else
-              doc.update_attributes(attrs, options)
+              doc.update_attributes(attrs)
             end
           end
         end

data/lib/mongoid/relations/builders/nested_attributes/one.rb

@@ -18,19 +18,18 @@ module Mongoid
           #   document, or a removal of the relation.
           #
           # @param [ Document ] parent The parent document.
-          # @param [ Hash ] options The mass assignment options.
           #
           # @return [ Document ] The built document.
           #
           # @since 2.0.0
-          def build(parent, options = {})
+          def build(parent)
             return if reject?(parent, attributes)
             @existing = parent.send(metadata.name)
             if update?
               attributes.delete_id
-              existing.assign_attributes(attributes, options)
+              existing.assign_attributes(attributes)
             elsif replace?
-              parent.send(metadata.setter, Factory.build(metadata.klass, attributes, options))
+              parent.send(metadata.setter, Factory.build(metadata.klass, attributes))
             elsif delete?
               parent.send(metadata.setter, nil)
             end
@@ -40,7 +39,7 @@ module Mongoid
           # relations.
           #
           # @example Instantiate the builder.
-          #   One.new(metadata, attributes, options)
+          #   One.new(metadata, attributes)
           #
           # @param [ Metadata ] metadata The relation metadata.
           # @param [ Hash ] attributes The attributes hash to attempt to set.

data/lib/mongoid/relations/builders/referenced/in.rb

@@ -17,7 +17,7 @@ module Mongoid
           def build(type = nil)
             return object unless query?
             model = type ? type.constantize : metadata.klass
-            metadata.criteria(object, model).from_map_or_db
+            metadata.criteria(object, model).first
           end
         end
       end

data/lib/mongoid/relations/builders/referenced/many.rb

@@ -17,8 +17,7 @@ module Mongoid
           def build(type = nil)
             return object unless query?
             return [] if object.is_a?(Array)
-            crit = metadata.criteria(Conversions.flag(object, metadata), base.class)
-            IdentityMap.get_many(crit.klass, crit.send(:selector_with_type_selection)) || crit
+            metadata.criteria(Conversions.flag(object, metadata), base.class)
           end
         end
       end

data/lib/mongoid/relations/builders/referenced/many_to_many.rb

@@ -17,8 +17,7 @@ module Mongoid
           def build(type = nil)
             return object.try(:dup) unless query?
             ids = object || []
-            crit = metadata.criteria(ids, base.class)
-            IdentityMap.get(crit.klass, ids) || crit
+            metadata.criteria(ids, base.class)
           end
 
           # Do we need to perform a database query? It will be so if the object we

data/lib/mongoid/relations/builders/referenced/one.rb

@@ -17,7 +17,7 @@ module Mongoid
           def build(type = nil)
             return object unless query?
             return nil if base.new_record?
-            metadata.criteria(Conversions.flag(object, metadata), base.class).from_map_or_db
+            metadata.criteria(Conversions.flag(object, metadata), base.class).first
           end
         end
       end

data/lib/mongoid/relations/builders.rb

@@ -65,7 +65,7 @@ module Mongoid
         def builder(name, metadata)
           re_define_method("build_#{name}") do |*args|
             attributes, options = parse_args(*args)
-            document = Factory.build(metadata.klass, attributes, options)
+            document = Factory.build(metadata.klass, attributes)
             _building do
               child = send("#{name}=", document)
               child.run_callbacks(:build)
@@ -90,7 +90,7 @@ module Mongoid
         def creator(name, metadata)
           re_define_method("create_#{name}") do |*args|
             attributes, options = parse_args(*args)
-            document = Factory.build(metadata.klass, attributes, options)
+            document = Factory.build(metadata.klass, attributes)
             doc = send("#{name}=", document)
             doc.save
             save if new_record? && metadata.stores_foreign_key?

data/lib/mongoid/relations/cascading.rb

@@ -26,11 +26,9 @@ module Mongoid
       # @since 2.0.0.rc.1
       def cascade!
         cascades.each do |name|
-          if !metadata || !metadata.versioned?
-            if meta = relations[name]
-              strategy = meta.cascade_strategy
-              strategy.new(self, meta).cascade if strategy
-            end
+          if meta = relations[name]
+            strategy = meta.cascade_strategy
+            strategy.new(self, meta).cascade if strategy
           end
         end
       end

data/lib/mongoid/relations/constraint.rb

@@ -37,7 +37,7 @@ module Mongoid
         return object if metadata.polymorphic?
         klass, field = metadata.klass, metadata.klass.fields["_id"]
         if klass.using_object_ids?
-          Moped::BSON::ObjectId.mongoize(object)
+          BSON::ObjectId.mongoize(object)
         elsif object.is_a?(::Array)
           object.map!{ |obj| field.mongoize(obj) }
         else

data/lib/mongoid/relations/conversions.rb

@@ -20,7 +20,7 @@ module Mongoid
       # @since 2.3.0
       def flag(object, metadata)
         inverse = metadata.inverse_klass
-        if inverse.using_object_ids? || object.is_a?(Moped::BSON::ObjectId)
+        if inverse.using_object_ids? || object.is_a?(BSON::ObjectId)
           object
         else
           if object.is_a?(String)

data/lib/mongoid/relations/counter_cache.rb

@@ -4,6 +4,20 @@ module Mongoid
     module CounterCache
       extend ActiveSupport::Concern
 
+      # Reset the given counter using the .count() query from the
+      # db. This method is usuful in case that a counter got
+      # corrupted, or a new counter was added to the collection.
+      #
+      # @example Reset the given counter cache
+      #   post.reset_counters(:comments)
+      #
+      # @param [ Symbol, Array ] One or more counter caches to reset
+      #
+      # @since 4.0.0
+      def reset_counters(*counters)
+        self.class.reset_counters(self, *counters)
+      end
+
       module ClassMethods
 
         # Reset the given counter using the .count() query from the
@@ -18,12 +32,12 @@ module Mongoid
         #
         # @since 3.1.0
         def reset_counters(id, *counters)
-          object = find(id)
+          document = id.is_a?(Document) ? id : find(id)
           counters.each do |name|
             meta = reflect_on_association(name)
             inverse = meta.klass.reflect_on_association(meta.inverse)
             counter_name = inverse.counter_cache_column_name
-            object.update_attribute(counter_name, object.send(name).count)
+            document.update_attribute(counter_name, document.send(name).count)
           end
         end
 
@@ -36,24 +50,22 @@ module Mongoid
         #              :comments_count => 5, :likes_count => -2)
         #
         # @param [ String ] The id of the object to update.
-        # @param [ Hash ] Key = counter_cahe and Value = factor.
+        # @param [ Hash ] Key = counter_cache and Value = factor.
         #
         # @since 3.1.0
         def update_counters(id, counters)
-          counters.map do |key, value|
-            where(:_id => id).inc(key, value)
-          end
+          where(:_id => id).inc(counters)
         end
 
         # Increment the counter name from the entries that match the
         # id by one. This method is used on associations callbacks
-        # when counter_cache is enable
+        # when counter_cache is enabled
         #
         # @example Increment comments counter
         #   Post.increment_counter(:comments_count, '50e0edd97c71c17ea9000001')
         #
         # @param [ Symbol ] Counter cache name
-        # @param [ String ] The id of the object that will be reset.
+        # @param [ String ] The id of the object that will have its counter incremented.
         #
         # @since 3.1.0
         def increment_counter(counter_name, id)
@@ -62,13 +74,13 @@ module Mongoid
 
         # Decrement the counter name from the entries that match the
         # id by one. This method is used on associations callbacks
-        # when counter_cache is enable
+        # when counter_cache is enabled
         #
         # @example Decrement comments counter
         #   Post.decrement_counter(:comments_count, '50e0edd97c71c17ea9000001')
         #
         # @param [ Symbol ] Counter cache name
-        # @param [ String ] The id of the object that will be reset.
+        # @param [ String ] The id of the object that will have its counter decremented.
         #
         # @since 3.1.0
         def decrement_counter(counter_name, id)
@@ -82,7 +94,7 @@ module Mongoid
         # @api private
         #
         # @example Add the touchable.
-        #   Person.add_counter_callbacks(meta)
+        #   Person.add_counter_cache_callbacks(meta)
         #
         # @param [ Metadata ] metadata The metadata for the relation.
         #
@@ -92,13 +104,25 @@ module Mongoid
           cache_column = meta.counter_cache_column_name.to_sym
 
           after_create do
-            record = __send__(name)
-            record.class.increment_counter(cache_column, record.id) if record.try(:persisted?)
+            if record = __send__(name)
+              record[cache_column] = (record[cache_column] || 0) + 1
+
+              if record.persisted?
+                record.class.increment_counter(cache_column, record.id)
+                record.remove_change(cache_column)
+              end
+            end
           end
 
           before_destroy do
-            record = __send__(name)
-            record.class.decrement_counter(cache_column, record.id) if record.try(:persisted?)
+            if record = __send__(name)
+              record[cache_column] = (record[cache_column] || 0) - 1
+
+              if record.persisted?
+                record.class.decrement_counter(cache_column, record.id)
+                record.remove_change(cache_column)
+              end
+            end
           end
         end
       end