alib 0.4.0 → 0.5.0

data/lib/alib-0.5.0/main.rb.bak

@@ -0,0 +1,1029 @@
+#
+# template main building block classes
+#
+
+
+module ALib
+
+  class AbstractMain
+#--{{{
+    include ALib
+    include ALib::Logging
+
+    module Constants
+      EXIT_SUCCESS = 0
+      EXIT_PSEUDO_SUCCESS = 42 
+      EXIT_OK = 42 
+      EXIT_FAILURE = 1
+    end
+    include Constants
+
+    def self.exit_success() EXIT_SUCCESS end
+    def exit_success() EXIT_SUCCESS end
+    def self.status_success() EXIT_SUCCESS end
+    def status_success() EXIT_SUCCESS end
+
+    def self.exit_pseudo_success() EXIT_PSEUDO_SUCCESS end
+    def exit_pseudo_success() EXIT_PSEUDO_SUCCESS end
+    def self.status_pseudo_success() EXIT_PSEUDO_SUCCESS end
+    def status_pseudo_success() EXIT_PSEUDO_SUCCESS end
+
+    def self.exit_ok() EXIT_OK end
+    def exit_ok() EXIT_OK end
+    def self.status_ok() EXIT_OK end
+    def status_ok() EXIT_OK end
+
+    def self.exit_failure() EXIT_FAILURE end
+    def exit_failure() EXIT_FAILURE end
+    def self.status_failure() EXIT_FAILURE end
+    def status_failure() EXIT_FAILURE end
+
+    class << self
+#--{{{
+      def stringlist(*list)
+#--{{{
+        list.flatten.compact.map{|item| "#{ item }".strip}
+#--}}}
+      end
+      def instance_attributes(*names)
+#--{{{
+        names = stringlist names
+        names.each do |name|
+          getter = "#{ name }"
+          setter = "#{ name }="
+          code = <<-code
+            def #{ name }(*a)
+              unless a.empty?
+                self.#{ name }= a.shift
+              else
+                @#{ name }
+              end
+            end
+            def #{ name }= value
+              @#{ name } = value
+            end
+            alias #{ name }? #{ name }
+          code
+          module_eval code
+        end
+#--}}}
+      end
+      alias instance_attribute instance_attributes
+      alias i_attrs instance_attributes
+      alias i_attr instance_attributes
+      alias attribute instance_attributes
+      alias attributes instance_attributes
+      
+      def class_attributes(*names)
+#--{{{
+        names = stringlist names
+        names.each do |name|
+          getter = "#{ name }"
+          setter = "#{ name }="
+          code = <<-code
+            class << self
+              def #{ name }(*a)
+                unless a.empty?
+                  self.#{ name }= a.shift
+                else
+                  @#{ name }
+                end
+              end
+              def #{ name }= value
+                @#{ name } = value
+              end
+              alias #{ name }? #{ name }
+            end
+          code
+          module_eval code
+        end
+#--}}}
+      end
+      alias class_attribute class_attributes
+      alias c_attrs class_attributes
+      alias c_attr class_attributes
+
+      %w( version author program optspec name examples synopsis ).each do |meth|
+#--{{{
+        module_eval <<-code
+          def #{ meth }(*a)
+            unless a.empty?
+              self.#{ meth }= a.shift
+            else
+              @#{ meth }
+            end
+          end
+          def #{ meth }= value
+            @#{ meth } = value
+          end
+          def #{ meth }?
+            defined? @#{ meth } and @#{ meth }
+          end
+        code
+#--}}}
+      end
+      alias prognam program
+      alias progname program
+      alias prognam= program=
+      alias prognam? program?
+
+=begin
+      %w( usage examples ).each do |meth|
+#--{{{
+        module_eval <<-code
+          def #{ meth }(*a)
+            unless a.empty?
+              self.#{ meth }= a.shift
+            else
+              @#{ meth }
+            end
+          end
+          def #{ meth }= msg 
+            @#{ meth } = unindent_block msg.to_s
+          end
+          def #{ meth }?
+            defined? @#{ meth } and @#{ meth }
+          end
+        code
+#--}}}
+      end
+=end
+
+      def usage arg = nil
+#--{{{
+        if arg
+          @usage = arg.to_s
+        else
+          if defined? @usage
+            @usage
+          else
+            s = ""
+
+            unless name.to_s.empty?
+            #s << "\n"
+            s << "NAME\n"
+            s << indent_block("#{ name }\n", 2)
+            end
+
+            unless synopsis.to_s.empty?
+            s << "\n"
+            s << "SYNOPSIS\n"
+            s << indent_block("#{ synopsis }\n", 2)
+            end
+
+            unless examples.to_s.empty?
+            s << "\n"
+            s << "EXAMPLES\n"
+            s << indent_block("#{ examples }\n", 2)
+            end
+
+            s
+          end
+        end
+#--}}}
+      end
+
+=begin
+        usage <<-usage
+          NAME
+            #{ program } v#{ version }
+
+          SYNOPSIS
+            #{ program } [options]* [file]*
+        usage
+=end
+
+
+      def unindent_block buf
+#--{{{
+        buf = "#{ buf }"
+        lines = buf.to_a
+        indent_pat = %r/^\s*[\s|]/
+        indent = lines.first[ indent_pat ] rescue nil
+        if indent
+          lines.map do |line| 
+            line[ indent.size..-1 ] || "\n"
+          end.join 
+        else
+          buf 
+        end
+#--}}}
+      end
+
+      def indent_block buf, n = 2
+#--{{{
+        space = ' ' * n.to_i
+        unindent_block(buf).gsub %r/^/, space 
+#--}}}
+      end
+
+      def options(*list)
+#--{{{
+        @optspec ||= []
+        return @optspec if list.empty?
+        list = [list] unless Array === list.first
+        list.each{|spec| (@optspec ||= []) << spec}
+#--}}}
+      end
+      alias option options
+
+      def required_arguments(*list)
+#--{{{
+        @required_arguments ||= []
+        list.flatten.each do |arg| 
+          return(optional_argument(arg)) if Hash === arg
+          unless instance_methods.include? "#{ arg }"
+            module_eval <<-code
+              def #{ arg }(*__list)
+                if __list.empty?
+                  @#{ arg }
+                else
+                  send('#{ arg }=', *__list)
+                end
+              end
+              def #{ arg }=(__arg, *__list)
+                if __list.empty?
+                  @#{ arg } = __arg
+                else
+                  @#{ arg } = ([__arg] + __list)
+                end
+              end
+              def #{ arg }?
+                defined? @#{ arg } and @#{ arg }
+              end
+            code
+          end
+          @required_arguments << "#{ arg }"
+        end
+        @required_arguments
+#--}}}
+      end
+      alias required_argument required_arguments
+      alias arguments required_arguments
+      alias argument required_arguments
+
+      def optional_arguments(*list)
+#--{{{
+        @optional_arguments ||= []
+        list.flatten.each do |arg| 
+          arg, default =
+            case arg
+              when Hash
+                arg.to_a.first
+              else
+                [arg, nil]
+            end
+          @do_not_gc ||= [] 
+          @do_not_gc << default unless @do_not_gc.include? default
+          unless instance_methods.include? "#{ arg }"
+            module_eval <<-code
+              def #{ arg }(*__list)
+                unless @#{ arg }
+                  @#{ arg } = ObjectSpace::_id2ref #{ default.object_id }
+                end
+                if __list.empty?
+                  @#{ arg }
+                else
+                  send('#{ arg }=', *__list)
+                end
+              end
+              def #{ arg }=(__arg, *__list)
+                if __list.empty?
+                  @#{ arg } = __arg
+                else
+                  @#{ arg } = ([__arg] + __list)
+                end
+              end
+              def #{ arg }?
+                defined? @#{ arg } and @#{ arg }
+              end
+            code
+          end
+          @optional_arguments << "#{ arg }"
+        end
+        @optional_arguments
+#--}}}
+      end
+      alias optional_argument optional_arguments
+
+      def class_initialize
+#--{{{
+        version '0.0.0'
+
+        author 'ara.t.howard@noaa.gov'
+
+        program File.basename($0)
+
+        name "#{ program } v#{ version }"
+
+        optspec [
+          [ '--help', '-h', 'this message' ],
+          [ '--log=path','-l', 'set log file - (default stderr)' ],
+          [ '--verbosity=verbostiy', '-v', '0|fatal < 1|error < 2|warn < 3|info < 4|debug - (default info)' ],
+        ]
+
+=begin
+        usage <<-usage
+          NAME
+            #{ program } v#{ version }
+
+          SYNOPSIS
+            #{ program } [options]* [file]*
+        usage
+=end
+
+        examples ''
+#--}}}
+      end
+
+      def inherited klass, &b 
+#--{{{
+        ret = super(klass, &b)
+        klass.class_initialize
+        ret
+#--}}}
+      end
+
+      def run(*a, &b)
+#--{{{
+        new(*a, &b).run
+#--}}}
+      end
+
+      def defaults head = nil, *tail  
+#--{{{
+        @defaults ||= {}
+        return @defaults if head.nil?
+        return @defaults.update(head) if head.is_a?(Hash)
+        return @defaults.values_at(*head) if head.is_a?(Array)
+        return @defaults[head.to_s] if tail.empty?
+        keys = [head, tail].flatten.map{|k| k.to_s}
+        return @defaults.values_at(*keys)
+#--}}}
+      end
+      alias_method "default", "defaults"
+#--}}}
+    end
+
+    #class_attribute
+
+    class_initialize
+
+    attr :logger
+    attr :program
+    attr :argv
+    attr :env
+    attr :cmdline
+    attr :console
+    attr :options
+    attr :listoptions
+    attr :op
+    attr :logdev
+    attr :verbosity
+    alias console? console
+
+    def exit_status e = nil
+      (e ? (@exit_success = e) : (defined?(@exit_success) and @exit_success))
+    end
+    alias_method "exit_status?", "exit_status"
+
+    def initialize argv = ARGV, env = ENV
+#--{{{
+      @argv = Util::mcp(argv.to_a)
+      @env = Util::mcp(env.to_hash)
+      @program = File::expand_path $0
+      @cmdline = ([@program] + @argv).join ' '
+      @console = STDIN.tty?
+#--}}}
+    end
+    def klass; self.class; end
+    def required_arguments
+#--{{{
+      klass::required_arguments
+#--}}}
+    end
+    def optional_arguments
+#--{{{
+      klass::optional_arguments
+#--}}}
+    end
+    def run
+#--{{{
+      logcatch do
+        begin
+          pre_run
+          pre_parse_options
+          parse_options
+          post_parse_options
+          pre_parse_argv
+          parse_argv
+          post_parse_argv
+          pre_init_logging
+          init_logging
+          post_init_logging
+          pre_main
+          status = main
+          post_main
+          post_run
+          exit(exit_status ? exit_status : (status ? EXIT_SUCCESS : EXIT_FAILURE))
+        rescue Errno::EPIPE
+          STDOUT.tty? ?  raise : exit(EXIT_FAILURE)
+        end
+      end
+#--}}}
+    end
+    def pre_parse_options; end
+    def post_parse_options; end
+    def pre_init_logging; end
+    def post_init_logging; end
+    def pre_parse_argv
+#--{{{
+      if(@options.has_key?('help') or (@argv.size == 1 and @argv.first =~ %r/help/i))
+        usage STDOUT
+        exit EXIT_SUCCESS
+      end
+      if(@options.has_key?('version') or @argv.first =~ %r/version/i)
+        STDOUT.puts self.class.version
+        exit EXIT_SUCCESS
+      end
+#--}}}
+    end
+    def post_parse_argv; end
+    def pre_run; end
+    def post_run; end
+    def pre_main; end
+    def post_main; end
+    def logcatch 
+#--{{{
+      ret = nil
+      # @logger ||= Logger::new STDERR
+      logger!
+      begin
+        ret = yield
+      rescue Exception => e
+        unless SystemExit === e
+          fatal{ e }
+          exit EXIT_FAILURE
+        if false
+          if logger.debug?
+            fatal{ e }
+            exit EXIT_FAILURE
+          else
+            fatal{ emsg(e) }
+            exit EXIT_FAILURE
+          end
+        end
+        else
+          exit e.status 
+        end
+      end
+      ret
+#--}}}
+    end
+    def usage port = STDERR
+#--{{{
+      port << klass::usage << "\n" if(klass::usage and not klass::usage.empty?)
+      port << klass::examples << "\n" if(klass::examples and not klass::examples.empty?)
+
+      if klass::optspec 
+        port << 'OPTIONS' << "\n"
+
+        klass::optspec.each do |os| 
+          a, b, c = os
+          long, short, desc = nil
+          [a,b,c].each do |word|
+            next unless word
+            word.strip!
+            case word
+              when %r/^--[^-]/o
+                long = word
+              when %r/^-[^-]/o
+                short = word
+              else
+                desc = word
+            end
+          end
+
+          spec = ((long and short) ? [long, short] : [long])
+
+          if spec
+            port << Util::columnize(spec.join(', '), :width => 80, :indent => 2)
+            port << "\n"
+          end
+
+          if desc
+            port << Util::columnize(desc, :width => 80, :indent => 8)
+            port << "\n"
+          end
+        end
+
+        port << "\n"
+      end
+
+      port
+#--}}}
+    end
+    def parse_options
+#--{{{
+      @op = OptionParser::new
+      @options = {}
+      @listoptions = Hash::new{|h,k| h[k] = []} 
+      klass::optspec.each do |spec|
+        k = spec.first.gsub(%r/(?:--)|(?:=.*$)|(?:\s+)/o,'')
+        @op.def_option(*spec) do |v| 
+          @options[k] = v
+          @listoptions[k] << v
+        end
+      end
+      begin
+        op.parse! @argv 
+      rescue OptionParser::InvalidOption => e
+        # preverve unknown options
+        #e.recover(argv)
+        invalid_option e
+      end
+      @options
+#--}}}
+    end
+    def invalid_option e
+#--{{{
+      # e.recover argv
+      fatal{ e.to_s }
+      exit EXIT_FAILURE
+#--}}}
+    end
+    def init_logging opts = @options 
+#--{{{
+      log = Util::getopt 'log', opts
+      log_age = Util::getopt 'log_age', opts
+      log_size = Util::getopt 'log_size', opts
+      verbosity = Util::getopt 'verbosity', opts
+      log_age = Integer log_age rescue nil
+      log_size = Integer log_size rescue nil
+      $logger = self.logger = Logger::new(log || STDERR, log_age, log_size)
+    #
+    # hack to fix Logger sync bug
+    #
+      begin
+        class << @logger; attr :logdev unless @logger.respond_to?(:logdev); end
+        @logdev = @logger.logdev.dev 
+        @logdev.sync = true
+      rescue
+        nil
+      end
+      level = nil
+      verbosity ||= 'info'
+      verbosity =
+        case verbosity
+          when /^\s*(?:4|d|debug)\s*$/io
+            level = 'Logging::DEBUG'
+            4
+          when /^\s*(?:3|i|info)\s*$/io
+            level = 'Logging::INFO'
+            3
+          when /^\s*(?:2|w|warn)\s*$/io
+            level = 'Logging::WARN'
+            2
+          when /^\s*(?:1|e|error)\s*$/io
+            level = 'Logging::ERROR'
+            1
+          when /^\s*(?:0|f|fatal)\s*$/io
+            level = 'Logging::FATAL'
+            0
+          else
+            abort "illegal verbosity setting <#{ verbosity }>" 
+        end
+      logger.level = 2 - ((verbosity % 5) - 2) 
+      logger
+#--}}}
+    end
+    def parse_argv
+#--{{{
+      a, b = [], []
+      klass::required_arguments.each do |arg|
+        value = @argv.shift
+        if value 
+          send "#{ arg }=", value
+        else
+          die 'msg' => "required_argument <#{ arg }> not given"
+        end
+        a << send("#{ arg }")
+      end
+      klass::optional_arguments.each do |arg|
+        value = @argv.shift
+        if value 
+          send "#{ arg }=", value
+        end
+        b << send("#{ arg }")
+      end
+      [a, b, @argv]
+#--}}}
+    end
+    def die opts = {} 
+#--{{{
+      msg = Util::getopt 'msg', opts, klass.usage
+      errno = Util::getopt 'errno', opts, EXIT_FAILURE
+      STDERR.puts("#{ msg }")
+      exit(Integer(errno))
+#--}}}
+    end
+    def main 
+#--{{{
+      raise NotImplementedError, 'main'
+#--}}}
+    end
+    def options? *keys
+#--{{{
+      list = keys.map{|key| @options.has_key? key}
+      list.size > 0 and list.all?
+#--}}}
+    end
+    alias_method "option?", "options?"
+    def options *keys
+#--{{{
+      if keys.empty?
+        @options
+      else
+        keys.map{|key| @options[key]}
+      end
+#--}}}
+    end
+    def option key
+#--{{{
+      options(key).first
+#--}}}
+    end
+    def defaults *a, &b
+#--{{{
+      self.class.defaults *a, &b
+#--}}}
+    end
+    alias_method "default", "defaults"
+
+    def argv_plus_stdin
+#--{{{
+      stdin = argv.delete '-'
+      STDIN.each{|line| argv << line} if stdin
+      argv.map!{|arg| arg.strip}
+      argv
+#--}}}
+    end
+
+  #
+  # casting methods 
+  #
+    module Casting
+#--{{{
+      def int_list *list
+#--{{{
+        list.flatten.compact.map{|i| Util.atoi i}
+#--}}}
+      end
+      def float_list *list
+#--{{{
+        list.flatten.compact.map{|f| Float f}
+#--}}}
+      end
+      def string_list *list
+#--{{{
+        list.flatten.compact.map{|s| String s}
+#--}}}
+      end
+      def string_cast arg
+        arg.to_s
+      end
+      def int_cast arg
+        Integer arg.to_s
+      end
+      def float_cast arg
+        Float arg
+      end
+      def bool_cast arg
+        arg ? true : false
+      end
+      def bool_cast arg
+        case arg
+          when Numeric 
+            not arg.zero?
+          when String 
+            case arg
+              when %r/^(1|t|true)$/i
+                true
+              when %r/^(0|f|false)$/i
+                false
+              else
+                raise ArgumentError, arg.inspect
+            end
+          else
+            arg ? true : false
+        end
+      end
+      def re_cast arg
+        Regexp === arg ? arg : %r/#{ arg }/
+      end
+      def pathname_cast arg, opts = {}
+        expand = opts['expand'] || opts[:expand]
+        pn = (Pathname === arg ? arg : Pathname.new(arg.to_s))
+        expand ? pn.expand_path : pn 
+      end
+#--}}}
+    end
+    include Casting
+
+  #
+  # param dsl and class
+  #
+    class Param < ::String
+#--{{{
+      include Casting
+
+      def self.pattr name
+#--{{{
+        module_eval <<-code
+          def #{ name } *_a, &b
+            _a.push lambda{ instance_eval &b } if b
+            _a.size == 0 ? (defined? @#{ name } and @#{ name }) : (@#{ name }=_a.shift)
+          end
+          def #{ name }?
+            defined?(@#{ name }) and @#{ name }
+          end
+          def #{ name }= val
+            #{ name }( val )
+          end
+        code
+#--}}}
+      end
+
+      %w( 
+        this
+        rhs
+        required_argument
+        optional_argument
+        long
+        short
+        description
+        default 
+        munge
+        cast
+      ).each{|a| pattr a}
+
+      alias_method 'desc', 'description'
+      alias_method 'synopsis', 'description'
+
+      {
+        'requires_argument' => 'required_argument',
+        'argument_required' => 'required_argument',
+        'arg_required'      => 'required_argument',
+        'req_arg'           => 'required_argument',
+        'opt_arg'           => 'optional_argument',
+        'argument_optional' => 'optional_argument',
+        'arg_optional'      => 'optional_argument',
+      }.each{|dst,src| define_method(dst){ send src, true }}
+
+      def initialize name, this = nil, &block
+#--{{{
+        if name.is_a?(Array)
+          a, b, ignored = name
+          a, b = a.to_s, b.to_s
+          name = a.size > b.size ? a : b
+          st = a.size > b.size ? b : a
+          short st
+        end
+
+        name = name.to_s
+        @this = this
+
+        re = %r/\s*=\s*([^=]+)\s*$/
+        m, @rhs = re.match(name).to_a
+        name.gsub! re, '' if @rhs
+        name.gsub! %r/^\s*--/, ''
+
+        super(name.to_s.gsub(%r/^\s*--/,''))
+        instance_eval &block if block
+#--}}}
+      end
+      def long
+#--{{{
+        @long ||= "--#{ self }"
+#--}}}
+      end
+      def to_a
+#--{{{
+        [ long, short, description ].compact
+#--}}}
+      end
+      def to_option
+#--{{{
+        optspec = []
+
+        if long
+          s = "#{ long }"
+          if required_argument
+            s << "=#{ self }"
+          elsif optional_argument
+            s << "=[#{ self }]"
+          elsif rhs
+            s << "=#{ rhs }" unless s[%r/=/]
+          end
+          optspec << s
+        end
+
+        if short
+          s = "#{ short }".strip.gsub(%r/^-*/,'-')
+          optspec << s
+        end
+
+        if description 
+          s = "#{ description }"
+          optspec << s
+        end
+
+        optspec
+#--}}}
+      end
+      def argument what = :required
+#--{{{
+        case what.to_s
+          when /opt/i
+            send "optional_argument", true
+          when /req/i
+            send "required_argument", true
+          else
+            raise "what <#{ what }>"
+        end
+#--}}}
+      end
+      alias_method 'arg', 'argument'
+      def cast &b
+#--{{{
+        b and @cast = b
+        cast?  ? @cast : nil
+#--}}}
+      end
+      def cast?
+#--{{{
+        defined? @cast
+#--}}}
+      end
+      def param name # call up!
+#--{{{
+        @this.param name
+#--}}}
+      end
+      def value this = self
+#--{{{
+        if defined? @default
+          @default.respond_to?('call') ? @default.call : @default
+        else
+          nil
+        end
+#--}}}
+      end
+#--}}}
+    end
+  #
+  # meta-hooks for param dsl
+  #
+    class << self
+#--{{{
+      def params
+#--{{{
+        @params ||= {} 
+#--}}}
+      end
+      alias_method "parms", "params"
+      def param name, this = self, &block 
+#--{{{
+        parm =
+          if block or name.is_a?(Array)
+            param = Param.new name, this, &block
+            option *param.to_option
+            default param => param.default
+            params[ param.to_s ] = param
+          else
+            name = name.to_s
+            defined = params[ name ]
+            if defined
+              defined
+            else
+              param = Param.new name, this, &block
+              option *param.to_option
+              default param => param.default
+              params[ param.to_s ] = param
+            end
+          end
+        parm.value
+#--}}}
+      end
+      alias_method "parm", "param"
+      def get_param name
+        params[ name.to_s ]
+      end
+#--}}}
+    end
+    def params
+#--{{{
+      self.class.params
+#--}}}
+    end
+    alias_method "parms", "params"
+    def param? name
+#--{{{
+      key = name.to_s
+      options.has_key? key
+#--}}}
+    end
+    def param name, *a 
+#--{{{
+      key = name.to_s
+      pm = params[key] or raise "no such param <#{ key }>!"
+
+      value =
+        if options.has_key? key 
+          options[key] || default(key)
+        else
+          a.empty? ? default(key) : a.shift
+        end
+
+      #value = value.call if value.respond_to?('call')
+      value = instance_eval &value if Proc === value
+
+      #value = pm.cast[value] if(option?(key) and pm.cast?)
+      value = pm.cast[value] if(value and pm.cast?)
+
+      value
+#--}}}
+    end
+    alias_method "parm", "param"
+
+
+    def self.main &block
+      define_method :main, &block
+    end
+#--}}}
+  end # class AbstractMain
+
+  class SimpleMain < AbstractMain
+  end
+
+  class ConfigurableMain < AbstractMain
+#--{{{
+    def self.class_initialize
+#--{{{
+      super
+      class_attribute :config_default_path
+      class_attribute :config_search_path
+      class_attribute :configfile
+
+      config_default_path "#{ prognam }.conf"
+
+      config_search_path %w(. ~ /usr/local/etc /usr/etc /etc)
+
+      configfile Class::new(ALib::ConfigFile) #{ default = DATA; DATA.rewind; }
+
+      optspec << [ '--config=path', 'valid path - specify config file (default nil)' ]
+      optspec << [ '--template=[path]', 'valid path - generate a template config file in path (default stdout)' ]
+#--}}}
+    end
+
+    attribute :config
+
+    def pre_parse_argv
+#--{{{
+      super
+      if(@options.has_key?('template') or @argv.first =~ %r/template/i)
+        @argv.shift if @argv.first =~ %r/template/i
+        arg = @argv.first
+        gen_template @options['template'] || @options['config'] || arg
+        exit EXIT_SUCCESS
+      end
+#--}}}
+    end
+    def gen_template template
+#--{{{
+      klass::configfile::gen_template(template)
+      self
+#--}}}
+    end
+    def post_parse_argv
+#--{{{
+      init_config
+#--}}}
+    end
+    def init_config opts = @options
+#--{{{
+      conf = Util::getopt 'config', opts
+      @config =
+        if conf 
+          klass::configfile::new(conf)
+        else
+          klass::configfile::any klass::config_default_path, klass::config_search_path
+        end
+      @config
+#--}}}
+    end
+#--}}}
+  end
+
+end
+