danielharan-mongo_mapper 0.6.5

data/lib/mongo_mapper/associations/base.rb

@@ -0,0 +1,110 @@
+module MongoMapper
+  module Associations
+    # Base class for keeping track of associations.
+    #
+    # @private
+    class Base
+      attr_reader :type, :name, :options, :finder_options
+
+      # Options that should not be considered MongoDB query options/criteria
+      AssociationOptions = [:as, :class, :class_name, :dependent, :extend, :foreign_key, :polymorphic]
+
+      def initialize(type, name, options={}, &extension)
+        @type, @name, @options, @finder_options = type, name, {}, {}
+        options.symbolize_keys!
+
+        options[:extend] = modulized_extensions(extension, options[:extend])
+
+        options.each_pair do |key, value|
+          if AssociationOptions.include?(key)
+            @options[key] = value
+          else
+            @finder_options[key] = value
+          end
+        end
+      end
+
+      def class_name
+        @class_name ||= begin
+          if cn = options[:class_name]
+            cn
+          elsif many?
+            name.to_s.singularize.camelize
+          else
+            name.to_s.camelize
+          end
+        end
+      end
+
+      def klass
+        @klass ||= options[:class] || class_name.constantize
+      end
+
+      def many?
+        @many_type ||= @type == :many
+      end
+
+      def belongs_to?
+        @belongs_to_type ||= @type == :belongs_to
+      end
+
+      def polymorphic?
+        !!@options[:polymorphic]
+      end
+
+      def as?
+        !!@options[:as]
+      end
+
+      def type_key_name
+        @type_key_name ||= many? ? '_type' : "#{as}_type"
+      end
+
+      def as
+        @options[:as] || self.name
+      end
+
+      def foreign_key
+        @options[:foreign_key] || "#{name}_id"
+      end
+
+      def ivar
+        @ivar ||= "@_#{name}"
+      end
+
+      def embeddable?
+        many? && klass.embeddable?
+      end
+
+      def proxy_class
+        @proxy_class ||= begin
+          if many?
+            if self.klass.embeddable?
+              polymorphic? ? ManyEmbeddedPolymorphicProxy : ManyEmbeddedProxy
+            else
+              if polymorphic?
+                ManyPolymorphicProxy
+              elsif as?
+                ManyDocumentsAsProxy
+              else
+                ManyProxy
+              end
+            end
+          else
+            polymorphic? ? BelongsToPolymorphicProxy : BelongsToProxy
+          end
+        end # end begin
+      end # end proxy_class
+
+      private
+
+        # @param [Array<Module, Proc>] extensions a collection of Modules or 
+        #   Procs that extend the behaviour of this association.
+        def modulized_extensions(*extensions)
+          extensions.flatten.compact.map do |extension|
+            Proc === extension ? Module.new(&extension) : extension
+          end
+        end
+    end
+  end
+end

data/lib/mongo_mapper/associations/belongs_to_polymorphic_proxy.rb

@@ -0,0 +1,34 @@
+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.send("#{@association.foreign_key}=", id)
+        @owner.send("#{@association.type_key_name}=", type)
+        reset
+      end
+      
+      protected
+        def find_target
+          if proxy_id && proxy_class
+            proxy_class.find_by_id(proxy_id)
+          end
+        end
+        
+        def proxy_id
+          @proxy_id ||= @owner.send(@association.foreign_key)
+        end
+        
+        def proxy_class
+          @proxy_class ||= begin
+            klass = @owner.send(@association.type_key_name)
+            klass && klass.constantize
+          end
+        end
+    end
+  end
+end

data/lib/mongo_mapper/associations/belongs_to_proxy.rb

@@ -0,0 +1,22 @@
+module MongoMapper
+  module Associations
+    class BelongsToProxy < Proxy
+      def replace(doc)
+        if doc
+          doc.save if doc.new?
+          id = doc._id
+        end
+
+        @owner.send("#{@association.foreign_key}=", id)
+        reset
+      end
+
+      protected
+        def find_target
+          if association_id = @owner.send(@association.foreign_key)
+            @association.klass.find_by_id(association_id)
+          end
+        end
+    end
+  end
+end

data/lib/mongo_mapper/associations/many_documents_as_proxy.rb

