commander-openflighthpc 2.0.1 → 2.2.0

data/lib/commander/patches/priority_sort.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Commander
-  module Patches
-    module PrioritySort
-      attr_accessor :priority
-
-      def <=>(other)
-        # Different classes can not be compared and thus are considered
-        # equal in priority
-        return 0 unless self.class == other.class
-
-        # Sort firstly based on the commands priority
-        comp = (self.priority || 0) <=> (other.priority || 0)
-
-        # Fall back on name comparison if priority is equal
-        comp == 0 ? self.name <=> other.name : comp
-      end
-    end
-  end
-end

data/lib/commander/patches/validate_inputs.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-module Commander
-  module Patches
-    # An error in the usage of a command; will happen in practise and error
-    # message should be shown along with command usage info.
-    class CommandUsageError < StandardError; end
-
-    module ValidateInputs
-      # This is used to switch the Patch off during the original test of
-      # Commander. It is VERY MUCH a hack but it works
-      PatchEnabled = true
-
-      def call(args = [])
-        return super unless PatchEnabled
-        return super if syntax_parts[0..1] == ['commander', 'help']
-
-        # Use defined syntax to validate how many args this command can be
-        # passed.
-        assert_correct_number_of_args!(args)
-
-        # Invoke original method.
-        super(args)
-      end
-
-      private
-
-      def assert_correct_number_of_args!(args)
-        return if primary_command_word == 'help'
-        too_many = too_many_args?(args)
-        if too_many && sub_command_group?
-          raise CommandUsageError, "unrecognised command. Please select from the following:"
-        elsif too_many
-          raise CommandUsageError, "excess arguments for command '#{primary_command_word}'"
-        elsif too_few_args?(args)
-          raise CommandUsageError, "insufficient arguments for command '#{primary_command_word}'"
-        end
-      end
-
-      def syntax_parts
-        @syntax_parts ||= syntax.split.tap do |parts|
-          while part = parts.shift do
-            break if part == primary_command_word || parts.length == 0
-          end
-        end
-      end
-
-      def primary_command_word
-        name.split.last
-      end
-
-      def total_argument_count
-        syntax_parts.length
-      end
-
-      def optional_argument_count
-        syntax_parts.select do |part|
-          part[0] == '[' && part[-1] == ']'
-        end.length
-      end
-
-      def variable_arg?
-        syntax_parts.any? {|part| part[-4..-1] == '...]' || part[-3..-1] == '...'}
-      end
-
-      def required_argument_count
-        total_argument_count - optional_argument_count
-      end
-
-      def too_many_args?(args)
-        !variable_arg? && args.length > total_argument_count
-      end
-
-      def too_few_args?(args)
-        args.length < required_argument_count
-      end
-    end
-  end
-end

data/lib/commander/platform.rb

@@ -1,7 +0,0 @@
-module Commander
-  module Platform
-    def self.jruby?
-      defined?(RUBY_ENGINE) && (RUBY_ENGINE == 'jruby')
-    end
-  end
-end

data/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/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/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/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/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/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