scoot 0.0.4 → 0.0.6

data/.bundle/gems/ruby/2.2.0/gems/commander-4.3.4/lib/commander/version.rb

@@ -1,3 +0,0 @@
-module Commander
-  VERSION = '4.3.4'
-end

data/.bundle/gems/ruby/2.2.0/gems/commander-4.3.4/spec/command_spec.rb

@@ -1,157 +0,0 @@
-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
-    end
-
-    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
-      @options.send = 'foo'
-      expect(@options.__send__(:send)).to eq('foo')
-    end
-  end
-
-  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 }
-      @command.run '--recursive'
-    end
-
-    it 'should allow usage of common method names' do
-      @command.option '--open file'
-      @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') }
-        @command.run '--verbose', 'just', 'some', 'args'
-      end
-
-      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'
-      end
-
-      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
-        object = double 'Object'
-        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
-        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| expect(options.toggle).to be true }
-        @command.run '--toggle'
-        @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| expect(options.file).to eq('foo') }
-        @command.run '--file', 'foo'
-        expect { @command.run '--file' }.to raise_error(OptionParser::MissingArgument)
-      end
-
-      describe 'optional arguments' do
-        before do
-          @command.option '--use-config [file] '
-        end
-
-        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 }
-          @command.run '--use-config'
-        end
-
-        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
-        before do
-          @command.option '--interval N', Integer
-        end
-
-        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
-          expect { @command.run '--interval', 'invalid' }.to raise_error(OptionParser::InvalidArgument)
-        end
-      end
-
-      it 'lists' do
-        @command.option '--fav COLORS', Array
-        @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
-        @command.option '--fav MOVIES', Array
-        @command.when_called { |_, options| expect(options.fav).to eq(['super\ bad', 'nightmare']) }
-        @command.run '--fav', 'super\ bad,nightmare'
-      end
-
-      it 'defaults' do
-        @command.option '--files LIST', Array
-        @command.option '--interval N', Integer
-        @command.when_called do |_, options|
-          options.default \
-            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/.bundle/gems/ruby/2.2.0/gems/commander-4.3.4/spec/configure_spec.rb

@@ -1,37 +0,0 @@
-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 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') do |first_arg|
-          program :name, first_arg
-        end
-
-        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/.bundle/gems/ruby/2.2.0/gems/commander-4.3.4/spec/core_ext/array_spec.rb

@@ -1,18 +0,0 @@
-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(%w(just a test))
-    end
-
-    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
-      str = 'just a\\ test'
-      expect(Array.parse(str)).to eq(eval("%w(#{str})"))
-    end
-  end
-end

data/.bundle/gems/ruby/2.2.0/gems/commander-4.3.4/spec/core_ext/object_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-
-describe Object do
-  describe '#get_binding' do
-    it 'should return the objects binding' do
-      expect(-> {}.get_binding).to be_instance_of(Binding)
-    end
-  end
-
-  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
-      expect { i_am_a_missing_variable }.to raise_error(NameError)
-    end
-  end
-end

data/.bundle/gems/ruby/2.2.0/gems/commander-4.3.4/spec/help_formatters/terminal_compact_spec.rb

@@ -1,69 +0,0 @@
-require 'spec_helper'
-
-describe Commander::HelpFormatter::TerminalCompact do
-  include Commander::Methods
-
-  before :each do
-    mock_terminal
-  end
-
-  describe 'global help' do
-    before :each do
-      new_command_runner 'help' do
-        program :help_formatter, :compact
-        command :'install gem' do |c|
-          c.syntax = 'foo install gem [options]'
-          c.summary = 'Install some gem'
-        end
-      end.run!
-      @global_help = @output.string
-    end
-
-    describe 'should display' do
-      it 'the command name' do
-        expect(@global_help).to include('install gem')
-      end
-
-      it 'the summary' do
-        expect(@global_help).to include('Install some gem')
-      end
-    end
-  end
-
-  describe 'command help' do
-    before :each do
-      new_command_runner 'help', 'install', 'gem' do
-        program :help_formatter, :compact
-        command :'install gem' do |c|
-          c.syntax = 'foo install gem [options]'
-          c.summary = 'Install some gem'
-          c.description = 'Install some gem, blah blah blah'
-          c.example 'one', 'two'
-          c.example 'three', 'four'
-        end
-      end.run!
-      @command_help = @output.string
-    end
-
-    describe 'should display' do
-      it 'the command name' do
-        expect(@command_help).to include('install gem')
-      end
-
-      it 'the description' do
-        expect(@command_help).to include('Install some gem, blah blah blah')
-      end
-
-      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
-        expect(@command_help).to include('foo install gem [options]')
-      end
-    end
-  end
-end

data/.bundle/gems/ruby/2.2.0/gems/commander-4.3.4/spec/help_formatters/terminal_spec.rb

