main 0.0.1 → 0.0.2

data/lib/main.rb

@@ -1,24 +1,31 @@
 module Main
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
+  def version() VERSION end
 
   LIBDIR = File.join(File.dirname(File.expand_path(__FILE__)), self.name.downcase, '')
 
+  EXIT_SUCCESS = 0
+  EXIT_FAILURE = 1
+  EXIT_WARN = 42
+#
+# built-in
+#
   require 'logger'
   require 'enumerator'
-
-  begin
-    require 'rubygems'
-  rescue LoadError
-  end
-# TODO - inline these
-  require 'attributes'
-  require 'arrayfields'
-
+#
+# inlcuded from other codeforpeople.com projects
+#
+  require LIBDIR + 'attributes'
+  require LIBDIR + 'arrayfields'
+#
+# main libs
+#
   require LIBDIR + 'util'
   require LIBDIR + 'usage'
   require LIBDIR + 'cast'
   require LIBDIR + 'parameter'
   require LIBDIR + 'getoptlong'
+  require LIBDIR + 'proxy'
   require LIBDIR + 'base'
   require LIBDIR + 'factories'
 end

data/lib/main/arrayfields.rb

@@ -0,0 +1,347 @@
+#
+# The ArrayFields module implements methods which allow an Array to be indexed
+# by String or Symbol. It is not required to manually use this module to extend
+# Array's - they are auto-extended when Array#fields= is called
+#
+  module ArrayFields 
+#{{{
+    VERSION = '3.6.0'
+  #
+  # multiton cache of fields - wraps fields and fieldpos map to save memory
+  #
+    class FieldSet
+#{{{
+      class << self
+#{{{
+        def new fields
+#{{{
+          @sets ||= {}
+          obj = @sets[fields]
+          unless obj
+            obj = super  
+            @sets[fields] = obj
+          end
+          obj
+#}}}
+        end
+#}}}
+      end
+      attr :fields
+      attr :fieldpos
+      def initialize fields
+#{{{
+        raise ArgumentError, "<#{ fields.inspect }> not inject-able" unless
+          fields.respond_to? :inject
+
+        @fieldpos =
+          fields.inject({}) do |h, f|
+            unless String === f or Symbol === f
+              raise ArgumentError, "<#{ f.inspect }> neither String nor Symbol"
+            end
+            h[f] = h.size
+            h
+          end
+
+        @fields = fields
+#}}}
+      end
+      def pos f
+#{{{
+        return @fieldpos[f] if @fieldpos.has_key? f 
+        f = f.to_s
+        return @fieldpos[f] if @fieldpos.has_key? f 
+        f = f.intern
+        return @fieldpos[f] if @fieldpos.has_key? f 
+        nil
+#}}}
+      end
+#}}}
+    end
+  #
+  # methods redefined to work with fields as well as numeric indexes
+  #
+    def [](idx, *args) 
+#{{{
+      if @fieldset and (String === idx or Symbol === idx)
+        pos = @fieldset.pos idx
+        return nil unless pos
+        super(pos, *args)
+      else
+        super
+      end
+#}}}
+    end
+    alias slice []
+    def []=(idx, *args) 
+#{{{
+      if @fieldset and (String === idx or Symbol === idx) 
+        pos = @fieldset.pos idx
+        unless pos
+          @fieldset.fields << idx
+          @fieldset.fieldpos[idx] = pos = size
+        end
+        super(pos, *args)
+      else
+        super
+      end
+#}}}
+    end
+    def at idx
+#{{{
+      if @fieldset and (String === idx or Symbol === idx)
+        pos = @fieldset.pos idx
+        return nil unless pos
+        super pos
+      else
+        super
+      end
+#}}}
+    end
+    def delete_at idx
+#{{{
+      if @fieldset and (String === idx or Symbol === idx)
+        pos = @fieldset.pos idx
+        return nil unless pos
+        super pos
+      else
+        super
+      end
+#}}}
+    end
+    def fill(obj, *args)
+#{{{
+      idx = args.first
+      if idx and @fieldset and (String === idx or Symbol === idx)
+        idx = args.shift
+        pos = @fieldset.pos idx
+        super(obj, pos, *args)
+      else
+        super
+      end
+#}}}
+    end
+    def values_at(*idxs)
+#{{{
+      idxs.flatten!
+      if @fieldset
+        idxs.map!{|i| (String === i or Symbol === i) ? @fieldset.pos(i) : i}
+      end
+      super(*idxs)
+#}}}
+    end
+    alias indices values_at
+    alias indexes values_at 
+    def slice!(*args)
+#{{{
+      ret = self[*args]
+      self[*args] = nil
+      ret
+#}}}
+    end
+    def each_with_field
+#{{{
+      each_with_index do |elem, i|
+        yield elem, @fieldset.fields[i]
+      end
+#}}}
+    end
+  #
+  # methods which give a hash-like interface 
+  #
+    def each_pair
+#{{{
+      each_with_index do |elem, i|
+        yield @fieldset.fields[i], elem
+      end
+#}}}
+    end
+    def each_key
+#{{{
+      @fieldset.each{|field| yield field}
+#}}}
+    end
+    def each_value(*args, &block)
+#{{{
+      each(*args, &block)
+#}}}
+    end
+    def fetch key
+#{{{
+      self[key] or raise IndexError, 'key not found'
+#}}}
+    end
+    def has_key? key
+#{{{
+      @fieldset.fields.include? key
+#}}}
+    end
+    alias member? has_key?
+    alias key? has_key?
+    def has_value? value
+#{{{
+      if respond_to? 'include?'
+        self.include? value
+      else
+        a = []
+        each{|val| a << val}
+        a.include? value
+      end
+#}}}
+    end
+    alias value? has_value?
+    def keys
+#{{{
+      fields
+#}}}
+    end
+    def store key, value
+#{{{
+      self[key] = value
+#}}}
+    end
+    def values
+#{{{
+      if respond_to? 'to_ary'
+        self.to_ary
+      else
+        a = []
+        each{|val| a << val}
+        a
+      end
+#}}}
+    end
+    def to_hash
+#{{{
+      if respond_to? 'to_ary'
+        h = {}
+        @fieldset.fields.zip(to_ary){|f,e| h[f] = e}
+        h
+      else
+        a = []
+        each{|val| a << val}
+        h = {}
+        @fieldset.fields.zip(a){|f,e| h[f] = e}
+        h
+      end
+#}}}
+    end
+    alias to_h to_hash
+    def update other
+#--{{{
+      other.each{|k,v| self[k] = v}
+      to_hash
+#--}}}
+    end
+    def replace other
+#--{{{
+      Hash === other ? update(other) : super
+#--}}}
+    end
+    def invert
+#--{{{
+      to_hash.invert
+#--}}}
+    end
+#}}}
+  end
+#
+# Fieldable encapsulates methods in common for classes which may have their
+# fields set
+#
+  module Fieldable
+#{{{
+  #
+  # sets fields an dynamically extends this Array instance with methods for
+  # keyword access
+  #
+    def fields= fields
+#{{{
+      extend ArrayFields unless defined? @fieldset 
+
+      @fieldset = 
+        if ArrayFields::FieldSet === fields
+          fields
+        else
+          ArrayFields::FieldSet.new fields
+        end
+#}}}
+    end
+  #
+  # access to fieldset
+  #
+    attr_reader :fieldset
+  #
+  # access to field list
+  #
+    def fields
+#{{{
+      @fieldset and @fieldset.fields
+#}}}
+    end
+#}}}
+  end
+#
+# The Array class is extened with a methods to allow keyword access 
+#
+  class Array
+#{{{
+    include Fieldable
+#}}}
+  end
+#
+# proxy class that allows an array to be wrapped in a way that still allows #
+# keyword access.  also facilitate usage of ArrayFields with arraylike objects.
+# thnx to Sean O'Dell for the suggestion.
+#
+# sample usage
+#
+# fa = FieldedArray.new %w(zero one two), [0,1,2]
+# p fa['zero']   #=> 0
+#
+#
+  class FieldedArray
+#{{{
+    include Fieldable
+    class << self
+
+      def [](*pairs)
+#{{{
+        pairs.flatten!
+        raise ArgumentError, "argument must be key/val paris" unless 
+          (pairs.size % 2 == 0 and pairs.size >= 2)
+        fields, elements = [], []
+        #pairs.each do |f,e| 
+        while((f = pairs.shift) and (e = pairs.shift)) 
+          raise ArgumentError, "field must be String or Symbol" unless
+            (String === f or Symbol === f)
+          fields << f and elements << e
+        end
+        new fields, elements
+#}}}
+      end
+
+    end
+    def initialize fields, array
+#{{{
+      @a = array
+      self.fields = fields
+#}}}
+    end
+    def method_missing(meth, *args, &block)
+#{{{
+      @a.send(meth, *args, &block)
+#}}}
+    end
+    delegates =
+#{{{
+      %w(
+        to_s
+        to_str
+        inspect
+      )
+#}}}
+    delegates.each do |meth| 
+      class_eval "def #{ meth }(*a,&b); @a.#{ meth }(*a,&b);end"
+    end
+#}}}
+  end

