mongoid 3.1.7 → 4.0.0.alpha1

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/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

data/lib/mongoid/relations/eager.rb

@@ -0,0 +1,47 @@
+require "mongoid/relations/eager/base"
+require "mongoid/relations/eager/belongs_to"
+require "mongoid/relations/eager/has_one"
+require "mongoid/relations/eager/has_many"
+require "mongoid/relations/eager/has_and_belongs_to_many"
+
+module Mongoid
+  module Relations
+    module Eager
+
+      attr_accessor :eager_loaded
+
+      def with_eager_loading(document)
+        selecting do
+          return nil unless document
+          doc = Factory.from_db(klass, document, criteria.object_id)
+          eager_load_one(doc)
+          doc
+        end
+      end
+
+      def eager_load_one(doc)
+        eager_load([doc])
+      end
+
+      def eager_loadable?(document = nil)
+        return false if criteria.inclusions.empty?
+        !eager_loaded
+      end
+
+      def eager_load(docs)
+        return false unless eager_loadable?
+        preload(criteria.inclusions, docs)
+        self.eager_loaded = true
+      end
+
+      def preload(relations, docs)
+
+        relations.group_by do |metadata|
+          metadata.relation
+        end.each do |relation, associations|
+          relation.eager_load_klass.new(associations, docs).run
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/relations/eager/base.rb

@@ -0,0 +1,57 @@
+module Mongoid
+  module Relations
+    module Eager
+      class Base
+        def initialize(associations, docs)
+          @associations = associations
+          @docs = docs
+          @grouped_docs = {}
+        end
+
+        def shift_metadata
+          @metadata = @associations.shift
+        end
+
+        def run
+          while shift_metadata
+            preload
+          end
+        end
+
+        def preload
+          raise NotImplementedError
+        end
+
+        def each_loaded_document
+          @metadata.klass.any_in(key => keys_from_docs).each do |doc|
+            yield doc
+          end
+        end
+
+        def set_on_parent(id, element)
+          grouped_docs[id].each do |d|
+            set_relation(d, element)
+          end
+        end
+
+        def set_relation(doc, element)
+          doc.set_relation(@metadata.name, element)
+        end
+
+        def grouped_docs
+          @grouped_docs[@metadata.name] ||= @docs.group_by do |doc|
+            doc.send(group_by_key)
+          end
+        end
+
+        def keys_from_docs
+          grouped_docs.keys
+        end
+
+        def group_by_key(doc)
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/relations/eager/belongs_to.rb

@@ -0,0 +1,30 @@
+module Mongoid
+  module Relations
+    module Eager
+
+      class BelongsTo < Base
+
+        def preload
+          raise Errors::EagerLoad.new(@metadata.name) if @metadata.polymorphic?
+
+          @docs.each do |d|
+            set_relation(d, nil)
+          end
+
+          each_loaded_document do |doc|
+            id = doc.send(key)
+            set_on_parent(id, doc)
+          end
+        end
+
+        def group_by_key
+          @metadata.foreign_key
+        end
+
+        def key
+          @metadata.primary_key
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/relations/eager/has_and_belongs_to_many.rb

@@ -0,0 +1,40 @@
+module Mongoid
+  module Relations
+    module Eager
+
+      class HasAndBelongsToMany < Base
+
+        def preload
+          @docs.each do |d|
+            set_relation(d, [])
+          end
+
+          entries = Hash.new { |hash, key| hash[key] = [] }
+          each_loaded_document do |doc|
+
+            ids = doc.send(key)
+            ids.each do |id|
+              entries[id] << doc
+            end
+          end
+
+          entries.each do |id, docs|
+            set_on_parent(id, docs)
+          end
+        end
+
+        def set_relation(doc, element)
+          doc.__build__(@metadata.name, element, @metadata)
+        end
+
+        def group_by_key
+          @metadata.primary_key
+        end
+
+        def key
+          @metadata.inverse_foreign_key
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/relations/eager/has_many.rb

@@ -0,0 +1,37 @@
+module Mongoid
+  module Relations
+    module Eager
+
+      class HasMany < Base
+
+        def preload
+          @docs.each do |d|
+            set_relation(d, [])
+          end
+
+          entries = Hash.new { |hash, key| hash[key] = [] }
+          each_loaded_document do |doc|
+            fk = doc.send(key)
+            entries[fk] << doc
+          end
+
+          entries.each do |id, docs|
+            set_on_parent(id, docs)
+          end
+        end
+
+        def set_relation(doc, element)
+          doc.__build__(@metadata.name, element, @metadata)
+        end
+
+        def group_by_key
+          @metadata.primary_key
+        end
+
+        def key
+          @metadata.foreign_key
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/relations/eager/has_one.rb

@@ -0,0 +1,29 @@
+module Mongoid
+  module Relations
+    module Eager
+
+      class HasOne < Base
+
+        def preload
+          @docs.each do |d|
+            set_relation(d, nil)
+          end
+
+          each_loaded_document do |doc|
+            id = doc.send(key)
+            set_on_parent(id, doc)
+          end
+        end
+
+        def group_by_key
+          @metadata.primary_key
+        end
+
+        def key
+          @metadata.foreign_key
+        end
+
+      end
+    end
+  end
+end