mongo_mapper 0.10.1 → 0.11.0

data/lib/mongo_mapper/plugins/embedded_callbacks.rb

@@ -10,23 +10,21 @@ module MongoMapper
         define_model_callbacks :save, :create, :update, :destroy, :only => [:before, :after]
       end
 
-      module InstanceMethods
-        def run_callbacks(callback, *args, &block)
-          embedded_docs = []
+      def run_callbacks(callback, *args, &block)
+        embedded_docs = []
 
-          embedded_associations.each do |association|
-            embedded_docs += Array(get_proxy(association).send(:load_target))
-          end
+        embedded_associations.each do |association|
+          embedded_docs += Array(get_proxy(association).send(:load_target))
+        end
 
-          block = embedded_docs.inject(block) do |chain, doc|
-            if doc.class.respond_to?("_#{callback}_callbacks")
-              lambda { doc.run_callbacks(callback, *args, &chain) }
-            else
-              chain
-            end
+        block = embedded_docs.inject(block) do |chain, doc|
+          if doc.class.respond_to?("_#{callback}_callbacks")
+            lambda { doc.run_callbacks(callback, *args, &chain) }
+          else
+            chain
           end
-          super callback, *args, &block
         end
+        super callback, *args, &block
       end
     end
   end

data/lib/mongo_mapper/plugins/embedded_document.rb

@@ -18,37 +18,35 @@ module MongoMapper
         end
       end
 
-      module InstanceMethods
-        def new?
-          _root_document.try(:new?) || @_new
-        end
+      def new?
+        _root_document.try(:new?) || @_new
+      end
 
-        def destroyed?
-          !!_root_document.try(:destroyed?)
-        end
+      def destroyed?
+        !!_root_document.try(:destroyed?)
+      end
 
-        def save(options={})
-          _root_document.try(:save, options).tap do |result|
-            persist(options) if result
-          end
+      def save(options={})
+        _root_document.try(:save, options).tap do |result|
+          persist(options) if result
         end
+      end
 
-        def save!(options={})
-          valid? || raise(DocumentNotValid.new(self))
-          _root_document.try(:save!, options).tap do |result|
-            persist(options) if result
-          end
+      def save!(options={})
+        valid? || raise(DocumentNotValid.new(self))
+        _root_document.try(:save!, options).tap do |result|
+          persist(options) if result
         end
+      end
 
-        def persist(options={})
-          @_new = false
-          clear_changes if respond_to?(:clear_changes)
-          save_to_collection(options)
-        end
+      def persist(options={})
+        @_new = false
+        clear_changes if respond_to?(:clear_changes)
+        save_to_collection(options)
+      end
 
-        def _root_document
-          @_root_document ||= _parent_document.try(:_root_document)
-        end
+      def _root_document
+        @_root_document ||= _parent_document.try(:_root_document)
       end
     end
   end

data/lib/mongo_mapper/plugins/equality.rb

@@ -10,15 +10,13 @@ module MongoMapper
         end
       end
 
-      module InstanceMethods
-        def eql?(other)
-          other.is_a?(self.class) && _id == other._id
-        end
-        alias :== :eql?
+      def eql?(other)
+        other.is_a?(self.class) && _id == other._id
+      end
+      alias :== :eql?
 
-        def hash
-          _id.hash
-        end
+      def hash
+        _id.hash
       end
     end
   end

data/lib/mongo_mapper/plugins/identity_map.rb

@@ -108,22 +108,20 @@ module MongoMapper
           end
       end
 
-      module InstanceMethods
-        def identity_map
-          self.class.identity_map
-        end
+      def identity_map
+        self.class.identity_map
+      end
 
-        def save(*args)
-          if result = super
-            identity_map[_id] = self if self.class.identity_map_on?
-          end
-          result
+      def save(*args)
+        if result = super
+          identity_map[_id] = self if self.class.identity_map_on?
         end
+        result
+      end
 
-        def delete
-          identity_map.delete(_id) if self.class.identity_map_on?
-          super
-        end
+      def delete
+        identity_map.delete(_id) if self.class.identity_map_on?
+        super
       end
     end
   end

data/lib/mongo_mapper/plugins/inspect.rb

@@ -4,14 +4,12 @@ module MongoMapper
     module Inspect
       extend ActiveSupport::Concern
 
-      module InstanceMethods
-        def inspect(include_nil = false)
-          keys = include_nil ? key_names : attributes.keys
-          attributes_as_nice_string = keys.sort.collect do |name|
-            "#{name}: #{self[name].inspect}"
-          end.join(", ")
-          "#<#{self.class} #{attributes_as_nice_string}>"
-        end
+      def inspect(include_nil = false)
+        keys = include_nil ? key_names : attributes.keys
+        attributes_as_nice_string = keys.sort.collect do |name|
+          "#{name}: #{self[name].inspect}"
+        end.join(", ")
+        "#<#{self.class} #{attributes_as_nice_string}>"
       end
     end
   end

