trad-getopt 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 477c3ba1fa3b783d818c18c3a6ded9a1af536059
+  data.tar.gz: 68170ced8654712a2fb5dbe196293c7e5fe961f9
+SHA512:
+  metadata.gz: ebf8446087fcbe516a85dbf93f0fd564f7bb2ab562061ee18459e24ff9e1bdbf0f17ce13d9ef3e6de86700e7f2bec844c6ec3d78538283cb643f61afab137b6d
+  data.tar.gz: 5bb3b2bfe2ad16f387874e4ccb8125995fb10bf4e42d443f7a356459668f1e243ed7867f29be5b1ac13a702dee795daccd12bda996c732dd9fe5f3199776eb72

data/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2017, NOZAWA Hiromasa. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+  2. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in
+     the documentation and/or other materials provided with the
+     distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/Rakefile

@@ -0,0 +1,38 @@
+require 'rake/clean'
+require "rubygems/package_task"
+
+require "./trad-getopt.rb"	# Getopt::VERSION
+
+task :default => :gem
+
+task :gem
+spec = Gem::Specification.new { |s|
+  s.name = "trad-getopt"
+  s.version = Getopt::VERSION
+  s.author = "NOZAWA Hiromasa"
+  s.summary = "rather traditional getopt()"
+  s.license = "BSD-2-Clause"
+  s.homepage = "https://github.com/noz/ruby-trad-getopt"
+  s.files = FileList[
+    "LICENSE",
+    "Rakefile",
+    "test.rb",
+    "trad-getopt.rb",
+    "trad-getopt.txt",
+  ]
+  s.require_path = "."
+}
+Gem::PackageTask.new(spec) { |pkg|
+  pkg.need_tar_gz = true
+  pkg.need_tar_bz2 = true
+  pkg.need_zip = true
+}
+
+# require "rake/testtask"
+# Rake::TestTask.new { |t|
+#   t.test_files = FileList["test.rb"]
+# }
+desc "do unit test"
+task :test {
+  ruby "-w", "test.rb"
+}

data/test.rb

