Using the current method name within current method

ruby-talk
1

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

2

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

-- Daniel

···

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

3

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

···

--
Posted via http://www.ruby-forum.com/.

4

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'

···

On 7/30/06, Daniel Harple <dharple@generalconsumption.org> wrote:

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

5

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?

···

--
Posted via http://www.ruby-forum.com/\.

6

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

···

--
Posted via http://www.ruby-forum.com/\.

7

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.

8

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.

What exactly distinguishes a "bare file" from ordinary ruby code?

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.

You could as well just look at the next item in the list and use that:

$ ruby -e 'def f;p caller(1);end;f;1.times {f}'
["-e:1:in `<main>'"]
["-e:1:in `block in <main>'", "-e:1:in `times'", "-e:1:in `<main>'"]

Kind regards

robert

···

On Thu, May 16, 2013 at 7:32 PM, Dermot C. <lists@ruby-forum.com> wrote:

--
remember.guy do |as, often| as.you_can - without end
http://blog.rubybestpractices.com/

9

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

10

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.

···

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

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

11

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

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.

12

Logan Capaldo wrote:

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

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

bm.rb (355 Bytes)

···

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

13

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>

14

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

15

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.

16

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!

···

--
Posted via http://www.ruby-forum.com/\.

17

Wow, you just reviewed a 3.5 year old thread! :slight_smile:

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

···

2010/3/10 Ace Suares <ace@suares.an>:

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

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

--
remember.guy do |as, often| as.you_can - without end
http://blog.rubybestpractices.com/

18

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

···

On Wed, Mar 10, 2010 at 9:29 AM, Robert Klemme <shortcutter@googlemail.com> wrote:

2010/3/10 Ace Suares <ace@suares.an>:

--
Learning without thought is labor lost; thought without learning is perilous.”
--- Confucius

19

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 :wink:

--
Posted via http://www.ruby-forum.com/\.

20

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 :wink:

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?

···

--
Posted via http://www.ruby-forum.com/\.