getopt 1.4.2 → 1.6.0

data/Rakefile

@@ -1,19 +1,16 @@
 require 'rake'
 require 'rake/clean'
-require 'rake/testtask'
+require 'rspec/core/rake_task'
 
 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)
   end
 
   desc "Install the getopt gem"
@@ -23,23 +20,18 @@ namespace :gem do
   end
 end
 
-Rake::TestTask.new do |t|
-  t.warning = true
-  t.verbose = true
-end
+namespace :spec do
+  RSpec::Core::RakeTask.new(:all) do |t|
+    t.pattern = FileList['spec/*_spec.rb']
+  end
 
-namespace :test do
-  Rake::TestTask.new('getopt_long') do |t|
-    t.test_files = 'test/test_getopt_long.rb'
-    t.warning = true
-    t.verbose = true
+  RSpec::Core::RakeTask.new(:getopt_long) do |t|
+    t.pattern = FileList['spec/*long_spec.rb']
   end
 
-  Rake::TestTask.new('getopt_std') do |t|
-    t.test_files = 'test/test_getopt_std.rb'
-    t.warning = true
-    t.verbose = true
+  RSpec::Core::RakeTask.new(:getopt_std) do |t|
+    t.pattern = FileList['spec/*std_spec.rb']
   end
 end
 
-task :default => :test
+task :default => 'spec:all'

data/certs/djberg96_pub.pem

@@ -0,0 +1,26 @@
+-----BEGIN CERTIFICATE-----
+MIIEcDCCAtigAwIBAgIBATANBgkqhkiG9w0BAQsFADA/MREwDwYDVQQDDAhkamJl
+cmc5NjEVMBMGCgmSJomT8ixkARkWBWdtYWlsMRMwEQYKCZImiZPyLGQBGRYDY29t
+MB4XDTE4MDMxODE1MjIwN1oXDTI4MDMxNTE1MjIwN1owPzERMA8GA1UEAwwIZGpi
+ZXJnOTYxFTATBgoJkiaJk/IsZAEZFgVnbWFpbDETMBEGCgmSJomT8ixkARkWA2Nv
+bTCCAaIwDQYJKoZIhvcNAQEBBQADggGPADCCAYoCggGBALgfaroVM6CI06cxr0/h
+A+j+pc8fgpRgBVmHFaFunq28GPC3IvW7Nvc3Y8SnAW7pP1EQIbhlwRIaQzJ93/yj
+u95KpkP7tA9erypnV7dpzBkzNlX14ACaFD/6pHoXoe2ltBxk3CCyyzx70mTqJpph
+75IB03ni9a8yqn8pmse+s83bFJOAqddSj009sGPcQO+QOWiNxqYv1n5EHcvj2ebO
+6hN7YTmhx7aSia4qL/quc4DlIaGMWoAhvML7u1fmo53CYxkKskfN8MOecq2vfEmL
+iLu+SsVVEAufMDDFMXMJlvDsviolUSGMSNRTujkyCcJoXKYYxZSNtIiyd9etI0X3
+ctu0uhrFyrMZXCedutvXNjUolD5r9KGBFSWH1R9u2I3n3SAyFF2yzv/7idQHLJJq
+74BMnx0FIq6fCpu5slAipvxZ3ZkZpEXZFr3cIBtO1gFvQWW7E/Y3ijliWJS1GQFq
+058qERadHGu1yu1dojmFRo6W2KZvY9al2yIlbkpDrD5MYQIDAQABo3cwdTAJBgNV
+HRMEAjAAMAsGA1UdDwQEAwIEsDAdBgNVHQ4EFgQUFZsMapgzJimzsbaBG2Tm8j5e
+AzgwHQYDVR0RBBYwFIESZGpiZXJnOTZAZ21haWwuY29tMB0GA1UdEgQWMBSBEmRq
+YmVyZzk2QGdtYWlsLmNvbTANBgkqhkiG9w0BAQsFAAOCAYEAW2tnYixXQtKxgGXq
+/3iSWG2bLwvxS4go3srO+aRXZHrFUMlJ5W0mCxl03aazxxKTsVVpZD8QZxvK91OQ
+h9zr9JBYqCLcCVbr8SkmYCi/laxIZxsNE5YI8cC8vvlLI7AMgSfPSnn/Epq1GjGY
+6L1iRcEDtanGCIvjqlCXO9+BmsnCfEVehqZkQHeYczA03tpOWb6pon2wzvMKSsKH
+ks0ApVdstSLz1kzzAqem/uHdG9FyXdbTAwH1G4ZPv69sQAFAOCgAqYmdnzedsQtE
+1LQfaQrx0twO+CZJPcRLEESjq8ScQxWRRkfuh2VeR7cEU7L7KqT10mtUwrvw7APf
+DYoeCY9KyjIBjQXfbj2ke5u1hZj94Fsq9FfbEQg8ygCgwThnmkTrrKEiMSs3alYR
+ORVCZpRuCPpmC8qmqxUnARDArzucjaclkxjLWvCVHeFa9UP7K3Nl9oTjJNv+7/jM
+WZs4eecIcUc4tKdHxcAJ0MO/Dkqq7hGaiHpwKY76wQ1+8xAh
+-----END CERTIFICATE-----

