main 0.0.1

data/lib/main/usage.rb

@@ -0,0 +1,138 @@
+module Main
+  class Usage < ::Array
+    attribute 'chunkname'
+    attribute 'upcase'
+    attribute 'eos'
+
+    def initialize opts={} 
+      self.fields=[]
+      self.chunkname = lambda{|chunkname| chunkname.to_s.strip.upcase}
+      self.upcase = true 
+      self.eos = "\n\n"
+      if opts.has_key?(:upcase) or opts.has_key?('upcase')
+        self.upcase = opts[:upcase] || opts['optcase']
+      end
+    end
+
+    def clear
+      super
+    ensure
+      fields.clear
+    end
+
+    def delete_at key
+      self[key] = nil
+    end
+    alias_method 'delete', 'delete_at'
+
+    def self.default_synopsis main
+      s = "#{ main.name }"
+
+      main.parameters.each do |p|
+        if p.type == :argument
+          if p.required?
+            s << " #{ p.name }"
+          else
+            s << " [#{ p.name }]"
+          end
+        end
+      end
+
+      main.parameters.each do |p|
+        if p.type == :keyword
+          if p.required?
+            s << " #{ p.name }=#{ p.name }"
+          else
+            s << " [#{ p.name }=#{ p.name }]"
+          end
+        end
+      end
+
+      n = 0
+      main.parameters.each do |p|
+        if p.type == :option
+          if p.required?
+            case p.argument
+              when :required
+                s << " --#{ p.name }=#{ p.name }"
+              when :optional
+                s << " --#{ p.name }=[#{ p.name }]"
+              else
+                s << " --#{ p.name }"
+            end
+          else
+            n += 1
+          end
+        end
+      end
+      if n > 0
+        s << " [options]+"
+      end
+
+      s
+    end
+
+    def self.default_usage main
+      usage = new
+
+    # name
+      usage['name'] =
+        if main.version?
+          "#{ main.name } v#{ main.version }"
+        else
+          "#{ main.name }"
+        end
+
+    # synopsis
+      usage['synopsis'] = main.synopsis
+
+    # description
+      usage['description'] = main.description if main.description?
+
+    # parameters
+      arguments = main.parameters.select{|p| p.type == :argument}
+      keywords = main.parameters.select{|p| p.type == :keyword}
+      options = main.parameters.select{|p| p.type == :option}
+      environment = main.parameters.select{|p| p.type == :environment}
+
+      help, nothelp = options.partition{|p| p.name == 'help'}
+      options = nothelp + help
+
+      parameters = arguments + keywords + options + environment
+
+      s =
+        parameters.map do |p|
+          ps = ''
+          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"
+          end
+          ps
+        end.join("\n")
+      usage['parameters'] = s 
+
+    # author
+      usage['author'] = main.author if main.author?
+
+      usage
+    end
+    class << self
+      alias_method "default", "default_usage"
+    end
+
+    def to_s
+      s = '' 
+      each_pair do |key, value|
+        up, down = key.to_s.upcase, key.to_s.downcase
+        if value
+          s << (upcase ? up : down) << "\n" 
+          s << Util.indent(Util.unindent(value.to_s), 2)
+          s << eos 
+        end
+      end
+      s
+    end
+  end
+end

data/lib/main/util.rb

@@ -0,0 +1,91 @@
+module Main
+  module Util
+    module ClassMethods
+    end
+
+    module InstanceMethods
+    end
+
+    module Methods
+      def mcp obj
+        Marshal.load(Marshal.dump(obj))
+      end
+
+      def indent chunk, n = 2
+        lines = chunk.split %r/\n/
+        re = nil
+        s = ' ' * n
+        lines.map! do |line|
+          unless re
+            margin = line[%r/^\s*/]
+            re = %r/^#{ margin }/
+          end
+          line.gsub re, s 
+        end.join("\n")
+      end
+
+      def unindent chunk
+        lines = chunk.split %r/\n/
+        indent = nil
+        re = %r/^/ 
+        lines.map! do |line|
+          unless indent 
+            indent = line[%r/^\s*/]
+            re = %r/^#{ indent }/
+          end
+          line.gsub re, ''
+        end.join("\n")
+      end
+
+      def columnize buf, opts = {}
+        width = Util.getopt 'width', opts, 80
+        indent = Util.getopt 'indent', opts
+        indent = Fixnum === indent ? (' ' * indent) : "#{ indent }"
+        column = []
+        words = buf.split %r/\s+/o
+        row = "#{ indent }"
+        while((word = words.shift))
+          if((row.size + word.size) < (width - 1))
+            row << word
+          else
+            column << row
+            row = "#{ indent }"
+            row << word
+          end
+          row << ' ' unless row.size == (width - 1)
+        end
+        column << row unless row.strip.empty?
+        column.join "\n"
+      end
+
+      def getopt opt, hash, default = nil
+        keys = opt.respond_to?('each') ? opt : [opt]
+
+        keys.each do |key|
+          return hash[key] if hash.has_key? key
+          key = "#{ key }"
+          return hash[key] if hash.has_key? key
+          key = key.intern
+          return hash[key] if hash.has_key? key
+        end
+
+        return default
+      end
+    end
+
+    BLESS = lambda do |other|
+      other.module_eval{
+        include Methods
+        include InstanceMethods
+        extend Methods
+        extend ClassMethods
+      }
+    end
+
+    def self.included other
+      BLESS[ other ]
+    end
+
+    BLESS[ self ]
+  end
+end

