Injecting an instance method into another class' class method

I’d like to reopen a class Foo and redefine one of its methods to use an
instance method from class Bar. I can’t seem to figure out how to do it
or even if it is possible.

I tried lots of different techniques and none have worked, so here I am
asking for a bit of help. An example of one of the techniques I tried is
included below.

class Foo
def self.now
Time.now.to_i
end
end

class Bar
def initialize
@bar = proc { now }

Bar.class_eval <<-code
class Foo
  def Foo.now
    @bar.call
  end
end
code

end

def now
puts “bar now called”
end
end

I would like Foo.now to return Time.now.to_i for the normal case.
However, after an instance of Bar is created, I would like the Bar
instance to redefine Foo.now to call the #now instance method of Bar.

This is what the output should look like:

ruby-1.9.1-p378 > Foo.now
=> 1281540640
ruby-1.9.1-p378 > Bar.new
bar now
=> #<Bar:0x00000101216268 @bar=#Proc:[email protected]:41(irb)>
ruby-1.9.1-p378 > Foo.now
=> “bar now called”

Is it possible to do this?

cr

On Aug 11, 2010, at 11:11 AM, Jesús Gabriel y Galán wrote:

=> 1281540640
“Foo’s now”
end

$ ruby redefine.rb
Foo’s now
Bar’s now
Bar’s now

The problem with an instance variable is that you need to have self as
Bar’s instance in order for it to work. So if you can use a local
variable and use closures, it will work, as shown above.

Ah, excellent! I was trying to figure out how to use a closure for this
purpose, but my mind got all turned inside out.

I’m somewhat familiar with getting the singleton class of a class using
the “class << self;self;end” syntax, but I’m not sure what is happening
here:

class << Foo
self # what is self here? Foo? Bar? instance of Bar?
end

My inline questions lay it out.

I’d really like to understand how that part of it is working. I
understand the mechanics of the remaining code.

cr

On Wed, Aug 11, 2010 at 5:32 PM, Chuck R. [email protected]
wrote:

class Bar
end

cr

I’ve managed to do it with a local variable, instead of an instance
variable:

class Foo
def self.now
“Foo’s now”
end
end

class Bar
def initialize
bar = proc {now}
class << Foo; self; end.class_eval do
define_method(:now) do
bar.call
end
end
end

def now
“Bar’s now”
end
end

puts Foo.now
puts Bar.new.now
puts Foo.now

$ ruby redefine.rb
Foo’s now
Bar’s now
Bar’s now

The problem with an instance variable is that you need to have self as
Bar’s instance in order for it to work. So if you can use a local
variable and use closures, it will work, as shown above.

Jesus.

Hi,

On Thu, Aug 12, 2010 at 11:48 PM, Chuck R. [email protected]
wrote:

I’m somewhat familiar with getting the singleton class of a class using the “class << self;self;end” syntax, but I’m not sure what is >happening here:

class << Foo
self # what is self here? Foo? Bar? instance of Bar?
end

since classes are objects too , for “class << Foo; self; end” self is
singleton (or eigenclass) class of the class object. Typically class
methods of a class are defined in its singleton class.

http://yugui.jp/articles/846


Let them talk of their oriental summer climes of everlasting
conservatories; give me the privilege of making my own summer with my
own coals.

http://gnufied.org

This forum is not affiliated to the Ruby language, Ruby on Rails framework, nor any Ruby applications discussed here.

| Privacy Policy | Terms of Service | Remote Ruby Jobs