mrkurt-mongo_mapper 0.6.8

data/lib/mongo_mapper/associations/belongs_to_polymorphic_proxy.rb

@@ -0,0 +1,26 @@
+module MongoMapper
+  module Associations
+    class BelongsToPolymorphicProxy < Proxy
+      def replace(doc)
+        if doc
+          doc.save if doc.new?
+          id, type = doc.id, doc.class.name
+        end
+        
+        owner[reflection.foreign_key] = id
+        owner[reflection.type_key_name] = type
+        reset
+      end
+      
+      protected
+        def find_target
+          return nil if association_class.nil? || owner[reflection.foreign_key].nil?
+          association_class.first(:id => owner[reflection.foreign_key])
+        end
+        
+        def association_class
+          proxy_owner[reflection.type_key_name] ? proxy_owner[reflection.type_key_name].constantize : nil
+        end
+    end
+  end
+end

data/lib/mongo_mapper/associations/belongs_to_proxy.rb

@@ -0,0 +1,21 @@
+module MongoMapper
+  module Associations
+    class BelongsToProxy < Proxy
+      def replace(doc)
+        if doc
+          doc.save if doc.new?
+          id = doc.id
+        end
+        
+        owner[reflection.foreign_key] = id
+        reset
+      end
+
+      protected
+        def find_target
+          return nil if owner[reflection.foreign_key].nil?
+          klass.first(:id => owner[reflection.foreign_key])
+        end
+    end
+  end
+end

data/lib/mongo_mapper/associations/collection.rb

@@ -0,0 +1,19 @@
+module MongoMapper
+  module Associations
+    class Collection < Proxy
+      def to_ary
+        load_target
+        if target.is_a?(Array)
+          target.to_ary
+        else
+          Array(target)
+        end
+      end
+      
+      def reset
+        super
+        target = []
+      end
+    end
+  end
+end

data/lib/mongo_mapper/associations/many_documents_as_proxy.rb

@@ -0,0 +1,26 @@
+module MongoMapper
+  module Associations
+    class ManyDocumentsAsProxy < ManyDocumentsProxy
+      protected
+        def scoped_conditions
+          {type_key_name => owner.class.name, id_key_name => owner.id}
+        end
+
+        def apply_scope(doc)
+          ensure_owner_saved
+          doc[type_key_name] = owner.class.name
+          doc[id_key_name] = owner.id
+          doc
+        end
+        
+      private
+        def type_key_name
+          "#{options[:as]}_type"
+        end
+        
+        def id_key_name
+          "#{options[:as]}_id"
+        end
+    end
+  end
+end

data/lib/mongo_mapper/associations/many_documents_proxy.rb