@@ -1,67 +0,0 @@
-require 'spec_helper'
-
-describe Commander::HelpFormatter::Terminal do
-  include Commander::Methods
-
-  before :each do
-    mock_terminal
-  end
-
-  describe 'global help' do
-    before :each do
-      new_command_runner 'help' do
-        command :'install gem' do |c|
-          c.syntax = 'foo install gem [options]'
-          c.summary = 'Install some gem'
-        end
-      end.run!
-      @global_help = @output.string
-    end
-
-    describe 'should display' do
-      it 'the command name' do
-        expect(@global_help).to include('install gem')
-      end
-
-      it 'the summary' do
-        expect(@global_help).to include('Install some gem')
-      end
-    end
-  end
-
-  describe 'command help' do
-    before :each do
-      new_command_runner 'help', 'install', 'gem' do
-        command :'install gem' do |c|
-          c.syntax = 'foo install gem [options]'
-          c.summary = 'Install some gem'
-          c.description = 'Install some gem, blah blah blah'
-          c.example 'one', 'two'
-          c.example 'three', 'four'
-        end
-      end.run!
-      @command_help = @output.string
-    end
-
-    describe 'should display' do
-      it 'the command name' do
-        expect(@command_help).to include('install gem')
-      end
-
-      it 'the description' do
-        expect(@command_help).to include('Install some gem, blah blah blah')
-      end
-
-      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
-        expect(@command_help).to include('foo install gem [options]')
-      end
-    end
-  end
-end

data/.bundle/gems/ruby/2.2.0/gems/commander-4.3.4/spec/methods_spec.rb

@@ -1,20 +0,0 @@
-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/.bundle/gems/ruby/2.2.0/gems/commander-4.3.4/spec/runner_spec.rb

