[ruby-core:21427] Re: Proposal: Module#copy_method

I'm not saying that it couldn't work. If implemented differently than 1.9's module_function then it might be ok.
The example I referred to is following (1.8.6 works fine, 1.9 doesn't):

class Module
  # module_function is not defined on Class class, let's add a public alias:
  alias :mf :module_function
  public :mf
end

# define foo in D and a different one in singleton of D:
class D
  def foo
    puts 'D::foo'
  end

  class << self
    def foo
      puts 'S(D)::foo'
    end
  end
end

# define foo in C < D and in singleton of C via module_function:
class C < D
  # call module_function
  # - module_function checks that self is a class
  # - thus we need to call it with a module receiver (e.g. Kernel, but any other module would do)
  Kernel.mf

  # defines foo in singleton of C since module_function has been called in the current scope:
  def foo
    puts 'foo'
    super
  end

  # calls foo on C, which should invoke foo on singleton of C, which should call super method on singleton of D
  foo
end

Ruby 1.8.6 (right):
foo
S(D)::foo

Ruby 1.9.1 (wrong):
foo
D::foo

Tomas

From: Yehuda Katz [mailto:[e-mail]]
Sent: Sunday, January 18, 2009 9:16 PM
To: [e-mail]
Subject: [ruby-core:21426] Re: Proposal: Module#copy_method

I can show that this is not the case in MRI because my very crude hack (which just copies the method) doesn't break super semantics.

-- Yehuda
On Sun, Jan 18, 2009 at 10:04 PM, Tomas Matousek <[e-mail]<mailto:[e-mail]>> wrote:

I believe that methods (and blocks defined as methods via method_defined) are somehow closed over the module that declares them so that "super" can find the right module/class whose parent's method to call. At least they are in IronRuby :)



A simple copy of a method without changing binding to its declaring module therefore causes super to fail (or changes its semantics). I think this is the case even for module_function (I might have an example somewhere that demonstrates it, will send it tomorrow if I find it). module_function "copies" the method from declaring module to its singleton class, which is indeed not derived from the declaring module, breaking super in some constructed cases.



Tomas



From: Yehuda Katz [mailto:[e-mail]<mailto:[e-mail]>]
Sent: Sunday, January 18, 2009 3:14 PM
To: [e-mail]<mailto:[e-mail]>
Subject: [ruby-core:21423] Re: Proposal: Module#copy_method



Just FYI, the define_method version fails if your method requires the use of super. Observe:

class Zoo1
  def bar
    p "In superclass"
    1
  end
end

class Zoo2 < Zoo1
  def bar
    p "in Zoo2mod #{self}"
    super + 1
  end

  mod = Module.new do
    define_method(:bar, Zoo2.instance_method(:bar))
  end
  include mod

  def bar
    p "In bar"
    super + 1
  end
end

p Zoo2.new.bar

The above produces SystemStackError: stack level too deep, infinite-looping in the original bar implementation on Zoo2. Also, it doesn't work on 1.9.

-- Yehuda

On Sun, Jan 18, 2009 at 2:32 PM, Charles Oliver Nutter <[e-mail]<mailto:[e-mail]>> wrote:

Yehuda Katz wrote:

I'd like it to be possible to copy methods from one module to another. The rationale is that this feature would make it possible to modify existing methods without being forced to resort to aliasing. Here's an implementation that works on 1.8 and 1.9:



Here's a pure-ruby version that works on an unmodified JRuby:

require 'jruby'

class Module
 def copy_method(mod, sym)
   # get JRuby DynamicMethod object from RubyMethod
   org.jruby.RubyMethod.field_reader :method
   ruby_method = mod.instance_method(sym)
   real_method = JRuby.reference(ruby_method).method

   # native methods may have memory/object layout needs
   raise "can't copy native method" if real_method.native?

   # Add it directly to the JRuby RubyModule self
   real_modcls = JRuby.reference(self)
   real_modcls.add_method(sym.to_s, real_method)
 end
end

- Charlie



--
Yehuda Katz
Developer | Engine Yard
(ph) 718.877.1325



--
Yehuda Katz
Developer | Engine Yard
(ph) 718.877.1325