prototype 0.1.0 → 0.2.0

data/README

@@ -9,7 +9,7 @@ URIS
 
 SYNOPSIS
 
-  prototype.rb implements the prototype design pattern
+  prototype.rb facilitates a prototype based coding style 
 
     http://en.wikipedia.org/wiki/Prototype-based_programming
 
@@ -19,117 +19,205 @@ WHY
 
   prototype based programming can look very nice ;-)
 
-EXAMPLES
+SAMPLES
 
-  __________________________________________
-  ~ > cat samples/a.rb
-  __________________________________________
-  require 'prototype'
-
-  singleton = Prototype.new{
-    @a, @b = 40, 2
+  <========< samples/a.rb >========>
 
-    def answer() @a + @b end
-  }
-
-  p singleton.answer
+  ~ > cat samples/a.rb
 
+    require 'prototype'
+    
+    singleton = Prototype.new{
+      @a, @b = 40, 2
+    
+      def answer() @a + @b end
+    }
+    
+    p singleton.answer
 
-  __________________________________________
   ~ > ruby samples/a.rb
-  __________________________________________
-  42
 
+    42
 
 
-  __________________________________________
-  ~ > cat samples/b.rb
-  __________________________________________
-  require 'prototype'
-
-  DB = Prototype.new{
-    host 'localhost'
-    port 4242
-
-    def connect() p [host, port] end
-  }
+  <========< samples/b.rb >========>
 
-  p DB
-  p DB.host
-  p DB.port
-  DB.connect
+  ~ > 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
+    p DB.host
+    p DB.port
+    p DB.conn_string
+    
+    DB.connect
 
-  __________________________________________
   ~ > ruby samples/b.rb
-  __________________________________________
-  "localhost"
-  4242
-  ["localhost", 4242]
-
 
