mongo_mapper 0.13.1 → 0.14.0.rc1

data/lib/mongo_mapper/plugins/keys/key.rb

@@ -93,6 +93,11 @@ module MongoMapper
           !!@name.match(/\A[a-z_][a-z0-9_]*\z/i)
         end
 
+        RESERVED_KEYS = %w( id class object_id )
+        def reserved_name?
+          RESERVED_KEYS.include?(@name)
+        end
+
         def read_accessor?
           any_accessor? ["read"]
         end
@@ -111,18 +116,19 @@ module MongoMapper
           return !(@accessors & arr_opt).empty?
         end
 
-        private
-          def typecast_class
-            @typecast_class ||= options[:typecast].constantize
-          end
+      private
 
-          def validate_key_name!
-            if %w( id ).include? @name
-              raise MongoMapper::InvalidKey.new("`#{@name}` is a reserved key name (did you mean to use _id?)")
-            elsif !valid_ruby_name?
-              raise MongoMapper::InvalidKey.new("`#{@name}` is not a valid key name. Keys must match [a-z][a-z0-9_]*")
-            end
+        def typecast_class
+          @typecast_class ||= options[:typecast].constantize
+        end
+
+        def validate_key_name!
+          if reserved_name?
+            raise MongoMapper::InvalidKey.new("`#{@name}` is a reserved key name (did you mean to use _id?)")
+          elsif !valid_ruby_name?
+            raise MongoMapper::InvalidKey.new("`#{@name}` is not a valid key name. Keys must match [a-z][a-z0-9_]*")
           end
+        end
       end
     end
   end

data/lib/mongo_mapper/plugins/keys/static.rb

@@ -0,0 +1,45 @@
+module MongoMapper
+  module Plugins
+    module Keys
+      module Static
+        class MissingKeyError < StandardError; end
+
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          attr_writer :static_keys
+
+          def static_keys
+            @static_keys || false
+          end
+        end
+
+        def read_key(name)
+          if !self.class.static_keys || self.class.key?(name)
+            super
+          else
+            raise MissingKeyError, "Tried to read the key #{name.inspect}, but no key was defined. Either define key :#{name} or set self.static_keys = false"
+          end
+        end
+
+      private
+
+        def write_key(name, value)
+          if !self.class.static_keys || self.class.key?(name)
+            super
+          else
+            raise MissingKeyError, "Tried to write the key #{name.inspect}, but no key was defined. Either define key :#{name} or set self.static_keys = false"
+          end
+        end
+
+        def load_from_database(attrs, with_cast = false)
+          return super if !self.class.static_keys || !attrs.respond_to?(:each)
+
+          attrs = attrs.select { |key, _| self.class.key?(key) }
+
+          super(attrs, with_cast)
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/modifiers.rb

@@ -76,37 +76,38 @@ module MongoMapper
           collection.update(criteria, updates, args)
         end
 
-        private
-          def modifier_update(modifier, args)
-            criteria, updates, options = criteria_and_keys_from_args(args)
-            if options
-              collection.update(criteria, {modifier => updates}, options.merge(:multi => true))
-            else
-              collection.update(criteria, {modifier => updates}, :multi => true)
-            end
+      private
+
+        def modifier_update(modifier, args)
+          criteria, updates, options = criteria_and_keys_from_args(args)
+          if options
+            collection.update(criteria, {modifier => updates}, options.merge(:multi => true))
+          else
+            collection.update(criteria, {modifier => updates}, :multi => true)
           end
+        end
 
-          def criteria_and_keys_from_args(args)
-            if args[0].is_a?(Hash)
-              criteria = args[0]
-              updates  = args[1]
-              options  = args[2]
-            else
-              criteria, (updates, options) = args.partition { |a| !a.is_a?(Hash) }
-              criteria = { :id => criteria }
-            end
-            upgrade_legacy_safe_usage!(options)
-            updates = dealias_keys updates
-
-            [criteria_hash(criteria).to_hash, updates, options]
+        def criteria_and_keys_from_args(args)
+          if args[0].is_a?(Hash)
+            criteria = args[0]
+            updates  = args[1]
+            options  = args[2]
+          else
+            criteria, (updates, options) = args.partition { |a| !a.is_a?(Hash) }
+            criteria = { :id => criteria }
           end
+          upgrade_legacy_safe_usage!(options)
+          updates = dealias_keys updates
+
+          [criteria_hash(criteria).to_hash, updates, options]
+        end
 
