pry 0.9.8.4-java → 0.9.9-java

data/.gitignore

@@ -13,3 +13,4 @@ coverage/
 .rvmrc
 Gemfile.lock
 *.swp
+**/*~

data/CHANGELOG

@@ -1,3 +1,29 @@
+18/4/2012 version 0.9.9
+
+MAJOR NEW FEATURES
+* lines of input are syntax highlighted upon 'enter' keypress
+* show-source command can now show class/module sourcecode (use -a to see all monkeypatches). Hard dependency on ruby18_source_location gem in MRI 1.8
+* show-doc command can show class/module docs (use -a to see docs for all monkeypatches) Hard dependency on ruby18_source_location gem in MRI 1.8.
+* new `find-method` command, performs a recursive search in a namespace for the existence of methods. Can find methods whose names match a regex or methods which contain provided CODE! This command is like a ruby-aware 'grep', very cool (thanks swarley)
+* pry-coolline now works properly with Pry (https://github.com/pry/pry-coolline)
+* alias_command method now much more powerful, e.g: alias_command "lM", "ls -M"
+* `whereami` is now more intelligent, automatically showing entire sourcecode of current method if current context is a method (thanks robgleeson).
+
+remaining items:
+* fixed windows crashing bug when paging
+* lines ending with \ are incomplete (kudos to fowl)
+* `edit-method -n` no longer blocks (thanks misfo)s
+* show instance methods of modules by default in ls
+* docs for REPL defined methods can now be displayed using show-doc
+* autoload ruby18_source_location on mri18, when available (https://github.com/conradirwin/ruby18_source_location)
+* tab completion should work on first line now (historic bug fixed)
+* :quiet => true option added to `Pry.start`, turns off whereami
+* another easter egg added
+* show unloaded constants in yellow for ls
+* improved documentation for Pry.config options
+* improved auto indentation
+* JRuby: heuristics used to clean up 'ls' output (less internal methods polluting output)
+
 6/3/2012 version 0.9.8.4 major bugfix
 * ~/.pry_history wasnt being created (if it did not exist)! FIXED
 * `hist --save` saved colors! FIXED

data/README.markdown

@@ -33,9 +33,9 @@ these include:
 * Gist integration
 * Navigation around state (`cd`, `ls` and friends)
 * Runtime invocation (use Pry as a developer console or debugger)
-* Exotic object support (BasicObject ins
-* tances, IClasses, ...)
-* A Powerful and flexible command system* Ability to view and replay history
+* Exotic object support (BasicObject instances, IClasses, ...)
+* A Powerful and flexible command system
+* Ability to view and replay history
 
 * Many convenience commands inspired by IPython, Smalltalk and other advanced REPLs
 * A wide-range number of [plugins](https://github.com/pry/pry/wiki/Available-plugins) that provide remote sessions, full debugging functionality, and more.

data/lib/pry.rb

@@ -9,12 +9,13 @@ require 'pry/hooks'
 class Pry
   # The default hooks - display messages when beginning and ending Pry sessions.
   DEFAULT_HOOKS = Pry::Hooks.new.add_hook(:before_session, :default) do |out, target, _pry_|
+    next if _pry_.quiet?
     # ensure we're actually in a method
     file = target.eval('__FILE__')
 
     # /unknown/ for rbx
     if file !~ /(\(.*\))|<.*>/ && file !~ /__unknown__/ && file != "" && file != "-e"  || file == Pry.eval_path
-      _pry_.run_command("whereami 5", "", target)
+      _pry_.run_command("whereami", "", target)
     end
   end
 
@@ -158,6 +159,13 @@ class Pry
   end
 end
 
+if Pry::Helpers::BaseHelpers.mri_18?
+  begin
+  require 'ruby18_source_location'
+  rescue LoadError
+  end
+end
+
 require "method_source"
 require 'shellwords'
 require "readline"

data/lib/pry/code.rb

@@ -27,6 +27,72 @@ class Pry
   # object.
   class Code
     class << self
+
+      # Determine if a string of code is a complete Ruby expression.
+      # @param [String] code The code to validate.
+      # @return [Boolean] Whether or not the code is a complete Ruby expression.
+      # @raise [SyntaxError] Any SyntaxError that does not represent incompleteness.
+      # @example
+      #   complete_expression?("class Hello") #=> false
+      #   complete_expression?("class Hello; end") #=> true
+      def complete_expression?(str)
+        if defined?(Rubinius::Melbourne19) && RUBY_VERSION =~ /^1\.9/
+          Rubinius::Melbourne19.parse_string(str, Pry.eval_path)
+        elsif defined?(Rubinius::Melbourne)
+          Rubinius::Melbourne.parse_string(str, Pry.eval_path)
+        else
+          catch(:valid) do
+            Helpers::BaseHelpers.silence_warnings do
+              eval("BEGIN{throw :valid}\n#{str}", binding, Pry.eval_path)
+            end
+          end
+        end
+
+        # Assert that a line which ends with a , or \ is incomplete.
+        str !~ /[,\\]\s*\z/
+      rescue SyntaxError => e
+        if incomplete_user_input_exception?(e)
+          false
+        else
+          raise e
+        end
+      end
+
+      # Check whether the exception indicates that the user should input more.
+      #
+      # @param [SyntaxError] the exception object that was raised.
+      # @param [Array<String>] The stack frame of the function that executed eval.
+      # @return [Boolean]
+      #
+      def incomplete_user_input_exception?(ex)
+        case ex.message
+        when /unexpected (\$end|end-of-file|END_OF_FILE)/, # mri, jruby, ironruby
+          /unterminated (quoted string|string|regexp) meets end of file/, # "quoted string" is ironruby
+          /missing 'end' for/, /: expecting '[})\]]'$/, /can't find string ".*" anywhere before EOF/, /: expecting keyword_end/, /expecting kWHEN/ # rbx
+          true
+        else
+          false
+        end
+      end
+      private :incomplete_user_input_exception?
+
+      # Retrieve the first complete expression from the passed string.
+      #
+      # @param [String, Array<String>] str The string (or array of lines) to extract the complete
+      #   expression from.
+      # @return [String, nil] The first complete expression, or `nil` if
+      #   none found.
+      def retrieve_complete_expression_from(str_or_lines)
+        lines = str_or_lines.is_a?(Array) ? str_or_lines : str_or_lines.each_line.to_a
+
+        code = ""
+        lines.each do |v|
+          code << v
+          return code if complete_expression?(code)
+        end
+        nil
+      end
+
       # Instantiate a `Code` object containing code loaded from a file or
       # Pry's line buffer.
       #
@@ -63,6 +129,16 @@ class Pry
         new(meth.source, start_line, meth.source_type)
       end
 
+      # Attempt to extract the source code for module (or class) `mod`.
+      #
+      # @param [Module, Class] mod The module (or class) of interest.
+      # @return [Code]
+      def from_module(mod, start_line=nil)
+        mod = Pry::WrappedModule(mod)
+        start_line ||= mod.source_line || 1
+        new(mod.source, start_line, :ruby)
+      end
+
       protected
         # Guess the CodeRay type of a file from its extension, or nil if
         # unknown.
@@ -173,6 +249,23 @@ class Pry
       end
     end
 
+    # Take `num_lines` from `start_line`, forward or backwards
+    #
+    # @param [Fixnum] start_line
+    # @param [Fixnum] num_lines
+    # @return [Code]
+    def take_lines(start_line, num_lines)
+      if start_line >= 0
+        start_idx = @lines.index { |l| l.last >= start_line } || @lines.length
+      else
+        start_idx = @lines.length + start_line
+      end
+
+      alter do
+        @lines = @lines.slice(start_idx, num_lines)
+      end
+    end
+
     # Remove all lines except for the `lines` up to and excluding `line_num`.
     #
     # @param [Fixnum] line_num

data/lib/pry/command.rb

@@ -14,10 +14,15 @@ class Pry
     # Properties of the command itself (as passed as arguments to
     # {CommandSet#command} or {CommandSet#create_command}).
     class << self
-      attr_accessor :block
-      attr_accessor :name
+      attr_writer :block
       attr_writer :description
       attr_writer :command_options
+      attr_writer :match
+
+      def match(arg=nil)
+        @match = arg if arg
+        @match
+      end
 
       # Define or get the command's description
       def description(arg=nil)
@@ -40,24 +45,31 @@ class Pry
         @banner = arg if arg
         @banner || description
       end
-    end
 
+      def block
+        @block || instance_method(:process) && instance_method(:process)
+      end
+    end
 
     # Make those properties accessible to instances
     def name; self.class.name; end
+    def match; self.class.match; end
     def description; self.class.description; end
     def block; self.class.block; end
     def command_options; self.class.options; end
     def command_name; command_options[:listing]; end
 
     class << self
+      def name
+        super.to_s == "" ? "#<class(Pry::Command #{match.inspect})>" : super
+      end
       def inspect
-        "#<class(Pry::Command #{name.inspect})>"
+        name
       end
 
       # Create a new command with the given properties.
       #
-      # @param String name  the name of the command
+      # @param String/Regex match  the thing that triggers this command
       # @param String description  the description to appear in {help}
       # @param Hash options  behavioural options (@see {Pry::CommandSet#command})
       # @param Module helpers  a module of helper functions to be included.
@@ -65,10 +77,10 @@ class Pry
       #
       # @return Class (a subclass of Pry::Command)
       #
-      def subclass(name, description, options, helpers, &block)
+      def subclass(match, description, options, helpers, &block)
         klass = Class.new(self)
         klass.send(:include, helpers)
-        klass.name = name
+        klass.match = match
         klass.description = description
         klass.command_options = options
         klass.block = block
@@ -115,10 +127,11 @@ class Pry
       end
 
       def command_regex
-        prefix = convert_to_regex(Pry.config.command_prefix)
+        pr = defined?(Pry.config.command_prefix) ? Pry.config.command_prefix : ""
+        prefix = convert_to_regex(pr)
         prefix = "(?:#{prefix})?" unless options[:use_prefix]
 
-        /^#{prefix}#{convert_to_regex(name)}(?!\S)/
+        /^#{prefix}#{convert_to_regex(match)}(?!\S)/
       end
 
       def convert_to_regex(obj)
@@ -180,7 +193,7 @@ class Pry
     # @example
     #   run "amend-line",  "5", 'puts "hello world"'
     def run(command_string, *args)
-      complete_string = "#{command_string} #{args.join(" ")}"
+      complete_string = "#{command_string} #{args.join(" ")}".rstrip
       command_set.process_line(complete_string, context)
     end
 
@@ -233,12 +246,12 @@ class Pry
     # the current scope.
     # @param [String] command_name_match The name of the colliding command.
     # @param [Binding] target The current binding context.
-    def check_for_command_name_collision(command_name_match, arg_string)
-      collision_type = target.eval("defined?(#{command_name_match})")
+    def check_for_command_collision(command_match, arg_string)
+      collision_type = target.eval("defined?(#{command_match})")
       collision_type ||= 'local-variable' if arg_string.match(%r{\A\s*[-+*/%&|^]*=})
 
       if collision_type
