thor 0.18.1 → 0.19.0

data/spec/shell_spec.rb

@@ -1,4 +1,4 @@
-require 'helper'
+require "helper"
 
 describe Thor::Shell do
   def shell
@@ -7,29 +7,29 @@ describe Thor::Shell do
 
   describe "#initialize" do
     it "sets shell value" do
-      base = MyCounter.new [1, 2], { }, :shell => shell
+      base = MyCounter.new [1, 2], {}, :shell => shell
       expect(base.shell).to eq(shell)
     end
 
     it "sets the base value on the shell if an accessor is available" do
-      base = MyCounter.new [1, 2], { }, :shell => shell
+      base = MyCounter.new [1, 2], {}, :shell => shell
       expect(shell.base).to eq(base)
     end
   end
 
   describe "#shell" do
     it "returns the shell in use" do
-      expect(MyCounter.new([1,2]).shell).to be_kind_of(Thor::Base.shell)
+      expect(MyCounter.new([1, 2]).shell).to be_kind_of(Thor::Base.shell)
     end
 
     it "uses $THOR_SHELL" do
       class Thor::Shell::TestShell < Thor::Shell::Basic; end
 
       expect(Thor::Base.shell).to eq(shell.class)
-      ENV['THOR_SHELL'] = 'TestShell'
+      ENV["THOR_SHELL"] = "TestShell"
       Thor::Base.shell = nil
       expect(Thor::Base.shell).to eq(Thor::Shell::TestShell)
-      ENV['THOR_SHELL'] = ''
+      ENV["THOR_SHELL"] = ""
       Thor::Base.shell = shell.class
       expect(Thor::Base.shell).to eq(shell.class)
     end
@@ -37,7 +37,7 @@ describe Thor::Shell do
 
   describe "with_padding" do
     it "uses padding for inside block outputs" do
-      base = MyCounter.new([1,2])
+      base = MyCounter.new([1, 2])
       base.with_padding do
         expect(capture(:stdout) { base.say_status :padding, "cool" }.strip).to eq("padding    cool")
       end

data/spec/subcommand_spec.rb

@@ -1,4 +1,4 @@
-require 'helper'
+require "helper"
 
 describe Thor do
 
@@ -18,13 +18,31 @@ describe Thor do
     end
 
     it "ignores unknown options (the subcommand class will handle them)" do
-      expect(capture(:stdout) { Scripts::MyDefaults.start(%w[barn paint blue --coats 4])}.strip).to eq("4 coats of blue paint")
+      expect(capture(:stdout) { Scripts::MyDefaults.start(%w[barn paint blue --coats 4]) }.strip).to eq("4 coats of blue paint")
     end
 
     it "passes parsed options to subcommands" do
       output = capture(:stdout) { TestSubcommands::Parent.start(%w[sub print_opt --opt output]) }
       expect(output).to eq("output")
     end
+
+    it "accepts the help switch and calls the help command on the subcommand" do
+      output = capture(:stdout) { TestSubcommands::Parent.start(%w[sub print_opt --help]) }
+      sub_help = capture(:stdout) { TestSubcommands::Parent.start(%w[sub help print_opt]) }
+      expect(output).to eq(sub_help)
+    end
+
+    it "accepts the help short switch and calls the help command on the subcommand" do
+      output = capture(:stdout) { TestSubcommands::Parent.start(%w[sub print_opt -h]) }
+      sub_help = capture(:stdout) { TestSubcommands::Parent.start(%w[sub help print_opt]) }
+      expect(output).to eq(sub_help)
+    end
+
+    it "the help command on the subcommand and after it should result in the same output" do
+      output = capture(:stdout) { TestSubcommands::Parent.start(%w[sub help])}
+      sub_help = capture(:stdout) { TestSubcommands::Parent.start(%w[help sub])}
+      expect(output).to eq(sub_help)
+    end
   end
 
 end

data/spec/thor_spec.rb