-          def upgrade_legacy_safe_usage!(options)
-            if options and options.key?(:safe)
-              options.merge! Utils.get_safe_options(options)
-              options.delete :safe
-            end
+        def upgrade_legacy_safe_usage!(options)
+          if options and options.key?(:safe)
+            options.merge! Utils.get_safe_options(options)
+            options.delete :safe
           end
+        end
       end
 
       def unset(*args)

data/lib/mongo_mapper/plugins/partial_updates.rb

@@ -0,0 +1,86 @@
+module MongoMapper
+  module Plugins
+    module PartialUpdates
+      extend ActiveSupport::Concern
+
+      class PartialUpdatesDisabledError < StandardError; end
+
+      included do
+        class_attribute :partial_updates
+        self.partial_updates = false
+
+        self.after_find :_reset_partial_updates_callback
+        self.after_save :_reset_partial_updates_callback
+      end
+
+      def initialize(*)
+        _reset_partial_updates_callback
+        super
+      end
+
+      def fields_for_partial_update
+        raise PartialUpdatesDisabledError if !partial_updates
+
+        Hash.new.tap do |hash|
+          attrs = _dealiased_attributes
+
+          hash[:set_fields] = Array.new.tap do |array|
+            attrs.each do |key, value|
+              if !@_last_saved_attributes.include?(key) ||
+                  @_last_saved_attributes[key] != value
+                array << key
+              end
+            end
+          end
+
+          hash[:unset_fields] = @_last_saved_attributes.keys - attrs.keys
+        end
+      end
+
+    private
+
+      def _reset_partial_updates_callback
+        _reset_attributes_for_partial_update if partial_updates
+        true
+      end
+
+      def update(options={})
+        if partial_updates
+          super(options.merge(:persistence_method => :update))
+        else
+          super
+        end
+      end
+
+      def save_to_collection(options={})
+        if partial_updates && options[:persistence_method] == :update
+          updates = fields_for_partial_update
+
+          set_fields = updates[:set_fields]
+          unset_fields = updates[:unset_fields]
+
+          if set_fields.any? || unset_fields.any?
+            set_fields.push("_id") if !set_fields.include?("_id")
+          end
+
+          options = options.merge({
+            :set_fields => set_fields,
+            :unset_fields => unset_fields
+          })
+
+          super(options)
+        else
+          super
+        end
+      end
+
+      def _dealiased_attributes
+        self.class.dealias_keys(attributes)
+      end
+
+      def _reset_attributes_for_partial_update
+        @_last_saved_attributes = _dealiased_attributes._mongo_mapper_deep_copy_
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/persistence.rb

@@ -58,13 +58,14 @@ module MongoMapper
           database.collection(collection_name)
         end
 
-        private
-          def assert_supported
-            @embeddable ||= embeddable?
-            if @embeddable
-              raise MongoMapper::NotSupported.new('This is not supported for embeddable documents at this time.')
-            end
+      private
+
+        def assert_supported
+          @embeddable ||= embeddable?
+          if @embeddable
+            raise MongoMapper::NotSupported.new('This is not supported for embeddable documents at this time.')
           end
+        end
       end
 
       def collection

data/lib/mongo_mapper/plugins/protected.rb

@@ -35,11 +35,12 @@ module MongoMapper
         super(filter_protected_attrs(attrs))
       end
 
-      protected
-        def filter_protected_attrs(attrs)
-          return attrs if protected_attributes.blank? || attrs.blank?
-          attrs.dup.delete_if { |key, val| protected_attributes.include?(key.to_sym) }
-        end
+    protected
+
+      def filter_protected_attrs(attrs)
+        return attrs if protected_attributes.blank? || attrs.blank?
+        attrs.dup.delete_if { |key, val| protected_attributes.include?(key.to_sym) }
+      end
     end
   end
 end

data/lib/mongo_mapper/plugins/querying.rb

@@ -61,41 +61,42 @@ module MongoMapper
           Plucky::CriteriaHash.new(criteria, :object_ids => object_id_keys)
         end
 
-        private
-          def transformer
-            @transformer ||= lambda { |doc| load(doc) }
-          end
+      private
 
-          def initialize_each(*docs)
-            instances = []
-            docs = [{}] if docs.blank?
-            docs.flatten.each do |attrs|
-              doc = new(attrs)
-              yield(doc)
-              instances << doc
-            end
-            instances.size == 1 ? instances[0] : instances
-          end
+        def transformer
+          @transformer ||= lambda { |doc| load(doc) }
+        end
 
