alib 0.4.0 → 0.5.0

data/a.rb

@@ -1 +1,12 @@
-IO.popen('-'){|pipe| puts(pipe ? pipe.read : 42)}
+module M
+end
+class C
+end
+
+p(M === C)
+
+class C
+  include M
+end
+p(M === C)
+

data/lib/{alib-0.4.0.rb → alib-0.5.0.rb}

@@ -3,9 +3,7 @@
 #
 module ALib
 #--{{{
-  VERSION = '0.4.0'
-
-  def self.version() VERSION end
+  VERSION = '0.5.0'
 
   require 'pathname'
   require 'socket'
@@ -21,14 +19,19 @@ module ALib
   require 'fcntl'
   require 'uri'
   require 'net/http'
+  require 'thread'
 
-
-# TODO - bundle open4!!
+  class ::Object
+    Alib = ALib
+    def alib() ALib end
+  end
 
   LIBDIR = 'alib-%s/' % VERSION
 
-  AUTOLOAD = {
+  require LIBDIR + 'classmethods'
+  require LIBDIR + 'stdext'
 
+  AUTOLOAD = {
     'Util'             => 'util',
 
     'Logging'          => 'logging',
@@ -54,51 +57,25 @@ module ALib
     'AbstractMain'     => 'main',
     'SimpleMain'       => 'main',
     'ConfigurableMain' => 'main',
-
   }
 
   AUTOLOAD.each{|const, basename| autoload const.to_s, LIBDIR + basename.to_s}
 
-  METACLASS = 
+  SINGLETON_CLASS = 
     class << self
       self
     end
 
-  AUTOLOAD.each{ |const, m| METACLASS.module_eval{ define_method(m){ ALib.send 'const_get', const}}}
-
-  begin
-    require 'open4'
-  rescue LoadError
-    require LIBDIR + 'open4'
-  end
+  AUTOLOAD.each{ |const, m| SINGLETON_CLASS.module_eval{define_method(m){ALib.send 'const_get', const}} unless Alib.respond_to? m}
 
-  class << self
-#--{{{
-    def load basename 
-#--{{{
-      require LIBDIR + basename.to_s
-#--}}}
-    end
-    def simple_main &b
-#--{{{
-      b ? Class::new(ALib::SimpleMain, &b) : ALib::SimpleMain
-#--}}}
-    end
-    alias_method 'main', 'simple_main'
-    alias_method 'smain', 'simple_main'
-    def configurable_main &b
-#--{{{
-      b ? Class::new(ALib::ConfigurableMain, &b) : ALib::ConfigurableMain
-#--}}}
+  %w( open4 attributes prototype binding_of_caller ).each do |lib|
+    begin
+      require lib 
+    rescue LoadError
+      require LIBDIR + lib 
+      $LOADED_FEATURES << File.basename(lib)
     end
-    alias_method 'cmain', 'configurable_main'
-#--}}}
   end
 #--}}}
 end
 
-Alib = ALib
-
-class Object
-  def alib() Alib end
-end

data/lib/alib-0.5.0/attributes-3.2.0.rb

@@ -0,0 +1,54 @@
+module Attributes
+  VERSION = '3.2.0'
+
+  def version() VERSION end
+
+  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.flatten.compact.each{|name| names_and_defaults.update name => nil}
+
+      names_and_defaults.each do |name, default|
+        init = b || lambda { default }
+        ivar, getter, setter, query = "@#{ name }", "#{ name }", "#{ name }=", "#{ 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 }"
+            send setter, instance_eval(&init) unless defined
+            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
+
+class Object
+  def attributes *a, &b
+    sc = class << self; self; end
+    sc.attributes *a, &b
+  end
+
+  def attribute(*a, &b) attributes *a, &b end
+end
+
+class Module; include Attributes; end

data/lib/alib-0.5.0/attributes.rb

@@ -0,0 +1,54 @@
+module Attributes
+  VERSION = '3.2.0'
+
+  def version() VERSION end
+
+  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.flatten.compact.each{|name| names_and_defaults.update name => nil}
+
+      names_and_defaults.each do |name, default|
+        init = b || lambda { default }
+        ivar, getter, setter, query = "@#{ name }", "#{ name }", "#{ name }=", "#{ 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 }"
+            send setter, instance_eval(&init) unless defined
+            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
+
+class Object
+  def attributes *a, &b
+    sc = class << self; self; end
+    sc.attributes *a, &b
+  end
+
+  def attribute(*a, &b) attributes *a, &b end
+end
+
+class Module; include Attributes; end

data/lib/alib-0.5.0/binding_of_caller.rb

@@ -0,0 +1,70 @@
+begin
+  require 'simplecc'
+rescue LoadError
+  def Continuation.create(*args, &block)
+    cc = nil; result = callcc {|c| cc = c; block.call(cc) if block and args.empty?}
+    result ||= args
+    return *[cc, *result]
+  end
+end
+
+# This method returns the binding of the method that called your
+# method. It will raise an Exception when you're not inside a method.
+#
+# It's used like this:
+#   def inc_counter
+#     Binding.of_caller do |binding|
+#       eval("counter += 1", binding)
+#     end
+#   end
+#   counter = 0
+#   2.times { inc_counter }
+#   counter # => 2
+#
+# You will have to put the whole rest of your method into the
+# block that you pass into this method. If you don't do this
+# an Exception will be raised. Because of the way that this is
+# implemented it has to be done this way. If you don't do it
+# like this it will raise an Exception.
+def Binding.of_caller(&block)
+  old_critical = Thread.critical
+  Thread.critical = true
+  count = 0
+  cc, result, error, extra_data = Continuation.create(nil, nil)
+  error.call if error
+
+  tracer = lambda do |*args|
+    type, context, extra_data = args[0], args[4], args
+    if type == "return"
+      count += 1
+      # First this method and then calling one will return --
+      # the trace event of the second event gets the context
+      # of the method which called the method that called this
+      # method.
+      if count == 2
+        # It would be nice if we could restore the trace_func
+        # that was set before we swapped in our own one, but
+        # this is impossible without overloading set_trace_func
+        # in current Ruby.
+        set_trace_func(nil)
+        cc.call(eval("binding", context), nil, extra_data)
+      end
+    elsif type != "line"
+      set_trace_func(nil)
+      error_msg = "Binding.of_caller used in non-method context or " +
+        "trailing statements of method using it aren't in the block."
+      cc.call(nil, lambda { raise(ArgumentError, error_msg) }, nil)
+    end
+  end
+
+  unless result
+    set_trace_func(tracer)
+    return nil
+  else
+    Thread.critical = old_critical
+    case block.arity
+      when 1 then yield(result)
+      else yield(result, extra_data)        
+    end
+  end
+end

data/lib/alib-0.5.0/classmethods.rb

@@ -0,0 +1,39 @@
+module Alib
+  class << self
+#--{{{
+    def version() VERSION end
+    def load basename 
+#--{{{
+      require LIBDIR + basename.to_s
+#--}}}
+    end
+    def simple_main &b
+#--{{{
+      #c = b ? (Class::new(ALib::SimpleMain, &b); : ALib::SimpleMain
+      c = Class::new ALib::SimpleMain
+      c.module_eval &b if b
+      c
+#--}}}
+    end
+    alias_method 'smain', 'simple_main'
+    def configurable_main &b
+#--{{{
+      c = Class::new ALib::ConfigurableMain
+      c.module_eval &b if b
+      c
+#--}}}
+    end
+    alias_method 'cmain', 'configurable_main'
+    def script c = ALib::SimpleMain, &b
+#--{{{
+      c = Class::new c
+      c.class_eval{ include ALib::Util }
+      c.class_eval &b if b
+      c.run
+#--}}}
+    end
+    alias_method 'program', 'script'
+    alias_method 'cli', 'script'
+#--}}}
+  end
+end

data/lib/{alib-0.4.0 → alib-0.5.0}/logging.rb

@@ -9,12 +9,62 @@ module ALib::Logging
 # not all logging devices are put into sync mode, resulting in improper log
 # rolling.  this is a hack.
 #
+
   module LoggerExt
 #--{{{
     attr :logdev
     def << *args
-      args.flatten.each{|a| super a}
+#--{{{
+      m, c = Thread.main, Thread.current
+      args.flatten.each do |msg|
+        if m == c
+          super msg 
+        else
+          eol = msg[%r/\s*$/o]
+          msg[%r/\s*$/o] = ''
+          super "#{ msg }  (t:#{ c.object_id })#{ eol }"
+        end
+      end
       self
+#--}}}
+    end
+    def ___mutex
+#--{{{
+      unless defined?(@___mutex) and @___mutex
+        begin
+          Thread.critical = true
+          @___mutex = Sync::new unless defined?(@___mutex) and @___mutex
+        ensure
+          Thread.critical = false 
+        end
+      end
+      @___mutex
+#--}}}
+    end
+    def ___sync which = :EX
+#--{{{
+      ___mutex.synchronize(which){ yield }
+#--}}}
+    end
+
+    %w[ debug info warn error fatal ].each do |meth|
+      module_eval <<-code
+        def #{ meth }(*a, &b)
+          m, c = Thread.main, Thread.current
+          ___sync{ 
+            if m == c
+              super *a, &b
+            else
+                super{ 
+                  msg = (a.empty? ? b.call : a.join).to_s
+                  eol = msg[%r/\s*$/o]
+                  msg[%r/\s*$/o] = ''
+                  "\#{ msg }  (t:\#{ c.object_id })\#{ eol }"
+                }
+            end
+          }
+        end
+      code
     end
 #--}}}
   end # module LoggerExt
@@ -54,6 +104,7 @@ module ALib::Logging
       @logger
 #--}}}
     end
+    alias_method 'logger!', 'logger'
     def logger= log
 #--{{{
       __logger_sync do          
@@ -64,13 +115,15 @@ module ALib::Logging
       end
 #--}}}
     end
-    %w( debug info warn error fatal ).each do |meth|
+
+    %w[ debug info warn error fatal ].each do |meth|
       module_eval <<-code
         def #{ meth }(*a, &b)
-          __logger_sync{ logger.#{ meth }(*a, &b) }
+          logger.#{ meth } *a, &b
         end
       code
     end
+
     def log_err e
 #--{{{
       if logger.debug?
@@ -139,14 +192,25 @@ module ALib::Logging
 #--{{{
     def append_features c
 #--{{{
-      ret = super
-      c.extend LogMethods
-      c.extend LogClassMethods
+      return self if((LogMethods === c) or (LogClassMethods === c)) 
+      ret = super rescue(return(self))
+      c.module_eval{
+        extend LogClassMethods
+        include LogMethods
+        extend LogMethods
+      }
+      #c.extend LogMethods
+      #c.extend LogClassMethods
       ret
 #--}}}
     end
 #--}}}
   end
-  include LogMethods
+
+  append_features self
+
+  # include LogMethods
+  # extend LogMethods
+  # extend LogClassMethods
 #--}}}
 end # module Logging