@@ -0,0 +1,25 @@
+module MongoMapper
+  module Associations
+    class ManyDocumentsAsProxy < ManyDocumentsProxy
+      protected
+        def scoped_conditions
+          {as_type_name => @owner.class.name, as_id_name => @owner._id}
+        end
+
+        def apply_scope(doc)
+          ensure_owner_saved
+          doc.send("#{as_type_name}=", @owner.class.name)
+          doc.send("#{as_id_name}=", @owner._id)
+          doc
+        end
+
+        def as_type_name
+          @as_type_name ||= @association.options[:as].to_s + "_type"
+        end
+
+        def as_id_name
+          @as_id_name ||= @association.options[:as].to_s + "_id"
+        end
+    end
+  end
+end

data/lib/mongo_mapper/associations/many_documents_proxy.rb

@@ -0,0 +1,127 @@
+module MongoMapper
+  module Associations
+    class ManyDocumentsProxy < Proxy
+      delegate :klass, :to => :@association
+      delegate :collection, :to => :klass
+      
+      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)
+        @target.map(&:destroy) if load_target
+        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
+      
+      def method_missing(method, *args)
+        finder = DynamicFinder.new(method)
+        
+        if finder.found?
+          dynamic_find(finder, args)
+        else
+          super
+        end
+      end
+      
+      protected
+        def scoped_conditions
+          {self.foreign_key => @owner._id}
+        end
+        
+        def scoped_options(options)
+          @association.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.send("#{self.foreign_key}=", @owner._id)
+          doc
+        end
+
+        def foreign_key
+          @association.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,33 @@
+module MongoMapper
+  module Associations
+    class ManyEmbeddedPolymorphicProxy < Proxy
+      def replace(v)
+        @_values = v.map do |doc_or_hash|
+          if doc_or_hash.kind_of?(EmbeddedDocument)
+            doc = doc_or_hash
+            {@association.type_key_name => doc.class.name}.merge(doc.attributes)
+          else
+            doc_or_hash
+          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[@association.type_key_name]
+            class_name.constantize
+          else
+            @association.klass
+          end
+        end
+    end
+  end
+end

data/lib/mongo_mapper/associations/many_embedded_proxy.rb

@@ -0,0 +1,53 @@
+module MongoMapper
+  module Associations
+    class ManyEmbeddedProxy < Proxy
+      def replace(v)
+        @_values = v.map { |e| e.kind_of?(EmbeddedDocument) ? e.attributes : e }
+        reset
+      end
+
+      def build(attributes={})
+        doc = @association.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)
+        if load_target
+          docs.each do |doc|
+            assign_root_document(doc)
+            @target << doc
+          end
+        end
+      end
+      alias_method :push, :<<
+      alias_method :concat, :<<
+
+      private
+        def find_target
+          (@_values || []).map do |e|
+            child = @association.klass.new(e)
+            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.send("#{@association.type_key_name}=", doc.class.name)
+          super
+        end
+    end
+  end
+end

data/lib/mongo_mapper/associations/many_proxy.rb

@@ -0,0 +1,6 @@
+module MongoMapper
+  module Associations
+    class ManyProxy < ManyDocumentsProxy
+    end
+  end
+end

data/lib/mongo_mapper/associations/proxy.rb

@@ -0,0 +1,80 @@
+module MongoMapper
+  module Associations
+    class Proxy < BasicObject
+      attr_reader :owner, :association
+      
+      def initialize(owner, association)
+        @owner = owner
+        @association = association
+        @association.options[:extend].each { |ext| class << self; self; end.instance_eval { include ext } }
+        reset
+      end
+
+      def respond_to?(*methods)
+        (load_target && @target.respond_to?(*methods))
+      end
+
+      def reset
+        @target = nil
+      end
+
+      def reload_target
+        reset
+        load_target
+        self
+      end
+
+      def send(method, *args)
+        metaclass_instance_methods = class << self; self; end.instance_methods
+        
+        if metaclass_instance_methods.any? { |m| m.to_s == method.to_s }
+          return __send__(method, *args)
+        end
+        
+        load_target
+        @target.send(method, *args)
+      end
+
+      def replace(v)
+        raise NotImplementedError
+      end
+      
+      def inspect
+        load_target
+        @target.inspect
+      end
+      
+      def nil?
+        load_target
+        @target.nil?
+      end
+      
+      protected
+        def method_missing(method, *args, &block)
+          if load_target
+            if block.nil?
+              @target.send(method, *args)
+            else
+              @target.send(method, *args)  { |*block_args| block.call(*block_args) }
+            end
+          end
+        end
+
+        def load_target
+          @target ||= find_target
+        end
+
+        def find_target
+          raise NotImplementedError
+        end
+        
+        # Array#flatten has problems with recursive arrays. Going one level
+        # deeper solves the majority of the problems.
+        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