main 2.9.3 → 3.0.1

data/lib/main/program/instance_methods.rb

@@ -0,0 +1,253 @@
+module Main
+  class Program
+    module InstanceMethods
+    # instance methods
+    #
+      fattr('main'){ self.class }
+      fattr('argv'){ main.argv }
+      fattr('env'){ main.env }
+      fattr('opts'){ main.opts }
+      fattr('stdin'){ main.stdin }
+      fattr('stdout'){ main.stdout }
+      fattr('stderr'){ main.stderr }
+      fattr('logger'){ main.logger }
+      fattr('params')
+
+      %w( 
+        program name synopsis description author version
+        exit_status exit_success exit_failure exit_warn
+        logger_level
+        usage
+      ).each{|a| fattr(a){ self.class.send a}}
+
+      alias_method 'status', 'exit_status'
+      alias_method 'status=', 'exit_status='
+
+      %w( parameters param ).each do |dst|
+        alias_method "#{ dst }", "params"
+        alias_method "#{ dst }=", "params="
+        alias_method "#{ dst }?", "params?"
+      end
+
+      %w( debug info warn fatal error ).each do |m|
+        module_eval <<-code
+          def #{ m } *a, &b
+            logger.#{ m } *a, &b
+          end
+        code
+      end
+
+      def pre_initialize() :hook end
+      def before_initialize() :hook end
+      def main_initialize()
+        setup_finalizers
+        setup_io_restoration
+        setup_io_redirection
+        setup_logging
+      end
+      def initialize() :hook end
+      def after_initialize() :hook 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
+
+      def setup_io_redirection
+        self.stdin = opts['stdin'] || opts[:stdin] || stdin
+        self.stdout = opts['stdout'] || opts[:stdout] || stdout
+        self.stderr = opts['stderr'] || opts[:stderr] || stderr
+      end
+
+      def setup_logging
+        log = self.class.logger || stderr
+        self.logger = log
+      end
+      undef_method 'logger='
+      def logger= log
+        unless(defined?(@logger) and @logger == log)
+          case log 
+            when ::Logger, Logger
+              @logger = log
+            when IO, StringIO
+              @logger = Logger.new log 
+              @logger.level = logger_level 
+            else
+              @logger = Logger.new(*log)
+              @logger.level = logger_level 
+          end
+        end
+        @logger
+      end
+
+      def setup_io_restoration
+        [STDIN, STDOUT, STDERR].each do |io|
+          dup = io.dup and @finalizers.push lambda{ io.reopen dup rescue nil }
+        end
+      end
+
+      undef_method 'stdin='
+      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
+          end
+        end
+      end
+
+      undef_method 'stdout='
+      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
+
+      undef_method 'stderr='
+      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
+      end
+      
+      def pre_parse_parameters() :hook end
+      def before_parse_parameters() :hook end
+      def parse_parameters
+        pre_parse_parameters
+        before_parse_parameters
+
+        self.class.parameters.parse(self)
+        @params = Parameter::Table.new
+        self.class.parameters.each{|p| @params[p.name.to_s] = p}
+
+        after_parse_parameters
+        post_parse_parameters
+      end
+      def after_parse_parameters() :hook end
+      def post_parse_parameters() :hook end
+
+      def pre_run() :hook end
+      def before_run() :hook end
+      def run
+        raise NotImplementedError, 'run not defined'
+      end
+      def after_run() :hook end
+      def post_run() :hook end
+
+      fattr 'mode'
+      def modes
+        self.class.modes
+      end
+
+      def help!(status = 0)
+        print usage.to_s
+        exit(status)
+      end
+
+      def help?
+        (params['help'] and params['help'].given?) or argv.first == 'help'
+      end
+
+      def abort(message = 'exit')
+        raise SystemExit.new(message)
+      end
+
+      def handle_exception(e)
+        if e.respond_to?(:error_handler_before)
+          fcall(e, :error_handler_before, self)
+        end
+
+        if e.respond_to?(:error_handler_instead)
+          fcall(e, :error_handler_instead, self)
+        else
+          if e.respond_to?(:status)
+            exit_status(( e.status ))
+          end
+
+          if Softspoken === e or SystemExit === e
+            quiet = ((SystemExit === e and e.message.respond_to?('abort')) or # see main/stdext.rb
+                    (SystemExit === e and e.message == 'exit'))
+            stderr.puts e.message unless quiet
+          else
+            fatal{ e }
+          end
+        end
+
+        if e.respond_to?(:error_handler_after)
+          fcall(e, :error_handler_after, self)
+        end
+
+        exit_status(( exit_failure )) if exit_status == exit_success
+        exit_status(( Integer(exit_status) rescue(exit_status ? 0 : 1) ))
+      end
+
+      def handle_exit(status)
+        exit(( Integer(status) rescue 1 ))
+      end
+
+      def fcall(object, method, *argv, &block)
+        method = object.method(method)
+        arity = m.arity
+        if arity >= 0
+          argv = argv[0, arity]
+        else
+          arity = arity.abs - 1
+          argv = argv[0, arity] + argv[arity .. -1]
+        end
+        method.call(*argv, &block)
+      end
+
+      %w[ before instead after ].each do |which|
+        module_eval <<-code
+          def error_handler_#{ which } *argv, &block
+            block.call *argv
+          end
+        code
+      end
+
+      def instance_eval_block(*argv, &block)
+        singleton_class =
+          class << self
+            self
+          end
+        singleton_class.module_eval{ define_method('__instance_eval_block', &block) }
+        fcall(self, '__instance_eval_block', *argv, &block)
+      end
+    end
+
+    include InstanceMethods
+  end
+end

