mongo_mapper-unstable 2010.3.8 → 2010.06.23

data/lib/mongo_mapper/plugins/modifiers.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 module MongoMapper
   module Plugins
     module Modifiers
@@ -14,7 +15,24 @@ module MongoMapper
         end
 
         def set(*args)
-          modifier_update('$set', args)
+          criteria, updates = criteria_and_keys_from_args(args)
+          updates.each do |key, value|
+            updates[key] = keys[key].set(value) if key?(key)
+          end
+          collection.update(criteria, {'$set' => updates}, :multi => true)
+        end
+
+        def unset(*args)
+          if args[0].is_a?(Hash)
+            criteria, keys = args.shift, args
+          else
+            keys, ids = args.partition { |arg| arg.is_a?(Symbol) }
+            criteria = {:id => ids}
+          end
+
+          criteria  = criteria_hash(criteria).to_hash
+          modifiers = keys.inject({}) { |hash, key| hash[key] = 1; hash }
+          collection.update(criteria, {'$unset' => modifiers}, :multi => true)
         end
 
         def push(*args)
@@ -25,11 +43,10 @@ module MongoMapper
           modifier_update('$pushAll', args)
         end
 
-        def push_uniq(*args)
-          criteria, keys = criteria_and_keys_from_args(args)
-          keys.each { |key, value | criteria[key] = {'$ne' => value} }
-          collection.update(criteria, {'$push' => keys}, :multi => true)
+        def add_to_set(*args)
+          modifier_update('$addToSet', args)
         end
+        alias push_uniq add_to_set
 
         def pull(*args)
           modifier_update('$pull', args)
@@ -45,41 +62,49 @@ module MongoMapper
 
         private
           def modifier_update(modifier, args)
-            criteria, keys = criteria_and_keys_from_args(args)
-            modifiers = {modifier => keys}
-            collection.update(criteria, modifiers, :multi => true)
+            criteria, updates = criteria_and_keys_from_args(args)
+            collection.update(criteria, {modifier => updates}, :multi => true)
           end
 
           def criteria_and_keys_from_args(args)
             keys     = args.pop
             criteria = args[0].is_a?(Hash) ? args[0] : {:id => args}
-            [to_criteria(criteria), keys]
+            [criteria_hash(criteria).to_hash, keys]
           end
       end
 
       module InstanceMethods
+        def unset(*keys)
+          self.class.unset(id, *keys)
+        end
+
         def increment(hash)
-          self.class.increment({:_id => id}, hash)
+          self.class.increment(id, hash)
         end
 
         def decrement(hash)
-          self.class.decrement({:_id => id}, hash)
+          self.class.decrement(id, hash)
         end
 
         def set(hash)
-          self.class.set({:_id => id}, hash)
+          self.class.set(id, hash)
         end
 
         def push(hash)
-          self.class.push({:_id => id}, hash)
+          self.class.push(id, hash)
         end
 
         def pull(hash)
-          self.class.pull({:_id => id}, hash)
+          self.class.pull(id, hash)
+        end
+
+        def add_to_set(hash)
+          self.class.push_uniq(id, hash)
         end
+        alias push_uniq add_to_set
 
-        def push_uniq(hash)
-          self.class.push_uniq({:_id => id}, hash)
+        def pop(hash)
+          self.class.pop(id, hash)
         end
       end
     end

data/lib/mongo_mapper/plugins/pagination.rb

@@ -1,24 +1,14 @@
+# encoding: UTF-8
 module MongoMapper
   module Plugins
     module Pagination
       module ClassMethods
-        def per_page
-          25
-        end
-
-        def paginate(options)
-          per_page      = options.delete(:per_page) || self.per_page
-          page          = options.delete(:page)
-          total_entries = count(options)
-          pagination    = Pagination::Proxy.new(total_entries, page, per_page)
+        def per_page; 25 end
 
-          options.update(:limit => pagination.limit, :skip => pagination.skip)
-          pagination.subject = find_many(options)
-          pagination
+        def paginate(opts={})
+          query.paginate({:per_page => per_page}.merge(opts))
         end
       end
     end
   end
