commander 4.2.1 → 4.3.0

data/lib/commander/version.rb

@@ -1,3 +1,3 @@
 module Commander
-  VERSION = '4.2.1'
+  VERSION = '4.3.0'
 end

data/spec/command_spec.rb

@@ -2,157 +2,156 @@ require 'spec_helper'
 
 describe Commander::Command do
   include Commander::Methods
-  
+
   before :each do
     mock_terminal
     create_test_command
   end
-  
+
   describe 'Options' do
     before :each do
-      @options = Commander::Command::Options.new  
+      @options = Commander::Command::Options.new
     end
-    
-    it "should act like an open struct" do
+
+    it 'should act like an open struct' do
       @options.send = 'mail'
       @options.call = true
       expect(@options.send).to eq('mail')
       expect(@options.call).to eq(true)
     end
-    
-    it "should allow __send__ to function as always" do
+
+    it 'should allow __send__ to function as always' do
       @options.send = 'foo'
       expect(@options.__send__(:send)).to eq('foo')
     end
   end
-  
-  describe "#option" do
-    it "should add options" do
+
+  describe '#option' do
+    it 'should add options' do
       expect { @command.option '--recursive' }.to change(@command.options, :length).from(1).to(2)
     end
-    
-    it "should allow procs as option handlers" do
-      @command.option('--recursive') { |recursive| expect(recursive).to be_true }
+
+    it 'should allow procs as option handlers' do
+      @command.option('--recursive') { |recursive| expect(recursive).to be true }
       @command.run '--recursive'
     end
-    
-    it "should allow usage of common method names" do
+
+    it 'should allow usage of common method names' do
       @command.option '--open file'
-      @command.when_called { |_, options| expect(options.open).to eq('foo') }  
+      @command.when_called { |_, options| expect(options.open).to eq('foo') }
       @command.run '--open', 'foo'
     end
   end
-  
-  describe "#run" do
-    describe "should invoke #when_called" do
-      it "with arguments seperated from options" do
-        @command.when_called { |args, options| expect(args.join(' ')).to eq('just some args') }  
+
+  describe '#run' do
+    describe 'should invoke #when_called' do
+      it 'with arguments seperated from options' do
+        @command.when_called { |args, _options| expect(args.join(' ')).to eq('just some args') }
         @command.run '--verbose', 'just', 'some', 'args'
       end
-      
-      it "calling the #call method by default when an object is called" do
+
+      it 'calling the #call method by default when an object is called' do
         object = double 'Object'
         expect(object).to receive(:call).once
         @command.when_called object
-        @command.run 'foo'        
+        @command.run 'foo'
       end
-      
-      it "should allow #action as an alias to #when_called" do
+
+      it 'should allow #action as an alias to #when_called' do
         object = double 'Object'
         expect(object).to receive(:call).once
         @command.action object
         @command.run 'foo'
       end
-            
-      it "calling an arbitrary method when an object is called" do
+
+      it 'calling an arbitrary method when an object is called' do
         object = double 'Object'
         expect(object).to receive(:foo).once
         @command.when_called object, :foo
-        @command.run 'foo'        
+        @command.run 'foo'
       end
-      
-      it "should raise an error when no handler is present" do
+
+      it 'should raise an error when no handler is present' do
         expect { @command.when_called }.to raise_error(ArgumentError)
       end
     end
-    
-    describe "should populate options with" do
-      it "boolean values" do
+
+    describe 'should populate options with' do
+      it 'boolean values' do
         @command.option '--[no-]toggle'
-        @command.when_called { |_, options| expect(options.toggle).to be_true }  
+        @command.when_called { |_, options| expect(options.toggle).to be true }
         @command.run '--toggle'
-        @command.when_called { |_, options| expect(options.toggle).to be_false }  
+        @command.when_called { |_, options| expect(options.toggle).to be false }
         @command.run '--no-toggle'
       end
 
-      it "mandatory arguments" do
+      it 'mandatory arguments' do
         @command.option '--file FILE'
-        @command.when_called { |_, options| expect(options.file).to eq('foo') }  
+        @command.when_called { |_, options| expect(options.file).to eq('foo') }
         @command.run '--file', 'foo'
         expect { @command.run '--file' }.to raise_error(OptionParser::MissingArgument)
       end
 