data/lib/main/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/main/base.rb

@@ -1,9 +1,5 @@
 module Main
   class Base
-    EXIT_SUCCESS = 0
-    EXIT_FAILURE = 1
-    EXIT_OK = 42
-
     class << self
       attribute( 'program' ){ File.basename $0 } 
       attribute( 'name' ){ File.basename $0 } 
@@ -11,20 +7,17 @@ module Main
       attribute( 'description' )
       attribute( 'author' )
       attribute( 'version' )
-      attribute( 'logger' ){ STDERR } 
+      attribute( 'stdin' ){ $stdin } 
+      attribute( 'stdout' ){ $stdout } 
+      attribute( 'stderr' ){ $stderr } 
+      attribute( 'logger' ){ stderr } 
+      attribute( 'logger_level' ){ Logger::INFO } 
       attribute( 'exit_status' ){ EXIT_SUCCESS } 
       attribute( 'exit_success' ){ EXIT_SUCCESS } 
       attribute( 'exit_failure' ){ EXIT_FAILURE } 
-      attribute( 'exit_ok' ){ EXIT_OK } 
+      attribute( 'exit_warn' ){ EXIT_WARN } 
       attribute( 'usage' ){ Usage.default_usage self } 
 
-      def new *a, &b
-        obj = allocate
-        obj.__initialize__
-        obj.instance_eval{ initialize *a, &b }
-        obj
-      end
-
       def parameters
         @parameters ||= Parameter::List[]
       end