data/getopt.gemspec

@@ -2,18 +2,27 @@ require 'rubygems'
 
 Gem::Specification.new do |spec|
   spec.name       = 'getopt'
-  spec.version    = '1.4.2'
+  spec.version    = '1.6.0'
   spec.author     = 'Daniel J. Berger'
-  spec.license    = 'Artistic 2.0'
+  spec.license    = 'Apache-2.0'
   spec.email      = 'djberg96@gmail.com'
   spec.homepage   = 'https://github.com/djberg96/getopt'
   spec.summary    = 'Getopt::Std and Getopt::Long option parsers for Ruby'
-  spec.test_files = Dir['test/*.rb']
+  spec.test_files = Dir['spec/*_spec.rb']
   spec.files      = Dir['**/*'].reject{ |f| f.include?('git') }
+  spec.cert_chain = Dir['certs/*']
 
-  spec.extra_rdoc_files  = ['README', 'CHANGES', 'MANIFEST']
-   
-  spec.add_development_dependency('test-unit', '>= 2.5.0')
+  spec.add_development_dependency('rake')
+  spec.add_development_dependency('rspec', '~> 3.9')
+
+  spec.metadata = {
+    'homepage_uri'      => 'https://github.com/djberg96/getopt',
+    'bug_tracker_uri'   => 'https://github.com/djberg96/getopt/issues',
+    'changelog_uri'     => 'https://github.com/djberg96/getopt/blob/master/CHANGES',
+    'documentation_uri' => 'https://github.com/djberg96/getopt/wiki',
+    'source_code_uri'   => 'https://github.com/djberg96/getopt',
+    'wiki_uri'          => 'https://github.com/djberg96/getopt/wiki'
+  }
 
   spec.description = <<-EOF
     The getopt library provides two different command line option parsers.

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

@@ -1,3 +1,5 @@
+require_relative 'version'
+
 # The Getopt module serves as a namespace only
 module Getopt
 
@@ -12,13 +14,11 @@ module Getopt
 
    # The Getopt::Long class encapsulates longhanded parameter parsing options
    class Long
+      include Getopt::Version
 
       # Error raised if an illegal option or argument is passed
       class Error < StandardError; end
 
-      # The version of the getopt library
-      VERSION = '1.4.2'
-
       # Takes an array of switches. Each array consists of up to three
       # elements that indicate the name and type of switch. Returns a hash
       # containing each switch name, minus the '-', as a key. The value
@@ -59,7 +59,7 @@ module Getopt
             valid.push(switch[0])       # Set valid long switches
 
             # Set type for long switch, default to BOOLEAN.
-            if switch[1].kind_of?(Fixnum)
+            if switch[1].kind_of?(Integer)
                switch[2] = switch[1]
                types[switch[0]] = switch[2]
                switch[1] = switch[0][1..2]