@@ -1,61 +1,61 @@
-require 'helper'
+require "helper"
 
 describe Thor do
   describe "#method_option" do
     it "sets options to the next method to be invoked" do
-      args = ["foo", "bar", "--force"]
-      arg, options = MyScript.start(args)
-      expect(options).to eq({ "force" => true })
+      args = %w[foo bar --force]
+      _, options = MyScript.start(args)
+      expect(options).to eq("force" => true)
     end
 
     describe ":lazy_default" do
       it "is absent when option is not specified" do
-        arg, options = MyScript.start(["with_optional"])
+        _, options = MyScript.start(%w[with_optional])
         expect(options).to eq({})
       end
 
       it "sets a default that can be overridden for strings" do
-        arg, options = MyScript.start(["with_optional", "--lazy"])
-        expect(options).to eq({ "lazy" => "yes" })
+        _, options = MyScript.start(%w[with_optional --lazy])
+        expect(options).to eq("lazy" => "yes")
 
-        arg, options = MyScript.start(["with_optional", "--lazy", "yesyes!"])
-        expect(options).to eq({ "lazy" => "yesyes!" })
+        _, options = MyScript.start(%w[with_optional --lazy yesyes!])
+        expect(options).to eq("lazy" => "yesyes!")
       end
 
       it "sets a default that can be overridden for numerics" do
-        arg, options = MyScript.start(["with_optional", "--lazy-numeric"])
-        expect(options).to eq({ "lazy_numeric" => 42 })
+        _, options = MyScript.start(%w[with_optional --lazy-numeric])
+        expect(options).to eq("lazy_numeric" => 42)
 
-        arg, options = MyScript.start(["with_optional", "--lazy-numeric", 20000])
-        expect(options).to eq({ "lazy_numeric" => 20000 })
+        _, options = MyScript.start(%w[with_optional --lazy-numeric 20000])
+        expect(options).to eq("lazy_numeric" => 20_000)
       end
 
       it "sets a default that can be overridden for arrays" do
-        arg, options = MyScript.start(["with_optional", "--lazy-array"])
-        expect(options).to eq({ "lazy_array" => %w[eat at joes] })
+        _, options = MyScript.start(%w[with_optional --lazy-array])
+        expect(options).to eq("lazy_array" => %w[eat at joes])
 
-        arg, options = MyScript.start(["with_optional", "--lazy-array", "hello", "there"])
-        expect(options).to eq({ "lazy_array" => %w[hello there] })
+        _, options = MyScript.start(%w[with_optional --lazy-array hello there])
+        expect(options).to eq("lazy_array" => %w[hello there])
       end
 
       it "sets a default that can be overridden for hashes" do
-        arg, options = MyScript.start(["with_optional", "--lazy-hash"])
-        expect(options).to eq({ "lazy_hash" => {'swedish' => 'meatballs'} })
+        _, options = MyScript.start(%w[with_optional --lazy-hash])
+        expect(options).to eq("lazy_hash" => {"swedish" => "meatballs"})
 
-        arg, options = MyScript.start(["with_optional", "--lazy-hash", "polish:sausage"])
-        expect(options).to eq({ "lazy_hash" => {'polish' => 'sausage'} })
+        _, options = MyScript.start(%w[with_optional --lazy-hash polish:sausage])
+        expect(options).to eq("lazy_hash" => {"polish" => "sausage"})
       end
     end
 
     describe "when :for is supplied" do
       it "updates an already defined command" do
-        args, options = MyChildScript.start(["animal", "horse", "--other=fish"])
+        _, options = MyChildScript.start(%w[animal horse --other=fish])
         expect(options[:other]).to eq("fish")
       end
 
       describe "and the target is on the parent class" do
         it "updates an already defined command" do
-          args = ["example_default_command", "my_param", "--new-option=verified"]
+          args = %w[example_default_command my_param --new-option=verified]
           options = Scripts::MyScript.start(args)
           expect(options[:new_option]).to eq("verified")
         end
