main 2.8.0 → 2.8.1

data/gemspec.rb

@@ -21,11 +21,10 @@ Gem::Specification::new do |spec|
   spec.executables = shiteless[Dir::glob("bin/*")].map{|exe| File::basename exe}
   
   spec.require_path = "lib" 
-  spec.autorequire = lib
 
   spec.has_rdoc = File::exist? "doc" 
   spec.test_suite_file = "test/#{ lib }.rb" if File::directory? "test"
-  spec.add_dependency 'attributes', '>= 5.0.0'
+  spec.add_dependency 'fattr', '>= 1.0.3'
   spec.add_dependency 'arrayfields', '>= 4.5.0'
 
   spec.extensions << "extconf.rb" if File::exists? "extconf.rb"
@@ -33,4 +32,5 @@ Gem::Specification::new do |spec|
   spec.author = "Ara T. Howard"
   spec.email = "ara.t.howard@gmail.com"
   spec.homepage = "http://codeforpeople.com/lib/ruby/#{ lib }/"
+  spec.rubyforge_project = 'codeforpeople'
 end

data/lib/main.rb

@@ -28,12 +28,12 @@ module Main
     42
   end
 
-  require 'attributes'
+  require 'fattr'
   begin
-    version = Attributes.version
-    raise unless version[%r/^5\./] 
+    version = Fattr.version
+    raise unless version[%r/^1\./] 
   rescue
-    abort "main requires attributes >= 5.0.0 - gem install attributes"
+    abort "main requires fattrs >= 1.0.3 - gem install fattr"
   end
 
   require 'arrayfields'

data/lib/main/base.rb

@@ -49,9 +49,9 @@ module Main
         end
       end
 
-      def self.inheritable_attribute name, &block
+      def self.inheritable_fattr name, &block
         block ||= lambda{}
-        attribute( name ){ 
+        fattr( name ){ 
           catch :value do
             if parent?
               value = parent.send name 
@@ -68,34 +68,34 @@ module Main
         } 
       end
 
-    # attributes
-      attribute( 'name' ){ File.basename $0 } 
-      attribute( 'synopsis' ){ Usage.default_synopsis(self) }
-      attribute( 'description' )
-      attribute( 'usage' ){ Usage.default_usage self } 
-      attribute( 'modes' ){ Mode.list }
-      attribute( 'mode_definitions' ){ Array.new }
-      attribute( 'mode_name' ){ 'main' }
-      attribute( 'parent' ){ nil }
-      attribute( 'children' ){ Set.new }
-
-      attribute( 'program' ){ File.basename $0 } 
-      attribute( 'author' )
-      attribute( 'version' )
-      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_warn' ){ EXIT_WARN } 
-      inheritable_attribute( 'parameters' ){ Parameter::List[] }
-      inheritable_attribute( 'can_has_hash' ){ Hash.new }
-      inheritable_attribute( 'mixin_table' ){ Hash.new }
-
-    # override a few attributes
+    # fattrs
+      fattr( 'name' ){ File.basename $0 } 
+      fattr( 'synopsis' ){ Usage.default_synopsis(self) }
+      fattr( 'description' )
+      fattr( 'usage' ){ Usage.default_usage self } 
+      fattr( 'modes' ){ Mode.list }
+      fattr( 'mode_definitions' ){ Array.new }
+      fattr( 'mode_name' ){ 'main' }
+      fattr( 'parent' ){ nil }
+      fattr( 'children' ){ Set.new }
+
+      fattr( 'program' ){ File.basename $0 } 
+      fattr( 'author' )
+      fattr( 'version' )
+      fattr( 'stdin' ){ $stdin } 
+      fattr( 'stdout' ){ $stdout } 
+      fattr( 'stderr' ){ $stderr } 
+      fattr( 'logger' ){ stderr } 
+      fattr( 'logger_level' ){ Logger::INFO } 
+      fattr( 'exit_status' ){ EXIT_SUCCESS } 
+      fattr( 'exit_success' ){ EXIT_SUCCESS } 
+      fattr( 'exit_failure' ){ EXIT_FAILURE } 
+      fattr( 'exit_warn' ){ EXIT_WARN } 
+      inheritable_fattr( 'parameters' ){ Parameter::List[] }
+      inheritable_fattr( 'can_has_hash' ){ Hash.new }
+      inheritable_fattr( 'mixin_table' ){ Hash.new }
+
+    # override a few fattrs
       def mode_name=(value)
         @mode_name = Mode.new value
       end
@@ -263,20 +263,20 @@ module Main
     end
     extend DSL
 
-    attribute 'argv'
-    attribute 'env'
-    attribute 'params'
-    attribute 'logger'
-    attribute 'stdin'
-    attribute 'stdout'
-    attribute 'stderr'
+    fattr 'argv'
+    fattr 'env'
+    fattr 'params'
+    fattr 'logger'
+    fattr 'stdin'
+    fattr 'stdout'
+    fattr 'stderr'
 
     %w( 
       program name synopsis description author version
       exit_status exit_success exit_failure exit_warn
       logger_level
       usage
-    ).each{|a| attribute(a){ self.class.send a}}
+    ).each{|a| fattr(a){ self.class.send a}}
 
     %w( parameters param ).each do |dst|
       alias_method "#{ dst }", "params"
