getopt 1.4.2 → 1.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f54f1e6653d0a5c7be3fe5980cd54dbadb36ee6a
-  data.tar.gz: 18ee08f16d15ad19931458fbd3146257adeb84aa
+  metadata.gz: e01b97f25a4930c245cb4297d867d3c99db93bea
+  data.tar.gz: bae1d1f080a05aa8c87010f7b141caaefe71d94a
 SHA512:
-  metadata.gz: 450e1d25c05e828390a3b333e5d39eb474ab2c63b26643b8cddf71efa9ff548498d7340115c651099fc84b545dffd10902279e8013671fccc91df38bb4b9fe14
-  data.tar.gz: cccc37509314d516557763cd97615f8562afca023311374ca704c0a03f3690dc00a23a83cd3d83f3e74f1c0ef975f2df2ed4dd11550a871cf4073f007c1cbeee
+  metadata.gz: cb33d4cc4bc8b1f1afa3a99b3297f8e3bb79cebfd1a7bd2f7e97493c6198dc1ab6b3f0654bb22ed509a2b1079facb83e11ffe82428fa17f4676424373a3907fa
+  data.tar.gz: 6c8cd8707a430ee5727a43b5cb1854e169ad8838f6f42c95a37a2550c8d1e4f9c22e390be55487431f8cbe861ddf33ba8817d4dbf288eb9771b66224d8424283

data/CHANGES

@@ -1,3 +1,8 @@
+== 1.4.3 - 7-Jan-2016
+* This gem is now signed.
+* The gem related tasks in the Rakefile now assume Rubygems 2.x.
+* Added getopt.rb, getopt-std.rb and getopt-long.rb files for convenience.
+
 == 1.4.2 - 12-Oct-2014
 * Updated Rakefile, README and gemspec.
 * Minor updates to the test file and examples.

data/MANIFEST

@@ -3,9 +3,13 @@
 * README
 * Rakefile
 * getopt.gemspec
+* certs/djberg96_pub.pem
 * examples/example_std.rb
 * examples/example_long.rb
-* lib/getopt/std.rb
+* lib/getopt.rb
+* lib/getopt-long.rb
+* lib/getopt-std.rb
 * lib/getopt/long.rb
-* test/test_getopt_std.rb
+* lib/getopt/std.rb
 * test/test_getopt_long.rb
+* test/test_getopt_std.rb

data/README

@@ -184,7 +184,7 @@ INCREMENT
   Artistic 2.0
 
 = Copyright
-  (C) 2005-2014, Daniel J. Berger
+  (C) 2005-2016, Daniel J. Berger
   All Rights Reserved
 
 = Author

data/Rakefile

@@ -7,13 +7,10 @@ CLEAN.include("**/*.gem", "**/*.rbc")
 namespace :gem do
   desc "Create the getopt gem"
   task :create => [:clean] do
+    require 'rubygems/package'
     spec = eval(IO.read('getopt.gemspec'))
-    if Gem::VERSION < "2.0"
-      Gem::Builder.new(spec).build
-    else
-      require 'rubygems/package'
-      Gem::Package.build(spec)
-    end
+    spec.signing_key = File.join(Dir.home, '.ssh', 'gem-private_key.pem')
+    Gem::Package.build(spec, true)
   end
 
   desc "Install the getopt gem"

data/certs/djberg96_pub.pem

@@ -0,0 +1,21 @@
+-----BEGIN CERTIFICATE-----
+MIIDcDCCAligAwIBAgIBATANBgkqhkiG9w0BAQUFADA/MREwDwYDVQQDDAhkamJl
+cmc5NjEVMBMGCgmSJomT8ixkARkWBWdtYWlsMRMwEQYKCZImiZPyLGQBGRYDY29t
+MB4XDTE1MDkwMjIwNDkxOFoXDTE2MDkwMTIwNDkxOFowPzERMA8GA1UEAwwIZGpi
+ZXJnOTYxFTATBgoJkiaJk/IsZAEZFgVnbWFpbDETMBEGCgmSJomT8ixkARkWA2Nv
+bTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMyTkvXqRp6hLs9eoJOS
+Hmi8kRYbq9Vkf15/hMxJpotYMgJVHHWrmDcC5Dye2PbnXjTkKf266Zw0PtT9h+lI
+S3ts9HO+vaCFSMwFFZmnWJSpQ3CNw2RcHxjWkk9yF7imEM8Kz9ojhiDXzBetdV6M
+gr0lV/alUr7TNVBDngbXEfTWscyXh1qd7xZ4EcOdsDktCe5G45N/o3662tPQvJsi
+FOF0CM/KuBsa/HL1/eoEmF4B3EKIRfTHrQ3hu20Kv3RJ88QM4ec2+0dd97uX693O
+zv6981fyEg+aXLkxrkViM/tz2qR2ZE0jPhHTREPYeMEgptRkTmWSKAuLVWrJEfgl
+DtkCAwEAAaN3MHUwCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAwHQYDVR0OBBYEFEwe
+nn6bfJADmuIDiMSOzedOrL+xMB0GA1UdEQQWMBSBEmRqYmVyZzk2QGdtYWlsLmNv
+bTAdBgNVHRIEFjAUgRJkamJlcmc5NkBnbWFpbC5jb20wDQYJKoZIhvcNAQEFBQAD
+ggEBAHmNOCWoDVD75zHFueY0viwGDVP1BNGFC+yXcb7u2GlK+nEMCORqzURbYPf7
+tL+/hzmePIRz7i30UM//64GI1NLv9jl7nIwjhPpXpf7/lu2I9hOTsvwSumb5UiKC
+/sqBxI3sfj9pr79Wpv4MuikX1XPik7Ncb7NPsJPw06Lvyc3Hkg5X2XpPtLtS+Gr2
+wKJnmzb5rIPS1cmsqv0M9LPWflzfwoZ/SpnmhagP+g05p8bRNKjZSA2iImM/GyYZ
+EJYzxdPOrx2n6NYR3Hk+vHP0U7UBSveI6+qx+ndQYaeyCn+GRX2PKS9h66YF/Q1V
+tGSHgAmcLlkdGgan182qsE/4kKM=
+-----END CERTIFICATE-----

