alib 0.4.0 → 0.5.0

data/lib/alib-0.5.0/prototype-0.3.0.rb

@@ -0,0 +1,200 @@
+
+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.3.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__    # does not recurse!
+      end
+
+      def __prototype_table_inject__ other
+        __prototype_table__.each do |ivar, value|
+          other.instance_variable_set ivar, value
+        end
+        __prototype_table__.clear
+      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__ c = self.class
+        c.__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 }
+          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"
+
+    def prototyping obj, *a, &b
+      c =
+        class << obj 
+          self
+        end
+      parent = c.class
+      c.extend Prototypical unless Prototypical === c
+      c.__prototype_table__.update parent.__prototype_table__ if
+        parent.respond_to? '__prototype_table__'
+      c.__prototype_prototype__ &b
+      obj.__prototype_init__ c
+      obj
+    end
+  end
+end
+
+class Object
+  def Prototype(*a, &b) Prototype.new *a, &b end
+  def prototype(*a, &b) Prototype.new *a, &b end
+  def Prototyping(*a, &b) Prototype.prototyping self, *a, &b end
+  def prototyping(*a, &b) Prototype.prototyping self, *a, &b end
+end

data/lib/alib-0.5.0/prototype.rb

@@ -0,0 +1,200 @@
+
+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.3.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__    # does not recurse!
+      end
+
+      def __prototype_table_inject__ other
+        __prototype_table__.each do |ivar, value|
+          other.instance_variable_set ivar, value
+        end
+        __prototype_table__.clear
+      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__ c = self.class
+        c.__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 }
+          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"
+
+    def prototyping obj, *a, &b
+      c =
+        class << obj 
+          self
+        end
+      parent = c.class
+      c.extend Prototypical unless Prototypical === c
+      c.__prototype_table__.update parent.__prototype_table__ if
+        parent.respond_to? '__prototype_table__'
+      c.__prototype_prototype__ &b
+      obj.__prototype_init__ c
+      obj
+    end
+  end
+end
+
+class Object
+  def Prototype(*a, &b) Prototype.new *a, &b end
+  def prototype(*a, &b) Prototype.new *a, &b end
+  def Prototyping(*a, &b) Prototype.prototyping self, *a, &b end
+  def prototyping(*a, &b) Prototype.prototyping self, *a, &b end
+end

data/lib/alib-0.5.0/stdext.rb

@@ -0,0 +1,174 @@
+class Object
+  def singleton_class obj = self, &b
+#--{{{
+    sc =
+      class << obj
+        self
+      end
+    sc.module_eval &b
+    sc
+#--}}}
+  end
+  def tap &b
+#--{{{
+    b.arity == 1 ? yield(self) : instance_eval(&b)
+    return self
+#--}}}
+  end
+end
+
+class Numeric 
+  def of head = nil, *tail, &b
+#--{{{
+    if head
+      a = tail.empty? ? head : [head]+tail
+      b = lambda{ a }
+    end
+    Array.new(self).map &b
+#--}}}
+  end
+
+  def microseconds() Float(self  * (10 ** -6)) end
+  def milliseconds() Float(self  * (10 ** -3)) end
+  def seconds() self end
+  def minutes() 60 * seconds end
+  def hours() 60 * minutes end
+  def days() 24 * hours end
+  def weeks() 7 * days end
+  def months() 30 * days end
+  def years() 365 * days end
+  def decades() 10 * years end
+
+  %w[
+    microseconds
+    milliseconds
+    seconds
+    minutes
+    hours
+    days
+    weeks
+    months
+    years
+    decades
+  ].each{|m| alias_method m.chop, m}
+end
+
+class Hash
+  def getopt opt, default = nil
+#--{{{
+    hash = self
+    keys = opt.respond_to?('each') ? opt : [opt]
+    keys.each do |key|
+      return hash[key] if hash.has_key? key
+      key = "#{ key }"
+      return hash[key] if hash.has_key? key
+      key = key.intern
+      return hash[key] if hash.has_key? key
+    end
+    return default
+#--}}}
+  end
+  def hasopt? opt, default = nil
+#--{{{
+    hash = self
+    keys = opt.respond_to?('each') ? opt : [opt]
+    keys.each do |key|
+      return key if hash.has_key? key
+      key = "#{ key }"
+      return key if hash.has_key? key
+      key = key.intern
+      return key if hash.has_key? key
+    end
+    return default
+#--}}}
+  end
+  alias_method "hasopt", "hasopt?"
+end
+
+class Array
+  def self.step i, *a, &b
+#--{{{
+    j, s, ignored = *a
+    i, j = 0, i if j.nil?
+    s ||= (j < i ? -1 : 1)
+    list = new
+    i.step(j,s){|k| list << k}
+    list.map! &b if b
+    list
+#--}}}
+  end
+end
+
+module Enumerable
+  def sum n = 0
+    inject(n){|n,i| n += i}
+  end
+  def product n = 1
+    return 0 if empty?
+    inject(n){|n,i| n *= i}
+  end
+end
+
+class Module
+  def tattrs *list 
+#--{{{
+    list.flatten.compact.map do |t|
+      module_eval <<-code
+        def #{ t } *a
+          return(send('#{ t }', a.shift)) unless a.empty?
+          Thread.current['#{ t }']
+        end
+        def #{ t }= val 
+          Thread.current['#{ t }?'] = true 
+          Thread.current['#{ t }'] = val
+        end
+        def #{ t }?
+          Thread.current['#{ t }?']
+        end
+      code
+      t.to_s
+    end
+#--}}}
+  end
+  alias_method "tattr", "tattrs"
+end
+
+=begin
+
+class Thread
+  class << self
+    alias_method "__new__", "new"
+    def new *a, &b
+      child '__new__', *a, &b
+    end
+    alias_method "__start__", "start"
+    def start *a, &b
+      child '__start__', *a, &b
+    end
+  private
+    def child as, *a, &b
+      parent = Thread.current
+      send(as, *a) do |*a|
+        Thread.current.parent = parent
+        b.call *a
+      end
+    end
+  end
+  def parent
+    self['parent']
+  end
+  def parent= parent
+    self['parent'] = parent
+  end
+  def ancestors
+    return self['ancestors'] if self['ancestors']
+    list = [t = self]
+    while((t = t.parent))
+      list << t
+    end
+    self['ancestors'] = list
+  end
+end
+
+=end
+