mongo_mapper_ign 0.7.7 → 0.7.8

data/lib/mongo_mapper/plugins/callbacks.rb

@@ -1,241 +1,241 @@
-# encoding: UTF-8
-# Almost all of this callback stuff is pulled directly from ActiveSupport
-# in the interest of support rails 2 and 3 at the same time and is the
-# same copyright as rails.
-module MongoMapper
-  module Plugins
-    module Callbacks
-      def self.configure(model)
-        model.class_eval do
-          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,
-            :validate_on_create,          :validate_on_update,
-            :validate
-          )
-        end
-      end
-
-      module ClassMethods
-        def define_callbacks(*callbacks)
-          callbacks.each do |callback|
-            class_eval <<-"end_eval"
-              def self.#{callback}(*methods, &block)
-                callbacks = CallbackChain.build(:#{callback}, *methods, &block)
-                @#{callback}_callbacks ||= CallbackChain.new
-                @#{callback}_callbacks.concat callbacks
-              end
-
-              def self.#{callback}_callback_chain
-                @#{callback}_callbacks ||= CallbackChain.new
-
-                if superclass.respond_to?(:#{callback}_callback_chain)
-                  CallbackChain.new(
-                    superclass.#{callback}_callback_chain +
-                    @#{callback}_callbacks
-                  )
-                else
-                  @#{callback}_callbacks
-                end
-              end
-            end_eval
-          end
-        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
-
-        # Overriding validatable's valid_for_group? to integrate validation callbacks
-        def valid_for_group?(group) #:nodoc:
-          errors.clear
-          run_before_validations
-          run_callbacks(:validate)
-          new? ? run_callbacks(:validate_on_create) : run_callbacks(:validate_on_update)
-          self.class.validate_children(self, group)
-          self.validate_group(group)
-          errors.empty?
-        end
-
-        def destroy
-          run_callbacks(:before_destroy)
-          result = super
-          run_callbacks(:after_destroy)
-          result
-        end
-
-        def run_callbacks(kind, options = {}, &block)
-          callback_chain_method = "#{kind}_callback_chain"
-          return unless self.class.respond_to?(callback_chain_method)
-          self.class.send(callback_chain_method).run(self, options, &block)
-          self.embedded_associations.each do |association|
-            if association.one?
-              self.send(association.name).run_callbacks(kind, options, &block)
-            else
-              self.send(association.name).each do |document|
-                document.run_callbacks(kind, options, &block)
-              end
-            end
-          end
-        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
-
-      class CallbackChain < Array
-        def self.build(kind, *methods, &block)
-          methods, options = extract_options(*methods, &block)
-          methods.map! { |method| Callback.new(kind, method, options) }
-          new(methods)
-        end
-
-        def run(object, options = {}, &terminator)
-          enumerator = options[:enumerator] || :each
-
-          unless block_given?
-            send(enumerator) { |callback| callback.call(object) }
-          else
-            send(enumerator) do |callback|
-              result = callback.call(object)
-              break result if terminator.call(result, object)
-            end
-          end
-        end
-
-        # TODO: Decompose into more Array like behavior
-        def replace_or_append!(chain)
-          if index = index(chain)
-            self[index] = chain
-          else
-            self << chain
-          end
-          self
-        end
-
-        def find(callback, &block)
-          select { |c| c == callback && (!block_given? || yield(c)) }.first
-        end
-
-        def delete(callback)
-          super(callback.is_a?(Callback) ? callback : find(callback))
-        end
-
-        private
-          def self.extract_options(*methods, &block)
-            methods.flatten!
-            options = methods.extract_options!
-            methods << block if block_given?
-            return methods, options
-          end
-
-          def extract_options(*methods, &block)
-            self.class.extract_options(*methods, &block)
-          end
-      end
-
-      class Callback
-        attr_reader :kind, :method, :identifier, :options
-
-        def initialize(kind, method, options = {})
-          @kind       = kind
-          @method     = method
-          @identifier = options[:identifier]
-          @options    = options
-        end
-
-        def ==(other)
-          case other
-          when Callback
-            (self.identifier && self.identifier == other.identifier) || self.method == other.method
-          else
-            (self.identifier && self.identifier == other) || self.method == other
-          end
-        end
-
-        def eql?(other)
-          self == other
-        end
-
-        def dup
-          self.class.new(@kind, @method, @options.dup)
-        end
-
-        def hash
-          if @identifier
-            @identifier.hash
-          else
-            @method.hash
-          end
-        end
-
-        def call(*args, &block)
-          evaluate_method(method, *args, &block) if should_run_callback?(*args)
-        rescue LocalJumpError
-          raise ArgumentError,
-            "Cannot yield from a Proc type filter. The Proc must take two " +
-            "arguments and execute #call on the second argument."
-        end
-
-        private
-          def evaluate_method(method, *args, &block)
-            case method
-              when Symbol
-                object = args.shift
-                object.send(method, *args, &block)
-              when String
-                eval(method, args.first.instance_eval { binding })
-              when Proc, Method
-                method.call(*args, &block)
-              else
-                if method.respond_to?(kind)
-                  method.send(kind, *args, &block)
-                else
-                  raise ArgumentError,
-                    "Callbacks must be a symbol denoting the method to call, a string to be evaluated, " +
-                    "a block to be invoked, or an object responding to the callback method."
-                end
-            end
-          end
-
-          def should_run_callback?(*args)
-            [options[:if]].flatten.compact.all? { |a| evaluate_method(a, *args) } &&
-            ![options[:unless]].flatten.compact.any? { |a| evaluate_method(a, *args) }
-          end
-      end
-    end
-  end
-end
+# encoding: UTF-8
+# Almost all of this callback stuff is pulled directly from ActiveSupport
+# in the interest of support rails 2 and 3 at the same time and is the
+# same copyright as rails.
+module MongoMapper
+  module Plugins
+    module Callbacks
+      def self.configure(model)
+        model.class_eval do
+          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,
+            :validate_on_create,          :validate_on_update,
+            :validate
+          )
+        end
+      end
+
+      module ClassMethods
+        def define_callbacks(*callbacks)
+          callbacks.each do |callback|
+            class_eval <<-"end_eval"
+              def self.#{callback}(*methods, &block)
+                callbacks = CallbackChain.build(:#{callback}, *methods, &block)
+                @#{callback}_callbacks ||= CallbackChain.new
+                @#{callback}_callbacks.concat callbacks
+              end
+
+              def self.#{callback}_callback_chain
+                @#{callback}_callbacks ||= CallbackChain.new
+
+                if superclass.respond_to?(:#{callback}_callback_chain)
+                  CallbackChain.new(
+                    superclass.#{callback}_callback_chain +
+                    @#{callback}_callbacks
+                  )
+                else
+                  @#{callback}_callbacks
+                end
+              end
+            end_eval
+          end
+        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
+
+        # Overriding validatable's valid_for_group? to integrate validation callbacks
+        def valid_for_group?(group) #:nodoc:
+          errors.clear
+          run_before_validations
+          run_callbacks(:validate)
+          new? ? run_callbacks(:validate_on_create) : run_callbacks(:validate_on_update)
+          self.class.validate_children(self, group)
+          self.validate_group(group)
+          errors.empty?
+        end
+
+        def destroy
+          run_callbacks(:before_destroy)
+          result = super
+          run_callbacks(:after_destroy)
+          result
+        end
+
+        def run_callbacks(kind, options = {}, &block)
+          callback_chain_method = "#{kind}_callback_chain"
+          return unless self.class.respond_to?(callback_chain_method)
+          self.class.send(callback_chain_method).run(self, options, &block)
+          self.embedded_associations.each do |association|
+            if association.one?
+              self.send(association.name).run_callbacks(kind, options, &block)
+            else
+              self.send(association.name).each do |document|
+                document.run_callbacks(kind, options, &block)
+              end
+            end
+          end
+        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
+
+      class CallbackChain < Array
+        def self.build(kind, *methods, &block)
+          methods, options = extract_options(*methods, &block)
+          methods.map! { |method| Callback.new(kind, method, options) }
+          new(methods)
+        end
+
+        def run(object, options = {}, &terminator)
+          enumerator = options[:enumerator] || :each
+
+          unless block_given?
+            send(enumerator) { |callback| callback.call(object) }
+          else
+            send(enumerator) do |callback|
+              result = callback.call(object)
+              break result if terminator.call(result, object)
+            end
+          end
+        end
+
+        # TODO: Decompose into more Array like behavior
+        def replace_or_append!(chain)
+          if index = index(chain)
+            self[index] = chain
+          else
+            self << chain
+          end
+          self
+        end
+
+        def find(callback, &block)
+          select { |c| c == callback && (!block_given? || yield(c)) }.first
+        end
+
+        def delete(callback)
+          super(callback.is_a?(Callback) ? callback : find(callback))
+        end
+
+        private
+          def self.extract_options(*methods, &block)
+            methods.flatten!
+            options = methods.extract_options!
+            methods << block if block_given?
+            return methods, options
+          end
+
+          def extract_options(*methods, &block)
+            self.class.extract_options(*methods, &block)
+          end
+      end
+
+      class Callback
+        attr_reader :kind, :method, :identifier, :options
+
+        def initialize(kind, method, options = {})
+          @kind       = kind
+          @method     = method
+          @identifier = options[:identifier]
+          @options    = options
+        end
+
+        def ==(other)
+          case other
+          when Callback
+            (self.identifier && self.identifier == other.identifier) || self.method == other.method
+          else
+            (self.identifier && self.identifier == other) || self.method == other
+          end
+        end
+
+        def eql?(other)
+          self == other
+        end
+
+        def dup
+          self.class.new(@kind, @method, @options.dup)
+        end
+
+        def hash
+          if @identifier
+            @identifier.hash
+          else
+            @method.hash
+          end
+        end
+
+        def call(*args, &block)
+          evaluate_method(method, *args, &block) if should_run_callback?(*args)
+        rescue LocalJumpError
+          raise ArgumentError,
+            "Cannot yield from a Proc type filter. The Proc must take two " +
+            "arguments and execute #call on the second argument."
+        end
+
+        private
+          def evaluate_method(method, *args, &block)
+            case method
+              when Symbol
+                object = args.shift
+                object.send(method, *args, &block)
+              when String
+                eval(method, args.first.instance_eval { binding })
+              when Proc, Method
+                method.call(*args, &block)
+              else
+                if method.respond_to?(kind)
+                  method.send(kind, *args, &block)
+                else
+                  raise ArgumentError,
+                    "Callbacks must be a symbol denoting the method to call, a string to be evaluated, " +
+                    "a block to be invoked, or an object responding to the callback method."
+                end
+            end
+          end
+
+          def should_run_callback?(*args)
+            [options[:if]].flatten.compact.all? { |a| evaluate_method(a, *args) } &&
+            ![options[:unless]].flatten.compact.any? { |a| evaluate_method(a, *args) }
+          end
+      end
+    end
+  end
+end