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