data/getopt.gemspec

@@ -2,7 +2,7 @@ require 'rubygems'
 
 Gem::Specification.new do |spec|
   spec.name       = 'getopt'
-  spec.version    = '1.4.2'
+  spec.version    = '1.4.3'
   spec.author     = 'Daniel J. Berger'
   spec.license    = 'Artistic 2.0'
   spec.email      = 'djberg96@gmail.com'
@@ -10,6 +10,7 @@ Gem::Specification.new do |spec|
   spec.summary    = 'Getopt::Std and Getopt::Long option parsers for Ruby'
   spec.test_files = Dir['test/*.rb']
   spec.files      = Dir['**/*'].reject{ |f| f.include?('git') }
+  spec.cert_chain = Dir['certs/*']
 
   spec.extra_rdoc_files  = ['README', 'CHANGES', 'MANIFEST']
    

data/lib/getopt-long.rb

@@ -0,0 +1 @@
+require_relative 'getopt/long'

data/lib/getopt-std.rb

@@ -0,0 +1 @@
+require_relative 'getopt/std'

data/lib/getopt.rb

@@ -0,0 +1,2 @@
+require_relative 'getopt/std'
+require_relative 'getopt/long'

data/lib/getopt/long.rb

@@ -17,7 +17,7 @@ module Getopt
       class Error < StandardError; end
 
       # The version of the getopt library
-      VERSION = '1.4.2'
+      VERSION = '1.4.3'
 
       # Takes an array of switches. Each array consists of up to three
       # elements that indicate the name and type of switch. Returns a hash

data/lib/getopt/std.rb

@@ -10,7 +10,7 @@ module Getopt
       class Error < StandardError; end
 
       # The version of the getopt library
-      VERSION = '1.4.2'
+      VERSION = '1.4.3'
 
       # Processes single character command line options with option
       # clustering.  This information is parsed from ARGV and returned

data/test/test_getopt_long.rb

@@ -9,256 +9,256 @@ require 'getopt/long'
 include Getopt
 
 class TC_Getopt_Long < Test::Unit::TestCase
-   def setup
-      @opts = nil
-   end
+  def setup
+    @opts = nil
+  end
 
-   def test_version
-      assert_equal('1.4.2', Long::VERSION)
-   end
+  def test_version
+    assert_equal('1.4.3', Long::VERSION)
+  end
 
-   def test_constants
-      assert_not_nil(BOOLEAN)
-      assert_not_nil(OPTIONAL)
-      assert_not_nil(REQUIRED)
-      assert_not_nil(INCREMENT)
-   end
+  def test_constants
+    assert_not_nil(BOOLEAN)
+    assert_not_nil(OPTIONAL)
+    assert_not_nil(REQUIRED)
+    assert_not_nil(INCREMENT)
+  end
 
-   def test_getopts_basic
-      assert_respond_to(Long, :getopts)
-      assert_nothing_raised{
-         Long.getopts(["--test"],["--help"],["--foo"])
-      }
-      assert_nothing_raised{
-         Long.getopts(["--test", "-x"],["--help", "-y"],["--foo", "-z"])
-      }
-      assert_nothing_raised{
-         Long.getopts(
-            ["--test", "-x", BOOLEAN],
-            ["--help", "-y", REQUIRED],
-            ["--foo",  "-z", OPTIONAL],
-            ["--more", "-m", INCREMENT]
-         )
-      }
-      assert_kind_of(Hash, Long.getopts("--test"))
-   end
+  def test_getopts_basic
+    assert_respond_to(Long, :getopts)
+    assert_nothing_raised{
+      Long.getopts(["--test"],["--help"],["--foo"])
+    }
+    assert_nothing_raised{
+      Long.getopts(["--test", "-x"],["--help", "-y"],["--foo", "-z"])
+    }
+    assert_nothing_raised{
+      Long.getopts(
+        ["--test", "-x", BOOLEAN],
+        ["--help", "-y", REQUIRED],
+        ["--foo",  "-z", OPTIONAL],
+        ["--more", "-m", INCREMENT]
+      )
+    }
+    assert_kind_of(Hash, Long.getopts("--test"))
+  end
 
