murano-cli-commander 4.4.10

data/lib/murano-cli-commander/version.rb

@@ -0,0 +1,3 @@
+module Commander
+  VERSION = '4.4.10'.freeze
+end

data/murano-cli-commander.gemspec

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+
+$LOAD_PATH.push File.expand_path('../lib', __FILE__)
+require 'murano-cli-commander/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'murano-cli-commander'
+  s.version     = Commander::VERSION
+  # (lb); Original thanks to:
+  #   s.authors     = ['TJ Holowaychuk', 'Gabriel Gilder']
+  #   s.email       = ['gabriel@gabrielgilder.com']
+  #   s.homepage    = 'https://github.com/commander-rb/commander'
+  s.authors     = ['Exosite LLC']
+  s.email       = ['murano-cli-commander@exosite.com']
+  s.license     = 'MIT'
+  s.homepage    = 'https://github.com/exosite/murano-cli-commander'
+  s.summary     = 'The complete solution for Ruby command-line executables'
+  s.description = 'The complete solution for Ruby command-line executables. Commander bridges the gap between other terminal related libraries you know and love (OptionParser, HighLine), while providing many new features, and an elegant API.'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  s.add_runtime_dependency('highline', '~> 1.7.2')
+
+  s.add_development_dependency('rspec', '~> 3.2')
+  s.add_development_dependency('rake')
+  s.add_development_dependency('simplecov')
+  if RUBY_VERSION < '2.0'
+    s.add_development_dependency('rubocop', '~> 0.41.1')
+    s.add_development_dependency('json', '< 2.0')
+  else
+    s.add_development_dependency('rubocop', '~> 0.49.1')
+  end
+end

data/spec/command_spec.rb

@@ -0,0 +1,169 @@
+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
+    end
+  end
+end

data/spec/configure_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'murano-cli-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

@@ -0,0 +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(%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/spec/core_ext/object_spec.rb

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,69 @@
+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

@@ -0,0 +1,67 @@
+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

@@ -0,0 +1,61 @@
+require 'spec_helper'
+require 'murano-cli-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_terminal = $terminal
+        $terminal = terminal
+      end
+
+      after do
+        $terminal = $_old_terminal
+      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