-      describe "optional arguments" do
+      describe 'optional arguments' do
         before do
           @command.option '--use-config [file] '
         end
 
-        it "should return the argument when provided" do
+        it 'should return the argument when provided' do
           @command.when_called { |_, options| expect(options.use_config).to eq('foo') }
           @command.run '--use-config', 'foo'
         end
 
-        it "should return true when present without an argument" do
-          @command.when_called { |_, options| expect(options.use_config).to be_true }
+        it 'should return true when present without an argument' do
+          @command.when_called { |_, options| expect(options.use_config).to be true }
           @command.run '--use-config'
         end
 
-        it "should return nil when not present" do
+        it 'should return nil when not present' do
           @command.when_called { |_, options| expect(options.use_config).to be_nil }
           @command.run
         end
       end
 
-      describe "typed arguments" do
+      describe 'typed arguments' do
         before do
           @command.option '--interval N', Integer
         end
 
-        it "should parse valid values" do
+        it 'should parse valid values' do
           @command.when_called { |_, options| expect(options.interval).to eq(5) }
           @command.run '--interval', '5'
         end
 
-        it "should reject invalid values" do
+        it 'should reject invalid values' do
           expect { @command.run '--interval', 'invalid' }.to raise_error(OptionParser::InvalidArgument)
         end
       end
 
-      it "lists" do
+      it 'lists' do
         @command.option '--fav COLORS', Array
-        @command.when_called { |_, options| expect(options.fav).to eq(['red', 'green', 'blue']) }  
+        @command.when_called { |_, options| expect(options.fav).to eq(%w(red green blue)) }
         @command.run '--fav', 'red,green,blue'
       end
-      
-      it "lists with multi-word items" do
+
+      it 'lists with multi-word items' do
         @command.option '--fav MOVIES', Array
-        @command.when_called { |_, options| expect(options.fav).to eq(['super\ bad', 'nightmare']) }  
-        @command.run '--fav', 'super\ bad,nightmare'        
+        @command.when_called { |_, options| expect(options.fav).to eq(['super\ bad', 'nightmare']) }
+        @command.run '--fav', 'super\ bad,nightmare'
       end
-      
-      it "defaults" do
+
+      it 'defaults' do
         @command.option '--files LIST', Array
         @command.option '--interval N', Integer
         @command.when_called do |_, options|
           options.default \
-            :files => ['foo', 'bar'],
-            :interval => 5
-          expect(options.files).to eq(['foo', 'bar'])
+            files: %w(foo bar),
+            interval: 5
+          expect(options.files).to eq(%w(foo bar))
           expect(options.interval).to eq(15)
         end
         @command.run '--interval', '15'
       end
     end
   end
-  
 end

data/spec/configure_spec.rb

@@ -13,17 +13,17 @@ describe Commander do
       end
 
       it 'provides Commander configuration methods' do
-        Commander.configure {
+        Commander.configure do
           program :name, 'test'
-        }
+        end
 
         expect(Commander::Runner.instance.program(:name)).to eq('test')
       end
 
       it 'passes all arguments to the block' do
-        Commander.configure('foo') { |first_arg|
+        Commander.configure('foo') do |first_arg|
           program :name, first_arg
-        }
+        end
 
         expect(Commander::Runner.instance.program(:name)).to eq('foo')
       end

data/spec/core_ext/array_spec.rb

@@ -1,20 +1,18 @@
 require 'spec_helper'
 
 describe Array do
-
-  describe "#parse" do
-    it "should seperate a list of words into an array" do
-      expect(Array.parse('just a test')).to eq(['just', 'a', 'test'])
+  describe '#parse' do
+    it 'should seperate a list of words into an array' do
+      expect(Array.parse('just a test')).to eq(%w(just a test))
     end
 
-    it "should preserve escaped whitespace" do
+    it 'should preserve escaped whitespace' do
       expect(Array.parse('just a\ test')).to eq(['just', 'a test'])
     end
 
-    it "should match %w behavior with multiple backslashes" do
+    it 'should match %w behavior with multiple backslashes' do
       str = 'just a\\ test'
       expect(Array.parse(str)).to eq(eval("%w(#{str})"))
     end
   end
-
 end

data/spec/core_ext/object_spec.rb