@@ -0,0 +1,115 @@
+module MongoMapper
+  module Associations
+    class ManyDocumentsProxy < Collection
+      include ::MongoMapper::Finders
+      
+      def find(*args)
+        options = args.extract_options!
+        klass.find(*args << scoped_options(options))
+      end
+      
+      def find!(*args)
+        options = args.extract_options!
+        klass.find!(*args << scoped_options(options))
+      end
+
+      def paginate(options)
+        klass.paginate(scoped_options(options))
+      end
+
+      def all(options={})
+        klass.all(scoped_options(options))
+      end
+
+      def first(options={})
+        klass.first(scoped_options(options))
+      end
+
+      def last(options={})
+        klass.last(scoped_options(options))
+      end
+
+      def count(options={})
+        klass.count(scoped_options(options))
+      end
+
+      def replace(docs)
+        load_target
+        target.map(&:destroy)
+        docs.each { |doc| apply_scope(doc).save }
+        reset
+      end
+
+      def <<(*docs)
+        ensure_owner_saved
+        flatten_deeper(docs).each { |doc| apply_scope(doc).save }
+        reset
+      end
+      alias_method :push, :<<
+      alias_method :concat, :<<
+
+      def build(attrs={})
+        doc = klass.new(attrs)
+        apply_scope(doc)
+        doc
+      end
+
+      def create(attrs={})
+        doc = klass.new(attrs)
+        apply_scope(doc).save
+        doc
+      end
+      
+      def create!(attrs={})
+        doc = klass.new(attrs)
+        apply_scope(doc).save!
+        doc
+      end
+
+      def destroy_all(options={})
+        all(options).map(&:destroy)
+        reset
+      end
+
+      def delete_all(options={})
+        klass.delete_all(options.merge(scoped_conditions))
+        reset
+      end
+      
+      def nullify
+        criteria = FinderOptions.new(klass, scoped_conditions).criteria
+        all(criteria).each do |doc|
+          doc.update_attributes(self.foreign_key => nil)
+        end
+        reset
+      end
+
+      protected
+        def scoped_conditions
+          {self.foreign_key => owner.id}
+        end
+        
+        def scoped_options(options)
+          reflection.finder_options.merge(options).merge(scoped_conditions)
+        end
+
+        def find_target
+          all
+        end
+
+        def ensure_owner_saved
+          owner.save if owner.new?
+        end
+
+        def apply_scope(doc)
+          ensure_owner_saved
+          doc[foreign_key] = owner.id
+          doc
+        end
+
+        def foreign_key
+          options[:foreign_key] || owner.class.name.underscore.gsub("/", "_") + "_id"
+        end
+    end
+  end
+end

data/lib/mongo_mapper/associations/many_embedded_polymorphic_proxy.rb

@@ -0,0 +1,31 @@
+module MongoMapper
+  module Associations
+    class ManyEmbeddedPolymorphicProxy < Collection
+      def replace(values)
+        @_values = values.map do |v|
+          if v.kind_of?(EmbeddedDocument)
+            v.attributes.merge(reflection.type_key_name => v.class.name)
+          else
+            v
+          end
+        end
+        reset
+      end
+
+      protected
+        def find_target
+          (@_values || []).map do |hash|
+            polymorphic_class(hash).new(hash)
+          end
+        end
+        
+        def polymorphic_class(doc)
+          if class_name = doc[reflection.type_key_name]
+            class_name.constantize
+          else
+            klass
+          end
+        end
+    end
+  end
+end

data/lib/mongo_mapper/associations/many_embedded_proxy.rb

@@ -0,0 +1,54 @@
+module MongoMapper
+  module Associations
+    class ManyEmbeddedProxy < Collection
+      def replace(values)
+        @_values = values.map do |v|
+          v.kind_of?(EmbeddedDocument) ? v.attributes : v
+        end
+        reset
+      end
+
+      def build(attributes={})
+        doc = klass.new(attributes)
+        assign_root_document(doc)
+        self << doc
+        doc
+      end
+
+      # TODO: test that both string and oid version work
+      def find(id)
+        load_target
+        target.detect { |item| item.id.to_s == id || item.id == id }
+      end
+
+      def <<(*docs)
+        load_target
+        docs.each do |doc|
+          assign_root_document(doc)
+          target << doc
+        end
+      end
+      alias_method :push, :<<
+      alias_method :concat, :<<
+
+      private
+        def find_target
+          (@_values || []).map do |v|
+            child = klass.new(v)
+            assign_root_document(child)
+            child
+          end
+        end
+
+        def root_document
+          owner._root_document || owner
+        end
+
+        def assign_root_document(*docs)
+          docs.each do |doc|
+            doc._root_document = root_document
+          end
+        end
+    end
+  end
+end

data/lib/mongo_mapper/associations/many_polymorphic_proxy.rb

@@ -0,0 +1,11 @@
+module MongoMapper
+  module Associations
+    class ManyPolymorphicProxy < ManyDocumentsProxy
+      private
+        def apply_scope(doc)
+          doc[reflection.type_key_name] = doc.class.name
+          super
+        end
+    end
+  end
+end

data/lib/mongo_mapper/associations/one_proxy.rb