+    #<#<Class:0xb7595348>:0xb7595438 @conn_string="localhost:4242", @port=4242, @host="localhost">
+    "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
+    p b.method
+    
+    a.extend{
+      def method2() '42' end
+    }
+    
+    p a.method2
+    p b.method2
+    
+    b.extend{
+      def method3() 42.0 end
+    }
+    
+    p b.method3
+    p a.method3  # throws error!
+    
+
+  ~ > ruby samples/c.rb
+
+    42
+    42
+    "42"
+    "42"
+    42.0
+    samples/c.rb:24: undefined method `method3' for #<#<Class:0xb7595860>:0xb75953c4> (NoMethodError)
+
+
+  <========< 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)}
+    
+    clone = proto.clone
+    proto.c = 42
+    
+    %w( a b c ).each{|attr| p proto.send(attr)}
+    %w( a b c ).each{|attr| p clone.send(attr)}
+
+  ~ > ruby samples/d.rb
+
+    1
+    2
+    3
+    1
+    2
+    42
+    1
+    2
+    3
+
+
+  <========< samples/e.rb >========>
 
-  __________________________________________
   ~ > cat samples/e.rb
-  __________________________________________
-  require 'prototype'
-
-  proto = prototype{
-    @a = 40
-    @b = 2
-  }
 
-  p(proto.a + proto.b)
+    require 'prototype'
+    
+    proto = prototype{
+      @a = 40
+      @b = 2
+    }
+    
+    p(proto.a + proto.b)
 
+  ~ > ruby samples/e.rb
 
-  ~ > ruby -Ilib samples/e.rb
-  42
+    42
 
 
+  <========< samples/f.rb >========>
 
-  __________________________________________
   ~ > cat samples/f.rb
-  __________________________________________
-  require 'prototype'
-
-  a = prototype{ attributes 'a' => 4, 'b' => 10, 'c' => 2 }
-
-  b = prototype{ a 4; b 10; c 2 }
-
-  c = prototype{ @a, @b, @c = 4, 10, 2 }
 
-  [a, b, c].each{|obj| p(obj.a * obj.b + obj.c) }
+    require 'prototype'
+    
+    a = prototype{ attributes 'a' => 4, 'b' => 10, 'c' => 2}
+    
+    b = prototype{ a 4; b 10; c 2 } 
+    
+    c = prototype{ @a = 4; @b = 10; @c = 2 }
+    
+    [a, b, c].each{|obj| p(obj.a * obj.b + obj.c) }
 
+  ~ > ruby samples/f.rb
 
-  ~ > ruby -Ilib samples/f.rb
-  42
-  42
-  42
+    42
+    42
+    42
 
 
+  <========< samples/g.rb >========>
 
-  __________________________________________
   ~ > cat samples/g.rb
-  __________________________________________
-  require 'prototype'
 
-  a = prototype
+    
+    require 'prototype'
+    
+    a = prototype
+    
+    b = prototype(a){ @a, @b, @c = 4, 10, 2 } 
+    
+    a.extend{ def answer() a * b + c end }
+    
+    p b.answer
+    
 
-  b = prototype(a){ @a, @b, @c = 4, 10, 2 }
+  ~ > ruby samples/g.rb
 
-  a.extend{ def answer() a * b + c end }
+    42
 
-  p b.answer
 
+  <========< samples/h.rb >========>
 
-  ~ > ruby -Ilib samples/g.rb
-  42
+  ~ > cat samples/h.rb
 
-  
+    require 'prototype'
+    
+    proto = prototype{
+      a 1
+      b 1
+      c 40
+    
+      sum { a + b + c }
+    }
+    
+    p proto.sum
 
-DOCS
+  ~ > ruby samples/h.rb
 
-  see
+    42
 
-    lib/*rb
-    samples/*rb

data/README.tmpl

@@ -0,0 +1,24 @@
+NAME
+
+  prototype.rb
+
+URIS
+
+  http://codeforpeople.com/lib/ruby/
+  http://rubyforge.org/projects/codeforpeople/
+
+SYNOPSIS
+
+  prototype.rb facilitates a prototype based coding style 
+
+    http://en.wikipedia.org/wiki/Prototype-based_programming
+
+  for ruby
+
+WHY
+
+  prototype based programming can look very nice ;-)
+
+SAMPLES
+
+  @samples

data/gemspec.rb

@@ -16,6 +16,7 @@ Gem::Specification::new do |spec|
 
   spec.has_rdoc = File::exist? "doc" 
   spec.test_suite_file = "test/#{ lib }.rb" if File::directory? "test"
+  spec.add_dependency 'attributes', '~> 3.0'
 
   spec.author = "Ara T. Howard"
   spec.email = "ara.t.howard@noaa.gov"

data/gen_readme.rb

@@ -0,0 +1,32 @@
+require 'pathname'
+
+$VERBOSE=nil
+
+def indent s, n = 2
+  ws = ' ' * n
+  s.gsub %r/^/, ws 
+end
+
+template = IO::read 'README.tmpl'
+
+samples = ''
+prompt = '~ > '
+
+Dir['sample*/*'].sort.each do |sample|
+  samples << "\n" << "  <========< #{ sample } >========>" << "\n\n"
+
+  cmd = "cat #{ sample }" 
+  samples << indent(prompt + cmd, 2) << "\n\n" 
+  samples << indent(`#{ cmd }`, 4) << "\n" 
+
+  cmd = "ruby #{ sample }" 
+  samples << indent(prompt + cmd, 2) << "\n\n" 
+
+  cmd = "ruby -Ilib #{ sample }" 
+  samples << indent(`#{ cmd } 2>&1`, 4) << "\n" 
+end
+
+#samples.gsub! %r/^/, '  '
+
+readme  = template.gsub %r/^\s*@samples\s*$/, samples
+print readme 

data/lib/prototype-0.2.0.rb

