mongo_mapper-unstable 2010.1.6 → 2010.1.12

data/VERSION

@@ -1 +1 @@
-2010.01.06
+2010.01.12

data/lib/mongo_mapper/descendant_appends.rb

@@ -0,0 +1,44 @@
+module MongoMapper
+  module DescendantAppends
+    def included(model)
+      extra_extensions.each { |extension| model.extend(extension) }
+      extra_inclusions.each { |inclusion| model.send(:include, inclusion) }
+      descendants << model
+    end
+    
+    # @api public
+    def descendants
+      @descendants ||= Set.new
+    end
+
+    # @api public
+    def append_extensions(*extensions)
+      extra_extensions.concat extensions
+
+      # Add the extension to existing descendants
+      descendants.each do |model|
+        extensions.each { |extension| model.extend(extension) }
+      end
+    end
+
+    # @api public
+    def append_inclusions(*inclusions)
+      extra_inclusions.concat inclusions
+
+      # Add the inclusion to existing descendants
+      descendants.each do |model|
+        inclusions.each { |inclusion| model.send(:include, inclusion) }
+      end
+    end
+
+    # @api private
+    def extra_extensions
+      @extra_extensions ||= []
+    end
+
+    # @api private
+    def extra_inclusions
+      @extra_inclusions ||= []
+    end
+  end
+end

data/lib/mongo_mapper/document.rb

@@ -1,66 +1,38 @@
-require 'set'
-
 module MongoMapper
   module Document
+    extend DescendantAppends
+
     def self.included(model)
       model.class_eval do
-        include EmbeddedDocument
         include InstanceMethods
-        include Callbacks
-        include Dirty
-        include RailsCompatibility::Document
-        extend Validations::Macros
-        extend ClassMethods
-        extend Finders
-
-        def self.per_page
-          25
-        end unless respond_to?(:per_page)
-      end
-
-      extra_extensions.each { |extension| model.extend(extension) }
-      extra_inclusions.each { |inclusion| model.send(:include, inclusion) }
-
-      descendants << model
-    end
-
-    def self.descendants
-      @descendants ||= Set.new
-    end
-
-    def self.append_extensions(*extensions)
-      extra_extensions.concat extensions
-
-      # Add the extension to existing descendants
-      descendants.each do |model|
-        extensions.each { |extension| model.extend(extension) }
+        extend  ClassMethods
+        extend  Finders
+
+        extend Plugins
+        plugin Plugins::Associations
+        plugin Plugins::Clone
+        plugin Plugins::Descendants
+        plugin Plugins::Equality
+        plugin Plugins::Inspect
+        plugin Plugins::Keys
+        plugin Plugins::Dirty # for now dirty needs to be after keys
+        plugin Plugins::Logger
+        plugin Plugins::Pagination
+        plugin Plugins::Rails
+        plugin Plugins::Serialization
+        plugin Plugins::Validations
+        plugin Plugins::Callbacks # for now callbacks needs to be after validations
+        
+        extend Plugins::Validations::DocumentMacros
       end
-    end
-
-    # @api private
-    def self.extra_extensions
-      @extra_extensions ||= []
-    end
-
-    def self.append_inclusions(*inclusions)
-      extra_inclusions.concat inclusions
-
-      # Add the inclusion to existing descendants
-      descendants.each do |model|
-        inclusions.each { |inclusion| model.send :include, inclusion }
-      end
-    end
-
-    # @api private
-    def self.extra_inclusions
-      @extra_inclusions ||= []
+      
+      super
     end
     
     module ClassMethods
-      def key(*args)
-        key = super
-        create_indexes_for(key)
-        key
+      def inherited(subclass)
+        subclass.set_collection_name(collection_name)
+        super
       end
 
       def ensure_index(name_or_array, options={})
@@ -98,17 +70,6 @@ module MongoMapper
         nil
       end
 
-      def paginate(options)
-        per_page      = options.delete(:per_page) || self.per_page
-        page          = options.delete(:page)
-        total_entries = count(options)
-        pagination    = Pagination::PaginationProxy.new(total_entries, page, per_page)
-
-        options.merge!(:limit => pagination.limit, :skip => pagination.skip)
-        pagination.subject = find_every(options)
-        pagination
-      end
-
       def first(options={})
         find_one(options)
       end
@@ -204,6 +165,10 @@ module MongoMapper
         modifier_update('$pullAll', args)
       end
       
