alib 0.4.0 → 0.5.0

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

@@ -10,9 +10,33 @@ module ALib
     include ALib
     include ALib::Logging
 
-    EXIT_SUCCESS = 0
-    EXIT_PSEUDO_SUCCESS = 42 
-    EXIT_FAILURE = 1
+    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
 #--{{{
@@ -79,7 +103,7 @@ module ALib
       alias c_attrs class_attributes
       alias c_attr class_attributes
 
-      %w( version author program optspec ).each do |meth|
+      %w( version author program optspec name examples synopsis ).each do |meth|
 #--{{{
         module_eval <<-code
           def #{ meth }(*a)
@@ -99,9 +123,11 @@ module ALib
 #--}}}
       end
       alias prognam program
+      alias progname program
       alias prognam= program=
       alias prognam? program?
 
+=begin
       %w( usage examples ).each do |meth|
 #--{{{
         module_eval <<-code
@@ -121,6 +147,51 @@ module ALib
         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
@@ -139,6 +210,13 @@ module ALib
 #--}}}
       end
 
+      def indent_block buf, n = 2
+#--{{{
+        space = ' ' * n.to_i
+        unindent_block(buf).gsub %r/^/, space 
+#--}}}
+      end
+
       def options(*list)
 #--{{{
         @optspec ||= []
@@ -236,27 +314,31 @@ module ALib
 
         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]+
+            #{ program } [options]* [file]*
         usage
+=end
 
         examples ''
 #--}}}
       end
 
-      def inherited klass
+      def inherited klass, &b 
 #--{{{
-        ret = super
+        ret = super(klass, &b)
         klass.class_initialize
         ret
 #--}}}
@@ -267,9 +349,24 @@ module ALib
         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
@@ -285,7 +382,12 @@ module ALib
     attr :verbosity
     alias console? console
 
-    def initialize argv = ARGV, env = ENV
+    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)
@@ -294,7 +396,16 @@ module ALib
       @console = STDIN.tty?
 #--}}}
     end
+
+    def self.new *a, &b
+#--{{{
+      (obj = allocate).instance_eval{ __initialize__ *a, &b }
+      obj
+#--}}}
+    end
+
     def klass; self.class; end
+
     def required_arguments
 #--{{{
       klass::required_arguments
@@ -310,26 +421,39 @@ module ALib
       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
+
+          initialize
+
           pre_main
           status = main
           post_main
+
           post_run
-          exit(status ? EXIT_SUCCESS : EXIT_FAILURE)
+
+          exit(exit_status ? exit_status : (status ? EXIT_SUCCESS : EXIT_FAILURE))
         rescue Errno::EPIPE
           STDOUT.tty? ?  raise : exit(EXIT_FAILURE)
         end
       end
 #--}}}
     end
+    def initialize; 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))
@@ -350,7 +474,8 @@ module ALib
     def logcatch 
 #--{{{
       ret = nil
-      @logger ||= Logger::new STDERR
+      # @logger ||= Logger::new STDERR
+      logger!
       begin
         ret = yield
       rescue Exception => e
@@ -453,7 +578,7 @@ module ALib
       verbosity = Util::getopt 'verbosity', opts
       log_age = Integer log_age rescue nil
       log_size = Integer log_size rescue nil
-      $logger = @logger = Logger::new(log || STDERR, log_age, log_size)
+      $logger = self.logger = Logger::new(log || STDERR, log_age, log_size)
     #
     # hack to fix Logger sync bug
     #
@@ -486,8 +611,8 @@ module ALib
           else
             abort "illegal verbosity setting <#{ verbosity }>" 
         end
-      @logger.level = 2 - ((verbosity % 5) - 2) 
-      @logger
+      logger.level = 2 - ((verbosity % 5) - 2) 
+      logger
 #--}}}
     end
     def parse_argv
@@ -522,9 +647,286 @@ module ALib
     end
     def main 
 #--{{{
-      raise NotImplementedError, 'main'
+      42
+#--}}}
+    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 arguments *args
+#--{{{
+      args.map{|arg| send arg}
+#--}}}
+    end
+    def argument arg
+#--{{{
+      arguments(arg).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
+
+  #
+  # param dsl and class
+  #
+    class Param < ::String
+#--{{{
+      include Util::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