mongo_mapper 0.13.0 → 0.15.1

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

@@ -3,10 +3,11 @@ module MongoMapper
   module Plugins
     module Keys
       class Key
-        attr_accessor :name, :type, :options, :default, :ivar, :abbr, :accessors
-
+        RESERVED_KEYS = %w( id class object_id attributes )
         ID_STR = '_id'
 
+        attr_accessor :name, :type, :options, :default, :ivar, :abbr, :accessors
+
         def initialize(*args)
           options_from_args = args.extract_options!
           @name, @type = args.shift.to_s, args.shift
@@ -60,12 +61,17 @@ module MongoMapper
           # Special Case: Generate default _id on access
           value = default_value if @is_id and !value
 
+          value = type.from_mongo(value)
+
           if @typecast
-            klass = typecast_class  # Don't make this lookup on every call
-            type.from_mongo(value).map { |v| klass.from_mongo(v) }
-          else
-            type.from_mongo(value)
+            klass = typecast_class # Don't make this lookup on every call
+            # typecast assumes array-ish object.
+            value = value.map { |v| klass.from_mongo(v) }
+            # recast it in the original type
+            value = type.from_mongo(value)
           end
+
+          value
         end
 
         def set(value)
@@ -93,6 +99,10 @@ module MongoMapper
           !!@name.match(/\A[a-z_][a-z0-9_]*\z/i)
         end
 
+        def reserved_name?
+          RESERVED_KEYS.include?(@name)
+        end
+
         def read_accessor?
           any_accessor? ["read"]
         end
@@ -111,18 +121,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")
+          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

@@ -13,7 +13,7 @@ module MongoMapper
           criteria, keys, options = criteria_and_keys_from_args(args)
           values, to_decrement = keys.values, {}
           keys.keys.each_with_index { |k, i| to_decrement[k] = -values[i].abs }
-          collection.update(criteria, {'$inc' => to_decrement}, :multi => true)
+          collection.update_many(criteria, {'$inc' => to_decrement}, options || {})
         end
 
         def set(*args)
@@ -44,7 +44,16 @@ module MongoMapper
         end
 
         def push_all(*args)
-          modifier_update('$pushAll', args)
+          Kernel.warn "push_all no longer supported. use $push with $each"
+
+          hash = args.pop
+          ids = args
+
+          push_values = hash.inject({}) do |hsh, (key, values)|
+            { key => { '$each' => values } }
+          end
+
+          modifier_update('$addToSet', [ids, push_values].flatten)
         end
 
         def add_to_set(*args)
@@ -64,61 +73,64 @@ module MongoMapper
           modifier_update('$pop', args)
         end
 
-        def find_and_modify(args)
-          args[:query]  = dealias_keys(args[:query])  if args.key? :query
-          args[:update] = dealias_keys(args[:update]) if args.key? :update
-          collection.find_and_modify(args)
+        def find_one_and_update(args)
+          args = args.dup
+          args[:query]  = dealias_keys(args.delete :query)  if args.key? :query
+          args[:update] = dealias_keys(args.delete :update) if args.key? :update
+          collection.find_one_and_update(args[:query], args[:update], args)
         end
+        alias_method :find_and_modify, :find_one_and_update
 
         def upsert(selector, updates, args = {})
           criteria = dealias_keys(selector)
           updates  = dealias_keys(updates)
-          collection.update(criteria, updates, args)
+          collection.update_one(criteria, updates, args.merge(upsert: 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
+      private
+
+        def modifier_update(modifier, args)
+          criteria, updates, options = criteria_and_keys_from_args(args)
+          if options
+            collection.update_many(criteria, {modifier => updates}, options)
+          else
+            collection.update_many(criteria, {modifier => updates})
           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
 
-          def upgrade_legacy_safe_usage!(options)
-            if options and options.key?(:safe)
-              options.merge! Utils.get_safe_options(options)
-              options.delete :safe
-            end
+          [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
+        end
       end
 
       def unset(*args)
         self.class.unset({:_id => id}, *args)
       end
 
-      def increment(hash, options=nil)
-        self.class.increment({:_id => id}, hash, options)
+      def increment(args, options=nil)
+        self.class.increment({:_id => id}, _args_for_counter(args), options)
       end
 
-      def decrement(hash, options=nil)
-        self.class.decrement({:_id => id}, hash, options)
+      def decrement(args, options=nil)
+        self.class.decrement({:_id => id}, _args_for_counter(args), options)
       end
 
       def set(hash, options=nil)
@@ -130,7 +142,13 @@ module MongoMapper
       end
 
       def push_all(hash, options=nil)
-        self.class.push_all({:_id => id}, hash, options)
+        Kernel.warn "push_all no longer supported. use $push with $each"
+
+        push_values = hash.inject({}) do |hsh, (key, values)|
+          { key => { '$each' => values } }
+        end
+
+        self.class.push({:_id => id}, push_values, options)
       end
 
       def pull(hash, options=nil)
@@ -149,6 +167,14 @@ module MongoMapper
       def pop(hash, options=nil)
         self.class.pop({:_id => id}, hash, options)
       end
+
+    private
+
+      def _args_for_counter(args)
+        args.kind_of?(String) || args.kind_of?(Symbol) ?
+          { args => 1 } :
+          args
+      end
     end
   end
 end

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

@@ -39,7 +39,7 @@ module MongoMapper
           if database_name.nil?
             MongoMapper.database
           else
-            connection.db(database_name)
+            connection.use(database_name).database
           end
         end
 
@@ -55,16 +55,21 @@ module MongoMapper
 
         def collection
           assert_supported
-          database.collection(collection_name)
+          database.collection(collection_name, collection_options)
         end
 
-        private
-          def assert_supported
-            @embeddable ||= embeddable?
-            if @embeddable
-              raise MongoMapper::NotSupported.new('This is not supported for embeddable documents at this time.')
-            end
+        def collection_options
+          {}
+        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,67 @@ 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))
+      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)
+
+        if query_options.any?
+          collection = self.collection.with(write: query_options)
+        else
+          collection = self.collection
         end
 
-        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_one(update, query_options)
+        when :save
+          collection.update_one({:_id => _id}, update, query_options.merge(upsert: true))
+        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_one(find_query, update_query, query_options)
+          end
         end
+      end
     end
   end
 end