कक्षा विधि को लपेटने के लिए मॉड्यूल?

Question

क्या यह काम कक्षा के अंत में मॉड्यूल को शामिल किए बिना, बस इसे शीर्ष पर शामिल करना संभव है?

module VerboseJob 
    def self.included(job_class) 
    class << job_class 
     alias_method :original_perform, :perform 
     def perform(*args) 
     JobLogger.verbose { original_perform(*args) } 
     end 
    end 
    end 
end 

class HelloJob 
    include VerboseJob 

    def self.perform(arg1, arg2) 
    puts "Job invoked with #{arg1} and #{arg2}" 
    end 
end 

मैं क्या करना चाहते हैं, HelloJob.perform वास्तव में VerboseJob.perform आह्वान करने के लिए के लिए (जो फिर एक ब्लॉक के अंदर मूल विधि कॉल) है। चूंकि यहां मॉड्यूल कक्षा के शीर्ष पर शामिल है, यह काम नहीं करता है, क्योंकि perform अभी तक परिभाषित नहीं है। अंत में include को स्थानांतरित करना काम करता है, लेकिन क्या ऐसा कोई तरीका है जो थोड़ा और क्षमा कर रहा है? मैं अपनी कक्षा परिभाषाओं के शीर्ष पर सभी शामिल मॉड्यूल रखना चाहता हूं।

मैं Module या Class पर कुछ विधि की तलाश में हूं, जब इसे पूरी तरह से लोड किया गया है, इसके बजाए रनटाइम द्वारा इसका अर्थ लिया गया है।

Answer 1

यहाँ यह करने का एक बल्कि राउंडअबाउट/hackish तरीका है कि मैं जब तक मूल विधि परिभाषित किया गया था आवरण विधि की परिभाषा टाल द्वारा के साथ आया है:

module A 
    def self.included(base) 
    base.class_eval do 
     def self.singleton_method_added(name) 
     @@ran||=false 
     if name==:perform && !@@ran 
      @@ran=true 
      class<<self 
      alias_method :original_perform, :perform 
      def perform(*args) 
       puts "Hello" 
       original_perform(*args) 
      end 
      end 
     end 
     end 
    end 
    end 
end 

class B 
    include A 

    def self.perform 
    puts "Foobar" 
    end 
end 

B.perform 

संपादित करें:

d11wtq अधिक स्वच्छ के इस सरल:

module VerboseJob 
    module ClassMethods 
    def wrap_perform! 
     class << self 
     def perform_with_verbose(*args) 
      JobLogger.verbose { perform_without_verbose(*args) } 
     end 

     alias_method_chain :perform, :verbose \ 
      unless instance_method(:perform) == instance_method(:perform_with_verbose) 
     end 
    end 

    def singleton_method_added(name) 
     wrap_perform! if name == :perform 
    end 
    end 

    def self.included(job_class) 
    job_class.extend ClassMethods 
    job_class.wrap_perform! if job_class.respond_to?(:perform) 
    end 
end 

Answer 2

यह मानते हुए कि आप अपनी कक्षाओं के सभी से पहले परिभाषित चाहते आप perform रन चाहते हैं, आप Kernel#at_exit उपयोग कर सकते हैं:

एक प्रोक वस्तु को ब्लॉक में कनवर्ट करता है (और इसलिए बिंदु कॉल की पर यह बांधता है) और निष्पादन जब कार्यक्रम बाहर निकलता है के लिए यह पंजीकृत करता है। यदि एकाधिक हैंडलर पंजीकृत हैं, तो उन्हें पंजीकरण के के विपरीत क्रम में निष्पादित किया जाता है।

def do_at_exit(str1) 
    at_exit { print str1 } 
    end 
    at_exit { puts "cruel world" } 
    do_at_exit("goodbye ") 
    exit 

पैदा करता है:

अलविदा क्रूर दुनिया

आप भी इस तरह के टेस्ट :: यूनिट या MiniTest के रूप में कैसे इकाई परीक्षण चौखटे, को देखने के लिए, देरी संभाल कर सकते हैं कार्यों का चल रहा है।