mongo_mapper 0.7.6 → 0.8.0

data/lib/mongo_mapper/document.rb

@@ -1,283 +1,41 @@
+# encoding: UTF-8
 module MongoMapper
   module Document
     extend Support::DescendantAppends
 
     def self.included(model)
       model.class_eval do
-        include InstanceMethods
-        extend  Support::Find
-        extend  ClassMethods
         extend  Plugins
 
+        plugin Plugins::Document
+        plugin Plugins::Querying # for now needs to be before associations (save_to_collection)
         plugin Plugins::Associations
+        plugin Plugins::Caching
         plugin Plugins::Clone
         plugin Plugins::Descendants
+        plugin Plugins::DynamicQuerying
         plugin Plugins::Equality
         plugin Plugins::Inspect
+        plugin Plugins::Indexes
         plugin Plugins::Keys
         plugin Plugins::Dirty # for now dirty needs to be after keys
         plugin Plugins::Logger
         plugin Plugins::Modifiers
         plugin Plugins::Pagination
         plugin Plugins::Persistence
+        plugin Plugins::Accessible
         plugin Plugins::Protected
         plugin Plugins::Rails
+        plugin Plugins::Safe # needs to be after querying (save_to_collection)
+        plugin Plugins::Sci
+        plugin Plugins::Scopes
         plugin Plugins::Serialization
         plugin Plugins::Timestamps
         plugin Plugins::Userstamps
         plugin Plugins::Validations
         plugin Plugins::Callbacks # for now callbacks needs to be after validations
-
-        extend Plugins::Validations::DocumentMacros
       end
-
       super
     end
