mongo_mapper 0.13.0 → 0.15.1

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

@@ -5,10 +5,11 @@ module MongoMapper
       class SingleAssociation < Base
         def setup(model)
           @model = model
-          model.associations_module.module_eval <<-end_eval
+
+          model.associations_module.module_eval(<<-end_eval, __FILE__, __LINE__ + 1)
             def #{name}
               proxy = get_proxy(associations[#{name.inspect}])
-              proxy.nil? ? nil : proxy
+              proxy.nil? ? nil : proxy.read
             end
 
             def #{name}=(value)
@@ -20,7 +21,7 @@ module MongoMapper
               end
 
               proxy.replace(value)
-              value
+              proxy.read
             end
 
             def #{name}?
@@ -43,4 +44,4 @@ module MongoMapper
       end
     end
   end
-end
+end

data/lib/mongo_mapper/plugins/callbacks.rb

@@ -4,6 +4,18 @@ 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
@@ -13,6 +25,7 @@ module MongoMapper
       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

data/lib/mongo_mapper/plugins/document.rb

@@ -19,7 +19,7 @@ module MongoMapper
       end
 
       def reload
-        if doc = collection.find_one(:_id => id)
+        if doc = collection.find({:_id => id},{limit: -1}).first
           self.class.associations.each_value do |association|
             get_proxy(association).reset
           end

data/lib/mongo_mapper/plugins/dynamic_querying.rb

@@ -29,16 +29,17 @@ module MongoMapper
           end
         end
 
-        protected
-          def method_missing(method, *args, &block)
-            finder = DynamicFinder.new(method)
-
-            if finder.found?
-              dynamic_find(finder, args)
-            else
-              super
-            end
+      private
+
+        def method_missing(method, *args, &block)
+          finder = DynamicFinder.new(method)
+
+          if finder.found?
+            dynamic_find(finder, args)
+          else
+            super
           end
+        end
       end
     end
   end

data/lib/mongo_mapper/plugins/dynamic_querying/dynamic_finder.rb

@@ -20,25 +20,26 @@ module MongoMapper
           bang == true
         end
 
-        protected
-          def match
-            case method.to_s
-              when /^find_(all_by|by)_([_a-zA-Z]\w*)$/
-                @finder = :all if $1 == 'all_by'
-                names = $2
-              when /^find_by_([_a-zA-Z]\w*)\!$/
-                @bang = true
-                names = $1
-              when /^find_or_(initialize|create)_by_([_a-zA-Z]\w*)$/
-                @instantiator = $1 == 'initialize' ? :new : :create
-                names = $2
-              else
-                @finder = nil
-            end
+      protected
 
-            @attributes = names && names.split('_and_')
+        def match
+          case method.to_s
+            when /^find_(all_by|by)_([_a-zA-Z]\w*)$/
+              @finder = :all if $1 == 'all_by'
+              names = $2
+            when /^find_by_([_a-zA-Z]\w*)\!$/
+              @bang = true
+              names = $1
+            when /^find_or_(initialize|create)_by_([_a-zA-Z]\w*)$/
+              @instantiator = $1 == 'initialize' ? :new : :create
+              names = $2
+            else
+              @finder = nil
           end
+
+          @attributes = names && names.split('_and_')
+        end
       end
     end
   end
-end
+end

data/lib/mongo_mapper/plugins/embedded_callbacks.rb

@@ -8,7 +8,7 @@ module MongoMapper
         extend  ::ActiveModel::Callbacks
 
         define_model_callbacks :save, :create, :update, :destroy, :only => [:before, :after]
-        define_model_callbacks :touch, :only => [:after]
+        define_model_callbacks :initialize, :find, :touch, :only => [:after]
 
         proxy_callbacks(
           :before => [:save, :create, :update, :destroy],
@@ -44,6 +44,7 @@ module MongoMapper
           definition.each do |prefix, suffixes|
             suffixes.each do |suffix|
               callback = "%s_%s" % [prefix, suffix]
+
               class_eval <<-CALLBACK, __FILE__, __LINE__ + 1
                 class << self
                   alias_method :__original_#{callback}, :#{callback}

data/lib/mongo_mapper/plugins/embedded_document.rb

@@ -41,7 +41,7 @@ module MongoMapper
 
       def persist(options={})
         @_new = false
-        clear_changes if respond_to?(:clear_changes)
+        changes_applied if respond_to?(:changes_applied)
         save_to_collection(options)
       end
 

data/lib/mongo_mapper/plugins/identity_map.rb

@@ -69,7 +69,7 @@ module MongoMapper
           end
         end
 
-        def load(attrs)
+        def load(attrs, with_cast = false)
           return super unless Thread.current[:mongo_mapper_identity_map_enabled]
           return nil unless attrs
           document = get_from_identity_map(attrs['_id'])
@@ -133,10 +133,12 @@ module PluckyMethods
     end
 
     def find_each(opts={})
+      return super if !block_given?
+
       query = clone.amend(opts)
       super(opts) do |doc|
         doc.remove_from_identity_map if doc && query.fields?
-        yield doc if block_given?
+        yield doc
       end
     end
   end

data/lib/mongo_mapper/plugins/indexes.rb

@@ -6,31 +6,38 @@ module MongoMapper
 
       module ClassMethods
         def ensure_index(spec, options = {})
-          collection.ensure_index dealias_options(spec), options
+          #TODO: should we emulate the mongo 1.x behaviour of caching attempts to create indexes?
+          collection.indexes.create_one dealias_options(spec), options
         end
 
         def create_index(spec, options = {})
-          collection.create_index dealias_options(spec), options
+          collection.indexes.create_one dealias_options(spec), options
         end
 
         def drop_index(name)
-          collection.drop_index name
+          collection.indexes.drop_one name
         end
 
         def drop_indexes
-          collection.drop_indexes
+          collection.indexes.drop_all
         end
 
-        private
+      private
 
         def dealias_options(options)
           case options
           when Symbol, String
-             abbr(options)
+            {abbr(options) => 1}
           when Hash
             dealias_keys(options)
           when Array
-            options.map {|o| dealias_options(o) }
+            if options.first.is_a?(Hash)
+              options.map {|o| dealias_options(o) }
+            elsif options.first.is_a?(Array) # [[:foo, 1], [:bar, 1]]
+              options.inject({}) {|acc, tuple| acc.merge(dealias_options(tuple))}
+            else
+              dealias_keys(Hash[*options])
+            end
           else
             options
           end

data/lib/mongo_mapper/plugins/keys.rb

@@ -1,5 +1,6 @@
 # encoding: UTF-8
 require 'mongo_mapper/plugins/keys/key'
+require 'mongo_mapper/plugins/keys/static'
 
 module MongoMapper
   module Plugins
@@ -57,7 +58,7 @@ module MongoMapper
           Key.new(*args).tap do |key|
             keys[key.name] = key
             keys[key.abbr] = key if key.abbr
-            create_accessors_for(key) if key.valid_ruby_name?
+            create_accessors_for(key) if key.valid_ruby_name? && !key.reserved_name?
             create_key_in_descendants(*args)
             create_indexes_for(key)
             create_validations_for(key)
@@ -122,132 +123,144 @@ module MongoMapper
           end.allocate.initialize_from_database(attrs, with_cast)
         end
 
-        private
-          def key_accessors_module_defined?
-            # :nocov:
-            if IS_RUBY_1_9
-              const_defined?('MongoMapperKeys')
-            else
-              const_defined?('MongoMapperKeys', false)
-            end
-            # :nocov:
-          end
+      private
 
-          def accessors_module
-            if key_accessors_module_defined?
-              const_get 'MongoMapperKeys'
-            else
-              const_set 'MongoMapperKeys', Module.new
-            end
+        def key_accessors_module_defined?
+          # :nocov:
+          if IS_RUBY_1_9
+            const_defined?('MongoMapperKeys')
+          else
+            const_defined?('MongoMapperKeys', false)
           end
+          # :nocov:
+        end
 
-          def create_accessors_for(key)
-            accessors = ""
-            if key.read_accessor?
-              accessors << <<-end_eval
-                def #{key.name}
-                  read_key(:#{key.name})
-                end
-
-                def #{key.name}_before_type_cast
-                  read_key_before_type_cast(:#{key.name})
-                end
-              end_eval
-            end
-
-            if key.write_accessor?
-              accessors << <<-end_eval
-                def #{key.name}=(value)
-                  write_key(:#{key.name}, value)
-                end
-              end_eval
-            end
-
-            if key.predicate_accessor?
-              accessors << <<-end_eval
-                def #{key.name}?
-                  read_key(:#{key.name}).present?
-                end
-              end_eval
-            end
+        def accessors_module
+          if key_accessors_module_defined?
+            const_get 'MongoMapperKeys'
+          else
+            const_set 'MongoMapperKeys', Module.new
+          end
+        end
 
-            if block_given?
-              accessors_module.module_eval do
-                yield
+        def create_accessors_for(key)
+          accessors = ""
+          if key.read_accessor?
+            accessors << <<-end_eval
+              def #{key.name}
+                read_key(:#{key.name})
               end
-            end
 
-            accessors_module.module_eval accessors
-            include accessors_module
+              def #{key.name}_before_type_cast
+                read_key_before_type_cast(:#{key.name})
+              end
+            end_eval
           end
 
-          def create_key_in_descendants(*args)
-            descendants.each { |descendant| descendant.key(*args) }
+          if key.write_accessor?
+            accessors << <<-end_eval
+              def #{key.name}=(value)
+                write_key(:#{key.name}, value)
+              end
+            end_eval
           end
 
-          def remove_key_in_descendants(name)
-            descendants.each { |descendant| descendant.remove_key(name) }
+          if key.predicate_accessor?
+            accessors << <<-end_eval
+              def #{key.name}?
+                read_key(:#{key.name}).present?
+              end
+            end_eval
           end
 
-          def create_indexes_for(key)
-            if key.options[:index] && !key.embeddable?
-              warn "[DEPRECATION] :index option when defining key #{key.name.inspect} is deprecated. Put indexes in `db/indexes.rb`"
-              ensure_index key.name
+          if block_given?
+            accessors_module.module_eval do
+              yield
             end
           end
 
-          def create_validations_for(key)
-            attribute = key.name.to_sym
+          accessors_module.module_eval accessors
+          include accessors_module
+        end
 
-            if key.options[:required]
-              if key.type == Boolean
-                validates_inclusion_of attribute, :in => [true, false]
-              else
-                validates_presence_of(attribute)
-              end
-            end
+        def create_key_in_descendants(*args)
+          descendants.each { |descendant| descendant.key(*args) }
+        end
 
-            if key.options[:unique]
-              validates_uniqueness_of(attribute)
-            end
+        def remove_key_in_descendants(name)
+          descendants.each { |descendant| descendant.remove_key(name) }
+        end
 
-            if key.options[:numeric]
-              number_options = key.type == Integer ? {:only_integer => true} : {}
-              validates_numericality_of(attribute, number_options)
-            end
+        def create_indexes_for(key)
+          if key.options[:index] && !key.embeddable?
+            warn "[DEPRECATION] :index option when defining key #{key.name.inspect} is deprecated. Put indexes in `db/indexes.rb`"
+            ensure_index key.name
+          end
+        end
 
-            if key.options[:format]
-              validates_format_of(attribute, :with => key.options[:format])
-            end
+        def create_validations_for(key)
+          attribute = key.name.to_sym
 
-            if key.options[:in]
-              validates_inclusion_of(attribute, :in => key.options[:in])
+          if key.options[:required]
+            if key.type == Boolean
+              validates_inclusion_of attribute, :in => [true, false]
+            else
+              validates_presence_of(attribute)
             end
+          end
 
-            if key.options[:not_in]
-              validates_exclusion_of(attribute, :in => key.options[:not_in])
-            end
+          if key.options[:unique]
+            validates_uniqueness_of(attribute)
+          end
 
-            if key.options[:length]
-              length_options = case key.options[:length]
-              when Integer
-                {:minimum => 0, :maximum => key.options[:length]}
-              when Range
-                {:within => key.options[:length]}
-              when Hash
-                key.options[:length]
-              end
-              validates_length_of(attribute, length_options)
+          if key.options[:numeric]
+            number_options = key.type == Integer ? {:only_integer => true} : {}
+            validates_numericality_of(attribute, number_options)
+          end
+
+          if key.options[:format]
+            validates_format_of(attribute, :with => key.options[:format])
+          end
+
+          if key.options[:in]
+            validates_inclusion_of(attribute, :in => key.options[:in])
+          end
+
+          if key.options[:not_in]
+            validates_exclusion_of(attribute, :in => key.options[:not_in])
+          end
+
+          if key.options[:length]
+            length_options = case key.options[:length]
+            when Integer
+              {:minimum => 0, :maximum => key.options[:length]}
+            when Range
+              {:within => key.options[:length]}
+            when Hash
+              key.options[:length]
             end
+            validates_length_of(attribute, length_options)
           end
+        end
 
-          def remove_validations_for(name)
-            name = name.to_sym
-            a_name = [name]
+        def remove_validations_for(name)
+          name = name.to_sym
+          a_name = [name]
 
-            _validators.reject!{ |key, _| key == name }
-            _validate_callbacks.reject! {|callback| callback.raw_filter.attributes == a_name }
+          _validators.reject!{ |key, _| key == name }
+          remove_validate_callbacks a_name
+        end
+
+        def remove_validate_callbacks(a_name)
+          chain = _validate_callbacks.dup.reject do |callback|
+            f = callback.raw_filter
+            f.respond_to?(:attributes) && f.attributes == a_name
+          end
+          reset_callbacks(:validate)
+          chain.each do |callback|
+            set_callback 'validate', callback.raw_filter
           end
+        end
       end
 
       def initialize(attrs={})
@@ -282,8 +295,16 @@ module MongoMapper
         end
       end
 
+      # NOTE: We can't use alias_method here as we need the #attributes=
+      # superclass method to get called (for example:
+      # MongoMapper::Plugins::Accessible filters non-permitted parameters
+      # through `attributes=`
+      def assign_attributes(new_attributes)
+        self.attributes = new_attributes
+      end
+
       def to_mongo(include_abbreviatons = true)
-        BSON::OrderedHash.new.tap do |attrs|
+        Hash.new.tap do |attrs|
           self.class.unaliased_keys.each do |name, key|
             value = self.read_key(key.name)
             if key.type == ObjectId || !value.nil?
@@ -293,7 +314,7 @@ module MongoMapper
 
           embedded_associations.each do |association|
             if documents = instance_variable_get(association.ivar)
-              if association.instance_of?(Associations::OneAssociation)
+              if association.is_a?(Associations::OneAssociation)
                 attrs[association.name] = documents.to_mongo
               else
                 attrs[association.name] = documents.map(&:to_mongo)
@@ -360,8 +381,8 @@ module MongoMapper
         end
       end
 
-      alias_method :[], :read_key
-      alias_method :attribute, :read_key
+      def [](key_name); read_key(key_name); end
+      def attribute(key_name); read_key(key_name); end
 
       def []=(name, value)
         write_key(name, value)
@@ -379,7 +400,7 @@ module MongoMapper
         @embedded_keys ||= keys.values.select(&:embeddable?)
       end
 
-      protected
+    protected
 
       def unalias_key(name)
         name = name.to_s
@@ -390,68 +411,66 @@ module MongoMapper
         end
       end
 
-      private
+    private
 
-        def init_ivars
-          @__mm_keys = self.class.keys                                # Not dumpable
-          @__mm_default_keys = @__mm_keys.values.select(&:default?)   # Not dumpable
-          @_dynamic_attributes = {}                                      # Dumpable
-        end
+      def init_ivars
+        @__mm_keys = self.class.keys                                # Not dumpable
+        @__mm_default_keys = @__mm_keys.values.select(&:default?)   # Not dumpable
+        @_dynamic_attributes = {}                                      # Dumpable
+      end
 
-        def load_from_database(attrs, with_cast = false)
-          return if attrs == nil || attrs.blank?
+      def load_from_database(attrs, with_cast = false)
+        return if attrs == nil || attrs.blank?
 
-          attrs.each do |key, value|
-            if !@__mm_keys.key?(key) && respond_to?(:"#{key}=")
-              self.send(:"#{key}=", value)
-            else
-              internal_write_key key, value, with_cast
-            end
+        attrs.each do |key, value|
+          if !@__mm_keys.key?(key) && respond_to?(:"#{key}=")
+            self.send(:"#{key}=", value)
+          else
+            internal_write_key key, value, with_cast
           end
         end
+      end
 
-        def set_parent_document(key, value)
-          if key.type and value.instance_of?(key.type) && key.embeddable? && value.respond_to?(:_parent_document)
-            value._parent_document = self
-          end
+      def set_parent_document(key, value)
+        if key.type and value.instance_of?(key.type) && key.embeddable? && value.respond_to?(:_parent_document)
+          value._parent_document = self
         end
+      end
 
-        # This exists to be patched over by plugins, while letting us still get to the undecorated
-        # version of the method.
-        def write_key(name, value)
-          init_ivars unless @__mm_keys
-          internal_write_key(name.to_s, value)
-        end
+      # This exists to be patched over by plugins, while letting us still get to the undecorated
+      # version of the method.
+      def write_key(name, value)
+        init_ivars unless @__mm_keys
+        internal_write_key(name.to_s, value)
+      end
 
-        def internal_write_key(name, value, cast = true)
-          key         = @__mm_keys[name] || dynamic_key(name)
-          as_mongo    = cast ? key.set(value) : value
-          as_typecast = key.get(as_mongo)
-          if key.ivar
-            if key.embeddable?
-              set_parent_document(key, value)
-              set_parent_document(key, as_typecast)
-            end
-            instance_variable_set key.ivar, as_typecast
-          else
-            @_dynamic_attributes[key.name.to_sym] = as_typecast
+      def internal_write_key(name, value, cast = true)
+        key         = @__mm_keys[name] || dynamic_key(name)
+        as_mongo    = cast ? key.set(value) : value
+        as_typecast = key.get(as_mongo)
+        if key.ivar
+          if key.embeddable?
+            set_parent_document(key, value)
+            set_parent_document(key, as_typecast)
           end
-          @attributes = nil
-          value
+          instance_variable_set key.ivar, as_typecast
+        else
+          @_dynamic_attributes[key.name.to_sym] = as_typecast
         end
+        value
+      end
 
-        def dynamic_key(name)
-          self.class.key(name, :__dynamic => true)
-        end
+      def dynamic_key(name)
+        self.class.key(name, :__dynamic => true)
+      end
 
-        def initialize_default_values(except = {})
-          @__mm_default_keys.each do |key|
-            if !(except && except.key?(key.name))
-              internal_write_key key.name, key.default_value, false
-            end
+      def initialize_default_values(except = {})
+        @__mm_default_keys.each do |key|
+          if !(except && except.key?(key.name))
+            internal_write_key key.name, key.default_value, false
           end
         end
-      #end private
+      end
     end
   end
 end