mongo_mapper 0.13.0.beta2 → 0.15.0

data/lib/mongo_mapper/plugins/associations/many_embedded_proxy.rb

@@ -10,14 +10,15 @@ module MongoMapper
           reset
         end
 
-        private
-          def find_target
-            (@_values ||= []).map do |attrs|
-              klass.load(attrs, true).tap do |child|
-                assign_references(child)
-              end
+      private
+
+        def find_target
+          (@_values ||= []).map do |attrs|
+            klass.load(attrs, true).tap do |child|
+              assign_references(child)
             end
           end
+        end
       end
     end
   end

data/lib/mongo_mapper/plugins/associations/many_polymorphic_proxy.rb

@@ -3,11 +3,13 @@ module MongoMapper
   module Plugins
     module Associations
       class ManyPolymorphicProxy < ManyDocumentsProxy
-        private
-          def apply_scope(doc)
-            doc[association.type_key_name] = doc.class.name
-            super
-          end
+
+      private
+
+        def apply_scope(doc)
+          doc[association.type_key_name] = doc.class.name
+          super
+        end
       end
     end
   end

data/lib/mongo_mapper/plugins/associations/one_as_proxy.rb

@@ -3,20 +3,23 @@ module MongoMapper
   module Plugins
     module Associations
       class OneAsProxy < OneProxy
-        protected
-          def criteria
-            {type_key_name => proxy_owner.class.name, id_key_name => proxy_owner.id}
-          end
-        
-        private
-          def type_key_name
-            "#{options[:as]}_type"
-          end
-        
-          def id_key_name
-            "#{options[:as]}_id"
-          end
+
+      protected
+
+        def criteria
+          {type_key_name => proxy_owner.class.name, id_key_name => proxy_owner.id}
+        end
+
+      private
+
+        def type_key_name
+          "#{options[:as]}_type"
+        end
+
+        def id_key_name
+          "#{options[:as]}_id"
+        end
       end
     end
   end
-end
+end

data/lib/mongo_mapper/plugins/associations/one_embedded_polymorphic_proxy.rb

@@ -8,22 +8,23 @@ module MongoMapper
           reset
         end
 
-        protected
-          def find_target
-            if @value
-              child = polymorphic_class(@value).load(@value, true)
-              assign_references(child)
-              child
-            end
+      protected
+
+        def find_target
+          if @value
+            child = polymorphic_class(@value).load(@value, true)
+            assign_references(child)
+            child
           end
+        end
 
-          def polymorphic_class(doc)
-            if class_name = doc[association.type_key_name]
-              class_name.constantize
-            else
-              klass
-            end
+        def polymorphic_class(doc)
+          if class_name = doc[association.type_key_name]
+            class_name.constantize
+          else
+            klass
           end
+        end
       end
     end
   end

data/lib/mongo_mapper/plugins/associations/one_embedded_proxy.rb

@@ -25,19 +25,19 @@ module MongoMapper
           @target.persist(options) if @target
         end
 
-        protected
+      protected
 
-          def find_target
-            if @value
-              klass.load(@value, true).tap do |child|
-                assign_references(child)
-              end
+        def find_target
+          if @value
+            klass.load(@value, true).tap do |child|
+              assign_references(child)
             end
           end
+        end
 
-          def assign_references(doc)
-            doc._parent_document = proxy_owner if doc
-          end
+        def assign_references(doc)
+          doc._parent_document = proxy_owner if doc
+        end
       end
     end
   end

data/lib/mongo_mapper/plugins/associations/one_proxy.rb

@@ -57,38 +57,39 @@ module MongoMapper
           reset
         end
 
-        protected
-          def find_target
-            target_class.first(association.query_options.merge(criteria))
-          end
+      protected
 
-          def instantiate_target(instantiator, attrs={}, &block)
-            @target = target_class.send(instantiator, attrs.update(criteria), &block)
-            loaded
-            @target
-          end
+        def find_target
+          target_class.first(association.query_options.merge(criteria))
+        end
 
-          def target_class
-            @target_class ||= options[:class] || (options[:class_name] || association.name.to_s.camelize).constantize
-          end
+        def instantiate_target(instantiator, attrs={}, &block)
+          @target = target_class.send(instantiator, attrs.update(criteria), &block)
+          loaded
+          @target
+        end
 
