drogus-mongo_mapper 0.6.10

data/lib/mongo_mapper/plugins/associations/one_proxy.rb

@@ -0,0 +1,68 @@
+module MongoMapper
+  module Plugins
+    module Associations
+      class OneProxy < Proxy
+        undef_method :object_id
+        
+        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
+end

data/lib/mongo_mapper/plugins/associations/proxy.rb

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

data/lib/mongo_mapper/plugins/callbacks.rb

@@ -0,0 +1,134 @@
+module MongoMapper
+  module Plugins
+    if defined?(ActiveModel)
+      # Rails 3 stuff
+      module Callbacks
+        def self.configure(model)
+          model.class_eval do
+            extend ActiveModel::Callbacks
+            define_model_callbacks  :create, :save, :update, :destroy, :validation,
+                                    :validation_on_create, :validation_on_update
+          end
+        end
+
+        module InstanceMethods
+          def valid?
+            action = new? ? 'create' : 'update'
+            result = nil
+
+            _run_validation_callbacks do
+              self.send("_run_validation_on_#{action}_callbacks") do
+                result = super
+              end
+            end
+
+            result
+          end
+
+          def destroy
+            result = nil
+
+            _run_destroy_callbacks do
+              result = super
+            end
+
+            result
+          end
+
+          private
+            def create_or_update(*args)
+              result = nil
+
+              _run_save_callbacks do
+                result = super
+              end
+
+              result
+            end
+
+            def create(*args)
+              result = nil
+
+              _run_create_callbacks do
+                result = super
+              end
+
+              result
+            end
+
+            def update(*args)
+              result = nil
+
+              _run_update_callbacks do
+                result = super
+              end
+
+              result
+            end
+        end
+      end
+    else
+      module Callbacks
+        def self.configure(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
+        
+        module InstanceMethods
+          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
+    end
+  end
+end

data/lib/mongo_mapper/plugins/clone.rb

@@ -0,0 +1,13 @@
+module MongoMapper
+  module Plugins
+    module Clone
+      module InstanceMethods
+        def clone
+          clone_attributes = self.attributes
+          clone_attributes.delete("_id")
+          self.class.new(clone_attributes)
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/descendants.rb

@@ -0,0 +1,16 @@
+module MongoMapper
+  module Plugins
+    module Descendants
+      module ClassMethods
+        def inherited(descendant)
+          (@descendants ||= []) << descendant
+          super
+        end
+
+        def descendants
+          @descendants
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/dirty.rb

@@ -0,0 +1,119 @@
+module MongoMapper
+  module Plugins
+    module Dirty
+      module InstanceMethods
+        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, key| h[key] = key_change(key); h }
+        end
+
+        def initialize(*args)
+          super
+          changed_keys.clear if args.first.blank? || !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)
+          document = super
+          changed_keys.clear
+          document
+        end
+
+        private
+          def clone_key_value(key)
+            value = read_key(key)
+            value.duplicable? ? value.clone : value
+          rescue TypeError, NoMethodError
+            value
+          end
+
+          def changed_keys
+            @changed_keys ||= {}
+          end
+
+          def key_changed?(key)
+            changed_keys.include?(key)
+          end
+
+          def key_change(key)
+            [changed_keys[key], __send__(key)] if key_changed?(key)
+          end
+
+          def key_was(key)
+            key_changed?(key) ? changed_keys[key] : __send__(key)
+          end
+
+          def key_will_change!(key)
+            changed_keys[key] = clone_key_value(key)
+          end
+
+          def write_key(key, value)
+            key = key.to_s
+
+            if changed_keys.include?(key)
+              old = changed_keys[key]
+              changed_keys.delete(key) unless value_changed?(key, old, value)
+            else
+              old = clone_key_value(key)
+              changed_keys[key] = old if value_changed?(key, old, value)
+            end
+
+            super(key, 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
+  end
+end