mongo_mapper 0.5.0

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,27 @@
+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,116 @@
+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 paginate(options)
+        klass.paginate(scoped_options(options))
+      end
+
+      def all(options={})
+        find(:all, scoped_options(options))
+      end
+
+      def first(options={})
+        find(:first, scoped_options(options))
+      end
+
+      def last(options={})
+        find(:last, scoped_options(options))
+      end
+
+      def count(conditions={})
+        klass.count(conditions.deep_merge(scoped_conditions))
+      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 destroy_all(conditions={})
+        all(:conditions => conditions).map(&:destroy)
+        reset
+      end
+
+      def delete_all(conditions={})
+        klass.delete_all(conditions.deep_merge(scoped_conditions))
+        reset
+      end
+      
+      def nullify
+        criteria = FinderOptions.to_mongo_criteria(scoped_conditions)
+        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)
+          options.deep_merge({:conditions => scoped_conditions})
+        end
+
+        def find_target
+          find(: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,67 @@
+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(opts={})
+        owner = @owner
+        child = @association.klass.new(opts)
+        assign_parent_reference(child)
+        child._root_document = owner
+        self << child
+        child
+      end
+      
+      def find(opts)
+        case opts
+        when :all
+          self
+        when String
+          if load_target
+            child = @target.detect {|item| item.id == opts}
+            assign_parent_reference(child)
+            child
+          end
+        end
+      end
+
+      def <<(*docs)
+        if load_target
+          root = @owner._root_document || @owner
+          docs.each do |doc|
+            doc._root_document = root
+            @target << doc
+          end
+        end
+      end
+      alias_method :push, :<<
+      alias_method :concat, :<<
+
+      protected
+        def find_target
+          (@_values || []).map do |e|
+            child = @association.klass.new(e)
+            assign_parent_reference(child)
+            child
+          end
+        end
+        
+      private
+      
+        def assign_parent_reference(child)
+          return unless child && @owner
+          return if @owner.class.name.blank?
+          owner = @owner
+          child.class_eval do
+            define_method(owner.class.name.underscore) do
+              owner
+            end
+          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,64 @@
+module MongoMapper
+  module Associations
+    class Proxy < BasicObject
+      attr_reader :owner, :association
+      
+      def initialize(owner, association)
+        @owner = owner
+        @association = association
+        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)
+        return super if methods.include?(method.to_s)
+        load_target
+        @target.send(method, *args)
+      end
+
+      def replace(v)
+        raise NotImplementedError
+      end
+
+      protected
+        def method_missing(method, *args)
+          if load_target
+            if block_given?
+              @target.send(method, *args)  { |*block_args| yield(*block_args) }
+            else
+              @target.send(method, *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

data/lib/mongo_mapper/callbacks.rb

@@ -0,0 +1,106 @@
+module MongoMapper
+  module Callbacks    
+    def self.included(model) #:nodoc:
+      model.class_eval do
+        extend Observable
+        include ActiveSupport::Callbacks
+        
+        define_callbacks *%w(
+          before_save after_save before_create after_create before_update after_update before_validation
+          after_validation before_validation_on_create after_validation_on_create before_validation_on_update
+          after_validation_on_update before_destroy after_destroy
+        )
+        
+        [:create_or_update, :valid?, :create, :update, :destroy].each do |method|
+          alias_method_chain method, :callbacks
+        end
+      end
+    end
+
+    def before_save() end
+
+    def after_save()  end
+    def create_or_update_with_callbacks #:nodoc:
+      return false if callback(:before_save) == false
+      if result = create_or_update_without_callbacks
+        callback(:after_save)
+      end
+      result
+    end
+    private :create_or_update_with_callbacks
+
+    def before_create() end
+
+    def after_create() end
+    def create_with_callbacks #:nodoc:
+      return false if callback(:before_create) == false
+      result = create_without_callbacks
+      callback(:after_create)
+      result
+    end
+    private :create_with_callbacks
+
+    def before_update() end
+
+    def after_update() end
+
+    def update_with_callbacks(*args) #:nodoc:
+      return false if callback(:before_update) == false
+      result = update_without_callbacks(*args)
+      callback(:after_update)
+      result
+    end
+    private :update_with_callbacks
+
+    def before_validation() end
+
+    def after_validation() end
+
+    def before_validation_on_create() end
+
+    def after_validation_on_create()  end
+
+    def before_validation_on_update() end
+
+    def after_validation_on_update()  end
+
+    def valid_with_callbacks? #:nodoc:
+      return false if callback(:before_validation) == false
+      result = new? ? callback(:before_validation_on_create) : callback(:before_validation_on_update)
+      return false if false == result
+      
+      result = valid_without_callbacks?
+      callback(:after_validation)
+      
+      new? ? callback(:after_validation_on_create) : callback(:after_validation_on_update)
+      return result
+    end
+
+    def before_destroy() end
+
+    def after_destroy()  end
+    def destroy_with_callbacks #:nodoc:
+      return false if callback(:before_destroy) == false
+      result = destroy_without_callbacks
+      callback(:after_destroy)
+      result
+    end
+
+    private
+      def callback(method)
+        result = run_callbacks(method) { |result, object| false == result }
+        
+        if result != false && respond_to?(method)
+          result = send(method)
+        end
+        
+        notify(method)
+        return result
+      end
+      
+      def notify(method) #:nodoc:
+        self.class.changed
+        self.class.notify_observers(method, self)
+      end
+  end
+end