-          def foreign_key
-            options[:foreign_key] || proxy_owner.class.name.foreign_key
-          end
+        def target_class
+          @target_class ||= options[:class] || (options[:class_name] || association.name.to_s.camelize).constantize
+        end
 
-          def criteria
-            {self.foreign_key => proxy_owner.id}
-          end
+        def foreign_key
+          options[:foreign_key] || proxy_owner.class.name.foreign_key
+        end
 
-          def nullify_scope(doc)
-            criteria.each { |key, value| doc[key] = nil }
-            doc
-          end
+        def criteria
+          {self.foreign_key => proxy_owner.id}
+        end
 
-          def apply_scope(doc)
-            criteria.each { |key, value| doc[key] = value }
-            doc
-          end
+        def nullify_scope(doc)
+          criteria.each { |key, value| doc[key] = nil }
+          doc
+        end
+
+        def apply_scope(doc)
+          criteria.each { |key, value| doc[key] = value }
+          doc
+        end
       end
     end
   end

data/lib/mongo_mapper/plugins/associations/proxy.rb

@@ -91,47 +91,50 @@ module MongoMapper
           proxy_respond_to?(*args) || (load_target && target.respond_to?(*args))
         end
 
-        def send(method, *args)
+        def send(method, *args, &block)
           if proxy_respond_to?(method, true)
             super
           else
             load_target
-            target.send(method, *args)
+            target.send(method, *args, &block)
           end
         end
 
-        protected
-          def method_missing(method, *args, &block)
-            if load_target
-              target.send(method, *args, &block)
-            end
-          end
+      protected
 
-          def load_target
-            unless loaded?
-              if @target.is_a?(Array) && @target.any?
-                @target = find_target + @target.find_all { |record| !record.persisted? }
-              else
-                @target = find_target
-              end
-              loaded
+        def load_target
+          unless loaded?
+            if @target.is_a?(Array) && @target.any?
+              @target = find_target + @target.find_all { |record| !record.persisted? }
+            else
+              @target = find_target
             end
-            @target
-          rescue MongoMapper::DocumentNotFound
-            reset
+            loaded
           end
+          @target
+        rescue MongoMapper::DocumentNotFound
+          reset
+        end
 
-          # :nocov:
-          def find_target
-            raise NotImplementedError
-          end
-          # :nocov:
+        # :nocov:
+        def find_target
+          raise NotImplementedError
+        end
+        # :nocov:
+
+        def flatten_deeper(array)
+          array.collect do |element|
+            (element.respond_to?(:flatten) && !element.is_a?(Hash)) ? element.flatten : element
+          end.flatten
+        end
+
+      private
 
-          def flatten_deeper(array)
-            array.collect do |element|
-              (element.respond_to?(:flatten) && !element.is_a?(Hash)) ? element.flatten : element
-            end.flatten
+        def method_missing(method, *args, &block)
+          if load_target
+            target.send(method, *args, &block)
           end
+        end
       end
     end
   end

data/lib/mongo_mapper/plugins/callbacks.rb

@@ -4,15 +4,28 @@ module MongoMapper
     module Callbacks
       extend ActiveSupport::Concern
 
+      def initialize(*)
+        run_callbacks(:initialize) { super }
+      end
+
+      def initialize_from_database(*)
+        run_callbacks(:initialize) do
+          run_callbacks(:find) do
+            super
+          end
+        end
+      end
+
       def destroy
         run_callbacks(:destroy) { super }
       end
-      
+
       def touch(*)
         run_callbacks(:touch) { super }
       end
 
     private
+
       def create_or_update(*)
         run_callbacks(:save) { super }
       end

data/lib/mongo_mapper/plugins/counter_cache.rb

