optimist 3.1.0 → 3.2.0

data/optimist.gemspec

@@ -22,7 +22,7 @@ specify."
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.metadata    = {
-    "changelog_uri" => "https://github.com/ManageIQ/optimist/blob/master/History.txt",
+    "changelog_uri"   => "https://github.com/ManageIQ/optimist/blob/master/CHANGELOG.md",
     "source_code_uri" => "https://github.com/ManageIQ/optimist/",
     "bug_tracker_uri" => "https://github.com/ManageIQ/optimist/issues",
   }

data/renovate.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": [
+    "config:recommended"
+  ]
+}

data/test/optimist/alt_names_test.rb

@@ -0,0 +1,168 @@
+require 'test_helper'
+
+module Optimist
+
+  class AlternateNamesTest < ::Minitest::Test
+
+    def setup
+      @p = Parser.new
+    end
+
+    def get_help_string
+      assert_raises(Optimist::HelpNeeded) do
+        @p.parse(%w(--help))
+      end
+      sio = StringIO.new "w"
+      @p.educate sio
+      sio.string
+    end
+
+    def test_altshort
+      @p.opt :catarg, "desc", :short => ["c", "-C"]
+       opts = @p.parse %w(-c)
+       assert_equal true, opts[:catarg]
+       opts = @p.parse %w(-C)
+       assert_equal true, opts[:catarg]
+       err_regex = /option '-C' specified multiple times/
+       assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(-c -C) }
+       assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(-cC) }
+    end
+
+    def test_altshort_invalid_none
+      err_regex = /Cannot use :none with any other values in short option:/
+      assert_raises_errmatch(ArgumentError, err_regex) {
+        @p.opt :something, "some opt", :short => [:s, :none]
+      }
+      assert_raises_errmatch(ArgumentError, err_regex) {
+        @p.opt :something, "some opt", :short => [:none, :s]
+      }
+      assert_raises_errmatch(ArgumentError, err_regex) {
+        @p.opt :zumthing, "some opt", :short => [:none, :none]
+      }
+    end
+
+    def test_altshort_with_multi
+      @p.opt :flag, "desc", :short => ["-c", "C", :x], :multi => true
+      @p.opt :num, "desc", :short => ["-n", "N"], :multi => true, type: Integer
+      @p.parse %w(-c)
+      @p.parse %w(-C -c -x)
+      @p.parse %w(-c -C)
+      @p.parse %w(-c -C -c -C)
+      opts = @p.parse %w(-ccCx)
+      assert_equal true, opts[:flag]
+      @p.parse %w(-c)
+      @p.parse %w(-N 1 -n 3)
+      @p.parse %w(-n 2 -N 4)
+      opts = @p.parse %w(-n 4 -N 3 -n 2 -N 1)
+      assert_equal [4, 3, 2, 1], opts[:num]
+    end
+
+    def test_altlong
+      @p.opt "goodarg0", "desc", :alt => "zero"
+      @p.opt "goodarg1", "desc", :long => "newone", :alt => "one"
+      @p.opt "goodarg2", "desc", :alt => "--two"
+      @p.opt "goodarg3", "desc", :alt => ["three", "--four", :five]
+
+      [%w[--goodarg0], %w[--zero]].each do |a|
+        opts = @p.parse(a)
+        assert opts.goodarg0
+      end
+      
+      [%w[--newone], %w[-n], %w[--one]].each  do |a|
+        opts = @p.parse(a)
+        assert opts.goodarg1
+      end
+
+      [%w[--two]].each  do |a|
+        opts = @p.parse(a)
+        assert opts.goodarg2
+      end
+
+      [%w[--three], %w[--four], %w[--five]].each  do |a|
+        opts = @p.parse(a)
+        assert opts.goodarg3
+      end
+
+      [%w[--goodarg1], %w[--missing], %w[-a]].each do |a|
+        assert_raises_errmatch(Optimist::CommandlineError, /unknown argument/) { @p.parse(a) }
+      end
+
+      ["", '--', '-bad', '---threedash'].each do |altitem|
+        assert_raises_errmatch(ArgumentError, /invalid long option name/) { @p.opt "badarg", "desc", :alt => altitem }
+      end
+    end
+    
+    def test_altshort_help
+      @p.opt :cat, 'cat', short: ['c','C','a','T']
+      outstring = get_help_string
+      # expect mutliple short-opts to be in the help
+      assert_match(/-c, -C, -a, -T, --cat/, outstring)
+    end
+
+    
+    def test_altlong_help
+      @p.opt :cat, 'a cat', alt: :feline
+      @p.opt :dog, 'a dog', alt: ['Pooch', :canine]
+      @p.opt :fruit, 'a fruit', long: :fig, alt: ['peach', :pear, "--apple"], short: :none
+      @p.opt :veg, "gemuse", long: :gemuse, alt: [:groente]
+      outstring = get_help_string
+
+      assert_match(/^\s*-c, --cat, --feline/, outstring)
+      assert_match(/^\s*-d, --dog, --Pooch, --canine/, outstring)
+
+      # expect long-opt to shadow the actual name
+      assert_match(/^\s*--fig, --peach, --pear, --apple/, outstring)
+      assert_match(/^\s*-g, --gemuse, --groente/, outstring)
+      
+    end
+
+    def test_alt_duplicates
+      # alt duplicates named option
+      err_regex = /long option name "cat" is already taken; please specify a \(different\) :long\/:alt/ 
+      assert_raises_errmatch(ArgumentError, err_regex) {
+        @p.opt :cat, 'desc', :alt => :cat
+      }
+      # alt duplicates :long 
+      err_regex = /long option name "feline" is already taken; please specify a \(different\) :long\/:alt/ 
+      assert_raises_errmatch(ArgumentError, err_regex) {
+        @p.opt :cat, 'desc', :long => :feline, :alt => [:feline]
+      }
+      # alt duplicates itself
+      err_regex = /long option name "aaa" is already taken; please specify a \(different\) :long\/:alt/ 
+      assert_raises_errmatch(ArgumentError, err_regex) {
+        @p.opt :abc, 'desc', :alt => [:aaa, :aaa]
+      }
+    end
+    
+    def test_altlong_collisions
+      @p.opt :fat, 'desc'
+      @p.opt :raton, 'desc', :long => :rat
+      @p.opt :bat, 'desc', :alt => [:baton, :twirl]
+
+      # :alt collision with named option
+      err_regex = /long option name "fat" is already taken; please specify a \(different\) :long\/:alt/ 
+      assert_raises_errmatch(ArgumentError, err_regex) {
+        @p.opt :cat, 'desc', :alt => :fat
+      }
+
+      # :alt collision with :long option
+      err_regex = /long option name "cat" is already taken; please specify a \(different\) :long\/:alt/ 
+      assert_raises_errmatch(ArgumentError, err_regex) {
+        @p.opt :cat, 'desc', :alt => :rat
+      }
+
+      # :named option collision with existing :alt option
+      err_regex = /long option name "baton" is already taken; please specify a \(different\) :long\/:alt/ 
+      assert_raises_errmatch(ArgumentError, err_regex) {
+        @p.opt :baton, 'desc'
+      }
+
+      # :long option collision with existing :alt option
+      err_regex = /long option name "twirl" is already taken; please specify a \(different\) :long\/:alt/ 
+      assert_raises_errmatch(ArgumentError, err_regex) {
+        @p.opt :whirl, 'desc', :long => 'twirl'
+      }
+      
+    end
+  end
+end

