optimist 3.1.0 → 3.2.0

data/test/optimist/parser_test.rb

@@ -3,7 +3,7 @@ require 'test_helper'
 
 module Optimist
 
-class ParserTest < ::MiniTest::Test
+class ParserTest < ::Minitest::Test
   def setup
     @p = Parser.new
   end
@@ -35,8 +35,6 @@ class ParserTest < ::MiniTest::Test
     assert_equal "synopsis string", parser.synopsis
   end
 
-  # def test_depends
-  # def test_conflicts
   # def test_stop_on
   # def test_stop_on_unknown
 
@@ -45,10 +43,57 @@ class ParserTest < ::MiniTest::Test
 
 
   def test_unknown_arguments
-    assert_raises(CommandlineError) { @p.parse(%w(--arg)) }
+    assert_raises_errmatch(CommandlineError, /unknown argument '--arg'/) { @p.parse(%w(--arg)) }
     @p.opt "arg"
     @p.parse(%w(--arg))
-    assert_raises(CommandlineError) { @p.parse(%w(--arg2)) }
+    assert_raises_errmatch(CommandlineError, /unknown argument '--arg2'/) { @p.parse(%w(--arg2)) }
+  end
+
+  def test_unknown_arguments_with_suggestions
+    unless (Module::const_defined?("DidYouMean") &&
+      Module::const_defined?("DidYouMean::JaroWinkler") &&
+      Module::const_defined?("DidYouMean::Levenshtein"))
+      # if we cannot
+      skip("Skipping because DidYouMean was not found")
+      return false
+    end
+    sugp = Parser.new(:suggestions => true)
+    err = assert_raises(CommandlineError) { sugp.parse(%w(--bone)) }
+    assert_match(/unknown argument '--bone'$/, err.message)
+
+    sugp.opt "cone"
+    sugp.parse(%w(--cone))
+
+    # single letter mismatch
+    err = assert_raises(CommandlineError) { sugp.parse(%w(--bone)) }
+    assert_match(/unknown argument '--bone'.  Did you mean: \[--cone\] \?$/, err.message)
+
+    # transposition
+    err = assert_raises(CommandlineError) { sugp.parse(%w(--ocne)) }
+    assert_match(/unknown argument '--ocne'.  Did you mean: \[--cone\] \?$/, err.message)
+
+    # extra letter at end
+    err = assert_raises(CommandlineError) { sugp.parse(%w(--cones)) }
+    assert_match(/unknown argument '--cones'.  Did you mean: \[--cone\] \?$/, err.message)
+
+    # too big of a mismatch to suggest (extra letters in front)
+    err = assert_raises(CommandlineError) { sugp.parse(%w(--snowcone)) }
+    assert_match(/unknown argument '--snowcone'$/, err.message)
+
+    # too big of a mismatch to suggest (nothing close)
+    err = assert_raises(CommandlineError) { sugp.parse(%w(--clown-nose)) }
+    assert_match(/unknown argument '--clown-nose'$/, err.message)
+
+    sugp.opt "zippy"
+    sugp.opt "zapzy"
+    # single letter mismatch, matches two
+    err = assert_raises(CommandlineError) { sugp.parse(%w(--zipzy)) }
+    assert_match(/unknown argument '--zipzy'.  Did you mean: \[--zippy, --zapzy\] \?$/, err.message)
+
+    sugp.opt "big_bug"
+    # suggest common case of dash versus underscore in argnames
+    err = assert_raises(CommandlineError) { sugp.parse(%w(--big_bug)) }
+    assert_match(/unknown argument '--big_bug'.  Did you mean: \[--big-bug\] \?$/, err.message)
   end
 
   def test_syntax_check
@@ -56,8 +101,8 @@ class ParserTest < ::MiniTest::Test
 
     @p.parse(%w(--arg))
     @p.parse(%w(arg))
-    assert_raises(CommandlineError) { @p.parse(%w(---arg)) }
-    assert_raises(CommandlineError) { @p.parse(%w(-arg)) }
+    assert_raises_errmatch(CommandlineError, /invalid argument syntax: '---arg'/) { @p.parse(%w(---arg)) }
+    assert_raises_errmatch(CommandlineError, /unknown argument '-r'/) { @p.parse(%w(-arg)) }
   end
 
   def test_required_flags_are_required
