mongo_mapper-unstable 2010.1.6 → 2010.1.12

data/lib/mongo_mapper/associations/in_array_proxy.rb

@@ -1,137 +0,0 @@
-module MongoMapper
-  module Associations
-    class InArrayProxy < Collection
-      include ::MongoMapper::Finders
-      
-      def find(*args)
-        options = args.extract_options!
-        
-        case args.first
-          when :first
-            first(options)
-          when :last
-            last(options)
-          when :all
-            all(options)
-          else
-            klass.find(*scoped_ids(args) << scoped_options(options))
-        end
-      end
-      
-      def find!(*args)
-        options = args.extract_options!
-        
-        case args.first
-          when :first
-            first(options)
-          when :last
-            last(options)
-          when :all
-            all(options)
-          else
-            klass.find!(*scoped_ids(args) << scoped_options(options))
-        end
-      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={})
-        options.blank? ? ids.size : klass.count(scoped_options(options))
-      end
-      
-      def destroy_all(options={})
-        all(options).each do |doc|
-          ids.delete(doc.id)
-          doc.destroy
-        end
-        reset
-      end
-
-      def delete_all(options={})
-        docs = all(options.merge(:select => ['_id']))
-        docs.each { |doc| ids.delete(doc.id) }
-        klass.delete(docs.map(&:id))
-        reset
-      end
-      
-      def nullify
-        replace([])
-        reset
-      end
-      
-      def create(attrs={})
-        doc = klass.create(attrs)
-        unless doc.new?
-          ids << doc.id
-          owner.save
-        end
-        doc
-      end
-      
-      def create!(attrs={})
-        doc = klass.create!(attrs)
-        unless doc.new?
-          ids << doc.id
-          owner.save
-        end
-        doc
-      end
-      
-      def <<(*docs)
-        flatten_deeper(docs).each do |doc|
-          doc.save if doc.new?
-          unless ids.include?(doc.id)
-            ids << doc.id
-          end
-        end
-        reset
-      end
-      alias_method :push, :<<
-      alias_method :concat, :<<
-      
-      def replace(docs)
-        doc_ids = docs.map do |doc|
-          doc.save if doc.new?
-          doc.id
-        end
-        ids.replace(doc_ids.uniq)
-        reset
-      end
-      
-      private
-        def scoped_conditions
-          {:_id => ids}
-        end
-        
-        def scoped_options(options)
-          reflection.finder_options.merge(options).merge(scoped_conditions)
-        end
-        
-        def scoped_ids(args)
-          args.flatten.reject { |id| !ids.include?(id) }
-        end
-        
-        def find_target
-          ids.blank? ? [] : all
-        end
-        
-        def ids
-          owner[options[:in]]
-        end
-    end
-  end
-end

data/lib/mongo_mapper/associations/many_documents_as_proxy.rb

@@ -1,26 +0,0 @@
-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

@@ -1,115 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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
-        
-        reset
-        
-        unless doc.nil?
-          owner.save if owner.new?
-          doc[foreign_key] = owner.id
-          doc.save if doc.new?
-          loaded
-          @target = doc
-        end
-      end
-
-      protected
-        def find_target
-          target_class.first(reflection.finder_options.merge(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] || reflection.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

@@ -1,116 +0,0 @@
-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, @loaded = owner, reflection, false
-        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 present?
-        load_target
-        target.present?
-      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

data/lib/mongo_mapper/associations.rb

@@ -1,78 +0,0 @@
-module MongoMapper
-  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
-
-      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
-  end
-end

data/lib/mongo_mapper/callbacks.rb

@@ -1,61 +0,0 @@
-module MongoMapper
-  module Callbacks
-    def self.included(model)
-      model.class_eval do
-        include ActiveSupport::Callbacks
-
-        define_callbacks(
-          :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
-        )
-      end
-    end
-
-    def valid?
-      action = new? ? 'create' : 'update'
-      
-      run_callbacks(:before_validation)
-      run_callbacks("before_validation_on_#{action}".to_sym)
-      result = super
-      run_callbacks("after_validation_on_#{action}".to_sym)
-      run_callbacks(:after_validation)
-      
-      result
-    end
-
-    def destroy
-      run_callbacks(:before_destroy)
-      result = super
-      run_callbacks(:after_destroy)
-      result
-    end
-
-    private
-      def create_or_update(*args)
-        run_callbacks(:before_save)
-        if result = super
-          run_callbacks(:after_save)
-        end
-        result
-      end
-
-      def create(*args)
-        run_callbacks(:before_create)
-        result = super
-        run_callbacks(:after_create)
-        result
-      end
-
-      def update(*args)
-        run_callbacks(:before_update)
-        result = super
-        run_callbacks(:after_update)
-        result
-      end
-  end
-end