@@ -1,21 +1,19 @@
 require 'spec_helper'
 
 describe Object do
-  
-  describe "#get_binding" do
-    it "should return the objects binding" do
+  describe '#get_binding' do
+    it 'should return the objects binding' do
       expect(lambda {}.get_binding).to be_instance_of(Binding)
     end
   end
 
-  describe "#method_missing" do
-    it "should preserve its original behavior for missing methods" do
-      expect { i_am_a_missing_method() }.to raise_error(NoMethodError)
+  describe '#method_missing' do
+    it 'should preserve its original behavior for missing methods' do
+      expect { send(:i_am_a_missing_method) }.to raise_error(NoMethodError)
     end
 
-    it "should preserve its original behavior for missing variables" do
+    it 'should preserve its original behavior for missing variables' do
       expect { i_am_a_missing_variable }.to raise_error(NameError)
     end
   end
-
 end

data/spec/help_formatters/terminal_spec.rb

@@ -2,12 +2,12 @@ require 'spec_helper'
 
 describe Commander::HelpFormatter::Terminal do
   include Commander::Methods
-  
+
   before :each do
     mock_terminal
   end
-  
-  describe "global help" do
+
+  describe 'global help' do
     before :each do
       new_command_runner 'help' do
         command :'install gem' do |c|
@@ -17,19 +17,19 @@ describe Commander::HelpFormatter::Terminal do
       end.run!
       @global_help = @output.string
     end
-    
-    describe "should display" do
-      it "the command name" do
+
+    describe 'should display' do
+      it 'the command name' do
         expect(@global_help).to include('install gem')
       end
-      
-      it "the summary" do
+
+      it 'the summary' do
         expect(@global_help).to include('Install some gem')
       end
     end
   end
-  
-  describe "command help" do
+
+  describe 'command help' do
     before :each do
       new_command_runner 'help', 'install', 'gem' do
         command :'install gem' do |c|
@@ -42,27 +42,26 @@ describe Commander::HelpFormatter::Terminal do
       end.run!
       @command_help = @output.string
     end
-    
-    describe "should display" do
-      it "the command name" do
+
+    describe 'should display' do
+      it 'the command name' do
         expect(@command_help).to include('install gem')
       end
-      
-      it "the description" do
+
+      it 'the description' do
         expect(@command_help).to include('Install some gem, blah blah blah')
       end
-      
-      it "all examples" do
+
+      it 'all examples' do
         expect(@command_help).to include('# one')
         expect(@command_help).to include('two')
         expect(@command_help).to include('# three')
         expect(@command_help).to include('four')
       end
-      
-      it "the syntax" do
+
+      it 'the syntax' do
         expect(@command_help).to include('foo install gem [options]')
       end
     end
   end
-  
 end

data/spec/runner_spec.rb

@@ -8,111 +8,111 @@ describe Commander do
     mock_terminal
     create_test_command
   end
-  
-  describe "#program" do
-    it "should set / get program information" do
+
+  describe '#program' do
+    it 'should set / get program information' do
       program :name, 'test'
       expect(program(:name)).to eq('test')
     end
-    
-    it "should allow arbitrary blocks of global help documentation" do
+
+    it 'should allow arbitrary blocks of global help documentation' do
       program :help, 'Copyright', 'TJ Holowaychuk'
       expect(program(:help)['Copyright']).to eq('TJ Holowaychuk')
     end
-    
-    it "should raise an error when required info has not been set" do
+
+    it 'should raise an error when required info has not been set' do
       new_command_runner '--help'
       program :version, ''
       expect { run! }.to raise_error(Commander::Runner::CommandError)
     end
-    
-    it "should allow aliases of help formatters" do
+
+    it 'should allow aliases of help formatters' do
       program :help_formatter, :compact
       expect(program(:help_formatter)).to eq(Commander::HelpFormatter::TerminalCompact)
     end
   end
-  
-  describe "#command" do
-    it "should return a command instance when only the name is passed" do
+
+  describe '#command' do
+    it 'should return a command instance when only the name is passed' do
       expect(command(:test)).to be_instance_of(Commander::Command)
     end
-    
-    it "should return nil when the command does not exist" do
+
+    it 'should return nil when the command does not exist' do
       expect(command(:im_not_real)).to be_nil
     end
   end