@@ -0,0 +1,97 @@
+module MongoMapper
+  module Plugins
+    # Counter Caching for MongoMapper::Document
+    #
+    # Examples:
+    #
+    #   class Post
+    #     belongs_to :user
+    #     counter_cache :user
+    #   end
+    #
+    #   or:
+    #
+    #   class Post
+    #     belongs_to :user
+    #     counter_cache :user, :custom_posts_count
+    #   end
+    #
+    # Field names follow rails conventions, so counter_cache :user will increment the Integer field `posts_count' on User
+    #
+    # Alternatively, you can also use the more common ActiveRecord syntax:
+    #
+    #   class Post
+    #     belongs_to :user, :counter_cache => true
+    #   end
+    #
+    # Or with an alternative field name:
+    #
+    #   class Post
+    #     belongs_to :user, :counter_cache => :custom_posts_count
+    #   end
+    #
+    module CounterCache
+      class InvalidCounterCacheError < StandardError; end
+
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def counter_cache(association_name, options = {})
+          options.symbolize_keys!
+
+          field = options[:field] ?
+            options[:field] :
+            "#{self.collection_name.gsub(/.*\./, '')}_count"
+
+          association = associations[association_name]
+
+          if !association
+            raise InvalidCounterCacheError, "You must define an association with name `#{association_name}' on model #{self}"
+          end
+
+          # make a define-time check to make sure the counter cache field is defined.
+          # note: this can only be done in non-polymorphic classes
+          # (since we may not know the class on the other side of the association)
+          if !association.polymorphic?
+            association_class = association.klass
+            key_names = association_class.keys.keys
+
+            if !key_names.include?(field.to_s)
+              _raise_when_missing_counter_cache_key(association_class, field)
+            end
+          end
+
+          after_create do
+            if obj = self.send(association_name)
+              if !obj.respond_to?(field)
+                self.class._raise_when_missing_counter_cache_key(obj.class, field)
+              end
+
+              obj.increment(field => 1)
+              obj.write_attribute(field, obj.read_attribute(field) + 1)
+            end
+
+            true
+          end
+
+          after_destroy do
+            if obj = self.send(association_name)
+              if !obj.respond_to?(field)
+                self.class._raise_when_missing_counter_cache_key(obj.class, field)
+              end
+
+              obj.decrement(field => 1)
+              obj.write_attribute(field, obj.read_attribute(field) - 1)
+            end
+
+            true
+          end
+        end
+
+        def _raise_when_missing_counter_cache_key(klass, field)
+          raise InvalidCounterCacheError, "Missing `key #{field.to_sym.inspect}, Integer, :default => 0' on model #{klass}"
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/dirty.rb

@@ -3,58 +3,50 @@ module MongoMapper
   module Plugins
     module Dirty
       extend ActiveSupport::Concern
-
       include ::ActiveModel::Dirty
 
-      def initialize(*)
-        # never register initial id assignment as a change
-        # Chaining super into tap breaks implicit block passing in Ruby 1.8
-        doc = super
-        doc.tap { changed_attributes.delete('_id') }
-      end
-
-      def save(*)
-        clear_changes { super }
+      module ClassMethods
+        def create_accessors_for(key)
+          super.tap do
+            define_attribute_methods([key.name])
+          end
+        end
       end
 
-      def reload(*)
-        doc = super
-        doc.tap { clear_changes }
+      def create_or_update(*)
+        super.tap do
+          changes_applied
+        end
       end
 
-      def clear_changes
-        previous = changes
-        (block_given? ? yield : true).tap do |result|
-          unless result == false #failed validation; nil is OK.
-            @previously_changed = previous
-            changed_attributes.clear
-          end
+      def reload!
+        super.tap do
+          clear_changes_information
         end
       end
 
-      protected
+    private
 
-      # We don't call super here to avoid invoking #attributes, which builds a whole new hash per call.
-      def attribute_method?(attr_name)
-        keys.key?(attr_name) || !embedded_associations.detect {|a| a.name == attr_name }.nil?
-      end
+      def write_key(key_name, value)
+        key_name = unalias_key(key_name)
 
-      private
-
-      def write_key(key, value)
-        key = unalias_key(key)
-        if !keys.key?(key)
+        if !keys.key?(key_name)
           super
         else
-          attribute_will_change!(key) unless attribute_changed?(key)
-          super.tap do
-            changed_attributes.delete(key) unless attribute_value_changed?(key)
+          # find the MongoMapper::Plugins::Keys::Key
+          _, key = keys.detect { |n, v| n == key_name }
+
+          # typecast to the new value
+          old_value = read_key(key_name)
+          new_value = key.type.to_mongo(value)
+
+          # only mark changed if really changed value (after typecasting)
+          unless old_value == new_value
+            attribute_will_change!(key_name)
           end
-        end
-      end
 
-      def attribute_value_changed?(key_name)
-        changed_attributes[key_name] != read_key(key_name)
+          super
+        end
       end
     end
   end