mongo_mapper 0.6.10 → 0.7.0

data/lib/mongo_mapper/embedded_document.rb

@@ -1,380 +1,55 @@
 module MongoMapper
   module EmbeddedDocument
+    extend Support::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
 
-        extend Validations::Macros
+        plugin Plugins::Associations
+        plugin Plugins::Clone
+        plugin Plugins::Descendants
+        plugin Plugins::Equality
+        plugin Plugins::Inspect
+        plugin Plugins::Keys
+        plugin Plugins::Logger
+        plugin Plugins::Protected
+        plugin Plugins::Rails
+        plugin Plugins::Serialization
+        plugin Plugins::Validations
 
-        key :_id, ObjectId
-        attr_accessor :_root_document
+        attr_accessor :_root_document, :_parent_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)
+        true
       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
+      def embedded_in(owner_name)
+        define_method(owner_name) { _parent_document }
       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
+      def save(options={})
+        if result = _root_document.try(:save, options)
+          @new = false
         end
-        
-        self[:_id] = value
-      end
-
-      def using_custom_id?
-        !!@using_custom_id
+        result
       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)
-      end
-      
       def save!(options={})
-        _root_document.try(:save!, options)
-      end
-
-      def update_attributes(attrs={})
-        self.attributes = attrs
-        save
-      end
-
-      def update_attributes!(attrs={})
-        self.attributes = attrs
-        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
+        if result = _root_document.try(:save!, options)
+          @new = false
         end
+        result
+      end
     end # InstanceMethods
   end # EmbeddedDocument
 end # MongoMapper

data/lib/mongo_mapper/plugins.rb

@@ -0,0 +1,31 @@
+module MongoMapper
+  module Plugins
+    def plugins
+      @plugins ||= []
+    end
+
+    def plugin(mod)
+      extend mod::ClassMethods     if mod.const_defined?(:ClassMethods)
+      include mod::InstanceMethods if mod.const_defined?(:InstanceMethods)
+      mod.configure(self)          if mod.respond_to?(:configure)
+      plugins << mod
+    end
+
+    autoload :Callbacks,      'mongo_mapper/plugins/callbacks'
+    autoload :Clone,          'mongo_mapper/plugins/clone'
+    autoload :Descendants,    'mongo_mapper/plugins/descendants'
+    autoload :Dirty,          'mongo_mapper/plugins/dirty'
+    autoload :Equality,       'mongo_mapper/plugins/equality'
+    autoload :IdentityMap,    'mongo_mapper/plugins/identity_map'
+    autoload :Inspect,        'mongo_mapper/plugins/inspect'
+    autoload :Keys,           'mongo_mapper/plugins/keys'
+    autoload :Logger,         'mongo_mapper/plugins/logger'
+    autoload :Protected,      'mongo_mapper/plugins/protected'
+    autoload :Rails,          'mongo_mapper/plugins/rails'
+    autoload :Serialization,  'mongo_mapper/plugins/serialization'
+    autoload :Validations,    'mongo_mapper/plugins/validations'
+  end
+end
+
+require 'mongo_mapper/plugins/associations'
+require 'mongo_mapper/plugins/pagination'

data/lib/mongo_mapper/plugins/associations.rb

@@ -0,0 +1,105 @@
+module MongoMapper
+  module Plugins
+    module Associations
+      module ClassMethods
+        def belongs_to(association_id, options={}, &extension)
+          create_association(:belongs_to, association_id, options, &extension)
+        end
+
+        def many(association_id, options={}, &extension)
+          create_association(:many, association_id, options, &extension)
+        end
+
+        def one(association_id, options={}, &extension)
+          create_association(:one, association_id, options, &extension)
+        end
+
+        def associations
+          @associations ||= HashWithIndifferentAccess.new
+        end
+
+        def associations=(hash)
+          @associations = hash
+        end
+
+        def inherited(subclass)
+          subclass.associations = associations.dup
+          super
+        end
+
+        private
+          def create_association(type, name, options, &extension)
+            association = Associations::Base.new(type, name, options, &extension)
+            associations[association.name] = association
+
+            define_method(association.name) do
+              get_proxy(association)
+            end
+
+            define_method("#{association.name}=") do |value|
+              get_proxy(association).replace(value)
+              value
+            end
+
+            if association.one? || association.belongs_to?
+              define_method("#{association.name}?") do
+                get_proxy(association).present?
+              end
+            end
+
+            if association.options[:dependent] && association.many? && !association.embeddable?
+              after_destroy do |doc|
+                case association.options[:dependent]
+                  when :destroy
+                    doc.get_proxy(association).destroy_all
+                  when :delete_all
+                    doc.get_proxy(association).delete_all
+                  when :nullify
+                    doc.get_proxy(association).nullify
+                end
+              end
+            end
+          end
+      end
+
+      module InstanceMethods
+        def associations
+          self.class.associations
+        end
+
+        # @api private?
+        def embedded_associations
+          associations.select do |name, association|
+            association.embeddable?
+          end.map do |name, association|
+            association
+          end
+        end
+
+        def get_proxy(association)
+          unless proxy = self.instance_variable_get(association.ivar)
+            proxy = association.proxy_class.new(self, association)
+            self.instance_variable_set(association.ivar, proxy)
+          end
+
+          proxy
+        end
+      end
+
+      autoload :Base,                         'mongo_mapper/plugins/associations/base'
+      autoload :Collection,                   'mongo_mapper/plugins/associations/collection'
+      autoload :EmbeddedCollection,           'mongo_mapper/plugins/associations/embedded_collection'
+      autoload :ManyDocumentsProxy,           'mongo_mapper/plugins/associations/many_documents_proxy'
+      autoload :BelongsToProxy,               'mongo_mapper/plugins/associations/belongs_to_proxy'
+      autoload :BelongsToPolymorphicProxy,    'mongo_mapper/plugins/associations/belongs_to_polymorphic_proxy'
+      autoload :ManyPolymorphicProxy,         'mongo_mapper/plugins/associations/many_polymorphic_proxy'
+      autoload :ManyEmbeddedProxy,            'mongo_mapper/plugins/associations/many_embedded_proxy'
+      autoload :ManyEmbeddedPolymorphicProxy, 'mongo_mapper/plugins/associations/many_embedded_polymorphic_proxy'
+      autoload :ManyDocumentsAsProxy,         'mongo_mapper/plugins/associations/many_documents_as_proxy'
+      autoload :OneProxy,                     'mongo_mapper/plugins/associations/one_proxy'
+      autoload :InArrayProxy,                 'mongo_mapper/plugins/associations/in_array_proxy'
+    end
+  end
+end
+
+require 'mongo_mapper/plugins/associations/proxy'