data/lib/main/stdext.rb

@@ -1,16 +1,17 @@
 class Object
-  def singleton_class object = self, &block
-    sc =
+  def singleton_class(object = self, &block)
+    singleton_class =
       class << object
         self
       end
-    block ? sc.module_eval(&block) : sc
+    block ? singleton_class.module_eval(&block) : singleton_class
   end
-
 end
 
-module SaneAbort
-  def abort message = nil
+module Kernel
+private
+  undef_method 'abort'
+  def abort(message = nil)
     if message
       message = message.to_s
       message.singleton_class{ fattr 'abort' => true }
@@ -20,19 +21,16 @@ module SaneAbort
   end
 end
 
-  def abort message = nil
-    if message
-      message = message.to_s
-      message.singleton_class{ fattr 'abort' => true }
-      STDERR.puts message
-    end
-    exit 1
-  end
-  def Process.abort message = nil
-    if message
-      message = message.to_s
-      message.singleton_class{ fattr 'abort' => true }
-      STDERR.puts message
+module Process
+  class << Process
+    undef_method 'abort'
+    def abort(message = nil)
+      if message
+        message = message.to_s
+        message.singleton_class{ fattr 'abort' => true }
+        STDERR.puts message
+      end
+      exit 1
     end
-    exit 1
   end
+end

data/main.gemspec

@@ -3,11 +3,12 @@
 
 Gem::Specification::new do |spec|
   spec.name = "main"
-  spec.version = "2.9.3"
+  spec.description = 'a class factory and dsl for generating command line programs real quick'
+  spec.version = "3.0.1"
   spec.platform = Gem::Platform::RUBY
   spec.summary = "main"
 
-  spec.files = ["lib", "lib/main", "lib/main/base.rb", "lib/main/cast.rb", "lib/main/factories.rb", "lib/main/getoptlong.rb", "lib/main/logger.rb", "lib/main/mode.rb", "lib/main/parameter.rb", "lib/main/softspoken.rb", "lib/main/stdext.rb", "lib/main/usage.rb", "lib/main/util.rb", "lib/main.rb", "main.gemspec", "Rakefile", "README", "README.erb", "samples", "samples/a.rb", "samples/b.rb", "samples/c.rb", "samples/d.rb", "samples/e.rb", "samples/f.rb", "samples/g.rb", "samples/h.rb", "test", "test/main.rb", "TODO"]
+  spec.files = ["a.rb", "lib", "lib/main", "lib/main/cast.rb", "lib/main/dsl.rb", "lib/main/factories.rb", "lib/main/getoptlong.rb", "lib/main/logger.rb", "lib/main/mode.rb", "lib/main/parameter.rb", "lib/main/program", "lib/main/program/class_methods.rb", "lib/main/program/instance_methods.rb", "lib/main/program.rb", "lib/main/softspoken.rb", "lib/main/stdext.rb", "lib/main/usage.rb", "lib/main/util.rb", "lib/main.rb", "main.gemspec", "Rakefile", "README", "README.erb", "samples", "samples/a.rb", "samples/b.rb", "samples/c.rb", "samples/d.rb", "samples/e.rb", "samples/f.rb", "samples/g.rb", "samples/h.rb", "test", "test/main.rb", "TODO"]
   spec.executables = []
   
   
@@ -16,8 +17,8 @@ Gem::Specification::new do |spec|
 
   spec.has_rdoc = true
   spec.test_files = "test/main.rb"
-  #spec.add_dependency 'lib', '>= version'
-  #spec.add_dependency 'fattr'
+  spec.add_dependency 'fattr', '>= 1.0.3'
+  spec.add_dependency 'arrayfields', '>= 4.5.0'
 
   spec.extensions.push(*[])
 

data/samples/e.rb

@@ -1,18 +1,27 @@
 require 'main'
 