-        output.puts "#{Pry::Helpers::Text.bold('WARNING:')} Calling Pry command '#{command_name_match}'," +
+        output.puts "#{Pry::Helpers::Text.bold('WARNING:')} Calling Pry command '#{command_match}'," +
                                                           "which conflicts with a #{collision_type}.\n\n"
       end
     rescue Pry::RescuableException
@@ -248,8 +261,8 @@ class Pry
     #
     # @param String  the line of input
     # @return [
-    #   String   the command name used, or portion of line that matched the command_regex
-    #   String   a string of all the arguments (i.e. everything but the name)
+    #   String   the portion of the line that matched with the Command match
+    #   String   a string of all the arguments (i.e. everything but the match)
     #   Array    the captures caught by the command_regex
     #   Array    args the arguments got by splitting the arg_string
     # ]
@@ -285,9 +298,9 @@ class Pry
     # @param String  the line to process
     # @return  Object or Command::VOID_VALUE
     def process_line(line)
-      command_name, arg_string, captures, args = tokenize(line)
+      command_match, arg_string, captures, args = tokenize(line)
 
-      check_for_command_name_collision(command_name, arg_string) if Pry.config.collision_warning
+      check_for_command_collision(command_match, arg_string) if Pry.config.collision_warning
 
       self.arg_string = arg_string
       self.captures = captures
