test/test_option_parser.rb in cri-2.12.0 vs test/test_option_parser.rb in cri-2.13.0

@@ -6,43 +6,43 @@
   class OptionParserTestCase < Cri::TestCase
     def test_parse_without_options
       input = %w[foo bar baz]
       opt_defns = []
 
-      parser = Cri::OptionParser.new(input, opt_defns, []).run
+      parser = Cri::OptionParser.new(input, opt_defns, [], false).run
 
       assert_equal({}, parser.options)
       assert_equal(%w[foo bar baz], parser.arguments.to_a)
     end
 
     def test_parse_with_invalid_option
       input = %w[foo -x]
       opt_defns = []
 
       assert_raises(Cri::OptionParser::IllegalOptionError) do
-        Cri::OptionParser.new(input, opt_defns, []).run
+        Cri::OptionParser.new(input, opt_defns, [], false).run
       end
     end
 
     def test_parse_with_unused_options
       input = %w[foo]
       opt_defns = [
         { long: 'aaa', short: 'a', argument: :forbidden },
       ].map { |hash| make_opt_defn(hash) }
 
-      parser = Cri::OptionParser.new(input, opt_defns, []).run
+      parser = Cri::OptionParser.new(input, opt_defns, [], false).run
 
       assert(!parser.options[:aaa])
     end
 
     def test_parse_with_long_valueless_option
       input = %w[foo --aaa bar]
       opt_defns = [
         { long: 'aaa', short: 'a', argument: :forbidden },
       ].map { |hash| make_opt_defn(hash) }
 
-      parser = Cri::OptionParser.new(input, opt_defns, []).run
+      parser = Cri::OptionParser.new(input, opt_defns, [], false).run
 
       assert(parser.options[:aaa])
       assert_equal(%w[foo bar], parser.arguments.to_a)
     end
 
@@ -50,11 +50,11 @@
       input = %w[foo --aaa xxx bar]
       opt_defns = [
         { long: 'aaa', short: 'a', argument: :required },
       ].map { |hash| make_opt_defn(hash) }
 
-      parser = Cri::OptionParser.new(input, opt_defns, []).run
+      parser = Cri::OptionParser.new(input, opt_defns, [], false).run
 
       assert_equal({ aaa: 'xxx' }, parser.options)
       assert_equal(%w[foo bar], parser.arguments.to_a)
     end
 
@@ -62,11 +62,11 @@
       input = %w[foo --aaa=xxx bar]
       opt_defns = [
         { long: 'aaa', short: 'a', argument: :required },
       ].map { |hash| make_opt_defn(hash) }
 
-      parser = Cri::OptionParser.new(input, opt_defns, []).run
+      parser = Cri::OptionParser.new(input, opt_defns, [], false).run
 
       assert_equal({ aaa: 'xxx' }, parser.options)
       assert_equal(%w[foo bar], parser.arguments.to_a)
     end
 
@@ -75,11 +75,11 @@
       opt_defns = [
         { long: 'aaa', short: 'a', argument: :required },
       ].map { |hash| make_opt_defn(hash) }
 
       assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
-        Cri::OptionParser.new(input, opt_defns, []).run
+        Cri::OptionParser.new(input, opt_defns, [], false).run
       end
     end
 
     def test_parse_with_two_long_valueful_options
       input = %w[foo --all --port 2]
@@ -87,21 +87,21 @@
         { long: 'all',  short: 'a', argument: :required },
         { long: 'port', short: 'p', argument: :required },
       ].map { |hash| make_opt_defn(hash) }
 
       assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
-        Cri::OptionParser.new(input, opt_defns, []).run
+        Cri::OptionParser.new(input, opt_defns, [], false).run
       end
     end
 
     def test_parse_with_long_valueless_option_with_optional_value
       input = %w[foo --aaa]
       opt_defns = [
         { long: 'aaa', short: 'a', argument: :optional },
       ].map { |hash| make_opt_defn(hash) }
 
-      parser = Cri::OptionParser.new(input, opt_defns, []).run
+      parser = Cri::OptionParser.new(input, opt_defns, [], false).run
 
       assert(parser.options[:aaa])
       assert_equal(['foo'], parser.arguments.to_a)
     end
 
@@ -109,11 +109,11 @@
       input = %w[foo --aaa xxx]
       opt_defns = [
         { long: 'aaa', short: 'a', argument: :optional },
       ].map { |hash| make_opt_defn(hash) }
 
