tpitale-mongo_mapper 0.6.9

data/lib/mongo_mapper/associations/proxy.rb

@@ -0,0 +1,113 @@
+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
+        
+        # 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/associations.rb

@@ -0,0 +1,70 @@
+module MongoMapper
+  module Associations
+    module ClassMethods
+      def belongs_to(association_id, options={}, &extension)
+        create_association(:belongs_to, association_id, options, &extension)
+        self
+      end
+
+      def many(association_id, options={}, &extension)
+        create_association(:many, association_id, options, &extension)
+        self
+      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.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) if !frozen?
+        end
+        proxy
+      end
+    end
+  end
+end

data/lib/mongo_mapper/callbacks.rb

@@ -0,0 +1,109 @@
+module MongoMapper
+  # This module is mixed into the Document module to provide call-backs before 
+  # and after the following events:
+  #
+  # * save
+  # * create
+  # * update
+  # * validation
+  # ** every validation
+  # ** validation when created
+  # ** validation when updated
+  # * destruction
+  #
+  # @see ActiveSupport::Callbacks
+  module Callbacks
+    def self.included(model) #:nodoc:
+      model.class_eval do
+        extend Observable
+        include ActiveSupport::Callbacks
+
+        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
+        )
+
+        define_callbacks(*callbacks)
+
+        callbacks.each do |callback|
+          define_method(callback.to_sym) {}
+        end
+      end
+    end
+
+    def valid? #: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 = super
+      callback(:after_validation)
+
+      new? ? callback(:after_validation_on_create) : callback(:after_validation_on_update)
+      return result
+    end
+
+    # Here we override the +destroy+ method to allow for the +before_destroy+ 
+    # and +after_destroy+ call-backs. Note that the +destroy+ call is aborted 
+    # if the +before_destroy+ call-back returns +false+.
+    #
+    # @return the result of calling +destroy+ on the document
+    def destroy #:nodoc:
+      return false if callback(:before_destroy) == false
+      result = super
+      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
+
+      def create_or_update #:nodoc:
+        return false if callback(:before_save) == false
+        if result = super
+          callback(:after_save)
+        end
+        result
+      end
+
+      def create #:nodoc:
+        return false if callback(:before_create) == false
+        result = super
+        callback(:after_create)
+        result
+      end
+
+      def update(*args) #:nodoc:
+        return false if callback(:before_update) == false
+        result = super
+        callback(:after_update)
+        result
+      end
+  end
+end

data/lib/mongo_mapper/dirty.rb

@@ -0,0 +1,136 @@
+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
+
+    # List of keys with unsaved changes.
+    #   person.changed # => []
+    #   person.name = 'bob'
+    #   person.changed # => ['name']
+    def changed
+      changed_keys.keys
+    end
+
+    # Map of changed attrs => [original value, new value].
+    #   person.changes # => {}
+    #   person.name = 'bob'
+    #   person.changes # => { 'name' => ['bill', 'bob'] }
+    def changes
+      changed.inject({}) { |h, attribute| h[attribute] = key_change(attribute); h }
+    end
+    
+    def initialize(attrs={})
+      super(attrs)
+      changed_keys.clear unless new?
+    end
+
+    # Attempts to +save+ the record and clears changed keys if successful.
+    def save(*args)
+      if status = super
+        changed_keys.clear
+      end
+      status
+    end
+
+    # Attempts to <tt>save!</tt> the record and clears changed keys if successful.
+    def save!(*args)
+      status = super
+      changed_keys.clear
+      status
+    end
+
+    # <tt>reload</tt> the record and clears changed keys.
+    # def reload(*args) #:nodoc:
+    #   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
+      
+      # Map of change <tt>attr => original value</tt>.
+      def changed_keys
+        @changed_keys ||= {}
+      end
+
+      # Handle <tt>*_changed?</tt> for +method_missing+.
+      def key_changed?(attribute)
+        changed_keys.include?(attribute)
+      end
+
+      # Handle <tt>*_change</tt> for +method_missing+.
+      def key_change(attribute)
+        [changed_keys[attribute], __send__(attribute)] if key_changed?(attribute)
+      end
+
+      # Handle <tt>*_was</tt> for +method_missing+.
+      def key_was(attribute)
+        key_changed?(attribute) ? changed_keys[attribute] : __send__(attribute)
+      end
+
+      # Handle <tt>*_will_change!</tt> for +method_missing+.
+      def key_will_change!(attribute)
+        changed_keys[attribute] = clone_key_value(attribute)
+      end
+
+      # Wrap write_attribute to remember original key value.
+      def write_attribute(attribute, value)
+        attribute = attribute.to_s
+
+        # The key already has an unsaved change.
+        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
+
+        # Carry on.
+        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