-  
-  describe "#separate_switches_from_description" do
-    it "should seperate switches and description returning both" do
+
+  describe '#separate_switches_from_description' do
+    it 'should seperate switches and description returning both' do
       switches, description = *Commander::Runner.separate_switches_from_description('-h', '--help', 'display help')
       expect(switches).to eq(['-h', '--help'])
       expect(description).to eq('display help')
     end
   end
-  
-  describe "#switch_to_sym" do
-    it "should return a symbol based on the switch name" do
-     expect(Commander::Runner.switch_to_sym('--trace')).to eq(:trace)
-     expect(Commander::Runner.switch_to_sym('--foo-bar')).to eq(:foo_bar)
-     expect(Commander::Runner.switch_to_sym('--[no-]feature"')).to eq(:feature)
-     expect(Commander::Runner.switch_to_sym('--[no-]feature ARG')).to eq(:feature)
-     expect(Commander::Runner.switch_to_sym('--file [ARG]')).to eq(:file)
-     expect(Commander::Runner.switch_to_sym('--colors colors')).to eq(:colors)
+
+  describe '#switch_to_sym' do
+    it 'should return a symbol based on the switch name' do
+      expect(Commander::Runner.switch_to_sym('--trace')).to eq(:trace)
+      expect(Commander::Runner.switch_to_sym('--foo-bar')).to eq(:foo_bar)
+      expect(Commander::Runner.switch_to_sym('--[no-]feature"')).to eq(:feature)
+      expect(Commander::Runner.switch_to_sym('--[no-]feature ARG')).to eq(:feature)
+      expect(Commander::Runner.switch_to_sym('--file [ARG]')).to eq(:file)
+      expect(Commander::Runner.switch_to_sym('--colors colors')).to eq(:colors)
     end
   end
-  
-  describe "#alias_command" do
-    it "should alias a command" do
+
+  describe '#alias_command' do
+    it 'should alias a command' do
       alias_command :foo, :test
       expect(command(:foo)).to eq(command(:test))
     end
-    
-    it "should pass arguments passed to the alias when called" do
+
+    it 'should pass arguments passed to the alias when called' do
       gem_name = ''
       new_command_runner 'install', 'gem', 'commander' do
         command :install do |c|
           c.option '--gem-name NAME', 'Install a gem'
           c.when_called { |_, options| gem_name = options.gem_name }
-        end 
+        end
         alias_command :'install gem', :install, '--gem-name'
       end.run!
       expect(gem_name).to eq('commander')
     end
   end
-  
-  describe "#global_option" do
-    it "should be invoked when used in the args list" do
+
+  describe '#global_option' do
+    it 'should be invoked when used in the args list' do
       file = ''
       new_command_runner 'test', '--config', 'foo' do
         global_option('--config FILE') { |f| file = f }
       end.run!
       expect(file).to eq('foo')
     end
-    
-    it "should be inherited by commands" do
+
+    it 'should be inherited by commands' do
       quiet = nil
       new_command_runner 'foo', '--quiet' do
         global_option('--quiet', 'Suppress output')
         command :foo do |c|
-          c.when_called { |_, options| quiet = options.quiet } 
+          c.when_called { |_, options| quiet = options.quiet }
         end
       end.run!
-      expect(quiet).to be_true
+      expect(quiet).to be true
     end
-    
-    it "should be inherited by commands even when a block is present" do
+
+    it 'should be inherited by commands even when a block is present' do
       quiet = nil
       new_command_runner 'foo', '--quiet' do
         global_option('--quiet', 'Suppress output') {}
         command :foo do |c|
-          c.when_called { |_, options| quiet = options.quiet } 
+          c.when_called { |_, options| quiet = options.quiet }
         end
       end.run!
-      expect(quiet).to be_true      
+      expect(quiet).to be true
     end
   end
 
-  describe "#parse_global_options" do
+  describe '#parse_global_options' do
     it 'should parse global options before command' do
       global_option = nil
       new_command_runner('--testing-global', 'foo') do
@@ -127,7 +127,7 @@ describe Commander do
 
     it 'should parse global options after command' do
       global_option = nil
-      new_command_runner('foo','--testing-global') do
+      new_command_runner('foo', '--testing-global') do
         global_option('--testing-global') { global_option = 'MAGIC' }
 
         command :foo do |c|