-   def test_getopts_using_equals
-      ARGV.push("--foo=hello","-b","world")
-      assert_nothing_raised{
-         @opts = Long.getopts(
-            ["--foo", "-f", REQUIRED],
-            ["--bar", "-b", OPTIONAL]
-         )
-      }
-      assert_equal("hello", @opts["foo"])
-      assert_equal("hello", @opts["f"])
-      assert_equal("world", @opts["bar"])
-      assert_equal("world", @opts["b"])
-   end
+  def test_getopts_using_equals
+    ARGV.push("--foo=hello","-b","world")
+    assert_nothing_raised{
+      @opts = Long.getopts(
+        ["--foo", "-f", REQUIRED],
+        ["--bar", "-b", OPTIONAL]
+      )
+    }
+    assert_equal("hello", @opts["foo"])
+    assert_equal("hello", @opts["f"])
+    assert_equal("world", @opts["bar"])
+    assert_equal("world", @opts["b"])
+  end
 
-   def test_getopts_long_embedded_hyphens
-      ARGV.push('--foo-bar', 'hello', '--test1-test2-test3', 'world')
-      assert_nothing_raised{
-         @opts = Long.getopts(
-            ['--foo-bar', '-f', REQUIRED],
-            ['--test1-test2-test3', '-t', REQUIRED]
-         )
-      }
-      assert_equal('hello', @opts['foo-bar'])
-      assert_equal('hello', @opts['f'])
-      assert_equal('world', @opts['test1-test2-test3'])
-      assert_equal('world', @opts['t'])
-   end
+  def test_getopts_long_embedded_hyphens
+    ARGV.push('--foo-bar', 'hello', '--test1-test2-test3', 'world')
+    assert_nothing_raised{
+      @opts = Long.getopts(
+        ['--foo-bar', '-f', REQUIRED],
+        ['--test1-test2-test3', '-t', REQUIRED]
+      )
+    }
+    assert_equal('hello', @opts['foo-bar'])
+    assert_equal('hello', @opts['f'])
+    assert_equal('world', @opts['test1-test2-test3'])
+    assert_equal('world', @opts['t'])
+  end
 
-   def test_getopts_long_embedded_hyphens_using_equals_sign
-      ARGV.push('--foo-bar=hello', '--test1-test2-test3=world')
-      assert_nothing_raised{
-         @opts = Long.getopts(
-            ['--foo-bar', '-f', REQUIRED],
-            ['--test1-test2-test3', '-t', REQUIRED]
-         )
-      }
-      assert_equal('hello', @opts['foo-bar'])
-      assert_equal('hello', @opts['f'])
-      assert_equal('world', @opts['test1-test2-test3'])
-      assert_equal('world', @opts['t'])
-   end
+  def test_getopts_long_embedded_hyphens_using_equals_sign
+    ARGV.push('--foo-bar=hello', '--test1-test2-test3=world')
+    assert_nothing_raised{
+      @opts = Long.getopts(
+        ['--foo-bar', '-f', REQUIRED],
+        ['--test1-test2-test3', '-t', REQUIRED]
+      )
+    }
+    assert_equal('hello', @opts['foo-bar'])
+    assert_equal('hello', @opts['f'])
+    assert_equal('world', @opts['test1-test2-test3'])
+    assert_equal('world', @opts['t'])
+  end
 
-   def test_getopts_short_switch_squished
-      ARGV.push("-f", "hello", "-bworld")
-      assert_nothing_raised{
-         @opts = Long.getopts(
-            ["--foo", "-f", REQUIRED],
-            ["--bar", "-b", OPTIONAL]
-         )
-      }
-      assert_equal("hello", @opts["f"])
-      assert_equal("world", @opts["b"])
-   end
+  def test_getopts_short_switch_squished
+    ARGV.push("-f", "hello", "-bworld")
+    assert_nothing_raised{
+      @opts = Long.getopts(
+        ["--foo", "-f", REQUIRED],
+        ["--bar", "-b", OPTIONAL]
+      )
+    }
+    assert_equal("hello", @opts["f"])
+    assert_equal("world", @opts["b"])
+  end
 
-   def test_getopts_increment_type
-      ARGV.push("-m","-m")
-      assert_nothing_raised{
-         @opts = Long.getopts(["--more", "-m", INCREMENT])
-      }
-      assert_equal(2, @opts["more"])
-      assert_equal(2, @opts["m"])
-   end
+  def test_getopts_increment_type
+    ARGV.push("-m","-m")
+    assert_nothing_raised{
+      @opts = Long.getopts(["--more", "-m", INCREMENT])
+    }
+    assert_equal(2, @opts["more"])
+    assert_equal(2, @opts["m"])
+  end
 
