trad-getopt 1.2.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 38d82a3905311e9231690786b724538d2701406265862291124d9b16cbd7e980
-  data.tar.gz: 7a4e1c88210f75a9363296ff6a62139ef8ca0c6c0c58faeb11d6d1602a264388
+  metadata.gz: 249a0240a2d24ecd2acdfbbeea4ea735b7741a111c3a3d73f73924ab7c69dbaa
+  data.tar.gz: 01f880cd85ba5f25295aa1a7edbe831217fd5f60e19e9c1ffa408e20cd2fe1ed
 SHA512:
-  metadata.gz: 37acd030e56c0040730efa270001cf71eee98efe293164700a12658ac00988f6042af636f0294c052907b2f9f5d917b324283e33d5187a1065b2ab2f1d9f69b7
-  data.tar.gz: db1ecf6e8daac1c477def3d23f4a519de128da70fd53c720194a1dec7c05a380cc4c0c5a4b0474f440e66a1481283879935806c42a3945e92d59d0572be04bf8
+  metadata.gz: ae31e46184189f798d898d7b78f4b2036f286ad373a537f4abb235909aea49c0475412c8b224947a911f633b251f32c1c6699a0dfd1f05ebb6f57d679a340078
+  data.tar.gz: 255ba6bab37aa24df764a7631f2519568dfbf68572d4e7d2aca67d1f8f9b5a84806871295fc95e4bdae5f0c7a4bf73a6fa65760f6c5275a8620ec5648cbb7298

data/test.rb

@@ -41,8 +41,8 @@ class Test_getopt < Test::Unit::TestCase
     got = getopt(av, "a")
     msg = $stderr.string
     $stderr = STDERR
-    assert_equal [:unknown_option, "x"], got
-    assert_equal "#{myname}: unknown option -x\n", msg
+    assert_equal [:unknown_option, "-x"], got
+    assert_equal "#{myname}: Unknown option: -x\n", msg
     assert_equal [], av
   end
 
@@ -66,8 +66,8 @@ class Test_getopt < Test::Unit::TestCase
     got = getopt(av, "a:")
     msg = $stderr.string
     $stderr = STDERR
-    assert_equal [:argument_required, "a"], got
-    assert_equal "#{myname}: option requires an argument -a\n", msg
+    assert_equal [:argument_required, "-a"], got
+    assert_equal "#{myname}: Option requires an argument: -a\n", msg
     assert_equal [], av
   end
 
@@ -94,7 +94,7 @@ class Test_getopt < Test::Unit::TestCase
     $stderr = StringIO.new
     got = getopt(av, "a::", optional_short:false)
     $stderr = STDERR
-    assert_equal [ :argument_required, "a"],  got
+    assert_equal [ :argument_required, "-a"],  got
   end
 
   # concatenation
@@ -148,8 +148,8 @@ class Test_getopt < Test::Unit::TestCase
     got = getopt(av, opts)
     msg = $stderr.string
     $stderr = STDERR
-    assert_equal [:unknown_option, "-"],  got
-    assert_equal "#{myname}: unknown option --\n", msg
+    assert_equal [:unknown_option, "--"],  got
+    assert_equal "#{myname}: Unknown option: --\n", msg
     assert_equal [], av
   end
 
@@ -164,8 +164,8 @@ class Test_getopt < Test::Unit::TestCase
     got = getopt(av, "a:")
     msg = $stderr.string
     $stderr = STDERR
-    assert_equal [:unknown_option, ":"],  got
-    assert_equal "#{myname}: unknown option -:\n", msg
+    assert_equal [:unknown_option, "-:"],  got
+    assert_equal "#{myname}: Unknown option: -:\n", msg
     assert_equal [], av
   end
 
@@ -177,7 +177,7 @@ class Test_getopt < Test::Unit::TestCase
     getopt(av, "a", error_message:true, program_name:"foo")
     msg = $stderr.string
     $stderr = STDERR
