module Thunder

Provides a simple, yet powerful ability to quickly and easily tie Ruby methods with command line actions.

The syntax is very similar to Thor, so switching over should be extremely easy

Constants

VERSION: Version string for gemspec

Public Class Methods

included(base) click to toggle source

@api private Automatically extends the singleton with {ClassMethods}

# File lib/thunder.rb, line 117
def self.included(base)
  base.send :extend, ClassMethods
end

Public Instance Methods

start(args = ARGV.dup, options = {}) click to toggle source

Start the object as a command line program, processing the given arguments and using the provided options.

@param args [<String>] (ARGV) the command line arguments @param options [{Symbol => *}] ({}) the default options to use

# File lib/thunder.rb, line 15
def start(args = ARGV.dup, options = {})
  command_spec = determine_command(args)
  return unless command_spec

  if command_spec[:name] == :help && command_spec[:default_help]
    return get_help(args, options)
  end

  parsed_options = process_options(args, command_spec)
  options.merge!(parsed_options) if parsed_options

  return command_spec[:subcommand].start(args, options) if command_spec[:subcommand]

  args << options if parsed_options

  if command_spec[:params]
    min = command_spec[:params].count { |param| param.first == :req}
    if args.size < min
      ARGV.insert((ARGV.size - args.size) - 1, "help")
      puts help_command(command_spec)
      return
    end
    max = if command_spec[:params].map(&:first).include?(:rest)
      nil
    else
      command_spec[:params].size
    end
    if !max.nil? && args.size > max
      ARGV.insert((ARGV.size - args.size) - 1, "help")
      puts help_command(command_spec)
      return
    end
  end
  return send command_spec[:name], *args
end

Protected Instance Methods

determine_command(args) click to toggle source

Determine the command to use from the given arguments

@param args [<String>] the arguments to process @return [Hash,nil] the command specification for the given arguments,

or nil if there is no appropriate command

# File lib/thunder.rb, line 57
def determine_command(args)
  if args.empty?
    return self.class.thunder[:commands][self.class.thunder[:default_command]]
  end
  command_name = args.first.to_sym
  command_spec = self.class.thunder[:commands][command_name]
  if command_spec
    args.shift
  else
    command_spec = self.class.thunder[:commands][self.class.thunder[:default_command]]
  end
  return command_spec
end

get_help(args, options) click to toggle source

get help on the provided subjects

@param args [<String>] the arguments list @param options [Hash] any included options

# File lib/thunder.rb, line 90
def get_help(args, options)
  if args.empty?
    puts help_list(self.class.thunder[:commands])
  else
    puts help_command(determine_command(args))
  end
end

help_command(command_spec) click to toggle source

Render detailed help on a specific command

@param command_spec [Hash] the command to render detailed help for @return [String] the rendered help

# File lib/thunder.rb, line 110
def help_command(command_spec)
  self.class.get_help_formatter.help_command(command_spec)
end

help_list(commands) click to toggle source

Render a usage list of the given commands

@param commands [<Hash>] the commands to list @return [String] the rendered help

# File lib/thunder.rb, line 102
def help_list(commands)
  self.class.get_help_formatter.help_list(commands)
end

process_options(args, command_spec) click to toggle source

Process command line options from the given argument list

@param args [<String>] the argument list to process @param command_spec [Hash] the command specification to use @return [{Symbol => *},nil] the options

# File lib/thunder.rb, line 76
def process_options(args, command_spec)
  return nil unless command_spec[:options]

  unless self.class.thunder[:options_processor]
    require File.expand_path("../thunder/options/optparse", __FILE__)
    self.class.thunder[:options_processor] = Thunder::OptParseAdapter
  end
  self.class.thunder[:options_processor].process_options(args, command_spec)
end