@@ -67,10 +60,14 @@ module Main
     attribute 'env'
     attribute 'params'
     attribute 'logger'
+    attribute 'stdin'
+    attribute 'stdout'
+    attribute 'stderr'
 
     %w( 
       program name synopsis description author version
-      exit_status exit_success exit_failure exit_ok
+      exit_status exit_success exit_failure exit_warn
+      logger_level
       usage
     ).each{|a| attribute(a){ self.class.send a}}
 
@@ -80,7 +77,7 @@ module Main
       alias_method "#{ dst }?", "params?"
     end
 
-    %w( exit_success! exit_failure! exit_ok! ).each do |code|
+    %w( exit_success! exit_failure! exit_warn! ).each do |code|
       module_eval <<-code
         def #{ code } *a, &b
           exit #{ code.chop }
@@ -96,55 +93,126 @@ module Main
       code
     end
 
-    def __initialize__ argv = ARGV, env = ENV
-      @argv, @env = argv, env
+    def pre_initialize() :hook end
+    def initialize argv = ARGV, env = ENV, opts = {}
+      @argv, @env, @opts = argv, env, opts
+      setup_finalizers
+      setup_io_restoration
+      setup_io_redirection
+      setup_logging
+    end
+    def post_initialize() :hook end
+
+    def setup_finalizers
+      @finalizers = finalizers = []
+      ObjectSpace.define_finalizer(self) do
+        while((f = finalizers.pop)); f.call; end
+      end
+    end
+
+    def finalize
+      while((f = @finalizers.pop)); f.call; end
+    end
 