-end
-
-require 'mongo_mapper/plugins/pagination/proxy'
+end

data/lib/mongo_mapper/plugins/persistence.rb

@@ -0,0 +1,69 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Persistence
+      module ClassMethods
+        def connection(mongo_connection=nil)
+          assert_supported
+          if mongo_connection.nil?
+            @connection ||= MongoMapper.connection
+          else
+            @connection = mongo_connection
+          end
+          @connection
+        end
+
+        def set_database_name(name)
+          assert_supported
+          @database_name = name
+        end
+
+        def database_name
+          assert_supported
+          @database_name
+        end
+
+        def database
+          assert_supported
+          if database_name.nil?
+            MongoMapper.database
+          else
+            connection.db(database_name)
+          end
+        end
+
+        def set_collection_name(name)
+          assert_supported
+          @collection_name = name
+        end
+
+        def collection_name
+          assert_supported
+          @collection_name ||= self.to_s.tableize.gsub(/\//, '.')
+        end
+
+        def collection
+          assert_supported
+          database.collection(collection_name)
+        end
+
+        private
+          def assert_supported
+            if embeddable?
+              raise NotSupported.new('This is not supported for embeddable documents at this time.')
+            end
+          end
+      end
+
+      module InstanceMethods
+        def collection
+          _root_document.class.collection
+        end
+
+        def database
+          _root_document.class.database
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/protected.rb

@@ -1,8 +1,12 @@
+# encoding: UTF-8
+require 'set'
+
 module MongoMapper
   module Plugins
     module Protected
       module ClassMethods
         def attr_protected(*attrs)
+          raise AccessibleOrProtected.new(name) if try(:accessible_attributes?)
           self.write_inheritable_attribute(:attr_protected, Set.new(attrs) + (protected_attributes || []))
         end
 
@@ -10,6 +14,10 @@ module MongoMapper
           self.read_inheritable_attribute(:attr_protected)
         end
 
+        def protected_attributes?
+          !protected_attributes.nil?
+        end
+
         def key(*args)
           key = super
           attr_protected key.name.to_sym if key.options[:protected]
@@ -36,7 +44,7 @@ module MongoMapper
 
         protected
           def filter_protected_attrs(attrs)
-            return attrs if protected_attributes.blank?
+            return attrs if protected_attributes.blank? || attrs.blank?
             attrs.dup.delete_if { |key, val| protected_attributes.include?(key.to_sym) }
           end
       end

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

@@ -0,0 +1,46 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Querying
+      module Decorator
+        include DynamicQuerying::ClassMethods
+
+        def model(model=nil)
+          return @model if model.nil?
+          @model = model
+          self
+        end
+
+        def find!(*ids)
+          raise DocumentNotFound, "Couldn't find without an ID" if ids.size == 0
+
+          find(*ids).tap do |result|
+            if result.nil? || ids.size != Array(result).size
+              raise DocumentNotFound, "Couldn't find all of the ids (#{ids.join(',')}). Found #{Array(result).size}, but was expecting #{ids.size}"
+            end
+          end
+        end
+
+        def all(opts={})
+          super.map { |doc| model.load(doc) }
+        end
+
+        def first(opts={})
+          model.load(super)
+        end
+
+        def last(opts={})
+          model.load(super)
+        end
+
+        private
+          def method_missing(method, *args, &block)
+            return super unless model.respond_to?(method)
+            result = model.send(method, *args, &block)
+            return super unless result.is_a?(Plucky::Query)
+            merge(result)
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# encoding: UTF-8
+require 'forwardable'
+
+module MongoMapper
+  module Plugins
+    module Querying
+      module PluckyMethods
+        extend Forwardable
+        def_delegators :query,  :where, :fields, :limit, :skip, :sort,
+                                :count, :last, :first, :all, :paginate,
+                                :find, :find!, :exists?, :exist?, :find_each
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/querying.rb

@@ -0,0 +1,176 @@
+# encoding: UTF-8
+require 'mongo_mapper/plugins/querying/decorator'
+require 'mongo_mapper/plugins/querying/plucky_methods'
+
+module MongoMapper
+  module Plugins
+    module Querying
+      module ClassMethods
+        include PluckyMethods
+
+        def find_each(opts={})
+          super(opts).each { |doc| yield load(doc) }
+        end
+
+        def find_by_id(id)
+          find_one(:_id => id)
+        end
+
+        def first_or_create(args)
+          first(args) || create(args.reject { |key, value| !key?(key) })
+        end
+
+        def first_or_new(args)
+          first(args) || new(args.reject { |key, value| !key?(key) })
+        end
+
+        def create(*docs)
+          initialize_each(*docs) { |doc| doc.save }
+        end
+
+        def create!(*docs)
+          initialize_each(*docs) { |doc| doc.save! }
+        end
+
+        def update(*args)
+          if args.length == 1
+            update_multiple(args[0])
+          else
+            id, attributes = args
+            update_single(id, attributes)
+          end
+        end
+
+        def delete(*ids)
+          query(:_id => ids.flatten).remove
+        end
+
+        def delete_all(options={})
+          query(options).remove
+        end
+
+        def destroy(*ids)
+          find_some!(ids.flatten).each(&:destroy)
+        end
+
+        def destroy_all(options={})
+          find_each(options) { |document| document.destroy }
+        end
+
+        # @api private for now
+        def query(options={})
+          Plucky::Query.new(collection).tap do |query|
+            query.extend(Decorator)
+            query.object_ids(object_id_keys)
+            query.update(options)
+            query.model(self)
+          end
+        end
+
+        # @api private for now
+        def criteria_hash(criteria={})
+          Plucky::CriteriaHash.new(criteria, :object_ids => object_id_keys)
+        end
+
+        private
+          def find_some(ids, options={})
+            query = query(options).update(:_id => ids.flatten.compact.uniq)
+            find_many(query.to_hash).compact
+          end
+
+          def find_some!(ids, options={})
+            ids  = ids.flatten.compact.uniq
+            docs = find_some(ids, options)
+
+            if ids.size != docs.size
+              raise DocumentNotFound, "Couldn't find all of the ids (#{ids.to_sentence}). Found #{docs.size}, but was expecting #{ids.size}"
+            end
+
+            docs
+          end
+
+          # All query methods that load documents pass through find_one or find_many
+          def find_one(options={})
+            query(options).first
+          end
+
+          # All query methods that load documents pass through find_one or find_many
+          def find_many(options)
+            query(options).all
+          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
+
+          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
+
+            find(id).tap do |doc|
+              doc.update_attributes(attrs)
+            end
+          end
+
+          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
+
+      module InstanceMethods
+        def save(options={})
+          options.assert_valid_keys(:validate, :safe)
+          options.reverse_merge!(:validate => true)
+          !options[:validate] || valid? ? create_or_update(options) : false
+        end
+
+        def save!(options={})
+          options.assert_valid_keys(:safe)
+          save(options) || raise(DocumentNotValid.new(self))
+        end
+
+        def destroy
+          delete
+        end
+
+        def delete
+          @_destroyed = true
+          self.class.delete(id) unless new?
+        end
+
+        private
+          def create_or_update(options={})
+            result = new? ? create(options) : update(options)
+            result != false
+          end
+
+          def create(options={})
+            save_to_collection(options)
+          end
+
+          def update(options={})
+            save_to_collection(options)
+          end
+
+          def save_to_collection(options={})
+            @_new = false
+            collection.save(to_mongo, :safe => options[:safe])
+          end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/rails.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 module MongoMapper
   module Plugins
     module Rails
@@ -7,13 +8,17 @@ module MongoMapper
 
       module InstanceMethods
         def to_param
-          id.to_s
+          id.to_s if persisted?
         end
 
         def to_model
           self
         end
 
+        def to_key
+          [id] if persisted?
+        end
+
         def new_record?
           new?
         end

data/lib/mongo_mapper/plugins/safe.rb

@@ -0,0 +1,28 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Safe
+      module ClassMethods
+        def inherited(subclass)
+          super
+          subclass.safe if safe?
+        end
+
+        def safe
+          @safe = true
+        end
+
+        def safe?
+          @safe == true
+        end
+      end
+
+      module InstanceMethods
+        def save_to_collection(options={})
+          options[:safe] = self.class.safe? unless options.key?(:safe)
+          super
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/sci.rb

@@ -0,0 +1,32 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Sci
+      module ClassMethods
+        def inherited(subclass)
+          key :_type, String unless key?(:_type)
+          subclass.instance_variable_set("@single_collection_inherited", true)
+          subclass.set_collection_name(collection_name) unless subclass.embeddable?
+          super
+        end
+
+        def single_collection_inherited?
+          @single_collection_inherited == true
+        end
+
+        def query(options={})
+          super.tap do |query|
+            query[:_type] = name if single_collection_inherited?
+          end
+        end
+      end
+
+      module InstanceMethods
+        def initialize(*args)
+          super
+          write_key :_type, self.class.name if self.class.key?(:_type)
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/scopes.rb

@@ -0,0 +1,21 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Scopes
+      module ClassMethods
+        def scope(name, scope_options={})
+          scopes[name] = lambda do |*args|
+            result = scope_options.is_a?(Proc) ? scope_options.call(*args) : scope_options
+            result = self.query(result) if result.is_a?(Hash)
+            self.query.merge(result)
+          end
+          singleton_class.send :define_method, name, &scopes[name]
+        end
+
+        def scopes
+          read_inheritable_attribute(:scopes) || write_inheritable_attribute(:scopes, {})
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/serialization.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 require 'active_support/json'
 
 module MongoMapper
@@ -6,7 +7,7 @@ module MongoMapper
       def self.configure(model)
         model.class_eval { cattr_accessor :include_root_in_json, :instance_writer => true }
       end
-      
+
       module InstanceMethods
         def as_json options={}
           options ||= {}
@@ -43,7 +44,7 @@ module MongoMapper
             }
           end
           # End rip