@@ -0,0 +1,177 @@
+
+begin
+  require 'rubygems'
+rescue LoadError
+  nil
+end
+
+begin
+  require 'attributes'
+rescue LoadError
+  warn <<-msg
+  attributes.rb not found!
+  
+    download from
+      - http://rubyforge.org/projects/codeforpeople/
+
+    or
+
+      - http://codeforpeople.com/lib/ruby/
+  msg
+  raise
+end
+
+#
+# http://en.wikipedia.org/wiki/Prototype-based_programming
+#
+
+class Prototype
+  VERSION = '0.2.0'
+
+  module Prototypical
+    module ClassMethods
+      def __prototype_table__  # uses closure/init to avoid instance-var 
+        __prototype_singleton_class__{
+          table = {}
+          define_method('__prototype_table__'){ table }
+        }
+        __prototype_table__
+      end
+
+      def __prototype_eval__ &b
+        tid = Thread.current.object_id.abs
+        src, dst = "method_missing", "__method_missing_#{ tid }__"
+        aliased = false
+
+        __prototype_singleton_class__{
+          unless respond_to? dst 
+            alias_method dst, src
+            aliased = true 
+          end
+
+          def method_missing m, *a, &b
+            __prototype_barewords_can_set_and_get_ivars_and_define_methods__ m, *a, &b
+          end
+
+          def __prototype_barewords_can_set_and_get_ivars_and_define_methods__ m, *a, &b
+            if b
+              define_method m, *a, &b
+            else
+              ivar = "@#{ m }"
+              if a.size == 0
+                defined?(ivar) ? instance_variable_get(ivar) : super
+              elsif a.size == 1
+                instance_variable_set ivar, a.shift
+              else
+                __method_missing__(m, *a, &b) 
+              end
+            end
+          end
+        }
+
+        module_eval &b
+
+      ensure
+        __prototype_singleton_class__{ alias_method src, dst } if aliased
+      end
+
+      def __prototype_singleton_class__ &b
+        sc =
+          class << self
+            self
+          end
+        sc.module_eval &b if b
+        sc
+      end
+
+      def __prototype_prototype__ &b
+        return unless b
+
+        __prototype_eval__ &b
+
+        table =
+          instance_variables.inject({}) do |t,ivar|
+            value = 
+              instance_eval do
+                begin
+                  instance_variable_get ivar
+                ensure
+                  remove_instance_variable ivar
+                end
+              end
+            t.update ivar => value
+          end
+
+        __prototype_table__.update table
+      end
+    end
+
+    module InstanceMethods
+      def initialize *a, &b
+        __prototype_init__
+        super
+      end
+
+      def __prototype_init__
+        self.class.__prototype_table__.each do |ivar, value|
+          defined = instance_eval "defined? #{ ivar }"
+          unless defined
+            instance_variable_set ivar, value
+          end
+
+          a = ivar[%r/\w+/]
+          defined = respond_to? a 
+          unless defined
+            self.class.module_eval{ attribute a => value }
+          end
+        end
+      end
+
+      def extend *a, &b
+        unless a.empty?
+          super
+        else
+          self.class.__prototype_prototype__ &b
+          __prototype_init__
+          self
+        end
+      end
+
+      def clone *a, &b
+        obj = prototype(self.class, *a, &b)
+        instance_variables.each do |ivar|
+          value = instance_variable_get ivar
+          obj.instance_variable_set ivar, value
+        end
+        obj
+      end
+    end
+
+    def self.extend_object c
+      c.extend ClassMethods
+      c.module_eval{ include InstanceMethods }
+      super
+    end
+  end
+
+  class << self
+    def new parent = Object, *a, &b
+      parent = parent.class unless Class === parent
+      c = Class.new parent
+      c.extend Prototypical
+      c.__prototype_table__.update parent.__prototype_table__ if
+        parent.respond_to? '__prototype_table__'
+      c.__prototype_prototype__ &b
+      obj = c.new *a 
+      obj
+    end
+
+    alias_method "exnihilo", "new"
+    alias_method "ex_nihilo", "new"
+  end
+end
+
+class Object
+  def Prototype(*a, &b) Prototype.new *a, &b end
+  def prototype(*a, &b) Prototype.new *a, &b end
+end

data/lib/prototype.rb

@@ -1,155 +1,155 @@
 
+begin
+  require 'rubygems'
+rescue LoadError
+  nil
+end
+
+begin
+  require 'attributes'
+rescue LoadError
+  warn <<-msg
+  attributes.rb not found!
+  
+    download from
+      - http://rubyforge.org/projects/codeforpeople/
+
+    or
+
+      - http://codeforpeople.com/lib/ruby/
+  msg
+  raise
+end
+
 #
 # http://en.wikipedia.org/wiki/Prototype-based_programming
 #
 
 class Prototype