-    assert_equal "foo: unknown option -x\n", msg
+    assert_equal "foo: Unknown option: -x\n", msg
   end
 
   test "error_message" do
@@ -195,8 +195,8 @@ class Test_getopt < Test::Unit::TestCase
       getopt(av, "a", use_exception:true)
     rescue => ex
       assert_equal Getopt::UnknownOptionError, ex.class
-      assert_equal "x", ex.option
-      assert_equal "unknown option", ex.message
+      assert_equal "-x", ex.option
+      assert_equal "Unknown option", ex.message
     end
   end
 
@@ -206,8 +206,8 @@ class Test_getopt < Test::Unit::TestCase
       getopt(av, "a:", use_exception:true)
     rescue => ex
       assert_equal Getopt::ArgumentRequiredError, ex.class
-      assert_equal "a", ex.option
-      assert_equal "option requires an argument", ex.message
+      assert_equal "-a", ex.option
+      assert_equal "Option requires an argument", ex.message
     end
   end
 
@@ -233,7 +233,8 @@ class Test_getopt < Test::Unit::TestCase
     av = [ "-a", "" ]
     opts = "a:"
     $stderr = StringIO.new
-    assert_equal [:argument_required, "a"],  getopt(av, opts, allow_empty_optarg:false)
+    assert_equal [:argument_required, "-a"],
+                 getopt(av, opts, allow_empty_optarg:false)
     $stderr = STDERR
   end
 
@@ -241,7 +242,8 @@ class Test_getopt < Test::Unit::TestCase
     av = [ "--foo=" ]
     longopts = { "foo" => :required_argument }
     $stderr = StringIO.new
-    assert_equal [:argument_required, "foo"],  getopt(av, "", longopts, allow_empty_optarg:false)
+    assert_equal [:argument_required, "--foo"],
+                 getopt(av, "", longopts, allow_empty_optarg:false)
     $stderr = STDERR
   end
 
@@ -249,7 +251,8 @@ class Test_getopt < Test::Unit::TestCase
     av = [ "--foo", "" ]
     longopts = { "foo" => :required_argument }
     $stderr = StringIO.new
-    assert_equal [:argument_required, "foo"],  getopt(av, "", longopts, allow_empty_optarg:false)
+    assert_equal [:argument_required, "--foo"],
+                 getopt(av, "", longopts, allow_empty_optarg:false)
     $stderr = STDERR
   end
 
@@ -257,7 +260,8 @@ class Test_getopt < Test::Unit::TestCase
     av = [ "--foo=" ]
     longopts = { "foo" => :optional_argument }
     $stderr = StringIO.new
-    assert_equal [:argument_required, "foo"],  getopt(av, "", longopts, allow_empty_optarg:false)
+    assert_equal [:argument_required, "--foo"],
+                 getopt(av, "", longopts, allow_empty_optarg:false)
     $stderr = STDERR
   end
 
@@ -268,7 +272,7 @@ class Test_getopt < Test::Unit::TestCase
     opts = "a"
     assert_equal [ "a" ], getopt(av, opts)
     $stderr = StringIO.new
-    assert_equal [ :unknown_option, "-" ], getopt(av, opts)
+    assert_equal [ :unknown_option, "--" ], getopt(av, opts)
     $stderr = STDERR
   end
 
@@ -292,7 +296,7 @@ class Test_getopt < Test::Unit::TestCase
     assert_equal [ "a" ], getopt(av, opts, lopts)
     assert_equal [ "-" ], getopt(av, opts, lopts)
     $stderr = StringIO.new
-    assert_equal [ :unknown_option, "f" ], getopt(av, opts, lopts)
+    assert_equal [ :unknown_option, "-f" ], getopt(av, opts, lopts)
     $stderr = STDERR
   end
 
@@ -353,8 +357,8 @@ class Test_getopt < Test::Unit::TestCase
     got = getopt(av, "", lopts)
     msg = $stderr.string
     $stderr = STDERR
