commander-openflighthpc 1.0.0.pre.alpha1

data/lib/commander/patches/option_defaults.rb

@@ -0,0 +1,23 @@
+module Commander
+  module Patches
+    module OptionDefaults
+      # I can't remember what this patch does, but I found it in the code
+      # base. It is better if this magic is kept separate
+      def option(*args, &block)
+        default = nil
+        args.delete_if do |v|
+          if v.is_a?(Hash) && v.key?(:default)
+            default = v[:default]
+            true
+          else
+            false
+          end
+        end
+        opt = super
+        opt.tap do |h|
+          h.merge!( { default: default } ) unless default.nil?
+        end
+      end
+    end
+  end
+end

data/lib/commander/patches/validate_inputs.rb

@@ -0,0 +1,76 @@
+# 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'
+        if too_many_args?(args)
+          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

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

data/lib/commander/runner.rb

@@ -0,0 +1,493 @@
+module Commander
+  class Runner
+    #--
+    # Exceptions
+    #++
+
+    class CommandError < StandardError; end
+    class InvalidCommandError < CommandError; end
+
+    ##
+    # Array of commands.
+
+    attr_reader :commands
+
+    ##
+    # Global options.
+
+    attr_reader :options
+
+    ##
+    # Hash of help formatter aliases.
+
+    attr_reader :help_formatter_aliases
+
+    ##
+    # Initialize a new command runner. Optionally
+    # supplying _args_ for mocking, or arbitrary usage.
+
+    def initialize(args = ARGV)
+      @args, @commands, @aliases, @options = args, {}, {}, []
+      @help_formatter_aliases = help_formatter_alias_defaults
+      @program = program_defaults
+      @always_trace = false
+      @never_trace = false
+      @silent_trace = false
+      @error_handler = nil
+      create_default_commands
+    end
+
+    ##
+    # Return singleton Runner instance.
+
+    def self.instance
+      @singleton ||= new
+    end
+
+    ##
+    # Run command parsing and execution process.
+
+    def run!
+      trace = @always_trace || false
+      require_program :version, :description
+      trap('INT') { abort program(:int_message) } if program(:int_message)
+      trap('INT') { program(:int_block).call } if program(:int_block)
+      global_option('-h', '--help', 'Display help documentation') do
+        args = @args - %w(-h --help)
+        command(:help).run(*args)
+        return
+      end
+      global_option('--version', 'Display version information') do
+        say version
+        return
+      end
+      global_option('--trace', 'Display backtrace when an error occurs') { trace = true } unless @never_trace || @always_trace
+      parse_global_options
+      remove_global_options options, @args
+      if trace
+        run_active_command
+      else
+        begin
+          run_active_command
+        rescue InvalidCommandError => e
+          error_handler&.call(e) ||
+            abort("#{e}. Use --help for more information")
+        rescue \
+          OptionParser::InvalidOption,
+          OptionParser::InvalidArgument,
+          OptionParser::MissingArgument => e
+          error_handler&.call(e) ||
+            abort(e.to_s)
+        rescue => e
+          error_handler&.call(e) ||
+            if @never_trace || @silent_trace
+              abort("error: #{e}.")
+            else
+              abort("error: #{e}. Use --trace to view backtrace")
+            end
+        end
+      end
+    end
+
+    ##
+    # Return program version.
+
+    def version
+      format('%s %s', program(:name), program(:version))
+    end
+
+    ##
+    # Enable tracing on all executions (bypasses --trace)
+
+    def always_trace!
+      @always_trace = true
+      @never_trace = false
+      @silent_trace = false
+    end
+
+    ##
+    # Hide the trace option from the help menus and don't add it as a global option
+
+    def never_trace!
+      @always_trace = false
+      @never_trace = true
+      @silent_trace = false
+    end
+
+    ##
+    # Includes the trace option in the help but not in the error message
+
+    def silent_trace!
+      @always_trace = false
+      @never_trace = false
+      @silent_trace = true
+    end
+
+    ##
+    # Set a handler to be used for advanced exception handling
+
+    def error_handler(&block)
+      @error_handler = block if block
+      @error_handler
+    end
+
+    ##
+    # Assign program information.
+    #
+    # === Examples
+    #
+    #   # Set data
+    #   program :name, 'Commander'
+    #   program :version, Commander::VERSION
+    #   program :description, 'Commander utility program.'
+    #   program :help, 'Copyright', '2008 TJ Holowaychuk'
+    #   program :help, 'Anything', 'You want'
+    #   program :int_message 'Bye bye!'
+    #   program :help_formatter, :compact
+    #   program :help_formatter, Commander::HelpFormatter::TerminalCompact
+    #
+    #   # Get data
+    #   program :name # => 'Commander'
+    #
+    # === Keys
+    #
+    #   :version         (required) Program version triple, ex: '0.0.1'
+    #   :description     (required) Program description
+    #   :name            Program name, defaults to basename of executable
+    #   :help_formatter  Defaults to Commander::HelpFormatter::Terminal
+    #   :help            Allows addition of arbitrary global help blocks
+    #   :help_paging     Flag for toggling help paging
+    #   :int_message     Message to display when interrupted (CTRL + C)
+    #
+
+    def program(key, *args, &block)
+      if key == :help && !args.empty?
+        @program[:help] ||= {}
+        @program[:help][args.first] = args.at(1)
+      elsif key == :help_formatter && !args.empty?
+        @program[key] = (@help_formatter_aliases[args.first] || args.first)
+      elsif block
+        @program[key] = block
+      else
+        unless args.empty?
+          @program[key] = args.count == 1 ? args[0] : args
+        end
+        @program[key]
+      end
+    end
+
+    ##
+    # Creates and yields a command instance when a block is passed.
+    # Otherwise attempts to return the command, raising InvalidCommandError when
+    # it does not exist.
+    #
+    # === Examples
+    #
+    #   command :my_command do |c|
+    #     c.when_called do |args|
+    #       # Code
+    #     end
+    #   end
+    #
+
+    def command(name, &block)
+      yield add_command(Commander::Command.new(name)) if block
+      @commands[name.to_s]
+    end
+
+    ##
+    # Add a global option; follows the same syntax as Command#option
+    # This would be used for switches such as --version, --trace, etc.
+
+    def global_option(*args, &block)
+      switches, description = Runner.separate_switches_from_description(*args)
+      @options << {
+        args: args,
+        proc: block,
+        switches: switches,
+        description: description,
+      }
+    end
+
+    ##
+    # Alias command _name_ with _alias_name_. Optionally _args_ may be passed
+    # as if they were being passed straight to the original command via the command-line.
+
+    def alias_command(alias_name, name, *args)
+      @commands[alias_name.to_s] = command name
+      @aliases[alias_name.to_s] = args
+    end
+
+    ##
+    # Default command _name_ to be used when no other
+    # command is found in the arguments.
+
+    def default_command(name)
+      @default_command = name
+    end
+
+    ##
+    # Add a command object to this runner.
+
+    def add_command(command)
+      @commands[command.name] = command
+    end
+
+    ##
+    # Check if command _name_ is an alias.
+
+    def alias?(name)
+      @aliases.include? name.to_s
+    end
+
+    ##
+    # Check if a command _name_ exists.
+
+    def command_exists?(name)
+      @commands[name.to_s]
+    end
+
+    #:stopdoc:
+
+    ##
+    # Get active command within arguments passed to this runner.
+
+    def active_command
+      @__active_command ||= command(command_name_from_args)
+    end
+
+    ##
+    # Attempts to locate a command name from within the arguments.
+    # Supports multi-word commands, using the largest possible match.
+
+    def command_name_from_args
+      @__command_name_from_args ||= (valid_command_names_from(*@args.dup).sort.last || @default_command)
+    end
+
+    ##
+    # Returns array of valid command names found within _args_.
+
+    def valid_command_names_from(*args)
+      arg_string = args.delete_if { |value| value =~ /^-/ }.join ' '
+      commands.keys.find_all { |name| name if arg_string =~ /^#{name}\b/ }
+    end
+
+    ##
+    # Help formatter instance.
+
+    def help_formatter
+      @__help_formatter ||= program(:help_formatter).new self
+    end
+
+    ##
+    # Return arguments without the command name.
+
+    def args_without_command_name
+      removed = []
+      parts = command_name_from_args.split rescue []
+      @args.dup.delete_if do |arg|
+        removed << arg if parts.include?(arg) && !removed.include?(arg)
+      end
+    end
+
+    ##
+    # Returns hash of help formatter alias defaults.
+
+    def help_formatter_alias_defaults
+      {
+        compact: HelpFormatter::TerminalCompact,
+      }
+    end
+
+    ##
+    # Returns hash of program defaults.
+
+    def program_defaults
+      {
+        help_formatter: HelpFormatter::Terminal,
+        name: File.basename($PROGRAM_NAME),
+        help_paging: true,
+      }
+    end
+
+    ##
+    # Limit commands to those which are subcommands of the one that is active
+    def limit_commands_to_subcommands(command)
+      commands.reject! { |k, v|
+        (k.to_s == command.name) ? true : !k.to_s.start_with?("#{command.name} ")
+      }
+    end
+
+    ##
+    # Creates default commands such as 'help' which is
+    # essentially the same as using the --help switch.
+
+    def create_default_commands
+      command :help do |c|
+        c.syntax = 'commander help [command]'
+        c.description = 'Display global or [command] help documentation'
+        c.example 'Display global help', 'command help'
+        c.example "Display help for 'foo'", 'command help foo'
+        c.when_called do |args, _options|
+          UI.enable_paging if program(:help_paging)
+          @help_commands = @commands.dup
+          if args.empty?
+            @help_options = @options.reject {|o| o[:switches].first == '--trace'}
+            @help_commands.reject! { |k, v| !!v.hidden }
+            say help_formatter.render
+          else
+            command = command args.join(' ')
+            begin
+              require_valid_command command
+            rescue InvalidCommandError => e
+              error_handler&.call(e) ||
+                abort("#{e}. Use --help for more information")
+            end
+            if command.sub_command_group?
+              limit_commands_to_subcommands(command)
+              say help_formatter.render_subcommand(command)
+            else
+              say help_formatter.render_command(command)
+            end
+          end
+        end
+      end
+    end
+
+    ##
+    # Raises InvalidCommandError when a _command_ is not found.
+
+    def require_valid_command(command = active_command)
+      fail InvalidCommandError, 'invalid command', caller if command.nil?
+    end
+
+    ##
+    # Removes global _options_ from _args_. This prevents an invalid
+    # option error from occurring when options are parsed
+    # again for the command.
+
+    def remove_global_options(options, args)
+      # TODO: refactor with flipflop, please TJ ! have time to refactor me !
+      options.each do |option|
+        switches = option[:switches].dup
+        next if switches.empty?
+
+        if (switch_has_arg = switches.any? { |s| s =~ /[ =]/ })
+          switches.map! { |s| s[0, s.index('=') || s.index(' ') || s.length] }
+        end
+
+        switches = expand_optionally_negative_switches(switches)
+
+        past_switch, arg_removed = false, false
+        args.delete_if do |arg|
+          if switches.any? { |s| s == arg }
+            arg_removed = !switch_has_arg
+            past_switch = true
+          elsif past_switch && !arg_removed && arg !~ /^-/
+            arg_removed = true
+          else
+            arg_removed = true
+            false
+          end
+        end
+      end
+    end
+
+    # expand switches of the style '--[no-]blah' into both their
+    # '--blah' and '--no-blah' variants, so that they can be
+    # properly detected and removed
+    def expand_optionally_negative_switches(switches)
+      switches.reduce([]) do |memo, val|
+        if val =~ /\[no-\]/
+          memo << val.gsub(/\[no-\]/, '')
+          memo << val.gsub(/\[no-\]/, 'no-')
+        else
+          memo << val
+        end
+      end
+    end
+
+    ##
+    # Parse global command options.
+
+    def parse_global_options
+      parser = options.inject(OptionParser.new) do |options, option|
+        options.on(*option[:args], &global_option_proc(option[:switches], &option[:proc]))
+      end
+
+      options = @args.dup
+      begin
+        parser.parse!(options)
+      rescue OptionParser::InvalidOption => e
+        # Remove the offending args and retry.
+        options = options.reject { |o| e.args.include?(o) }
+        retry
+      end
+    end
+
+    ##
+    # Returns a proc allowing for commands to inherit global options.
+    # This functionality works whether a block is present for the global
+    # option or not, so simple switches such as --verbose can be used
+    # without a block, and used throughout all commands.
+
+    def global_option_proc(switches, &block)
+      lambda do |value|
+        unless active_command.nil?
+          active_command.proxy_options << [Runner.switch_to_sym(switches.last), value]
+        end
+        yield value if block && !value.nil?
+      end
+    end
+
+    ##
+    # Raises a CommandError when the program any of the _keys_ are not present, or empty.
+
+    def require_program(*keys)
+      keys.each do |key|
+        fail CommandError, "program #{key} required" if program(key).nil? || program(key).empty?
+      end
+    end
+
+    ##
+    # Return switches and description separated from the _args_ passed.
+
+    def self.separate_switches_from_description(*args)
+      switches = args.find_all { |arg| arg.to_s =~ /^-/ }
+      description = args.last if args.last.is_a?(String) && !args.last.match(/^-/)
+      [switches, description]
+    end
+
+    ##
+    # Attempts to generate a method name symbol from +switch+.
+    # For example:
+    #
+    #   -h                 # => :h
+    #   --trace            # => :trace
+    #   --some-switch      # => :some_switch
+    #   --[no-]feature     # => :feature
+    #   --file FILE        # => :file
+    #   --list of,things   # => :list
+    #
+
+    def self.switch_to_sym(switch)
+      switch.scan(/[\-\]](\w+)/).join('_').to_sym rescue nil
+    end
+
+    ##
+    # Run the active command.
+
+    def run_active_command
+      require_valid_command
+      if alias? command_name_from_args
+        active_command.run(*(@aliases[command_name_from_args.to_s] + args_without_command_name))
+      else
+        active_command.run(*args_without_command_name)
+      end
+    end
+
+    def say(*args) #:nodoc:
+      $terminal.say(*args)
+    end
+  end
+end