commander-openflighthpc 1.0.0.pre.alpha1

data/lib/commander/version.rb

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

data/spec/command_spec.rb

@@ -0,0 +1,157 @@
+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/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 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 '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

data/spec/patches/validate_inputs_spec.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'commander/patches/validate_inputs'
+
+# These specs inspired by those in Commander gem in `spec/runner_spec.rb`.
+
+RSpec.describe Commander::Patches::ValidateInputs do
+  include Commander::Delegates
+
+  def mock_patch_terminal
+    @input = StringIO.new
+    @output = StringIO.new
+    $terminal = HighLine.new @input, @output
+  end
+
+  def create_test_patch_command
+    command :test do |c|
+      c.syntax = 'metal test ARG1 ARG2 [OPTIONAL_ARG3]'
+      c.description = 'test description'
+      c.example 'description', 'command'
+      c.option '-o', '--some-option', 'Some option that does things'
+      c.when_called do |args, _options|
+        format('test %<foo>s', foo: args.join(' '))
+      end
+    end
+    @command = command :test
+  end
+
+  def create_multi_word_test_command
+    command :'test do' do |c|
+      c.syntax = 'metal test do ARG1 ARG2'
+      c.when_called do |args, _options|
+        format('test do %<foo>s', foo: args.join(' '))
+      end
+    end
+    @command = command :'test do'
+  end
+
+  before do
+    $stderr = StringIO.new
+    mock_patch_terminal
+    create_test_patch_command
+  end
+
+  describe '#call' do
+    describe 'validating passed arguments against syntax' do
+      it 'raises if too many arguments given' do
+        expect do
+          command(:test).call(['one', 'two', 'three', 'four'])
+        end.to raise_error(Commander::Patches::CommandUsageError)
+      end
+
+      it 'raises if too few arguments given' do
+        expect do
+          command(:test).call(['one'])
+        end.to raise_error(Commander::Patches::CommandUsageError)
+      end
+
+      it 'proceeds as normal if valid number of arguments given' do
+        expect(
+          command(:test).call(['one', 'two', 'three'])
+        ).to eql('test one two three')
+      end
+
+      describe 'when multi-word command' do
+        before do
+          create_multi_word_test_command
+        end
+
+        it 'raises if too few arguments given' do
+          expect do
+            command(:'test do').call
+          end.to raise_error(Commander::Patches::CommandUsageError)
+        end
+
+        it 'proceeds as normal if valid number of arguments given' do
+          expect(
+            command(:'test do').call(['one', 'two'])
+          ).to eql('test do one two')
+        end
+      end
+    end
+  end
+end