自定義掛鉤/回調/宏方法

Question

如何在子類中創建自定義掛鉤方法？

不需要複製Rails，當然 - 越簡單越好。

我的目標是轉換：

class SubClass 

    def do_this_method 
    first_validate_something 
    end 
    def do_that_method 
    first_validate_something 
    end 

    private 

    def first_validate_something; end 
end 

要：

class ActiveClass; end 

class SubClass < ActiveClass 
    before_operations :first_validate_something, :do_this_method, :do_that_method 

    def do_this_method; end 
    def do_that_method; end 

    private 

    def first_validate_something; end 
end 

實例模塊：https://github.com/PragTob/after_do/blob/master/lib/after_do.rb

Rails的#before_action：http://apidock.com/rails/v4.0.2/AbstractController/Callbacks/ClassMethods/before_action

Answer 1

這是一個使用prepend的解決方案。當您第一次致電before_operations時，它會創建一個新的（空的）模塊並將其預先分配給您的班級。這意味着當你在你的類上調用方法foo時，它將首先在模塊中查找該方法。

before_operations方法然後在此模塊中定義簡單的方法，首先調用您的'before'方法，然後使用super來調用您的類中的實際實現。

class ActiveClass 
    def self.before_operations(before_method,*methods) 
    prepend(@active_wrapper=Module.new) unless @active_wrapper 
    methods.each do |method_name| 
     @active_wrapper.send(:define_method,method_name) do |*args,&block| 
     send before_method 
     super(*args,&block) 
     end 
    end 
    end 
end 

class SubClass < ActiveClass 
    before_operations :first_validate_something, :do_this_method, :do_that_method 

    def do_this_method(*args,&block) 
    p doing:'this', with:args, and:block 
    end 
    def do_that_method; end 

    private 

    def first_validate_something 
    p :validating 
    end 
end 

SubClass.new.do_this_method(3,4){ |x| p x } 
#=> :validating 
#=> {:doing=>"this", :with=>[3, 4], :and=>#<Proc:0x007fdb1301fa18@/tmp.rb:31>} 

---

如果您想通過@SteveTurczyn使思想工作，你必須：

1. 收到的define_method塊的ARGS參數，可以不作爲參數傳遞給它。
2. 致電before_operations在您的方法已被定義後，如果你想能夠將它們別名。

 

class ActiveClass 
    def self.before_operations(before_method, *methods) 
    methods.each do |meth| 
     raise "No method `#{meth}` defined in #{self}" unless method_defined?(meth) 
     orig_method = "_original_#{meth}" 
     alias_method orig_method, meth 
     define_method(meth) do |*args,&block| 
     send before_method 
     send orig_method, *args, &block 
     end 
    end 
    end 
end 

class SubClass < ActiveClass 
    def do_this_method(*args,&block) 
    p doing:'this', with:args, and:block 
    end 
    def do_that_method; end 

    before_operations :first_validate_something, :do_this_method, :do_that_method 

    private  
    def first_validate_something 
     p :validating 
    end 
end 

SubClass.new.do_this_method(3,4){ |x| p x } 
#=> :validating 
#=> {:doing=>"this", :with=>[3, 4], :and=>#<Proc:0x007fdb1301fa18@/tmp.rb:31>} 

Answer 2

您可以別名原始方法以不同的名字（所以:do_this_something是談到:original_do_this_something），然後定義一個新的:do_this_something方法調用:first_validate_something然後像這樣的方法事情的原始版本...

class ActiveClass 
    def self.before_operations(before_method, *methods) 
    methods.each do |method| 
     alias_method "original_#{method.to_s}".to_sym, method 
     define_method(method, *args, &block) do 
     send before_method 
     send "original_#{method.to_s}", *args, &block 
     end 
    end 
    end 
end 

Answer 3

這是編寫的代碼，不使用別名的方式。它包含一個類方法validate，它指定驗證方法和要調用驗證方法的方法。可以多次調用此方法validate以更改驗證器並動態驗證。

class ActiveClass 
end 

將所有的方法不是在命名（比如說）MidClass的ActiveClass一個子類的驗證等。

class MidClass < ActiveClass 
    def do_this_method(v,a,b) 
    puts "this: v=#{v}, a=#{a}, b=#{b}" 
    end 

    def do_that_method(v,a,b) 
    puts "that: v=#{v}, a=#{a}, b=#{b}" 
    end 

    def yet_another_method(v,a,b) 
    puts "yet_another: v=#{v}, a=#{a}, b=#{b}" 
    end 
end 

MidClass.instance_methods(false) 
    #=> [:do_this_method, :do_that_method, :yet_another_method] 

廣場的驗證，有一類方法validate在一起，在一個名爲（說）​​的MidClass一個子類。

class SubClass < MidClass 
    def self.validate(validator, *validatees) 
    superclass.instance_methods(false).each do |m| 
     if validatees.include?(m) 
     define_method(m) do |v, *args| 
      send(validator, v) 
      super(v, *args) 
     end 
     else 
     define_method(m) do |v, *args| 
      super(v, *args) 
     end 
     end 
    end 
    end 

    private 

    def validator1(v) 
    puts "valid1, v=#{v}" 
    end 

    def validator2(v) 
    puts "valid2, v=#{v}" 
    end 
end 

SubClass.methods(false) 
    #=> [:validate] 
SubClass.private_instance_methods(false) 
    #=> [:validator1, :validator2] 

類方法validate傳遞要使用的驗證方法的符號以及要驗證的方法。我們來試試吧。

sc = SubClass.new 

SubClass.validate(:validator1, :do_this_method, :do_that_method) 

sc.do_this_method(1,2,3) 
    # valid1, v=1 
    # this: v=1, a=2, b=3 
sc.do_that_method(1,2,3) 
    # valid1, v=1 
    # that: v=1, a=2, b=3 
sc.yet_another_method(1,2,3) 
    # yet_another: v=1, a=2, b=3 

現在更改驗證。

SubClass.validate(:validator2, :do_that_method, :yet_another_method) 

sc.do_this_method(1,2,3) 
    # this: v=1, a=2, b=3 
sc.do_that_method(1,2,3) 
    # valid2, v=1 
    # that: v=1, a=2, b=3 
sc.yet_another_method(1,2,3) 
    # valid2, v=1 
    # yet_another: v=1, a=2, b=3 

當super不加參數從通常的方法調用時，所有參數和一個塊中，如果有一個，被傳遞到超級。但是，如果該方法是使用define_method創建的，則不會將參數（並且不包含任何塊）傳遞給super。在後一種情況下，論據必須明確。

我想通過一個塊或過程super如果有一個，但一直在使用錯誤的祕密醬油。我希望爲此提供建議。