-   def test_switches_exist
-      ARGV.push("--verbose","--test","--foo")
-      assert_nothing_raised{ @opts = Long.getopts("--verbose --test --foo") }
-      assert_equal(true, @opts.has_key?("verbose"))
-      assert_equal(true, @opts.has_key?("test"))
-      assert_equal(true, @opts.has_key?("foo"))
-   end
+  def test_switches_exist
+    ARGV.push("--verbose","--test","--foo")
+    assert_nothing_raised{ @opts = Long.getopts("--verbose --test --foo") }
+    assert_equal(true, @opts.has_key?("verbose"))
+    assert_equal(true, @opts.has_key?("test"))
+    assert_equal(true, @opts.has_key?("foo"))
+  end
 
-   def test_short_switch_synonyms
-      ARGV.push("--verbose","--test","--foo")
-      assert_nothing_raised{ @opts = Long.getopts("--verbose --test --foo") }
-      assert_equal(true, @opts.has_key?("v"))
-      assert_equal(true, @opts.has_key?("t"))
-      assert_equal(true, @opts.has_key?("f"))
-   end
+  def test_short_switch_synonyms
+    ARGV.push("--verbose","--test","--foo")
+    assert_nothing_raised{ @opts = Long.getopts("--verbose --test --foo") }
+    assert_equal(true, @opts.has_key?("v"))
+    assert_equal(true, @opts.has_key?("t"))
+    assert_equal(true, @opts.has_key?("f"))
+  end
 
-   def test_short_switch_synonyms_with_explicit_types
-      ARGV.push("--verbose", "--test", "hello", "--foo")
-      assert_nothing_raised{
-         @opts = Long.getopts(
-            ["--verbose", BOOLEAN],
-            ["--test", REQUIRED],
-            ["--foo", BOOLEAN]
-         )
-      }
-      assert(@opts.has_key?("v"))
-      assert(@opts.has_key?("t"))
-      assert(@opts.has_key?("f"))
-   end
+  def test_short_switch_synonyms_with_explicit_types
+    ARGV.push("--verbose", "--test", "hello", "--foo")
+    assert_nothing_raised{
+      @opts = Long.getopts(
+        ["--verbose", BOOLEAN],
+        ["--test", REQUIRED],
+        ["--foo", BOOLEAN]
+      )
+    }
+    assert(@opts.has_key?("v"))
+    assert(@opts.has_key?("t"))
+    assert(@opts.has_key?("f"))
+  end
 
-   def test_switches_with_required_arguments
-      ARGV.push("--foo","1","--bar","hello")
-      assert_nothing_raised{
-         @opts = Long.getopts(
-            ["--foo", "-f", REQUIRED],
-            ["--bar", "-b", REQUIRED]
-         )
-      }
-      assert_equal({"foo"=>"1", "bar"=>"hello", "f"=>"1", "b"=>"hello"}, @opts)
-   end
+  def test_switches_with_required_arguments
+    ARGV.push("--foo","1","--bar","hello")
+    assert_nothing_raised{
+      @opts = Long.getopts(
+        ["--foo", "-f", REQUIRED],
+        ["--bar", "-b", REQUIRED]
+      )
+    }
+    assert_equal({"foo"=>"1", "bar"=>"hello", "f"=>"1", "b"=>"hello"}, @opts)
+  end
 
-   def test_compressed_switches
-      ARGV.push("-fb")
-      assert_nothing_raised{
-         @opts = Long.getopts(
-            ["--foo", "-f", BOOLEAN],
-            ["--bar", "-b", BOOLEAN]
-         )
-      }
-      assert_equal({"foo"=>true, "f"=>true, "b"=>true, "bar"=>true}, @opts)
-   end
+  def test_compressed_switches
+    ARGV.push("-fb")
+    assert_nothing_raised{
+      @opts = Long.getopts(
+        ["--foo", "-f", BOOLEAN],
+        ["--bar", "-b", BOOLEAN]
+      )
+    }
+    assert_equal({"foo"=>true, "f"=>true, "b"=>true, "bar"=>true}, @opts)
+  end
 