@@ -218,14 +218,14 @@ describe Commander do
         global_option('--testing-global VALUE') { |v| global_option = v }
 
         command :foo do |c|
-          c.option('--testing-command') { }
+          c.option('--testing-command') {}
           c.when_called {}
         end
       end.run!
 
       expect(global_option).to eq('bar')
     end
-    
+
     it 'should allow global arguments with values before command arguments (github issue #8)' do
       global_option = nil
       command_option = nil
@@ -243,13 +243,12 @@ describe Commander do
     end
   end
 
-  
-  describe "#remove_global_options" do
-    it "should remove only specified switches" do
+  describe '#remove_global_options' do
+    it 'should remove only specified switches' do
       options, args = [], []
-      options << { :switches => ['-t', '--trace'] }
-      options << { :switches => ['--help'] }
-      options << { :switches => ['--paths PATHS'] }
+      options << { switches: ['-t', '--trace'] }
+      options << { switches: ['--help'] }
+      options << { switches: ['--paths PATHS'] }
       args << '-t'
       args << '--help'
       args << '--command'
@@ -259,65 +258,65 @@ describe Commander do
       expect(args).to eq(['--command', '--command-with-arg', 'rawr'])
     end
 
-    it "should not swallow an argument unless it expects an argument" do
+    it 'should not swallow an argument unless it expects an argument' do
       options, args = [], []
-      options << { :switches => ['-n', '--no-arg'] }
-      options << { :switches => ['-y', '--yes ARG'] }
-      options << { :switches => ['-a', '--alternative=ARG'] }
+      options << { switches: ['-n', '--no-arg'] }
+      options << { switches: ['-y', '--yes ARG'] }
+      options << { switches: ['-a', '--alternative=ARG'] }
       args << '-n' << 'alpha'
       args << '--yes' << 'deleted'
       args << '-a' << 'deleted'
       args << 'beta'
       command_runner.remove_global_options options, args
-      expect(args).to eq(['alpha', 'beta'])
+      expect(args).to eq(%w(alpha beta))
     end
   end
-  
-  describe "--trace" do
-    it "should display pretty errors by default" do
-      pending("JRuby's Kernel.abort implementation is not testable") if Commander::Platform::jruby?
-      expect {
+
+  describe '--trace' do
+    it 'should display pretty errors by default' do
+      pending("JRuby's Kernel.abort implementation is not testable") if Commander::Platform.jruby?
+      expect do
         new_command_runner 'foo' do
-          command(:foo) { |c| c.when_called { raise 'cookies!' } }
+          command(:foo) { |c| c.when_called { fail 'cookies!' } }
         end.run!
-      }.to raise_error(SystemExit, /error: cookies!. Use --trace/)
+      end.to raise_error(SystemExit, /error: cookies!. Use --trace/)
     end
 
-    it "should display callstack when using this switch" do
-      expect {
+    it 'should display callstack when using this switch' do
+      expect do
         new_command_runner 'foo', '--trace' do
-          command(:foo) { |c| c.when_called { raise 'cookies!' } }
-        end.run!  
-      }.to raise_error(RuntimeError)
+          command(:foo) { |c| c.when_called { fail 'cookies!' } }
+        end.run!
+      end.to raise_error(RuntimeError)
     end
   end
 
-  describe "#always_trace!" do
-    it "should enable tracing globally, regardless of whether --trace was passed or not" do
-      expect {
+  describe '#always_trace!' do
+    it 'should enable tracing globally, regardless of whether --trace was passed or not' do
+      expect do
         new_command_runner 'foo' do
           always_trace!
-          command(:foo) { |c| c.when_called { raise 'cookies!' } }
+          command(:foo) { |c| c.when_called { fail 'cookies!' } }
         end.run!
-      }.to raise_error(RuntimeError)
+      end.to raise_error(RuntimeError)
     end
   end
 
-  describe "#never_trace!" do
-    it "should disable tracing globally, regardless of whether --trace was passed or not" do
-      expect {
+  describe '#never_trace!' do
+    it 'should disable tracing globally, regardless of whether --trace was passed or not' do
+      expect do
         new_command_runner 'help', '--trace' do
           never_trace!
         end.run!
-      }.to raise_error(SystemExit, /invalid option: --trace/)
+      end.to raise_error(SystemExit, /invalid option: --trace/)
     end
 
