From: Jesús Gabriel y Galán on
On Mon, Jun 14, 2010 at 7:23 AM, Sateesh Kambhamapati
<sateesh.mca09(a)gmail.com> wrote:
> Jesús Gabriel y Galán wrote:
>> On Thu, Jun 10, 2010 at 11:53 AM, Sateesh Kambhamapati
>> <sateesh.mca09(a)gmail.com> wrote:
>>> end
>>> end
>>> f=flower.new
>>> f.rose-------------------->It gives me rose
>>> but now f.jasmine------------------->It calls method_missing
>>> but i want it comes to my class "Flower"
>>
>> I'm not sure if I understand you correctly, but if you want those
>> method missing calls, to be called on the Flower class, you can do
>> this:
>>
>> irb(main):001:0> class Flower
>> irb(main):002:1> def self.jasmine
>> irb(main):003:2> "jasmine"
>> irb(main):004:2> end
>> irb(main):005:1> def method_missing meth, *args, &blk
>> irb(main):006:2> self.class.send meth, *args, &blk
>> irb(main):007:2> end
>> irb(main):008:1> end
>> => nil
>> irb(main):016:0> Flower.new.jasmine
>> => "jasmine"
>>
>>> So i Want to know which methods are invoked by my "Flower" object
>>
>> I don't understand this question.
>>
>> Jesus.
>
> Thanks for reply
> i would like to know which methods are called by class object i.e
> class Flower
>     def jasmine
>     puts "iam jasmine"
>   end
>      def rose
>      puts "iam rose"
>  end
> end
>
> flowerlist=Flower.new #----->Creating instance for flower
> flowerlist.jasmine  #------->"gives output as "iam jasmine"
> flowerlist.rose  # =======> "gives output as "i am rose"
> flowerlist.lotus   #------->"Shows No Method Error"
>
> Question : --> My Question is i would like to know which methods are
> called by object i.e flowerlist  in the class Flower
>
> if i already know those methods then
> suppose if i have not define some method then i will define it
> dynamically example here is "lotus"
>
> i think u understand my question

As I understand the question now, I think the answer from Phrogz is
spot on. You need to use the method_missing method, which will catch
any call to a method you haven't defined:

class Flower
def jasmine
puts "iam jasmine"
end
def rose
puts "iam rose"
end

def method_missing meth, *args, &blk
puts "method #{meth} called, but not defined"
end
end

flowerlist=Flower.new #----->Creating instance for flower
flowerlist.jasmine #------->"gives output as "iam jasmine"
flowerlist.rose # =======> "gives output as "i am rose"
flowerlist.lotus #=> "method lotus called, but not defined"

So, now you know where you have a place to do whatever you want to do
with a call to a method that doesn't exist. For example, if you want
to dynamically create a method that returns its name as a string, you
can do:

def method_missing method, *args, &blk
self.class.send(:define_method, method) do
method.to_s
end
send(method)
end

This will dynamically define (and call) a method that returns its name
as a string. So if you add that to the Flower class:

class Flower
def method_missing method, *args, &blk
self.class.send(:define_method, method) do
method.to_s
end
send(method)
end
end

f = Flower.new
f.lotus #=> "lotus"
f.rose #=> "rose"

and so on. In any case, I recommend looking at Phrogz's answer,
because it's a nice little utility to automatically define method that
do different things depending the the name patterns.

Regards,

Jesus.

From: Brian Candler on
Sateesh Kambhamapati wrote:
> i would like to know which methods are called by class object i.e

Not sure what you mean by "called by class object"

> Question : --> My Question is i would like to know which methods are
> called by object i.e flowerlist in the class Flower
>
> if i already know those methods then
> suppose if i have not define some method then i will define it
> dynamically example here is "lotus"

If you want to intercept *all* calls to the object, then put a proxy
object in front of it, and delegate the calls (e.g. see
SimpleDelegator).

If you're happy to intercept only the unknown methods (which you will
then define), then method_missing is what you want.

class Flower
def jasmine
puts "I am jasmine"
end
def method_missing(meth,*args,&blk)
puts "method #{meth.inspect} called with #{args.inspect}"
end
end
flowerlist=Flower.new
flowerlist.jasmine # I am jasmine
flowerlist.lotus # method :lotus called with []
--
Posted via http://www.ruby-forum.com/.

From: Rein Henrichs on
On 2010-06-14 01:22:40 -0700, Jes�s Gabriel y Gal�n said:

