在Rails中运行另一种方法之前调用方法

Question

我有一个Model，它有method_1到method_10。我也有ModelObserver。 我想在调用method1至method_9之前通知ModelObserver，但不是method_10。

有没有一种干的方式来写这个，而不是在所有9个方法中重复notify_observers（：after_something）？

Answer 1

在config/initializers dirctory中添加一个名为monkey_patches.rb的文件。

class Object 
    def self.method_hook(*args) 
    options = args.extract_options! 
    return unless (options[:before].present? or options[:after].present?) 
    args.each do |method_name|  
     old_method = instance_method(method_name) rescue next 

     define_method(method_name) do |*args| 
     # invoke before callback 
     if options[:before].present? 
      options[:before].is_a?(Proc) ? options[:before].call(method_name, self): 
      send(options[:before], method_name) 
     end 

     # you can modify the code to call after callback 
     # only when the old method returns true etc.. 
     old_method.bind(self).call(*args) 

     # invoke after callback 
     if options[:after].present? 
      options[:after].is_a?(Proc) ? options[:after].call(method_name, self): 
      send(options[:after], method_name) 
     end 
     end 
    end 
    end 
end 

的补丁，您可以在一个类的实例方法添加before和after回调。钩可以是：

• 它接受一个参数
• 一个lambda接受两个参数

多个钩子可以在相同的方法来注册的实例方法的名称。被钩住的方法应该在钩子之前。

E.g：

class Model < ActiveRecord::Base 

    def method1 
    end 

    def method2 
    end 

    def method3 
    end 

    def method4 
    end 

    def update_cache 
    end 

    # instance method name as `after` callback parameter 
    method_hook :method1, :method2, :after => :update_cache 

    # lambda as `before` callback parameter 
    method_hook :method1, :method2, 
    :before => lambda{|name, record| p name;p record} 

    # lambda as `after` callback parameter 
    method_hook :method3, :method4, 
    :after => lambda{|name, record| 
     Model2.increment_counter(:post_count, record.model2_id)} 

end 

Answer 2

这样的事情呢？

def notify; puts "Was notified."; end 
def method1; end 
def method2; end 
def method3; end 

def original 
    notify 
    method1 
    notify 
    method2 
    method3 
end 

def dry 
    [:method1, :method2].each do |m| 
    notify 
    send(m) 
    end 
    method3 
end 

original 
dry