@@ -0,0 +1,501 @@
+require "test/unit"
+require "./trad-getopt.rb"
+
+class Test_getopt < Test::Unit::TestCase
+
+  test "empty argv" do
+    av = []
+    assert_equal nil, getopt(av, "a")
+    assert_equal [], av
+  end
+  test "empty opts" do
+    av = [ "a" ]
+    assert_equal nil, getopt(av, "")
+    assert_equal [ "a" ], av
+  end
+  test "nil opts" do
+    av = [ "a" ]
+    assert_equal nil, getopt(av, nil)
+    assert_equal [ "a" ], av
+  end
+
+  test "stop at non option" do
+    av = ["foo"]
+    assert_equal nil, getopt(av, "-a")
+    assert_equal ["foo"], av
+  end
+  test "unknown error" do
+    av = [ "-x" ]
+    $stderr = StringIO.new
+    got = getopt(av, "a")
+    msg = $stderr.string
+    $stderr = STDERR
+    assert_equal [:unknown_option, "x"], got
+    assert_equal "test.rb: unknown option - x\n", msg
+    assert_equal [], av
+  end
+
+  test "short noarg" do
+    av = [ "-a", "foo" ]
+    assert_equal ["a"], getopt(av, "a")
+    assert_equal ["foo"], av
+  end
+
+  test "short reqarg" do
+    av = [ "-a", "foo" ]
+    assert_equal ["a", "foo"], getopt(av, "a:")
+    assert_equal [], av
+  end
+  test "short reqarg. error" do
+    av = [ "-a" ]
+    $stderr = StringIO.new
+    got = getopt(av, "a:")
+    msg = $stderr.string
+    $stderr = STDERR
+    assert_equal [:argument_required, "a"], got
+    assert_equal "test.rb: option requires an argument - a\n", msg
+    assert_equal [], av
+  end
+
+  test "short optarg, with arg" do
+    av = [ "-afoo" ]
+    assert_equal ["a", "foo"], getopt(av, "a::")
+    assert_equal [], av
+  end
+  test "short optarg, no arg" do
+    av = [ "-a", "foo" ]
+    assert_equal [ "a", nil ], getopt(av, "a::")
+    assert_equal [ "foo" ], av
+  end
+  test "short optarg, no arg, at tail" do
+    av = [ "-a" ]
+    assert_equal [ "a", nil ], getopt(av, "a::")
+    assert_equal [], av
+  end
+  test "short optarg, disabled" do
+    av = [ "-a" ]
+    $stderr = StringIO.new
+    got = getopt(av, "a::", optional_short:false)
+    $stderr = STDERR
+    assert_equal [ :argument_required, "a"],  got
+  end
+
+  ### concatenation
+
+  test "concat, noarg + noarg" do
+    av = [ "-ab" ]
+    opts = "ab"
+    assert_equal ["a"], getopt(av, opts)
+    assert_equal ["b"], getopt(av, opts)
+  end
+  test "concat, noarg + reqarg + arg" do
+    av = [ "-abfoo" ]
+    opts = "ab:"
+    assert_equal ["a"], getopt(av, opts)
+    assert_equal ["b", "foo"], getopt(av, opts)
+  end
+
+  ### special chars
+
+  test "single `-'" do
+    av = [ "-" ]
+    assert_equal nil, getopt(av, "a")
+    assert_equal ["-"], av
+  end
+  test "stop by `--'" do
+    av = [ "--" ]
+    assert_equal nil, getopt(av, "a")
+    assert_equal [], av
+  end
+
+  test "stop_by_double_hyphen, disable" do
+    av = [ "--" ]
+    assert_equal [ "-" ], getopt(av, "-", stop_by_double_hyphen:false)
+  end
+
+  test "hyphen in concat, as option" do
+    av = [ "-a-" ]
+    opts = "a-"
+    assert_equal ["a"], getopt(av, opts)
+    assert_equal ["-"], getopt(av, opts)
+    assert_equal [], av
+  end
+  test "hyphen in concat, not as option" do
+    av = [ "-a-" ]
+    opts = "a"
+    assert_equal ["a"], getopt(av, opts)
+    $stderr = StringIO.new
+    got = getopt(av, opts)
+    msg = $stderr.string
+    $stderr = STDERR
+    assert_equal [:unknown_option, "-"],  got
+    assert_equal "test.rb: unknown option - -\n", msg
+    assert_equal [], av
+  end
+
+  test "colon as option" do
+    av = [ "-:" ]
+    assert_equal [":"],  getopt(av, ":a")
+  end
+  test "colon not as option" do
+    av = [ "-:" ]
+    $stderr = StringIO.new
+    got = getopt(av, "a:")
+    msg = $stderr.string
+    $stderr = STDERR
+    assert_equal [:unknown_option, ":"],  got
+    assert_equal "test.rb: unknown option - :\n", msg
+    assert_equal [], av
+  end
+
+  ### keywords
+
+  test "program_name" do
+    av = [ "-x" ]
+    $stderr = StringIO.new
+    getopt(av, "a", error_message:true, program_name:"foo")
+    msg = $stderr.string
+    $stderr = STDERR
+    assert_equal "foo: unknown option - x\n", msg
+  end
+
+  test "error_message" do
+    av = [ "-x" ]
+    $stderr = StringIO.new
+    getopt(av, "a", error_message:false)
+    msg = $stderr.string
+    $stderr = STDERR
+    assert_equal "", msg
+  end
+
+  test "use_exception, Getopt::UnknownOptionError" do
+    av = [ "-x" ]
+    begin
+      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
+    end
+  end
+  test "use_exception, Getopt::ArgumentRequiredError" do
+    av = [ "-a" ]
+    begin
+      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
+    end
+  end
+
+  test "permute" do
+    av = [ "foo", "-a", "bar" ]
+    opts = "a"
+    assert_equal ["a"],  getopt(av, opts, permute:true)
+    assert_equal nil, getopt(av, opts, permute:true)
+    assert_equal ["foo", "bar"], av
+  end
+  test "permute, reqarg" do
+    av = [ "foo", "-a", "bar", "baz" ]
+    opts = "a:"
+    assert_equal ["a", "bar"],  getopt(av, opts, permute:true)
+    assert_equal nil, getopt(av, opts, permute:true)
+    assert_equal ["foo", "baz"], av
+  end
+
+  test "allow_empty_optarg" do
+    av = [ "-a", "" ]
+    opts = "a:"
+    $stderr = StringIO.new
+    assert_equal [:argument_required, "a"],  getopt(av, opts, allow_empty_optarg:false)
+    $stderr = STDERR
+  end
+  test "allow_empty_optarg. long" do
+    av = [ "--foo=" ]
+    longopts = { "foo" => :required_argument }
+    $stderr = StringIO.new
+    assert_equal [:argument_required, "foo"],  getopt(av, "", longopts, allow_empty_optarg:false)
+    $stderr = STDERR
+  end
+  test "allow_empty_optarg. long 2" do
+    av = [ "--foo", "" ]
+    longopts = { "foo" => :required_argument }
+    $stderr = StringIO.new
+    assert_equal [:argument_required, "foo"],  getopt(av, "", longopts, allow_empty_optarg:false)
+    $stderr = STDERR
+  end
+  test "allow_empty_optarg. optional long" do
+    av = [ "--foo=" ]
+    longopts = { "foo" => :optional_argument }
+    $stderr = StringIO.new
+    assert_equal [:argument_required, "foo"],  getopt(av, "", longopts, allow_empty_optarg:false)
+    $stderr = STDERR
+  end
+
+  ### short context
+
+  test "short context" do
+    av = [ "-a-" ]
+    opts = "a"
+    assert_equal [ "a" ], getopt(av, opts)
+    $stderr = StringIO.new
+    assert_equal [ :unknown_option, "-" ], getopt(av, opts)
+    $stderr = STDERR
+  end
+  test "short context, not long option" do
+    av = [ "-a-foo" ]
+    opts = "afo-"
+    lopts = {
+      "foo" => :no_argument
+    }
+    assert_equal [ "a" ], getopt(av, opts, lopts)
+    assert_equal [ "-" ], getopt(av, opts, lopts)
+    assert_equal [ "f" ], getopt(av, opts, lopts)
+  end
+  test "short context, not long option, error" do
+    av = [ "-a-foo" ]
+    opts = "a-"
+    lopts = {
+      "foo" => :no_argument
+    }
+    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)
+    $stderr = STDERR
+  end
+
+  ### long option
+
+  test "long option" do
+    av = [ "--foo" ]
+    opts = "fo-"
+    lopts = {
+      "foo" => :no_argument
+    }
+    assert_equal [ "foo" ], getopt(av, opts, lopts)
+  end
+
+  test "not long option" do
+    av = [ "-foo" ]
+    opts = "fo"
+    lopts = {
+      "foo" => :no_argument
+    }
+    assert_equal [ "f" ], getopt(av, opts, lopts)
+    assert_equal [ "o" ], getopt(av, opts, lopts)
+    assert_equal [ "o" ], getopt(av, opts, lopts)
+  end
+
+  test "wrong long option type" do
+    av = [ "--foo" ]
+    lopts = {
+      "foo" => :bar
+    }
+    begin
+      getopt(["--foo"], "", lopts)
+    rescue => ex
+      assert_equal ArgumentError, ex.class
+      assert_equal [ "--foo" ], av
+    end
+  end
+  test "wrong long option type, permute" do
+    av = [ "a", "--foo", "b" ]
+    lopts = {
+      "foo" => :bar
+    }
+    begin
+      getopt(["--foo"], "", lopts, permute:true)
+    rescue => ex
+      assert_equal ArgumentError, ex.class
+      assert_equal [ "a", "--foo", "b" ], av
+    end
+  end
+
+  test "unknown long option" do
+    av = [ "--bar" ]
+    lopts = {
+      "foo" => :no_argument
+    }
+    $stderr = StringIO.new
+    got = getopt(av, "", lopts)
+    msg = $stderr.string
+    $stderr = STDERR
+    assert_equal [ :unknown_option, "bar" ], got
+    assert_equal "test.rb: unknown option - bar\n", msg
+  end
+
+  test "no_argument" do
+    av = [ "--foo" ]
+    lopts = {
+      "foo" => :no_argument
+    }
+    assert_equal [ "foo" ], getopt(av, "", lopts)
+  end
+  test "no_argument, error" do
+    av = [ "--foo=bar" ]
+    lopts = {
+      "foo" => :no_argument
+    }
+    $stderr = StringIO.new
+    got = getopt(av, "", lopts)
+    msg = $stderr.string
+    $stderr = STDERR
+    assert_equal [ :argument_given, "foo" ], got
+    assert_equal "test.rb: option doesn't take an argument - foo\n", msg
+  end
+  test "no_argument, exception" do
+    av = [ "--foo=bar" ]
+    lopts = {
+      "foo" => :no_argument
+    }
+    begin
+      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
+    end
+  end
+
+  test "required_argument" do
+    av = [ "--foo=bar" ]
+    lopts = {
+      "foo" => :required_argument
+    }
+    assert_equal [ "foo", "bar" ], getopt(av, "", lopts)
+  end
+  test "required_argument, split" do
+    av = [ "--foo", "bar" ]
+    lopts = {
+      "foo" => :required_argument
+    }
+    assert_equal [ "foo", "bar" ], getopt(av, "", lopts)
+  end
+  test "required_argument, empty arg" do
+    av = [ "--foo=" ]
+    lopts = {
+      "foo" => :required_argument
+    }
+    assert_equal [ "foo", "" ], getopt(av, "", lopts)
+  end
+  test "required_argument, error" do
+    av = [ "--foo" ]
+    lopts = {
+      "foo" => :required_argument
+    }
+    $stderr = StringIO.new
+    got = getopt(av, "", lopts)
+    msg = $stderr.string
+    $stderr = STDERR
+    assert_equal [ :argument_required, "foo" ], got
+    assert_equal "test.rb: option requires an argument - foo\n", msg
+  end
+  test "required_argument, exception" do
+    av = [ "--foo" ]
+    lopts = {
+      "foo" => :required_argument
+    }
+    begin
+      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
+    end
+  end
+
+  test "optional_argument, with arg" do
+    av = [ "--foo=bar" ]
+    lopts = {
+      "foo" => :optional_argument
+    }
+    assert_equal [ "foo", "bar" ], getopt(av, "", lopts)
+  end
+  test "optional_argument, empty arg" do
+    av = [ "--foo=" ]
+    lopts = {
+      "foo" => :optional_argument
+    }
+    assert_equal [ "foo", "" ], getopt(av, "", lopts)
+  end
+  test "optional_argument, no arg" do
+    av = [ "--foo", "bar" ]
+    lopts = {
+      "foo" => :optional_argument
+    }
+    assert_equal [ "foo", nil ], getopt(av, "", lopts)
+  end
+  test "optional_argument, no arg, at tail" do
+    av = [ "--foo" ]
+    lopts = {
+      "foo" => :optional_argument
+    }
+    assert_equal [ "foo", nil ], getopt(av, "", lopts)
+  end
+
+  test "unique abbrev, no candidates" do
+    av = [ "--fo" ]
+    lopts = {
+      "foo" => :no_argument
+    }
+    assert_equal [ "foo" ], getopt(av, "", lopts)
+  end
+  test "unique abbrev" do
+    av = [ "--foo-" ]
+    lopts = {
+      "foo" => :no_argument,
+      "foo-bar" => :no_argument
+    }
+    assert_equal [ "foo-bar" ], getopt(av, "", lopts)
+  end
+  test "abbrev, exact match" do
+    av = [ "--foo" ]
+    lopts = {
+      "foo" => :no_argument,
+      "foo-bar" => :no_argument
+    }
+    assert_equal [ "foo" ], getopt(av, "", lopts)
+  end
+  test "abbrev, ambiguous" do
+    av = [ "--foo" ]
+    lopts = {
+      "foo1" => :no_argument,
+      "foo2" => :no_argument
+    }
+    $stderr = StringIO.new
+    got = getopt(av, "", lopts)
+    msg = $stderr.string
+    $stderr = STDERR
+    assert_equal [ :ambiguous_option, "foo", ["foo1", "foo2"] ], got
+    assert_equal "test.rb: ambiguos option (--foo1 --foo2) - foo\n", msg
+  end
+  test "abbrev, ambiguous, exception" do
+    av = [ "--foo" ]
+    lopts = {
+      "foo1" => :no_argument,
+      "foo2" => :no_argument
+    }
+    begin
+      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
+    end
+  end
+
+  test "abbrev disabled" do
+    av = [ "--fo" ]
+    lopts = {
+      "foo" => :no_argument,
+    }
+    $stderr = StringIO.new
+    got = getopt(av, "", lopts, abbreviation:false)
+    msg = $stderr.string
+    $stderr = STDERR
+    assert_equal [ :unknown_option, "fo" ], got
+    assert_equal "test.rb: unknown option - fo\n", msg
+  end
+end