-  VERSION = '0.1.0'
-
-  #
-  # inline my attribute.rb file here
-  #
-  module Attrbiutes
-    def attributes *a, &b
-      unless a.empty?
-        hashes, names = a.partition{|x| Hash === x}
-
-        names_and_defaults = {}
-        hashes.each{|h| names_and_defaults.update h}
-        names.each{|name| names_and_defaults.update name => nil}
-
-        names_and_defaults.each do |name, default|
-          init = b || lambda { default }
-          ivar = "@#{ name }"
-          getter = "#{ name }"
-          setter = "#{ name }="
-          query = "#{ name }?"
-
-          define_method(setter) do |value|
-            instance_variable_set ivar, value
+  VERSION = '0.2.0'
+
+  module Prototypical
+    module ClassMethods
+      def __prototype_table__  # uses closure/init to avoid instance-var 
+        __prototype_singleton_class__{
+          table = {}
+          define_method('__prototype_table__'){ table }
+        }
+        __prototype_table__
+      end
+
+      def __prototype_eval__ &b
+        tid = Thread.current.object_id.abs
+        src, dst = "method_missing", "__method_missing_#{ tid }__"
+        aliased = false
+
+        __prototype_singleton_class__{
+          unless respond_to? dst 
+            alias_method dst, src
+            aliased = true 
           end
 
-          define_method(getter) do |*value|
-            unless value.empty?
-              send setter, value.shift
+          def method_missing m, *a, &b
+            __prototype_barewords_can_set_and_get_ivars_and_define_methods__ m, *a, &b
+          end
+
+          def __prototype_barewords_can_set_and_get_ivars_and_define_methods__ m, *a, &b
+            if b
+              define_method m, *a, &b
             else
-              defined = instance_eval "defined? #{ ivar }"
-              unless defined
-                send setter, instance_eval(&init) 
+              ivar = "@#{ m }"
+              if a.size == 0
+                defined?(ivar) ? instance_variable_get(ivar) : super
+              elsif a.size == 1
+                instance_variable_set ivar, a.shift
+              else
+                __method_missing__(m, *a, &b) 
               end
-              instance_variable_get ivar
             end
           end
+        }
 
-          alias_method query, getter
+        module_eval &b
 
-          (attributes << name).uniq!
-          attributes
-        end
-      else
-        @attributes ||= [] 
+      ensure
+        __prototype_singleton_class__{ alias_method src, dst } if aliased
       end
-    end
 
-    def attribute *a, &b
-      attributes *a, &b
-    end
-  end
-
-  module ClassMethods
-    include Attrbiutes
-
-    def method_missing m, *a, &b
-      ivar = "@#{ m }"
-      if a.size == 0
-        if defined? ivar
-          instance_variable_get ivar
-        else
-          super
-        end
-      elsif a.size == 1
-        instance_variable_set ivar, a.shift
-      else
-        super
+      def __prototype_singleton_class__ &b
+        sc =
+          class << self
+            self
+          end
+        sc.module_eval &b if b
+        sc
       end
-    end
-  end
 
-  module InstanceMethods
-    def initialize(*a, &b)
-      __protoinit__
-      super
-    end
+      def __prototype_prototype__ &b
+        return unless b
 
-    def __protoinit__
-      self.class.__prototable__.each do |ivar, value|
-        defined = instance_eval "defined? #{ ivar }"
-        unless defined
-          instance_variable_set ivar, value
-        end
+        __prototype_eval__ &b
 
-        a = ivar[%r/\w+/]
-        #defined = respond_to? a 
-        defined = self.class.module_eval{ attributes }.include? a
-        unless defined
-          self.class.module_eval{ attribute a }
-        end
+        table =
+          instance_variables.inject({}) do |t,ivar|
+            value = 
+              instance_eval do
+                begin
+                  instance_variable_get ivar
+                ensure
+                  remove_instance_variable ivar
+                end
+              end
+            t.update ivar => value
+          end
+
+        __prototype_table__.update table
       end
     end
 
-    def extend *a, &b
-      unless a.empty?
+    module InstanceMethods
+      def initialize *a, &b
+        __prototype_init__
         super
-      else
-        self.class.__prototype__ &b
-        __protoinit__
-        self
       end
-    end
 