data/test/optimist/command_line_error_test.rb

@@ -1,7 +1,7 @@
 require 'test_helper'
 
 module Optimist
-  class CommandlineErrorTest < ::MiniTest::Test
+  class CommandlineErrorTest < ::Minitest::Test
     def test_class
       assert_kind_of Exception, cle("message")
     end

data/test/optimist/help_needed_test.rb

@@ -1,7 +1,7 @@
 require 'test_helper'
 
 module Optimist
-  class HelpNeededTest < ::MiniTest::Test
+  class HelpNeededTest < ::Minitest::Test
     def test_class
       assert_kind_of Exception, hn("message")
     end

data/test/optimist/parser_constraint_test.rb

@@ -0,0 +1,141 @@
+require 'test_helper'
+
+module Optimist
+
+class ParserConstraintTest < ::Minitest::Test
+  def setup
+    @p = Parser.new
+  end
+
+  def parser
+    @p ||= Parser.new
+  end
+
+  def test_conflicts
+    @p.opt :one
+    err_regex = /unknown option 'two'/
+    assert_raises_errmatch(ArgumentError, err_regex) { @p.conflicts :one, :two }
+    @p.opt :two
+    @p.conflicts :one, :two
+    @p.parse %w(--one)
+    @p.parse %w(--two)
+    err_regex = /only one of --one, --two can be given/
+
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--one --two) }
+
+    @p.opt :hello
+    @p.opt :yellow
+    @p.opt :mellow
+    @p.opt :jello
+    @p.conflicts :hello, :yellow, :mellow, :jello
+    err_regex = /only one of --hello, --yellow, --mellow, --jello can be given/
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--hello --yellow --mellow --jello) }
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--hello --mellow --jello) }
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--hello --jello) }
+
+    @p.parse %w(--hello)
+    @p.parse %w(--jello)
+    @p.parse %w(--yellow)
+    @p.parse %w(--mellow)
+
+    @p.parse %w(--mellow --one)
+    @p.parse %w(--mellow --two)
+
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--mellow --two --jello) }
+    err_regex = /only one of --one, --two can be given/
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--one --mellow --two --jello) }
+  end
+
+  def test_conflict_error_messages
+    @p.opt :one
+    @p.opt "two"
+    @p.conflicts :one, "two"
+    err_regex = %r/only one of --one, --two can be given/
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--one --two) }
+  end
+
+  def test_either
+    @p.opt :one
+    err_regex = /unknown option 'two'/
+    assert_raises_errmatch(ArgumentError, err_regex) { @p.either :one, :two }
+    @p.opt :two
+    @p.either :one, :two
+    @p.parse %w(--one)
+    @p.parse %w(--two)
+    err_regex = /one and only one of --one, --two is required/
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--one --two) }
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w() }
+
+    @p.opt :hello
+    @p.opt :yellow
+    @p.opt :mellow
+    @p.opt :jello
+    @p.either :hello, :yellow, :mellow, :jello
+    err_regex = /one and only one of --hello, --yellow, --mellow, --jello is required/
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--one --hello --yellow --mellow --jello) }
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--two --hello --mellow --jello) }
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--one --hello --jello) }
+
+    @p.parse %w(--hello --one)
+    @p.parse %w(--jello --two)
+    @p.parse %w(--mellow --one)
+    @p.parse %w(--mellow --two)
+
+    err_regex = /one and only one of/
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--mellow --two --jello) }
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--one --mellow --two --jello) }
+  end
+
+  def test_either_error_messages
+    @p.opt :one
+    @p.opt :two
+    @p.opt :three
+    @p.either :one, :two, :three
+    err_regex = %r/one and only one of --one, --two, --three is required/
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--one --two) }
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--three --two --one) }
+  end
+
+  def test_depends
+    @p.opt :one
+    err_regex = /unknown option 'two'/
+    assert_raises_errmatch(ArgumentError, err_regex) { @p.depends :one, :two }
+    @p.opt :two
+    @p.depends :one, :two
+    @p.parse %w(--one --two)
+    err_regex = /--one, --two have a dependency and must be given together/
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--one) }
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--two) }
+
+    @p.opt :hello
+    @p.opt :yellow
+    @p.opt :mellow
+    @p.opt :jello
+    @p.depends :hello, :yellow, :mellow, :jello
+    @p.parse %w(--hello --yellow --mellow --jello)
+    err_regex = /-hello, --yellow, --mellow, --jello have a dependency and must be given together/
+
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--hello --mellow --jello) }
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--hello --jello) }
+
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--hello) }
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--mellow) }
+
+    @p.parse %w(--hello --yellow --mellow --jello --one --two)
+    @p.parse %w(--hello --yellow --mellow --jello --one --two a b c)
+
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--mellow --two --jello --one) }
+  end
+
+  def test_depends_error_messages
+    @p.opt :one
+    @p.opt "two"
+    @p.depends :one, "two"
+
+    @p.parse %w(--one --two)
+    err_regex = %r/--one, --two have a dependency and must be given together/
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--one) }
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--two) }
+  end
+end
+end