-    assert_equal [ :unknown_option, "bar" ], got
-    assert_equal "#{myname}: unknown option --bar\n", msg
+    assert_equal [ :unknown_option, "--bar" ], got
+    assert_equal "#{myname}: Unknown option: --bar\n", msg
   end
 
   test "no_argument" do
@@ -374,8 +378,8 @@ class Test_getopt < Test::Unit::TestCase
     got = getopt(av, "", lopts)
     msg = $stderr.string
     $stderr = STDERR
-    assert_equal [ :argument_given, "foo" ], got
-    assert_equal "#{myname}: option doesn't take an argument --foo\n", msg
+    assert_equal [ :argument_given, "--foo" ], got
+    assert_equal "#{myname}: Option doesn't take an argument: --foo\n", msg
   end
 
   test "no_argument, exception" do
@@ -387,8 +391,8 @@ class Test_getopt < Test::Unit::TestCase
       getopt(av, "", lopts, use_exception:true)
     rescue => ex
       assert_equal Getopt::ArgumentGivenError, ex.class
-      assert_equal "foo", ex.option
-      assert_equal "option doesn't take an argument", ex.message
+      assert_equal "--foo", ex.option
+      assert_equal "Option doesn't take an argument", ex.message
     end
   end
 
@@ -425,8 +429,8 @@ class Test_getopt < Test::Unit::TestCase
     got = getopt(av, "", lopts)
     msg = $stderr.string
     $stderr = STDERR
-    assert_equal [ :argument_required, "foo" ], got
-    assert_equal "#{myname}: option requires an argument --foo\n", msg
+    assert_equal [ :argument_required, "--foo" ], got
+    assert_equal "#{myname}: Option requires an argument: --foo\n", msg
   end
 
   test "required_argument, exception" do
@@ -438,8 +442,8 @@ class Test_getopt < Test::Unit::TestCase
       getopt(av, "", lopts, use_exception:true)
     rescue => ex
       assert_equal Getopt::ArgumentRequiredError, ex.class
-      assert_equal "foo", ex.option
-      assert_equal "option requires an argument", ex.message
+      assert_equal "--foo", ex.option
+      assert_equal "Option requires an argument", ex.message
     end
   end
 
@@ -513,8 +517,8 @@ class Test_getopt < Test::Unit::TestCase
     got = getopt(av, "", lopts)
     msg = $stderr.string
     $stderr = STDERR
-    assert_equal [ :ambiguous_option, "foo", ["foo1", "foo2"] ], got
-    assert_equal "#{myname}: ambiguos option (--foo1 --foo2) --foo\n", msg
+    assert_equal [ :ambiguous_option, ["--foo", [ "--foo1", "--foo2" ]]], got
+    assert_equal "#{myname}: Ambiguos option (--foo1,--foo2): --foo\n", msg
   end
 
   test "abbrev, ambiguous, exception" do
@@ -527,8 +531,8 @@ class Test_getopt < Test::Unit::TestCase
       getopt(av, "", lopts, use_exception:true)
     rescue => ex
       assert_equal Getopt::AmbiguousOptionError, ex.class
-      assert_equal "foo", ex.option
-      assert_equal "ambiguos option (--foo1 --foo2)", ex.message
+      assert_equal "--foo", ex.option
+      assert_equal "Ambiguos option (--foo1,--foo2)", ex.message
     end
   end
 
@@ -541,7 +545,64 @@ class Test_getopt < Test::Unit::TestCase
     got = getopt(av, "", lopts, abbreviation:false)
     msg = $stderr.string
     $stderr = STDERR
-    assert_equal [ :unknown_option, "fo" ], got
-    assert_equal "#{myname}: unknown option --fo\n", msg
+    assert_equal [ :unknown_option, "--fo" ], got
+    assert_equal "#{myname}: Unknown option: --fo\n", msg
   end