-      parser = Cri::OptionParser.new(input, opt_defns, []).run
+      parser = Cri::OptionParser.new(input, opt_defns, [], false).run
 
       assert_equal({ aaa: 'xxx' }, parser.options)
       assert_equal(['foo'], parser.arguments.to_a)
     end
 
@@ -123,11 +123,11 @@
         { long: 'aaa', short: 'a', argument: :optional  },
         { long: 'bbb', short: 'b', argument: :forbidden },
         { long: 'ccc', short: 'c', argument: :forbidden },
       ].map { |hash| make_opt_defn(hash) }
 
-      parser = Cri::OptionParser.new(input, opt_defns, []).run
+      parser = Cri::OptionParser.new(input, opt_defns, [], false).run
 
       assert(parser.options[:aaa])
       assert(parser.options[:bbb])
       assert(parser.options[:ccc])
       assert_equal(['foo'], parser.arguments.to_a)
@@ -137,11 +137,11 @@
       input = %w[foo -a bar]
       opt_defns = [
         { long: 'aaa', short: 'a', argument: :forbidden },
       ].map { |hash| make_opt_defn(hash) }
 
-      parser = Cri::OptionParser.new(input, opt_defns, []).run
+      parser = Cri::OptionParser.new(input, opt_defns, [], false).run
 
       assert(parser.options[:aaa])
       assert_equal(%w[foo bar], parser.arguments.to_a)
     end
 
@@ -150,11 +150,11 @@
       opt_defns = [
         { long: 'aaa', short: 'a', argument: :required },
       ].map { |hash| make_opt_defn(hash) }
 
       assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
-        Cri::OptionParser.new(input, opt_defns, []).run
+        Cri::OptionParser.new(input, opt_defns, [], false).run
       end
     end
 
     def test_parse_with_short_combined_valueless_options
       input = %w[foo -abc bar]
@@ -162,11 +162,11 @@
         { long: 'aaa', short: 'a', argument: :forbidden },
         { long: 'bbb', short: 'b', argument: :forbidden },
         { long: 'ccc', short: 'c', argument: :forbidden },
       ].map { |hash| make_opt_defn(hash) }
 
-      parser = Cri::OptionParser.new(input, opt_defns, []).run
+      parser = Cri::OptionParser.new(input, opt_defns, [], false).run
 
       assert(parser.options[:aaa])
       assert(parser.options[:bbb])
       assert(parser.options[:ccc])
       assert_equal(%w[foo bar], parser.arguments.to_a)
@@ -178,11 +178,11 @@
         { long: 'aaa', short: 'a', argument: :required  },
         { long: 'bbb', short: 'b', argument: :forbidden },
         { long: 'ccc', short: 'c', argument: :forbidden },
       ].map { |hash| make_opt_defn(hash) }
 
-      parser = Cri::OptionParser.new(input, opt_defns, []).run
+      parser = Cri::OptionParser.new(input, opt_defns, [], false).run
 
       assert_equal('bar', parser.options[:aaa])
       assert(parser.options[:bbb])
       assert(parser.options[:ccc])
       assert_equal(%w[foo qux], parser.arguments.to_a)
@@ -194,21 +194,21 @@
         { long: 'all',  short: 'a', argument: :required },
         { long: 'port', short: 'p', argument: :required },
       ].map { |hash| make_opt_defn(hash) }
 
       assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
-        Cri::OptionParser.new(input, opt_defns, []).run
+        Cri::OptionParser.new(input, opt_defns, [], false).run
       end
     end
 
     def test_parse_with_short_valueless_option_with_optional_value
       input = %w[foo -a]
       opt_defns = [
         { long: 'aaa', short: 'a', argument: :optional },
       ].map { |hash| make_opt_defn(hash) }
 
-      parser = Cri::OptionParser.new(input, opt_defns, []).run
+      parser = Cri::OptionParser.new(input, opt_defns, [], false).run
 
       assert(parser.options[:aaa])
       assert_equal(['foo'], parser.arguments.to_a)
     end
 
@@ -216,11 +216,11 @@
       input = %w[foo -a xxx]
       opt_defns = [
         { long: 'aaa', short: 'a', argument: :optional },
       ].map { |hash| make_opt_defn(hash) }
 
-      parser = Cri::OptionParser.new(input, opt_defns, []).run
+      parser = Cri::OptionParser.new(input, opt_defns, [], false).run
 
       assert_equal({ aaa: 'xxx' }, parser.options)
       assert_equal(['foo'], parser.arguments.to_a)
     end
 