-    it "should not prompt to use --trace switch on errors" do
+    it 'should not prompt to use --trace switch on errors' do
       msg = nil
       begin
         new_command_runner 'foo' do
           never_trace!
-          command(:foo) { |c| c.when_called { raise 'cookies!' } }
+          command(:foo) { |c| c.when_called { fail 'cookies!' } }
         end.run!
       rescue SystemExit => e
         msg = e.message
@@ -327,171 +326,171 @@ describe Commander do
     end
   end
 
-  context "conflict between #always_trace! and #never_trace!" do
-    it "respects the last used command" do
-      expect {
+  context 'conflict between #always_trace! and #never_trace!' do
+    it 'respects the last used command' do
+      expect do
         new_command_runner 'foo' do
           never_trace!
           always_trace!
-          command(:foo) { |c| c.when_called { raise 'cookies!' } }
+          command(:foo) { |c| c.when_called { fail 'cookies!' } }
         end.run!
-      }.to raise_error(RuntimeError)
+      end.to raise_error(RuntimeError)
     end
   end
 
-  describe "--version" do
-    it "should output program version" do
+  describe '--version' do
+    it 'should output program version' do
       expect(run('--version')).to eq("test 1.2.3\n")
     end
   end
-  
-  describe "--help" do
-    it "should not output an invalid command message" do
+
+  describe '--help' do
+    it 'should not output an invalid command message' do
       expect(run('--help')).not_to eq("invalid command. Use --help for more information\n")
     end
-    
-    it "can be used before or after the command and options" do
+
+    it 'can be used before or after the command and options' do
       expect(run('test', '--help')).to eq("Implement help for test here\n")
     end
   end
-  
-  describe "with invalid options" do
-    it "should output an invalid option message" do
-      pending("JRuby's Kernel.abort implementation is not testable") if Commander::Platform::jruby?
-      expect {
-        run('test', '--invalid-option')  
-      }.to raise_error(SystemExit, /invalid option: --invalid-option/)
+
+  describe 'with invalid options' do
+    it 'should output an invalid option message' do
+      pending("JRuby's Kernel.abort implementation is not testable") if Commander::Platform.jruby?
+      expect do
+        run('test', '--invalid-option')
+      end.to raise_error(SystemExit, /invalid option: --invalid-option/)
     end
   end
-  
-  describe "with invalid command passed" do
-    it "should output an invalid command message" do
-      pending("JRuby's Kernel.abort implementation is not testable") if Commander::Platform::jruby?
-      expect {
-        run('foo')  
-      }.to raise_error(SystemExit, /invalid command. Use --help for more information/)
+
+  describe 'with invalid command passed' do
+    it 'should output an invalid command message' do
+      pending("JRuby's Kernel.abort implementation is not testable") if Commander::Platform.jruby?
+      expect do
+        run('foo')
+      end.to raise_error(SystemExit, /invalid command. Use --help for more information/)
     end
   end
-  
-  describe "with invalid command passed to help" do
-    it "should output an invalid command message" do
-      pending("JRuby's Kernel.abort implementation is not testable") if Commander::Platform::jruby?
-      expect {
+
+  describe 'with invalid command passed to help' do
+    it 'should output an invalid command message' do
+      pending("JRuby's Kernel.abort implementation is not testable") if Commander::Platform.jruby?
+      expect do
         run('help', 'does_not_exist')
-      }.to raise_error(SystemExit, /invalid command. Use --help for more information/)
+      end.to raise_error(SystemExit, /invalid command. Use --help for more information/)
     end
   end
-  
-  describe "with invalid command passed to --help" do
-    it "should output an invalid command message" do
-      pending("JRuby's Kernel.abort implementation is not testable") if Commander::Platform::jruby?
-      expect {
+
+  describe 'with invalid command passed to --help' do
+    it 'should output an invalid command message' do
+      pending("JRuby's Kernel.abort implementation is not testable") if Commander::Platform.jruby?
+      expect do
         run('--help', 'does_not_exist')
-      }.to raise_error(SystemExit, /invalid command. Use --help for more information/)
+      end.to raise_error(SystemExit, /invalid command. Use --help for more information/)
     end
   end
 
