Est-il possible d'exécuter du code après chaque ligne dans Ruby?

Question

Je comprends qu'il est possible de décorer des méthodes avec des crochets avant et après en rubis, mais est-il possible de le faire pour chaque ligne d'une méthode donnée? Par exemple, j'ai un test d'automatisation et je veux vérifier qu'après chaque étape il n'y a pas d'erreur affichée sur la page. L'erreur est montrée comme un div rouge et n'est pas visible par Ruby comme raise ou n'importe quoi de pareil, donc je dois le vérifier manuellement (il y a plusieurs autres cas d'utilisation aussi).

Je comprends qu'il pourrait être possible d'utiliser set_trace_func. Mais je pense que cela peut apporter plus de problèmes que d'avantages car cela fonctionne sur l'ensemble de l'arbre d'appel (et nécessite que je le filtre moi-même).

UPDATE (clarification):

Je suis intéressé à intercepter toutes les actions (ou appels) qui sont effectués au sein une méthode donnée. Cela signifie qu'un nombre indéterminé de classes est appelé, donc je ne peux pas intercepter un ensemble donné de classes/méthodes.

Answer 1

Il est, et vous pouvez obtenir une description complète de la façon de le faire dans la section 8.9 de The Ruby Programming Language. L'exécution du code sur chaque appel de la méthode implique l'envoi de la méthode à une classe TracedObject qui a une implémentation pour method_missing. Chaque fois qu'il reçoit un message, il appelle method_missing et exécute le code que vous lui avez assigné. (Ceci est, bien sûr, pour le traçage général).

C'est la description générale de la procédure pour le faire, vous pouvez consulter le livre pour plus de détails.

Answer 2

On dirait que vous voulez tracer sur chaque appel de méthode sur chaque objet, mais seulement pendant la durée de chaque appel à une méthode particulière. Dans ce cas, vous pourriez simplement redéfinir la méthode pour allumer et éteindre l'instrumentation. Tout d'abord, utiliser l'instrumentation universelle suggsted dans Pinochle's answer, redéfinir alors la méthode en question comme suit:

# original definition, in /lib/foo.rb: 
class Foo 
    def bar(baz) 
    do_stuff 
    end 
end 

# redefinition, in /test/add_instrumentation_to_foo.rb: 
Foo.class_eval do 
    original_bar = instance_method(:bar) 
    def bar(baz) 
    TracedObject.install! 
    original_bar.bind(self).call(baz) 
    TracedObject.uninstall! 
    end 
end 

Vous aurez besoin d'écrire les méthodes install! et uninstall, mais ils devraient être assez trivial: juste activer ou désactiver une classe variable et vérifiez-le dans la logique d'instrumentation.

Answer 3

Qu'en est-il (essaie juste)

class User 

     def initialize(name) 
     @name = name 
     end 

     def say_hello 
     puts "hello #{@name}" 
     end 

     def say_hi(friend) 
     puts "hi #{@name} from #{friend}" 
     end 

     def say_bye(a, b = 'Anna') 
     puts "bye #{a} and #{b}" 
     end 

    end 

    User.class_eval do 
     User.instance_methods(false).each do |method| 
     original = instance_method(method) 
     define_method method do |*options| 
      parameters = original.parameters 
      if parameters.empty? 
      original.bind(self).call 
      else 
      original.bind(self).call(*options) 
      end 
      puts __method__ 
     end 
     end 
    end 

    user = User.new("John") 

    user.say_hello 
    user.say_hi("Bob") 
    user.say_bye("Bob") 
    user.say_bye("Bob", "Lisa") 

sorties:

hello John 
    say_hello 
    hi John from Bob 
    say_hi 
    bye Bob and Anna 
    say_bye 
    bye Bob and Lisa 
    say_bye