Forum: Ruby using the current method name within current method

Is there a way to get the current method name within the current method?

def test_method
  puts self.current_method
end

--- output ----
test_method

Thanks,
Matt

On Jul 30, 2006, at 11:37 PM, Matthew Heidemann wrote:

> Is there a way to get the current method name within the current  
> method?
>
> def test_method
>  puts self.current_method
> end
>
> --- output ----
> test_method

In 1.9 (Ruby CVS HEAD) there is #__method__ and #__callee__: http://
eigenclass.org/hiki.rb?Changes+in+Ruby+1.9#l90

-- Daniel

This is kindof a hack, but it seems to work:

def get_mname
  caller[0]=~/`(.*?)'/  # note the first quote is a backtick
  $1
end

def dinosaur
  puts get_mname
end

dinosaur()
=> 'dinosaur'

If you wanted to modularize it just for the sake of it, you could do
something similar to the following:

module CurrentMethodName
  def this_method
    caller[0]=~/`(.*?)'/
    $1
  end
end

And, then, use it like this:

class Foo
  include CurrentMethodName
  def bar
    this_method
  end
end

Hope this cleans it up a bit for you. It's a holdover until 1.9.

M.T.

Matt Todd wrote:
> If you wanted to modularize it just for the sake of it, you could do
> something similar to the following:
> 
> module CurrentMethodName
>  def this_method
>    caller[0]=~/`(.*?)'/
>    $1
>  end
> end

You can rewrite that as

def this_method
   caller[0][/`([^']*)'/, 1]
end

and thusly avoid the global variable.

Kind regards

	robert

On Jul 31, 2006, at 4:25 AM, Robert Klemme wrote:

> You can rewrite that as
>
I have a sneaking suspicion he might have done it with the global
variable (although $1 isn't really global) on purpose, since =~ /
literal/ is the fastest way to do a regexp.

As much as I'd like to take credit for knowing its superior speed, I
can't as I stole it from Aleks. :)

However, I did know that $1 wasn't a true global in the sense of the
term, but a magic variable specific to the regexp test. It's commonly
acceptable, and, hey, if it's faster, why not, right?

A side note: this is one of the first things I've worked with that I
decided to make into something that was includable.... It's a
milestone in my way of thinking and coding with Ruby! Yay! (Sorry, had
to tell someone!)

Cheers!

M.T.

Logan Capaldo wrote:
>>>  end
>> Kind regards
>>
>>     robert
>>
> 
> I have a sneaking suspicion he might have done it with the global 
> variable (although $1 isn't really global) on purpose, since =~ 
> /literal/ is the fastest way to do a regexp.

I did a benchmark just to put some meat to this:

13:37:39 [Temp]: ./bm.rb
Rehearsal --------------------------------------------
global     1.859000   0.000000   1.859000 (  1.863000)
String[]   2.156000   0.000000   2.156000 (  2.180000)
----------------------------------- total: 4.015000sec

                user     system      total        real
global     1.828000   0.000000   1.828000 (  1.872000)
String[]   2.094000   0.000000   2.094000 (  2.172000)

IOW, the global var version uses 87,3% of the time or is 15% faster.

Kind regards

	robert

Depending on how you feel about mucking with core ruby types, a method
like this one seems like a decent candidate for mixing in to Object.

class Object
  def this_method
    caller[0]=~/`(.*?)'/
    $1
  end
end

Course I'm one of those crazy irb hack loving people that mixes
convenience methods into everything....

> >> Matt Todd wrote:
> >>> If you wanted to modularize it just for the sake of it, you could do
> >>> something similar to the following:
> >>> module CurrentMethodName
> >>>  def this_method
> >>>    caller[0]=~/`(.*?)'/
> >>>    $1
> >>>  end
> >>> end

<snip>

Aleks Kissinger wrote:
> Depending on how you feel about mucking with core ruby types, a method
> like this one seems like a decent candidate for mixing in to Object.
> 
> class Object
>  def this_method
>    caller[0]=~/`(.*?)'/
>    $1
>  end
> end

These methods are typically put into Kernel and made private.  Also, you
don't check whether the RX actually matches.  I'd also prefer to change
the RX to a more efficient one.  So that would give

module Kernel
private
   def this_method
     caller[0] =~ /`([^']*)'/ and $1
   end
end

Kind regards

	robert

I like that much better. That seems to fit in with the rest of how
Ruby works. Well done. Also, thanks for improving the RX efficiency: I
see how that would be a bit more efficient.

M.T.

Robert Klemme wrote:

<snip>

> These methods are typically put into Kernel and made private.  Also, you
> don't check whether the RX actually matches.  I'd also prefer to change
> the RX to a more efficient one.  So that would give
> 
> module Kernel
> private
>    def this_method
>      caller[0] =~ /`([^']*)'/ and $1
>    end
> end
> 
> Kind regards
> 
>   robert

Excellent! I was searching for this for a long time. 'what method called 
this method' or 'how to find out which method called this method ?'

So, here's one:

module Kernel
private
  def this_method
    caller[0] =~ /`([^']*)'/ and $1
  end
  def calling_method
    caller[1] =~ /`([^']*)'/ and $1
  end
end

Example:

def a
 b
end

def b
 puts "this method: " + this_method
 puts "calling method: " + calling_method
end

calling 'a' will output
this method: b
calling method: a

Thx!

2010/3/10 Ace Suares <ace@suares.an>:
>>    def this_method
> private
> def a
> calling method: a
Wow, you just reviewed a 3.5 year old thread! :-)

Btw, nowadays I would change the regular expression matching to use
String#[] which I find much more elegant:

  def this_method
    caller[0][/`([^']*)'/, 1]
  end

Kind regards

robert

On Wed, Mar 10, 2010 at 9:29 AM, Robert Klemme
<shortcutter@googlemail.com> wrote:
> 2010/3/10 Ace Suares <ace@suares.an>:
I would leave Kernel (and Object ) alone for that

module Whatever
end

mix it in where and when you want. Ok that is a matter of taste but
gives you a less intrusive way

Cheers
R

Reviving thread again: I'd use __method__

In terms of original example.

def test_method
  puts __method__
end

Maybe __method__ didn't exist in 2006 (too lazy to check, maybe its
>=1.8.7), in 2010 it definitely did ;-)

eT Ma wrote in post #988662:
> Reviving thread again: I'd use __method__
>
> In terms of original example.
>
> def test_method
>   puts __method__
> end
>
> Maybe __method__ didn't exist in 2006 (too lazy to check, maybe its
>>=1.8.7), in 2010 it definitely did ;-)

I'm writing plugins for SketchUp which uses Ruby 1.8.6. __method__ does 
not exist there.

Using caller does give me the name of the calling method, but there is 
no reference to what module or class that method belonged to. Is that 
possible to obtain?

> Using caller does give me the name of the calling method, but there is
> no reference to what module or class that method belonged to. Is that
> possible to obtain?

def get_mname
  caller[0]=~/`(.*?)'/  # note the first quote is a backtick
  $1
end

def dinosaur
  puts get_mname
  puts method(get_mname).owner
end

dinosaur

--output:--
dinosaur
Object

7stud -- wrote in post #1083904:
>> Using caller does give me the name of the calling method, but there is
>> no reference to what module or class that method belonged to. Is that
>> possible to obtain?
>
> def get_mname
>   caller[0]=~/`(.*?)'/  # note the first quote is a backtick
>   $1
> end
>
> def dinosaur
>   puts get_mname
>   puts method(get_mname).owner
> end
>
> dinosaur
>
> --output:--
> dinosaur
> Object

There is no Method#owner in Ruby 1.8.6.

And I don't understand how it would have worked anyway - determining the 
class/method a method belongs to given just a string with the method 
name? If you have two classes, Foo and Bar - each each method #biz - how 
would method('biz').owner returned the correct caller?

7stud -- wrote in post #1083904:
>> Using caller does give me the name of the calling method, but there is
>> no reference to what module or class that method belonged to. Is that
>> possible to obtain?
>
> def get_mname
>   caller[0]=~/`(.*?)'/  # note the first quote is a backtick
>   $1
> end
>
> def dinosaur
>   puts get_mname
>   puts method(get_mname).owner
> end
>
> dinosaur
>
> --output:--
> dinosaur
> Object

Guys, FYI caller doesn't give meaningful data about method when the
method is called from a bare file, e.g. a Cucumber Step definition.
Instead of giving

common_steps.rb:42:in `some_method_or_other' ...

it gives

common_steps.rb:42:in `block in <top (required)>' ...

For these situations you're better off using __method__ and
self.name.to_s if you also need the class in which the method is 
contained.

HTH,

Dermot