[ANN] prototype-2.0.0

[ara.t.howard]

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
42
true
false
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
42
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
42
42.0


enjoy

-a