-
-    module ClassMethods
-      def inherited(subclass)
-        subclass.set_collection_name(collection_name)
-        super
-      end
-
-      def ensure_index(spec, options={})
-        collection.create_index(spec, options)
-      end
-
-      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
-          query = query(options).update(:_id => args[0])
-          find_one(query.to_hash)
-        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
-          query = query(options).update(:_id => args[0])
-          find_one(query.to_hash) || raise(DocumentNotFound, "Document match #{options.inspect} does not exist in #{collection.name} collection")
-        end
-      end
-
-      def find_each(options={})
-        query(options).find().each { |doc| yield load(doc) }
-      end
-
-      def find_by_id(id)
-        find(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 first(options={})
-        find_one(options)
-      end
-
-      def last(options={})
-        raise ':order option must be provided when using last' if options[:order].blank?
-        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 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 embeddable?
-        false
-      end
-
-      def single_collection_inherited?
-        keys.key?(:_type) && single_collection_inherited_superclass?
-      end
-
-      def single_collection_inherited_superclass?
-        superclass.respond_to?(:keys) && superclass.keys.key?(:_type)
-      end
-
-      # @api private for now
-      def query(options={})
-        Query.new(self, options)
-      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 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
-          documents = find_some(ids, options)
-
-          if ids.size == documents.size
-            documents
-          else
-            raise DocumentNotFound, "Couldn't find all of the ids (#{ids.to_sentence}). Found #{documents.size}, but was expecting #{ids.size}"
-          end
-        end
-
-        # All query methods that load documents pass through find_one or find_many
-        def find_one(options={})
-          load(query(options).first)
-        end
-
-        # All query methods that load documents pass through find_one or find_many
-        def find_many(options)
-          query(options).all().map { |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
-
-          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
-
-      def new?
-        @new
-      end
-
-      def destroyed?
-        @_destroyed == true
-      end
-
-      def reload
-        if doc = self.class.query(:_id => id).first
-          self.class.associations.each { |name, assoc| send(name).reset if respond_to?(name) }
-          self.attributes = doc
-          self
-        else
-          raise DocumentNotFound, "Document match #{_id.inspect} does not exist in #{collection.name} collection"
-        end
-      end
-
-      # Used by embedded docs to find root easily without if/respond_to? stuff.
-      # Documents are always root documents.
-      def _root_document
-        self
-      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={})
-        safe = options[:safe] || false
-        @new = false
-        collection.save(to_mongo, :safe => safe)
-      end
-    end
   end # Document
 end # MongoMapper

data/lib/mongo_mapper/embedded_document.rb

@@ -1,14 +1,15 @@
+# encoding: UTF-8
 module MongoMapper
   module EmbeddedDocument
     extend Support::DescendantAppends
 
     def self.included(model)
       model.class_eval do
-        include InstanceMethods
-        extend  ClassMethods
         extend  Plugins
 
+        plugin Plugins::EmbeddedDocument
         plugin Plugins::Associations
+        plugin Plugins::Caching
         plugin Plugins::Clone
         plugin Plugins::Descendants
         plugin Plugins::Equality
@@ -16,55 +17,15 @@ module MongoMapper
         plugin Plugins::Keys
         plugin Plugins::Logger
         plugin Plugins::Persistence
+        plugin Plugins::Accessible
         plugin Plugins::Protected
         plugin Plugins::Rails
+        plugin Plugins::Sci
         plugin Plugins::Serialization
         plugin Plugins::Validations
         plugin Plugins::Callbacks
-
-        attr_reader :_root_document, :_parent_document
       end
-
       super
     end
-
-    module ClassMethods
-      def embeddable?
-        true
-      end
-
-      def embedded_in(owner_name)
-        define_method(owner_name) { _parent_document }
-      end
-    end
-
-    module InstanceMethods
-      def destroyed?
-        !!_root_document.try(:destroyed?)
-      end
-
-      def new?
-        _root_document.try(:new?) || @new
-      end
-
-      def save(options={})
-        if result = _root_document.try(:save, options)
-          @new = false
-        end
-        result
-      end
-
-      def save!(options={})
-        if result = _root_document.try(:save!, options)
-          @new = false
-        end
-        result
-      end
-
-      def _parent_document=(value)
-        @_root_document   = value._root_document
-        @_parent_document = value
-      end
-    end # InstanceMethods
-  end # EmbeddedDocument
-end # MongoMapper
+  end
+end

data/lib/mongo_mapper/exceptions.rb

@@ -0,0 +1,30 @@
+# encoding: UTF-8
+module MongoMapper
+  # generic MM error
+  class Error < StandardError; end
+
+  # raised when key expected to exist but not found
+  class KeyNotFound < Error; end
+
+  # raised when document expected but not found
+  class DocumentNotFound < Error; end
+
+  # raised when trying to connect using uri with incorrect scheme
+  class InvalidScheme < Error; end
+
+  # raised when trying to do something not supported, mostly for edocs
+  class NotSupported < Error; end
+
+  # raised when document not valid and using !
+  class DocumentNotValid < Error
+    def initialize(document)
+      super("Validation failed: #{document.errors.full_messages.join(", ")}")
+    end
+  end
+
+  class AccessibleOrProtected < Error
+    def initialize(name)
+      super("Declare either attr_protected or attr_accessible for #{name}, but not both.")
+    end
+  end
+end

data/lib/mongo_mapper/extensions/array.rb

@@ -0,0 +1,19 @@
+# encoding: UTF-8
+module MongoMapper
+  module Extensions
+    module Array
+      def to_mongo(value)
+        value = value.respond_to?(:lines) ? value.lines : value
+        value.to_a
+      end
+
+      def from_mongo(value)
+        value || []
+      end
+    end
+  end
+end
+
+class Array
+  extend MongoMapper::Extensions::Array
+end

data/lib/mongo_mapper/extensions/binary.rb

@@ -0,0 +1,22 @@
+# encoding: UTF-8
+module MongoMapper
+  module Extensions
+    module Binary
+      def to_mongo(value)
+        if value.is_a?(::BSON::Binary)
+          value
+        else
+          value.nil? ? nil : ::BSON::Binary.new(value)
+        end
+      end
+
+      def from_mongo(value)
+        value
+      end
+    end
+  end
+end
+
+class Binary
+  extend MongoMapper::Extensions::Binary
+end

data/lib/mongo_mapper/extensions/boolean.rb

@@ -0,0 +1,44 @@
+# encoding: UTF-8
+module MongoMapper
+  module Extensions
+    module Boolean
+      Mapping = {
+        true    => true, 
+        'true'  => true, 
+        'TRUE'  => true, 
+        'True'  => true, 
+        't'     => true, 
+        'T'     => true, 
+        '1'     => true, 
+        1       => true, 
+        1.0     => true,
+        false   => false, 
+        'false' => false, 
+        'FALSE' => false, 
+        'False' => false, 
+        'f'     => false, 
+        'F'     => false, 
+        '0'     => false, 
+        0       => false, 
+        0.0     => false, 
+        nil     => nil
+      }
+
+      def to_mongo(value)
+        if value.is_a?(Boolean)
+          value
+        else
+          Mapping[value]
+        end
+      end
+
+      def from_mongo(value)
+        value.nil? ? nil : !!value
+      end
+    end
+  end
+end
+
+class Boolean
+  extend MongoMapper::Extensions::Boolean
+end