mongo_mapper 0.7.6 → 0.8.0

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

@@ -1,11 +1,10 @@
+# encoding: UTF-8
 module MongoMapper
   module Plugins
     module Persistence
       module ClassMethods
-        class Unsupported < MongoMapperError; end
-
         def connection(mongo_connection=nil)
-          not_supported_by_embedded
+          assert_supported
           if mongo_connection.nil?
             @connection ||= MongoMapper.connection
           else
@@ -15,17 +14,17 @@ module MongoMapper
         end
 
         def set_database_name(name)
-          not_supported_by_embedded
+          assert_supported
           @database_name = name
         end
 
         def database_name
-          not_supported_by_embedded
+          assert_supported
           @database_name
         end
 
         def database
-          not_supported_by_embedded
+          assert_supported
           if database_name.nil?
             MongoMapper.database
           else
@@ -34,23 +33,25 @@ module MongoMapper
         end
 
         def set_collection_name(name)
-          not_supported_by_embedded
+          assert_supported
           @collection_name = name
         end
 
         def collection_name
-          not_supported_by_embedded
+          assert_supported
           @collection_name ||= self.to_s.tableize.gsub(/\//, '.')
         end
 
         def collection
-          not_supported_by_embedded
+          assert_supported
           database.collection(collection_name)
         end
 
         private
-          def not_supported_by_embedded
-            raise Unsupported.new('This is not supported for embeddable documents at this time.') if embeddable?
+          def assert_supported
+            if embeddable?
+              raise NotSupported.new('This is not supported for embeddable documents at this time.')
+            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]

data/lib/mongo_mapper/plugins/querying.rb

@@ -0,0 +1,236 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Querying
+      module ClassMethods
+        def find(*args)
+          options = args.extract_options!
+          return nil if args.size == 0
+
+          if args.first.is_a?(Array) || args.size > 1
+            find_some(args, options)
+          else
+            find_one(options.merge(:_id => args[0]))
+          end
+        end
+
+        def find!(*args)
+          options = args.extract_options!
+          raise DocumentNotFound, "Couldn't find without an ID" if args.size == 0
+
+          if args.first.is_a?(Array) || args.size > 1
+            find_some!(args, options)
+          else
+            find_one(options.merge(:_id => args[0])) ||
+              raise(DocumentNotFound, "Document match #{options.inspect} does not exist
+                                        in #{collection.name} collection")
+          end
+        end
+
+        def find_each(options={})
+          query(options).find_each.each { |doc| yield load(doc) }
+        end
+
+        def find_by_id(id)
+          find_one(:_id => id)
+        end
+
+        def first(options={})
+          find_one(options)
+        end
+
+        # All bets are off an actual order if you provide none.
+        def last(options={})
+          find_one(query(options).reverse.to_hash)
+        end
+
+        def all(options={})
+          find_many(options)
+        end
+
+        def count(options={})
+          query(options).count
+        end
+
+        def exists?(options={})
+          !count(options).zero?
+        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
+
+        def where(options={})
+          query.where(options)
+        end
+
+        def fields(*args)
+          query.fields(*args)
+        end
+
+        def limit(*args)
+          query.limit(*args)
+        end
+
+        def skip(*args)
+          query.skip(*args)
+        end
+
+        def sort(*args)
+          query.sort(*args)
+        end
+
+        # @api private for now
+        def query(options={})
+          Plucky::Query.new(collection).tap do |query|
+            query.extend(MongoMapper::Plugins::Querying::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/querying/decorator.rb

@@ -0,0 +1,46 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Querying
+      module Decorator
+        include MongoMapper::Plugins::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/rails.rb

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

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