commander 4.1.6 → 4.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 89c316cbb98922c1aa25063c184fe3214dc33f03
-  data.tar.gz: 5222385e2c3e6f4d59b4b748315b429173d95435
+  metadata.gz: 21b09d008c6a8a753877a504afd266191e9d56f1
+  data.tar.gz: eb66a9f050995361aef5eb5abe80b957386547b1
 SHA512:
-  metadata.gz: 1d88c3df61b540cfa7e5bf58f83891393f331f0844a031619692a5429417471f3aacd1910fb7fdfb52bcaa8aa0ca469b050cd301b2323e3cd9220851d36bce2e
-  data.tar.gz: 5534ce249d8211b77c8c8112d9793e122137ec0513146bef96cf6ad1fcca4610f0bdf8a83856a1288bcca8e4f0818e537263df017263ba2709943ff0b290fd46
+  metadata.gz: f193eb63b1ac9b359c5087ee82db39058b11dfb479ecf562d419bdf7e0dc339ba4ffd47528054a7e6ba67891b43c3210b17d59a8b0eabb201ba4a5c7c81ac87b
+  data.tar.gz: 166c934efdbd6469f8f67d312b1d88758b6158e2116a3179e571f31531efbbf89f9f733eaadde33a972909bc641e1a1d6182c5553b735932678ce1d322330f1c

data/History.rdoc

