cmd-optparse.rb 0.1.0

data/misc/rb_optparse.bash

@@ -0,0 +1,21 @@
+# -*- bash -*-
+#
+# Completion for bash:
+#
+# (1) install this file,
+#
+# (2) load the script, and
+#      . ~/.profile.d/rb_optparse.bash
+#
+# (3) define completions in your .bashrc,
+#      rb_optparse command_using_optparse_1
+#      rb_optparse command_using_optparse_2
+
+_rb_optparse() {
+  COMPREPLY=($("${COMP_WORDS[0]}" "--*-completion-bash=${COMP_WORDS[COMP_CWORD]}"))
+  return 0
+}
+
+rb_optparse () {
+  [ $# = 0 ] || complete -o default -F _rb_optparse "$@"
+}

data/misc/rb_optparse.zsh

@@ -0,0 +1,39 @@
+# -*- zsh -*-
+#
+# Completion for zsh:
+# (based on <http://d.hatena.ne.jp/rubikitch/20071002/zshcomplete>)
+#
+# (1) install this file.
+#      mkdir -p ~/.zsh.d
+#      cp rb_optparse.zsh ~/.zsh.d/rb_optparse.zsh
+#
+# (2) load the script, and add a directory to fpath before compinit.
+#      echo '. ~/.zsh.d/rb_optparse.zsh' >> "${ZDOTDIR:-~}/.zshrc"
+#      echo 'fpath=(~/.zsh.d/Completion $fpath)' >> "${ZDOTDIR:-~}/.zshrc"
+#      echo 'autoload -U compinit; compinit' >> "${ZDOTDIR:-~}/.zshrc"
+#
+# (3) restart zsh.
+#
+# (4) generate completion files once.
+#      generate-complete-function/ruby/optparse COMMAND1
+#      generate-complete-function/ruby/optparse COMMAND2
+#
+
+generate-complete-function/ruby/optparse ()
+{
+    local cmpl="_${1:t}"
+    mkdir -p "${ZSH_COMPLETION_DIR-$HOME/.zsh.d/Completion}"
+    $1 "--*-completion-zsh=${1:t}" >! "${ZSH_COMPLETION_DIR-$HOME/.zsh.d/Completion}/$cmpl"
+    if [[ $(type -w "$cmpl") == "${cmpl}: function" ]]; then
+        unfunction "$cmpl"
+        autoload -U "$cmpl"
+    else
+        compinit "$cmpl"
+    fi
+}
+
+compdef _command generate-complete-function/ruby/optparse
+
+for cmd in "$@"; do
+    generate-complete-function/ruby/optparse "$cmd"
+done

data/rakelib/changelogs.rake

@@ -0,0 +1,34 @@
+task "build" => "changelogs"
+
+changelog = proc do |output, ver = nil, prev = nil|
+  ver &&= Gem::Version.new(ver)
+  range = [[prev], [ver, "HEAD"]].map {|ver, branch| ver ? "v#{ver.to_s}" : branch}.compact.join("..")
+  IO.popen(%W[git log --format=fuller --topo-order --no-merges #{range}]) do |log|
+    line = log.gets
+    FileUtils.mkpath(File.dirname(output))
+    File.open(output, "wb") do |f|
+      f.print "-*- coding: utf-8 -*-\n\n", line
+      log.each_line do |line|
+        line.sub!(/^(?!:)(?:Author|Commit)?(?:Date)?: /, '  \&')
+        line.sub!(/ +$/, '')
+        f.print(line)
+      end
+    end
+  end
+end
+
+tags = IO.popen(%w[git tag -l v[0-9]*]).grep(/v(.*)/) {$1}
+tags.sort_by! {|tag| tag.scan(/\d+/).map(&:to_i)}
+tags.inject(nil) do |prev, tag|
+  task("logs/ChangeLog-#{tag}") {|t| changelog[t.name, tag, prev]}
+  tag
+end
+
+desc "Make ChangeLog"
+task "ChangeLog", [:ver, :prev] do |t, ver: nil, prev: tags.last|
+  changelog[t.name, ver, prev]
+end
+
+changelogs = ["ChangeLog", *tags.map {|tag| "logs/ChangeLog-#{tag}"}]
+task "changelogs" => changelogs
+CLOBBER.concat(changelogs) << "logs"

data/rakelib/epoch.rake

@@ -0,0 +1,5 @@
+task "build" => "date_epoch"
+
+task "date_epoch" do
+  ENV["SOURCE_DATE_EPOCH"] = IO.popen(%W[git -C #{__dir__} log -1 --format=%ct], &:read).chomp
+end

data/rakelib/version.rake

@@ -0,0 +1,51 @@
+class << (helper = Bundler::GemHelper.instance)
+  def mainfile
+    "lib/#{File.basename(gemspec.loaded_from, ".gemspec")}.rb"
+  end
+
+  def update_version
+    File.open(mainfile, "r+b") do |f|
+      d = f.read
+      if d.sub!(/^(\s*OptionParser::Version\s*=\s*)".*"/) {$1 + gemspec.version.to_s.dump}
+        f.rewind
+        f.truncate(0)
+        f.print(d)
+      end
+    end
+  end
+
+  def commit_bump
+    sh(%W[git -C #{File.dirname(gemspec.loaded_from)} commit -m bump\ up\ to\ #{gemspec.version}
+          #{mainfile}])
+  end
+
+  def version=(v)
+    gemspec.version = v
+    update_version
+    commit_bump
+  end
+
+  def bump(major, minor = 0, teeny = 0, pre: nil)
+    self.version = [major, minor, teeny, pre].compact.join(".")
+  end
+end
+
+major, minor, teeny = helper.gemspec.version.segments
+
+task "bump:teeny", [:pre] do |t, pre: nil|
+  helper.bump(major, minor, teeny+1, pre: pre)
+end
+
+task "bump:minor", [:pre] do |t, pre: nil|
+  helper.bump(major, minor+1, pre: pre)
+end
+
+task "bump:major", [:pre] do |t, pre: nil|
+  helper.bump(major+1, pre: pre)
+end
+
+task "bump" => "bump:teeny"
+
+task "tag" do
+  helper.__send__(:tag_version)
+end

data/test/lib/helper.rb

@@ -0,0 +1,4 @@
+require "test/unit"
+require "core_assertions"
+
+Test::Unit::TestCase.include Test::Unit::CoreAssertions

data/test/optparse/test_acceptable.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: false
+require_relative 'test_optparse'
+
+class TestOptionParserAcceptable < TestOptionParser
+
+  def setup
+    super
+    @opt.def_option("--integer VAL", Integer) { |v| @integer = v }
+    @opt.def_option("--float VAL",   Float)   { |v| @float   = v }
+    @opt.def_option("--numeric VAL", Numeric) { |v| @numeric = v }
+
+    @opt.def_option("--decimal-integer VAL",
+                    OptionParser::DecimalInteger) { |i| @decimal_integer = i }
+    @opt.def_option("--octal-integer VAL",
+                    OptionParser::OctalInteger)   { |i| @octal_integer   = i }
+    @opt.def_option("--decimal-numeric VAL",
+                    OptionParser::DecimalNumeric) { |i| @decimal_numeric = i }
+  end
+
+  def test_integer
+    assert_equal(%w"", no_error {@opt.parse!(%w"--integer 0")})
+    assert_equal(0, @integer)
+
+    assert_equal(%w"", no_error {@opt.parse!(%w"--integer 0b10")})
+    assert_equal(2, @integer)
+
+    assert_equal(%w"", no_error {@opt.parse!(%w"--integer 077")})
+    assert_equal(63, @integer)
+
+    assert_equal(%w"", no_error {@opt.parse!(%w"--integer 10")})
+    assert_equal(10, @integer)
+
+    assert_equal(%w"", no_error {@opt.parse!(%w"--integer 0x3")})
+    assert_equal(3, @integer)
+
+    assert_raise(OptionParser::InvalidArgument) do
+      @opt.parse!(%w"--integer 0b")
+    end
+
+    assert_raise(OptionParser::InvalidArgument) do
+      @opt.parse!(%w"--integer 09")
+    end
+
+    assert_raise(OptionParser::InvalidArgument) do
+      @opt.parse!(%w"--integer 0x")
+    end
+
+    assert_raise(OptionParser::InvalidArgument) do
+      @opt.parse!(%w"--integer 1234xyz")
+    end
+  end
+
+  def test_float
+    assert_equal(%w"", no_error {@opt.parse!(%w"--float 0")})
+    assert_in_epsilon(0.0, @float)
+
+    assert_equal(%w"", no_error {@opt.parse!(%w"--float 0.0")})
+    assert_in_epsilon(0.0, @float)
+
+    assert_equal(%w"", no_error {@opt.parse!(%w"--float 1.2")})
+    assert_in_epsilon(1.2, @float)
+
+    assert_equal(%w"", no_error {@opt.parse!(%w"--float 1E2")})
+    assert_in_epsilon(100, @float)
+
+    assert_equal(%w"", no_error {@opt.parse!(%w"--float 1E-2")})
+    assert_in_epsilon(0.01, @float)
+
+    assert_raise(OptionParser::InvalidArgument) do
+      @opt.parse!(%w"--float 0e")
+    end
+
+    assert_raise(OptionParser::InvalidArgument) do
+      @opt.parse!(%w"--float 1.234xyz")
+    end
+  end
+
+  def test_numeric
+    assert_equal(%w"", no_error {@opt.parse!(%w"--numeric 0")})
+    assert_equal(0, @numeric)
+
+    assert_equal(%w"", no_error {@opt.parse!(%w"--numeric 0/1")})
+    assert_equal(0, @numeric)
+
+    assert_equal(%w"", no_error {@opt.parse!(%w"--numeric 1/2")})
+    assert_equal(Rational(1, 2), @numeric)
+
+    assert_equal(%w"", no_error {@opt.parse!(%w"--numeric 010")})
+    assert_equal(8, @numeric)
+
+    assert_equal(%w"", no_error {@opt.parse!(%w"--numeric 1.2/2.3")})
+    assert_equal(Rational(12, 23), @numeric)
+
+    assert_raise(OptionParser::InvalidArgument) do
+      @opt.parse!(%w"--numeric 1/")
+    end
+
+    assert_raise(OptionParser::InvalidArgument) do
+      @opt.parse!(%w"--numeric 12/34xyz")
+    end
+
+    assert_raise(OptionParser::InvalidArgument) do
+      @opt.parse!(%w"--numeric 12x/34yz")
+    end
+  end
+
+  def test_decimal_integer
+    assert_equal(%w"", no_error {@opt.parse!(%w"--decimal-integer 0")})
+    assert_equal(0, @decimal_integer)
+
+    assert_equal(%w"", no_error {@opt.parse!(%w"--decimal-integer 10")})
+    assert_equal(10, @decimal_integer)
+
+    assert_equal(%w"", no_error {@opt.parse!(%w"--decimal-integer 010")})
+    assert_equal(10, @decimal_integer)
+
+    assert_equal(%w"", no_error {@opt.parse!(%w"--decimal-integer 09")})
+    assert_equal(9, @decimal_integer)
+
+    assert_raise(OptionParser::InvalidArgument) do
+      @opt.parse!(%w"--decimal-integer 0b1")
+    end
+
+    assert_raise(OptionParser::InvalidArgument) do
+      @opt.parse!(%w"--decimal-integer x")
+    end
+
+    assert_raise(OptionParser::InvalidArgument) do
+      @opt.parse!(%w"--decimal-integer 1234xyz")
+    end
+  end
+
+  def test_octal_integer
+    assert_equal(%w"", no_error {@opt.parse!(%w"--octal-integer 0")})
+    assert_equal(0, @octal_integer)
+
+    assert_equal(%w"", no_error {@opt.parse!(%w"--octal-integer 6")})
+    assert_equal(6, @octal_integer)
+
+    assert_equal(%w"", no_error {@opt.parse!(%w"--octal-integer 07")})
+    assert_equal(7, @octal_integer)
+
+    assert_equal(%w"", no_error {@opt.parse!(%w"--octal-integer 10")})
+    assert_equal(8, @octal_integer)
+
+    assert_equal(%w"", no_error {@opt.parse!(%w"--octal-integer 011")})
+    assert_equal(9, @octal_integer)
+
+    assert_raise(OptionParser::InvalidArgument) do
+      @opt.parse!(%w"--octal-integer 09")
+    end
+
+    assert_raise(OptionParser::InvalidArgument) do
+      @opt.parse!(%w"--octal-integer 0b1")
+    end
+
+    assert_raise(OptionParser::InvalidArgument) do
+      @opt.parse!(%w"--octal-integer x")
+    end
+
+    assert_raise(OptionParser::InvalidArgument) do
+      @opt.parse!(%w"--octal-integer 01234xyz")
+    end
+  end
+
+  def test_decimal_numeric
+    assert_equal(%w"", no_error {@opt.parse!(%w"--decimal-numeric 0")})
+    assert_equal(0, @decimal_numeric)
+
+    assert_equal(%w"", no_error {@opt.parse!(%w"--decimal-numeric 01")})
+    assert_equal(1, @decimal_numeric)
+
+    assert_equal(%w"", no_error {@opt.parse!(%w"--decimal-numeric 1.2")})
+    assert_in_delta(1.2, @decimal_numeric)
+
+    assert_equal(%w"", no_error {@opt.parse!(%w"--decimal-numeric 1E2")})
+    assert_in_delta(100.0, @decimal_numeric)
+
+    assert_raise(OptionParser::InvalidArgument) do
+      @opt.parse!(%w"--decimal-numeric 0b1")
+    end
+
+    e = assert_raise(OptionParser::InvalidArgument) do
+      @opt.parse!(%w"--decimal-numeric 09")
+    end
+
+    assert_equal("invalid argument: --decimal-numeric 09", e.message)
+
+    assert_raise(OptionParser::InvalidArgument) do
+      @opt.parse!(%w"--decimal-integer 1234xyz")
+    end
+
+    assert_raise(OptionParser::InvalidArgument) do
+      @opt.parse!(%w"--decimal-integer 12.34xyz")
+    end
+  end
+
+end

data/test/optparse/test_autoconf.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: false
+require 'test/unit'
+require 'optparse/ac'
+
+class TestOptionParserAutoConf < Test::Unit::TestCase
+  def setup
+    @opt = OptionParser::AC.new
+    @foo = @bar = self.class
+    @opt.ac_arg_enable("foo", "foo option") {|x| @foo = x}
+    @opt.ac_arg_disable("bar", "bar option") {|x| @bar = x}
+    @opt.ac_arg_with("zot", "zot option") {|x| @zot = x}
+  end
+
+  class DummyOutput < String
+    alias write concat
+  end
+  def no_error(*args)
+    $stderr, stderr = DummyOutput.new, $stderr
+    assert_nothing_raised(*args) {return yield}
+  ensure
+    stderr, $stderr = $stderr, stderr
+    $!.backtrace.delete_if {|e| /\A#{Regexp.quote(__FILE__)}:#{__LINE__-2}/o =~ e} if $!
+    assert_empty(stderr)
+  end
+
+  def test_enable
+    @opt.parse!(%w"--enable-foo")
+    assert_equal(true, @foo)
+    @opt.parse!(%w"--enable-bar")
+    assert_equal(true, @bar)
+  end
+
+  def test_enable_value
+    @opt.parse!(%w"--enable-foo=A")
+    assert_equal("A", @foo)
+    @opt.parse!(%w"--enable-bar=B")
+    assert_equal("B", @bar)
+  end
+
+  def test_disable
+    @opt.parse!(%w"--disable-foo")
+    assert_equal(false, @foo)
+    @opt.parse!(%w"--disable-bar")
+    assert_equal(false, @bar)
+  end
+
+  def test_with
+    @opt.parse!(%w"--with-zot=foobar")
+    assert_equal("foobar", @zot)
+    @opt.parse!(%w"--without-zot")
+    assert_nil(@zot)
+  end
+
+  def test_without
+    @opt.parse!(%w"--without-zot")
+    assert_nil(@zot)
+    assert_raise(OptionParser::NeedlessArgument) {@opt.parse!(%w"--without-zot=foobar")}
+  end
+
+  def test_help
+    help = @opt.help
+    assert_match(/--enable-foo/, help)
+    assert_match(/--disable-bar/, help)
+    assert_match(/--with-zot/, help)
+    assert_not_match(/--disable-foo/, help)
+    assert_not_match(/--enable-bar/, help)
+    assert_not_match(/--without/, help)
+  end
+end

data/test/optparse/test_bash_completion.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: false
+require 'test/unit'
+require 'optparse'
+
+class TestOptionParserBashCompletion < Test::Unit::TestCase
+  def setup
+    @opt = OptionParser.new
+    @opt.define("-z", "zzz") {}
+    @opt.define("--foo") {}
+    @opt.define("--bar=BAR") {}
+    @opt.define("--for=TYPE", [:hello, :help, :zot]) {}
+  end
+
+  def test_empty
+    assert_equal([], @opt.candidate(""))
+  end
+
+  def test_one_hyphen
+    assert_equal(%w[-z --foo --bar= --for=], @opt.candidate("-"))
+  end
+
+  def test_two_hyphen
+    assert_equal(%w[--foo --bar= --for=], @opt.candidate("--"))
+  end
+
+  def test_long_f
+    assert_equal(%w[--foo --for=], @opt.candidate("--f"))
+  end
+
+  def test_long_for_option
+    assert_equal(%w[--for=], @opt.candidate("--for"))
+  end
+
+  def test_long_for_option_args
+    assert_equal(%w[hello help zot], @opt.candidate("--for="))
+  end
+
+  def test_long_for_option_complete
+    assert_equal(%w[hello help], @opt.candidate("--for=h"))
+  end
+
+  def test_case_sensitive
+    @opt.define("-Z") {}
+    assert_equal(%w[-z], @opt.candidate("-z"))
+  end
+end

data/test/optparse/test_cclass.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: false
+require_relative 'test_optparse'
+
+class TestOptionParserCClass < TestOptionParser
+  def test_no_argument
+    flags = []
+    @opt.def_option("-[a-z]") {|x| flags << x}
+    no_error {@opt.parse!(%w"-a")}
+    assert_equal(%w"a", flags)
+  end
+
+  def test_required_argument
+    flags = []
+    @opt.def_option("-[a-z]X") {|x| flags << x}
+    no_error {@opt.parse!(%w"-a")}
+    assert_equal(%w"a", flags)
+  end
+end

data/test/optparse/test_did_you_mean.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: false
+require_relative 'test_optparse'
+begin
+  require "did_you_mean"
+rescue LoadError
+  return
+end
+
+class TestOptionParserDidYouMean < TestOptionParser
+  def setup
+    super
+    @opt.def_option("--foo", Integer) { |v| @foo = v }
+    @opt.def_option("--bar", Integer) { |v| @bar = v }
+    @opt.def_option("--baz", Integer) { |v| @baz = v }
+    @formatter = ::DidYouMean.formatter
+    if ::DidYouMean.const_defined?(:Formatter)
+      ::DidYouMean.formatter = ::DidYouMean::Formatter
+    else
+      case @formatter
+      when ::DidYouMean::PlainFormatter
+      else
+        ::DidYouMean.formatter = ::DidYouMean::PlainFormatter.new
+      end
+    end
+  end
+
+  def teardown
+    ::DidYouMean.formatter = @formatter
+  end
+
+  def test_no_suggestion
+    assert_raise_with_message(OptionParser::InvalidOption, "invalid option: --cuz") do
+      @opt.permute!(%w"--cuz")
+    end
+  end
+
+  def test_plain
+    assert_raise_with_message(OptionParser::InvalidOption, /invalid option: --baa\nDid you mean\?\s+bar\s+baz\Z/) do
+      @opt.permute!(%w"--baa")
+    end
+  end
+
+  def test_ambiguous
+    assert_raise_with_message(OptionParser::AmbiguousOption, /ambiguous option: --ba\nDid you mean\?\s+bar\s+baz\Z/) do
+      @opt.permute!(%w"--ba")
+    end
+  end
+end

data/test/optparse/test_getopts.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: false
+require 'test/unit'
+require 'optparse'
+
+class TestOptionParserGetopts < Test::Unit::TestCase
+  def setup
+    @opt = OptionParser.new
+  end
+
+  def test_short_noarg
+    o = @opt.getopts(%w[-a], "ab")
+    assert_equal(true, o['a'])
+    assert_equal(false, o['b'])
+
+    o = @opt.getopts(%w[-a], "ab", symbolize_names: true)
+    assert_equal(true, o[:a])
+    assert_equal(false, o[:b])
+  end
+
+  def test_short_arg
+    o = @opt.getopts(%w[-a1], "a:b:")
+    assert_equal("1", o['a'])
+    assert_equal(nil, o['b'])
+
+    o = @opt.getopts(%w[-a1], "a:b:", symbolize_names: true)
+    assert_equal("1", o[:a])
+    assert_equal(nil, o[:b])
+  end
+
+  def test_long_noarg
+    o = @opt.getopts(%w[--foo], "", "foo", "bar")
+    assert_equal(true, o['foo'])
+    assert_equal(false, o['bar'])
+
+    o = @opt.getopts(%w[--foo], "", "foo", "bar", symbolize_names: true)
+    assert_equal(true, o[:foo])
+    assert_equal(false, o[:bar])
+  end
+
+  def test_long_arg
+    o = @opt.getopts(%w[--bar ZOT], "", "foo:FOO", "bar:BAR")
+    assert_equal("FOO", o['foo'])
+    assert_equal("ZOT", o['bar'])
+
+    o = @opt.getopts(%w[--bar ZOT], "", "foo:FOO", "bar:BAR", symbolize_names: true)
+    assert_equal("FOO", o[:foo])
+    assert_equal("ZOT", o[:bar])
+  end
+end

data/test/optparse/test_kwargs.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: false
+require 'test/unit'
+require 'optparse'
+require 'optparse/kwargs'
+
+class TestOptionParserKwArg < Test::Unit::TestCase
+  class K
+    def initialize(host:, port: 8080)
+      @host = host
+      @port = port
+    end
+  end
+
+  class DummyOutput < String
+    alias write concat
+  end
+  def assert_no_error(*args)
+    $stderr, stderr = DummyOutput.new, $stderr
+    assert_nothing_raised(*args) {return yield}
+  ensure
+    stderr, $stderr = $stderr, stderr
+    $!.backtrace.delete_if {|e| /\A#{Regexp.quote(__FILE__)}:#{__LINE__-2}/o =~ e} if $!
+    assert_empty(stderr)
+  end
+  alias no_error assert_no_error
+
+  def test_kwarg
+    opt = OptionParser.new
+    options = opt.define_by_keywords({}, K.instance_method(:initialize),
+                                     port: [Integer])
+    assert_raise(OptionParser::MissingArgument) {opt.parse!(%w"--host")}
+    assert_nothing_raised {opt.parse!(%w"--host=localhost")}
+    assert_equal("localhost", options[:host])
+    assert_nothing_raised {opt.parse!(%w"--port")}
+    assert_nothing_raised {opt.parse!(%w"--port=80")}
+    assert_equal(80, options[:port])
+  end
+end