@@ -67,8 +112,9 @@ class ParserTest < ::MiniTest::Test
 
     @p.parse(%w(--arg))
     @p.parse(%w(--arg --arg2))
-    assert_raises(CommandlineError) { @p.parse(%w(--arg2)) }
-    assert_raises(CommandlineError) { @p.parse(%w(--arg2 --arg3)) }
+    err_regex = %r/option --arg must be specified/
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse(%w(--arg2)) }
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse(%w(--arg2 --arg3)) }
   end
 
   ## flags that take an argument error unless given one
@@ -77,8 +123,9 @@ class ParserTest < ::MiniTest::Test
     @p.opt "goodarg2", "desc", :type => String
 
     @p.parse(%w(--goodarg goat))
-    assert_raises(CommandlineError) { @p.parse(%w(--goodarg --goodarg2 goat)) }
-    assert_raises(CommandlineError) { @p.parse(%w(--goodarg)) }
+    err_regex = %r/option '--goodarg' needs a parameter/
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse(%w(--goodarg --goodarg2 goat)) }
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse(%w(--goodarg)) }
   end
 
   ## flags that don't take arguments ignore them
@@ -95,19 +142,24 @@ class ParserTest < ::MiniTest::Test
   ## flags that require args of a specific type refuse args of other
   ## types
   def test_typed_args_refuse_args_of_other_types
-    @p.opt "goodarg", "desc", :type => :int
-    assert_raises(ArgumentError) { @p.opt "badarg", "desc", :type => :asdf }
+    @p.opt "goodarg", "desc", :type => :int    
+    err_regex = %r/Unsupported argument type 'asdf', registry lookup 'asdf'/
+    assert_raises_errmatch(ArgumentError, err_regex) { @p.opt "badarg", "desc", :type => :asdf }
 
     @p.parse(%w(--goodarg 3))
-    assert_raises(CommandlineError) { @p.parse(%w(--goodarg 4.2)) }
-    assert_raises(CommandlineError) { @p.parse(%w(--goodarg hello)) }
+    err_regex = %r/option 'goodarg' needs an integer/
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse(%w(--goodarg 4.2)) }
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse(%w(--goodarg hello)) }
   end
 
   ## type is correctly derived from :default
   def test_type_correctly_derived_from_default
-    assert_raises(ArgumentError) { @p.opt "badarg", "desc", :default => [] }
-    assert_raises(ArgumentError) { @p.opt "badarg3", "desc", :default => [{1 => 2}] }
-    assert_raises(ArgumentError) { @p.opt "badarg4", "desc", :default => Hash.new }
+    err_regex = %r/multiple argument type cannot be deduced from an empty array/
+    assert_raises_errmatch(ArgumentError, err_regex) { @p.opt "badarg", "desc", :default => [] }
+    err_regex = %r/Unsupported argument type 'hashs', registry lookup 'hashs'/
+    assert_raises_errmatch(ArgumentError, err_regex) { @p.opt "badarg3", "desc", :default => [{1 => 2}] }
+    err_regex = %r/Unsupported argument type 'hash', registry lookup 'hash'/
+    assert_raises_errmatch(ArgumentError, err_regex) { @p.opt "badarg4", "desc", :default => Hash.new }
 
     # single arg: int
     @p.opt "argsi", "desc", :default => 0
@@ -119,9 +171,9 @@ class ParserTest < ::MiniTest::Test
     assert_equal 4, opts["argsi"]
     opts = @p.parse(%w(--argsi=-4))
     assert_equal( -4, opts["argsi"])
-
-    assert_raises(CommandlineError) { @p.parse(%w(--argsi 4.2)) }
-    assert_raises(CommandlineError) { @p.parse(%w(--argsi hello)) }
+    err_regex = /option 'argsi' needs an integer/
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse(%w(--argsi 4.2)) }
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse(%w(--argsi hello)) }
 
     # single arg: float
     @p.opt "argsf", "desc", :default => 3.14
@@ -133,7 +185,8 @@ class ParserTest < ::MiniTest::Test
     assert_equal 2, opts["argsf"]
     opts = @p.parse(%w(--argsf 1.0e-2))
     assert_equal 1.0e-2, opts["argsf"]
-    assert_raises(CommandlineError) { @p.parse(%w(--argsf hello)) }
+    err_regex = /option 'argsf' needs a floating-point number/
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse(%w(--argsf hello)) }
 
     # single arg: date
     date = Date.today