data/test/optimist/parser_educate_test.rb

@@ -2,7 +2,7 @@ require 'stringio'
 require 'test_helper'
 
 module Optimist
-  class ParserEduateTest < ::MiniTest::Test
+  class ParserEduateTest < ::Minitest::Test
     def setup
     end
 
@@ -158,6 +158,27 @@ module Optimist
     assert help[1] =~ /Default/
     assert help[2] =~ /default/
   end
+
+  def test_help_has_grammatical_permitted_text
+    parser.opt :arg1, 'description with period.', :type => :strings, :permitted => %w(foo bar)
+    parser.opt :arg2, 'description without period', :type => :strings, :permitted => %w(foo bar)
+    sio = StringIO.new 'w'
+    parser.educate sio
+
+    help = sio.string.split "\n"
+    assert help[1] =~ /Permitted/
+    assert help[2] =~ /permitted/
+  end
+
+  def test_help_with_permitted_range
+    parser.opt :rating, 'rating', permitted: 1..5
+    parser.opt :hex, 'hexadecimal', permitted: /^[0-9a-f]/i
+    sio = StringIO.new 'w'
+    parser.educate sio
+    help = sio.string.split "\n"
+    assert_match %r{rating \(permitted: 1\.\.5\)}, help[1]
+    assert_match %r{hexadecimal \(permitted: \/\^\[0-9a-f\]\/i\)}, help[2]
+  end
 ############
 
     private

