Hoi Rubyists.
I am kind of … confused. Up till now I had the illusion you could only
call methods on an object which you could also find via methods or via
the included modules. Fine… Why does this output what it does then?
Where is this method defined? Some kind of method lookup cache? How to
force flushing it (besides redefining the methods of the receiver?)
Thanks in advance for the help,
-Martin
— snippiesnap: fun_delegate.rb —
class A; def a; “a”; end; end
class B; def b; “b”; end; end
obvious: return difference of instance methods, ignoring
“method_missing”
def inst_meth_delta( klass1, klass2 )
klass1.instance_methods - klass2.instance_methods - [
“method_missing” ]
end
obvious:P
if delegation is to be established, create an anonymous module, define
methods on it to delegate to the receiver, extend the sender with this
module.
if delegation is to be deleted, remove methods from the anonymous
module.
def fun_delegate(snd, rcv)
return unless (snd && rcv)
deinstalled=false;
# maybe remove the delegation again?
(class << snd ; included_modules ; end).each do |mod|
# get the source object_id (obj which is delegated to)
dd = mod.instance_variables.include?('@dd') &&
mod.instance_variable_get(:@dd)
# deinstall methods if rcv is delegated to a second
# time - or when rcv is :off.
if dd && (dd == rcv.object_id || rcv == :off) then
puts “Removing delegation from #{snd} to #{rcv}
(mod: #{mod})”
mod.instance_methods.each do |meth|
mod.send(:remove_method, meth.intern)
end
deinstalled=true;
mod.instance_variable_set(:@dd, nil)
end
end
# ... or set it up?
unless deinstalled
(mod = Module.new).instance_variable_set(:@dd,
rcv.object_id)
puts “delegating from #{snd} to #{rcv} via #{mod}…”
inst_meth_delta(rcv.class, snd.class).each {|meth|
mod.send(:define_method, meth.intern) {|*args|
rcv.send(meth.intern, *args) }
}
snd.extend(mod)
end
end
a=A.new; b=B.new
obvious so far
nometherr
begin puts a.b rescue puts $! end
fun_delegate a,b
“b”
begin puts a.b rescue puts $! end
fun_delegate a,b
MAGIC!!!
“b”
begin puts a.b rescue puts $! end
Fine, where is this “b” coming from?
puts a.methods.find{|m| m==‘b’} ;# -> nil
puts a.methods - Kernel.methods ;# -> “a”
puts a.singleton_methods ;# -> []
puts “#{(class << a ; included_modules ; end).collect {|mod|
mod.instance_methods unless mod.name == “Kernel”
}}” ;# -> [[], nil]
— snappiesnip: fun_delegate.rb —
— output —
$ ruby -vw fun_delegate.rb
ruby 1.8.4 (2005-12-24) [i386-netbsdelf]
undefined method `b’ for #<A:0x806b618>
delegating from #<A:0x806b618> to #<B:0x806b604> via
#Module:0x806b4b0…
b
Removing delegation from #<A:0x806b618> to #<B:0x806b604> (mod:
#Module:0x806b4b0)
b
nil
a
— end —