@@ -142,7 +195,8 @@ class ParserTest < ::MiniTest::Test
     assert_equal Date.today, opts["argsd"]
     opts = @p.parse(['--argsd', 'Jan 4, 2007'])
     assert_equal Date.civil(2007, 1, 4), opts["argsd"]
-    assert_raises(CommandlineError) { @p.parse(%w(--argsd hello)) }
+    err_regex = /option 'argsd' needs a date/
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse(%w(--argsd hello)) }
 
     # single arg: string
     @p.opt "argss", "desc", :default => "foobar"
@@ -159,8 +213,9 @@ class ParserTest < ::MiniTest::Test
     assert_equal [3, 5], opts["argmi"]
     opts = @p.parse(%w(--argmi 4))
     assert_equal [4], opts["argmi"]
-    assert_raises(CommandlineError) { @p.parse(%w(--argmi 4.2)) }
-    assert_raises(CommandlineError) { @p.parse(%w(--argmi hello)) }
+    err_regex = /option 'argmi' needs an integer/
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse(%w(--argmi 4.2)) }
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse(%w(--argmi hello)) }
 
     # multi args: floats
     @p.opt "argmf", "desc", :default => [3.34, 5.21]
@@ -170,7 +225,8 @@ class ParserTest < ::MiniTest::Test
     assert_equal [2], opts["argmf"]
     opts = @p.parse(%w(--argmf 4.0))
     assert_equal [4.0], opts["argmf"]
-    assert_raises(CommandlineError) { @p.parse(%w(--argmf hello)) }
+    err_regex = /option 'argmf' needs a floating-point number/
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse(%w(--argmf hello)) }
 
     # multi args: dates
     dates = [Date.today, Date.civil(2007, 1, 4)]
@@ -179,7 +235,8 @@ class ParserTest < ::MiniTest::Test
     assert_equal dates, opts["argmd"]
     opts = @p.parse(['--argmd', 'Jan 4, 2007'])
     assert_equal [Date.civil(2007, 1, 4)], opts["argmd"]
-    assert_raises(CommandlineError) { @p.parse(%w(--argmd hello)) }
+    err_regex = /option 'argmd' needs a date/
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse(%w(--argmd hello)) }
 
     # multi args: strings
     @p.opt "argmst", "desc", :default => %w(hello world)
@@ -193,10 +250,12 @@ class ParserTest < ::MiniTest::Test
 
   ## :type and :default must match if both are specified
   def test_type_and_default_must_match