@@ -438,7 +438,7 @@ module Main
     def modes
       self.class.modes
     end
-    attribute 'mode'
+    fattr 'mode'
 
     def help! status = 0
       print usage.to_s

data/lib/main/parameter.rb

@@ -2,7 +2,7 @@ module Main
   class Parameter
     class Error < StandardError
       include Softspoken
-      attribute 'wrapped'
+      fattr 'wrapped'
     end
     class Arity < Error; end
     class NotGiven < Arity; end
@@ -54,25 +54,25 @@ module Main
       end
     end
 
-    attribute 'type'
-    attribute 'names'
-    attribute 'abbreviations'
-    attribute 'argument'
-    attribute 'given'
-    attribute 'cast'
-    attribute 'validate'
-    attribute 'description'
-    attribute 'synopsis'
-    attribute('values'){ [] }
-    attribute('defaults'){ [] }
-    attribute('examples'){ [] }
-
-    attribute 'arity' => 1
-    attribute 'required' => false
-
-    attribute 'error_handler_before'
-    attribute 'error_handler_instead'
-    attribute 'error_handler_after'
+    fattr 'type'
+    fattr 'names'
+    fattr 'abbreviations'
+    fattr 'argument'
+    fattr 'given'
+    fattr 'cast'
+    fattr 'validate'
+    fattr 'description'
+    fattr 'synopsis'
+    fattr('values'){ [] }
+    fattr('defaults'){ [] }
+    fattr('examples'){ [] }
+
+    fattr 'arity' => 1
+    fattr 'required' => false
+
+    fattr 'error_handler_before'
+    fattr 'error_handler_instead'
+    fattr 'error_handler_after'
 
     def initialize name, *names, &block
       @names = Cast.list_of_string name, *names
@@ -248,9 +248,9 @@ puts
     end
 
     class Argument < Parameter
-      attribute 'required' => true
+      fattr 'required' => true
 
-      attribute 'synopsis' do
+      fattr 'synopsis' do
         label = name
         op = required ? "->" : "~>"
         value = defaults.size > 0 ? "#{ name }=#{ defaults.join ',' }" : name 
@@ -260,10 +260,10 @@ puts
     end
 
     class Option < Parameter
-      attribute 'required' => false
-      attribute 'arity' => 0
+      fattr 'required' => false
+      fattr 'arity' => 0
 
-      attribute 'synopsis' do
+      fattr 'synopsis' do
         long, *short = names
         value = cast || name 
         rhs = argument ? (argument == :required ? "=#{ name }" : "=[#{ name }]") : nil 
@@ -280,10 +280,10 @@ puts
     end
 
     class Keyword < Parameter
-      attribute 'required' => false
-      attribute 'argument' => :required 
+      fattr 'required' => false
+      fattr 'argument' => :required 
 
