Ruby Buzz Forum - Tricking that old, picky interpreter: prototype-based OOP

This post originated from an RSS feed registered with Ruby Buzz by Eigen Class.
Original Post: Tricking that old, picky interpreter: prototype-based OOP Feed Title: Eigenclass Feed URL: http://feeds.feedburner.com/eigenclass Feed Description: Ruby stuff --- trying to stay away from triviality.	Latest Ruby Buzz Posts Latest Ruby Buzz Posts by Eigen Class Latest Posts From Eigenclass

Ruby's object model has been becoming more strict as of late, preventing some imaginative (albeit ultimately useless?) tricks like the following prototypish OOP:

a = Object.new
def a.foo; "a#foo" end
a.foo                                              # => "a#foo"
ProtoA = Class.new(class << a; self.dup end)
b = ProtoA.new
b.foo                                              # => "a#foo"
RUBY_VERSION                                       # => "1.8.2"

Nowadays, that snippet would die on the Class#dup of the singleton class:

a = Object.new
def a.foo; "a#foo" end
a.foo                                              # => "a#foo"
ProtoA = Class.new(class << a; self.dup end)
b = ProtoA.new
b.foo                                              # => 
# ~> -:4:in `initialize_copy': can't copy singleton class (TypeError)
# ~> 	from -:4

This doesn't mean we cannot do it, though, but it requires some black magic:

a = "foo"
def a.bar; "A#bar" end
proto = a.prototype
proto                                              # => #<Class:0xb7d43f50>
proto.superclass                                   # => #<Class:#<String:0xb7d45544>>
orig = String.instance_methods
proto.instance_methods(true) - orig                # => ["bar"]

ueber_string = proto.new
ueber_string                                       # => ""
ueber_string.bar                                   # => "A#bar"

proto.class_eval do
  def initialize(x); super(x.to_s.upcase) end
end

proto.new("hello, world")                          # => "HELLO, WORLD"

object = Object.new
class << object
  def foo; "object#foo" end
end

obj = object.prototype.new
obj.foo                                            # => "object#foo"

def object.bar; "object#bar" end
obj.bar                                            # => "object#bar"

That's more powerful than a mere Class.new(singleton_class.dup) because changes in the singleton class affect descendents, as happens with normal inheritance (for both classes and modules).

Making it happen

Read more...


	Web Artima.com