> On Mon, Jun 14, 2010 at 7:23 AM, Sateesh Kambhamapati
> <sateesh.mca09(a)gmail.com> wrote:
>> Jes�s Gabriel y Gal�n wrote:
>>> On Thu, Jun 10, 2010 at 11:53 AM, Sateesh Kambhamapati
>>> <sateesh.mca09(a)gmail.com> wrote:
>>>> end
>>>> end
>>>> f=flower.new
>>>> f.rose-------------------->It gives me rose
>>>> but now f.jasmine------------------->It calls method_missing
>>>> but i want it comes to my class "Flower"
>>>
>>> I'm not sure if I understand you correctly, but if you want those
>>> method missing calls, to be called on the Flower class, you can do
>>> this:
>>>
>>> irb(main):001:0> class Flower
>>> irb(main):002:1> def self.jasmine
>>> irb(main):003:2> "jasmine"
>>> irb(main):004:2> end
>>> irb(main):005:1> def method_missing meth, *args, &blk
>>> irb(main):006:2> self.class.send meth, *args, &blk
>>> irb(main):007:2> end
>>> irb(main):008:1> end
>>> => nil
>>> irb(main):016:0> Flower.new.jasmine
>>> => "jasmine"
>>>
>>>> So i Want to know which methods are invoked by my "Flower" object
>>>
>>> I don't understand this question.
>>>
>>> Jesus.
>>
>> Thanks for reply
>> i would like to know which methods are called by class object i.e
>> class Flower
>> � � def jasmine
>> � � puts "iam jasmine"
>> � end
>> � � �def rose
>> � � �puts "iam rose"
>> �end
>> end
>>
>> flowerlist=Flower.new #----->Creating instance for flower
>> flowerlist.jasmine �#------->"gives output as "iam jasmine"
>> flowerlist.rose �# =======> "gives output as "i am rose"
>> flowerlist.lotus � #------->"Shows No Method Error"
>>
>> Question : --> My Question is i would like to know which methods are
>> called by object i.e flowerlist �in the class Flower
>>
>> if i already know those methods then
>> suppose if i have not define some method then i will define it
>> dynamically example here is "lotus"
>>
>> i think u understand my question
>
> As I understand the question now, I think the answer from Phrogz is
> spot on. You need to use the method_missing method, which will catch
> any call to a method you haven't defined:
>
> class Flower
> def jasmine
> puts "iam jasmine"
> end
> def rose
> puts "iam rose"
> end
>
> def method_missing meth, *args, &blk
> puts "method #{meth} called, but not defined"
> end
> end
>
> flowerlist=Flower.new #----->Creating instance for flower
> flowerlist.jasmine #------->"gives output as "iam jasmine"
> flowerlist.rose # =======> "gives output as "i am rose"
> flowerlist.lotus #=> "method lotus called, but not defined"
>
> So, now you know where you have a place to do whatever you want to do
> with a call to a method that doesn't exist. For example, if you want
> to dynamically create a method that returns its name as a string, you
> can do:
>
> def method_missing method, *args, &blk
> self.class.send(:define_method, method) do
> method.to_s
> end
> send(method)
> end
>
> This will dynamically define (and call) a method that returns its name
> as a string. So if you add that to the Flower class:
>
> class Flower
> def method_missing method, *args, &blk
> self.class.send(:define_method, method) do
> method.to_s
> end
> send(method)
> end
> end
>
> f = Flower.new
> f.lotus #=> "lotus"
> f.rose #=> "rose"
>
> and so on. In any case, I recommend looking at Phrogz's answer,
> because it's a nice little utility to automatically define method that
> do different things depending the the name patterns.
>
> Regards,
>
> Jesus.

My goodness. Has anyone asked why such metaprogramming might be
necessary? I don't even understand the question, let enough to the
extent that I would feel confident in suggesting such drastic measures
as the solution.

Metaprogramming is not a universal hammer. Even if it were, you
wouldn't want everything to be a nail.

--
Rein Henrichs
http://puppetlabs.com
http://reinh.com

From: Jesús Gabriel y Galán on
On Mon, Jun 14, 2010 at 7:20 PM, Rein Henrichs <reinh(a)reinh.com> wrote:

> My goodness. Has anyone asked why such metaprogramming might be necessary? I
> don't even understand the question, let enough to the extent that I would
> feel confident in suggesting such drastic measures as the solution.

It's what I understood from the OP. He said:

"suppose if i have not define some method then i will define it dynamically"

From this and the rest of his question, I understood he wanted to
intercept calls to missing methods and define them dynamically.
Do you understand something different?

> Metaprogramming is not a universal hammer. Even if it were, you wouldn't
> want everything to be a nail.

I can agree with this, but when the OP explicitly asks for a way to
dynamically define missing methods, this is what comes to my mind.

Of course, it might very well be the case that to solve OP's problem,
this is not necessary at all and that studying his original problem
might lead to a different solution, but in any case I see no harm in
explaining him method_missing and how to define methods. Feel free to
ask him about what problem he is trying to solve, and maybe we can
come up with a better solution.

Regards,

Jesus.

From: Rein Henrichs on
On 2010-06-14 10:36:57 -0700, Jesús Gabriel y Galán said:

> Of course, it might very well be the case that to solve OP's problem,
> this is not necessary at all and that studying his original problem
> might lead to a different solution, but in any case I see no harm in
> explaining him method_missing and how to define methods. Feel free to
> ask him about what problem he is trying to solve, and maybe we can
> come up with a better solution.
>
> Regards,
>
> Jesus.

Agreed. I would prefer that we attempt to understand a bit more of the
context of the question.

Rant follows:

Questions like these are often the result of something like the
Dunning–Kruger effect, where the questioner may not know enough to know
that the question is bad and may only receive a confusing or misleading
answer. For example:

A: "How can I get more angular velocity out of this screwdriver?"

B: "Um, just twist it harder."

A: "Ok, that isn't helping me drive this nail in."

B: *facepalm* "Oh, you should be using a hammer."

TL;DR: Why does OP want to define methods dynamically? What business
value would this provide?


--
Rein Henrichs
http://puppetlabs.com
http://reinh.com