mongo_mapper 0.6.10 → 0.7.0

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(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

@@ -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/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

data/lib/mongo_mapper/dirty.rb

@@ -1,117 +0,0 @@
-module MongoMapper
-  module Dirty
-    DIRTY_SUFFIXES = ['_changed?', '_change', '_will_change!', '_was']
-    
-    def method_missing(method, *args, &block)
-      if method.to_s =~ /(_changed\?|_change|_will_change!|_was)$/
-        method_suffix = $1
-        key = method.to_s.gsub(method_suffix, '')
-        
-        if key_names.include?(key)
-          case method_suffix
-            when '_changed?'
-              key_changed?(key)
-            when '_change'
-              key_change(key)
-            when '_will_change!'
-              key_will_change!(key)
-            when '_was'
-              key_was(key)
-          end
-        else
-          super
-        end
-      else
-        super
-      end
-    end
-    
-    def changed?
-      !changed_keys.empty?
-    end
-
-    def changed
-      changed_keys.keys
-    end
-
-    def changes
-      changed.inject({}) { |h, attribute| h[attribute] = key_change(attribute); h }
-    end
-    
-    def initialize(attrs={})
-      super(attrs)
-      changed_keys.clear unless new?
-    end
-
-    def save(*args)
-      if status = super
-        changed_keys.clear
-      end
-      status
-    end
-
-    def save!(*args)
-      status = super
-      changed_keys.clear
-      status
-    end
-
-    def reload(*args)
-      record = super
-      changed_keys.clear
-      record
-    end
-
-    private
-      def clone_key_value(attribute_name)
-        value = send(:read_attribute, attribute_name)
-        value.duplicable? ? value.clone : value
-      rescue TypeError, NoMethodError
-        value
-      end
-      
-      def changed_keys
-        @changed_keys ||= {}
-      end
-
-      def key_changed?(attribute)
-        changed_keys.include?(attribute)
-      end
-
-      def key_change(attribute)
-        [changed_keys[attribute], __send__(attribute)] if key_changed?(attribute)
-      end
-
-      def key_was(attribute)
-        key_changed?(attribute) ? changed_keys[attribute] : __send__(attribute)
-      end
-
-      def key_will_change!(attribute)
-        changed_keys[attribute] = clone_key_value(attribute)
-      end
-
-      def write_attribute(attribute, value)
-        attribute = attribute.to_s
-
-        if changed_keys.include?(attribute)
-          old = changed_keys[attribute]
-          changed_keys.delete(attribute) unless value_changed?(attribute, old, value)
-        else
-          old = clone_key_value(attribute)
-          changed_keys[attribute] = old if value_changed?(attribute, old, value)
-        end
-
-        super(attribute, value)
-      end
-      
-      def value_changed?(key_name, old, value)
-        key = _keys[key_name]
-        
-        if key.number? && value.blank?
-          value = nil
-        end
-        
-        old != value
-      end
-  end
-end