-    assert_raises(ArgumentError) { @p.opt "badarg", "desc", :type => :int, :default => "hello" }
-    assert_raises(ArgumentError) { @p.opt "badarg2", "desc", :type => :String, :default => 4 }
-    assert_raises(ArgumentError) { @p.opt "badarg2", "desc", :type => :String, :default => ["hi"] }
-    assert_raises(ArgumentError) { @p.opt "badarg2", "desc", :type => :ints, :default => [3.14] }
+    # Different versions of ruby raise different error messages.
+    err_regex = %r/(type specification and default type don't match|Unsupported argument type)/
+    assert_raises_errmatch(ArgumentError, err_regex) { @p.opt "badarg", "desc", :type => :int, :default => "hello" }
+    assert_raises_errmatch(ArgumentError, err_regex) { @p.opt "badarg2", "desc", :type => :String, :default => 4 }
+    assert_raises_errmatch(ArgumentError, err_regex) { @p.opt "badarg2", "desc", :type => :String, :default => ["hi"] }
+    assert_raises_errmatch(ArgumentError, err_regex) { @p.opt "badarg2", "desc", :type => :ints, :default => [3.14] }
 
     @p.opt "argsi", "desc", :type => :int, :default => 4
     @p.opt "argsf", "desc", :type => :float, :default => 3.14
@@ -239,10 +298,11 @@ class ParserTest < ::MiniTest::Test
     @p.opt "argmf", "desc", :type => :floats, :default => []
     @p.opt "argmd", "desc", :type => :dates, :default => []
     @p.opt "argms", "desc", :type => :strings, :default => []
-    assert_raises(ArgumentError) { @p.opt "badi", "desc", :type => :int, :default => [] }
-    assert_raises(ArgumentError) { @p.opt "badf", "desc", :type => :float, :default => [] }
-    assert_raises(ArgumentError) { @p.opt "badd", "desc", :type => :date, :default => [] }
-    assert_raises(ArgumentError) { @p.opt "bads", "desc", :type => :string, :default => [] }
+    err_regex = %r/multiple argument type must be plural/
+    assert_raises_errmatch(ArgumentError, err_regex) { @p.opt "badi", "desc", :type => :int, :default => [] }
+    assert_raises_errmatch(ArgumentError, err_regex) { @p.opt "badf", "desc", :type => :float, :default => [] }
+    assert_raises_errmatch(ArgumentError, err_regex) { @p.opt "badd", "desc", :type => :date, :default => [] }
+    assert_raises_errmatch(ArgumentError, err_regex) { @p.opt "bads", "desc", :type => :string, :default => [] }
     opts = @p.parse([])
     assert_equal(opts["argmi"], [])
     assert_equal(opts["argmf"], [])
@@ -255,18 +315,20 @@ class ParserTest < ::MiniTest::Test
     @p.opt "goodarg2", "desc", :long => "--two"
     @p.opt "goodarg3", "desc", :long => "arg-3"
     @p.opt "goodarg4", "desc", :long => "--good-arg-four"
-    assert_raises(ArgumentError) { @p.opt "badarg", "desc", :long => "" }
-    assert_raises(ArgumentError) { @p.opt "badarg2", "desc", :long => "--" }
-    assert_raises(ArgumentError) { @p.opt "badarg3", "desc", :long => "-one" }
-    assert_raises(ArgumentError) { @p.opt "badarg4", "desc", :long => "---toomany" }
+    err_regex = /invalid long option name/
+    assert_raises_errmatch(ArgumentError, err_regex) { @p.opt "badarg", "desc", :long => "" }
+    assert_raises_errmatch(ArgumentError, err_regex) { @p.opt "badarg2", "desc", :long => "--" }
+    assert_raises_errmatch(ArgumentError, err_regex) { @p.opt "badarg3", "desc", :long => "-one" }
+    assert_raises_errmatch(ArgumentError, err_regex) { @p.opt "badarg4", "desc", :long => "---toomany" }
   end
 
   def test_short_detects_bad_names
     @p.opt "goodarg", "desc", :short => "a"
     @p.opt "goodarg2", "desc", :short => "-b"
-    assert_raises(ArgumentError) { @p.opt "badarg", "desc", :short => "" }
-    assert_raises(ArgumentError) { @p.opt "badarg2", "desc", :short => "-ab" }
-    assert_raises(ArgumentError) { @p.opt "badarg3", "desc", :short => "--t" }
+    err_regex = /invalid short option name/
+    assert_raises_errmatch(ArgumentError, err_regex) { @p.opt "badarg", "desc", :short => "" }
+    assert_raises_errmatch(ArgumentError, err_regex) { @p.opt "badarg2", "desc", :short => "-ab" }
+    assert_raises_errmatch(ArgumentError, err_regex) { @p.opt "badarg3", "desc", :short => "--t" }
   end
 
   def test_short_names_created_automatically
@@ -310,25 +372,29 @@ class ParserTest < ::MiniTest::Test
     @p.educate sio
     assert sio.string =~ /--arg\s+desc/
 
-    assert_raises(CommandlineError) { @p.parse %w(-a) }
+    assert_raises_errmatch(CommandlineError, /unknown argument '-a'/) { @p.parse %w(-a) }
   end
 
   ## two args can't have the same name
   def test_conflicting_names_are_detected
     @p.opt "goodarg"
-    assert_raises(ArgumentError) { @p.opt "goodarg" }
+    err_regex = /you already have an argument named 'goodarg'/
+    assert_raises_errmatch(ArgumentError, err_regex) { @p.opt "goodarg" }
   end
 
   ## two args can't have the same :long
   def test_conflicting_longs_detected
     @p.opt "goodarg", "desc", :long => "--goodarg"
-    assert_raises(ArgumentError) { @p.opt "badarg", "desc", :long => "--goodarg" }
+    err_regex = /long option name \"goodarg\" is already taken/
+
+    assert_raises_errmatch(ArgumentError, err_regex) { @p.opt "badarg", "desc", :long => "--goodarg" }
   end
 
   ## two args can't have the same :short
   def test_conflicting_shorts_detected
     @p.opt "goodarg", "desc", :short => "-g"
-    assert_raises(ArgumentError) { @p.opt "badarg", "desc", :short => "-g" }
+    err_regex = /short option name \"g\" is already taken/
+    assert_raises_errmatch(ArgumentError, err_regex) { @p.opt "badarg", "desc", :short => "-g" }
   end
 
   ## note: this behavior has changed in optimist 2.0!
@@ -397,7 +463,7 @@ class ParserTest < ::MiniTest::Test
     assert_equal false, opts[:no_default_true]
 
     ## disallow double negatives for reasons of sanity preservation
-    assert_raises(CommandlineError) { @p.parse %w(--no-no-default-true) }
+    assert_raises_errmatch(CommandlineError, /unknown argument '--no-default-true'/) { @p.parse %w(--no-no-default-true) }
   end
 
   def test_short_options_combine
@@ -420,8 +486,9 @@ class ParserTest < ::MiniTest::Test
     assert_equal true, opts[:arg2]
     assert_equal 4, opts[:arg3]
 
-    assert_raises(CommandlineError) { @p.parse %w(-cab 4) }
-    assert_raises(CommandlineError) { @p.parse %w(-cba 4) }
+    err_regex = /option '-c' needs a parameter/
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(-cab 4) }
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(-cba 4) }
   end
 
   def test_doubledash_ends_option_processing