-          
+
           options.delete(:only) if options[:only].nil? or options[:only].empty?
 
           hash.each do |key, value|
@@ -51,13 +52,13 @@ module MongoMapper
               hash[key] = value.map do |item|
                 item.respond_to?(:as_json) ? item.as_json(options) : item
               end
-            elsif value.is_a? Mongo::ObjectID
+            elsif value.is_a? BSON::ObjectID
               hash[key] = value.to_s
             elsif value.respond_to?(:as_json)
               hash[key] = value.as_json(options)
             end
           end
-          
+
           # Replicate Rails 3 naming - and also bin anytihng after : for use in our dynamic classes from unit tests
           hash = { ActiveSupport::Inflector.underscore(ActiveSupport::Inflector.demodulize(self)).gsub(/:.*/,'') => hash } if include_root_in_json
           hash

data/lib/mongo_mapper/plugins/timestamps.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 module MongoMapper
   module Plugins
     module Timestamps
@@ -8,7 +9,7 @@ module MongoMapper
           class_eval { before_save :update_timestamps }
         end
       end
-      
+
       module InstanceMethods
         def update_timestamps
           now = Time.now.utc

data/lib/mongo_mapper/plugins/userstamps.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 module MongoMapper
   module Plugins
     module Userstamps

data/lib/mongo_mapper/plugins/validations.rb

@@ -1,16 +1,20 @@
+# encoding: UTF-8
 module MongoMapper
   module Plugins
     module Validations
       def self.configure(model)
-        model.class_eval { include Validatable }
+        model.class_eval do
+          include Validatable
+          extend Validations::DocumentMacros
+        end
       end
-      
+
       module DocumentMacros
         def validates_uniqueness_of(*args)
-          add_validations(args, MongoMapper::Plugins::Validations::ValidatesUniquenessOf)
+          add_validations(args, Validations::ValidatesUniquenessOf)
         end
       end
-      
+
       class ValidatesUniquenessOf < Validatable::ValidationBase
         option :scope, :case_sensitive
         default :case_sensitive => true
@@ -37,7 +41,7 @@ module MongoMapper
 
         def where_conditions(instance)
           conditions = {}
-          conditions[attribute] = /#{instance[attribute].to_s}/i unless case_sensitive
+          conditions[attribute] = /^#{Regexp.escape(instance[attribute].to_s)}$/i unless case_sensitive
           conditions
         end
       end