Ticket #10727: activesupport_callbacks.diff

activesupport/test/callbacks_test.rb

@@ +1 @@
+require 'abstract_unit'
+
+class Record
+  include ActiveSupport::Callbacks
+
+  define_callbacks :before_save, :after_save
+
+  class << self
+    def callback_symbol(callback_method)
+      returning("#{callback_method}_method") do |method_name|
+        define_method(method_name) do
+          history << [callback_method, :symbol]
+        end
+      end
+    end
+
+    def callback_string(callback_method)
+      "history << [#{callback_method.to_sym.inspect}, :string]"
+    end
+
+    def callback_proc(callback_method)
+      Proc.new { |model| model.history << [callback_method, :proc] }
+    end
+
+    def callback_object(callback_method)
+      klass = Class.new
+      klass.send(:define_method, callback_method) do |model|
+        model.history << [callback_method, :object]
+      end
+      klass.new
+    end
+  end
+
+  def history
+    @history ||= []
+  end
+end
+
+class Person < Record
+  [:before_save, :after_save].each do |callback_method|
+    callback_method_sym = callback_method.to_sym
+    send(callback_method, callback_symbol(callback_method_sym))
+    send(callback_method, callback_string(callback_method_sym))
+    send(callback_method, callback_proc(callback_method_sym))
+    send(callback_method, callback_object(callback_method_sym))
+    send(callback_method) { |model| model.history << [callback_method_sym, :block] }
+  end
+
+  def save
+    run_callbacks(:before_save)
+    run_callbacks(:after_save)
+  end
+end
+
+class ConditionalPerson < Record
+  before_save Proc.new { |r| r.history << [:before_save, :proc] }, :if => Proc.new { |r| true }
+  before_save Proc.new { |r| r.history << "b00m" }, :if => Proc.new { |r| false }
+  before_save Proc.new { |r| r.history << [:before_save, :proc] }, :unless => Proc.new { |r| false }
+  before_save Proc.new { |r| r.history << "b00m" }, :unless => Proc.new { |r| true }
+
+  def save
+    run_callbacks(:before_save)
+    run_callbacks(:after_save)
+  end
+end
+
+class CallbacksTest < Test::Unit::TestCase
+  def test_save_person
+    person = Person.new
+    assert_equal [], person.history
+    person.save
+    assert_equal [
+      [:before_save, :symbol],
+      [:before_save, :string],
+      [:before_save, :proc],
+      [:before_save, :object],
+      [:before_save, :block],
+      [:after_save, :symbol],
+      [:after_save, :string],
+      [:after_save, :proc],
+      [:after_save, :object],
+      [:after_save, :block]
+    ], person.history
+  end
+end
+
+class ConditionalCallbackTest < Test::Unit::TestCase
+  def test_save_conditional_person
+    person = ConditionalPerson.new
+    person.save
+    assert_equal [
+      [:before_save, :proc],
+      [:before_save, :proc]
+    ], person.history
+  end
+end

activesupport/test/test_test.rb

@@ -79 +79 @@
-  teardown :foo, :sentinel, :foo
-
-  def test_inherited_setup_callbacks
-
+.map(&:method)
-    assert_equal [:foo], @called_back
-
+.map(&:method)
-  end
-
-  protected
@@ -104 +104 @@
-  teardown :bar
-
-  def test_inherited_setup_callbacks
-
+.map(&:method)
-    assert_equal [:foo, :bar], @called_back
-
+.map(&:method)
-  end
-
-  protected
@@ -115 +115 @@
-    end
-
-    def sentinel
-bar, :
+
-    end
-end

activesupport/lib/active_support/callbacks.rb