+      def pop(*args)
+        modifier_update('$pop', args)
+      end
+      
       def modifier_update(modifier, args)
         criteria, keys = criteria_and_keys_from_args(args)
         modifiers = {modifier => keys}
@@ -218,6 +183,10 @@ module MongoMapper
       end
       private :criteria_and_keys_from_args
 
+      def embeddable?
+        false
+      end
+
       def connection(mongo_connection=nil)
         if mongo_connection.nil?
           @connection ||= MongoMapper.connection
@@ -269,23 +238,19 @@ module MongoMapper
       end
 
       def single_collection_inherited?
-        keys.has_key?('_type') && single_collection_inherited_superclass?
+        keys.key?(:_type) && single_collection_inherited_superclass?
       end
 
       def single_collection_inherited_superclass?
-        superclass.respond_to?(:keys) && superclass.keys.has_key?('_type')
+        superclass.respond_to?(:keys) && superclass.keys.key?(:_type)
       end
 
       private
-        def create_indexes_for(key)
-          ensure_index key.name if key.options[:index]
-        end
-
         def initialize_each(*docs)
           instances = []
           docs = [{}] if docs.blank?
           docs.flatten.each do |attrs|
-            doc = initialize_doc(attrs)
+            doc = new(attrs)
             yield(doc)
             instances << doc
           end
@@ -295,7 +260,7 @@ module MongoMapper
         def find_every(options)
           criteria, options = to_finder_options(options)
           collection.find(criteria, options).to_a.map do |doc|
-            initialize_doc(doc)
+            load(doc)
           end
         end
 
@@ -313,7 +278,7 @@ module MongoMapper
         def find_one(options={})
           criteria, options = to_finder_options(options)
           if doc = collection.find_one(criteria, options)
-            initialize_doc(doc)
+            load(doc)
           end
         end
 
@@ -366,20 +331,12 @@ module MongoMapper
       def collection
         self.class.collection
       end
-      
+
       def database
         self.class.database
       end
 
-      def new?
-        read_attribute('_id').blank? || using_custom_id?
-      end
-
       def save(options={})
-        if options === false
-          ActiveSupport::Deprecation.warn "save with true/false is deprecated. You should now use :validate => true/false."
-          options = {:validate => false}
-        end
         options.reverse_merge!(:validate => true)
         perform_validations = options.delete(:validate)
         !perform_validations || valid? ? create_or_update(options) : false
@@ -388,9 +345,19 @@ module MongoMapper
       def save!
         save || raise(DocumentNotValid.new(self))
       end
+      
+      def update_attributes(attrs={})
+        self.attributes = attrs
+        save
+      end
+
+      def update_attributes!(attrs={})
+        self.attributes = attrs
+        save!
+      end
 
       def destroy
-        self.class.delete(id) unless new?
+        delete
       end
       
       def delete
@@ -411,34 +378,23 @@ module MongoMapper
       end
 
       def create(options={})
-        assign_id
         save_to_collection(options)
       end
 
-      def assign_id
-        if read_attribute(:_id).blank?
-          write_attribute :_id, Mongo::ObjectID.new
-        end
-      end
-
       def update(options={})
         save_to_collection(options)
       end
 
       def save_to_collection(options={})
-        clear_custom_id_flag
         safe = options.delete(:safe) || false
+        @new = false
         collection.save(to_mongo, :safe => safe)
       end
 
       def update_timestamps
         now = Time.now.utc
-        write_attribute('created_at', now) if new? && read_attribute('created_at').blank?
-        write_attribute('updated_at', now)
-      end
-
-      def clear_custom_id_flag
-        @using_custom_id = nil
+        self[:created_at] = now if new? && !created_at?
+        self[:updated_at] = now
       end
     end
   end # Document

data/lib/mongo_mapper/embedded_document.rb

@@ -1,380 +1,60 @@
 module MongoMapper
   module EmbeddedDocument
+    extend DescendantAppends
+    
     def self.included(model)
       model.class_eval do
-        extend ClassMethods
         include InstanceMethods
-        
-        extend Associations::ClassMethods
-        include Associations::InstanceMethods
-
-        include RailsCompatibility::EmbeddedDocument
-        include Validatable
-        include Serialization
+        extend  ClassMethods
+        
+        extend Plugins
+        plugin Plugins::Associations
+        plugin Plugins::Clone
+        plugin Plugins::Descendants
+        plugin Plugins::Equality
+        plugin Plugins::Inspect
+        plugin Plugins::Keys
+        plugin Plugins::Logger
+        plugin Plugins::Rails
+        plugin Plugins::Serialization
+        plugin Plugins::Validations
 