@@ -508,13 +575,15 @@ Options:
     assert_equal(-0.1, opts[:arg])
     opts = @p.parse %w(-f -.1)
     assert_equal(-0.1, opts[:arg])
-    assert_raises(CommandlineError) { @p.parse %w(-f a) }
-    assert_raises(CommandlineError) { @p.parse %w(-f 1a) }
-    assert_raises(CommandlineError) { @p.parse %w(-f 1.a) }
-    assert_raises(CommandlineError) { @p.parse %w(-f a.1) }
-    assert_raises(CommandlineError) { @p.parse %w(-f 1.0.0) }
-    assert_raises(CommandlineError) { @p.parse %w(-f .) }
-    assert_raises(CommandlineError) { @p.parse %w(-f -.) }
+    err_regex = %r/option 'arg' needs a floating-point number/
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(-f a) }
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(-f 1a) }
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(-f 1.a) }
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(-f a.1) }
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(-f 1.0.0) }
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(-f .) }
+    err_regex = %r/unknown argument '-.'/
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(-f -.) }
   end
 
   def test_floating_point_formatting_default
@@ -532,23 +601,30 @@ Options:
   end
 
   def test_short_options_cant_be_numeric
-    assert_raises(ArgumentError) { @p.opt :arg, "desc", :short => "-1" }
+    err_regex = %r/short option name '1' can't be a number or a dash/
+    assert_raises_errmatch(ArgumentError, err_regex) { @p.opt :arg, "desc", :short => "-1" }
     @p.opt :a1b, "desc"
     @p.opt :a2b, "desc"
-    assert @p.specs[:a2b].short.to_i == 0
+    @p.parse []
+    # testing private interface to ensure default
+    # short options did not become numeric
+    assert_equal @p.specs[:a1b].short.chars.first, 'a'
+    assert_equal @p.specs[:a2b].short.chars.first, 'b'
   end
 
   def test_short_options_can_be_weird
     @p.opt :arg1, "desc", :short => "#"
     @p.opt :arg2, "desc", :short => "."
-    assert_raises(ArgumentError) { @p.opt :arg3, "desc", :short => "-" }
+    err_regex = %r/short option name '-' can't be a number or a dash/
+    assert_raises_errmatch(ArgumentError, err_regex) { @p.opt :arg3, "desc", :short => "-" }
   end
 
   def test_options_cant_be_set_multiple_times_if_not_specified
     @p.opt :arg, "desc", :short => "-x"
     @p.parse %w(-x)
-    assert_raises(CommandlineError) { @p.parse %w(-x -x) }
-    assert_raises(CommandlineError) { @p.parse %w(-xx) }
+    err_regex = /option '-x' specified multiple times/
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(-x -x) }
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(-xx) }
   end
 
   def test_options_can_be_set_multiple_times_if_specified
@@ -632,7 +708,7 @@ Options:
     assert_equal [4, 6, 9], opts[:arg3]
     assert_equal [3.14, 2.41], opts[:arg4]
 