-      attribute 'synopsis' do
+      fattr 'synopsis' do
         label = "#{ name }=#{ name }"
         op = required ? "->" : "~>"
         value = defaults.size > 0 ? "#{ name }=#{ defaults.join ',' }" : name 
@@ -293,9 +293,9 @@ puts
     end
 
     class Environment < Parameter
-      attribute 'argument' => :required 
+      fattr 'argument' => :required 
 
-      attribute 'synopsis' do
+      fattr 'synopsis' do
         label = "env[#{ name }]=#{ name }"
         op = required ? "->" : "~>"
         value = defaults.size > 0 ? "#{ name }=#{ defaults.join ',' }" : name 
@@ -523,21 +523,21 @@ puts
         @param = param
       end
 
-      def attribute a = nil, &block
+      def fattr a = nil, &block
         name = param.name
         a ||= name
-        b = attribute_block_for name, &block 
-        Main.current.module_eval{ attribute *a, &b }
+        b = fattr_block_for name, &block 
+        Main.current.module_eval{ fattr *a, &b }
       end
+      alias_method 'attribute', 'fattr'
 
-      def attribute_block_for name, &block
-        #block ||= lambda{|param| param.arity == 1 ? param.value : param.values}
+      def fattr_block_for name, &block
         block ||= lambda{|param| param.arity.abs <= 1 ? param.value : param.values }
         lambda{ block.call self.param[name] }
       end
 
       def attr *a, &b
-        attribute *a, &b
+        fattr *a, &b
       end
 
       def example *list
@@ -663,6 +663,12 @@ puts
         self.fields = []
         extend BoundsCheck
       end
+
+      def to_options
+        (hash = self.to_hash ).keys.each { |key| hash[key] = hash[key].value }
+        return hash
+      end
+
       module BoundsCheck
         def [] *a, &b
           p = super

data/lib/main/softspoken.rb

@@ -1,7 +1,7 @@
 module Main
   module Softspoken
     class << self
-      attribute 'softspoken' => true
+      fattr 'softspoken' => true
       def on!() softspoken(true) end 
       def off!() softspoken(false) end 
       def === other

data/lib/main/stdext.rb

@@ -13,7 +13,7 @@ module SaneAbort
   def abort message = nil
     if message
       message = message.to_s
-      message.singleton_class{ attribute 'abort' => true }
+      message.singleton_class{ fattr 'abort' => true }
       STDERR.puts message
     end
     exit 1
@@ -23,7 +23,7 @@ end
   def abort message = nil
     if message
       message = message.to_s
-      message.singleton_class{ attribute 'abort' => true }
+      message.singleton_class{ fattr 'abort' => true }
       STDERR.puts message
     end
     exit 1
@@ -31,7 +31,7 @@ end
   def Process.abort message = nil
     if message
       message = message.to_s
-      message.singleton_class{ attribute 'abort' => true }
+      message.singleton_class{ fattr 'abort' => true }
       STDERR.puts message
     end
     exit 1

data/lib/main/usage.rb

@@ -1,8 +1,8 @@
 module Main
   class Usage < ::Array
-    attribute 'chunkname'
-    attribute 'upcase'
-    attribute 'eos'
+    fattr 'chunkname'
+    fattr 'upcase'
+    fattr 'eos'
 
     def initialize opts={} 
       self.fields=[]
@@ -182,7 +182,7 @@ module Main
       alias_method "default", "default_usage"
     end
 
-    attribute "main"
+    fattr "main"
 
     def set_defaults!
       usage = self

data/samples/g.rb

@@ -0,0 +1,10 @@
+require 'main'
+
+ARGV.replace %w( 42 ) if ARGV.empty?
+
+Main {
+  argument( 'foo' )
+  option( 'bar' )
+
+  run { puts "This is what to_options produces: #{params.to_options.inspect}" }
+}

data/test/main.rb

@@ -8,9 +8,9 @@ require 'test/unit'
 require 'main'
 
 class T < Test::Unit::TestCase