-   def test_compress_switches_with_required_arg
-      ARGV.push("-xf", "foo.txt")
-      assert_nothing_raised{
-         @opts = Long.getopts(
-            ["--expand", "-x", BOOLEAN],
-            ["--file", "-f", REQUIRED]
-         )
-      }
-      assert_equal(
-         {"x"=>true, "expand"=>true, "f"=>"foo.txt", "file"=>"foo.txt"}, @opts
+  def test_compress_switches_with_required_arg
+    ARGV.push("-xf", "foo.txt")
+    assert_nothing_raised{
+      @opts = Long.getopts(
+        ["--expand", "-x", BOOLEAN],
+        ["--file", "-f", REQUIRED]
       )
-   end
+    }
+    assert_equal(
+      {"x"=>true, "expand"=>true, "f"=>"foo.txt", "file"=>"foo.txt"}, @opts
+    )
+  end
 
-   def test_compress_switches_with_compressed_required_arg
-      ARGV.push("-xffoo.txt")
-      assert_nothing_raised{
-         @opts = Long.getopts(
-            ["--expand", "-x", BOOLEAN],
-            ["--file", "-f", REQUIRED]
-         )
-      }
-      assert_equal(
-         {"x"=>true, "expand"=>true, "f"=>"foo.txt", "file"=>"foo.txt"}, @opts
+  def test_compress_switches_with_compressed_required_arg
+    ARGV.push("-xffoo.txt")
+    assert_nothing_raised{
+      @opts = Long.getopts(
+        ["--expand", "-x", BOOLEAN],
+        ["--file", "-f", REQUIRED]
       )
-   end
+    }
+    assert_equal(
+     {"x"=>true, "expand"=>true, "f"=>"foo.txt", "file"=>"foo.txt"}, @opts
+    )
+  end
 
-   def test_compress_switches_with_optional_arg_not_defined
-      ARGV.push("-xf")
-      assert_nothing_raised{
-         @opts = Long.getopts(
-            ["--expand", "-x", BOOLEAN],
-            ["--file", "-f", OPTIONAL]
-         )
-      }
-      assert_equal(
-         {"x"=>true, "expand"=>true, "f"=>nil, "file"=>nil}, @opts
+  def test_compress_switches_with_optional_arg_not_defined
+    ARGV.push("-xf")
+    assert_nothing_raised{
+      @opts = Long.getopts(
+        ["--expand", "-x", BOOLEAN],
+        ["--file", "-f", OPTIONAL]
       )
-   end
+    }
+    assert_equal(
+      {"x"=>true, "expand"=>true, "f"=>nil, "file"=>nil}, @opts
+    )
+  end
 
-   def test_compress_switches_with_optional_arg
-      ARGV.push("-xf", "boo.txt")
-      assert_nothing_raised{
-         @opts = Long.getopts(
-            ["--expand", "-x", BOOLEAN],
-            ["--file", "-f", OPTIONAL]
-         )
-      }
-      assert_equal(
-         {"x"=>true, "expand"=>true, "f"=>"boo.txt", "file"=>"boo.txt"}, @opts
+  def test_compress_switches_with_optional_arg
+    ARGV.push("-xf", "boo.txt")
+    assert_nothing_raised{
+      @opts = Long.getopts(
+        ["--expand", "-x", BOOLEAN],
+        ["--file", "-f", OPTIONAL]
       )
-   end
+    }
+    assert_equal(
+      {"x"=>true, "expand"=>true, "f"=>"boo.txt", "file"=>"boo.txt"}, @opts
+    )
+  end
 
-   def test_compress_switches_with_compressed_optional_arg
-      ARGV.push("-xfboo.txt")
-      assert_nothing_raised{
-         @opts = Long.getopts(
-            ["--expand", "-x", BOOLEAN],
-            ["--file", "-f", OPTIONAL]
-         )
-      }
-      assert_equal(
-         {"x"=>true, "expand"=>true, "f"=>"boo.txt", "file"=>"boo.txt"}, @opts
+  def test_compress_switches_with_compressed_optional_arg
+    ARGV.push("-xfboo.txt")
+    assert_nothing_raised{
+      @opts = Long.getopts(
+        ["--expand", "-x", BOOLEAN],
+        ["--file", "-f", OPTIONAL]
       )
-   end
+    }
+    assert_equal(
+     {"x"=>true, "expand"=>true, "f"=>"boo.txt", "file"=>"boo.txt"}, @opts
+    )
+  end
 
-   def test_compressed_short_and_long_mixed
-      ARGV.push("-xb", "--file", "boo.txt", "-v")
-      assert_nothing_raised{
-         @opts = Long.getopts(
-            ["--expand", "-x", BOOLEAN],
-            ["--verbose", "-v", BOOLEAN],
-            ["--file", "-f", REQUIRED],
-            ["--bar", "-b", OPTIONAL]
-         )
-         assert_equal(
-            { "x"=>true, "expand"=>true,
-              "v"=>true, "verbose"=>true,
-              "f"=>"boo.txt", "file"=>"boo.txt",
-              "b"=>nil, "bar"=>nil
-            },
-            @opts
-         )
-      }
-   end
+  def test_compressed_short_and_long_mixed
+    ARGV.push("-xb", "--file", "boo.txt", "-v")
+    assert_nothing_raised{
+      @opts = Long.getopts(
+        ["--expand", "-x", BOOLEAN],
+        ["--verbose", "-v", BOOLEAN],
+        ["--file", "-f", REQUIRED],
+        ["--bar", "-b", OPTIONAL]
+      )
+      assert_equal(
+        { "x"=>true, "expand"=>true,
+          "v"=>true, "verbose"=>true,
+          "f"=>"boo.txt", "file"=>"boo.txt",
+          "b"=>nil, "bar"=>nil
+        },
+        @opts
+      )
+    }
+  end
 
-   def test_multiple_similar_long_switches_with_no_short_switches
-      ARGV.push('--to','1','--too','2','--tooo','3')
-      assert_nothing_raised{
-         @opts = Long.getopts(
-            ["--to",  REQUIRED],
-            ["--too", REQUIRED],
-            ["--tooo", REQUIRED]
-         )
-      }
-      assert_equal('1', @opts['to'])
-      assert_equal('2', @opts['too'])
-      assert_equal('3', @opts['tooo'])
-   end
+  def test_multiple_similar_long_switches_with_no_short_switches
+    ARGV.push('--to','1','--too','2','--tooo','3')
+    assert_nothing_raised{
+      @opts = Long.getopts(
+        ["--to",  REQUIRED],
+        ["--too", REQUIRED],
+        ["--tooo", REQUIRED]
+      )
+    }
+    assert_equal('1', @opts['to'])
+    assert_equal('2', @opts['too'])
+    assert_equal('3', @opts['tooo'])
+  end
 
-   def teardown
-      @opts = nil
-      ARGV.clear
-   end
+  def teardown
+    @opts = nil
+    ARGV.clear
+  end
 end

data/test/test_getopt_std.rb

@@ -9,117 +9,116 @@ require 'getopt/std'
 include Getopt
 
 class TC_Getopt_Std < Test::Unit::TestCase
-
-   def test_version
-      assert_equal('1.4.2', Std::VERSION)
-   end
-
-   def test_getopts_basic
-      assert_respond_to(Std, :getopts)
-      assert_nothing_raised{ Std.getopts("ID") }
-      assert_kind_of(Hash, Std.getopts("ID"))
-   end
-
-   def test_getopts_separated_switches
-      ARGV.push("-I", "-D")
-      assert_equal({"I"=>true, "D"=>true}, Std.getopts("ID"))
-   end
-
-   # Inspired by RF bug #23477
-   def test_getopts_arguments_that_match_switch_are_ok
-      ARGV.push("-d", "d")
-      assert_equal({"d" => "d"}, Std.getopts("d:"))
-
-      ARGV.push("-d", "ad")
-      assert_equal({"d" => "ad"}, Std.getopts("d:"))
-
-      ARGV.push("-a", "ad")
-      assert_equal({"a" => "ad"}, Std.getopts("d:a:"))
-
-      ARGV.push("-a", "da")
-      assert_equal({"a" => "da"}, Std.getopts("d:a:"))
-
-      ARGV.push("-a", "d")
-      assert_equal({"a" => "d"}, Std.getopts("d:a:"))
-
-      ARGV.push("-a", "dad")
-      assert_equal({"a" => "dad"}, Std.getopts("d:a:"))
-
-      ARGV.push("-d", "d", "-a", "a")
-      assert_equal({"d" => "d", "a" => "a"}, Std.getopts("d:a:"))
-   end
-
-   def test_getopts_joined_switches
-      ARGV.push("-ID")
-      assert_equal({"I"=>true, "D"=>true}, Std.getopts("ID"))
-   end
-
-   def test_getopts_separated_switches_with_mandatory_arg
-      ARGV.push("-o", "hello", "-I", "-D")
-      assert_equal({"o"=>"hello", "I"=>true, "D"=>true}, Std.getopts("o:ID"))
-   end
-
-   def test_getopts_joined_switches_with_mandatory_arg
-      ARGV.push("-IDo", "hello")
-      assert_equal({"o"=>"hello", "I"=>true, "D"=>true}, Std.getopts("o:ID"))
-   end
-
-   def test_getopts_no_args
-      assert_nothing_raised{ Std.getopts("ID") }
-      assert_equal({}, Std.getopts("ID"))
-      assert_nil(Std.getopts("ID")["I"])
-      assert_nil(Std.getopts("ID")["D"])
-   end
-
-   # If a switch that accepts an argument appears more than once, the values
-   # are rolled into an array.
-   def test_getopts_switch_repeated
-      ARGV.push("-I", "-I", "-o", "hello", "-o", "world")
-      assert_equal({"o" => ["hello","world"], "I"=>true}, Std.getopts("o:ID"))
-   end
-
-   # EXPECTED ERRORS
-
-   def test_getopts_expected_errors_passing_switch_to_another_switch
-      ARGV.push("-d", "-d")
-      assert_raise(Getopt::Std::Error){ Std.getopts("d:a:") }
-
-      ARGV.push("-d", "-a")
-      assert_raise(Getopt::Std::Error){ Std.getopts("d:a:") }
-
-      ARGV.push("-a", "-d")
-      assert_raise(Getopt::Std::Error){ Std.getopts("d:a:") }
-
-      ARGV.push("-d", "-d")
-      assert_raise_message("cannot use switch '-d' as argument to another switch"){ Std.getopts("d:a:") }
-   end
-
-   def test_getopts_expected_errors_missing_arg
-      ARGV.push("-ID")
-      assert_raises(Std::Error){ Std.getopts("I:D") }
-
-      ARGV.push("-ID")
-      assert_raises(Std::Error){ Std.getopts("ID:") }
-   end
-
-   def test_getopts_expected_errors_extra_arg
-      ARGV.push("-I", "-D", "-X")
-      assert_raises(Std::Error){ Std.getopts("ID") }
-
-      ARGV.push("-IDX")
-      assert_raises(Std::Error){ Std.getopts("ID") }
-
-      ARGV.push("-IDX")
-      assert_raise_message("invalid option 'X'"){ Std.getopts("ID") }
-   end
-
-   def test_getopts_expected_errors_basic
-      assert_raises(ArgumentError){ Std.getopts }
-      assert_raises(NoMethodError){ Std.getopts(0) }
-      assert_raises(NoMethodError){ Std.getopts(nil) }
-   end
-
-   def teardown
-      ARGV.clear
-   end
+  def test_version
+    assert_equal('1.4.3', Std::VERSION)
+  end
+
+  def test_getopts_basic
+    assert_respond_to(Std, :getopts)
+    assert_nothing_raised{ Std.getopts("ID") }
+    assert_kind_of(Hash, Std.getopts("ID"))
+  end
+
+  def test_getopts_separated_switches
+    ARGV.push("-I", "-D")
+    assert_equal({"I"=>true, "D"=>true}, Std.getopts("ID"))
+  end
+
+  # Inspired by RF bug #23477
+  def test_getopts_arguments_that_match_switch_are_ok
+    ARGV.push("-d", "d")
+    assert_equal({"d" => "d"}, Std.getopts("d:"))
+
+    ARGV.push("-d", "ad")
+    assert_equal({"d" => "ad"}, Std.getopts("d:"))
+
+    ARGV.push("-a", "ad")
+    assert_equal({"a" => "ad"}, Std.getopts("d:a:"))
+
+    ARGV.push("-a", "da")
+    assert_equal({"a" => "da"}, Std.getopts("d:a:"))
+
+    ARGV.push("-a", "d")
+    assert_equal({"a" => "d"}, Std.getopts("d:a:"))
+
+    ARGV.push("-a", "dad")
+    assert_equal({"a" => "dad"}, Std.getopts("d:a:"))
+
+    ARGV.push("-d", "d", "-a", "a")
+    assert_equal({"d" => "d", "a" => "a"}, Std.getopts("d:a:"))
+  end
+
+  def test_getopts_joined_switches
+    ARGV.push("-ID")
+    assert_equal({"I"=>true, "D"=>true}, Std.getopts("ID"))
+  end
+
+  def test_getopts_separated_switches_with_mandatory_arg
+    ARGV.push("-o", "hello", "-I", "-D")
+    assert_equal({"o"=>"hello", "I"=>true, "D"=>true}, Std.getopts("o:ID"))
+  end
+
+  def test_getopts_joined_switches_with_mandatory_arg
+    ARGV.push("-IDo", "hello")
+    assert_equal({"o"=>"hello", "I"=>true, "D"=>true}, Std.getopts("o:ID"))
+  end
+
+  def test_getopts_no_args
+    assert_nothing_raised{ Std.getopts("ID") }
+    assert_equal({}, Std.getopts("ID"))
+    assert_nil(Std.getopts("ID")["I"])
+    assert_nil(Std.getopts("ID")["D"])
+  end
+
+  # If a switch that accepts an argument appears more than once, the values
+  # are rolled into an array.
+  def test_getopts_switch_repeated
+    ARGV.push("-I", "-I", "-o", "hello", "-o", "world")
+    assert_equal({"o" => ["hello","world"], "I"=>true}, Std.getopts("o:ID"))
+  end
+
+  # EXPECTED ERRORS
+
+  def test_getopts_expected_errors_passing_switch_to_another_switch
+    ARGV.push("-d", "-d")
+    assert_raise(Getopt::Std::Error){ Std.getopts("d:a:") }
+
+    ARGV.push("-d", "-a")
+    assert_raise(Getopt::Std::Error){ Std.getopts("d:a:") }
+
+    ARGV.push("-a", "-d")
+    assert_raise(Getopt::Std::Error){ Std.getopts("d:a:") }
+
+    ARGV.push("-d", "-d")
+    assert_raise_message("cannot use switch '-d' as argument to another switch"){ Std.getopts("d:a:") }
+  end
+
+  def test_getopts_expected_errors_missing_arg
+    ARGV.push("-ID")
+    assert_raises(Std::Error){ Std.getopts("I:D") }
+
+    ARGV.push("-ID")
+    assert_raises(Std::Error){ Std.getopts("ID:") }
+  end
+
+  def test_getopts_expected_errors_extra_arg
+    ARGV.push("-I", "-D", "-X")
+    assert_raises(Std::Error){ Std.getopts("ID") }
+
+    ARGV.push("-IDX")
+    assert_raises(Std::Error){ Std.getopts("ID") }
+
+    ARGV.push("-IDX")
+    assert_raise_message("invalid option 'X'"){ Std.getopts("ID") }
+  end
+
+  def test_getopts_expected_errors_basic
+    assert_raises(ArgumentError){ Std.getopts }
+    assert_raises(NoMethodError){ Std.getopts(0) }
+    assert_raises(NoMethodError){ Std.getopts(nil) }
+  end
+
+  def teardown
+    ARGV.clear
+  end
 end

metadata

@@ -1,14 +1,36 @@
 --- !ruby/object:Gem::Specification
 name: getopt
 version: !ruby/object:Gem::Version
-  version: 1.4.2
+  version: 1.4.3
 platform: ruby
 authors:
 - Daniel J. Berger
 autorequire: 
 bindir: bin
-cert_chain: []
-date: 2014-10-13 00:00:00.000000000 Z
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDcDCCAligAwIBAgIBATANBgkqhkiG9w0BAQUFADA/MREwDwYDVQQDDAhkamJl
+  cmc5NjEVMBMGCgmSJomT8ixkARkWBWdtYWlsMRMwEQYKCZImiZPyLGQBGRYDY29t
+  MB4XDTE1MDkwMjIwNDkxOFoXDTE2MDkwMTIwNDkxOFowPzERMA8GA1UEAwwIZGpi
+  ZXJnOTYxFTATBgoJkiaJk/IsZAEZFgVnbWFpbDETMBEGCgmSJomT8ixkARkWA2Nv
+  bTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMyTkvXqRp6hLs9eoJOS
+  Hmi8kRYbq9Vkf15/hMxJpotYMgJVHHWrmDcC5Dye2PbnXjTkKf266Zw0PtT9h+lI
+  S3ts9HO+vaCFSMwFFZmnWJSpQ3CNw2RcHxjWkk9yF7imEM8Kz9ojhiDXzBetdV6M
+  gr0lV/alUr7TNVBDngbXEfTWscyXh1qd7xZ4EcOdsDktCe5G45N/o3662tPQvJsi
+  FOF0CM/KuBsa/HL1/eoEmF4B3EKIRfTHrQ3hu20Kv3RJ88QM4ec2+0dd97uX693O
+  zv6981fyEg+aXLkxrkViM/tz2qR2ZE0jPhHTREPYeMEgptRkTmWSKAuLVWrJEfgl
+  DtkCAwEAAaN3MHUwCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAwHQYDVR0OBBYEFEwe
+  nn6bfJADmuIDiMSOzedOrL+xMB0GA1UdEQQWMBSBEmRqYmVyZzk2QGdtYWlsLmNv
+  bTAdBgNVHRIEFjAUgRJkamJlcmc5NkBnbWFpbC5jb20wDQYJKoZIhvcNAQEFBQAD
+  ggEBAHmNOCWoDVD75zHFueY0viwGDVP1BNGFC+yXcb7u2GlK+nEMCORqzURbYPf7
+  tL+/hzmePIRz7i30UM//64GI1NLv9jl7nIwjhPpXpf7/lu2I9hOTsvwSumb5UiKC
+  /sqBxI3sfj9pr79Wpv4MuikX1XPik7Ncb7NPsJPw06Lvyc3Hkg5X2XpPtLtS+Gr2
+  wKJnmzb5rIPS1cmsqv0M9LPWflzfwoZ/SpnmhagP+g05p8bRNKjZSA2iImM/GyYZ
+  EJYzxdPOrx2n6NYR3Hk+vHP0U7UBSveI6+qx+ndQYaeyCn+GRX2PKS9h66YF/Q1V
+  tGSHgAmcLlkdGgan182qsE/4kKM=
+  -----END CERTIFICATE-----
+date: 2016-01-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: test-unit
@@ -37,15 +59,24 @@ extra_rdoc_files:
 - CHANGES
 - MANIFEST
 files:
+- certs
+- certs/djberg96_pub.pem
 - CHANGES
-- MANIFEST
-- README
-- Rakefile
+- examples
 - examples/example_long.rb
 - examples/example_std.rb
 - getopt.gemspec
+- lib
+- lib/getopt
 - lib/getopt/long.rb
 - lib/getopt/std.rb
+- lib/getopt-long.rb
+- lib/getopt-std.rb
+- lib/getopt.rb
+- MANIFEST
+- Rakefile
+- README
+- test
 - test/test_getopt_long.rb
 - test/test_getopt_std.rb
 homepage: https://github.com/djberg96/getopt
@@ -68,7 +99,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.2
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Getopt::Std and Getopt::Long option parsers for Ruby