@@ -1,573 +0,0 @@
-require 'spec_helper'
-
-describe Commander do
-  include Commander::Methods
-
-  before :each do
-    $stderr = StringIO.new
-    mock_terminal
-    create_test_command
-  end
-
-  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
-      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
-      new_command_runner '--help'
-      program :version, ''
-      expect { run! }.to raise_error(Commander::Runner::CommandError)
-    end
-
-    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
-      expect(command(:test)).to be_instance_of(Commander::Command)
-    end
-
-    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
-      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)
-    end
-  end
-
-  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
-      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
-        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
-      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
-      quiet = nil
-      new_command_runner 'foo', '--quiet' do
-        global_option('--quiet', 'Suppress output')
-        command :foo do |c|
-          c.when_called { |_, options| quiet = options.quiet }
-        end
-      end.run!
-      expect(quiet).to be true
-    end
-
-    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 }
-        end
-      end.run!
-      expect(quiet).to be true
-    end
-  end
-
-  describe '#parse_global_options' do
-    it 'should parse global options before command' do
-      global_option = nil
-      new_command_runner('--testing-global', 'foo') do
-        global_option('--testing-global') { global_option = 'MAGIC' }
-
-        command :foo do |c|
-          c.when_called {}
-        end
-      end.run!
-      expect(global_option).to eq('MAGIC')
-    end
-
-    it 'should parse global options after command' do
-      global_option = nil
-      new_command_runner('foo', '--testing-global') do
-        global_option('--testing-global') { global_option = 'MAGIC' }
-
-        command :foo do |c|
-          c.when_called {}
-        end
-      end.run!
-      expect(global_option).to eq('MAGIC')
-    end
-
-    it 'should parse global options placed before command options' do
-      global_option = nil
-      new_command_runner('foo', '--testing-global', '--testing-command') do
-        global_option('--testing-global') { global_option = 'MAGIC' }
-
-        command :foo do |c|
-          c.option('--testing-command') {}
-          c.when_called {}
-        end
-      end.run!
-
-      expect(global_option).to eq('MAGIC')
-    end
-
-    it 'should parse global options placed after command options' do
-      global_option = nil
-      new_command_runner('foo', '--testing-command', '--testing-global') do
-        global_option('--testing-global') { global_option = 'MAGIC' }
-
-        command :foo do |c|
-          c.option('--testing-command') {}
-          c.when_called {}
-        end
-      end.run!
-
-      expect(global_option).to eq('MAGIC')
-    end
-
-    it 'should parse global options surrounded by command options' do
-      global_option = nil
-      new_command_runner('foo', '--testing-command', '--testing-global', '--other-command') do
-        global_option('--testing-global') { global_option = 'MAGIC' }
-
-        command :foo do |c|
-          c.option('--testing-command') {}
-          c.option('--other-command') {}
-          c.when_called {}
-        end
-      end.run!
-
-      expect(global_option).to eq('MAGIC')
-    end
-
-    it 'should not parse command options' do
-      global_option = nil
-      command_option = nil
-      new_command_runner('foo', '--testing-command', '--testing-global') do
-        global_option('--testing-global') { global_option = 'MAGIC' }
-
-        command :foo do |c|
-          c.option('--testing-command') { command_option = 'NO!' }
-          c.when_called {}
-        end
-      end.parse_global_options
-
-      expect(command_option).to be_nil
-      expect(global_option).to eq('MAGIC')
-    end
-
-    it 'should not affect command arguments with values' do
-      global_option = nil
-      command_option = nil
-      new_command_runner('foo', '--testing-command', 'bar', '--testing-global') do
-        global_option('--testing-global') { global_option = 'MAGIC' }
-
-        command :foo do |c|
-          c.option('--testing-command VALUE') { |v| command_option = v }
-          c.when_called {}
-        end
-      end.run!
-
-      expect(command_option).to eq('bar')
-      expect(global_option).to eq('MAGIC')
-    end
-
-    it 'should not affect global arguments with values' do
-      global_option = nil
-      new_command_runner('foo', '--testing-command', '--testing-global', 'bar') do
-        global_option('--testing-global VALUE') { |v| global_option = v }
-
-        command :foo do |c|
-          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
-      new_command_runner('foo', '--config', 'path', 'bar') do
-        global_option('--config VALUE') { |v| global_option = v }
-
-        command :foo do |c|
-          c.option('bar') { command_option = 'bar' }
-          c.when_called {}
-        end
-      end.run!
-
-      expect(global_option).to eq('path')
-      expect(command_option).to eq('bar')
-    end
-  end
-
-  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'] }
-      args << '-t'
-      args << '--help'
-      args << '--command'
-      args << '--command-with-arg' << 'rawr'
-      args << '--paths' << '"lib/**/*.js","spec/**/*.js"'
-      command_runner.remove_global_options options, args
-      expect(args).to eq(['--command', '--command-with-arg', 'rawr'])
-    end
-
-    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'] }
-      args << '-n' << 'alpha'
-      args << '--yes' << 'deleted'
-      args << '-a' << 'deleted'
-      args << 'beta'
-      command_runner.remove_global_options options, args
-      expect(args).to eq(%w(alpha beta))
-    end
-  end
-
-  describe '--trace' do
-    it 'should display pretty errors by default' do
-      expect do
-        new_command_runner 'foo' do
-          command(:foo) { |c| c.when_called { fail 'cookies!' } }
-        end.run!
-      end.to raise_error(SystemExit, /error: cookies!. Use --trace/)
-    end
-
-    it 'should display callstack when using this switch' do
-      expect do
-        new_command_runner 'foo', '--trace' do
-          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 do
-        new_command_runner 'foo' do
-          always_trace!
-          command(:foo) { |c| c.when_called { fail 'cookies!' } }
-        end.run!
-      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 do
-        new_command_runner 'help', '--trace' do
-          never_trace!
-        end.run!
-      end.to raise_error(SystemExit, /invalid option: --trace/)
-    end
-
-    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 { fail 'cookies!' } }
-        end.run!
-      rescue SystemExit => e
-        msg = e.message
-      end
-      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
-      expect do
-        new_command_runner 'foo' do
-          never_trace!
-          always_trace!
-          command(:foo) { |c| c.when_called { fail 'cookies!' } }
-        end.run!
-      end.to raise_error(RuntimeError)
-    end
-  end
-
-  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
-      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
-      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
-      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
-      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
-      expect do
-        run('help', 'does_not_exist')
-      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
-      expect do
-        run('--help', 'does_not_exist')
-      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
-      expect do
-        run('--help', 'test', '--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
-      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
-      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
-      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
-      new_command_runner '--help', '--arbitrary', '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') {}
-      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') {}
-      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'
-      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'
-      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'
-      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'
-      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
-      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
-      new_command_runner 'foo', 'bar', '--trace' do
-        default_command :test
-        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
-      new_command_runner 'foo', 'bar', 'something'
-      default_command :'foo bar'
-      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
-      new_command_runner '--trace' do
-        default_command :foobar
-        alias_command :foobar, :test
-        expect(command(:test)).to receive(:run).once
-      end.run!
-    end
-  end
-
-  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(%w(foo bar))
-          expect(options.verbose).to be true
-        end
-      end.run!
-    end
-
-    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(%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
-      new_command_runner 'test', '--verbose', 'foo', 'test', 'bar' do
-        @command.when_called do |args, options|
-          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
-      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')
-        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') }
-        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
-      new_command_runner '--verbose', 'my', 'command', 'something', 'my', 'command' do
-        command('my command') {}
-        command('my command something') { |c| c.option('--verbose') }
-        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
-
-  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]')
-          c.when_called do |_, options|
-            expect(options.optional).to eq('arg1')
-          end
-        end
-      end.run!
-    end
-
-    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
-          end
-        end
-      end.run!
-    end
-  end
-end