data/lib/mongo_mapper/plugins/keys.rb

@@ -159,151 +159,150 @@ module MongoMapper
           end
       end
 
-      module InstanceMethods
-        def initialize(attrs={})
-          @_new = true
-          self.attributes = attrs
-        end
+      def initialize(attrs={})
+        @_new = true
+        self.attributes = attrs
+      end
 
-        def initialize_from_database(attrs={})
-          @_new = false
-          load_from_database(attrs)
-          self
-        end
+      def initialize_from_database(attrs={})
+        @_new = false
+        load_from_database(attrs)
+        self
+      end
 
-        def persisted?
-          !new? && !destroyed?
-        end
+      def persisted?
+        !new? && !destroyed?
+      end
 
-        def attributes=(attrs)
-          return if attrs.blank?
+      def attributes=(attrs)
+        return if attrs.blank?
 
-          attrs.each_pair do |key, value|
-            if respond_to?(:"#{key}=")
-              self.send(:"#{key}=", value)
-            else
-              self[key] = value
-            end
+        attrs.each_pair do |key, value|
+          if respond_to?(:"#{key}=")
+            self.send(:"#{key}=", value)
+          else
+            self[key] = value
           end
         end
+      end
 
-        def attributes
-          HashWithIndifferentAccess.new.tap do |attrs|
-            keys.select { |name,key| !self[key.name].nil? || key.type == ObjectId }.each do |name, key|
-              value = key.set(self[key.name])
-              attrs[name] = value
-            end
+      def attributes
+        HashWithIndifferentAccess.new.tap do |attrs|
+          keys.select { |name,key| !self[key.name].nil? || key.type == ObjectId }.each do |name, key|
+            value = key.set(self[key.name])
+            attrs[name] = value
+          end
 
-            embedded_associations.each do |association|
-              if documents = instance_variable_get(association.ivar)
-                if association.is_a?(Associations::OneAssociation)
-                  attrs[association.name] = documents.to_mongo
-                else
-                  attrs[association.name] = documents.map { |document| document.to_mongo }
-                end
+          embedded_associations.each do |association|
+            if documents = instance_variable_get(association.ivar)
+              if association.is_a?(Associations::OneAssociation)
+                attrs[association.name] = documents.to_mongo
+              else
+                attrs[association.name] = documents.map { |document| document.to_mongo }
               end
             end
           end
         end
-        alias :to_mongo :attributes
-
-        def assign(attrs={})
-          warn "[DEPRECATION] #assign is deprecated, use #attributes="
-          self.attributes = attrs
-        end
-
-        def update_attributes(attrs={})
-          self.attributes = attrs
-          save
-        end
+      end
+      alias :to_mongo :attributes
 
-        def update_attributes!(attrs={})
-          self.attributes = attrs
-          save!
-        end
+      def assign(attrs={})
+        warn "[DEPRECATION] #assign is deprecated, use #attributes="
+        self.attributes = attrs
+      end
 
-        def update_attribute(name, value)
-          update_attributes(name.to_sym => value)
-        end
+      def update_attributes(attrs={})
+        self.attributes = attrs
+        save
+      end
 
-        def id
-          _id
-        end
+      def update_attributes!(attrs={})
+        self.attributes = attrs
+        save!
+      end
 
-        def id=(value)
-          if self.class.using_object_id?
-            value = ObjectId.to_mongo(value)
-          end
+      def update_attribute(name, value)
+        self.send(:"#{name}=", value)
+        save(:validate => false)
+      end
 
-          self[:_id] = value
-        end
+      def id
+        _id
+      end
 
-        def [](name)
-          read_key(name)
+      def id=(value)
+        if self.class.using_object_id?
+          value = ObjectId.to_mongo(value)
         end
 
-        def []=(name, value)
-          ensure_key_exists(name)
-          write_key(name, value)
-        end
+        self[:_id] = value
+      end
 
-        def keys
-          self.class.keys
-        end
+      def [](name)
+        read_key(name)
+      end
 
-        def key_names
-          keys.keys
-        end
+      def []=(name, value)
+        ensure_key_exists(name)
+        write_key(name, value)
+      end
 
-        def non_embedded_keys
-          keys.values.select { |key| !key.embeddable? }
-        end
+      def keys
+        self.class.keys
+      end
 
-        def embedded_keys
-          keys.values.select { |key| key.embeddable? }
-        end
+      def key_names
+        keys.keys
+      end
 