+
+  # Getopt.parse
+
+  test "Getopt.parse" do
+    av = [ "-a", "foo", "-bx", "-x",
+           "-c", "-cx",
+           "--noarg", "--reqarg=x",
+           "--oparg", "--oparg=x" ]
+    lopts = {
+      "noarg" => :no_argument,
+      "reqarg" => :required_argument,
+      "oparg" => :optional_argument,
+    }
+
+    got = Getopt.parse(av, "ab:c::", lopts)
+
+    assert_equal [ [ :short, :no_argument, "-a" ],
+                   "foo",
+                   [ :short, :required_argument, "-b", "x" ],
+                   [ :error, :unknown_option, "-x" ],
+                   [ :short, :optional_argument, "-c", nil ],
+                   [ :short, :optional_argument, "-c", "x" ],
+                   [ :long, :no_argument, "--noarg" ],
+                   [ :long, :required_argument, "--reqarg", "x" ],
+                   [ :long, :optional_argument, "--oparg", nil ],
+                   [ :long, :optional_argument, "--oparg", "x" ]],
+                 got
+  end
+
+  # Getopt.list
+
+  test "Getopt.list" do
+    av = [ "-a", "foo", "-bx", "-x",
+           "-c", "-cx",
+           "--noarg", "--reqarg=x",
+           "--oparg", "--oparg=x" ]
+    lopts = {
+      "noarg" => :no_argument,
+      "reqarg" => :required_argument,
+      "oparg" => :optional_argument,
+    }
+
+    got = Getopt.list(av, "ab:c::", lopts)
+
+    assert_equal [ "-a",
+                   "foo",
+                   %|-b "x"|,
+                   [ :error, :unknown_option, "-x" ],
+                   "-c",
+                   %|-c"x"|,
+                   "--noarg",
+                   %|--reqarg="x"|,
+                   "--oparg",
+                   %|--oparg="x"| ],
+                 got
+  end
+
 end

data/trad-getopt.rb

@@ -1,8 +1,6 @@
-# rather traditional getopt for Ruby
-
 module Getopt
 
-  VERSION = "1.2.1"
+  VERSION = "2.0.0"
 
   class GetoptError < StandardError
     def initialize option, message
@@ -11,48 +9,171 @@ module Getopt
     end
     attr_reader :option
   end
+
   class UnknownOptionError < GetoptError
-    def initialize option, message = "unknown option"
+    def initialize option, message = "Unknown option"
       super option, message
     end
   end
+
   class ArgumentRequiredError < GetoptError
-    def initialize option, message = "option requires an argument"
+    def initialize option, message = "Option requires an argument"
       super option, message
     end
   end
+
   class ArgumentGivenError < GetoptError
-    def initialize option, message = "option doesn't take an argument"
+    def initialize option, message = "Option doesn't take an argument"
       super option, message
     end
   end
+
   class AmbiguousOptionError < GetoptError
     def initialize option, message, candidates
-      message ||= "ambiguos option"
+      message ||= "Ambiguos option"
       @candidates = candidates
-      cands = candidates.collect { |c| "--#{c}" }.join " "
-      super option, "#{message} (#{cands})"
+      super option, %|#{message} (#{candidates.join ","})|
     end
     attr_reader :candidates
   end