@@ -230,11 +230,11 @@
         { long: 'aaa', short: 'a', argument: :optional  },
         { long: 'bbb', short: 'b', argument: :forbidden },
         { long: 'ccc', short: 'c', argument: :forbidden },
       ].map { |hash| make_opt_defn(hash) }
 
-      parser = Cri::OptionParser.new(input, opt_defns, []).run
+      parser = Cri::OptionParser.new(input, opt_defns, [], false).run
 
       assert(parser.options[:aaa])
       assert(parser.options[:bbb])
       assert(parser.options[:ccc])
       assert_equal(['foo'], parser.arguments.to_a)
@@ -242,21 +242,21 @@
 
     def test_parse_with_single_hyphen
       input = %w[foo - bar]
       opt_defns = []
 
-      parser = Cri::OptionParser.new(input, opt_defns, []).run
+      parser = Cri::OptionParser.new(input, opt_defns, [], false).run
 
       assert_equal({}, parser.options)
       assert_equal(['foo', '-', 'bar'], parser.arguments.to_a)
     end
 
     def test_parse_with_end_marker
       input = %w[foo bar -- -x --yyy -abc]
       opt_defns = []
 
-      parser = Cri::OptionParser.new(input, opt_defns, []).run
+      parser = Cri::OptionParser.new(input, opt_defns, [], false).run
 
       assert_equal({}, parser.options)
       assert_equal(['foo', 'bar', '-x', '--yyy', '-abc'], parser.arguments.to_a)
     end
 
@@ -265,22 +265,22 @@
       opt_defns = [
         { long: 'aaa', short: 'a', argument: :required },
       ].map { |hash| make_opt_defn(hash) }
 
       assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
-        Cri::OptionParser.new(input, opt_defns, []).run
+        Cri::OptionParser.new(input, opt_defns, [], false).run
       end
     end
 
     def test_parse_with_multiple_options
       input = %w[foo -o test -o test2 -v -v -v]
       opt_defns = [
         { long: 'long', short: 'o', argument: :required, multiple: true },
         { long: 'verbose', short: 'v', multiple: true },
       ].map { |hash| make_opt_defn(hash) }
 
-      parser = Cri::OptionParser.new(input, opt_defns, []).run
+      parser = Cri::OptionParser.new(input, opt_defns, [], false).run
 
       assert_equal(%w[test test2], parser.options[:long])
       assert_equal(3, parser.options[:verbose].size)
     end
 
@@ -288,11 +288,11 @@
       input = %w[foo]
       opt_defns = [
         { long: 'animal', short: 'a', argument: :required, default: 'donkey' },
       ].map { |hash| make_opt_defn(hash) }
 
-      parser = Cri::OptionParser.new(input, opt_defns, []).run
+      parser = Cri::OptionParser.new(input, opt_defns, [], false).run
 
       assert_equal({ animal: 'donkey' }, parser.options)
       assert_equal(['foo'], parser.arguments.to_a)
     end
 
@@ -301,21 +301,21 @@
       opt_defns = [
         { long: 'animal', short: 'a', argument: :required, default: 'donkey' },
       ].map { |hash| make_opt_defn(hash) }
 
       assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
-        Cri::OptionParser.new(input, opt_defns, []).run
+        Cri::OptionParser.new(input, opt_defns, [], false).run
       end
     end
 
     def test_parse_with_default_required_value
       input = %w[foo -a giraffe]
       opt_defns = [
         { long: 'animal', short: 'a', argument: :required, default: 'donkey' },
       ].map { |hash| make_opt_defn(hash) }
 
-      parser = Cri::OptionParser.new(input, opt_defns, []).run
+      parser = Cri::OptionParser.new(input, opt_defns, [], false).run
 
       assert_equal({ animal: 'giraffe' }, parser.options)
       assert_equal(['foo'], parser.arguments.to_a)
     end
 
@@ -323,11 +323,11 @@
       input = %w[foo]
       opt_defns = [
         { long: 'animal', short: 'a', argument: :optional, default: 'donkey' },
       ].map { |hash| make_opt_defn(hash) }
 
-      parser = Cri::OptionParser.new(input, opt_defns, []).run
+      parser = Cri::OptionParser.new(input, opt_defns, [], false).run
 
       assert_equal({ animal: 'donkey' }, parser.options)
       assert_equal(['foo'], parser.arguments.to_a)
     end
 