@@ -75,7 +75,7 @@ module Getopt
             syns[switch[0]] = switch[1] unless syns[switch[1]]
             syns[switch[1]] = switch[0] unless syns[switch[1]]
 
-            switch[1] = [switch[1]] if RUBY_VERSION.to_f >= 1.9
+            switch[1] = [switch[1]]
 
             switch[1].each{ |char|
                types[char] = switch[2]  # Set type for short switch
@@ -217,7 +217,7 @@ module Getopt
          # the same value
          hash.dup.each{ |switch, val|
             if syns.keys.include?(switch)
-               syns[switch] = [syns[switch]] if RUBY_VERSION.to_f >= 1.9
+               syns[switch] = [syns[switch]]
                syns[switch].each{ |key|
                   hash[key] = val
                }

data/lib/getopt/std.rb

@@ -1,17 +1,17 @@
+require_relative 'version'
+
 # The Getopt module serves as a namespace only
 module Getopt
 
    # The Getopt::Std class serves as a base class for the getopts method.
    class Std
+      include Getopt::Version
 
       # The Getopt::Std::Error class is raised if there are any illegal
       # command line arguments.
       #
       class Error < StandardError; end
 
-      # The version of the getopt library
-      VERSION = '1.4.2'
-
       # Processes single character command line options with option
       # clustering.  This information is parsed from ARGV and returned
       # as a hash, with the switch (minus the "-") as the key.  The value

data/lib/getopt/version.rb

@@ -0,0 +1,6 @@
+module Getopt
+  module Version
+    # The version of the getopt library
+    VERSION = '1.6.0'.freeze
+  end
+end

data/spec/getopt_long_spec.rb

@@ -0,0 +1,279 @@
+#####################################################################
+# getopt_long_spec.rb
+#
+# Specs for the getopt-long library. You should run this test
+# via the 'rake spec:getopt_long' rake task.
+#####################################################################
+require 'rspec'
+require 'getopt/long'
+
+RSpec.describe Getopt::Long do
+  before do
+    @opts = nil
+  end
+
+  example "version" do
+    expect(Getopt::Long::VERSION).to eq('1.6.0')
+    expect(Getopt::Long::VERSION).to be_frozen
+  end
+
+  example "constants" do
+    expect(Getopt::BOOLEAN).not_to be_nil
+    expect(Getopt::OPTIONAL).not_to be_nil
+    expect(Getopt::REQUIRED).not_to be_nil
+    expect(Getopt::INCREMENT).not_to be_nil
+  end
+
+  example "getopts long basic functionality" do
+    expect(Getopt::Long).to respond_to(:getopts)
+
+    expect{ Getopt::Long.getopts(["--test"],["--help"],["--foo"]) }.not_to raise_error
+    expect{ Getopt::Long.getopts(["--test", "-x"],["--help", "-y"],["--foo", "-z"]) }.not_to raise_error
+
+    expect{
+      Getopt::Long.getopts(
+        ["--test", "-x", Getopt::BOOLEAN],
+        ["--help", "-y", Getopt::REQUIRED],
+        ["--foo",  "-z", Getopt::OPTIONAL],
+        ["--more", "-m", Getopt::INCREMENT]
+      )
+    }.not_to raise_error
+
+    expect(Getopt::Long.getopts("--test")).to be_kind_of(Hash)
+  end
+
+  example "getopts long using equals sign works as expected" do
+    ARGV.push("--foo=hello","-b","world")
+
+    expect{
+      @opts = Getopt::Long.getopts(
+        ["--foo", "-f", Getopt::REQUIRED],
+        ["--bar", "-b", Getopt::OPTIONAL]
+      )
+    }.not_to raise_error
+
+    expect(@opts["foo"]).to eq("hello")
+    expect(@opts["f"]).to eq("hello")
+    expect(@opts["bar"]).to eq("world")
+    expect(@opts["b"]).to eq("world")
+  end
+
+  example "getopts long with embedded hyphens works as expected" do
+    ARGV.push('--foo-bar', 'hello', '--test1-test2-test3', 'world')
+
+    expect{
+      @opts = Getopt::Long.getopts(
+        ['--foo-bar', '-f', Getopt::REQUIRED],
+        ['--test1-test2-test3', '-t', Getopt::REQUIRED]
+      )
+    }.not_to raise_error
+
+    expect(@opts['foo-bar']).to eq('hello')
+    expect(@opts['f']).to eq('hello')
+    expect(@opts['test1-test2-test3']).to eq('world')
+    expect(@opts['t']).to eq('world')
+  end
+
+  example "getopts long embedded hyphens using equals sign works as expected" do
+    ARGV.push('--foo-bar=hello', '--test1-test2-test3=world')
+
+    expect{
+      @opts = Getopt::Long.getopts(
+        ['--foo-bar', '-f', Getopt::REQUIRED],
+        ['--test1-test2-test3', '-t', Getopt::REQUIRED]
+      )
+    }.not_to raise_error
+
+    expect(@opts['foo-bar']).to eq('hello')
+    expect(@opts['f']).to eq('hello')
+    expect(@opts['test1-test2-test3']).to eq('world')
+    expect(@opts['t']).to eq('world')
+  end
+
+  example "getopts long with short switch squished works as expected" do
+    ARGV.push("-f", "hello", "-bworld")
+
+    expect{
+      @opts = Getopt::Long.getopts(
+        ["--foo", "-f", Getopt::REQUIRED],
+        ["--bar", "-b", Getopt::OPTIONAL]
+      )
+    }.not_to raise_error
+
+    expect(@opts["f"]).to eq("hello")
+    expect(@opts["b"]).to eq("world")
+  end
+
+  example "getopts long increment type works as expected" do
+    ARGV.push("-m","-m")
+
+    expect{ @opts = Getopt::Long.getopts(["--more", "-m", Getopt::INCREMENT]) }.not_to raise_error
+
+    expect(@opts["more"]).to eq(2)
+    expect(@opts["m"]).to eq(2)
+  end
+
+  example "switches are set as expected" do
+    ARGV.push("--verbose","--test","--foo")
+    expect{ @opts = Getopt::Long.getopts("--verbose --test --foo") }.not_to raise_error
+    expect( @opts.has_key?("verbose")).to eq(true)
+    expect( @opts.has_key?("test")).to eq(true)
+    expect( @opts.has_key?("foo")).to eq(true)
+  end
+
+  example "short switch synonyms work as expected" do
+    ARGV.push("--verbose","--test","--foo")
+    expect{ @opts = Getopt::Long.getopts("--verbose --test --foo") }.not_to raise_error
+    expect(@opts.has_key?("v")).to eq(true)
+    expect(@opts.has_key?("t")).to eq(true)
+    expect(@opts.has_key?("f")).to eq(true)
+  end
+
+  example "short_switch_synonyms_with_explicit_types" do
+    ARGV.push("--verbose", "--test", "hello", "--foo")
+
+    expect{
+      @opts = Getopt::Long.getopts(
+        ["--verbose", Getopt::BOOLEAN],
+        ["--test", Getopt::REQUIRED],
+        ["--foo", Getopt::BOOLEAN]
+      )
+    }.not_to raise_error
+
+    expect(@opts.has_key?("v")).to be(true)
+    expect(@opts.has_key?("t")).to be(true)
+    expect(@opts.has_key?("f")).to be(true)
+  end
+
+  example "switches with required arguments" do
+    ARGV.push("--foo","1","--bar","hello")
+
+    expect{
+      @opts = Getopt::Long.getopts(
+        ["--foo", "-f", Getopt::REQUIRED],
+        ["--bar", "-b", Getopt::REQUIRED]
+      )
+    }.not_to raise_error
+
+    expect(@opts).to eq({"foo"=>"1", "bar"=>"hello", "f"=>"1", "b"=>"hello"})
+  end
+
+  example "compressed switches work as expected" do
+    ARGV.push("-fb")
+
+    expect{
+      @opts = Getopt::Long.getopts(
+        ["--foo", "-f", Getopt::BOOLEAN],
+        ["--bar", "-b", Getopt::BOOLEAN]
+      )
+    }.not_to raise_error
+
+    expect(@opts).to eq({"foo"=>true, "f"=>true, "b"=>true, "bar"=>true})
+  end
+
+  example "compress switches with required argument works as expected" do
+    ARGV.push("-xf", "foo.txt")
+
+    expect{
+      @opts = Getopt::Long.getopts(
+        ["--expand", "-x", Getopt::BOOLEAN],
+        ["--file", "-f", Getopt::REQUIRED]
+      )
+    }.not_to raise_error
+
+    expect(@opts).to eq({"x"=>true, "expand"=>true, "f"=>"foo.txt", "file"=>"foo.txt"})
+  end
+
+  example "compress switches with argument that is compressed works as expected" do
+    ARGV.push("-xffoo.txt")
+
+    expect{
+      @opts = Getopt::Long.getopts(
+        ["--expand", "-x", Getopt::BOOLEAN],
+        ["--file", "-f", Getopt::REQUIRED]
+      )
+    }.not_to raise_error
+
+    expect(@opts).to eq({"x"=>true, "expand"=>true, "f"=>"foo.txt", "file"=>"foo.txt"})
+  end
+
+  example "compress switches with optional argument not defined works as expected" do
+    ARGV.push("-xf")
+
+    expect{
+      @opts = Getopt::Long.getopts(
+        ["--expand", "-x", Getopt::BOOLEAN],
+        ["--file", "-f", Getopt::OPTIONAL]
+      )
+    }.not_to raise_error
+
+    expect(@opts).to eq({"x"=>true, "expand"=>true, "f"=>nil, "file"=>nil})
+  end
+
+  example "compress switches with optional argument works as expected" do
+    ARGV.push("-xf", "boo.txt")
+
+    expect{
+      @opts = Getopt::Long.getopts(
+        ["--expand", "-x", Getopt::BOOLEAN],
+        ["--file", "-f", Getopt::OPTIONAL]
+      )
+    }.not_to raise_error
+
+    expect(@opts).to eq({"x"=>true, "expand"=>true, "f"=>"boo.txt", "file"=>"boo.txt"})
+  end
+
+  example "compress switches with compressed optional argument works as expected" do
+    ARGV.push("-xfboo.txt")
+
+    expect{
+      @opts = Getopt::Long.getopts(
+        ["--expand", "-x", Getopt::BOOLEAN],
+        ["--file", "-f", Getopt::OPTIONAL]
+      )
+    }.not_to raise_error
+
+    expect(@opts).to eq({"x"=>true, "expand"=>true, "f"=>"boo.txt", "file"=>"boo.txt"})
+  end
+
+  example "compressed_short_and_long_mixed" do
+    ARGV.push("-xb", "--file", "boo.txt", "-v")
+
+    expect{
+      @opts = Getopt::Long.getopts(
+        ["--expand", "-x", Getopt::BOOLEAN],
+        ["--verbose", "-v", Getopt::BOOLEAN],
+        ["--file", "-f", Getopt::REQUIRED],
+        ["--bar", "-b", Getopt::OPTIONAL]
+      )
+    }.not_to raise_error
+
+    expect(@opts).to eq({
+      "x"=>true, "expand"=>true,
+      "v"=>true, "verbose"=>true,
+      "f"=>"boo.txt", "file"=>"boo.txt",
+      "b"=>nil, "bar"=>nil
+    })
+  end
+
+  example "multiple similar long switches with no short switches works as expected" do
+    ARGV.push('--to','1','--too','2','--tooo','3')
+
+    expect{
+      @opts = Getopt::Long.getopts(
+        ["--to",  Getopt::REQUIRED],
+        ["--too", Getopt::REQUIRED],
+        ["--tooo", Getopt::REQUIRED]
+      )
+    }.not_to raise_error
+
+    expect(@opts['to']).to eq('1')
+    expect(@opts['too']).to eq('2')
+    expect(@opts['tooo']).to eq('3')
+  end
+
+  after do
+    @opts = nil
+    ARGV.clear
+  end
+end