@@ -310,7 +323,7 @@ class Pry
       block_init_string = arg_string.slice!(block_index..-1)[1..-1]
       prime_string = "proc #{block_init_string}\n"
 
-      if !_pry_.complete_expression?(prime_string)
+      if !Pry::Code.complete_expression?(prime_string)
         block_string = _pry_.r(target, prime_string)
       else
         block_string = prime_string
@@ -335,14 +348,14 @@ class Pry
       unless dependencies_met?
         gems_needed = Array(command_options[:requires_gem])
         gems_not_installed = gems_needed.select { |g| !gem_installed?(g) }
-        output.puts "\nThe command '#{name}' is #{Helpers::Text.bold("unavailable")} because it requires the following gems to be installed: #{(gems_not_installed.join(", "))}"
+        output.puts "\nThe command '#{command_name}' is #{Helpers::Text.bold("unavailable")} because it requires the following gems to be installed: #{(gems_not_installed.join(", "))}"
         output.puts "-"
-        output.puts "Type `install-command #{name}` to install the required gems and activate this command."
+        output.puts "Type `install-command #{command_name}` to install the required gems and activate this command."
         return void
       end
 
       if command_options[:argument_required] && args.empty?
-        raise CommandError, "The command '#{name}' requires an argument."
+        raise CommandError, "The command '#{command_name}' requires an argument."
       end
 
       ret = call_with_hooks(*args)
