ssherman-mongo_mapper 0.8.6

data/lib/mongo_mapper/plugins/pagination.rb

@@ -0,0 +1,14 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Pagination
+      module ClassMethods
+        def per_page; 25 end
+
+        def paginate(opts={})
+          query.paginate({:per_page => per_page}.merge(opts))
+        end
+      end
+    end
+  end
+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

@@ -0,0 +1,53 @@
+# 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
+
+        def protected_attributes
+          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]
+          key
+        end
+      end
+
+      module InstanceMethods
+        def assign(attrs={})
+          super(filter_protected_attrs(attrs))
+        end
+
+        def update_attributes(attrs={})
+          super(filter_protected_attrs(attrs))
+        end
+
+        def update_attributes!(attrs={})
+          super(filter_protected_attrs(attrs))
+        end
+
+        def protected_attributes
+          self.class.protected_attributes
+        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
+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/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/rails.rb

@@ -0,0 +1,58 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Rails
+      def self.configure(model)
+        model.extend ActiveModel::Naming if defined?(ActiveModel)
+      end
+
+      module InstanceMethods
+        def to_param
+          id.to_s if persisted?
+        end
+
+        def to_model
+          self
+        end
+
+        def to_key
+          [id] if persisted?
+        end
+
+        def new_record?
+          new?
+        end
+
+        def read_attribute(name)
+          self[name]
+        end
+
+        def read_attribute_before_typecast(name)
+          read_key_before_typecast(name)
+        end
+
+        def write_attribute(name, value)
+          self[name] = value
+        end
+      end
+
+      module ClassMethods
+        def has_one(*args)
+          one(*args)
+        end
+
+        def has_many(*args)
+          many(*args)
+        end
+
+        def column_names
+          keys.keys
+        end
+
+        def human_name
+          self.name.demodulize.titleize
+        end
+      end
+    end
+  end
+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