Ruby accès au symbole "invoqué par"

Question

Je souhaite obtenir (efficacement) le symbole avec lequel une méthode d'alias est appelée lors de l'exécution. Un accès direct efficace à un objet de cadre de pile de quelque sorte pour l'obtenir serait le fantasme.

ie:

classe Foo
    def generic_call (* args)
        puts ("generic_call() a été appelée à l'aide # {} ???")
    fin

    alias: specific_call1: generic_call
    alias: specific_call2: generic_call

fin

Foo.new.specific_call1
Foo.new.specific_call2

le résultat que je veux

generic_call() a été appelé en utilisant specific_call1()
generic_call() a été appelée en utilisant specific_call2()

Answer 1

class Foo 
    def generic_call() 
    puts "generic call was called by #{caller[0][/in `([^']+)'/, 1]}" 
    end 

    def specific_call1() generic_call end 
    def specific_call2() generic_call end 
end 

Foo.new.specific_call2 # Prints: generic call was called by specific_call2 

Cela cependant fonctionnera pas si vous utilisez alias pour créer specific_callN à partir generic_call parce que les méthodes créées par alias sont en fait une copie de la méthode originale - ils ne remettent pas en fait la méthode originale (ce qui est la raison pour laquelle vous peut librement redéfinir l'original sans affecter l'alias).

Answer 2

Il n'y a pas de façon intégrée de le faire. Vous pouvez sorte de pirater comme:

def current_method_name 
    caller[0].split('`').last.split('\'')[0] 
end 

Answer 3

Un extrait de code pour obtenir le nom de la méthode actuelle:

module Kernel 
    private 
    # Defined in ruby 1.9 
    unless defined?(__method__) 
     def __method__ 
     caller[0] =~ /`([^']*)'/ and $1 
     end 
    end 
    end 

Answer 4

Peut-être, vous voulez quelque chose comme ça?

class Object 
    def named_alias(name, generic_name) 
    ([Class, Module].include?(self.class) ? self : self.class).class_eval do 
     define_method(name) { |*args| send(generic_name, name, *args) } 
    end 
    end 
end 

class Foo 
    def generic_call(f, *args) 
    puts("generic_call() was called by using #{f} with #{args}") 
    end 

    # def specific_call1(*args) 
    #  generic_call(:specific_call1, *args) 
    # end 
    named_alias(:specific_call1, :generic_call) 
    named_alias(:specific_call2, :generic_call) 
end 

Foo.new.specific_call1 
Foo.new.specific_call2 

Disclaimer: Je ne sais pas Ruby, je viens de googlé how one performs currying there, puis adapté un peu le code.