@@ -507,6 +520,6 @@ class Pry
     #       gist_method
     #     end
     #   end
-    def process; raise CommandError, "command '#{name}' not implemented" end
+    def process; raise CommandError, "command '#{command_name}' not implemented" end
   end
 end

data/lib/pry/command_set.rb

@@ -1,7 +1,7 @@
 class Pry
   class NoCommandError < StandardError
-    def initialize(name, owner)
-      super "Command '#{name}' not found in command set #{owner}"
+    def initialize(match, owner)
+      super "Command '#{match}' not found in command set #{owner}"
     end
   end
 
@@ -27,8 +27,7 @@ class Pry
     end
 
     # Defines a new Pry command.
-    # @param [String, Regexp] name The name of the command. Can be
-    #   Regexp as well as String.
+    # @param [String, Regexp] match The start of invocations of this command.
     # @param [String] description A description of the command.
     # @param [Hash] options The optional configuration parameters.
     # @option options [Boolean] :keep_retval Whether or not to use return value
@@ -43,7 +42,7 @@ class Pry
     #   executing the command. Defaults to true.
     # @option options [String] :listing The listing name of the
     #   command. That is the name by which the command is looked up by
-    #   help and by show-command. Necessary for regex based commands.
+    #   help and by show-command. Necessary for commands with regex matches.
     # @option options [Boolean] :use_prefix Whether the command uses
     #   `Pry.config.command_prefix` prefix (if one is defined). Defaults
     #   to true.
@@ -80,18 +79,17 @@ class Pry
     #   # hello john, nice number: 10
     #   # pry(main)> help number
     #   # number-N regex command
-    def block_command(name, description="No description.", options={}, &block)
+    def block_command(match, description="No description.", options={}, &block)
       description, options = ["No description.", description] if description.is_a?(Hash)
-      options = default_options(name).merge!(options)
+      options = default_options(match).merge!(options)
 
-      commands[name] = Pry::BlockCommand.subclass(name, description, options, helper_module, &block)
+      commands[match] = Pry::BlockCommand.subclass(match, description, options, helper_module, &block)
     end
     alias_method :command, :block_command
 
     # Defines a new Pry command class.
     #
-    # @param [String, Regexp] name The name of the command. Can be
-    #   Regexp as well as String.
+    # @param [String, Regexp] match The start of invocations of this command.
     # @param [String] description A description of the command.
     # @param [Hash] options The optional configuration parameters, see {#command}
     # @param &Block  The class body's definition.
@@ -113,40 +111,40 @@ class Pry
     #     end
     #   end
     #
-    def create_command(name, description="No description.", options={}, &block)
+    def create_command(match, description="No description.", options={}, &block)
       description, options = ["No description.", description] if description.is_a?(Hash)
-      options = default_options(name).merge!(options)
+      options = default_options(match).merge!(options)
 
-      commands[name] = Pry::ClassCommand.subclass(name, description, options, helper_module, &block)
-      commands[name].class_eval(&block)
-      commands[name]
+      commands[match] = Pry::ClassCommand.subclass(match, description, options, helper_module, &block)
+      commands[match].class_eval(&block)
+      commands[match]
     end
 
     # Execute a block of code before a command is invoked. The block also
     # gets access to parameters that will be passed to the command and
     # is evaluated in the same context.
-    # @param [String, Regexp] name The name of the command.
+    # @param [String, Regexp] search The match or listing of the command.
     # @yield The block to be run before the command.
     # @example Display parameter before invoking command
     #   Pry.commands.before_command("whereami") do |n|
     #     output.puts "parameter passed was #{n}"
     #   end