-  describe "with invalid option passed to --help" do
-    it "should output an invalid option message" do
-      pending("JRuby's Kernel.abort implementation is not testable") if Commander::Platform::jruby?
-      expect {
+  describe 'with invalid option passed to --help' do
+    it 'should output an invalid option message' do
+      pending("JRuby's Kernel.abort implementation is not testable") if Commander::Platform.jruby?
+      expect do
         run('--help', 'test', '--invalid-option')
-      }.to raise_error(SystemExit, /invalid option: --invalid-option/)
+      end.to raise_error(SystemExit, /invalid option: --invalid-option/)
     end
   end
-  
-  describe "#valid_command_names_from" do
-    it "should return array of valid command names" do
+
+  describe '#valid_command_names_from' do
+    it 'should return array of valid command names' do
       new_command_runner do
         command('foo bar') {}
         command('foo bar foo') {}
         expect(command_runner.valid_command_names_from('foo', 'bar', 'foo').sort).to eq(['foo bar', 'foo bar foo'])
       end
     end
-    
-    it "should return empty array when no possible command names exist" do
+
+    it 'should return empty array when no possible command names exist' do
       new_command_runner do
         expect(command_runner.valid_command_names_from('fake', 'command', 'name')).to eq([])
       end
     end
 
-    it "should match exact commands only" do
+    it 'should match exact commands only' do
       new_command_runner do
         command('foo') {}
         expect(command_runner.valid_command_names_from('foobar')).to eq([])
       end
     end
   end
-  
-  describe "#command_name_from_args" do
-    it "should locate command within arbitrary arguments passed" do
+
+  describe '#command_name_from_args' do
+    it 'should locate command within arbitrary arguments passed' do
       new_command_runner '--help', '--arbitrary', 'test'
       expect(command_runner.command_name_from_args).to eq('test')
     end
-    
-    it "should support multi-word commands" do
+
+    it 'should support multi-word commands' do
       new_command_runner '--help', '--arbitrary', 'some', 'long', 'command', 'foo'
       command('some long command') {}
       expect(command_runner.command_name_from_args).to eq('some long command')
     end
-    
-    it "should match the longest possible command" do
+
+    it 'should match the longest possible command' do
       new_command_runner '--help', '--arbitrary', 'foo', 'bar', 'foo'
       command('foo bar') {}
       command('foo bar foo') {}
-      expect(command_runner.command_name_from_args).to eq('foo bar foo'      )
+      expect(command_runner.command_name_from_args).to eq('foo bar foo')
     end
-    
-    it "should use the left-most command name when multiple are present" do
+
+    it 'should use the left-most command name when multiple are present' do
       new_command_runner 'help', 'test'
-      expect(command_runner.command_name_from_args).to eq('help'      )
+      expect(command_runner.command_name_from_args).to eq('help')
     end
   end
-  
-  describe "#active_command" do
-    it "should resolve the active command" do
+
+  describe '#active_command' do
+    it 'should resolve the active command' do
       new_command_runner '--help', 'test'
       expect(command_runner.active_command).to be_instance_of(Commander::Command)
     end
-    
-    it "should resolve active command when invalid options are passed" do
+
+    it 'should resolve active command when invalid options are passed' do
       new_command_runner '--help', 'test', '--arbitrary'
       expect(command_runner.active_command).to be_instance_of(Commander::Command)
     end
-    
-    it "should return nil when the command is not found" do
+
+    it 'should return nil when the command is not found' do
       new_command_runner 'foo'
       expect(command_runner.active_command).to be_nil
     end
   end
-  
-  describe "#default_command" do
-    it "should allow you to default any command when one is not explicitly passed" do
+
+  describe '#default_command' do
+    it 'should allow you to default any command when one is not explicitly passed' do
       new_command_runner '--trace' do
         default_command :test
         expect(command(:test)).to receive(:run).once
         expect(command_runner.active_command).to eq(command(:test))
       end.run!
     end
-    
-    it "should not prevent other commands from being called" do
+
+    it 'should not prevent other commands from being called' do
       new_command_runner 'foo', 'bar', '--trace' do
         default_command :test