@@ -335,11 +335,11 @@
       input = %w[foo -a]
       opt_defns = [
         { long: 'animal', short: 'a', argument: :optional, default: 'donkey' },
       ].map { |hash| make_opt_defn(hash) }
 
-      parser = Cri::OptionParser.new(input, opt_defns, []).run
+      parser = Cri::OptionParser.new(input, opt_defns, [], false).run
 
       assert_equal({ animal: 'donkey' }, parser.options)
       assert_equal(['foo'], parser.arguments.to_a)
     end
 
@@ -347,11 +347,11 @@
       input = %w[foo -a giraffe]
       opt_defns = [
         { long: 'animal', short: 'a', argument: :optional, default: 'donkey' },
       ].map { |hash| make_opt_defn(hash) }
 
-      parser = Cri::OptionParser.new(input, opt_defns, []).run
+      parser = Cri::OptionParser.new(input, opt_defns, [], false).run
 
       assert_equal({ animal: 'giraffe' }, parser.options)
       assert_equal(['foo'], parser.arguments.to_a)
     end
 
@@ -359,11 +359,11 @@
       input = %w[foo -a gi raffe]
       opt_defns = [
         { long: 'animal', short: 'a', argument: :optional, default: 'donkey' },
       ].map { |hash| make_opt_defn(hash) }
 
-      parser = Cri::OptionParser.new(input, opt_defns, []).run
+      parser = Cri::OptionParser.new(input, opt_defns, [], false).run
 
       assert_equal({ animal: 'gi' }, parser.options)
       assert_equal(%w[foo raffe], parser.arguments.to_a)
     end
 
@@ -373,11 +373,11 @@
         { long: 'aaa', short: 'a', argument: :forbidden },
         { long: 'bbb', short: 'b', argument: :required },
         { long: 'ccc', short: 'c', argument: :required },
       ].map { |hash| make_opt_defn(hash) }
 
-      parser = Cri::OptionParser.new(input, opt_defns, []).run
+      parser = Cri::OptionParser.new(input, opt_defns, [], false).run
 
       assert_equal({ aaa: true, bbb: 'xxx', ccc: 'yyy' }, parser.options)
       assert_equal(%w[foo zzz], parser.arguments.to_a)
     end
 
@@ -387,11 +387,11 @@
         { long: 'aaa', short: 'a', argument: :forbidden },
         { long: 'bbb', short: 'b', argument: :optional },
         { long: 'ccc', short: 'c', argument: :required },
       ].map { |hash| make_opt_defn(hash) }
 
-      parser = Cri::OptionParser.new(input, opt_defns, []).run
+      parser = Cri::OptionParser.new(input, opt_defns, [], false).run
 
       assert_equal({ aaa: true, bbb: 'xxx', ccc: 'yyy' }, parser.options)
       assert_equal(%w[foo zzz], parser.arguments.to_a)
     end
 
@@ -401,11 +401,11 @@
         { long: 'aaa', short: 'a', argument: :forbidden },
         { long: 'bbb', short: 'b', argument: :required },
         { long: 'ccc', short: 'c', argument: :optional, default: 'c default' },
       ].map { |hash| make_opt_defn(hash) }
 
-      parser = Cri::OptionParser.new(input, opt_defns, []).run
+      parser = Cri::OptionParser.new(input, opt_defns, [], false).run
 
       assert_equal({ aaa: true, bbb: 'xxx', ccc: 'c default' }, parser.options)
       assert_equal(%w[foo], parser.arguments.to_a)
     end
 
@@ -413,11 +413,11 @@
       input = %w[--port 123]
       opt_defns = [
         { long: 'port', short: 'p', argument: :required, transform: ->(x) { Integer(x) } },
       ].map { |hash| make_opt_defn(hash) }
 
-      parser = Cri::OptionParser.new(input, opt_defns, []).run
+      parser = Cri::OptionParser.new(input, opt_defns, [], false).run
 
       assert_equal({ port: 123 }, parser.options)
       assert_equal([], parser.arguments.to_a)
     end
 
@@ -425,11 +425,11 @@
       input = %w[--port 123]
       opt_defns = [
         { long: 'port', short: 'p', argument: :required, transform: method(:Integer) },
       ].map { |hash| make_opt_defn(hash) }
 
