Ruby custom shell with custom commands

There's quite a bit that goes into creating a robust REPL, but there are a few optimizations you can take to simplify what you've got here.

1. Create a separate Runner class that holds all of your commands. Use methods and instance_methods to get a list of supported commands without maintaining a separate list.
2. Check whether a command is supported, then call the method directly rather than using a case statement.
3. Capture ctrl+c to exit your loop cleanly.

class Shell
  class Runner
    def supported_method?(method)
      # This will return an array of the instance methods that are not provided by ancestors
      (methods - Object.instance_methods).include?(method.to_sym)
    end

    def help
      puts "[TODO: Help info]"
    end

    def exit
      system "clear"
    end
  end

  def self.start
    runner = Runner.new
    loop do 
      print (">> ")
      input = gets.chomp
      if runner.supported_method?(input)
        runner.send(input)
      else 
        puts("Unknown commands: #{input}\nType \"help\" for more info.")
      end
    end
  rescue SystemExit, Interrupt, IRB::Abort
    puts "\nShutting down."
  end
end

Here's one way to do this:

• Make a Command class, with an inherited hook that registers the subclass in the Command
• Make make each command a subclass of Command, with a method that produces an OptionParser for that command, a method that produces a short description, and another method that accepts args and executes the command
• In your REPL, command_name, *agrs = Shellwords.shellsplit(line), find the registered command that matches the name, get its OptionParser and run it on args, then invoke the command's executor method
• For help, just iterate on all the registered commands and get their descriptions
• For help <command>, just get the command's OptionParser, then display its help
• Use the readline module instead of gets so your users don't curse at you

EDIT: Here's the barebones example:

require 'optparse'
require 'shellwords'
require 'readline'

class Command
  @commands = {}

  def self.inherited(klass)
    klass.new.then { |instance| @commands[instance.name] = instance }
  end

  def self.commands
    @commands
  end

  def name
    self.class.to_s.downcase
  end

  def opts(parser)
    parser.program_name = name
  end

  def args; (0..Float::Infinity); end
end

class BangShell
  def self.start
    while line = Readline.readline("! ", true)
      name, *args = Shellwords.shellsplit(line)
      command = Command.commands[name]
      unless command
        STDERR.puts "Error: Don't know about #{name}!"
        next
      end
      command.opts(opts = OptionParser.new)
      opts.parse!(args, into: options = {})
      unless command.args === args.length
        STDERR.puts "Error: Invalid number of arguments for #{name}!"
        next
      end
      if options.empty?           # this is Ruby being weird about **; but I think it's changing in 3.0
        command.call(*args)
      else
        command.call(*args, **options)
      end
    end
  end
end

class Echo < Command
  def call(*args, n: false)
    print args.join(' ')
    puts unless n
  end

  def description
    "Echoes arguments to console"
  end

  def opts(parser)
    super
    parser.on('-n', 'Do not emit newline')
  end
end

class Help < Command
  def call(name=nil)
    if name
      command = Command.commands[name]
      unless command
        STDERR.puts "Error: Don't know about #{name}!"
        return
      end
      puts command.opts(OptionParser.new)
    else
      puts "Commands:"
      Command.commands.each do |name, command|
        puts command.name.ljust(20) + command.description
      end
    end
  end

  def description
    "Shows help"
  end

  def args; (0..1); end
end

BangShell.start