-  attribute 'status'
-  attribute 'logger'
-  attribute 'error'
+  fattr 'status'
+  fattr 'logger'
+  fattr 'error'
 
   def setup
     @status = nil 

metadata

@@ -1,35 +1,44 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.4
-specification_version: 1
 name: main
 version: !ruby/object:Gem::Version 
-  version: 2.8.0
-date: 2007-12-23 00:00:00 -07:00
-summary: main
-require_paths: 
-- lib
-email: ara.t.howard@gmail.com
-homepage: http://codeforpeople.com/lib/ruby/main/
-rubyforge_project: 
-description: 
-autorequire: main
-default_executable: 
-bindir: bin
-has_rdoc: false
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
-  version: 
+  version: 2.8.1
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
 - Ara T. Howard
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-07-11 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: fattr
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.3
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: arrayfields
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 4.5.0
+    version: 
+description: 
+email: ara.t.howard@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
 files: 
-- a.rb
 - gemspec.rb
 - gen_readme.rb
 - install.rb
@@ -47,6 +56,7 @@ files:
 - lib/main/usage.rb
 - lib/main/util.rb
 - lib/main.rb
+- main-2.8.1.gem
 - README
 - samples
 - samples/a.rb
@@ -55,38 +65,35 @@ files:
 - samples/d.rb
 - samples/e.rb
 - samples/f.rb
+- samples/g.rb
 - test
 - test/main.rb
-- test/main.rb.bak
 - TODO
-test_files: 
-- test/main.rb
+has_rdoc: false
+homepage: http://codeforpeople.com/lib/ruby/main/
+post_install_message: 
 rdoc_options: []
 
-extra_rdoc_files: []
-
-executables: []
-
-extensions: []
-
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 requirements: []
 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: attributes
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Version::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 5.0.0
-    version: 
-- !ruby/object:Gem::Dependency 
-  name: arrayfields
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Version::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 4.5.0
-    version: 
+rubyforge_project: codeforpeople
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: main
+test_files: 
+- test/main.rb

data/a.rb

@@ -1,7 +0,0 @@
-require 'main'
-
-Main {
-  option('foo'){
-    examples
-  }
-}

data/test/main.rb.bak