@@ -81,7 +81,7 @@ describe Thor do
     end
 
     it "invokes the default command if no command is specified even if switches are given" do
-      expect(MyScript.start(["--with", "option"])).to eq({"with"=>"option"})
+      expect(MyScript.start(%w[--with option])).to eq("with" => "option")
     end
 
     it "inherits the default command from parent" do
@@ -98,37 +98,37 @@ describe Thor do
 
       desc "exec", "Run a command"
       def exec(*args)
-        return options, args
+        [options, args]
       end
 
       desc "boring", "An ordinary command"
       def boring(*args)
-        return options, args
+        [options, args]
       end
     end
 
     it "passes remaining args to command when it encounters a non-option" do
-      expect(my_script.start(%w[exec command --verbose])).to eq [{}, ["command", "--verbose"]]
+      expect(my_script.start(%w[exec command --verbose])).to eq [{}, %w[command --verbose]]
     end
 
     it "passes remaining args to command when it encounters an unknown option" do
-      expect(my_script.start(%w[exec --foo command --bar])).to eq [{}, ["--foo", "command", "--bar"]]
+      expect(my_script.start(%w[exec --foo command --bar])).to eq [{}, %w[--foo command --bar]]
     end
 
     it "still accepts options that are given before non-options" do
-      expect(my_script.start(%w[exec --verbose command --foo])).to eq [{"verbose" => true}, ["command", "--foo"]]
+      expect(my_script.start(%w[exec --verbose command --foo])).to eq [{"verbose" => true}, %w[command --foo]]
     end
 
     it "still accepts options that require a value" do
-      expect(my_script.start(%w[exec --mode rashly command])).to eq [{"mode" => "rashly"}, ["command"]]
+      expect(my_script.start(%w[exec --mode rashly command])).to eq [{"mode" => "rashly"}, %w[command]]
     end
 
     it "still passes everything after -- to command" do
-      expect(my_script.start(%w[exec -- --verbose])).to eq [{}, ["--verbose"]]
+      expect(my_script.start(%w[exec -- --verbose])).to eq [{}, %w[--verbose]]
     end
 
     it "does not affect ordinary commands"  do
-      expect(my_script.start(%w[boring command --verbose])).to eq [{"verbose" => true}, ["command"]]
+      expect(my_script.start(%w[boring command --verbose])).to eq [{"verbose" => true}, %w[command]]
     end
 
     context "when provided with multiple command names" do
@@ -136,9 +136,9 @@ describe Thor do
         stop_on_unknown_option! :foo, :bar
       end
       it "affects all specified commands" do
-        expect(klass.stop_on_unknown_option?(mock :name => "foo")).to be_true
-        expect(klass.stop_on_unknown_option?(mock :name => "bar")).to be_true
-        expect(klass.stop_on_unknown_option?(mock :name => "baz")).to be_false
+        expect(klass.stop_on_unknown_option?(double(:name => "foo"))).to be true
+        expect(klass.stop_on_unknown_option?(double(:name => "bar"))).to be true
+        expect(klass.stop_on_unknown_option?(double(:name => "baz"))).to be false
       end
     end
 
@@ -148,21 +148,25 @@ describe Thor do
         stop_on_unknown_option! :bar
       end
       it "affects all specified commands" do
-        expect(klass.stop_on_unknown_option?(mock :name => "foo")).to be_true
-        expect(klass.stop_on_unknown_option?(mock :name => "bar")).to be_true
-        expect(klass.stop_on_unknown_option?(mock :name => "baz")).to be_false
+        expect(klass.stop_on_unknown_option?(double(:name => "foo"))).to be true
+        expect(klass.stop_on_unknown_option?(double(:name => "bar"))).to be true
+        expect(klass.stop_on_unknown_option?(double(:name => "baz"))).to be false
       end
     end