data/test/optimist/parser_opt_test.rb

@@ -3,7 +3,7 @@ require 'test_helper'
 
 module Optimist
 
-  class ParserOptTest < ::MiniTest::Test
+  class ParserOptTest < ::Minitest::Test
 
     private
 

data/test/optimist/parser_parse_test.rb

@@ -2,7 +2,7 @@ require 'stringio'
 require 'test_helper'
 
 module Optimist
-  class ParserParseTest < ::MiniTest::Test
+  class ParserParseTest < ::Minitest::Test
 
   # TODO: parse
     # resolve_default_short_options!
@@ -37,7 +37,7 @@ module Optimist
 
   def test_version_needed_unset
     parser.opt "arg"
-    assert_raises(CommandlineError) { parser.parse %w(-v) }
+    assert_raises_errmatch(CommandlineError, /unknown argument '-v'/) { parser.parse %w(-v) }
   end
 
   def test_version_needed
@@ -54,7 +54,7 @@ module Optimist
 
   def test_version_only_appears_if_set
     parser.opt "arg"
-    assert_raises(CommandlineError) { parser.parse %w(-v) }
+    assert_raises_errmatch(CommandlineError, /unknown argument '-v'/) { parser.parse %w(-v) }
   end
 
   def test_version_with_other_args

data/test/optimist/parser_permitted_test.rb