-    def before_command(name, &block)
-      cmd = find_command_by_name_or_listing(name)
+    def before_command(search, &block)
+      cmd = find_command_by_match_or_listing(search)
       cmd.hooks[:before].unshift block
     end
 
     # Execute a block of code after a command is invoked. The block also
     # gets access to parameters that will be passed to the command and
     # is evaluated in the same context.
-    # @param [String, Regexp] name The name of the command.
+    # @param [String, Regexp] search The match or listing of the command.
     # @yield The block to be run after the command.
     # @example Display text 'command complete' after invoking command
     #   Pry.commands.after_command("whereami") do |n|
     #     output.puts "command complete!"
     #   end
-    def after_command(name, &block)
-      cmd = find_command_by_name_or_listing(name)
+    def after_command(search, &block)
+      cmd = find_command_by_match_or_listing(search)
       cmd.hooks[:after] << block
     end
 
@@ -154,91 +152,122 @@ class Pry
       @commands.each(&block)
     end
 
+    # Add a given command object to this set.
+    # @param Command the subclass of Pry::Command you wish to add.
+    def add_command(command)
+      commands[command.match] = command
+    end
+
     # Removes some commands from the set
-    # @param [Array<String>] names name of the commands to remove
-    def delete(*names)
-      names.each do |name|
-        cmd = find_command_by_name_or_listing(name)
-        commands.delete cmd.name
+    # @param [Array<String>] searches the matches or listings of the commands to remove
+    def delete(*searches)
+      searches.each do |search|
+        cmd = find_command_by_match_or_listing(search)
+        commands.delete cmd.match
       end
     end
 
     # Imports all the commands from one or more sets.
     # @param [Array<CommandSet>] sets Command sets, all of the commands of which
     #   will be imported.
+    # @return [Pry::CommandSet] Returns the reciever (a command set).
     def import(*sets)
       sets.each do |set|
         commands.merge! set.commands
         helper_module.send :include, set.helper_module
       end
+      self
     end
 
     # Imports some commands from a set
     # @param [CommandSet] set Set to import commands from
-    # @param [Array<String>] names Commands to import
-    def import_from(set, *names)
+    # @param [Array<String>] matches Commands to import
+    # @return [Pry::CommandSet] Returns the reciever (a command set).
+    def import_from(set, *matches)
       helper_module.send :include, set.helper_module
-      names.each do |name|
-        cmd = set.find_command_by_name_or_listing(name)
-        commands[cmd.name] = cmd
+      matches.each do |match|
+        cmd = set.find_command_by_match_or_listing(match)
+        commands[cmd.match] = cmd
       end
+      self
     end
 
-    # @param [String, Regexp] name_or_listing The name or listing name
+    # @param [String, Regexp] match_or_listing The match or listing of a command.
     #   of the command to retrieve.
     # @return [Command] The command object matched.
-    def find_command_by_name_or_listing(name_or_listing)
-      if commands[name_or_listing]
-        cmd = commands[name_or_listing]
+    def find_command_by_match_or_listing(match_or_listing)
+      if commands[match_or_listing]
+        cmd = commands[match_or_listing]
       else
-        _, cmd = commands.find { |name, command| command.options[:listing] == name_or_listing }
+        _, cmd = commands.find { |match, command| command.options[:listing] == match_or_listing }
       end
 
-      raise ArgumentError, "Cannot find a command with name: '#{name_or_listing}'!" if !cmd
+      raise ArgumentError, "Cannot find a command: '#{match_or_listing}'!" if !cmd
       cmd
     end
-    protected :find_command_by_name_or_listing
+    protected :find_command_by_match_or_listing
 
     # Aliases a command
