280 lines
8.4 KiB
Ruby
280 lines
8.4 KiB
Ruby
|
module ActiveSupport
|
||
|
|
# Callbacks are hooks into the lifecycle of an object that allow you to trigger logic
|
||
|
|
# before or after an alteration of the object state.
|
||
|
|
#
|
||
|
|
# Mixing in this module allows you to define callbacks in your class.
|
||
|
|
#
|
||
|
|
# Example:
|
||
|
|
# class Storage
|
||
|
|
# include ActiveSupport::Callbacks
|
||
|
|
#
|
||
|
|
# define_callbacks :before_save, :after_save
|
||
|
|
# end
|
||
|
|
#
|
||
|
|
# class ConfigStorage < Storage
|
||
|
|
# before_save :saving_message
|
||
|
|
# def saving_message
|
||
|
|
# puts "saving..."
|
||
|
|
# end
|
||
|
|
#
|
||
|
|
# after_save do |object|
|
||
|
|
# puts "saved"
|
||
|
|
# end
|
||
|
|
#
|
||
|
|
# def save
|
||
|
|
# run_callbacks(:before_save)
|
||
|
|
# puts "- save"
|
||
|
|
# run_callbacks(:after_save)
|
||
|
|
# end
|
||
|
|
# end
|
||
|
|
#
|
||
|
|
# config = ConfigStorage.new
|
||
|
|
# config.save
|
||
|
|
#
|
||
|
|
# Output:
|
||
|
|
# saving...
|
||
|
|
# - save
|
||
|
|
# saved
|
||
|
|
#
|
||
|
|
# Callbacks from parent classes are inherited.
|
||
|
|
#
|
||
|
|
# Example:
|
||
|
|
# class Storage
|
||
|
|
# include ActiveSupport::Callbacks
|
||
|
|
#
|
||
|
|
# define_callbacks :before_save, :after_save
|
||
|
|
#
|
||
|
|
# before_save :prepare
|
||
|
|
# def prepare
|
||
|
|
# puts "preparing save"
|
||
|
|
# end
|
||
|
|
# end
|
||
|
|
#
|
||
|
|
# class ConfigStorage < Storage
|
||
|
|
# before_save :saving_message
|
||
|
|
# def saving_message
|
||
|
|
# puts "saving..."
|
||
|
|
# end
|
||
|
|
#
|
||
|
|
# after_save do |object|
|
||
|
|
# puts "saved"
|
||
|
|
# end
|
||
|
|
#
|
||
|
|
# def save
|
||
|
|
# run_callbacks(:before_save)
|
||
|
|
# puts "- save"
|
||
|
|
# run_callbacks(:after_save)
|
||
|
|
# end
|
||
|
|
# end
|
||
|
|
#
|
||
|
|
# config = ConfigStorage.new
|
||
|
|
# config.save
|
||
|
|
#
|
||
|
|
# Output:
|
||
|
|
# preparing save
|
||
|
|
# saving...
|
||
|
|
# - save
|
||
|
|
# saved
|
||
|
|
module Callbacks
|
||
|
|
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
|
||
|
|
|
||
|
|
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) # def self.before_save(*methods, &block)
|
||
|
|
callbacks = CallbackChain.build(:#{callback}, *methods, &block) # callbacks = CallbackChain.build(:before_save, *methods, &block)
|
||
|
|
@#{callback}_callbacks ||= CallbackChain.new # @before_save_callbacks ||= CallbackChain.new
|
||
|
|
@#{callback}_callbacks.concat callbacks # @before_save_callbacks.concat callbacks
|
||
|
|
end # end
|
||
|
|
#
|
||
|
|
def self.#{callback}_callback_chain # def self.before_save_callback_chain
|
||
|
|
@#{callback}_callbacks ||= CallbackChain.new # @before_save_callbacks ||= CallbackChain.new
|
||
|
|
#
|
||
|
|
if superclass.respond_to?(:#{callback}_callback_chain) # if superclass.respond_to?(:before_save_callback_chain)
|
||
|
|
CallbackChain.new( # CallbackChain.new(
|
||
|
|
superclass.#{callback}_callback_chain + # superclass.before_save_callback_chain +
|
||
|
|
@#{callback}_callbacks # @before_save_callbacks
|
||
|
|
) # )
|
||
|
|
else # else
|
||
|
|
@#{callback}_callbacks # @before_save_callbacks
|
||
|
|
end # end
|
||
|
|
end # end
|
||
|
|
end_eval
|
||
|
|
end
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
# Runs all the callbacks defined for the given options.
|
||
|
|
#
|
||
|
|
# If a block is given it will be called after each callback receiving as arguments:
|
||
|
|
#
|
||
|
|
# * the result from the callback
|
||
|
|
# * the object which has the callback
|
||
|
|
#
|
||
|
|
# If the result from the block evaluates to false, the callback chain is stopped.
|
||
|
|
#
|
||
|
|
# Example:
|
||
|
|
# class Storage
|
||
|
|
# include ActiveSupport::Callbacks
|
||
|
|
#
|
||
|
|
# define_callbacks :before_save, :after_save
|
||
|
|
# end
|
||
|
|
#
|
||
|
|
# class ConfigStorage < Storage
|
||
|
|
# before_save :pass
|
||
|
|
# before_save :pass
|
||
|
|
# before_save :stop
|
||
|
|
# before_save :pass
|
||
|
|
#
|
||
|
|
# def pass
|
||
|
|
# puts "pass"
|
||
|
|
# end
|
||
|
|
#
|
||
|
|
# def stop
|
||
|
|
# puts "stop"
|
||
|
|
# return false
|
||
|
|
# end
|
||
|
|
#
|
||
|
|
# def save
|
||
|
|
# result = run_callbacks(:before_save) { |result, object| result == false }
|
||
|
|
# puts "- save" if result
|
||
|
|
# end
|
||
|
|
# end
|
||
|
|
#
|
||
|
|
# config = ConfigStorage.new
|
||
|
|
# config.save
|
||
|
|
#
|
||
|
|
# Output:
|
||
|
|
# pass
|
||
|
|
# pass
|
||
|
|
# stop
|
||
|
|
def run_callbacks(kind, options = {}, &block)
|
||
|
|
self.class.send("#{kind}_callback_chain").run(self, options, &block)
|
||
|
|
end
|
||
|
|
end
|
||
|
|
end
|