在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