@@ -0,0 +1,121 @@
+require 'stringio'
+require 'test_helper'
+
+module Optimist
+
+class ParserPermittedTest < ::Minitest::Test
+  def setup
+    @p = Parser.new
+  end
+
+  def test_permitted_flags_filter_inputs
+    @p.opt "arg", "desc", :type => :strings, :permitted => %w(foo bar)
+
+    result = @p.parse(%w(--arg foo))
+    assert_equal ["foo"], result["arg"]
+    assert_raises_errmatch(CommandlineError, /option '--arg' only accepts one of: foo, bar/) { @p.parse(%w(--arg baz)) }
+  end
+
+  def test_permitted_invalid_scalar_value
+    err_regexp = /permitted values for option "(bad|mad|sad)" must be either nil, Range, Regexp or an Array/
+    assert_raises_errmatch(ArgumentError, err_regexp) {
+      @p.opt 'bad', 'desc', :permitted => 1
+    }
+    assert_raises_errmatch(ArgumentError, err_regexp) {
+      @p.opt 'mad', 'desc', :permitted => "A"
+    }
+    assert_raises_errmatch(ArgumentError, err_regexp) {
+      @p.opt 'sad', 'desc', :permitted => :abcd
+    }
+  end
+
+  def test_permitted_with_string_array
+    @p.opt 'fiz', 'desc', :type => 'string', :permitted => ['foo', 'bar']
+    @p.parse(%w(--fiz foo))
+    assert_raises_errmatch(CommandlineError, /option '--fiz' only accepts one of: foo, bar/) {
+      @p.parse(%w(--fiz buz))
+    }
+  end
+  def test_permitted_with_symbol_array
+    @p.opt 'fiz', 'desc', :type => 'string', :permitted => %i[dog cat]
+    @p.parse(%w(--fiz dog)) 
+    @p.parse(%w(--fiz cat)) 
+    assert_raises_errmatch(CommandlineError, /option '--fiz' only accepts one of: dog, cat/) {
+      @p.parse(%w(--fiz rat))
+    }
+  end
+
+  def test_permitted_with_numeric_array
+    @p.opt 'mynum', 'desc', :type => Integer, :permitted => [1,2,4]
+    @p.parse(%w(--mynum 1)) 
+    @p.parse(%w(--mynum 4)) 
+    assert_raises_errmatch(CommandlineError, /option '--mynum' only accepts one of: 1, 2, 4/) {
+      @p.parse(%w(--mynum 3))
+    }
+  end
+
+  def test_permitted_with_string_range
+    @p.opt 'fiz', 'desc', :type => String, :permitted => 'A'..'z'
+    opts = @p.parse(%w(--fiz B))
+    assert_equal opts['fiz'], "B"
+    opts = @p.parse(%w(--fiz z))
+    assert_equal opts['fiz'], "z"
+    assert_raises_errmatch(CommandlineError, /option '--fiz' only accepts value in range of: A\.\.z/) {
+      @p.parse(%w(--fiz @))
+    }
+  end
+
+  def test_permitted_with_integer_range
+    @p.opt 'fiz', 'desc', :type => Integer, :permitted => 1..3
+    opts = @p.parse(%w(--fiz 1))
+    assert_equal opts['fiz'], 1
+    opts = @p.parse(%w(--fiz 3))
+    assert_equal opts['fiz'], 3
+    assert_raises_errmatch(CommandlineError, /option '--fiz' only accepts value in range of: 1\.\.3/) {
+      @p.parse(%w(--fiz 4))
+    }
+  end
+
+  def test_permitted_with_float_range
+    @p.opt 'fiz', 'desc', :type => Float, :permitted => 1.2 .. 3.5
+    opts = @p.parse(%w(--fiz 1.2))
+    assert_in_epsilon opts['fiz'], 1.2
+    opts = @p.parse(%w(--fiz 2.7))
+    assert_in_epsilon opts['fiz'], 2.7
+    opts = @p.parse(%w(--fiz 3.5))
+    assert_in_epsilon opts['fiz'], 3.5
+    err_regexp = /option '--fiz' only accepts value in range of: 1\.2\.\.3\.5/
+    assert_raises_errmatch(CommandlineError, err_regexp) {
+      @p.parse(%w(--fiz 3.51))
+    }
+    assert_raises_errmatch(CommandlineError, err_regexp) {
+      @p.parse(%w(--fiz 1.19))
+    }
+  end
+
+  def test_permitted_with_regexp
+    @p.opt 'zipcode', 'desc', :type => String, :permitted => /^[0-9]{5}$/
+    @p.parse(%w(--zipcode 39762))
+    err_regexp = %r|option '--zipcode' only accepts value matching: /\^\[0-9\]\{5\}\$/|
+    assert_raises_errmatch(CommandlineError, err_regexp) {
+      @p.parse(%w(--zipcode A9A9AA))
+    }
+  end
+  def test_permitted_with_reason
+    # test all keys passed into the formatter for the permitted_response
+    @p.opt 'zipcode', 'desc', type: String, permitted: /^[0-9]{5}$/,
+           permitted_response: "opt %{arg} should be a zipcode but you have %{value}"
+    @p.opt :wig, 'wig', type: Integer, permitted: 1..4,
+           permitted_response: "opt %{arg} exceeded four wigs (%{valid_string}), %{permitted}, but you gave '%{given}'"
+    err_regexp = %r|opt --zipcode should be a zipcode but you have A9A9AA|
+    assert_raises_errmatch(CommandlineError, err_regexp) {
+      @p.parse(%w(--zipcode A9A9AA))
+    }
+    err_regexp = %r|opt --wig exceeded four wigs \(value in range of: 1\.\.4\), 1\.\.4, but you gave '5'|
+    assert_raises_errmatch(CommandlineError, err_regexp) {
+      @p.parse(%w(--wig 5))
+    }
+  end
+
+end
+end