-    assert_raises(CommandlineError) { opts = @p.parse %w(-abcd 3.14 2.41) }
+    assert_raises_errmatch(CommandlineError, /option '-c' needs a parameter/) { opts = @p.parse %w(-abcd 3.14 2.41) }
   end
 
   def test_long_options_with_multiple_options
@@ -712,7 +788,7 @@ Options:
 
   def test_auto_generated_long_names_convert_underscores_to_hyphens
     @p.opt :hello_there
-    assert_equal "hello-there", @p.specs[:hello_there].long
+    assert_equal "hello-there", @p.specs[:hello_there].long.long
   end
 
   def test_arguments_passed_through_block
@@ -724,126 +800,37 @@ Options:
     assert_equal @goat, boat
   end
 
+  ## test-only access reader method so that we dont have to
+  ## expose settings in the public API.
+  class Optimist::Parser
+    def get_settings_for_testing ; return @settings ;end
+  end
+
+  def test_two_arguments_passed_through_block
+    newp = Parser.new(:abcd => 123, :efgh => "other" ) do |i|
+    end
+    assert_equal newp.get_settings_for_testing[:abcd], 123
+    assert_equal newp.get_settings_for_testing[:efgh], "other"
+  end
+
+
   def test_version_and_help_override_errors
     @p.opt :asdf, "desc", :type => String
     @p.version "version"
     @p.parse %w(--asdf goat)
-    assert_raises(CommandlineError) { @p.parse %w(--asdf) }
+    assert_raises_errmatch(CommandlineError, /option '--asdf' needs a parameter/) { @p.parse %w(--asdf) }
     assert_raises(HelpNeeded) { @p.parse %w(--asdf --help) }
     assert_raises(VersionNeeded) { @p.parse %w(--asdf --version) }
   end
 