+ARGV.replace %w( x y argument )
+
 Main {
-  argument 'global-argument'
-  option 'global-option'
+  argument 'argument'
+  option 'option'
 
-  def run() puts 'global-run' end
+  def run() puts 'run' end
 
   mode 'a' do
     option 'a-option'
+    def run() puts 'a-run' end
   end
 
-  mode 'b' do
-    option 'b-option'
+  mode 'x' do
+    option 'x-option'
+
+    def run() puts 'x-run' end
+
+      mode 'y' do
+        option 'y-option'
 
-    def run() puts 'b-run' end
+        def run() puts 'y-run' end
+      end
   end
 }

data/samples/f.rb

@@ -1,5 +1,7 @@
 require 'main'
 
+ARGV.replace %W( compress /data )
+
 Main {
   argument('directory'){ description 'the directory to operate on' }
 

data/test/main.rb

@@ -1,11 +1,11 @@
-$:.unshift '.'
-$:.unshift './lib'
-$:.unshift '..'
-$:.unshift '../lib'
+$:.unshift('.')
+$:.unshift('./lib')
+$:.unshift('..')
+$:.unshift('../lib')
 
-require 'stringio'
-require 'test/unit'
-require 'main'
+require('stringio')
+require('test/unit')
+require('main')
 
 
 class T < Test::Unit::TestCase
@@ -22,7 +22,7 @@ class T < Test::Unit::TestCase
   def teardown
   end
 
-  def main argv=[], env={}, &b
+  def main(argv=[], env={}, &block)
     at_exit{ exit! }
 
     $VERBOSE=nil
@@ -30,32 +30,33 @@ class T < Test::Unit::TestCase
     ENV.clear
     env.each{|k,v| ENV[k.to_s]=v.to_s}
 
-    this = self
+    test = self
 
-    klass = ::Main.create do
-      module_eval &b if b
+    factory = Main.factory(&block)
 
-      define_method :handle_exception do |e|
-        if e.respond_to? :status
-          this.status = e.status
+    program = factory.build(argv, env)
+
+    main = program.new
+
+    program.evaluate do
+      define_method :handle_exception do |exception|
+        if exception.respond_to?(:status)
+          test.status = main.status = exception.status
         else
-          raise
+          test.status = main.status
+          raise(exception)
         end
       end
-
-      define_method :handle_throw do |*a|
+      define_method :handle_exit do |status|
+        test.status = main.status = status
       end
     end
 
-    main = klass.new argv, env
+    main.logger = logger
 
-    main.logger = @logger
+    main.run
 
-    begin
-      main.run
-    ensure
-      this.status ||= main.exit_status
-    end
+    test.status ||= main.exit_status
 
     main
   end
@@ -77,7 +78,7 @@ class T < Test::Unit::TestCase
         define_method(:run){ x = 42 }
       }
     }
-    assert x == 42
+    assert_equal 42, x 
   end
  
 # exit status
@@ -88,7 +89,7 @@ class T < Test::Unit::TestCase
         def run() end
       }
     }
-    assert status == 0
+    assert_equal 0, status
   end
   def test_0030
     assert_nothing_raised{
@@ -96,7 +97,7 @@ class T < Test::Unit::TestCase
         def run() exit 42 end
       }
     }
-    assert status == 42
+    assert_equal 42, status
   end
   def test_0040
     assert_nothing_raised{
@@ -106,7 +107,7 @@ class T < Test::Unit::TestCase
         }
       }
       Process.wait
-      assert $?.exitstatus == 42 
+      assert_equal 42, $?.exitstatus
     }
   end
   def test_0050
@@ -115,15 +116,7 @@ class T < Test::Unit::TestCase
         def run() exit 42 end
       }
     }
-    assert status == 42 
-  end
-  def test_0060
-    assert_nothing_raised{
-      main{
-        def run() raise ArgumentError end
-      }
-    }
-    assert status == 1
+    assert_equal 42, status
   end
   def test_0060
     assert_raises(RuntimeError){
@@ -131,7 +124,7 @@ class T < Test::Unit::TestCase
         def run() exit_status 42; raise end
       }
     }
-    assert status == 42 
+    assert_equal 42, status
   end
   def test_0070
     assert_raises(ArgumentError){
@@ -139,7 +132,7 @@ class T < Test::Unit::TestCase
         def run() exit_status 42; raise ArgumentError end
       }
     }
-    assert status == 42 
+    assert_equal 42, status
   end
  
 # parameter parsing 