-    def clone *a, &b
-      obj = prototype(self.class, *a, &b)
-      instance_variables.each do |ivar|
-        value = instance_variable_get ivar
-        obj.instance_variable_set ivar, value
-      end
-      obj
-    end
-  end
+      def __prototype_init__
+        self.class.__prototype_table__.each do |ivar, value|
+          defined = instance_eval "defined? #{ ivar }"
+          unless defined
+            instance_variable_set ivar, value
+          end
 
-  module Prototype
-    def __prototable__  # uses const to avoid copying instance var
-      if const_defined? 'PROTOTABLE'
-        const_get 'PROTOTABLE'
-      else
-        const_set 'PROTOTABLE', {}
+          a = ivar[%r/\w+/]
+          defined = respond_to? a 
+          unless defined
+            self.class.module_eval{ attribute a => value }
+          end
+        end
       end
-    end
-
-    def __prototype__ &b
-      return unless b
-
-      module_eval &b
 
-      table =
-        instance_variables.inject({}) do |t,ivar|
-          value = 
-            instance_eval do
-              begin
-                instance_variable_get ivar
-              ensure
-                remove_instance_variable ivar
-              end
-            end
-          t.update ivar => value
+      def extend *a, &b
+        unless a.empty?
+          super
+        else
+          self.class.__prototype_prototype__ &b
+          __prototype_init__
+          self
         end
+      end
 
-      __prototable__.update table
+      def clone *a, &b
+        obj = prototype(self.class, *a, &b)
+        instance_variables.each do |ivar|
+          value = instance_variable_get ivar
+          obj.instance_variable_set ivar, value
+        end
+        obj
+      end
     end
 
-    def self.extend_object other
-      other.extend ClassMethods
-      other.module_eval{ include InstanceMethods }
+    def self.extend_object c
+      c.extend ClassMethods
+      c.module_eval{ include InstanceMethods }
       super
     end
   end
@@ -158,10 +158,10 @@ class Prototype
     def new parent = Object, *a, &b
       parent = parent.class unless Class === parent
       c = Class.new parent
-      c.extend Prototype
-      prototable = parent.const_get 'PROTOTABLE' rescue nil
-      c.__prototable__.update prototable if prototable
-      c.__prototype__ &b
+      c.extend Prototypical
+      c.__prototype_table__.update parent.__prototype_table__ if
+        parent.respond_to? '__prototype_table__'
+      c.__prototype_prototype__ &b
       obj = c.new *a 
       obj
     end
@@ -172,10 +172,6 @@ class Prototype
 end
 
 class Object
-  def Prototype *a, &b
-    Prototype.new *a, &b
-  end
-  def prototype *a, &b
-    Prototype.new *a, &b
-  end
+  def Prototype(*a, &b) Prototype.new *a, &b end
+  def prototype(*a, &b) Prototype.new *a, &b end
 end

data/samples/h.rb

@@ -0,0 +1,11 @@
+require 'prototype'
+
+proto = prototype{
+  a 1
+  b 1
+  c 40
+
+  sum { a + b + c }
+}
+
+p proto.sum

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: prototype
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
-date: 2006-07-12 00:00:00.000000 -06:00
+  version: 0.2.0
+date: 2006-07-13 00:00:00.000000 -06:00
 summary: prototype
 require_paths: 
   - lib
@@ -34,8 +34,11 @@ files:
   - gemspec.rb
   - samples
   - README
-  - lib/prototype-0.0.0.rb
+  - README.tmpl
+  - gen_readme.rb
+  - prototype-0.2.0.gem
   - lib/prototype.rb
+  - lib/prototype-0.2.0.rb
   - samples/c.rb
   - samples/a.rb
   - samples/b.rb
@@ -43,10 +46,21 @@ files:
   - samples/e.rb
   - samples/f.rb
   - samples/g.rb
+  - samples/h.rb
 test_files: []
 rdoc_options: []
 extra_rdoc_files: []
 executables: []
 extensions: []
 requirements: []
-dependencies: []
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: attributes
+    version_requirement: 
+    version_requirements: !ruby/object:Gem::Version::Requirement 
+      requirements: 
+        - 
+          - "~>"
+          - !ruby/object:Gem::Version 
+            version: "3.0"
+      version: 

data/lib/prototype-0.0.0.rb