-        command(:'foo bar'){}
+        command(:'foo bar') {}
         expect(command(:'foo bar')).to receive(:run).once
         expect(command_runner.active_command).to eq(command(:'foo bar'))
       end.run!
     end
-    
-    it "should not prevent longer commands to use the same words as the default" do
+
+    it 'should not prevent longer commands to use the same words as the default' do
       new_command_runner 'foo', 'bar', 'something'
       default_command :'foo bar'
-      command(:'foo bar'){}
-      command(:'foo bar something'){}
+      command(:'foo bar') {}
+      command(:'foo bar something') {}
       expect(command_runner.active_command).to eq(command(:'foo bar something'))
     end
-    
-    it "should allow defaulting of command aliases" do
+
+    it 'should allow defaulting of command aliases' do
       new_command_runner '--trace' do
         default_command :foobar
         alias_command :foobar, :test
@@ -499,36 +498,36 @@ describe Commander do
       end.run!
     end
   end
-  
-  describe "should function correctly" do
-    it "when options are passed before the command name" do
+
+  describe 'should function correctly' do
+    it 'when options are passed before the command name' do
       new_command_runner '--verbose', 'test', 'foo', 'bar' do
         @command.when_called do |args, options|
-          expect(args).to eq(['foo', 'bar'])
-          expect(options.verbose).to be_true
+          expect(args).to eq(%w(foo bar))
+          expect(options.verbose).to be true
         end
       end.run!
     end
 
-    it "when options are passed after the command name" do
+    it 'when options are passed after the command name' do
       new_command_runner 'test', '--verbose', 'foo', 'bar' do
         @command.when_called do |args, options|
-          expect(args).to eq(['foo', 'bar'])
-          expect(options.verbose).to be_true
+          expect(args).to eq(%w(foo bar))
+          expect(options.verbose).to be true
         end
       end.run!
     end
 
-    it "when an argument passed is the same name as the command" do
+    it 'when an argument passed is the same name as the command' do
       new_command_runner 'test', '--verbose', 'foo', 'test', 'bar' do
         @command.when_called do |args, options|
-          expect(args).to eq(['foo', 'test', 'bar'])
-          expect(options.verbose).to be_true
+          expect(args).to eq(%w(foo test bar))
+          expect(options.verbose).to be true
         end
       end.run!
     end
-    
-    it "when using multi-word commands" do
+
+    it 'when using multi-word commands' do
       new_command_runner '--verbose', 'my', 'command', 'something', 'foo', 'bar' do
         command('my command') { |c| c.option('--verbose') }
         expect(command_runner.command_name_from_args).to eq('my command')
@@ -536,15 +535,15 @@ describe Commander do
       end.run!
     end
 
-    it "when using multi-word commands with parts of the command name as arguments" do
+    it 'when using multi-word commands with parts of the command name as arguments' do
       new_command_runner '--verbose', 'my', 'command', 'something', 'my', 'command' do
         command('my command') { |c| c.option('--verbose') }
         expect(command_runner.command_name_from_args).to eq('my command')
         expect(command_runner.args_without_command_name).to eq(['--verbose', 'something', 'my', 'command'])
       end.run!
     end
-    
-    it "when using multi-word commands with other commands using the same words" do
+
+    it 'when using multi-word commands with other commands using the same words' do
       new_command_runner '--verbose', 'my', 'command', 'something', 'my', 'command' do
         command('my command') {}
         command('my command something') { |c| c.option('--verbose') }
@@ -554,8 +553,8 @@ describe Commander do
     end
   end
 
-  describe "options with optional arguments" do
-    it "should return the argument when it is specified" do
+  describe 'options with optional arguments' do
+    it 'should return the argument when it is specified' do
       new_command_runner 'foo', '--optional', 'arg1' do
         command('foo') do |c|
           c.option('--optional [argument]')
@@ -566,16 +565,15 @@ describe Commander do
       end.run!
     end
 
-    it "should return true when no argument is specified for the option" do
+    it 'should return true when no argument is specified for the option' do
       new_command_runner 'foo', '--optional' do
         command('foo') do |c|
           c.option('--optional [argument]')
           c.when_called do |_, options|
-            expect(options.optional).to be_true
+            expect(options.optional).to be true
           end
         end
       end.run!
     end
   end
-
 end