main 0.0.2 → 2.0.0

data/lib/main/pervasives.rb

@@ -0,0 +1,52 @@
+module Pervasives
+  VERSION = "1.1.0"
+  def self.version() VERSION end
+
+  Methods = Hash.new{|h,k| h[k] = {}}
+
+  [Class, Module, Object].each do |type|
+    type.instance_methods.each do |m|
+      Methods[type]["#{ m }"] = type.instance_method m
+    end
+  end
+
+  def self.call o, m, *a, &b
+    list = 
+      case o
+        when Class then [Class, Module, Object]
+        when Module then [Module, Object]
+        when Object then [Object]
+      end
+    type = list.detect{|type| Methods[type]["#{ m }"]} 
+    m = Methods[type]["#{ m }"]
+    ( m ).bind( o ).call( *a, &b )
+  end
+
+  class ::Object
+    def __pervasive__ m, *a, &b
+      Pervasives.call self, m, *a, &b
+    end
+  end
+
+  class Proxy
+    instance_methods.each{|m| undef_method m unless m[%r/__/]}
+
+    def initialize obj
+      @obj = obj
+    end
+
+    def method_missing m, *a, &b
+      Pervasives.call @obj, m, *a, &b
+    end
+  end
+
+  def self.new *a, &b
+    Proxy.new *a, &b
+  end
+
+  class ::Object
+    def Pervasives *a, &b
+      Proxy.new *a, &b
+    end
+  end
+end

data/lib/main/softspoken.rb

@@ -0,0 +1,12 @@
+module Main
+  module Softspoken
+    class << self
+      attribute 'softspoken' => true
+      def on!() softspoken(true) end 
+      def off!() softspoken(false) end 
+      def === other
+        softspoken ? super : false
+      end
+    end
+  end
+end

data/lib/main/stdext.rb

@@ -0,0 +1,18 @@
+class ::Logger
+  def device
+    @logdev.instance_eval{ @dev }
+  end
+  def tty?
+    device.respond_to?('tty?') and device.tty?
+  end
+end
+
+class Object
+  def singleton_class object = self, &block
+    sc =
+      class << object
+        self
+      end
+    block ? sc.module_eval(&block) : sc
+  end
+end

data/lib/main/usage.rb

@@ -26,8 +26,20 @@ module Main
     alias_method 'delete', 'delete_at'
 
     def self.default_synopsis main
+    # build up synopsis
       s = "#{ main.name }"
 
+    # mode info
+      if main.mode_name != 'main'
+        s << " #{ main.fully_qualified_mode.join ' ' }"
+      end
+
+      unless main.modes.empty?
+        modes = main.modes.keys.join('|')
+        s << " (#{ modes })"
+      end
+
+    # argument info
       main.parameters.each do |p|
         if p.type == :argument
           if p.required?
@@ -38,6 +50,7 @@ module Main
         end
       end
 
+    # keyword info
       main.parameters.each do |p|
         if p.type == :keyword
           if p.required?
@@ -48,6 +61,7 @@ module Main
         end
       end
 
+    # option info
       n = 0
       main.parameters.each do |p|
         if p.type == :option
@@ -103,12 +117,16 @@ module Main
       s =
         parameters.map do |p|
           ps = ''
-          ps << Util.columnize("* #{ p.synopsis }", :indent => 2, :width => 78)
-          ps << "\n"
+          ps << Util.columnize("#{ p.synopsis }", :indent => 2, :width => 78)
+          #ps << Util.columnize("* #{ p.synopsis }", :indent => 2, :width => 78)
+          #ps << "\n"
           if p.description?
-            ps << Util.columnize(p.description, :indent => 6, :width => 78)
             ps << "\n"
+            ps << Util.columnize("#{ p.description }", :indent => 6, :width => 78)
+            #ps << Util.columnize(p.description, :indent => 6, :width => 78)
+            #ps << "\n"
           end
+          #ps << "\n"
           ps
         end.join("\n")
       usage['parameters'] = s 

data/samples/e.rb

@@ -0,0 +1,18 @@
+require 'main'
+
+Main {
+  argument 'global-argument'
+  option 'global-option'
+
+  def run() puts 'global-run' end
+
+  mode 'a' do
+    option 'a-option'
+  end
+
+  mode 'b' do
+    option 'b-option'
+
+    def run() puts 'b-run' end
+  end
+}

data/samples/f.rb

@@ -0,0 +1,27 @@
+require 'main'
+
+Main {
+  argument('directory'){ description 'the directory to operate on' }
+
+  option('force'){ description 'use a bigger hammer' }
+
+  def run
+    puts 'this is how we run when no mode is specified'
+  end
+
+  mode 'compress' do
+    option('bzip'){ description 'use bzip compression' }
+
+    def run
+      puts 'this is how we run in compress mode' 
+    end
+  end
+
+  mode 'uncompress' do
+    option('delete-after'){ description 'delete orginal file after uncompressing' }
+
+    def run
+      puts 'this is how we run in un-compress mode' 
+    end
+  end
+}

data/test/main.rb

@@ -8,10 +8,12 @@ require 'test/unit'
 require 'main'
 
 class T < Test::Unit::TestCase
-  attr 'status'
+  attribute 'status'
+  attribute 'logger'
+  attribute 'error'
 
   def setup
-    @status = nil
+    @status = nil 
     @logger = Logger.new StringIO.new
     @error = nil
   end
@@ -21,22 +23,36 @@ class T < Test::Unit::TestCase
 
   def main argv=[], env={}, &b
     at_exit{ exit! }
+
     $VERBOSE=nil
     ARGV.replace argv
     ENV.clear
     env.each{|k,v| ENV[k.to_s]=v.to_s}