@@ -1,181 +0,0 @@
-
-#
-# http://en.wikipedia.org/wiki/Prototype-based_programming
-#
-
-class Prototype
-  VERSION = '0.1.0'
-
-  #
-  # inline my attribute.rb file here
-  #
-  module Attrbiutes
-    def attributes *a, &b
-      unless a.empty?
-        hashes, names = a.partition{|x| Hash === x}
-
-        names_and_defaults = {}
-        hashes.each{|h| names_and_defaults.update h}
-        names.each{|name| names_and_defaults.update name => nil}
-
-        names_and_defaults.each do |name, default|
-          init = b || lambda { default }
-          ivar = "@#{ name }"
-          getter = "#{ name }"
-          setter = "#{ name }="
-          query = "#{ name }?"
-
-          define_method(setter) do |value|
-            instance_variable_set ivar, value
-          end
-
-          define_method(getter) do |*value|
-            unless value.empty?
-              send setter, value.shift
-            else
-              defined = instance_eval "defined? #{ ivar }"
-              unless defined
-                send setter, instance_eval(&init) 
-              end
-              instance_variable_get ivar
-            end
-          end
-
-          alias_method query, getter
-
-          (attributes << name).uniq!
-          attributes
-        end
-      else
-        @attributes ||= [] 
-      end
-    end
-
-    def attribute *a, &b
-      attributes *a, &b
-    end
-  end
-
-  module ClassMethods
-    include Attrbiutes
-
-    def method_missing m, *a, &b
-      ivar = "@#{ m }"
-      if a.size == 0
-        if defined? ivar
-          instance_variable_get ivar
-        else
-          super
-        end
-      elsif a.size == 1
-        instance_variable_set ivar, a.shift
-      else
-        super
-      end
-    end
-  end
-
-  module InstanceMethods
-    def initialize(*a, &b)
-      __protoinit__
-      super
-    end
-
-    def __protoinit__
-      self.class.__prototable__.each do |ivar, value|
-        defined = instance_eval "defined? #{ ivar }"
-        unless defined
-          instance_variable_set ivar, value
-        end
-
-        a = ivar[%r/\w+/]
-        #defined = respond_to? a 
-        defined = self.class.module_eval{ attributes }.include? a
-        unless defined
-          self.class.module_eval{ attribute a }
-        end
-      end
-    end
-
-    def extend *a, &b
-      unless a.empty?
-        super
-      else
-        self.class.__prototype__ &b
-        __protoinit__
-        self
-      end
-    end
-
-    def clone *a, &b
-      obj = prototype(self.class, *a, &b)
-      instance_variables.each do |ivar|
-        value = instance_variable_get ivar
-        obj.instance_variable_set ivar, value
-      end
-      obj
-    end
-  end
-
-  module Prototype
-    def __prototable__  # uses const to avoid copying instance var
-      if const_defined? 'PROTOTABLE'
-        const_get 'PROTOTABLE'
-      else
-        const_set 'PROTOTABLE', {}
-      end
-    end
-
-    def __prototype__ &b
-      return unless b
-
-      module_eval &b
-
-      table =
-        instance_variables.inject({}) do |t,ivar|
-          value = 
-            instance_eval do
-              begin
-                instance_variable_get ivar
-              ensure
-                remove_instance_variable ivar
-              end
-            end
-          t.update ivar => value
-        end
-
-      __prototable__.update table
-    end
-
-    def self.extend_object other
-      other.extend ClassMethods
-      other.module_eval{ include InstanceMethods }
-      super
-    end
-  end
-
-  class << self
-    def new parent = Object, *a, &b
-      parent = parent.class unless Class === parent
-      c = Class.new parent
-      c.extend Prototype
-      prototable = parent.const_get 'PROTOTABLE' rescue nil
-      c.__prototable__.update prototable if prototable
-      c.__prototype__ &b
-      obj = c.new *a 
-      obj
-    end
-
-    alias_method "exnihilo", "new"
-    alias_method "ex_nihilo", "new"
-  end
-end
-
-class Object
-  def Prototype *a, &b
-    Prototype.new *a, &b
-  end
-  def prototype *a, &b
-    Prototype.new *a, &b
-  end
-end