Comment exécuter du code avant et après une méthode dans une sous-classe?

Question

Mes premières pensées sont quelque chose comme ceci:

class AbstractBuilder 
    attr_reader :time_taken 

    def build_with_timer 
    started_at = Time.now 
    build 
    @time_taken = Time.now - started_at 
    end 

    def build 
    raise 'Implement this method in a subclass' 
    end 
end 

class MyBuilder < AbstractBuilder 
    def build 
    sleep(5) 
    end 
end 

builder = MyBuilder.new.build_with_timer 
puts builder.time_taken 

Je pense qu'il ya une meilleure façon qui offre une meilleure flexibilité, par exemple idéalement, je voudrais appeler « construire » sur une instance de MyBuilder au lieu de 'build_with_timer' et ont toujours le temps d'exécution enregistré. J'ai envisagé d'utiliser alias_method depuis initialize ou même en utilisant un module mixin à la place de l'héritage de classe qui remplacerait la méthode de construction appelant super au milieu (je ne sais pas si cela fonctionnerait). Avant de descendre dans le trou du lapin, je pensais voir s'il y avait une pratique établie.

Answer 1

Je joue avec alias_method:

module Timeable 
    def time_methods *meths 
    meths.each do |meth| 
     alias_method "old_#{meth}", meth 

     define_method meth do |*args| 
     started_at = Time.now 
     res = send "old_#{meth}", *args 
     puts "Execution took %f seconds" % (Time.now - started_at) 
     res 
     end 
    end 
    end 

end 

class Foo 
    def bar str 
    puts str 
    end 
end 

Foo.extend Timeable 
Foo.time_methods :bar 
Foo.new.bar('asd') 
#=>asd 
#=>Execution took 0.000050 seconds 

Answer 2

On dirait que vous recherchez des accroches dans les événements du cycle de vie des objets. Vous devrez construire ceci dans votre objet de base et fournir un peu de DSL - je pense que vous cherchez quelque chose comme ActiveRecord Callbacks. Voici comment nous pourrions modifier votre exemple pour permettre à quelque chose comme ça:

class AbstractBuilder 
    attr_reader :time_taken 

    def construct! # i.e., build, and also call your hooks 
    @@prebuild.each { |sym| self.send(sym) } 
    build 
    @@postbuild.each { |sym| self.send(sym) } 
    end 

    def construct_with_timer 
    started_at = Time.now 
    construct! 
    @time_taken = Time.now - started_at 

    puts "!!! Build time: #@time_taken" 
    end 

    class << self 
    def before_build(fn); @@prebuild ||= []; @@prebuild << fn; end 
    def after_build(fn); @@postbuild ||= []; @@postbuild << fn; end 
    end 
end 

class MyBuilder < AbstractBuilder 
    before_build :preprocess 
    after_build :postprocess 

    def build; puts "BUILDING"; sleep(3); end 
    def preprocess; puts "Preparing to build..."; end 
    def postprocess; puts "Done building. Thank you for waiting."; end 
end 

builder = MyBuilder.new 
builder.construct_with_timer 

# => Preparing to build... 
# => BUILDING 
# => Done building. Thank you for waiting. 
# => !!! Build time: 3.000119 

Answer 3

J'ai eu un coup de couteau à une version pour obtenir ce que vous voulez. Cette version ne nécessite pas de sous-classe pour avoir du code supplémentaire non plus.

class AbstractBuilder 

    @@disable_override = false 

    def before_method 
    puts "before" 
    end 

    def after_method 
    puts "after" 
    end 

    def self.method_added name 
    unless @@disable_override 
     if name == :build 
     @@disable_override = true # to stop the new build method 
     self.send :alias_method, :sub_build, :build 
     self.send :remove_method, :build 
     self.send :define_method, :build do 
      before_method 
      sub_build 
      after_method 
     end 
     @@disable_override = false 
     else 
     puts "defining other method #{name}" 
     end 
    end 
    end 

end 

class MyBuilder < AbstractBuilder 

    def build 
    puts "starting build" 
    sleep(5) 
    puts "built." 
    end 

    def unnaffected_method 
    # this method won't get redefined 
    end 

end 

b = MyBuilder.new 
b.build 

Sorties

defining other method unnaffected_method 
before 
starting build 
built. 
after 

Answer 4

Ceci est une utilisation définition de manuel cas pour Aspect-Oriented Programming. Il offre généralement une séparation plus nette des préoccupations. Dans ce domaine, Ruby propose Aquarium et AspectR. Toutefois, vous pouvez ne pas vouloir ajouter une autre dépendance à votre projet. En tant que tel, vous pourriez toujours envisager d'utiliser l'une des autres approches.