-    main = nil
+
+    this = self
+
+    klass = ::Main.create do
+      module_eval &b if b
+
+      define_method :handle_exception do |e|
+        if e.respond_to? :status
+          this.status = e.status
+        else
+          raise
+        end
+      end
+    end
+
+    main = klass.new argv, env
+
+    main.logger = @logger
+
     begin
-      main = Object::Main.new(&b)
-      main.logger = @logger
       main.run
-    rescue Exception => e 
-      if SystemExit === e
-        @status = e.status
-      else
-        raise
-      end
+    ensure
+      this.status ||= main.exit_status
     end
+
     main
   end
 
@@ -92,10 +108,10 @@ class T < Test::Unit::TestCase
   def test_0050
     assert_nothing_raised{
       main{
-        def run() raise end
+        def run() exit 42 end
       }
     }
-    assert status == 1
+    assert status == 42 
   end
   def test_0060
     assert_nothing_raised{
@@ -106,7 +122,7 @@ class T < Test::Unit::TestCase
     assert status == 1
   end
   def test_0060
-    assert_nothing_raised{
+    assert_raises(RuntimeError){
       main{
         def run() exit_status 42; raise end
       }
@@ -114,7 +130,7 @@ class T < Test::Unit::TestCase
     assert status == 42 
   end
   def test_0070
-    assert_nothing_raised{
+    assert_raises(ArgumentError){
       main{
         def run() exit_status 42; raise ArgumentError end
       }
@@ -124,18 +140,6 @@ class T < Test::Unit::TestCase
 #
 # parameter parsing 
 #
-  def test_0080
-    p = nil
-    argv = %w[ 42 ]
-    assert_nothing_raised{
-      main(argv){
-        parameter('foo'){ type :argument }
-        define_method('run'){ p = param['foo'] }
-      }
-    }
-    assert p.value == argv.first 
-    assert p.values == argv
-  end
   def test_0080
     p = nil
     assert_raises(Main::Parameter::NotGiven){
@@ -147,17 +151,19 @@ class T < Test::Unit::TestCase
   end
   def test_0090
     p = nil
+    m = nil
     argv = %w[ 42 ]
     given = nil
     assert_nothing_raised{
-      main(argv){
+      main(argv.dup){
         argument 'foo'
-        define_method('run'){ p = param['foo'] }
+        define_method('run'){ m = self; p = param['foo'] }
       }
     }
     assert p.value == argv.first 
     assert p.values == argv
     assert p.given?
+    assert m.argv.empty? 
   end
   def test_0100
     p = nil
@@ -467,7 +473,7 @@ class T < Test::Unit::TestCase
   end
   def test_0290
     assert_nothing_raised{
-      u = Main::Usage.default main 
+      u = Main::Usage.default Main.create
     }
   end
   def test_0300
@@ -633,6 +639,126 @@ class T < Test::Unit::TestCase
     assert argv == $argv 
   end
 
+#
+# negative/globbing arity
+#
+  def test_4000
+    m = nil
+    argv = %w( a b c )
+    assert_nothing_raised{
+      main(argv.dup) {
+        argument('zero_or_more'){ arity -1 }
+        run{ m = self }
+      }
+    }
+    assert m.param['zero_or_more'].values == argv
+  end 
+  def test_4010
+    m = nil
+    argv = %w( a b c )
+    assert_nothing_raised{
+      main(argv.dup) {
+        argument('zero_or_more'){ arity '*' }
+        run{ m = self }
+      }
+    }
+    assert m.param['zero_or_more'].values == argv
+  end 
+  def test_4020
+    m = nil
+    argv = %w( a b c )
+    assert_nothing_raised{
+      main(argv.dup) {
+        argument('one_or_more'){ arity -2 }
+        run{ m = self }
+      }
+    }
+    assert m.param['one_or_more'].values == argv
+  end 
+  def test_4030
+    m = nil
+    argv = %w( a b c )
+    assert_nothing_raised{
+      main(argv.dup) {
+        argument('two_or_more'){ arity -3 }
+        run{ m = self }
+      }
+    }
+    assert m.param['two_or_more'].values == argv
+  end 
+  def test_4040
+    m = nil
+    argv = %w()
+    assert_nothing_raised{
+      main(argv.dup) {
+        argument('zero_or_more'){ arity -1 }
+        run{ m = self }
+      }
+    }
+    assert m.param['zero_or_more'].values == argv
+  end 
+  def test_4050
+    m = nil
+    argv = %w()
+    assert_raises(Main::Parameter::NotGiven){
+      main(argv.dup) {
+        argument('one_or_more'){ arity -2 }
+        run{ m = self }
+      }
+    }
+  end 
+  def test_4060
+    m = nil
+    argv = %w( a )
+    assert_raises(Main::Parameter::Arity){
+      main(argv.dup) {
+        argument('two_or_more'){ arity -3 }
+        run{ m = self }
+      }
+    }
+  end 
+  def test_4070
+    m = nil
+    argv = %w( a )
+    assert_raises(Main::Parameter::Arity){
+      main(argv.dup) {
+        argument('two_or_more'){ arity -4 }
+        run{ m = self }
+      }
+    }
+  end 
+#
+# sub-command/mode functionality
+#
+  def test_4080
+    m = nil
+    argv = %w( a b )
+    assert_nothing_raised{
+      main(argv.dup) {
+        mode 'a' do
+          argument 'b'
+          run{ m = self }
+        end
+      }
+    }
+    assert m.param['b'].value == 'b'
+  end 
+  def test_4090
+    m = nil
+    argv = %w( a b c )
+    assert_nothing_raised{
+      main(argv.dup) {
+        mode 'a' do
+          mode 'b' do
+            argument 'c'
+            run{ m = self }
+          end
+        end
+      }
+    }
+    assert m.param['c'].value == 'c'
+  end 
+
 end