commander 5.0.0 → 6.0.0

data/spec/command_spec.rb

@@ -1,198 +0,0 @@
-# frozen_string_literal: true
-
-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
-
-      it 'should be able to be run more than once' do
-        expect(@command.run('once')).to eql('test once')
-        expect(@command.run('twice')).to eql('test twice')
-      end
-
-      it 'should not accumulate entries in @proxy_options when run twice' do
-        expect(@command.run('--verbose')).to eql('test ')
-        expect(@command.proxy_options).to eq([[:verbose, true]])
-        expect(@command.run('foo')).to eql('test foo')
-        expect(@command.proxy_options).to eq([])
-      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
-
-      describe 'given a global option' do
-        before do
-          @command.global_options << [:global_option, 'gvalue']
-        end
-
-        describe 'and no command specific arguments' do
-          it 'provides the global option to the command action' do
-            @command.when_called { |_, options| expect(options.global_option).to eq('gvalue') }
-            @command.run
-          end
-        end
-
-        describe 'and a command specific option' do
-          it 'provides the global option to the command action' do
-            @command.when_called { |_, options| expect(options.global_option).to eq('gvalue') }
-            @command.run '--verbose'
-          end
-        end
-
-        describe 'and a command specific argument' do
-          it 'provides the global option to the command action' do
-            @command.when_called { |_, options| expect(options.global_option).to eq('gvalue') }
-            @command.run 'argument'
-          end
-        end
-      end
-    end
-  end
-end

data/spec/configure_spec.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-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/spec/core_ext/array_spec.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-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(['just', 'a test'])
-    end
-  end
-end

data/spec/core_ext/object_spec.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-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/spec/help_formatters/terminal_compact_spec.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-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/spec/help_formatters/terminal_spec.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-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/spec/methods_spec.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'commander/methods'
-
-describe Commander::Methods do
-  it 'includes Commander::UI' do
-    expect(subject.ancestors).to include(Commander::UI)
-  end
-
-  describe 'AskForClass' do
-    it 'includes Commander::UI::AskForClass' do
-      expect(subject.ancestors).to include(Commander::UI::AskForClass)
-    end
-
-    describe 'defining methods' do
-      let(:terminal) { double }
-
-      before do
-        allow(terminal).to receive(:ask)
-        @old_highline = HighLine.default_instance
-        HighLine.default_instance = terminal
-      end
-
-      after do
-        HighLine.default_instance = @old_highline
-      end
-
-      subject do
-        Class.new do
-          include Commander::UI::AskForClass
-        end.new
-      end
-
-      it 'defines common "ask_for_*" methods' do
-        expect(subject.respond_to?(:ask_for_float)).to be_truthy
-      end
-
-      it 'responds to "ask_for_*" methods for classes that implement #parse' do
-        expect(subject.respond_to?(:ask_for_datetime)).to be_truthy
-      end
-
-      it 'fails "ask_for_*" method invocations without a prompt' do
-        expect do
-          subject.ask_for_datetime
-        end.to raise_error(ArgumentError)
-      end
-
-      it 'implements "ask_for_*"' do
-        expect(terminal).to receive(:ask)
-        subject.ask_for_datetime('hi')
-      end
-    end
-  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