data/trad-getopt.rb

@@ -0,0 +1,248 @@
+# rather traditional getopt for Ruby
+
+module Getopt
+  VERSION = "1.1.0"
+
+  class GetoptError < StandardError
+    def initialize option, message
+      super message
+      @option = option
+    end
+    attr_reader :option
+  end
+  class UnknownOptionError < GetoptError
+    def initialize option, message = "unknown option"
+      super option, message
+    end
+  end
+  class ArgumentRequiredError < GetoptError
+    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"
+      super option, message
+    end
+  end
+  class AmbiguousOptionError < GetoptError
+    def initialize option, message, candidates
+      message ||= "ambiguos option"
+      @candidates = candidates
+      cands = candidates.collect { |c| "--#{c}" }.join " "
+      super option, "#{message} (#{cands})"
+    end
+    attr_reader :candidates
+  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)
+  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,
+                      program_name: program_name,
+                      stop_by_double_hyphen: stop_by_double_hyphen,
+                      use_exception: use_exception)
+      if argv.empty?
+        argv.unshift(*args)
+        return nil
+      end
+      args.push argv.shift
+    end
+    argv.unshift(*args)
+    return op
+  end
+
+  opts ||= ""
+  program_name ||= $0
+
+  arg = argv.shift
+  return nil if arg.nil?
+  if arg == :getopt_short
+    arg = argv.shift
+    return nil if arg.nil?
+  else
+    if arg == "-"
+      argv.unshift "-"
+      return nil
+    end
+    if stop_by_double_hyphen && arg == "--"
+      return 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
+        if abbr.empty?
+          raise Getopt::UnknownOptionError.new optopt
+        end
+        if abbr.size == 1
+          optopt = abbr.first.first
+        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
+        end
+      else
+        unless longopts[optopt]
+          raise Getopt::UnknownOptionError.new optopt
+        end
+      end
+
+      case longopts[optopt]
+      when :no_argument
+        if optarg
+          raise Getopt::ArgumentGivenError.new optopt
+        end
+        return [ optopt ]
+      when :required_argument
+        unless optarg
+          optarg = argv.shift
+          unless optarg
+            raise Getopt::ArgumentRequiredError.new optopt
+          end
+        end
+        if ! allow_empty_optarg && optarg.empty?
+          raise Getopt::ArgumentRequiredError.new optopt
+        end
+        return [ optopt, optarg ]
+      when :optional_argument
+        if ! allow_empty_optarg && optarg && optarg.empty?
+          raise Getopt::ArgumentRequiredError.new optopt
+        end
+        return [ optopt, optarg ]
+      else
+        raise ArgumentError,
+              "wrong long option type - #{longopts[optopt].inspect}"
+      end
+      # NOTREACHED
+    end
+  end
+
+  # non option argument
+  unless arg[0] == "-"
+    argv.unshift arg
+    return nil
+  end
+
+  # short option. here arg[0] == "-"
+
+  optopt = arg[1]
+  arg = arg[2 .. -1]
+  pos = opts.split("").find_index(optopt)
+  if pos.nil? || (optopt == ":" && pos != 0)
+    argv.unshift "-#{arg}" unless arg.empty?
+    # keep short option context on error
+    argv.unshift :getopt_short if arg[0] == "-"
+    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 ]
+    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
+      end
+      return [ optopt, optarg ]
+    end
+  else
+    # short option without argument
+    unless arg.empty?
+      argv.unshift "-#{arg}"
+      argv.unshift :getopt_short if arg[0] == "-"
+    end
+    return [ optopt ]
+  end
+
+rescue Getopt::GetoptError => ex
+  raise if use_exception
+  warn "#{program_name}: #{ex.message} - #{ex.option}" if error_message
+  case ex
+  when Getopt::UnknownOptionError
+    return [ :unknown_option, ex.option ]
+  when Getopt::ArgumentRequiredError
+    return [ :argument_required, ex.option ]
+  when Getopt::ArgumentGivenError
+    return [ :argument_given, ex.option ]
+  when Getopt::AmbiguousOptionError
+    return [ :ambiguous_option, ex.option, ex.candidates ]
+  end
+end
+
+Kernel.define_singleton_method "getopt", method(:getopt)
+
+if __FILE__ == $0
+
+def usage
+  puts <<EOD
+usage: #{$0} [-hVp] [-Llongopt] opts ...
+  -h    print this
+  -V    print revision
+  -L    define long option like -Lfoo, -Lfoo: or -Lfoo::
+  -p    permute
+  opts  define short options
+EOD
+end
+
+longopts = {}
+permute = false
+
+while op = getopt(ARGV, "hL:pV")
+  op, oparg = op
+  exit 1 if op.is_a? Symbol
+  case op
+  when "h"
+    usage
+    exit
+  when "V"
+    puts "trad-getopt rev.#{Getopt::VERSION}"
+    exit
+  when "p"
+    permute = true
+  when "L"
+    if oparg[-1] == ":"
+      if oparg[-2] == ":"
+        v = :optional_argument
+        oparg[-2] = ""
+      else
+        v = :required_argument
+      end
+      oparg[-1] = ""
+    else
+      v = :no_argument
+    end
+    longopts[oparg] = v
+  else
+    break
+  end
+end
+
+opts = ARGV.shift
+unless opts
+  puts "argument required"
+  exit 1
+end
+
+while op = getopt(ARGV, opts, longopts, permute:permute)
+  puts "option #{op} ARGV #{ARGV}"
+end
+puts "ARGV #{ARGV}"
+
+end