+
+  def self.parse argv, opts, longopts,
+                 abbreviation: true,
+                 allow_empty_optarg: true,
+                 optional_short: true,
+                 permute: false,
+                 program_name: nil,
+                 stop_by_double_hyphen: true,
+                 use_exception: false
+                 # error_message:
+                 # parse:
+
+    xargv = []
+    loop {
+      ret = getopt argv, opts, longopts,
+                   error_message: false,
+                   parse: true,
+                   #
+                   abbreviation: abbreviation,
+                   allow_empty_optarg: allow_empty_optarg,
+                   optional_short: optional_short,
+                   permute: permute,
+                   program_name: program_name,
+                   stop_by_double_hyphen: stop_by_double_hyphen,
+                   use_exception: use_exception
+
+      if ret == :stop
+        xargv.push :stop
+        xargv.concat argv
+        break
+      elsif ret.nil?
+        xargv.push argv.shift
+      else
+        xargv.push ret
+      end
+
+      break if argv.empty?
+    }
+    xargv
+  end
+
+  def self.list argv, opts, longopts,
+                abbreviation: true,
+                allow_empty_optarg: true,
+                optional_short: true,
+                permute: false,
+                program_name: nil,
+                stop_by_double_hyphen: true,
+                use_exception: false
+                # error_message:
+                # parse:
+
+    xargv = []
+    loop {
+      ret = getopt argv, opts, longopts,
+                   error_message: false,
+                   parse: true,
+                   #
+                   abbreviation: abbreviation,
+                   allow_empty_optarg: allow_empty_optarg,
+                   optional_short: optional_short,
+                   permute: permute,
+                   program_name: program_name,
+                   stop_by_double_hyphen: stop_by_double_hyphen,
+                   use_exception: use_exception
+
+      if ret == :stop
+        xargv.push "--"
+        xargv.concat argv
+        break
+      end
+
+      if ret.nil?
+        xargv.push argv.shift
+      else
+        case ret.first
+        when :error
+          xargv.push ret
+        when :short
+          case ret[1]
+          when :no_argument
+            xargv.push ret[2]
+          when :required_argument
+	    xargv.push %|#{ret[2]} "#{ret[3]}"|
+          when :optional_argument
+            if ret[3]
+              xargv.push %|#{ret[2]}"#{ret[3]}"|
+            else
+              xargv.push ret[2]
+            end
+          end
+        when :long
+          case ret[1]
+          when :no_argument
+            xargv.push ret[2]
+          when :required_argument
+            xargv.push %|#{ret[2]}="#{ret[3]}"|
+          when :optional_argument
+            if ret[3]
+              xargv.push %|#{ret[2]}="#{ret[3]}"|
+            else
+              xargv.push ret[2]
+            end
+          end
+        end
+      end
+
+      break if argv.empty?
+    }
+    xargv
+  end
+
 end
 
-def getopt(argv, opts, longopts = nil,
-           abbreviation: true, allow_empty_optarg: true,
-           error_message: true, optional_short: true, permute: false,
-           program_name: nil, stop_by_double_hyphen: true,
-           use_exception: false)
+def getopt argv, opts, longopts = nil,
+           abbreviation: true,
+           allow_empty_optarg: true,
+           error_message: true,
+           optional_short: true,
+           parse: false,
+           permute: false,
+           program_name: nil,
+           stop_by_double_hyphen: true,
+           use_exception: false
+
   if permute
     args = []
     until op = getopt(argv, opts, longopts,
-                      permute: false,
                       abbreviation: abbreviation,
                       allow_empty_optarg: allow_empty_optarg,
                       error_message: error_message,
                       optional_short: optional_short,
+                      parse: parse,
+                      permute: false,
                       program_name: program_name,
                       stop_by_double_hyphen: stop_by_double_hyphen,
                       use_exception: use_exception)
+
       if argv.empty?
         argv.unshift(*args)
         return nil
