mongo_mapper-unstable 2009.10.11

data/lib/mongo_mapper/associations/proxy.rb

@@ -0,0 +1,74 @@
+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
+      
+      def inspect
+        load_target
+        @target.inspect
+      end
+      
+      def nil?
+        load_target
+        @target.nil?
+      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/associations.rb

@@ -0,0 +1,86 @@
+module MongoMapper
+  module Associations
+    module ClassMethods
+      def belongs_to(association_id, options = {})
+        create_association(:belongs_to, association_id, options)
+        self
+      end
+
+      def many(association_id, options = {})
+        create_association(:many, association_id, options)
+        self
+      end
+
+      def associations
+        @associations ||= self.superclass.respond_to?(:associations) ? 
+                            self.superclass.associations : 
+                            HashWithIndifferentAccess.new
+      end
+
+      private
+        def create_association(type, name, options)
+          association = Associations::Base.new(type, name, options)
+          associations[association.name] = association
+          define_association_methods(association)
+          define_dependent_callback(association)
+          association
+        end
+
+        def define_association_methods(association)
+          define_method(association.name) do
+            get_proxy(association)
+          end
+
+          define_method("#{association.name}=") do |value|
+            get_proxy(association).replace(value)
+            value
+          end
+        end
+
+        def define_dependent_callback(association)
+          if association.options[:dependent]
+            if association.many?
+              define_dependent_callback_for_many(association)
+            elsif association.belongs_to?
+              define_dependent_callback_for_belongs_to(association)
+            end
+          end
+        end
+
+        def define_dependent_callback_for_many(association)
+          return if 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
+
+        def define_dependent_callback_for_belongs_to(association)
+          after_destroy do |doc|
+            case association.options[:dependent]
+            when :destroy
+              doc.get_proxy(association).destroy
+            end
+          end
+        end
+    end
+
+    module InstanceMethods
+      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,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

data/lib/mongo_mapper/dirty.rb

@@ -0,0 +1,137 @@
+module MongoMapper
+  module Dirty
+    DIRTY_SUFFIXES = ['_changed?', '_change', '_will_change!', '_was']
+    
+    def self.included(base)
+      base.alias_method_chain :write_attribute, :dirty
+      base.alias_method_chain :save,            :dirty
+      base.alias_method_chain :save!,           :dirty
+    end
+    
+    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
+    
+    # Attempts to +save+ the record and clears changed keys if successful.
+    def save_with_dirty(*args) #:nodoc:
+      if status = save_without_dirty(*args)
+        changed_keys.clear
+      end
+      status
+    end
+
+    # Attempts to <tt>save!</tt> the record and clears changed keys if successful.
+    def save_with_dirty!(*args) #:nodoc:
+      status = save_without_dirty!(*args)
+      changed_keys.clear
+      status
+    end
+    
+    # <tt>reload</tt> the record and clears changed keys.
+    # def reload_with_dirty(*args) #:nodoc:
+    #   record = reload_without_dirty(*args)
+    #   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_with_dirty(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.
+        write_attribute_without_dirty(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