@@ -1,3 +1,7 @@
+=== 4.2.0 / 2014-04-29
+
+* Add ability to use commander without importing into the global namespace (#61) (@krissi)
+
 === 4.1.6 / 2014-02-11
 
 * Respect environment setting for $LESS (@ellemenno)

data/README.md

@@ -1,4 +1,5 @@
 [<img src="https://secure.travis-ci.org/ggilder/commander.png?branch=master" alt="Build Status" />](http://travis-ci.org/ggilder/commander)
+[![Inline docs](http://inch-pages.github.io/github/visionmedia/commander.png)](http://inch-pages.github.io/github/visionmedia/commander)
 
 # Commander
 
@@ -42,6 +43,8 @@ For more option examples view the `Commander::Command#option` method. Also
 an important feature to note is that action may be a class to instantiate,
 as well as an object, specifying a method to call, so view the RDoc for more information.
 
+### Classic style
+
 ```ruby
 require 'rubygems'
 require 'commander/import'
@@ -80,6 +83,40 @@ $ foobar bar --suffix '}' --prefix '{'
 # => {bar}
 ```
 
+### Modular style
+```ruby
+require 'rubygems'
+require 'commander'
+
+class MyApplication
+  include Commander::Methods
+
+  def run
+    program :name, 'Foo Bar'
+    program :version, '1.0.0'
+    program :description, 'Stupid command that prints foo or bar.'
+
+    # see classic style example for options
+  end
+end
+
+MyApplication.new.run if $0 == __FILE__
+```
+
+### Block style
+```ruby
+require 'rubygems'
+require 'commander'
+
+Commander.configure do
+  program :name, 'Foo Bar'
+  program :version, '1.0.0'
+  program :description, 'Stupid command that prints foo or bar.'
+
+  # see classic style example for options
+end
+```
+
 ## HighLine
 
 As mentioned above, the highline gem is imported into the global scope. Here

data/commander.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |s|
 
   s.add_runtime_dependency("highline", "~> 1.6.11")
   
-  s.add_development_dependency("rspec", "~> 2")
+  s.add_development_dependency("rspec", "~> 2.14")
   s.add_development_dependency("rake")
   s.add_development_dependency("simplecov")
 end

data/lib/commander.rb

@@ -30,3 +30,5 @@ require 'commander/runner'
 require 'commander/command'
 require 'commander/help_formatters'
 require 'commander/platform'
+require 'commander/methods'
+require 'commander/configure'

data/lib/commander/configure.rb

@@ -0,0 +1,18 @@
+require 'commander'
+require 'commander/methods'
+
+module Commander
+  def configure(*configuration_opts, &configuration_block)
+    configuration_module = Module.new
+    configuration_module.extend Commander::Methods
+    
+    configuration_module.class_exec(*configuration_opts, &configuration_block)
+
+    configuration_module.class_exec do
+      run!
+    end
+  end
+
+  module_function :configure
+end
+

data/lib/commander/methods.rb

@@ -0,0 +1,11 @@
+require 'commander'
+require 'commander/delegates'
+
+module Commander::Methods
+  include Commander::UI
+  include Commander::UI::AskForClass
+  include Commander::Delegates
+
+  $terminal.wrap_at = HighLine::SystemExtensions.terminal_size.first - 5 rescue 80 if $stdin.tty?
+end
+

data/lib/commander/runner.rb

@@ -1,4 +1,3 @@
-
 require 'optparse'
 
 module Commander
@@ -286,11 +285,11 @@ module Commander
     def create_default_commands
       command :help do |c|
         c.syntax = 'commander help [command]'
-        c.description = 'Display global or [command] help documentation.'
+        c.description = 'Display global or [command] help documentation'
         c.example 'Display global help', 'command help'
         c.example "Display help for 'foo'", 'command help foo'
         c.when_called do |args, options|
-          enable_paging
+          UI.enable_paging
           if args.empty?
             say help_formatter.render 
           else

data/lib/commander/version.rb

@@ -1,3 +1,3 @@
 module Commander
-  VERSION = '4.1.6'
+  VERSION = '4.2.0'
 end

data/spec/command_spec.rb

@@ -1,6 +1,7 @@
 require 'spec_helper'
 
 describe Commander::Command do
+  include Commander::Methods
   
   before :each do
     mock_terminal
@@ -15,29 +16,29 @@ describe Commander::Command do
     it "should act like an open struct" do
       @options.send = 'mail'
       @options.call = true
-      @options.send.should eq('mail')
-      @options.call.should eq(true)
+      expect(@options.send).to eq('mail')
+      expect(@options.call).to eq(true)
     end
     
     it "should allow __send__ to function as always" do
       @options.send = 'foo'
-      @options.__send__(:send).should eq('foo')
+      expect(@options.__send__(:send)).to eq('foo')
     end
   end
   
   describe "#option" do
     it "should add options" do
-      lambda { @command.option '--recursive' }.should change(@command.options, :length).from(1).to(2)
+      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| recursive.should be_true }
+      @command.option('--recursive') { |recursive| expect(recursive).to be_true }
       @command.run '--recursive'
     end
     
     it "should allow usage of common method names" do
       @command.option '--open file'
-      @command.when_called { |_, options| options.open.should eq('foo') }  
+      @command.when_called { |_, options| expect(options.open).to eq('foo') }  
       @command.run '--open', 'foo'
     end
   end
@@ -45,50 +46,50 @@ describe Commander::Command do
   describe "#run" do
     describe "should invoke #when_called" do
       it "with arguments seperated from options" do
-        @command.when_called { |args, options| args.join(' ').should eq('just some args') }  
+        @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
         object = double 'Object'
-        object.should_receive(:call).once
+        expect(object).to receive(:call).once
         @command.when_called object
         @command.run 'foo'        
       end
       
       it "should allow #action as an alias to #when_called" do
         object = double 'Object'
-        object.should_receive(:call).once
+        expect(object).to receive(:call).once
         @command.action object
         @command.run 'foo'
       end
             
       it "calling an arbitrary method when an object is called" do
         object = double 'Object'
-        object.should_receive(:foo).once
+        expect(object).to receive(:foo).once
         @command.when_called object, :foo
         @command.run 'foo'        
       end
       
       it "should raise an error when no handler is present" do
-        lambda { @command.when_called }.should raise_error(ArgumentError)
+        expect { @command.when_called }.to raise_error(ArgumentError)
       end
     end
     
     describe "should populate options with" do
       it "boolean values" do
         @command.option '--[no-]toggle'
-        @command.when_called { |_, options| options.toggle.should be_true }  
+        @command.when_called { |_, options| expect(options.toggle).to be_true }  
         @command.run '--toggle'
-        @command.when_called { |_, options| options.toggle.should be_false }  
+        @command.when_called { |_, options| expect(options.toggle).to be_false }  
         @command.run '--no-toggle'
       end
 
       it "mandatory arguments" do
         @command.option '--file FILE'
-        @command.when_called { |_, options| options.file.should eq('foo') }  
+        @command.when_called { |_, options| expect(options.file).to eq('foo') }  
         @command.run '--file', 'foo'
-        lambda { @command.run '--file' }.should raise_error(OptionParser::MissingArgument)
+        expect { @command.run '--file' }.to raise_error(OptionParser::MissingArgument)
       end
 
       describe "optional arguments" do
@@ -97,17 +98,17 @@ describe Commander::Command do
         end
 
         it "should return the argument when provided" do
-          @command.when_called { |_, options| options.use_config.should eq('foo') }
+          @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| options.use_config.should be_true }
+          @command.when_called { |_, options| expect(options.use_config).to be_true }
           @command.run '--use-config'
         end
 
         it "should return nil when not present" do
-          @command.when_called { |_, options| options.use_config.should be_nil }
+          @command.when_called { |_, options| expect(options.use_config).to be_nil }
           @command.run
         end
       end
@@ -118,24 +119,24 @@ describe Commander::Command do
         end
 
         it "should parse valid values" do
-          @command.when_called { |_, options| options.interval.should eq(5) }
+          @command.when_called { |_, options| expect(options.interval).to eq(5) }
           @command.run '--interval', '5'
         end
 
         it "should reject invalid values" do
-          lambda { @command.run '--interval', 'invalid' }.should raise_error(OptionParser::InvalidArgument)
+          expect { @command.run '--interval', 'invalid' }.to raise_error(OptionParser::InvalidArgument)
         end
       end
 
       it "lists" do
         @command.option '--fav COLORS', Array
-        @command.when_called { |_, options| options.fav.should eq(['red', 'green', 'blue']) }  
+        @command.when_called { |_, options| expect(options.fav).to eq(['red', 'green', 'blue']) }  
         @command.run '--fav', 'red,green,blue'
       end
       
       it "lists with multi-word items" do
         @command.option '--fav MOVIES', Array
-        @command.when_called { |_, options| options.fav.should eq(['super\ bad', 'nightmare']) }  
+        @command.when_called { |_, options| expect(options.fav).to eq(['super\ bad', 'nightmare']) }  
         @command.run '--fav', 'super\ bad,nightmare'        
       end
       
@@ -146,8 +147,8 @@ describe Commander::Command do
           options.default \
             :files => ['foo', 'bar'],
             :interval => 5
-          options.files.should eq(['foo', 'bar'])
-          options.interval.should eq(15)
+          expect(options.files).to eq(['foo', 'bar'])
+          expect(options.interval).to eq(15)
         end
         @command.run '--interval', '15'
       end

data/spec/configure_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'commander/configure'
+
+describe Commander do
+  describe '.configure' do
+    it 'calls the given block' do
+      expect { Commander.configure { throw :block_called } }.to throw_symbol(:block_called)
+    end
+
+    describe 'called block' do
+      before(:each) do
+        allow(Commander::Runner.instance).to receive(:run!)
+      end
+
+      it 'provides Commander configuration methods' do
+        Commander.configure {
+          program :name, 'test'
+        }
+
+        expect(Commander::Runner.instance.program(:name)).to eq('test')
+      end
+
+      it 'passes all arguments to the block' do
+        Commander.configure('foo') { |first_arg|
+          program :name, first_arg
+        }
+
+        expect(Commander::Runner.instance.program(:name)).to eq('foo')
+      end
+    end
+
+    it 'calls Runner#run! after calling the configuration block' do
+      expect(Commander::Runner.instance).to receive(:run!)
+      Commander.configure {}
+    end
+  end
+end

data/spec/core_ext/array_spec.rb

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

data/spec/core_ext/object_spec.rb

@@ -4,17 +4,17 @@ describe Object do
   
   describe "#get_binding" do
     it "should return the objects binding" do
-      lambda {}.get_binding.should be_instance_of(Binding)
+      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
-      lambda { i_am_a_missing_method() }.should raise_error(NoMethodError)
+      expect { i_am_a_missing_method() }.to raise_error(NoMethodError)
     end
 
     it "should preserve its original behavior for missing variables" do
-      lambda { i_am_a_missing_variable }.should raise_error(NameError)
+      expect { i_am_a_missing_variable }.to raise_error(NameError)
     end
   end
 

data/spec/help_formatters/terminal_spec.rb

@@ -1,6 +1,7 @@
 require 'spec_helper'
 
 describe Commander::HelpFormatter::Terminal do
+  include Commander::Methods
   
   before :each do
     mock_terminal
@@ -19,11 +20,11 @@ describe Commander::HelpFormatter::Terminal do
     
     describe "should display" do
       it "the command name" do
-        @global_help.should include('install gem')
+        expect(@global_help).to include('install gem')
       end
       
       it "the summary" do
-        @global_help.should include('Install some gem')
+        expect(@global_help).to include('Install some gem')
       end
     end
   end
@@ -44,22 +45,22 @@ describe Commander::HelpFormatter::Terminal do
     
     describe "should display" do
       it "the command name" do
-        @command_help.should include('install gem')
+        expect(@command_help).to include('install gem')
       end
       
       it "the description" do
-        @command_help.should include('Install some gem, blah blah blah')
+        expect(@command_help).to include('Install some gem, blah blah blah')
       end
       
       it "all examples" do
-        @command_help.should include('# one')
-        @command_help.should include('two')
-        @command_help.should include('# three')
-        @command_help.should include('four')
+        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
-        @command_help.should include('foo install gem [options]')
+        expect(@command_help).to include('foo install gem [options]')
       end
     end
   end

data/spec/methods_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+require 'commander/methods'
+
+describe Commander::Methods do
+  it 'includes Commander::UI' do
+    expect(subject.ancestors).to include(Commander::UI)
+  end
+
+  it 'includes Commander::UI::AskForClass' do
+    expect(subject.ancestors).to include(Commander::UI::AskForClass)
+  end
+
+  it 'includes Commander::Delegates' do
+    expect(subject.ancestors).to include(Commander::Delegates)
+  end
+
+  it 'does not change the Object ancestors' do
+    expect(Object.ancestors).not_to include(Commander::UI)
+  end
+end

data/spec/runner_spec.rb

@@ -1,6 +1,8 @@
 require 'spec_helper'
 
 describe Commander do
+  include Commander::Methods
+
   before :each do
     $stderr = StringIO.new
     mock_terminal
@@ -10,59 +12,59 @@ describe Commander do
   describe "#program" do
     it "should set / get program information" do
       program :name, 'test'
-      program(:name).should eq('test')
+      expect(program(:name)).to eq('test')
     end
     
     it "should allow arbitrary blocks of global help documentation" do
       program :help, 'Copyright', 'TJ Holowaychuk'
-      program(:help)['Copyright'].should eq('TJ Holowaychuk')
+      expect(program(:help)['Copyright']).to eq('TJ Holowaychuk')
     end
     
     it "should raise an error when required info has not been set" do
       new_command_runner '--help'
       program :version, ''
-      lambda { run! }.should raise_error(Commander::Runner::CommandError)
+      expect { run! }.to raise_error(Commander::Runner::CommandError)
     end
     
     it "should allow aliases of help formatters" do
       program :help_formatter, :compact
-      program(:help_formatter).should eq(Commander::HelpFormatter::TerminalCompact)
+      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
-      command(:test).should be_instance_of(Commander::Command)
+      expect(command(:test)).to be_instance_of(Commander::Command)
     end
     
     it "should return nil when the command does not exist" do
-      command(:im_not_real).should be_nil
+      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
       switches, description = *Commander::Runner.separate_switches_from_description('-h', '--help', 'display help')
-      switches.should eq(['-h', '--help'])
-      description.should eq('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
-     Commander::Runner.switch_to_sym('--trace').should eq(:trace)
-     Commander::Runner.switch_to_sym('--foo-bar').should eq(:foo_bar)
-     Commander::Runner.switch_to_sym('--[no-]feature"').should eq(:feature)
-     Commander::Runner.switch_to_sym('--[no-]feature ARG').should eq(:feature)
-     Commander::Runner.switch_to_sym('--file [ARG]').should eq(:file)
-     Commander::Runner.switch_to_sym('--colors colors').should eq(:colors)
+     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
       alias_command :foo, :test
-      command(:foo).should eq(command(:test))
+      expect(command(:foo)).to eq(command(:test))
     end
     
     it "should pass arguments passed to the alias when called" do
@@ -74,7 +76,7 @@ describe Commander do
         end 
         alias_command :'install gem', :install, '--gem-name'
       end.run!
-      gem_name.should eq('commander')
+      expect(gem_name).to eq('commander')
     end
   end
   
@@ -84,7 +86,7 @@ describe Commander do
       new_command_runner 'test', '--config', 'foo' do
         global_option('--config FILE') { |f| file = f }
       end.run!
-      file.should eq('foo')
+      expect(file).to eq('foo')
     end
     
     it "should be inherited by commands" do
@@ -95,7 +97,7 @@ describe Commander do
           c.when_called { |_, options| quiet = options.quiet } 
         end
       end.run!
-      quiet.should be_true
+      expect(quiet).to be_true
     end
     
     it "should be inherited by commands even when a block is present" do
@@ -106,7 +108,7 @@ describe Commander do
           c.when_called { |_, options| quiet = options.quiet } 
         end
       end.run!
-      quiet.should be_true      
+      expect(quiet).to be_true      
     end
   end
 
@@ -120,7 +122,7 @@ describe Commander do
           c.when_called {}
         end
       end.run!
-      global_option.should eq('MAGIC')
+      expect(global_option).to eq('MAGIC')
     end
 
     it 'should parse global options after command' do
@@ -132,7 +134,7 @@ describe Commander do
           c.when_called {}
         end
       end.run!
-      global_option.should eq('MAGIC')
+      expect(global_option).to eq('MAGIC')
     end
 
     it 'should parse global options placed before command options' do
@@ -146,7 +148,7 @@ describe Commander do
         end
       end.run!
 
-      global_option.should eq('MAGIC')
+      expect(global_option).to eq('MAGIC')
     end
 
     it 'should parse global options placed after command options' do
@@ -160,7 +162,7 @@ describe Commander do
         end
       end.run!
 
-      global_option.should eq('MAGIC')
+      expect(global_option).to eq('MAGIC')
     end
 
     it 'should parse global options surrounded by command options' do
@@ -175,7 +177,7 @@ describe Commander do
         end
       end.run!
 
-      global_option.should eq('MAGIC')
+      expect(global_option).to eq('MAGIC')
     end
 
     it 'should not parse command options' do
@@ -190,8 +192,8 @@ describe Commander do
         end
       end.parse_global_options
 
-      command_option.should be_nil
-      global_option.should eq('MAGIC')
+      expect(command_option).to be_nil
+      expect(global_option).to eq('MAGIC')
     end
 
     it 'should not affect command arguments with values' do
@@ -206,8 +208,8 @@ describe Commander do
         end
       end.run!
 
-      command_option.should eq('bar')
-      global_option.should eq('MAGIC')
+      expect(command_option).to eq('bar')
+      expect(global_option).to eq('MAGIC')
     end
 
     it 'should not affect global arguments with values' do
@@ -221,7 +223,7 @@ describe Commander do
         end
       end.run!
 
-      global_option.should eq('bar')
+      expect(global_option).to eq('bar')
     end
     
     it 'should allow global arguments with values before command arguments (github issue #8)' do
@@ -236,8 +238,8 @@ describe Commander do
         end
       end.run!
 
-      global_option.should eq('path')
-      command_option.should eq('bar')
+      expect(global_option).to eq('path')
+      expect(command_option).to eq('bar')
     end
   end
 
@@ -254,7 +256,7 @@ describe Commander do
       args << '--command-with-arg' << 'rawr'
       args << '--paths' << '"lib/**/*.js","spec/**/*.js"'
       command_runner.remove_global_options options, args
-      args.should eq(['--command', '--command-with-arg', 'rawr'])
+      expect(args).to eq(['--command', '--command-with-arg', 'rawr'])
     end
 
     it "should not swallow an argument unless it expects an argument" do
@@ -267,47 +269,47 @@ describe Commander do
       args << '-a' << 'deleted'
       args << 'beta'
       command_runner.remove_global_options options, args
-      args.should eq(['alpha', 'beta'])
+      expect(args).to eq(['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?
-      lambda {
+      expect {
         new_command_runner 'foo' do
           command(:foo) { |c| c.when_called { raise 'cookies!' } }
         end.run!
-      }.should raise_error(SystemExit, /error: cookies!. Use --trace/)
+      }.to raise_error(SystemExit, /error: cookies!. Use --trace/)
     end
 
     it "should display callstack when using this switch" do
-      lambda {
+      expect {
         new_command_runner 'foo', '--trace' do
           command(:foo) { |c| c.when_called { raise 'cookies!' } }
         end.run!  
-      }.should raise_error(RuntimeError)
+      }.to raise_error(RuntimeError)
     end
   end
 
   describe "#always_trace!" do
     it "should enable tracing globally, regardless of whether --trace was passed or not" do
-      lambda {
+      expect {
         new_command_runner 'foo' do
           always_trace!
           command(:foo) { |c| c.when_called { raise 'cookies!' } }
         end.run!
-      }.should raise_error(RuntimeError)
+      }.to raise_error(RuntimeError)
     end
   end
 
   describe "#never_trace!" do
     it "should disable tracing globally, regardless of whether --trace was passed or not" do
-      lambda {
+      expect {
         new_command_runner 'help', '--trace' do
           never_trace!
         end.run!
-      }.should raise_error(SystemExit, /invalid option: --trace/)
+      }.to raise_error(SystemExit, /invalid option: --trace/)
     end
 
     it "should not prompt to use --trace switch on errors" do
@@ -320,81 +322,81 @@ describe Commander do
       rescue SystemExit => e
         msg = e.message
       end
-      msg.should match(/error: cookies!/)
-      msg.should_not match(/--trace/)
+      expect(msg).to match(/error: cookies!/)
+      expect(msg).not_to match(/--trace/)
     end
   end
 
   context "conflict between #always_trace! and #never_trace!" do
     it "respects the last used command" do
-      lambda {
+      expect {
         new_command_runner 'foo' do
           never_trace!
           always_trace!
           command(:foo) { |c| c.when_called { raise 'cookies!' } }
         end.run!
-      }.should raise_error(RuntimeError)
+      }.to raise_error(RuntimeError)
     end
   end
 
   describe "--version" do
     it "should output program version" do
-      run('--version').should eq("test 1.2.3\n")
+      expect(run('--version')).to eq("test 1.2.3\n")
     end
   end
   
   describe "--help" do
     it "should not output an invalid command message" do
-      run('--help').should_not == "invalid command. Use --help for more information\n"
+      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
-      run('test', '--help').should eq("Implement help for test here\n")
+      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?
-      lambda {
+      expect {
         run('test', '--invalid-option')  
-      }.should raise_error(SystemExit, /invalid option: --invalid-option/)
+      }.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?
-      lambda {
+      expect {
         run('foo')  
-      }.should raise_error(SystemExit, /invalid command. Use --help for more information/)
+      }.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?
-      lambda {
+      expect {
         run('help', 'does_not_exist')
-      }.should raise_error(SystemExit, /invalid command. Use --help for more information/)
+      }.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?
-      lambda {
+      expect {
         run('--help', 'does_not_exist')
-      }.should raise_error(SystemExit, /invalid command. Use --help for more information/)
+      }.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?
-      lambda {
+      expect {
         run('--help', 'test', '--invalid-option')
-      }.should raise_error(SystemExit, /invalid option: --invalid-option/)
+      }.to raise_error(SystemExit, /invalid option: --invalid-option/)
     end
   end
   
@@ -403,20 +405,20 @@ describe Commander do
       new_command_runner do
         command('foo bar') {}
         command('foo bar foo') {}
-        command_runner.valid_command_names_from('foo', 'bar', 'foo').sort.should eq(['foo bar', '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
       new_command_runner do
-        command_runner.valid_command_names_from('fake', 'command', 'name').should eq([])
+        expect(command_runner.valid_command_names_from('fake', 'command', 'name')).to eq([])
       end
     end
 
     it "should match exact commands only" do
       new_command_runner do
         command('foo') {}
-        command_runner.valid_command_names_from('foobar').should eq([])
+        expect(command_runner.valid_command_names_from('foobar')).to eq([])
       end
     end
   end
@@ -424,42 +426,42 @@ describe Commander do
   describe "#command_name_from_args" do
     it "should locate command within arbitrary arguments passed" do
       new_command_runner '--help', '--arbitrary', 'test'
-      command_runner.command_name_from_args.should eq('test')
+      expect(command_runner.command_name_from_args).to eq('test')
     end
     
     it "should support multi-word commands" do
       new_command_runner '--help', '--arbitrary', 'some', 'long', 'command', 'foo'
       command('some long command') {}
-      command_runner.command_name_from_args.should eq('some long command')
+      expect(command_runner.command_name_from_args).to eq('some long command')
     end
     
     it "should match the longest possible command" do
       new_command_runner '--help', '--arbitrary', 'foo', 'bar', 'foo'
       command('foo bar') {}
       command('foo bar foo') {}
-      command_runner.command_name_from_args.should 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
       new_command_runner 'help', 'test'
-      command_runner.command_name_from_args.should 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
       new_command_runner '--help', 'test'
-      command_runner.active_command.should be_instance_of(Commander::Command)
+      expect(command_runner.active_command).to be_instance_of(Commander::Command)
     end
     
     it "should resolve active command when invalid options are passed" do
       new_command_runner '--help', 'test', '--arbitrary'
-      command_runner.active_command.should be_instance_of(Commander::Command)
+      expect(command_runner.active_command).to be_instance_of(Commander::Command)
     end
     
     it "should return nil when the command is not found" do
       new_command_runner 'foo'
-      command_runner.active_command.should be_nil
+      expect(command_runner.active_command).to be_nil
     end
   end
   
@@ -467,8 +469,8 @@ describe Commander do
     it "should allow you to default any command when one is not explicitly passed" do
       new_command_runner '--trace' do
         default_command :test
-        command(:test).should_receive(:run).once
-        command_runner.active_command.should eq(command(:test))
+        expect(command(:test)).to receive(:run).once
+        expect(command_runner.active_command).to eq(command(:test))
       end.run!
     end
     
@@ -476,8 +478,8 @@ describe Commander do
       new_command_runner 'foo', 'bar', '--trace' do
         default_command :test
         command(:'foo bar'){}
-        command(:'foo bar').should_receive(:run).once
-        command_runner.active_command.should eq(command(:'foo bar'))
+        expect(command(:'foo bar')).to receive(:run).once
+        expect(command_runner.active_command).to eq(command(:'foo bar'))
       end.run!
     end
     
@@ -486,14 +488,14 @@ describe Commander do
       default_command :'foo bar'
       command(:'foo bar'){}
       command(:'foo bar something'){}
-      command_runner.active_command.should eq(command(:'foo bar something'))
+      expect(command_runner.active_command).to eq(command(:'foo bar something'))
     end
     
     it "should allow defaulting of command aliases" do
       new_command_runner '--trace' do
         default_command :foobar
         alias_command :foobar, :test
-        command(:test).should_receive(:run).once
+        expect(command(:test)).to receive(:run).once
       end.run!
     end
   end
@@ -502,8 +504,8 @@ describe Commander 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|
-          args.should eq(['foo', 'bar'])
-          options.verbose.should be_true
+          expect(args).to eq(['foo', 'bar'])
+          expect(options.verbose).to be_true
         end
       end.run!
     end
@@ -511,8 +513,8 @@ describe Commander 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|
-          args.should eq(['foo', 'bar'])
-          options.verbose.should be_true
+          expect(args).to eq(['foo', 'bar'])
+          expect(options.verbose).to be_true
         end
       end.run!
     end
@@ -520,8 +522,8 @@ describe Commander 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|
-          args.should eq(['foo', 'test', 'bar'])
-          options.verbose.should be_true
+          expect(args).to eq(['foo', 'test', 'bar'])
+          expect(options.verbose).to be_true
         end
       end.run!
     end
@@ -529,16 +531,16 @@ describe Commander 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') }
-        command_runner.command_name_from_args.should eq('my command')
-        command_runner.args_without_command_name.should eq(['--verbose', 'something', 'foo', 'bar'])
+        expect(command_runner.command_name_from_args).to eq('my command')
+        expect(command_runner.args_without_command_name).to eq(['--verbose', 'something', 'foo', 'bar'])
       end.run!
     end
 
     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') }
-        command_runner.command_name_from_args.should eq('my command')
-        command_runner.args_without_command_name.should eq(['--verbose', 'something', 'my', 'command'])
+        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
     
@@ -546,8 +548,8 @@ describe Commander do
       new_command_runner '--verbose', 'my', 'command', 'something', 'my', 'command' do
         command('my command') {}
         command('my command something') { |c| c.option('--verbose') }
-        command_runner.command_name_from_args.should eq('my command something')
-        command_runner.args_without_command_name.should eq(['--verbose', 'my', 'command'])
+        expect(command_runner.command_name_from_args).to eq('my command something')
+        expect(command_runner.args_without_command_name).to eq(['--verbose', 'my', 'command'])
       end.run!
     end
   end
@@ -558,7 +560,7 @@ describe Commander do
         command('foo') do |c|
           c.option('--optional [argument]')
           c.when_called do |_, options|
-            options.optional.should eq('arg1')
+            expect(options.optional).to eq('arg1')
           end
         end
       end.run!
@@ -569,7 +571,7 @@ describe Commander do
         command('foo') do |c|
           c.option('--optional [argument]')
           c.when_called do |_, options|
-            options.optional.should be_true
+            expect(options.optional).to be_true
           end
         end
       end.run!

data/spec/spec_helper.rb

@@ -1,7 +1,9 @@
 require 'rubygems'
 require 'stringio'
 require 'simplecov'
-SimpleCov.start
+SimpleCov.start do
+  add_filter "/spec/"
+end
 
 # Unshift so that local files load instead of something in gems
 $:.unshift File.dirname(__FILE__) + '/../lib'
@@ -9,21 +11,7 @@ $:.unshift File.dirname(__FILE__) + '/../lib'
 # This basically replicates the behavior of `require 'commander/import'`
 # but without adding an `at_exit` hook, which interferes with exit code
 require 'commander'
-require 'commander/delegates'
-
-include Commander::UI
-include Commander::UI::AskForClass
-include Commander::Delegates
-
-# prevent paging from actually occurring in test environment
-
-module Commander
-  module UI
-    def enable_paging
-      return
-    end
-  end
-end
+require 'commander/methods'
 
 # Mock terminal IO streams so we can spec against them
 
@@ -72,4 +60,18 @@ def run *args
     program :help_formatter, Commander::HelpFormatter::Base
   end.run!    
   @output.string
-end
+end
+
+RSpec.configure do |c|
+  c.expect_with(:rspec) do |e|
+    e.syntax = :expect
+  end
+
+  c.mock_with(:rspec) do |m|
+    m.syntax = :expect
+  end
+
+  c.before(:each) do
+    allow(Commander::UI).to receive(:enable_paging)
+  end
+end

data/spec/ui_spec.rb

@@ -1,11 +1,12 @@
 require 'spec_helper'
 
 describe Commander::UI do
+  include Commander::Methods
   
   describe ".replace_tokens" do
     it "should replace tokens within a string, with hash values" do
       result = Commander::UI.replace_tokens 'Welcome :name, enjoy your :object'.freeze, :name => 'TJ', :object => 'cookie'
-      result.should eq('Welcome TJ, enjoy your cookie')
+      expect(result).to eq('Welcome TJ, enjoy your cookie')
     end
   end
 
@@ -17,13 +18,13 @@ describe Commander::UI do
       rescue
         exception = true
       end
-      exception.should_not be_true
+      expect(exception).not_to be_true
     end
   end
   
   describe ".available_editor" do
     it "should not fail on available editors with shell arguments" do
-      Commander::UI.available_editor('sh -c').should eq('sh -c')
+      expect(Commander::UI.available_editor('sh -c')).to eq('sh -c')
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: commander
 version: !ruby/object:Gem::Version
-  version: 4.1.6
+  version: 4.2.0
 platform: ruby
 authors:
 - TJ Holowaychuk
@@ -9,62 +9,62 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-11 00:00:00.000000000 Z
+date: 2014-04-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: highline
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 1.6.11
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 1.6.11
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '2'
+        version: '2.14'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '2'
+        version: '2.14'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: The complete solution for Ruby command-line executables. Commander bridges
@@ -77,8 +77,8 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
+- ".gitignore"
+- ".travis.yml"
 - DEVELOPMENT
 - Gemfile
 - History.rdoc
@@ -91,6 +91,7 @@ files:
 - lib/commander.rb
 - lib/commander/blank.rb
 - lib/commander/command.rb
+- lib/commander/configure.rb
 - lib/commander/core_ext.rb
 - lib/commander/core_ext/array.rb
 - lib/commander/core_ext/object.rb
@@ -104,14 +105,17 @@ files:
 - lib/commander/help_formatters/terminal_compact/command_help.erb
 - lib/commander/help_formatters/terminal_compact/help.erb
 - lib/commander/import.rb
+- lib/commander/methods.rb
 - lib/commander/platform.rb
 - lib/commander/runner.rb
 - lib/commander/user_interaction.rb
 - lib/commander/version.rb
 - spec/command_spec.rb
+- spec/configure_spec.rb
 - spec/core_ext/array_spec.rb
 - spec/core_ext/object_spec.rb
 - spec/help_formatters/terminal_spec.rb
+- spec/methods_spec.rb
 - spec/runner_spec.rb
 - spec/spec_helper.rb
 - spec/ui_spec.rb
@@ -125,25 +129,27 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: commander
-rubygems_version: 2.2.1
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: The complete solution for Ruby command-line executables
 test_files:
 - spec/command_spec.rb
+- spec/configure_spec.rb
 - spec/core_ext/array_spec.rb
 - spec/core_ext/object_spec.rb
 - spec/help_formatters/terminal_spec.rb
+- spec/methods_spec.rb
 - spec/runner_spec.rb
 - spec/spec_helper.rb
 - spec/ui_spec.rb