-        private
-          def load_from_database(attrs)
-            return if attrs.blank?
-            attrs.each do |key, value|
-              if respond_to?(:"#{key}=") && !self.class.key?(key)
-                self.send(:"#{key}=", value)
-              else
-                self[key] = value
-              end
-            end
-          end
+      def non_embedded_keys
+        keys.values.select { |key| !key.embeddable? }
+      end
 
-          def ensure_key_exists(name)
-            self.class.key(name) unless respond_to?("#{name}=")
-          end
+      def embedded_keys
+        keys.values.select { |key| key.embeddable? }
+      end
 
-          def set_parent_document(key, value)
-            if key.embeddable? && value.is_a?(key.type)
-              value._parent_document = self
+      private
+        def load_from_database(attrs)
+          return if attrs.blank?
+          attrs.each do |key, value|
+            if respond_to?(:"#{key}=") && !self.class.key?(key)
+              self.send(:"#{key}=", value)
+            else
+              self[key] = value
             end
           end
+        end
 
-          def read_key(key_name)
-            if key = keys[key_name.to_s]
-              value = key.get(instance_variable_get(:"@#{key_name}"))
-              set_parent_document(key, value)
-              instance_variable_set(:"@#{key_name}", value)
-            end
-          end
+        def ensure_key_exists(name)
+          self.class.key(name) unless respond_to?("#{name}=")
+        end
 
-          def read_key_before_type_cast(name)
-            instance_variable_get(:"@#{name}_before_type_cast")
+        def set_parent_document(key, value)
+          if key.embeddable? && value.is_a?(key.type)
+            value._parent_document = self
           end
+        end
 
-          def write_key(name, value)
-            key = keys[name.to_s]
+        def read_key(key_name)
+          if key = keys[key_name.to_s]
+            value = key.get(instance_variable_get(:"@#{key_name}"))
             set_parent_document(key, value)
-            instance_variable_set :"@#{name}_before_type_cast", value
-            instance_variable_set :"@#{name}", key.set(value)
+            instance_variable_set(:"@#{key_name}", value)
           end
-      end
+        end
+
+        def read_key_before_type_cast(name)
+          instance_variable_get(:"@#{name}_before_type_cast")
+        end
+
+        def write_key(name, value)
+          key = keys[name.to_s]
+          set_parent_document(key, value)
+          instance_variable_set :"@#{name}_before_type_cast", value
+          instance_variable_set :"@#{name}", key.set(value)
+        end
     end
   end
 end

data/lib/mongo_mapper/plugins/logger.rb

@@ -10,10 +10,8 @@ module MongoMapper
         end
       end
 
-      module InstanceMethods
-        def logger
-          self.class.logger
-        end
+      def logger
+        self.class.logger
       end
     end
   end

data/lib/mongo_mapper/plugins/modifiers.rb

@@ -75,47 +75,45 @@ module MongoMapper
           end
       end
 
-      module InstanceMethods
-        def unset(*keys)
-          self.class.unset(id, *keys)
-        end
+      def unset(*keys)
+        self.class.unset(id, *keys)
+      end
 
-        def increment(hash)
-          self.class.increment(id, hash)
-        end
+      def increment(hash)
+        self.class.increment(id, hash)
+      end
 
-        def decrement(hash)
-          self.class.decrement(id, hash)
-        end
+      def decrement(hash)
+        self.class.decrement(id, hash)
+      end
 
-        def set(hash)
-          self.class.set(id, hash)
-        end
+      def set(hash)
+        self.class.set(id, hash)
+      end
 
-        def push(hash)
-          self.class.push(id, hash)
-        end
-        
-        def push_all(hash)
-          self.class.push_all(id, hash)
-        end
+      def push(hash)
+        self.class.push(id, hash)
+      end
 
-        def pull(hash)
-          self.class.pull(id, hash)
-        end
-        
-        def pull_all(hash)
-          self.class.pull_all(id, hash)
-        end
+      def push_all(hash)
+        self.class.push_all(id, hash)
+      end
 
-        def add_to_set(hash)
-          self.class.push_uniq(id, hash)
-        end
-        alias push_uniq add_to_set
+      def pull(hash)
+        self.class.pull(id, hash)
+      end
 
-        def pop(hash)
-          self.class.pop(id, hash)
-        end
+      def pull_all(hash)
+        self.class.pull_all(id, hash)
+      end
+
+      def add_to_set(hash)
+        self.class.push_uniq(id, hash)
+      end
+      alias push_uniq add_to_set
+
+      def pop(hash)
+        self.class.pop(id, hash)
       end
     end
   end