[lnkForumImage]
TotalShareware - Download Free Software
Confronta i prezzi di migliaia di prodotti.
Asp Forum
 Home | Login | Register | Search 


 

Forums >

comp.lang.ruby

using the current method name within current method

Matthew Heidemann

7/31/2006 3:37:00 AM

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
10 Answers

Daniel Harple

7/31/2006 3:44:00 AM

0

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

Aleks Kissinger

7/31/2006 4:06:00 AM

0

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

Matt Todd

7/31/2006 5:43:00 AM

0

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.

Robert Klemme

7/31/2006 8:22:00 AM

0

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

Logan Capaldo

7/31/2006 5:58:00 PM

0


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
>

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.

Matt Todd

8/1/2006 3:27:00 AM

0

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.

Robert Klemme

8/1/2006 11:40:00 AM

0

Logan Capaldo wrote:
>
> 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
>>
>
> 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

#!/usr/bin/env ruby

require 'benchmark'

REPEAT = 1_00_000

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

def this_method_2
caller[0] =~ /`([^']*)'/ and $1
end

Benchmark.bmbm do |bm|
bm.report "global" do
REPEAT.times do
this_method_2
end
end

bm.report "String[]" do
REPEAT.times do
this_method_1
end
end
end

Aleks Kissinger

8/2/2006 4:52:00 PM

0

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>

Robert Klemme

8/3/2006 9:28:00 AM

0

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

Matt Todd

8/3/2006 3:47:00 PM

0

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.