-          def update_single(id, attrs)
-            if id.blank? || attrs.blank? || !attrs.is_a?(Hash)
-              raise ArgumentError, "Updating a single document requires an id and a hash of attributes"
-            end
+        def initialize_each(*docs)
+          instances = []
+          docs = [{}] if docs.blank?
+          docs.flatten.each do |attrs|
+            doc = new(attrs)
+            yield(doc)
+            instances << doc
+          end
+          instances.size == 1 ? instances[0] : instances
+        end
 
-            find(id).tap do |doc|
-              doc.update_attributes(attrs)
-            end
+        def update_single(id, attrs)
+          if id.blank? || attrs.blank? || !attrs.is_a?(Hash)
+            raise ArgumentError, "Updating a single document requires an id and a hash of attributes"
           end
 
-          def update_multiple(docs)
-            unless docs.is_a?(Hash)
-              raise ArgumentError, "Updating multiple documents takes 1 argument and it must be hash"
-            end
+          find(id).tap do |doc|
+            doc.update_attributes(attrs)
+          end
+        end
 
-            instances = []
-            docs.each_pair { |id, attrs| instances << update(id, attrs) }
-            instances
+        def update_multiple(docs)
+          unless docs.is_a?(Hash)
+            raise ArgumentError, "Updating multiple documents takes 1 argument and it must be hash"
           end
+
+          instances = []
+          docs.each_pair { |id, attrs| instances << update(id, attrs) }
+          instances
+        end
       end
 
       def save(options={})
@@ -116,25 +117,61 @@ module MongoMapper
         self.class.delete(id).tap { @_destroyed = true } if persisted?
       end
 
-      private
-        def create_or_update(options={})
-          result = persisted? ? update(options) : create(options)
-          result != false
-        end
+    private
 
-        def create(options={})
-          save_to_collection(options.merge(:persistence_method => :insert))
-        end
+      def create_or_update(options={})
+        result = persisted? ? update(options) : create(options)
+        result != false
+      end
 
-        def update(options={})
-          save_to_collection(options.merge(:persistence_method => :save))
-        end
+      def create(options={})
+        save_to_collection(options.merge(:persistence_method => :insert))
+      end
+
+      def update(options={})
+        save_to_collection(options.reverse_merge(:persistence_method => :save))
+      end
+
+      def save_to_collection(options={})
+        @_new = false
+        method = options.delete(:persistence_method) || :save
+        update = to_mongo
+        query_options = Utils.get_safe_options(options)
 
-        def save_to_collection(options={})
-          @_new = false
-          method = options.delete(:persistence_method) || :save
-          collection.send(method, to_mongo, Utils.get_safe_options(options))
+        case method
+        when :insert
+          collection.insert(update, query_options)
+        when :save
+          collection.save(update, query_options)
+        when :update
+          update.stringify_keys!
+
+          id = update.delete("_id")
+
+          set_values = update
+          unset_values = {}
+
+          if fields_for_set = options.delete(:set_fields)
+            set_values = set_values.slice(*fields_for_set)
+          end
+
+          if fields_for_unset = options.delete(:unset_fields)
+            fields_for_unset.each do |field|
+              unset_values[field] = true
+            end
+          end
+
+          find_query = { :_id => id }
+
+          update_query = {}
+          update_query["$set"] = set_values if set_values.any?
+          update_query["$unset"] = unset_values if unset_values.any?
+
+          if update_query.any?
+            collection.update(find_query, update_query, query_options)
+          end
         end
+      end
     end
   end
 end

data/lib/mongo_mapper/plugins/querying/decorated_plucky_query.rb

@@ -58,17 +58,22 @@ module MongoMapper
           end
         end
 
-        protected
+      private
 
-          def method_missing(method, *args, &block)
-            return super unless model.respond_to?(method)
-            result = model.send(method, *args, &block)
-            if result.is_a?(Plucky::Query)
-              merge(result)
-            else
-              result
-            end
+        def method_missing(method, *args, &block)
+          return super unless model.respond_to?(method)
+
+          result = model.with_scope(criteria_hash) do
+            model.send(method, *args, &block)
           end
+
+          case result
+          when Plucky::Query
+            merge(result)
+          else
+            result
+          end
+        end
       end
     end
   end