@@ -0,0 +1,61 @@
+module MongoMapper
+  module Associations
+    class OneProxy < Proxy
+      def build(attrs={})
+        instantiate_target(:new, attrs)
+      end
+      
+      def create(attrs={})
+        instantiate_target(:create, attrs)
+      end
+      
+      def create!(attrs={})
+        instantiate_target(:create!, attrs)
+      end
+      
+      def replace(doc)
+        load_target
+        
+        if !@target.nil? && @target != doc
+          if options[:dependent] && !@target.new?
+            case options[:dependent]
+              when :delete
+                @target.delete
+              when :destroy
+                @target.destroy
+              when :nullify
+                @target[foreign_key] = nil
+                @target.save
+            end
+          end
+        end
+        
+        if doc
+          owner.save if owner.new?
+          doc[foreign_key] = owner.id
+          doc.save if doc.new?
+          reset
+        end
+      end
+
+      protected
+        def find_target
+          target_class.first(foreign_key => owner.id)
+        end
+        
+        def instantiate_target(instantiator, attrs={})
+          @target = target_class.send(instantiator, attrs.update(foreign_key => owner.id))
+          loaded
+          @target
+        end
+        
+        def target_class
+          @target_class ||= options[:class] || (options[:class_name] || association.name.to_s.camelize).constantize
+        end
+        
+        def foreign_key
+          options[:foreign_key] || owner.class.name.foreign_key
+        end
+    end
+  end
+end

data/lib/mongo_mapper/associations/proxy.rb

@@ -0,0 +1,111 @@
+module MongoMapper
+  module Associations
+    class Proxy
+      alias :proxy_respond_to? :respond_to?
+      alias :proxy_extend :extend
+      
+      instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?$|^send$|proxy_|^object_id$)/ }
+      
+      attr_reader :owner, :reflection, :target
+      
+      alias :proxy_owner :owner
+      alias :proxy_target :target
+      alias :proxy_reflection :reflection
+      
+      delegate :klass, :to => :proxy_reflection
+      delegate :options, :to => :proxy_reflection
+      delegate :collection, :to => :klass
+      
+      def initialize(owner, reflection)
+        @owner, @reflection = owner, reflection
+        Array(reflection.options[:extend]).each { |ext| proxy_extend(ext) }
+        reset
+      end
+      
+      def inspect
+        load_target
+        target.inspect
+      end
+      
+      def loaded?
+        @loaded
+      end
+      
+      def loaded
+        @loaded = true
+      end
+            
+      def nil?
+        load_target
+        target.nil?
+      end
+      
+      def blank?
+        load_target
+        target.blank?
+      end
+      
+      def reload
+        reset
+        load_target
+        self unless target.nil?
+      end
+      
+      def replace(v)
+        raise NotImplementedError
+      end
+
+      def reset
+        @loaded = false
+        target = nil
+      end
+
+      def respond_to?(*args)
+        proxy_respond_to?(*args) || (load_target && target.respond_to?(*args))
+      end
+
+      def send(method, *args)
+        if proxy_respond_to?(method)
+          super
+        else
+          load_target
+          target.send(method, *args)
+        end
+      end
+      
+      def ===(other)
+        load_target
+        other === target
+      end
+      
+      protected
+        def method_missing(method, *args, &block)
+          if load_target
+            if block_given?
+              target.send(method, *args)  { |*block_args| block.call(*block_args) }
+            else
+              target.send(method, *args)
+            end
+          end
+        end
+
+        def load_target
+          @target = find_target unless loaded?
+          loaded
+          @target
+        rescue MongoMapper::DocumentNotFound
+          reset
+        end
+
+        def find_target
+          raise NotImplementedError
+        end
+        
+        def flatten_deeper(array)
+          array.collect do |element|
+            (element.respond_to?(:flatten) && !element.is_a?(Hash)) ? element.flatten : element
+          end.flatten
+        end
+    end
+  end
+end