-        extend Validations::Macros
-
-        key :_id, ObjectId
         attr_accessor :_root_document
       end
+      
+      super
     end
 
     module ClassMethods
-      def logger
-        MongoMapper.logger
-      end
-
-      def inherited(subclass)
-        unless subclass.embeddable?
-          subclass.set_collection_name(collection_name)
-        end
-
-        (@subclasses ||= []) << subclass
-      end
-
-      def subclasses
-        @subclasses
-      end
-
-      def keys
-        @keys ||= if parent = parent_model
-          parent.keys.dup
-        else
-          HashWithIndifferentAccess.new
-        end
-      end
-
-      def key(*args)
-        key = Key.new(*args)
-        keys[key.name] = key
-
-        create_accessors_for(key)
-        create_key_in_subclasses(*args)
-        create_validations_for(key)
-
-        key
-      end
-      
-      def using_object_id?
-        object_id_key?(:_id)
-      end
-      
-      def object_id_key?(name)
-        key = keys[name.to_s]
-        key && key.type == ObjectId
-      end
-
       def embeddable?
-        !self.ancestors.include?(Document)
-      end
-
-      def parent_model
-        (ancestors - [self,EmbeddedDocument]).find do |parent_class|
-          parent_class.ancestors.include?(EmbeddedDocument)
-        end
-      end
-      
-      def to_mongo(instance)
-        return nil if instance.nil?
-        instance.to_mongo
-      end
-      
-      def from_mongo(value)
-        return nil if value.nil?
-        value.is_a?(self) ? value : initialize_doc(value)
-      end
-      
-    private
-      def initialize_doc(doc)
-        begin
-          klass = doc['_type'].present? ? doc['_type'].constantize : self
-          klass.new(doc)
-        rescue NameError
-          new(doc)
-        end
-      end
-      
-      def accessors_module
-        module_defined =  if method(:const_defined?).arity == 1 # Ruby 1.9 compat check
-                            const_defined?('MongoMapperKeys')
-                          else
-                            const_defined?('MongoMapperKeys', false)
-                          end
-
-        if module_defined
-          const_get 'MongoMapperKeys'
-        else
-          const_set 'MongoMapperKeys', Module.new
-        end
-      end
-
-      def create_accessors_for(key)
-        accessors_module.module_eval <<-end_eval
-          def #{key.name}
-            read_attribute(:'#{key.name}')
-          end
-
-          def #{key.name}_before_typecast
-            read_attribute_before_typecast(:'#{key.name}')
-          end
-
-          def #{key.name}=(value)
-            write_attribute(:'#{key.name}', value)
-          end
-
-          def #{key.name}?
-            read_attribute(:#{key.name}).present?
-          end
-        end_eval
-        include accessors_module
-      end
-      
-      def create_key_in_subclasses(*args)
-        return if subclasses.blank?
-
-        subclasses.each do |subclass|
-          subclass.key(*args)
-        end
-      end
-
-      def create_validations_for(key)
-        attribute = key.name.to_sym
-
-        if key.options[:required]
-          validates_presence_of(attribute)
-        end
-
-        if key.options[:unique]
-          validates_uniqueness_of(attribute)
-        end
-
-        if key.options[:numeric]
-          number_options = key.type == Integer ? {:only_integer => true} : {}
-          validates_numericality_of(attribute, number_options)
-        end
-
-        if key.options[:format]
-          validates_format_of(attribute, :with => key.options[:format])
-        end
-
-        if key.options[:length]
-          length_options = case key.options[:length]
-          when Integer
-            {:minimum => 0, :maximum => key.options[:length]}
-          when Range
-            {:within => key.options[:length]}
-          when Hash
-            key.options[:length]
-          end
-          validates_length_of(attribute, length_options)
-        end
+        true
       end
     end
 
     module InstanceMethods
-      def initialize(attrs={})
-        unless attrs.nil?
-          associations.each do |name, association|
-            if collection = attrs.delete(name)
-              if association.many? && association.klass.embeddable?
-                root_document = attrs[:_root_document] || self
-                collection.each do |doc|
-                  doc[:_root_document] = root_document
-                end
-              end
-              send("#{association.name}=", collection)
-            end
-          end
-
-          self.attributes = attrs
-          
-          if respond_to?(:_type=) && self['_type'].blank?
-            self._type = self.class.name
-          end
-        end
-
-        if self.class.embeddable?
-          if read_attribute(:_id).blank?
-            write_attribute :_id, Mongo::ObjectID.new
-            @new_document = true
-          else
-            @new_document = false
-          end
-        end
-      end
-
-      def new?
-        !!@new_document
-      end
-      
-      def to_param
-        id.to_s
-      end
-
-      def attributes=(attrs)
-        return if attrs.blank?
-        attrs.each_pair do |name, value|
-          writer_method = "#{name}="
-
-          if respond_to?(writer_method)
-            self.send(writer_method, value)
-          else
-            self[name.to_s] = value
-          end
-        end
-      end
-
-      def attributes
-        attrs = HashWithIndifferentAccess.new
-        
-        embedded_keys.each do |key|
-          attrs[key.name] = read_attribute(key.name).try(:attributes)
-        end
-        
-        non_embedded_keys.each do |key|
-          attrs[key.name] = read_attribute(key.name)
-        end
-        
-        embedded_associations.each do |association|
-          documents = instance_variable_get(association.ivar)
-          next if documents.nil?
-          attrs[association.name] = documents.collect { |doc| doc.attributes }
-        end
-        
-        attrs
-      end
-      
-      def to_mongo
-        attrs = HashWithIndifferentAccess.new
-        
-        _keys.each_pair do |name, key|
-          value = key.set(read_attribute(key.name))
-          attrs[name] = value unless value.nil?
-        end
-        
-        embedded_associations.each do |association|
-          if documents = instance_variable_get(association.ivar)
-            attrs[association.name] = documents.map { |document| document.to_mongo }
-          end
-        end
-        
-        attrs
-      end
-
-      def clone
-        clone_attributes = self.attributes
-        clone_attributes.delete("_id")
-        self.class.new(clone_attributes)
-      end
-
-      def [](name)
-        read_attribute(name)
-      end
-
-      def []=(name, value)
-        ensure_key_exists(name)
-        write_attribute(name, value)
-      end
-
-      def ==(other)
-        other.is_a?(self.class) && _id == other._id
-      end
-
-      def id
-        self[:_id]
-      end
-
-      def id=(value)
-        if self.class.using_object_id?
-          value = MongoMapper.normalize_object_id(value)
-        else
-          @using_custom_id = true
-        end
-        
-        self[:_id] = value
-      end
-
-      def using_custom_id?
-        !!@using_custom_id
-      end
-
-      def inspect
-        attributes_as_nice_string = key_names.collect do |name|
-          "#{name}: #{read_attribute(name).inspect}"
-        end.join(", ")
-        "#<#{self.class} #{attributes_as_nice_string}>"
-      end
-
       def save(options={})
-        _root_document.try(:save, options)
+        if result = _root_document.try(:save, options)
+          @new = false
+        end
+        result
       end
       
       def save!(options={})
-        _root_document.try(:save!, options)
+        if result = _root_document.try(:save!, options)
+          @new = false
+        end
+        result
       end
 
       def update_attributes(attrs={})
         self.attributes = attrs
-        save
+        self.save
       end
 
       def update_attributes!(attrs={})
         self.attributes = attrs
-        save!
+        self.save!
       end
-      
-      def logger
-        self.class.logger
-      end
-
-      private
-        def _keys
-          self.metaclass.keys
-        end
-        
-        def key_names
-          _keys.keys
-        end
-        
-        def non_embedded_keys
-          _keys.values.select { |key| !key.embeddable? }
-        end
-        
-        def embedded_keys
-          _keys.values.select { |key| key.embeddable? }
-        end
-        
-        def ensure_key_exists(name)
-          self.metaclass.key(name) unless respond_to?("#{name}=")
-        end
-
-        def read_attribute(name)
-          if key = _keys[name]
-            value = key.get(instance_variable_get("@#{name}"))
-            instance_variable_set "@#{name}", value
-            value
-          else
-            raise KeyNotFound, "Could not find key: #{name.inspect}"
-          end
-        end
-
-        def read_attribute_before_typecast(name)
-          instance_variable_get("@#{name}_before_typecast")
-        end
-
-        def write_attribute(name, value)
-          key = _keys[name]
-          instance_variable_set "@#{name}_before_typecast", value
-          instance_variable_set "@#{name}", key.set(value)
-        end
-        
-        def embedded_associations
-          associations.select do |name, association|
-            association.embeddable?
-          end.map do |name, association|
-            association
-          end
-        end
     end # InstanceMethods
   end # EmbeddedDocument
 end # MongoMapper