-      log = self.class.logger
+    def setup_io_redirection
+      self.stdin = @opts['stdin'] || @opts[:stdin] || self.class.stdin
+      self.stdout = @opts['stdout'] || @opts[:stdout] || self.class.stdout
+      self.stderr = @opts['stderr'] || @opts[:stderr] || self.class.stderr
+    end
 
-      @logger =
+    def setup_logging
+      log = self.class.logger || stderr
+      self.logger = log
+    end
+    def logger= log
+      unless(defined?(@logger) and @logger == log)
         case log 
           when Logger
-            log
+            @logger = log
           when IO, StringIO
-            Logger.new log 
+            @logger = Logger.new log 
+            @logger.level = logger_level 
           else
-            Logger.new *log
+            @logger = Logger.new *log
+            @logger.level = logger_level 
         end
+      end
+    end
 
-      __parse_parameters__
+    def setup_io_restoration
+      [STDIN, STDOUT, STDERR].each do |io|
+        dup = io.dup and @finalizers.push lambda{ io.reopen dup }
+      end
     end
 
-    def __parse_parameters__
-      self.class.parameters.parse @argv, @env
-      #(@params = []).fields = []
-      @params = Parameter::Table.new
-      self.class.parameters.each do |p|
-        @params[p.name.to_s] = p
+    def stdin= io
+      unless(defined?(@stdin) and (@stdin == io))
+        @stdin =
+          if io.respond_to? 'read'
+            io
+          else
+            fd = open io.to_s, 'r+'
+            @finalizers.push lambda{ fd.close }
+            fd
+          end
+        begin
+          STDIN.reopen @stdin
+        rescue
+          $stdin = @stdin
+          ::Object.const_set 'STDIN', @stdin
+#p STDIN
+#p STDIN.read
+        end
+#p 'STDIN' => STDIN
+#p '@stdin' => @stdin
+#p '$stdin' => $stdin
       end
     end
 
-    def __run__
-      if @params['help'] and @params['help'].given?
-        print usage.to_s
-        exit
+    def stdout= io
+      unless(defined?(@stdout) and (@stdout == io))
+        @stdout =
+          if io.respond_to? 'write'
+            io
+          else
+            fd = open io.to_s, 'w+'
+            @finalizers.push lambda{ fd.close }
+            fd
+          end
+        STDOUT.reopen @stdout rescue($stdout = @stdout)
       end
+    end
 
-      begin
-        run
-      rescue Exception => e
-        if SystemExit === e
-          exit_status e.status 
-        else
-          fatal{ e }
-          exit_status EXIT_FAILURE if exit_status == EXIT_SUCCESS
-        end
+    def stderr= io
+      unless(defined?(@stderr) and (@stderr == io))
+        @stderr =
+          if io.respond_to? 'write'
+            io
+          else
+            fd = open io.to_s, 'w+'
+            @finalizers.push lambda{ fd.close }
+            fd
+          end
+        STDERR.reopen @stderr rescue($stderr = @stderr)
       end
-      status = Integer(exit_status) rescue(exit_status ? 0 : 1)
-      exit status
     end
+    
+    def pre_parse_parameters() :hook end
+    def parse_parameters
+      pre_parse_parameters
+
+      self.class.parameters.parse @argv, @env
+      @params = Parameter::Table.new
+      self.class.parameters.each{|p| @params[p.name.to_s] = p}
+
+      post_parse_parameters
+    end
+    def post_parse_parameters() :hook end
 
+    def pre_run() end
     def run
       raise NotImplementedError, 'run not defined'
     end
+    def post_run() end
   end
 end