-      parser = Cri::OptionParser.new(input, opt_defns, []).run
+      parser = Cri::OptionParser.new(input, opt_defns, [], false).run
 
       assert_equal({ port: 123 }, parser.options)
       assert_equal([], parser.arguments.to_a)
     end
 
@@ -443,11 +443,11 @@
       input = %w[--port 123]
       opt_defns = [
         { long: 'port', short: 'p', argument: :required, transform: port },
       ].map { |hash| make_opt_defn(hash) }
 
-      parser = Cri::OptionParser.new(input, opt_defns, []).run
+      parser = Cri::OptionParser.new(input, opt_defns, [], false).run
 
       assert_equal({ port: 123 }, parser.options)
       assert_equal([], parser.arguments.to_a)
     end
 
@@ -462,11 +462,11 @@
       input = %w[]
       opt_defns = [
         { long: 'port', short: 'p', argument: :required, default: 8080, transform: port },
       ].map { |hash| make_opt_defn(hash) }
 
-      parser = Cri::OptionParser.new(input, opt_defns, []).run
+      parser = Cri::OptionParser.new(input, opt_defns, [], false).run
 
       assert_equal({ port: 8080 }, parser.options)
       assert_equal([], parser.arguments.to_a)
     end
 
@@ -475,22 +475,22 @@
       opt_defns = [
         { long: 'port', short: 'p', argument: :required, transform: method(:Integer) },
       ].map { |hash| make_opt_defn(hash) }
 
       exception = assert_raises(Cri::OptionParser::IllegalOptionValueError) do
-        Cri::OptionParser.new(input, opt_defns, []).run
+        Cri::OptionParser.new(input, opt_defns, [], false).run
       end
       assert_equal('invalid value "one_hundred_and_twenty_three" for --port option', exception.message)
     end
 
     def test_parse_with_param_defns
       input       = %w[localhost]
       param_defns = [
         { name: 'host' },
       ].map { |hash| Cri::ParamDefinition.new(hash) }
 
-      parser = Cri::OptionParser.new(input, [], param_defns).run
+      parser = Cri::OptionParser.new(input, [], param_defns, false).run
       assert_equal({}, parser.options)
       assert_equal('localhost', parser.arguments[0])
       assert_equal('localhost', parser.arguments[:host])
     end
 
@@ -498,11 +498,11 @@
       input       = []
       param_defns = [
         { name: 'host' },
       ].map { |hash| Cri::ParamDefinition.new(hash) }
 
-      parser = Cri::OptionParser.new(input, [], param_defns).run
+      parser = Cri::OptionParser.new(input, [], param_defns, false).run
       exception = assert_raises(Cri::ArgumentList::ArgumentCountMismatchError) do
         parser.arguments
       end
       assert_equal('incorrect number of arguments given: expected 1, but got 0', exception.message)
     end
@@ -511,11 +511,11 @@
       input       = %w[localhost oink]
       param_defns = [
         { name: 'host' },
       ].map { |hash| Cri::ParamDefinition.new(hash) }
 
-      parser = Cri::OptionParser.new(input, [], param_defns).run
+      parser = Cri::OptionParser.new(input, [], param_defns, false).run
       exception = assert_raises(Cri::ArgumentList::ArgumentCountMismatchError) do
         parser.arguments
       end
       assert_equal('incorrect number of arguments given: expected 1, but got 2', exception.message)
     end
@@ -524,11 +524,11 @@
       input       = %w[localhost]
       param_defns = [
         { name: 'host' },
       ].map { |hash| Cri::ParamDefinition.new(hash) }
 
-      parser = Cri::OptionParser.new(input, [], param_defns).run
+      parser = Cri::OptionParser.new(input, [], param_defns, false).run
 
       exception = assert_raises(ArgumentError) do
         parser.arguments['oink']
       end
       assert_equal('argument lists can be indexed using a Symbol or an Integer, but not a String', exception.message)
@@ -539,10 +539,10 @@
       param_defns = [
         { name: 'source' },
         { name: 'target' },
       ].map { |hash| Cri::ParamDefinition.new(hash) }
 
-      parser = Cri::OptionParser.new(input, [], param_defns).run
+      parser = Cri::OptionParser.new(input, [], param_defns, false).run
       assert_equal({}, parser.options)
       assert_equal('localhost', parser.arguments[0])
       assert_equal('localhost', parser.arguments[:source])
       assert_equal('example.com', parser.arguments[1])
       assert_equal('example.com', parser.arguments[:target])