data/samples/a.rb

@@ -0,0 +1,17 @@
+require 'main'
+
+ARGV.replace %w( 42 ) if ARGV.empty?
+
+Main {
+  argument('foo'){
+    required                    # this is the default
+    cast :int                   # value cast to Fixnum
+    validate{|foo| foo == 42}   # raises error in failure case 
+    description 'the foo param' # shown in --help
+  }
+
+  def run
+    p params['foo'].given?
+    p params['foo'].value
+  end
+}

data/samples/b.rb

@@ -0,0 +1,17 @@
+require 'main'
+
+ARGV.replace %w( 40 1 1 ) if ARGV.empty?
+
+Main {
+  argument('foo'){
+    arity 3                             # foo will given three times
+    cast :int                           # value cast to Fixnum
+    validate{|foo| [40,1].include? foo} # raises error in failure case 
+    description 'the foo param'         # shown in --help
+  }
+
+  def run
+    p params['foo'].given?
+    p params['foo'].values
+  end
+}

data/samples/c.rb

@@ -0,0 +1,21 @@
+require 'main'
+
+ARGV.replace %w( foo=40 foo=2 bar=false ) if ARGV.empty?
+
+Main {
+  keyword('foo'){
+    required  # by default keywords are not required
+    arity 2
+    cast :float
+  }
+  keyword('bar'){
+    cast :bool
+  }
+
+  def run
+    p params['foo'].given?
+    p params['foo'].values
+    p params['bar'].given?
+    p params['bar'].value
+  end
+}

data/samples/d.rb

@@ -0,0 +1,26 @@
+require 'main'
+
+ARGV.replace %w( --foo=40 -f2 ) if ARGV.empty?
+
+Main {
+  option('foo', 'f'){
+    required  # by default options are not required, we could use 'foo=foo'
+              # above as a shortcut
+    argument_required
+    arity 2
+    cast :float
+  }
+
+  option('bar=[bar]', 'b'){  # note shortcut syntax for optional args
+    # argument_optional      # we could also use this method
+    cast :bool
+    default false
+  }
+
+  def run
+    p params['foo'].given?
+    p params['foo'].values
+    p params['bar'].given?
+    p params['bar'].value
+  end
+}

data/test/main.rb

@@ -0,0 +1,523 @@
+$:.unshift '.'
+$:.unshift './lib'
+$:.unshift '..'
+$:.unshift '../lib'
+
+require 'stringio'
+require 'test/unit'
+require 'main'
+
+class T < Test::Unit::TestCase
+  attr 'status'
+
+  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}
+    main = nil
+    begin
+      main = Object::Main.new(&b)
+      main.logger = @logger
+      main.__run__
+    rescue Exception => e 
+      if SystemExit === e
+        @status = e.status
+      else
+        raise
+      end
+    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() raise end
+      }
+    }
+    assert status == 1
+  end
+  def test_0060
+    assert_nothing_raised{
+      main{
+        def run() raise ArgumentError end
+      }
+    }
+    assert status == 1
+  end
+  def test_0060
+    assert_nothing_raised{
+      main{
+        def run() exit_status 42; raise end
+      }
+    }
+    assert status == 42 
+  end
+  def test_0070
+    assert_nothing_raised{
+      main{
+        def run() exit_status 42; raise ArgumentError end
+      }
+    }
+    assert status == 42 
+  end
+#
+# 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){
+      main(){
+        argument 'foo'
+        define_method('run'){ }
+      }
+    }
+  end
+  def test_0090
+    p = nil
+    argv = %w[ 42 ]
+    given = nil
+    assert_nothing_raised{
+      main(argv){
+        argument 'foo'
+        define_method('run'){ p = param['foo'] }
+      }
+    }
+    assert p.value == argv.first 
+    assert p.values == argv
+    assert p.given?
+  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 
+    }
+  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
+
+end
+
+