-  def test_conflicts
-    @p.opt :one
-    assert_raises(ArgumentError) { @p.conflicts :one, :two }
-    @p.opt :two
-    @p.conflicts :one, :two
-    @p.parse %w(--one)
-    @p.parse %w(--two)
-    assert_raises(CommandlineError) { @p.parse %w(--one --two) }
-
-    @p.opt :hello
-    @p.opt :yellow
-    @p.opt :mellow
-    @p.opt :jello
-    @p.conflicts :hello, :yellow, :mellow, :jello
-    assert_raises(CommandlineError) { @p.parse %w(--hello --yellow --mellow --jello) }
-    assert_raises(CommandlineError) { @p.parse %w(--hello --mellow --jello) }
-    assert_raises(CommandlineError) { @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(CommandlineError) { @p.parse %w(--mellow --two --jello) }
-    assert_raises(CommandlineError) { @p.parse %w(--one --mellow --two --jello) }
-  end
-
-  def test_either
-    @p.opt :one
-    assert_raises(ArgumentError) { @p.either :one, :two }
-    @p.opt :two
-    @p.either :one, :two
-    @p.parse %w(--one)
-    @p.parse %w(--two)
-    assert_raises(CommandlineError) { @p.parse %w(--one --two) }
-    assert_raises(CommandlineError) { @p.parse %w() }
-
-    @p.opt :hello
-    @p.opt :yellow
-    @p.opt :mellow
-    @p.opt :jello
-    @p.either :hello, :yellow, :mellow, :jello
-    assert_raises(CommandlineError) { @p.parse %w(--hello --yellow --mellow --jello) }
-    assert_raises(CommandlineError) { @p.parse %w(--hello --mellow --jello) }
-    assert_raises(CommandlineError) { @p.parse %w(--hello --jello) }
-
-    @p.parse %w(--hello --one)
-    @p.parse %w(--jello --two)
-    @p.parse %w(--mellow --one)
-    @p.parse %w(--mellow --two)
-
-    assert_raises(CommandlineError) { @p.parse %w(--mellow --two --jello) }
-    assert_raises(CommandlineError) { @p.parse %w(--one --mellow --two --jello) }
-  end
-
-  def test_conflict_error_messages
-    @p.opt :one
-    @p.opt "two"
-    @p.conflicts :one, "two"
-
-    assert_raises(CommandlineError, /--one.*--two/) { @p.parse %w(--one --two) }
-  end
-
-  def test_depends
-    @p.opt :one
-    assert_raises(ArgumentError) { @p.depends :one, :two }
-    @p.opt :two
-    @p.depends :one, :two
-    @p.parse %w(--one --two)
-    assert_raises(CommandlineError) { @p.parse %w(--one) }
-    assert_raises(CommandlineError) { @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)
-    assert_raises(CommandlineError) { @p.parse %w(--hello --mellow --jello) }
-    assert_raises(CommandlineError) { @p.parse %w(--hello --jello) }
-
-    assert_raises(CommandlineError) { @p.parse %w(--hello) }
-    assert_raises(CommandlineError) { @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(CommandlineError) { @p.parse %w(--mellow --two --jello --one) }
-  end
-
-  def test_depend_error_messages
-    @p.opt :one
-    @p.opt "two"
-    @p.depends :one, "two"
-
-    @p.parse %w(--one --two)
-
-    assert_raises(CommandlineError, /--one.*--two/) { @p.parse %w(--one) }
-    assert_raises(CommandlineError, /--one.*--two/) { @p.parse %w(--two) }
-  end
 
   ## courtesy neill zero
   def test_two_required_one_missing_accuses_correctly
     @p.opt "arg1", "desc1", :required => true
     @p.opt "arg2", "desc2", :required => true
 
-    assert_raises(CommandlineError, /arg2/) { @p.parse(%w(--arg1)) }
-    assert_raises(CommandlineError, /arg1/) { @p.parse(%w(--arg2)) }
+    assert_raises_errmatch(CommandlineError, /arg2/) { @p.parse(%w(--arg1)) }
+    assert_raises_errmatch(CommandlineError, /arg1/) { @p.parse(%w(--arg2)) }
     @p.parse(%w(--arg1 --arg2))
   end
 
@@ -1004,8 +991,11 @@ Options:
 
     opts = @p.parse %w(--arg3 stdin)
     assert_equal $stdin, opts[:arg3]
-
-    assert_raises(CommandlineError) { opts = @p.parse %w(--arg /fdasfasef/fessafef/asdfasdfa/fesasf) }
+    
+    err_regex = %r/file or url for option 'arg' cannot be opened: No such file or directory/
+    assert_raises_errmatch(CommandlineError, err_regex) {
+      opts = @p.parse %w(--arg /fdasfasef/fessafef/asdfasdfa/fesasf) 
+    }
   end
 
   def test_openstruct_style_access
@@ -1106,6 +1096,86 @@ Options:
     assert opts[:ccd]
   end
 
+  def test_short_opts_not_implicitly_created
+    newp = Parser.new(implicit_short_opts: false)
+    newp.opt :user1, "user1"
+    newp.opt :bag, "bag", :short => 'b'
+    assert_raises_errmatch(CommandlineError, /unknown argument '-u'/) do
+      newp.parse %w(-u)
+    end
+    opts = newp.parse %w(--user1)
+    assert opts[:user1]
+    opts = newp.parse %w(-b)
+    assert opts[:bag]
+  end
+
+  def test_short_opts_not_implicit_help_ver
+    # When implicit_short_opts is false this implies the short options
+    # for the built-in help/version are also not created.
+    newp = Parser.new(implicit_short_opts: false)
+    newp.opt :abc, "abc"
+    newp.version "3.4.5"
+    assert_raises_errmatch(CommandlineError, /unknown argument '-h'/) do
+      newp.parse %w(-h)
+    end
+    assert_raises_errmatch(CommandlineError, /unknown argument '-v'/) do
+      newp.parse %w(-v)
+    end
+    assert_raises(HelpNeeded) do
+      newp.parse %w(--help)
+    end
+    assert_raises(VersionNeeded) do
+      newp.parse %w(--version)
+    end
+  end
+
+  def test_inexact_match
+    newp = Parser.new(exact_match: false)
+    newp.opt :liberation, "liberate something", :type => :int
+    newp.opt :evaluate, "evaluate something", :type => :string
+    opts = newp.parse %w(--lib 5 --ev bar)
+    assert_equal 5, opts[:liberation]
+    assert_equal 'bar', opts[:evaluate]
+    assert_nil opts[:eval]
+  end
+
+  def test_exact_match
+    newp = Parser.new()
+    newp.opt :liberation, "liberate something", :type => :int
+    newp.opt :evaluate, "evaluate something", :type => :string
+    assert_raises_errmatch(CommandlineError, /unknown argument '--lib'/) do
+      newp.parse %w(--lib 5)
+    end
+    assert_raises_errmatch(CommandlineError, /unknown argument '--ev'/) do
+      newp.parse %w(--ev bar)
+    end
+  end
+
+  def test_inexact_collision
+    newp = Parser.new(exact_match: false)
+    newp.opt :bookname, "name of a book", :type => :string
+    newp.opt :bookcost, "cost of the book", :type => :string
+    opts = newp.parse %w(--bookn hairy_potsworth --bookc 10)
+    assert_equal 'hairy_potsworth', opts[:bookname]
+    assert_equal '10', opts[:bookcost]
+    assert_raises_errmatch(CommandlineError, /ambiguous option '--book' matched keys \(bookname,bookcost\)/) do
+      newp.parse %w(--book 5) # ambiguous
+    end
+    ## partial match causes 'specified multiple times' error
+    assert_raises_errmatch(CommandlineError, /specified multiple times/) do
+      newp.parse %w(--bookc 17 --bookcost 22)
+    end
+  end
+
+  def test_inexact_collision_with_exact
+    newp = Parser.new(exact_match: false)
+    newp.opt :book, "name of a book", :type => :string, :default => "ABC"
+    newp.opt :bookcost, "cost of the book", :type => :int, :default => 5
+    opts = newp.parse %w(--book warthog --bookc 3)
+    assert_equal 'warthog', opts[:book]
+    assert_equal 3, opts[:bookcost]
+  end
+
   def test_accepts_arguments_with_spaces
     @p.opt :arg1, "arg", :type => String
     @p.opt :arg2, "arg2", :type => String
@@ -1163,7 +1233,7 @@ Options:
   end
 
   def test_simple_interface_handles_die
-    assert_stderr do
+    assert_stderr(/Error: argument --potato is invalid/) do
       ::Optimist::options(%w(--potato)) do
         opt :potato
       end
@@ -1172,7 +1242,7 @@ Options:
   end
 
   def test_simple_interface_handles_die_without_message
-    assert_stderr(/Error:/) do
+    assert_stderr(/Error: potato\./) do
       ::Optimist::options(%w(--potato)) do
         opt :potato
       end
@@ -1181,7 +1251,7 @@ Options:
   end
 
   def test_invalid_option_with_simple_interface
-    assert_stderr do
+    assert_stderr(/Error: unknown argument \'--potato\'\./) do
       assert_raises(SystemExit) do
         ::Optimist.options(%w(--potato))
       end
@@ -1197,7 +1267,7 @@ Options:
   end
 
   def test_supports_callback_inline
-    assert_raises(RuntimeError, "good") do
+    assert_raises_errmatch(RuntimeError, "good") do
       @p.opt :cb1 do |vals|
         raise "good"
       end
@@ -1206,7 +1276,7 @@ Options:
   end
 
   def test_supports_callback_param
-    assert_raises(RuntimeError, "good") do
+    assert_raises_errmatch(RuntimeError, "good") do
       @p.opt :cb1, "with callback", :callback => lambda { |vals| raise "good" }
       @p.parse(%w(--cb1))
     end
@@ -1261,6 +1331,37 @@ Options:
     assert opts[:arg1]
     assert_equal %w{-bu potato}, @p.leftovers
   end
+
+  # Due to strangeness in how the cloaker works, there were
+  # cases where Optimist.parse would work, but Optimist.options
+  # did not, depending on arguments given to the function.
+  # These serve to validate different args given to Optimist.options
+  def test_options_takes_hashy_settings
+    passargs_copy = []
+    settings_copy = []
+    ::Optimist.options(%w(--wig --pig), :fizz=>:buzz, :bear=>:cat) do |*passargs|
+      opt :wig
+      opt :pig
+      passargs_copy = passargs.dup
+      settings_copy = @settings
+    end
+    assert_equal [], passargs_copy
+    assert_equal settings_copy[:fizz], :buzz
+    assert_equal settings_copy[:bear], :cat
+  end
+
+  def test_options_takes_some_other_data
+    passargs_copy = []
+    settings_copy = []
+    ::Optimist.options(%w(--nose --close), 1, 2, 3) do |*passargs|
+      opt :nose
+      opt :close
+      passargs_copy = passargs.dup
+      settings_copy = @settings
+    end
+    assert_equal [1,2,3], passargs_copy
+    assert_equal(Optimist::Parser::DEFAULT_SETTINGS, settings_copy)
+  end
 end
 
 end