+
+    it "doesn't break new" do
+      expect(my_script.new).to be_a(Thor)
+    end
   end
 
   describe "#map" do
     it "calls the alias of a method if one is provided" do
-      expect(MyScript.start(["-T", "fish"])).to eq(["fish"])
+      expect(MyScript.start(%w[-T fish])).to eq(%w[fish])
     end
 
-    it "calls the alias of a method if several are provided via .map" do
-      expect(MyScript.start(["-f", "fish"])).to eq(["fish", {}])
-      expect(MyScript.start(["--foo", "fish"])).to eq(["fish", {}])
+    it "calls the alias of a method if several are provided via #map" do
+      expect(MyScript.start(%w[-f fish])).to eq(["fish", {}])
+      expect(MyScript.start(%w[--foo fish])).to eq(["fish", {}])
     end
 
     it "inherits all mappings from parent" do
@@ -172,27 +176,27 @@ describe Thor do
 
   describe "#package_name" do
     it "provides a proper description for a command when the package_name is assigned" do
-      content = capture(:stdout) { PackageNameScript.start(["help"]) }
+      content = capture(:stdout) { PackageNameScript.start(%w[help]) }
       expect(content).to match(/Baboon commands:/m)
     end
 
     # TODO: remove this, might be redundant, just wanted to prove full coverage
     it "provides a proper description for a command when the package_name is NOT assigned" do
-      content = capture(:stdout) { MyScript.start(["help"]) }
+      content = capture(:stdout) { MyScript.start(%w[help]) }
       expect(content).to match(/Commands:/m)
     end
   end
 
   describe "#desc" do
     it "provides description for a command" do