@@ -67,68 +188,79 @@ def getopt(argv, opts, longopts = nil,
   program_name ||= File.basename $0
 
   arg = argv.shift
-  return nil if arg.nil?
+  return nil unless arg
+
   if arg == :getopt_short
     arg = argv.shift
-    return nil if arg.nil?
+    return nil unless arg
   else
     if arg == "-"
       argv.unshift "-"
       return nil
     end
     if stop_by_double_hyphen && arg == "--"
-      return nil
+      return parse ? :stop : nil
     end
+
     # long option
     if longopts && arg.index("--") == 0
+
       optopt, optarg = arg[2..-1].split "=", 2
 
       if abbreviation
-        abbr = longopts.collect { |o| o if o[0] =~ /^#{optopt}/ }.compact
+        abbr = longopts.collect {|o| o if o[0] =~ /^#{optopt}/ }.compact
         if abbr.empty?
-          raise Getopt::UnknownOptionError.new optopt
+          raise Getopt::UnknownOptionError.new "--#{optopt}"
         end
         if abbr.size == 1
           optopt = abbr.first.first
-        elsif exact = abbr.find { |a| a[0] == optopt }
+        elsif exact = abbr.find {|a| a[0] == optopt }
           optopt = exact.first
         else
-          cands = abbr.collect { |o| o.first }
-          raise Getopt::AmbiguousOptionError.new optopt, nil, cands
+          cands = abbr.collect {|o| "--#{o.first}" }
+          raise Getopt::AmbiguousOptionError.new "--#{optopt}", nil, cands
         end
       else
         unless longopts[optopt]
-          raise Getopt::UnknownOptionError.new optopt
+          raise Getopt::UnknownOptionError.new "--#{optopt}"
         end
       end
 
       case longopts[optopt]
       when :no_argument
         if optarg
-          raise Getopt::ArgumentGivenError.new optopt
+          raise Getopt::ArgumentGivenError.new "--#{optopt}"
         end
-        return [ optopt ]
+        ret = [ optopt ]
+        info = [ :long, :no_argument ]
       when :required_argument
         unless optarg
           optarg = argv.shift
           unless optarg
-            raise Getopt::ArgumentRequiredError.new optopt
+            raise Getopt::ArgumentRequiredError.new "--#{optopt}"
           end
         end
         if ! allow_empty_optarg && optarg.empty?
-          raise Getopt::ArgumentRequiredError.new optopt
+          raise Getopt::ArgumentRequiredError.new "--#{optopt}"
         end
-        return [ optopt, optarg ]
+        ret = [ optopt, optarg ]
+        info = [ :long, :required_argument ]
       when :optional_argument
         if ! allow_empty_optarg && optarg && optarg.empty?
-          raise Getopt::ArgumentRequiredError.new optopt
+          raise Getopt::ArgumentRequiredError.new "--#{optopt}"
         end
-        return [ optopt, optarg ]
+        ret = [ optopt, optarg ]
+        info = [ :long, :optional_argument ]
       else
         raise ArgumentError,
-              "wrong long option type - #{longopts[optopt].inspect}"
+              "Wrong long option type - #{longopts[optopt].inspect}"
       end
-      # NOTREACHED
+
+      if parse
+        ret[0] = "--#{ret[0]}"
+        ret = info + ret
+      end
+      return ret
     end
   end
 
@@ -147,21 +279,23 @@ def getopt(argv, opts, longopts = nil,
     argv.unshift "-#{arg}" unless arg.empty?
     # keep short option context on error
     argv.unshift :getopt_short if arg[0] == "-"
-    raise Getopt::UnknownOptionError.new optopt
+    raise Getopt::UnknownOptionError.new "-#{optopt}"
   end
 
   if opts[pos.succ] == ":"
     if optional_short && opts[pos.succ.succ] == ":"
       # short option with optional argument
       optarg = arg.empty? ? nil : arg
-      return [ optopt, optarg ]
+      ret = [ optopt, optarg ]
+      info = [ :short, :optional_argument ]
     else
       # short option with required argument
       optarg = arg.empty? ? argv.shift : arg
       if optarg.nil? || (optarg.empty? && ! allow_empty_optarg)
-        raise Getopt::ArgumentRequiredError.new optopt
+        raise Getopt::ArgumentRequiredError.new "-#{optopt}"
       end
-      return [ optopt, optarg ]
+      ret = [ optopt, optarg ]
+      info = [ :short, :required_argument ]
     end
   else
     # short option without argument
@@ -169,30 +303,34 @@ def getopt(argv, opts, longopts = nil,
       argv.unshift "-#{arg}"
       argv.unshift :getopt_short if arg[0] == "-"
     end
-    return [ optopt ]
+    ret = [ optopt ]
+    info = [ :short, :no_argument ]
+  end
+
+  if parse
+    ret[0] = "-#{ret[0]}"
+    ret = info + ret
   end
+  ret
 
 rescue Getopt::GetoptError => ex
   raise if use_exception
 
-  if error_message
-    if ex.option.length == 1
-      warn "#{program_name}: #{ex.message} -#{ex.option}"
-    else
-      warn "#{program_name}: #{ex.message} --#{ex.option}"
-    end
-  end
+  warn "#{program_name}: #{ex.message}: #{ex.option}" if error_message
 
   case ex
   when Getopt::UnknownOptionError
-    return [ :unknown_option, ex.option ]
+    ret = [ :unknown_option, ex.option ]
   when Getopt::ArgumentRequiredError
-    return [ :argument_required, ex.option ]
+    ret = [ :argument_required, ex.option ]
   when Getopt::ArgumentGivenError
-    return [ :argument_given, ex.option ]
+    ret = [ :argument_given, ex.option ]
   when Getopt::AmbiguousOptionError
-    return [ :ambiguous_option, ex.option, ex.candidates ]
+    ret = [ :ambiguous_option, [ ex.option, ex.candidates ]]
   end
+
+  ret.unshift :error if parse
+  return ret
 end
 
 Kernel.define_singleton_method "getopt", method(:getopt)

data/trad-getopt.txt

@@ -95,8 +95,9 @@ longopts にはキーをオプション名、値をシンボルとするハッ
 
 - :ambiguousu_option (Getopt::AmbiguousOptionError)
   ロングオプションの省略形が一意でない。このときエラーメッセージに候補
-  を示す。また返り値の第 3 要素にも候補のリストを置く。例外を有効とし
-  ている場合は Getopt::AmbiguousOptionError#candidates() で取得できる。
+  を示す。:ambiguousu_option のみ返り値の第 2 要素はオプション文字と
+  候補リストのリストになる。例外を有効としている場合、候補リストは
+  Getopt::AmbiguousOptionError#candidates() で取得できる。
 
 = キーワード引数
 
@@ -115,6 +116,10 @@ longopts にはキーをオプション名、値をシンボルとするハッ
   偽にするとオプショナル引数つきショートオプションを無効にする。opts
   中の "::" を ":" と解釈してただの引数つきオプションとする。
 
+- parse => false
+  真にすると、オプション文字でなくオプションに関する情報をまとめたリスト
+  を返すようになる。Getopt.parse()、Getopt.list() が使う。
+
 - permute => false
   真にすると、オプションに出会うまで非オプションを飛ばす GNU の getopt
   を模した動作になる。argv 中にオプションが無ければ nil を返す。読んだ
@@ -160,31 +165,25 @@ longopts にはキーをオプション名、値をシンボルとするハッ
 ----------------------------------------------------------------------------
 require "trad-getopt"
 
-opts = "ab:"
-
 longopts = {
   "foo" => :no_argument,
-  "foo-bar" => :optional_argument,
-  "baz" => :required_argument,
+  "bar" => :required_argument,
+  "baz" => :optional_argument,
 }
 
-while op = getopt(ARGV, opts, longopts, permute:false)
-  case op[0]
+while (op, oparg = getopt(ARGV, "ab:c::", longopts))
+  case op
   when "a", "foo"
-    puts "option #{op[0]}"
-  when "b", "baz"
-    puts "option #{op[0]} with #{op[1]}"
-  when "foo-bar"
-    if op[1]
-      puts "option #{op[0]} with #{op[1]}"
-    else
-      puts "option #{op[0]} with no-arg"
-    end
-  when :unknown_option, :argument_required, :argument_given, :ambiguous_option
+    puts "option #{op}"
+  when "b", "bar"
+    puts "option #{op} with #{oparg.inspect}"
+  when "c", "baz"
+    puts "option #{op} with #{oparg.inspect}"
+  when Symbol
+    # errors
     exit 1
   end
 end
+
 puts "argv #{ARGV}"
 ----------------------------------------------------------------------------
-
-#eof

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trad-getopt
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 2.0.0
 platform: ruby
 authors:
 - NOZAWA Hiromasa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-04-16 00:00:00.000000000 Z
+date: 2019-04-17 00:00:00.000000000 Z
 dependencies: []
 description: 
 email: