NAME
prototype.rb
INSTALL
gem install prototype
URIS
http://rubyforge.org/projects/codeforpeople/
http://codeforpeople.com/lib/ruby/
SYNOPSIS
prototype.rb facilitates a prototype based coding style
http://en.wikipedia.org/wiki/Prototype-based_programming
for ruby
WHY
prototype based programming looks very nice 
also, there are many problems that a genuine singleton object with cloning
abilities can illuminate clearly
it's the basis of a new rendering model for rails
HISTORY
2.0.0
completely gutted the prototype library and re-implemented with a
module/singleton_class/include approach.
note that this version increases a major number because it is NOT
compatible with past releases. the incompatible change is that 'clone'
now returns an object that does not reflect changes made to the parent: it
is completely independant.
1.0.0
cleanup up a small error where bareword syntax errors in a prototype block
were silently ignored
SAMPLES
<========< samples/a.rb >========>
~ > cat samples/a.rb
require 'prototype'
singleton = Prototype.new{
@a, @b = 40, 2
def answer() @a + @b end
}
p singleton.answer #=> 42
~ > ruby samples/a.rb
42
<========< samples/b.rb >========>
~ > cat samples/b.rb
require 'prototype'
DB = Prototype.new{
host 'localhost'
port 4242
conn_string [host, port].join(':')
def connect() p [host, port] end
}
p DB.host #=> "localhost"
p DB.port #=> 4242
p DB.conn_string #=> "localhost:4242"
DB.connect #=> ["locahost", 4242]
~ > ruby samples/b.rb
"localhost"
4242
"localhost:4242"
["localhost", 4242]
<========< samples/c.rb >========>
~ > cat samples/c.rb
require 'prototype'
a = Prototype.new{
def method() 42 end
}
b = a.clone
p a.method #=> 42
p b.method #=> 42
a.extend{
def method2() '42' end
}
p a.respond_to?(:method2) #=> true
p b.respond_to?(:method2) #=> false
b.extend{
def method3() 42.0 end
}
p a.respond_to?(:method3) #=> false
p b.respond_to?(:method3) #=> true
~ > ruby samples/c.rb
42
true
false
true
<========< samples/d.rb >========>
~ > cat samples/d.rb
require 'prototype'
proto = prototype{ attributes 'a' => 1, 'b' => 2, 'c' => 3 }
proto = prototype{ a 1; b 2; c 3 }
%w( a b c ).each{|attr| p proto.send(attr)} #=> 1, 2, 3
clone = proto.clone
proto.c = 42
%w( a b c ).each{|attr| p proto.send(attr)} #=> 1, 2, 42
%w( a b c ).each{|attr| p clone.send(attr)} #=> 1, 2, 3
~ > ruby samples/d.rb
1
2
3
1
2
42
1
2
3
<========< samples/e.rb >========>
~ > cat samples/e.rb
require 'prototype'
proto = Object.prototype{
@a = 40
@b = 2
}
p(proto.a + proto.b) #=> 42
~ > ruby samples/e.rb
42
<========< samples/f.rb >========>
~ > cat samples/f.rb
require 'prototype'
a = Object.prototype{ attributes 'a' => 4, 'b' => 10, 'c' => 2}
b = Object.prototype{ a 4; b 10; c 2 }
c = Object.prototype{ @a = 4; @b = 10; @c = 2 }
[a, b, c].each{|obj| p(obj.a * obj.b + obj.c) } #=> 42, 42, 42
~ > ruby samples/f.rb
42
<========< samples/g.rb >========>
~ > cat samples/g.rb
require 'prototype'
a = prototype{ @a, @b, @c = 4, 10, 2 }
b = a.clone
b.extend{ def answer() a * b + c end }
p b.answer #=> 42
~ > ruby samples/g.rb
42
<========< samples/h.rb >========>
~ > cat samples/h.rb
require 'prototype'
proto = prototype{
a 1
b 1
c 40
sum { a + b + c }
}
p proto.sum #=> 42
~ > ruby samples/h.rb
42
<========< samples/i.rb >========>
~ > cat samples/i.rb
require 'prototype'
o = Object.new
o.prototyping do
@a = 42
attr 'a'
end
p o.a
o = prototype do
@a = 42
attr 'a'
end
p o.a
o.prototyping do
@b = 42
attr 'b'
end
p o.b
o.prototyping do
@b = 42.0
end
p o.b
~ > ruby samples/i.rb
42
42.0
enjoy
-a
···
--
we can deny everything, except that we have the possibility of being better. simply reflect on that.
h.h. the 14th dalai lama