@@ -1,767 +0,0 @@
-$:.unshift '.'
-$:.unshift './lib'
-$:.unshift '..'
-$:.unshift '../lib'
-
-require 'stringio'
-require 'test/unit'
-require 'main'
-
-class T < Test::Unit::TestCase
-  attribute 'status'
-  attribute 'logger'
-  attribute 'error'
-
-  def setup
-    @status = nil 
-    @logger = Logger.new StringIO.new
-    @error = nil
-  end
-
-  def teardown
-  end
-
-  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}
-
-    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
-
-      define_method :handle_throw do |*a|
-      end
-    end
-
-    main = klass.new argv, env
-
-    main.logger = @logger
-
-    begin
-      main.run
-    ensure
-      this.status ||= main.exit_status
-    end
-
-    main
-  end
-
-#
-# basic test
-#
-  def test_0000
-    assert_nothing_raised{
-      main{
-        def run() end
-      }
-    }
-  end
-  def test_0010
-    x = nil
-    assert_nothing_raised{
-      main{
-        define_method(:run){ x = 42 }
-      }
-    }
-    assert x == 42
-  end
-#
-# exit status
-#
-  def test_0020
-    assert_nothing_raised{
-      main{
-        def run() end
-      }
-    }
-    assert status == 0
-  end
-  def test_0030
-    assert_nothing_raised{
-      main{
-        def run() exit 42 end
-      }
-    }
-    assert status == 42
-  end
-  def test_0040
-    assert_nothing_raised{
-      fork{
-        main{
-          def run() exit! 42 end
-        }
-      }
-      Process.wait
-      assert $?.exitstatus == 42 
-    }
-  end
-  def test_0050
-    assert_nothing_raised{
-      main{
-        def run() exit 42 end
-      }
-    }
-    assert status == 42 
-  end
-  def test_0060
-    assert_nothing_raised{
-      main{
-        def run() raise ArgumentError end
-      }
-    }
-    assert status == 1
-  end
-  def test_0060
-    assert_raises(RuntimeError){
-      main{
-        def run() exit_status 42; raise end
-      }
-    }
-    assert status == 42 
-  end
-  def test_0070
-    assert_raises(ArgumentError){
-      main{
-        def run() exit_status 42; raise ArgumentError end
-      }
-    }
-    assert status == 42 
-  end
-#
-# parameter parsing 
-#
-  def test_0080
-    p = nil
-    assert_raises(Main::Parameter::NotGiven){
-      main(){
-        argument 'foo'
-        define_method('run'){ }
-      }
-    }
-  end
-  def test_0090
-    p = nil
-    m = nil
-    argv = %w[ 42 ]
-    given = nil
-    assert_nothing_raised{
-      main(argv.dup){
-        argument '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
-    argv = %w[]
-    given = nil
-    assert_nothing_raised{
-      main(argv){
-        p = argument('foo'){ optional }
-        define_method('run'){ p = param['foo'] }
-      }
-    }
-    assert p.optional?
-    assert !p.required?
-    assert p.value == nil 
-    assert p.values == [] 
-    assert !p.given?
-  end
-  def test_0101
-    p = nil
-    argv = %w[]
-    given = nil
-    assert_nothing_raised{
-      main(argv){
-        p = argument('foo'){ required false }
-        define_method('run'){ p = param['foo'] }
-      }
-    }
-    assert p.optional?
-    assert !p.required?
-    assert p.value == nil 
-    assert p.values == [] 
-    assert !p.given?
-  end
-  def test_0110
-    p = nil
-    argv = %w[ --foo ]
-    assert_nothing_raised{
-      main(argv){
-        option('foo'){ required }
-        define_method('run'){ p = param['foo'] }
-      }
-    }
-    assert p.value == true 
-    assert p.values ==[true] 
-    assert p.given?
-  end
-  def test_0120
-    p = nil
-    argv = [] 
-    assert_nothing_raised{
-      main(argv){
-        option 'foo'
-        define_method('run'){ p = param['foo'] }
-      }
-    }
-    assert p.value == nil 
-    assert p.values == [] 
-    assert !p.given?
-  end
-  def test_0130
-    p = nil 
-    assert_nothing_raised{
-      main(%w[--foo=42]){
-        option('foo'){ required; argument_required }
-        define_method('run'){ p = param['foo']}
-      }
-    }
-    assert p.required?
-    assert p.argument_required?
-    assert !p.optional?
-  end
-  def test_0131
-    assert_raises(Main::Parameter::NotGiven){
-      main(){
-        option('foo'){ required; argument_required }
-        define_method('run'){}
-      }
-    }
-  end
-  def test_0140
-    assert_raises(Main::Parameter::MissingArgument){
-      main(['--foo']){
-        option('foo'){ required; argument_required }
-        define_method('run'){}
-      }
-    }
-  end
-  def test_0150
-    param = nil
-    assert_nothing_raised{
-      main(%w[--foo=42 --bar=42.0 --foobar=true --barfoo=false --uri=http://foo --x=s]){
-        option('foo'){ 
-          required
-          argument_required
-          cast :int
-        }
-        option('bar'){ 
-          argument_required
-          cast :float
-        }
-        option('foobar'){ 
-          argument_required
-          cast :bool
-        }
-        option('barfoo'){ 
-          argument_required
-          cast :string
-        }
-        option('uri'){ 
-          argument_required
-          cast :uri
-        }
-        option('x'){ 
-          argument_required
-          cast{|x| x.to_s.upcase}
-        }
-        define_method('run'){ param = params }
-      }
-    }
-    assert param['foo'].value == 42
-    assert param['bar'].value == 42.0
-    assert param['foobar'].value == true 
-    assert param['barfoo'].value == 'false' 
-    assert param['uri'].value == URI.parse('http://foo') 
-    assert param['x'].value == 'S' 
-  end
-  def test_0160
-    p = nil 
-    assert_nothing_raised{
-      main(%w[--foo=42]){
-        option('foo'){ 
-          required
-          argument_required
-          cast :int
-          validate{|x| x == 42}
-        }
-        define_method('run'){ p = param['foo']}
-      }
-    }
-    assert p.value == 42
-    assert p.required?
-    assert p.argument_required?
-    assert !p.optional?
-  end
-  def test_0170
-    assert_raises(Main::Parameter::InValid){
-      main(%w[--foo=40]){
-        option('foo'){ 
-          required
-          argument_required
-          cast :int
-          validate{|x| x == 42}
-        }
-        define_method('run'){ }
-      }
-    }
-  end
-  def test_0180
-    assert_nothing_raised{
-      main(%w[--foo=42]){
-        option('--foo=foo'){ 
-          required
-          # argument_required
-          cast :int
-          validate{|x| x == 42}
-        }
-        define_method('run'){ }
-      }
-    }
-  end
-  def test_0190
-    assert_raises(Main::Parameter::MissingArgument){
-      main(%w[--foo]){
-        option('--foo=foo'){ }
-        define_method('run'){ }
-      }
-    }
-  end
-  def test_0200
-    p = nil
-    assert_nothing_raised{
-      main(%w[--foo]){
-        option('--foo=[foo]'){ }
-        define_method('run'){ p = param['foo'] }
-      }
-    }
-    assert p.value == true
-  end
-  def test_0210
-    p = nil
-    assert_nothing_raised{
-      main(%w[--foo=42]){
-        option('--foo=[foo]'){
-          cast :int
-          validate{|x| x == 42}
-        }
-        define_method('run'){ p = param['foo'] }
-      }
-    }
-    assert p.value == 42 
-  end
-  def test_0220
-    p = nil
-    assert_nothing_raised{
-      main(%w[--foo=40 --foo=2]){
-        option('--foo=foo'){
-          arity 2
-          cast :int
-          validate{|x| x == 40 or x == 2}
-        }
-        define_method('run'){ p = param['foo'] }
-      }
-    }
-    assert p.value == 40
-    assert p.values == [40,2]
-  end
-  def test_0230
-    p = nil
-    assert_nothing_raised{
-      main(%w[foo=42]){
-        keyword('foo'){
-          cast :int
-          validate{|x| x == 42}
-        }
-        define_method('run'){ p = param['foo'] }
-      }
-    }
-    assert p.value == 42
-  end
-  def test_0240
-    foo = nil
-    bar = nil
-    assert_nothing_raised{
-      main(%w[foo= bar]){
-        keyword 'foo'
-        keyword 'bar'
-        define_method('run'){ 
-          foo = param['foo'] 
-          bar = param['bar'] 
-        }
-      }
-    }
-    assert foo.value == ''
-    assert bar.value == nil 
-  end
-  def test_0250
-    foo = nil
-    bar = nil
-    assert_nothing_raised{
-      main(%w[foo=40 bar=2]){
-        keyword('foo'){
-          cast :int
-        }
-        keyword('bar'){
-          cast :int
-        }
-        define_method('run'){ 
-          foo = param['foo'] 
-          bar = param['bar'] 
-        }
-      }
-    }
-    assert foo.value == 40 
-    assert bar.value == 2 
-  end
-  def test_0260
-    foo = nil
-    bar = nil
-    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'
-
-        define_method('run'){ 
-          foo = param['foo'] 
-          bar = param['bar'] 
-          foobar = param['foobar'] 
-        }
-      }
-    }
-    assert foo.value == 40 
-    assert foo.values == [40, 42]
-    assert bar.value == 2 
-    assert foobar.value == 'foobar' 
-  end
-  def test_0270
-    foo = nil
-    assert_nothing_raised{
-      main([], 'foo' => '42'){
-        env('foo'){ cast :int }
-        define_method('run'){ 
-          foo = param['foo'] 
-        }
-      }
-    }
-    assert foo.value == 42 
-  end
-#
-# usage
-#
-  def test_0280
-    assert_nothing_raised{
-      u = Main::Usage.new
-    }
-  end
-  def test_0290
-    assert_nothing_raised{
-      u = Main::Usage.default Main.create
-    }
-  end
-  def test_0300
-    assert_nothing_raised{
-      chunk = <<-txt
-        a
-        b
-        c
-      txt
-      assert Main::Util.unindent(chunk) == "a\nb\nc"
-      chunk = <<-txt
-        a
-          b
-           c
-      txt
-      assert Main::Util.unindent(chunk) == "a\n  b\n   c"
-    }
-  end
-  def test_0310
-    assert_nothing_raised{
-      u = Main::Usage.new
-      u[:name] = 'foobar'
-      assert u[:name] = 'foobar'
-      assert u['name'] = 'foobar'
-    }
-  end
-  def test_0320
-    assert_nothing_raised{
-      u = Main::Usage.new
-      u[:name] = 'foobar'
-        assert u[:name] == 'foobar'
-        assert u['name'] == 'foobar'
-      u[:name2] = 'barfoo'
-        assert u[:name] == 'foobar'
-        assert u['name'] == 'foobar'
-        assert u[:name2] == 'barfoo'
-        assert u['name2'] == 'barfoo'
-      u.delete_at :name
-        assert u[:name] == nil
-        assert u['name'] == nil
-        assert u[:name2] == 'barfoo'
-        assert u['name2'] == 'barfoo'
-      u.delete_at :name2
-        assert u[:name] == nil
-        assert u['name'] == nil
-        assert u[:name2] == nil
-        assert u['name2'] == nil
-    }
-  end
-#
-# io redirection
-#
-  class ::Object
-    require 'tempfile'
-    def infile buf
-      t = Tempfile.new rand.to_s
-      t << buf
-      t.close
-      open t.path, 'r+'
-    end
-    def outfile
-      t = Tempfile.new rand.to_s
-      t.close
-      open t.path, 'w+'
-    end
-  end
-  def test_0330
-    s = "foo\nbar\n"
-    sio = StringIO.new s 
-    $buf = nil
-    assert_nothing_raised{
-      main{
-        stdin sio
-        def run
-          $buf = STDIN.read
-        end
-      }
-    }
-    assert $buf == s
-  end
-  def test_0340
-    s = "foo\nbar\n"
-    $sio = StringIO.new s 
-    $buf = nil
-    assert_nothing_raised{
-      main{
-        def run
-          self.stdin = $sio
-          $buf = STDIN.read
-        end
-      }
-    }
-    assert $buf == s
-  end
-  def test_0350
-    s = "foo\nbar\n"
-    $buf = nil
-    assert_nothing_raised{
-      main{
-        stdin infile(s) 
-        def run
-          $buf = STDIN.read
-        end
-      }
-    }
-    assert $buf == s
-  end
-  def test_0360
-    sout = outfile
-    assert_nothing_raised{
-      main{
-        stdout sout 
-        def run
-          puts 42
-        end
-      }
-    }
-    assert test(?e, sout.path)
-    assert IO.read(sout.path) == "42\n" 
-  end
-  def test_0370
-    m = nil
-    assert_nothing_raised{
-      m = main{
-        stdout StringIO.new 
-        def run
-          puts 42
-        end
-      }
-    }
-    assert m
-    assert_nothing_raised{ m.stdout.rewind }
-    assert m.stdout.read == "42\n" 
-  end
-#
-# main ctor
-#
-  def test_0380
-    argv = %w( a b c )
-    $argv = nil
-    assert_nothing_raised{
-      main(argv){
-        def run
-          $argv = @argv
-        end
-      }
-    }
-    assert argv == $argv 
-  end
-  def test_0390
-    argv = %w( a b c )
-    env = {'key' => 'val', 'foo' => 'bar'}
-    $argv = nil
-    $env = nil
-    assert_nothing_raised{
-      main(argv, env){
-        def run
-          $argv = @argv
-          $env = @env
-        end
-      }
-    }
-    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'){ optional; 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'){ optional; 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'){ optional; 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
-
-