data/trad-getopt.txt

@@ -0,0 +1,190 @@
+ruby-trad-getopt
+
+伝統的な getopt に近い getopt。コマンドラインオプションを解析する。
+
+---------------------------------------------
+getopt(argv, opts, longopts = nil, KWARGS...)
+---------------------------------------------
+
+argv にはコマンドライン引数文字列のリストをとる。opts にはショートオプ
+ションとする文字を並べた文字列、longopts にはロングオプションを定義す
+るハッシュをとる。
+
+argv の先頭の要素が opts または longopts に定義されたコマンドラインオ
+プションであるなら、オプションの種類に応じて次のような、オプション文字
+(列)を第 1 要素とするリストを返す。
+
+  ・引数なしオプションなら [ "オプション文字" ] 
+  ・引数つきオプションなら [ "オプション文字", "引数" ] 
+  ・オプショナル引数つきオプションの場合、引数が、
+    ・あるなら [ "オプション文字", "引数" ]
+    ・無いなら [ "オプション文字", nil ] 
+
+argv の先頭の要素がコマンドラインオプションでない場合、または argv が
+空の場合には nil を返す。
+
+コマンドラインオプションとして処理した要素は argv から削除する。argv
+は破壊的に変更されるので、解析をリセットする必要がある場合、あらかじめ
+呼び出し側で複製した argv を用いる必要がある。
+
+単独の `--' はオプション解析の停止を意味する特別なオプションとして扱い、
+argv からは削除して nil を返す。単独の `-' は非オプションとして扱い、
+argv から削除せず nil を返す。
+
+エラーした場合、第 1 要素にエラーの種類を表すシンボル、第 2 要素にエラー
+したオプション文字(列)を置いたリストを返す。
+
+= ショートオプション
+
+opts には "ab:c" のような、ショートオプションとする文字を並べた文字列
+をとる。
+
+  ・通常の文字は引数なしショートオプションとなる
+  ・後ろに `:' を置いた文字は引数つきショートオプションとなる
+  ・後ろに `::' を置いた文字はオプショナル引数つきショートオプションと
+    なる
+
+引数つきショートオプションのオプションと引数は、argv 上の続く 2 要素で
+あっても ([ "-a", "foo" ])、1 つの要素であっても ([ "-afoo" ]) よい。
+オプショナル引数つきショートオプションはオプションと引数が 1 つの要素
+で指定されたときのみ引数ありと解釈する。
+
+argv 上で [ "-a", "-b", "-c", "foo" ] のように連続しているショートオプ
+ションが [ "-abcfoo" ] のように連結されていてもよい。このとき
+getotpt() はこの要素を、呼び出し毎に "-bcfoo"、"-cfoo"、削除、と変更す
+る。
+
+= ロングオプション
+
+longopts にはキーをオプション名、値をシンボルとするハッシュをとる。有
+効なシンボルは次の通り。
+
+  ・:no_argument - 引数なしロングオプション
+  ・:required_argument - 引数つきロングオプション
+  ・:optional_argument - オプショナル引数つきロングオプション
+
+ロングオプションに引数を与えるには "--bar=引数" のようにオプションと引
+数を空白なしに `=' でつなげた形をとる。引数つきロングオプションは argv
+上で連続する 2 要素に分かれていてもよい ([ "--bar", "引数" ])。オプショ
+ナル引数つきロングオプションは `=' 区切りの 1 要素による指定の場合のみ
+引数をとる。
+
+ロングオプションは一意に特定できる限りにおいて省略できる。ただし省略形
+に完全一致するロングオプションを優先する。
+
+= エラー
+
+エラーすると標準エラー出力にメッセージを出力し、エラーを示すシンボルと
+エラーを生じたオプション文字(列)からなるリストを返す。エラーしたオプショ
+ンは argv から削除する。
+
+キーワード引数 use_exception を真にするとエラー時に例外を発生するよう
+になる。例外は Getopt::GetoptError をベースクラスとしており、インスタ
+ンスメソッド option() からエラーしたオプションを得られる。
+
+エラーを示すシンボルと対応する例外クラスは以下の通り:
+
+- :unknown_option (Getopt::UnknownOptionError)
+  未定義のオプション
+
+- :argument_required (Getopt::ArgumentRequiredError)
+  引数つきオプションに引数が無い
+
+- :argument_given (Getopt::ArgumentGivenError)
+  引数なしロングオプションに引数が指定された
+
+- :ambiguousu_option (Getopt::AmbiguousOptionError)
+  ロングオプションの省略形が一意でない。このときエラーメッセージに候補
+  を示す。また返り値の第 3 要素にも候補のリストを置く。例外を有効とし
+  ている場合は Getopt::AmbiguousOptionError#candidates() で取得できる。
+
+= キーワード引数
+
+- abbreviation => true
+  偽にするとロングオプションの省略形が無効になる。
+
+- allow_empty_optarg => true
+  偽にすると、引数つきオプションまたはオプショナル引数つきオプションで、
+  オプションの引数が空文字列だったときにエラー (:argument_required) と
+  する。
+
+- error_message => true
+  偽にするとエラーメッセージを出力しなくなる。
+
+- optional_short => true
+  偽にするとオプショナル引数つきショートオプションを無効にする。opts
+  中の "::" を ":" と解釈してただの引数つきオプションとする。
+
+- permute => false
+  真にすると、オプションに出会うまで非オプションを飛ばす GNU の getopt
+  を模した動作になる。argv 中にオプションが無ければ nil を返す。読んだ
+  オプションを削除することは変わらないので、nil が返るまで getopt() を
+  繰り返すと argv には非オプションの引数のみが残ることになる。
+
+- program_name => nil
+  エラーメッセージに出すプログラム名文字列を指定する。デフォルトは nil
+  で $0 を使う。
+
+- stop_by_double_hyphen => true
+  偽にすると `--' を特別扱いしなくなり、`-' を普通のショートオプション
+  文字として使えるようになる。
+
+- use_exception => false
+  真ならエラー時に例外を発生するようになる。
+
+= 要注意なオプション文字
+
+- `-'
+  ショートオプション文字としても解析停止の `--' を優先する都合上、単独
+  の表記では通常のショートオプションとして得られないが、`-a-' のように
+  ショートオプションの連結中に表れたときには通常のショートオプションと
+  して得られる。
+  キーワード引数 stop_by_double_hyphen を偽とすることで、`-' を単なる
+  ショートオプション文字としてのみ使えるようになる。
+  また本実装では、このコンテキストを捉えるために、連結されたオプション
+  の次回の読み出しが `-' になるとき、argv の先頭に :getopt_short とい
+  うシンボルを置く。
+
+- `:'
+  ショートオプション文字として使うには、引数つきオプションを示す `:'
+  と区別するため、opts の先頭に置かなければならない。C 言語等の
+  getopt() にオプション文字列先頭の `:' が特別な機能を持つものがあるが、
+  それとは意味が違う点に注意。
+
+- `>' や `|' などのシェルのメタ文字
+  コマンドライン上では `-\>' や `--foo\|bar' のようにエスケープして表
+  記する必要が生じる。具体的には使用しているシェルに依存する。
+
+= 例
+
+----------------------------------------------------------------------------
+require "trad-getopt"
+
+opts = "ab:"
+
+longopts = {
+  "foo" => :no_argument,
+  "foo-bar" => :optional_argument,
+  "baz" => :required_argument,
+}
+
+while op = getopt(ARGV, opts, longopts, permute:false)
+  case op[0]
+  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
+    exit 1
+  end
+end
+puts "argv #{ARGV}"
+----------------------------------------------------------------------------
+
+#eof

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: trad-getopt
+version: !ruby/object:Gem::Version
+  version: 1.1.0
+platform: ruby
+authors:
+- NOZAWA Hiromasa
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-03-19 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- Rakefile
+- test.rb
+- trad-getopt.rb
+- trad-getopt.txt
+homepage: https://github.com/noz/ruby-trad-getopt
+licenses:
+- BSD-2-Clause
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- "."
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: rather traditional getopt()
+test_files: []