-      content = capture(:stdout) { MyScript.start(["help"]) }
+      content = capture(:stdout) { MyScript.start(%w[help]) }
       expect(content).to match(/thor my_script:zoo\s+# zoo around/m)
     end
 
     it "provides no namespace if $thor_runner is false" do
       begin
         $thor_runner = false
-        content = capture(:stdout) { MyScript.start(["help"]) }
+        content = capture(:stdout) { MyScript.start(%w[help]) }
         expect(content).to match(/thor zoo\s+# zoo around/m)
       ensure
         $thor_runner = true
@@ -201,17 +205,17 @@ describe Thor do
 
     describe "when :for is supplied" do
       it "overwrites a previous defined command" do
-        expect(capture(:stdout) { MyChildScript.start(["help"]) }).to match(/animal KIND \s+# fish around/m)
+        expect(capture(:stdout) { MyChildScript.start(%w[help]) }).to match(/animal KIND \s+# fish around/m)
       end
     end
 
     describe "when :hide is supplied" do
       it "does not show the command in help" do
-        expect(capture(:stdout) { MyScript.start(["help"]) }).not_to match(/this is hidden/m)
+        expect(capture(:stdout) { MyScript.start(%w[help]) }).not_to match(/this is hidden/m)
       end
 
-      it "but the command is still invokcable not show the command in help" do
-        expect(MyScript.start(["hidden", "yesyes"])).to eq(["yesyes"])
+      it "but the command is still invokable, does not show the command in help" do
+        expect(MyScript.start(%w[hidden yesyes])).to eq(%w[yesyes])
       end
     end
   end
@@ -224,30 +228,30 @@ describe Thor do
     end
 
     it "overwrites default options if called on the method scope" do
-      args = ["zoo", "--force", "--param", "feathers"]
+      args = %w[zoo --force --param feathers]
       options = MyChildScript.start(args)
-      expect(options).to eq({ "force" => true, "param" => "feathers" })
+      expect(options).to eq("force" => true, "param" => "feathers")
     end
 
     it "allows default options to be merged with method options" do
-      args = ["animal", "bird", "--force", "--param", "1.0", "--other", "tweets"]
+      args = %w[animal bird --force --param 1.0 --other tweets]
       arg, options = MyChildScript.start(args)
-      expect(arg).to eq('bird')
-      expect(options).to eq({ "force"=>true, "param"=>1.0, "other"=>"tweets" })
+      expect(arg).to eq("bird")
+      expect(options).to eq("force" => true, "param" => 1.0, "other" => "tweets")
     end
   end
 
   describe "#start" do
     it "calls a no-param method when no params are passed" do
-      expect(MyScript.start(["zoo"])).to eq(true)
+      expect(MyScript.start(%w[zoo])).to eq(true)
     end
 
     it "calls a single-param method when a single param is passed" do
-      expect(MyScript.start(["animal", "fish"])).to eq(["fish"])
+      expect(MyScript.start(%w[animal fish])).to eq(%w[fish])
     end
 
     it "does not set options in attributes" do
-      expect(MyScript.start(["with_optional", "--all"])).to eq([nil, { "all" => true }, []])
+      expect(MyScript.start(%w[with_optional --all])).to eq([nil, {"all" => true}, []])
     end
 
     it "raises an error if the wrong number of params are provided" do
@@ -255,56 +259,66 @@ describe Thor do
         stderr = capture(:stderr) { Scripts::Arities.start(args) }
         expect(stderr.strip).to eq(msg)
       end
-      arity_asserter.call ["zero_args",    "one"         ], %Q'ERROR: thor zero_args was called with arguments ["one"]\nUsage: "thor scripts:arities:zero_args".'
-      arity_asserter.call ["one_arg"                     ], %Q'ERROR: thor one_arg was called with no arguments\nUsage: "thor scripts:arities:one_arg ARG".'
-      arity_asserter.call ["one_arg",      "one", "two"  ], %Q'ERROR: thor one_arg was called with arguments ["one", "two"]\nUsage: "thor scripts:arities:one_arg ARG".'
-      arity_asserter.call ["one_arg",      "one", "two"  ], %Q'ERROR: thor one_arg was called with arguments ["one", "two"]\nUsage: "thor scripts:arities:one_arg ARG".'
-      arity_asserter.call ["two_args",     "one"         ], %Q'ERROR: thor two_args was called with arguments ["one"]\nUsage: "thor scripts:arities:two_args ARG1 ARG2".'
-      arity_asserter.call ["optional_arg", "one", "two"  ], %Q'ERROR: thor optional_arg was called with arguments ["one", "two"]\nUsage: "thor scripts:arities:optional_arg [ARG]".'
+      arity_asserter.call %w[zero_args one], %Q(ERROR: "thor zero_args" was called with arguments ["one"]
+Usage: "thor scripts:arities:zero_args")
+      arity_asserter.call %w[one_arg], %Q(ERROR: "thor one_arg" was called with no arguments
+Usage: "thor scripts:arities:one_arg ARG")
+      arity_asserter.call %w[one_arg one two], %Q(ERROR: "thor one_arg" was called with arguments ["one", "two"]
+Usage: "thor scripts:arities:one_arg ARG")
+      arity_asserter.call %w[one_arg one two], %Q(ERROR: "thor one_arg" was called with arguments ["one", "two"]
+Usage: "thor scripts:arities:one_arg ARG")
+      arity_asserter.call %w[two_args one], %Q(ERROR: "thor two_args" was called with arguments ["one"]
+Usage: "thor scripts:arities:two_args ARG1 ARG2")
+      arity_asserter.call %w[optional_arg one two], %Q(ERROR: "thor optional_arg" was called with arguments ["one", "two"]
+Usage: "thor scripts:arities:optional_arg [ARG]")
     end
 
     it "raises an error if the invoked command does not exist" do
-      expect(capture(:stderr) { Amazing.start(["animal"]) }.strip).to eq('Could not find command "animal" in "amazing" namespace.')
+      expect(capture(:stderr) { Amazing.start(%w[animal]) }.strip).to eq('Could not find command "animal" in "amazing" namespace.')
     end
 
     it "calls method_missing if an unknown method is passed in" do
-      expect(MyScript.start(["unk", "hello"])).to eq([:unk, ["hello"]])
+      expect(MyScript.start(%w[unk hello])).to eq([:unk, %w[hello]])
     end
 
     it "does not call a private method no matter what" do
-      expect(capture(:stderr) { MyScript.start(["what"]) }.strip).to eq('Could not find command "what" in "my_script" namespace.')
+      expect(capture(:stderr) { MyScript.start(%w[what]) }.strip).to eq('Could not find command "what" in "my_script" namespace.')
     end
 
     it "uses command default options" do
-      options = MyChildScript.start(["animal", "fish"]).last
-      expect(options).to eq({ "other" => "method default" })
+      options = MyChildScript.start(%w[animal fish]).last
+      expect(options).to eq("other" => "method default")
     end
 
     it "raises when an exception happens within the command call" do
-      expect{ MyScript.start(["call_myself_with_wrong_arity"]) }.to raise_error(ArgumentError)
+      expect { MyScript.start(%w[call_myself_with_wrong_arity]) }.to raise_error(ArgumentError)
     end
 
     context "when the user enters an unambiguous substring of a command" do
       it "invokes a command" do
-        expect(MyScript.start(["z"])).to eq(MyScript.start(["zoo"]))
+        expect(MyScript.start(%w[z])).to eq(MyScript.start(%w[zoo]))
       end
 
       it "invokes a command, even when there's an alias it resolves to the same command" do
-        expect(MyScript.start(["hi", "arg"])).to eq(MyScript.start(["hidden", "arg"]))
+        expect(MyScript.start(%w[hi arg])).to eq(MyScript.start(%w[hidden arg]))
       end
 
       it "invokes an alias" do
-        expect(MyScript.start(["animal_pri"])).to eq(MyScript.start(["zoo"]))
+        expect(MyScript.start(%w[animal_pri])).to eq(MyScript.start(%w[zoo]))
       end
     end
 
     context "when the user enters an ambiguous substring of a command" do
-      it "raises an exception that explains the ambiguity" do
-        expect{ MyScript.start(["call"]) }.to raise_error(ArgumentError, 'Ambiguous command call matches [call_myself_with_wrong_arity, call_unexistent_method]')
+      it "raises an exception and displays a message that explains the ambiguity" do
+        shell = Thor::Base.shell.new
+        expect(shell).to receive(:error).with("Ambiguous command call matches [call_myself_with_wrong_arity, call_unexistent_method]")
+        MyScript.start(%w[call], :shell => shell)
       end
 
       it "raises an exception when there is an alias" do
-        expect{ MyScript.start(["f"]) }.to raise_error(ArgumentError, 'Ambiguous command f matches [foo, fu]')
+        shell = Thor::Base.shell.new
+        expect(shell).to receive(:error).with("Ambiguous command f matches [foo, fu]")
+        MyScript.start(%w[f], :shell => shell)
       end
     end
 
@@ -329,7 +343,7 @@ describe Thor do
       end
 
       it "uses the maximum terminal size to show commands" do
-        @shell.should_receive(:terminal_width).and_return(80)
+        expect(@shell).to receive(:terminal_width).and_return(80)
         content = capture(:stdout) { MyScript.help(shell) }
         expect(content).to match(/aaa\.\.\.$/)
       end
@@ -371,9 +385,9 @@ END
       end
 
       it "raises an error if the command can't be found" do
-        expect {
+        expect do
           MyScript.command_help(shell, "unknown")
-        }.to raise_error(Thor::UndefinedCommandError, 'Could not find command "unknown" in "my_script" namespace.')
+        end.to raise_error(Thor::UndefinedCommandError, 'Could not find command "unknown" in "my_script" namespace.')
       end
 
       it "normalizes names before claiming they don't exist" do
@@ -393,36 +407,36 @@ HELP
       end
 
       it "doesn't assign the long description to the next command without one" do
-        expect(capture(:stdout) {
+        expect(capture(:stdout) do
           MyScript.command_help(shell, "name_with_dashes")
-        }).not_to match(/so very long/i)
+        end).not_to match(/so very long/i)
       end
     end
 
     describe "instance method" do
       it "calls the class method" do
-        expect(capture(:stdout) { MyScript.start(["help"]) }).to match(/Commands:/)
+        expect(capture(:stdout) { MyScript.start(%w[help]) }).to match(/Commands:/)
       end
 
       it "calls the class method" do
-        expect(capture(:stdout) { MyScript.start(["help", "foo"]) }).to match(/Usage:/)
+        expect(capture(:stdout) { MyScript.start(%w[help foo]) }).to match(/Usage:/)
       end
     end
   end
 
   describe "when creating commands" do
     it "prints a warning if a public method is created without description or usage" do
-      expect(capture(:stdout) {
+      expect(capture(:stdout) do
         klass = Class.new(Thor)
         klass.class_eval "def hello_from_thor; end"
-      }).to match(/\[WARNING\] Attempted to create command "hello_from_thor" without usage or description/)
+      end).to match(/\[WARNING\] Attempted to create command "hello_from_thor" without usage or description/)
     end
 
     it "does not print if overwriting a previous command" do
-      expect(capture(:stdout) {
+      expect(capture(:stdout) do
         klass = Class.new(Thor)
         klass.class_eval "def help; end"
-      }).to be_empty
+      end).to be_empty
     end
   end
 
@@ -437,9 +451,9 @@ HELP
         end
       end
 
-      expect(klass.start(["hi", "jose"])).to eq("Hi jose")
-      expect(klass.start(["hi", "jose", "--loud"])).to eq("Hi JOSE")
-      expect(klass.start(["hi", "--loud", "jose"])).to eq("Hi JOSE")
+      expect(klass.start(%w[hi jose])).to eq("Hi jose")
+      expect(klass.start(%w[hi jose --loud])).to eq("Hi JOSE")
+      expect(klass.start(%w[hi --loud jose])).to eq("Hi JOSE")
     end
 
     it "passes through unknown options" do
@@ -450,8 +464,8 @@ HELP
         end
       end
 
-      expect(klass.start(["unknown", "foo", "--bar", "baz", "bat", "--bam"])).to eq(["foo", "--bar", "baz", "bat", "--bam"])
-      expect(klass.start(["unknown", "--bar", "baz"])).to eq(["--bar", "baz"])
+      expect(klass.start(%w[unknown foo --bar baz bat --bam])).to eq(%w[foo --bar baz bat --bam])
+      expect(klass.start(%w[unknown --bar baz])).to eq(%w[--bar baz])
     end
 
     it "does not pass through unknown options with strict args" do
@@ -464,8 +478,8 @@ HELP
         end
       end
 
-      expect(klass.start(["unknown", "--bar", "baz"])).to eq([])
-      expect(klass.start(["unknown", "foo", "--bar", "baz"])).to eq(["foo"])
+      expect(klass.start(%w[unknown --bar baz])).to eq([])
+      expect(klass.start(%w[unknown foo --bar baz])).to eq(%w[foo])
     end
 
     it "strict args works in the inheritance chain" do
@@ -480,12 +494,12 @@ HELP
         end
       end
 
-      expect(klass.start(["unknown", "--bar", "baz"])).to eq([])
-      expect(klass.start(["unknown", "foo", "--bar", "baz"])).to eq(["foo"])
+      expect(klass.start(%w[unknown --bar baz])).to eq([])
+      expect(klass.start(%w[unknown foo --bar baz])).to eq(%w[foo])
     end
 
     it "send as a command name" do
-      expect(MyScript.start(["send"])).to eq(true)
+      expect(MyScript.start(%w[send])).to eq(true)
     end
   end
 end