@@ +1 @@
+module ActiveSupport
+  module Callbacks
+    class Callback
+      def self.run(callbacks, object, enumerator = :each)
+        callbacks.send(enumerator) do |callback|
+          result = callback.call(object)
+          return false if result == false
+        end
+      end
+
+      attr_reader :name, :method, :options
+
+      def initialize(name, method, options = {})
+        @name    = name
+        @method  = method
+        @options = options
+      end
+
+      def call(object)
+        evaluate_method(method, object) if should_run_callback?(object)
+      end
+
+      private
+        def evaluate_method(method, object)
+          case method
+            when Symbol
+              object.send(method)
+            when String
+              eval(method, object.instance_eval { binding })
+            when Proc, Method
+              method.call(object)
+            else
+              if method.respond_to?(name)
+                method.send(name, object)
+              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?(object)
+          if options[:if]
+            evaluate_method(options[:if], object)
+          elsif options[:unless]
+            !evaluate_method(options[:unless], object)
+          else
+            true
+          end
+        end
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def define_callbacks(*callbacks)
+        callbacks.each do |callback|
+          class_eval <<-"end_eval"
+            def self.#{callback}(*methods, &block)
+              options = methods.extract_options!
+              methods << block if block_given?
+              callbacks = methods.map { |method| Callback.new(:#{callback}, method, options) }
+              (@#{callback}_callbacks ||= []).concat callbacks
+            end
+
+            def self.#{callback}_callback_chain
+              @#{callback}_callbacks ||= []
+
+              if superclass.respond_to?(:#{callback}_callback_chain)
+                superclass.#{callback}_callback_chain + @#{callback}_callbacks
+              else
+                @#{callback}_callbacks
+              end
+            end
+          end_eval
+        end
+      end
+    end
+
+    def run_callbacks(kind, enumerator = :each)
+      Callback.run(self.class.send("#{kind}_callback_chain"), self)
+    end
+  end
+end

activesupport/lib/active_support/testing/setup_and_teardown.rb

@@ -2 +2 @@
-  module Testing
-    module SetupAndTeardown
-      def self.included(base)
-
+
+
-
-        begin
-          require 'mocha'
@@ -12 +13 @@
-        end
-      end
-
-      module ClassMethods
-        def setup(*method_names, &block)
-          method_names << block if block_given?
-          (@setup_callbacks ||= []).concat method_names
-        end
-
-        def teardown(*method_names, &block)
-          method_names << block if block_given?
-          (@teardown_callbacks ||= []).concat method_names
-        end
-
-        def setup_callback_chain
-          @setup_callbacks ||= []
-
-          if superclass.respond_to?(:setup_callback_chain)
-            superclass.setup_callback_chain + @setup_callbacks
-          else
-            @setup_callbacks
-          end
-        end
-
-        def teardown_callback_chain
-          @teardown_callbacks ||= []
-
-          if superclass.respond_to?(:teardown_callback_chain)
-            superclass.teardown_callback_chain + @teardown_callbacks
-          else
-            @teardown_callbacks
-          end
-        end
-      end
-
-      # This redefinition is unfortunate but test/unit shows us no alternative.
-      def run_with_callbacks(result) #:nodoc:
-        return if @method_name.to_s == "default_test"
@@ -111 +80 @@
-        result.add_run
-        yield(Test::Unit::TestCase::FINISHED, name)
-      end
-
-      protected
-        def run_callbacks(kind, enumerator = :each)
-          self.class.send("#{kind}_callback_chain").send(enumerator) do |callback|
-            case callback
-            when Proc; callback.call(self)
-            when String, Symbol; send!(callback)
-            else raise ArgumentError, "Unrecognized callback #{callback.inspect}"
-            end
-          end
-        end
-    end
-  end
-end

activesupport/lib/active_support.rb

@@ -26 +26 @@
-require 'active_support/vendor'
-require 'active_support/basic_object'
-require 'active_support/inflector'
+require 'active_support/callbacks'
-
-require 'active_support/core_ext'
-

activerecord/test/validations_test.rb

@@ -1017 +1017 @@
-
-  def test_invalid_validator
-    Topic.validate 3
-ctiveRecord::ActiveRecord
+rgument
-  end
-
-  def test_throw_away_typing

activerecord/lib/active_record/validations.rb

@@ -279 +279 @@
-        alias_method_chain :save!, :validation
-        alias_method_chain :update_attribute, :validation_skipping
-      end
+
+      base.send :include, ActiveSupport::Callbacks
+
+      # TODO: Use helper ActiveSupport::Callbacks#define_callbacks instead
+      %w( validate validate_on_create validate_on_update ).each do |validation_method|
+        base.class_eval <<-"end_eval"
+          def self.#{validation_method}(*methods, &block)
+            options = methods.extract_options!
+            methods << block if block_given?
+            methods.map! { |method| Callback.new(:#{validation_method}, method, options) }
+            existing_methods = read_inheritable_attribute(:#{validation_method}) || []
+            write_inheritable_attribute(:#{validation_method}, existing_methods | methods)
+          end
+
+          def self.#{validation_method}_callback_chain
+            read_inheritable_attribute(:#{validation_method}) || []
+          end
+        end_eval
+      end
-    end
-
-    # All of the following validations are defined in the class scope of the model that you're interested in validating.
@@ -324 +343 @@
-      #   end
-      #
-      # This usage applies to #validate_on_create and #validate_on_update as well.
-      def validate(*methods, &block)
-        methods << block if block_given?
-        write_inheritable_set(:validate, methods)
-      end
-
-      def validate_on_create(*methods, &block)
-        methods << block if block_given?
-        write_inheritable_set(:validate_on_create, methods)
-      end
-
-      def validate_on_update(*methods, &block)
-        methods << block if block_given?
-        write_inheritable_set(:validate_on_update, methods)
-      end
-
-      def condition_block?(condition)
-        condition.respond_to?("call") && (condition.arity == 1 || condition.arity == -1)
-      end
-
-      # Determine from the given condition (whether a block, procedure, method or string)
-      # whether or not to validate the record.  See #validates_each.
-      def evaluate_condition(condition, record)
-        case condition
-          when Symbol; record.send(condition)
-          when String; eval(condition, record.instance_eval { binding })
-          else
-            if condition_block?(condition)
-              condition.call(record)
-            else
-              raise(
-                ActiveRecordError,
-                "Validations need to be either a symbol, string (to be eval'ed), proc/method, or " +
-                "class implementing a static validation method"
-              )
-            end
-          end
-      end
-
-      # Validates each attribute against a block.
-      #
-      #   class Person < ActiveRecord::Base
@@ -379 +361 @@
-      #   method, proc or string should return or evaluate to a true or false value.
-      # * <tt>unless</tt> - Specifies a method, proc or string to call to determine if the validation should
-      #   not occur (e.g. :unless => :skip_validation, or :unless => Proc.new { |user| user.signup_step <= 2 }).  The
-      
+
-      def validates_each(*attrs)
-        options = attrs.extract_options!.symbolize_keys
-        attrs   = attrs.flatten
-
-        # Declare the validation.
-
-
-
-
-
-
-
-
+
+
+
+
+
-          end
-        end
-      end
@@ -515 +494 @@
-
-        # can't use validates_each here, because it cannot cope with nonexistent attributes,
-        # while errors.add_on_empty can
-
-
-
-
-
+
+
+
-      end
-
-      # Validates that the specified attribute matches the length restrictions supplied. Only one option can be used at a time:
@@ -911 +888 @@
-        end
-      end
-
-
-      private
-        def write_inheritable_set(key, methods)
-          existing_methods = read_inheritable_attribute(key) || []
-          write_inheritable_attribute(key, existing_methods | methods)
-        end
-
-        def validation_method(on)
-          case on
-            when :save   then :validate
@@ -959 +930 @@
-    def valid?
-      errors.clear
-
-validation
+callback
-      validate
-
-      if new_record?
-validation
+callback
-        validate_on_create
-      else
-validation
+callback
-        validate_on_update
-      end
-
@@ -990 +961 @@
-      # Overwrite this method for validation checks used only on updates.
-      def validate_on_update # :doc:
-      end
-
-    private
-      def run_validations(validation_method)
-        validations = self.class.read_inheritable_attribute(validation_method.to_sym)
-        if validations.nil? then return end
-        validations.each do |validation|
-          if validation.is_a?(Symbol)
-            self.send(validation)
-          elsif validation.is_a?(String)
-            eval(validation, binding)
-          elsif validation_block?(validation)
-            validation.call(self)
-          elsif validation_class?(validation, validation_method)
-            validation.send(validation_method, self)
-          else
-            raise(
-              ActiveRecordError,
-              "Validations need to be either a symbol, string (to be eval'ed), proc/method, or " +
-              "class implementing a static validation method"
-            )
-          end
-        end
-      end
-
-      def validation_block?(validation)
-        validation.respond_to?("call") && (validation.arity == 1 || validation.arity == -1)
-      end
-
-      def validation_class?(validation, validation_method)
-        validation.respond_to?(validation_method)
-      end
-  end
-end

activerecord/lib/active_record/callbacks.rb

@@ -183 +183 @@
-        base.send :alias_method_chain, method, :callbacks
-      end
-
-
-
-
-
-
-
-
-
+
+
-    end
-
-    # Is called when the object was instantiated by one of the finders, like <tt>Base.find</tt>.
@@ -301 +295 @@
-      def callback(method)
-        notify(method)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
-        end
-
-        result = send(method) if respond_to_without_attributes?(method)
-
-        return result
-      end
-
-      def callbacks_for(method)
-        self.class.read_inheritable_attribute(method.to_sym) or []
-      end
-
-      def invoke_and_notify(method)
-        notify(method)
-        send(method) if respond_to_without_attributes?(method)
-      end
-
-      def notify(method) #:nodoc:
-        self.class.changed
-        self.class.notify_observers(method, self)