-    # @param [String] new_name New name of the command.
-    # @param [String] old_name Old name of the command.
-    # @param [String, nil] desc New description of the command.
-    def alias_command(new_name, old_name, desc="")
-      orig_command = find_command_by_name_or_listing(old_name)
-      commands[new_name] = orig_command.dup
-      commands[new_name].name = new_name
-      commands[new_name].description = desc
+    # Note that if `desc` parameter is `nil` then the default
+    # description is used.
+    # @param [String, Regex] match The match of the alias (can be a regex).
+    # @param [String] action The action to be performed (typically
+    #   another command).
+    # @param [Hash] options The optional configuration parameters,
+    #   accepts the same as the `command` method, but also allows the
+    #   command description to be passed this way too as `:desc`
+    # @example Creating an alias for `ls -M`
+    #   Pry.config.commands.alias_command "lM", "ls -M"
+    # @example Pass explicit description (overriding default).
+    #   Pry.config.commands.alias_command "lM", "ls -M", :desc => "cutiepie"
+    def alias_command(match, action,  options={})
+      original_options = find_command(action).options.dup
+
+      options = original_options.merge!({
+                                          :desc => "Alias for `#{action}`",
+                                          :listing => match
+                                        }).merge!(options)
+
+      # ensure default description is used if desc is nil
+      desc = options.delete(:desc).to_s
+
+      c = block_command match, desc, options do |*args|
+        run action, *args
+      end
+
+      c.group "Aliases"
+
+      c
     end
 
-    # Rename a command. Accepts either actual name or listing name for
-    # the `old_name`.
-    # `new_name` must be the actual name of the new command.
-    # @param [String, Regexp] new_name The new name for the command.
-    # @param [String, Regexp] old_name The command's current name.
+    # Rename a command. Accepts either match or listing for the search.
+    #
+    # @param [String, Regexp] new_name The new match for the command.
+    # @param [String, Regexp] search The command's current match or listing.
     # @param [Hash] options The optional configuration parameters,
     #   accepts the same as the `command` method, but also allows the
     #   command description to be passed this way too.
     # @example Renaming the `ls` command and changing its description.
     #   Pry.config.commands.rename "dir", "ls", :description => "DOS friendly ls"
-    def rename_command(new_name, old_name, options={})
-      cmd = find_command_by_name_or_listing(old_name)
+    def rename_command(new_match, search, options={})
+      cmd = find_command_by_match_or_listing(search)
 
       options = {
-        :listing     => new_name,
+        :listing     => new_match,
         :description => cmd.description
       }.merge!(options)
 
-      commands[new_name] = cmd.dup
-      commands[new_name].name = new_name
-      commands[new_name].description = options.delete(:description)
-      commands[new_name].options.merge!(options)
-      commands.delete(cmd.name)
+      commands[new_match] = cmd.dup
+      commands[new_match].match = new_match
+      commands[new_match].description = options.delete(:description)
+      commands[new_match].options.merge!(options)
+      commands.delete(cmd.match)
     end
 
     # Sets or gets the description for a command (replacing the old
     # description). Returns current description if no description
     # parameter provided.
-    # @param [String, Regexp] name The command name.
+    # @param [String, Regexp] match The command match.
     # @param [String] description The command description.
     # @example Setting
     #   MyCommands = Pry::CommandSet.new do
@@ -246,8 +275,8 @@ class Pry
     #   end
     # @example Getting
     #   Pry.config.commands.desc "amend-line"
-    def desc(name, description=nil)
-      cmd = find_command_by_name_or_listing(name)
+    def desc(search, description=nil)
+      cmd = find_command_by_match_or_listing(search)
       return cmd.description if !description
 
       cmd.description = description
@@ -282,6 +311,7 @@ class Pry
     def find_command(val)
       commands.values.select{ |c| c.matches?(val) }.sort_by{ |c| c.match_score(val) }.last
     end
+    alias_method :[], :find_command
 
     # Find the command that the user might be trying to refer to.
     #
@@ -289,7 +319,7 @@ class Pry
     # @return [Pry::Command, nil]
     def find_command_for_help(search)
       find_command(search) || (begin
-        find_command_by_name_or_listing(search)
+        find_command_by_match_or_listing(search)
       rescue ArgumentError
         nil
       end)
@@ -320,21 +350,21 @@ class Pry
     end
 
     # @nodoc  used for testing
-    def run_command(context, name, *args)
-      command = commands[name] or raise NoCommandError.new(name, self)
+    def run_command(context, match, *args)
+      command = commands[match] or raise NoCommandError.new(match, self)
       command.new(context).call_safely(*args)
     end
 
     private
 
-    def default_options(name)
+    def default_options(match)
       {
         :requires_gem => [],
         :keep_retval => false,
         :argument_required => false,
         :interpolate => true,
         :shellwords => true,
-        :listing => name,
+        :listing => (String === match ? match : match.inspect),
         :use_prefix => true,
         :takes_block => false
       }