@@ -439,9 +432,9 @@ class T < Test::Unit::TestCase
     foobar = nil
     assert_nothing_raised{
       main(%w[foo=40 --bar=2 foobar foo=42]){
-        kw('foo'){ cast :int; arity 2 }
-        opt('bar='){ cast :int }
-        arg 'foobar'
+        keyword('foo'){ cast :int; arity 2 }
+        option('bar='){ cast :int }
+        argument 'foobar'
 
         define_method('run'){ 
           foo = param['foo'] 
@@ -459,7 +452,7 @@ class T < Test::Unit::TestCase
     foo = nil
     assert_nothing_raised{
       main([], 'foo' => '42'){
-        env('foo'){ cast :int }
+        environment('foo'){ cast :int }
         define_method('run'){ 
           foo = param['foo'] 
         }
@@ -488,7 +481,7 @@ class T < Test::Unit::TestCase
   end
   def test_0290
     assert_nothing_raised{
-      u = Main::Usage.default Main.create
+      u = Main::Usage.default(Main.factory)
     }
   end
   def test_0300
@@ -662,7 +655,7 @@ class T < Test::Unit::TestCase
     argv = %w( a b c )
     assert_nothing_raised{
       main(argv.dup) {
-        argument('zero_or_more'){ arity -1 }
+        argument('zero_or_more'){ arity(-1) }
         run{ m = self }
       }
     }
@@ -673,7 +666,7 @@ class T < Test::Unit::TestCase
     argv = %w( a b c )
     assert_nothing_raised{
       main(argv.dup) {
-        argument('zero_or_more'){ arity -1 }
+        argument('zero_or_more'){ arity(-1) }
         run{ m = self }
       }
     }
@@ -684,7 +677,7 @@ class T < Test::Unit::TestCase
     argv = %w( a b c )
     assert_nothing_raised{
       main(argv.dup) {
-        argument('zero_or_more'){ arity '*' }
+        argument('zero_or_more'){ arity('*') }
         run{ m = self }
       }
     }
@@ -695,7 +688,7 @@ class T < Test::Unit::TestCase
     argv = %w( a b c )
     assert_nothing_raised{
       main(argv.dup) {
-        argument('one_or_more'){ arity -2 }
+        argument('one_or_more'){ arity(-2) }
         run{ m = self }
       }
     }
@@ -706,7 +699,7 @@ class T < Test::Unit::TestCase
     argv = %w( a b c )
     assert_nothing_raised{
       main(argv.dup) {
-        argument('two_or_more'){ arity -3 }
+        argument('two_or_more'){ arity(-3) }
         run{ m = self }
       }
     }
@@ -717,7 +710,7 @@ class T < Test::Unit::TestCase
     argv = %w()
     assert_nothing_raised{
       main(argv.dup) {
-        argument('zero_or_more'){ arity -1 }
+        argument('zero_or_more'){ arity(-1) }
         run{ m = self }
       }
     }
@@ -728,7 +721,7 @@ class T < Test::Unit::TestCase
     argv = %w()
     assert_raises(Main::Parameter::NotGiven){
       main(argv.dup) {
-        argument('one_or_more'){ arity -2 }
+        argument('one_or_more'){ arity(-2) }
         run{ m = self }
       }
     }
@@ -738,7 +731,7 @@ class T < Test::Unit::TestCase
     argv = %w( a )
     assert_raises(Main::Parameter::Arity){
       main(argv.dup) {
-        argument('two_or_more'){ arity -3 }
+        argument('two_or_more'){ arity(-3) }
         run{ m = self }
       }
     }
@@ -748,7 +741,7 @@ class T < Test::Unit::TestCase
     argv = %w( a )
     assert_raises(Main::Parameter::Arity){
       main(argv.dup) {
-        argument('two_or_more'){ arity -4 }
+        argument('two_or_more'){ arity(-4) }
         run{ m = self }
       }
     }
@@ -767,6 +760,7 @@ class T < Test::Unit::TestCase
         end
       }
     }
+    assert m, 'm.nil!'
     assert m.param['b'].value == 'b'
   end 
   def test_0490
@@ -782,8 +776,38 @@ class T < Test::Unit::TestCase
         end
       }
     }
+    assert m, 'm.nil!'
     assert m.param['c'].value == 'c'
   end 
+  def test_0491
+    m = nil
+    argv = %w(a b c)
+    count = Hash.new{|h,k| h[k] = 0}
+    assert_nothing_raised{
+      main(argv.dup) {
+        %w(
+          initialize
+          pre_initialize
+          before_initialize
+          post_initialize
+          after_initialize
+        ).each do |method|
+          define_method(method){ count[method] += 1 }
+        end
+        mode 'a' do
+          mode 'b' do
+            mode 'c' do
+              run{ m = self }
+            end
+          end
+        end
+      }
+    }
+    assert m, 'm.nil!'
+    count.each do |key, val|
+      assert val==1, key
+    end
+  end 
 
  
 # parameter attr/fattr/attribute 
@@ -832,7 +856,7 @@ class T < Test::Unit::TestCase
     argvs.each do |argv|
       assert_nothing_raised{
         main(argv.dup) {
-          argument(name){ arity -1; attr }
+          argument(name){ arity(-1); attr }
           run{ m = send(name) }
         }
       }