pry 0.9.9.6pre2-i386-mingw32 → 0.9.10-i386-mingw32

data/lib/pry/command.rb

@@ -68,15 +68,12 @@ class Pry
       end
 
       # Create a new command with the given properties.
-      #
-      # @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.
-      # @param Proc &block  (optional, a block, used for BlockCommands)
-      #
-      # @return Class (a subclass of Pry::Command)
-      #
+      # @param [String, Regex] match The thing that triggers this command
+      # @param [String] description The description to appear in `help`
+      # @param [Hash] options Behavioral options (see {Pry::CommandSet#command})
+      # @param [Module] helpers A module of helper functions to be included.
+      # @yield optional, used for BlockCommands
+      # @return [Class] (a subclass of {Pry::Command})
       def subclass(match, description, options, helpers, &block)
         klass = Class.new(self)
         klass.send(:include, helpers)
@@ -88,9 +85,8 @@ class Pry
       end
 
       # Should this command be called for the given line?
-      #
-      # @param String  a line input at the REPL
-      # @return Boolean
+      # @param [String] val A line input at the REPL
+      # @return [Boolean]
       def matches?(val)
         command_regex =~ val
       end
@@ -109,8 +105,8 @@ class Pry
       #   /\.*(.*)/.match_score("...foo") #=> 3
       #   'hi'.match_score("hi there") #=> 2
       #
-      # @param String  a line input at the REPL
-      # @return Fixnum
+      # @param [String] val A line input at the REPL
+      # @return [Fixnum]
       def match_score(val)
         if command_regex =~ val
           Regexp.last_match.size > 1 ? Regexp.last_match.begin(1) : Regexp.last_match.end(0)
@@ -147,25 +143,26 @@ class Pry
       # This is usually auto-generated from directory naming, but it can be
       # manually overridden if necessary.
       def group(name=nil)
-        @group = name if name
-        @group ||=(
-          case Pry::Method(block).source_file
-          when %r{/pry/.*_commands/(.*).rb}
-            $1.capitalize.gsub(/_/, " ")
-          when %r{(pry-[\w_]+)-([\d\.]+)}
-            name, version = $1, $2
-            "#{name.to_s} (v#{version.to_s})"
-          when /pryrc/
-            "~/.pryrc"
-          else
-            "(other)"
-          end
-        )
+        @group ||= if name
+                     name
+                   else
+                     case Pry::Method(block).source_file
+                     when %r{/pry/.*_commands/(.*).rb}
+                       $1.capitalize.gsub(/_/, " ")
+                     when %r{(pry-\w+)-([\d\.]+([\w\d\.]+)?)}
+                       name, version = $1, $2
+                       "#{name.to_s} (v#{version.to_s})"
+                     when /pryrc/
+                       "~/.pryrc"
+                     else
+                       "(other)"
+                     end
+                   end
       end
     end
 
     # Properties of one execution of a command (passed by {Pry#run_command} as a hash of
-    # context and expanded in {#initialize}
+    # context and expanded in `#initialize`
     attr_accessor :output
     attr_accessor :target
     attr_accessor :captures
@@ -214,8 +211,7 @@ class Pry
 
 
     # Instantiate a command, in preparation for calling it.
-    #
-    # @param Hash context  The runtime context to use with this command.
+    # @param [Hash] context The runtime context to use with this command.
     def initialize(context={})
       self.context      = context
       self.target       = context[:target]
@@ -225,9 +221,20 @@ class Pry
       self._pry_        = context[:pry_instance]
     end
 
-    # The value of {self} inside the {target} binding.
+    # @return [Object] The value of `self` inside the `target` binding.
     def target_self; target.eval('self'); end
 
+    # @return [Hash] Pry commands can store arbitrary state
+    #   here. This state persists between subsequent command invocations.
+    #   All state saved here is unique to the command, it does not
+    #   need to be namespaced.
+    # @example
+    #   state.my_state = "my state"  # this will not conflict with any
+    #                                # `state.my_state` used in another command.
+    def state
+      _pry_.command_state[match] ||= OpenStruct.new
+    end
+
     # Revaluate the string (str) and perform interpolation.
     # @param [String] str The string to reevaluate with interpolation.
     #
@@ -244,8 +251,6 @@ class Pry
 
     # Display a warning if a command collides with a local/method in
     # 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_collision(command_match, arg_string)
       collision_type = target.eval("defined?(#{command_match})")
       collision_type ||= 'local-variable' if arg_string.match(%r{\A\s*[-+*/%&|^]*=})
@@ -257,15 +262,20 @@ class Pry
     rescue Pry::RescuableException
     end
 
-    # Extract necessary information from a line that Command.matches? this command.
+    # Extract necessary information from a line that Command.matches? this
+    # command.
+    #
+    # Returns an array of four elements:
     #
-    # @param String  the line of input
-    # @return [
-    #   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
-    # ]
+    # ```
+    #  [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]  the arguments obtained by splitting the arg_string
+    # ```
+    #
+    # @param [String] val The line of input
+    # @return [Array]
     def tokenize(val)
       val.replace(interpolate_string(val)) if command_options[:interpolate]
 
@@ -294,9 +304,8 @@ class Pry
     end
 
     # Process a line that Command.matches? this command.
-    #
-    # @param String  the line to process
-    # @return  Object or Command::VOID_VALUE
+    # @param [String] line The line to process
+    # @return [Object, Command::VOID_VALUE]
     def process_line(line)
       command_match, arg_string, captures, args = tokenize(line)
 
@@ -316,7 +325,7 @@ class Pry
     #   Note that if we find the '| do' or '| {' we delete this and the
     #   elements following it from `arg_string`.
     def pass_block(arg_string)
-      block_index = arg_string.rindex /\| *(?:do|\{)/
+      block_index = arg_string.rindex(/\| *(?:do|\{)/)
 
       return if !block_index
 
@@ -338,12 +347,14 @@ class Pry
 
     private :pass_block
 
-    # Run the command with the given {args}.
+    # Run the command with the given `args`.
     #
-    # This is a public wrapper around {#call} which ensures all preconditions are met.
+    # This is a public wrapper around `#call` which ensures all preconditions
+    # are met.
     #
-    # @param *[String]  the arguments to pass to this command.
-    # @return Object  the return value of the {#call} method, or Command::VOID_VALUE
+    # @param [Array<String>] args The arguments to pass to this command.
+    # @return [Object] The return value of the `#call` method, or
+    #   {Command::VOID_VALUE}.
     def call_safely(*args)
       unless dependencies_met?
         gems_needed = Array(command_options[:requires_gem])
@@ -371,10 +382,9 @@ class Pry
 
     private
 
-    # Run the {#call} method and all the registered hooks.
-    #
-    # @param *String  the arguments to #{call}
-    # @return Object  the return value from #{call}
+    # Run the `#call` method and all the registered hooks.
+    # @param [Array<String>] args The arguments to `#call`
+    # @return [Object] The return value from `#call`
     def call_with_hooks(*args)
       self.class.hooks[:before].each do |block|
         instance_exec(*args, &block)
@@ -390,10 +400,9 @@ class Pry
     end
 
     # Fix the number of arguments we pass to a block to avoid arity warnings.
-    #
-    # @param Number  the arity of the block
-    # @param Array   the arguments to pass
-    # @return Array  a (possibly shorter) array of the arguments to pass
+    # @param [Fixnum] arity The arity of the block
+    # @param [Array] args The arguments to pass
+    # @return [Array] A (possibly shorter) array of the arguments to pass
     def correct_arg_arity(arity, args)
       case
       when arity < 0
@@ -417,9 +426,8 @@ class Pry
     alias_method :opts, :context
 
     # Call the block that was registered with this command.
-    #
-    # @param *String  the arguments passed
-    # @return Object  the return value of the block
+    # @param [Array<String>] args The arguments passed
+    # @return [Object] The return value of the block
     def call(*args)
       instance_exec(*correct_arg_arity(block.arity, args), &block)
     end
@@ -431,24 +439,26 @@ class Pry
 
   # A super-class ofr Commands with structure.
   #
-  # This class implements the bare-minimum functionality that a command should have,
-  # namely a --help switch, and then delegates actual processing to its subclasses.
+  # This class implements the bare-minimum functionality that a command should
+  # have, namely a --help switch, and then delegates actual processing to its
+  # subclasses.
   #
-  # Create subclasses using {Pry::CommandSet#create_command}, and override the {options(opt)} method
-  # to set up an instance of Slop, and the {process} method to actually run the command. If
-  # necessary, you can also override {setup} which will be called before {options}, for example to
-  # require any gems your command needs to run, or to set up state.
+  # Create subclasses using {Pry::CommandSet#create_command}, and override the
+  # `options(opt)` method to set up an instance of Slop, and the `process`
+  # method to actually run the command. If necessary, you can also override
+  # `setup` which will be called before `options`, for example to require any
+  # gems your command needs to run, or to set up state.
   class ClassCommand < Command
 
     attr_accessor :opts
     attr_accessor :args
 
-    # Set up {opts} and {args}, and then call {process}
+    # Set up `opts` and `args`, and then call `process`.
     #
     # This function will display help if necessary.
     #
-    # @param *String  the arguments passed
-    # @return Object  the return value of {process} or VOID_VALUE
+    # @param [Array<String>] args The arguments passed
+    # @return [Object] The return value of `process` or VOID_VALUE
     def call(*args)
       setup
 
@@ -477,7 +487,7 @@ class Pry
       end
     end
 
-    # A function called just before {options(opt)} as part of {call}.
+    # A function called just before `options(opt)` as part of `call`.
     #
     # This function can be used to set up any context your command needs to run, for example
     # requiring gems, or setting default values for options.
@@ -493,7 +503,7 @@ class Pry
     #
     # NOTE: please don't do anything side-effecty in the main part of this method,
     # as it may be called by Pry at any time for introspection reasons. If you need
-    # to set up default values, use {setup} instead.
+    # to set up default values, use `setup` instead.
     #
     # @example
     #  def options(opt)
@@ -506,11 +516,12 @@ class Pry
 
     # The actual body of your command should go here.
     #
-    # The {opts} mehod can be called to get the options that Slop has passed,
-    # and {args} gives the remaining, unparsed arguments.
+    # The `opts` mehod can be called to get the options that Slop has passed,
+    # and `args` gives the remaining, unparsed arguments.
     #
-    # The return value of this method is discarded unless the command was created
-    # with :keep_retval => true, in which case it is returned to the repl.
+    # The return value of this method is discarded unless the command was
+    # created with `:keep_retval => true`, in which case it is returned to the
+    # repl.
     #
     # @example
     #   def process

data/lib/pry/command_set.rb

@@ -92,7 +92,7 @@ class Pry
     # @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.
+    # @yield The class body's definition.
     #
     # @example
     #   Pry::Commands.create_command "echo", "echo's the input", :shellwords => false do
@@ -153,7 +153,7 @@ class Pry
     end
 
     # Add a given command object to this set.
-    # @param Command the subclass of Pry::Command you wish to add.
+    # @param [Command] command The subclass of Pry::Command you wish to add.
     def add_command(command)
       commands[command.match] = command
     end
@@ -208,8 +208,6 @@ class Pry
     protected :find_command_by_match_or_listing
 
     # Aliases a command
-    # 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).
@@ -242,7 +240,7 @@ class Pry
 
     # 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] new_match 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
@@ -267,8 +265,8 @@ class Pry
     # Sets or gets the description for a command (replacing the old
     # description). Returns current description if no description
     # parameter provided.
-    # @param [String, Regexp] match The command match.
-    # @param [String] description The command description.
+    # @param [String, Regexp] search The command match.
+    # @param [String?] description (nil) The command description.
     # @example Setting
     #   MyCommands = Pry::CommandSet.new do
     #     desc "help", "help description"
@@ -305,8 +303,7 @@ class Pry
     end
 
     # Find a command that matches the given line
-    #
-    # @param [String]  the line that may be a command invocation
+    # @param [String] val The line that might be a command invocation
     # @return [Pry::Command, nil]
     def find_command(val)
       commands.values.select{ |c| c.matches?(val) }.sort_by{ |c| c.match_score(val) }.last
@@ -314,9 +311,8 @@ class Pry
     alias_method :[], :find_command
 
     # Find the command that the user might be trying to refer to.
-    #
-    # @param [String]  the user's search.
-    # @return [Pry::Command, nil]
+    # @param [String] search The user's search.
+    # @return [Pry::Command?]
     def find_command_for_help(search)
       find_command(search) || (begin
         find_command_by_match_or_listing(search)
@@ -326,19 +322,16 @@ class Pry
     end
 
     # Is the given line a command invocation?
-    #
-    # @param [String]
+    # @param [String] val
     # @return [Boolean]
     def valid_command?(val)
       !!find_command(val)
     end
 
     # Process the given line to see whether it needs executing as a command.
-    #
-    # @param String  the line to execute
-    # @param Hash  the context to execute the commands with
-    # @return CommandSet::Result
-    #
+    # @param [String] val The line to execute
+    # @param [Hash] context The context to execute the commands with
+    # @return [CommandSet::Result]
     def process_line(val, context={})
       if command = find_command(val)
         context = context.merge(:command_set => self)
@@ -349,7 +342,7 @@ class Pry
       end
     end
 
-    # @nodoc  used for testing
+    # @private (used for testing)
     def run_command(context, match, *args)
       command = commands[match] or raise NoCommandError.new(match, self)
       command.new(context).call_safely(*args)

data/lib/pry/completion.rb

@@ -8,7 +8,7 @@ class Pry
   module InputCompleter
 
     if Readline.respond_to?("basic_word_break_characters=")
-      Readline.basic_word_break_characters= " \t\n\"\\'`><=;|&{("
+      Readline.basic_word_break_characters = " \t\n\"\\'`><=;|&{("
     end
 
     Readline.completion_append_character = nil
@@ -43,146 +43,164 @@ class Pry
     # @param [Array<String>] commands The array of Pry commands.
     def self.build_completion_proc(target, commands=[""])
       proc do |input|
-        bind = target
-
-        case input
-        when /^(\/[^\/]*\/)\.([^.]*)$/
-          # Regexp
-          receiver = $1
-          message = Regexp.quote($2)
-
-          candidates = Regexp.instance_methods.collect{|m| m.to_s}
-          select_message(receiver, message, candidates)
-
-        when /^([^\]]*\])\.([^.]*)$/
-          # Array
-          receiver = $1
-          message = Regexp.quote($2)
-
-          candidates = Array.instance_methods.collect{|m| m.to_s}
-          select_message(receiver, message, candidates)
-
-        when /^([^\}]*\})\.([^.]*)$/
-          # Proc or Hash
-          receiver = $1
-          message = Regexp.quote($2)
-
-          candidates = Proc.instance_methods.collect{|m| m.to_s}
-          candidates |= Hash.instance_methods.collect{|m| m.to_s}
-          select_message(receiver, message, candidates)
-
-        when /^(:[^:.]*)$/
-          # Symbol
-          if Symbol.respond_to?(:all_symbols)
-            sym = $1
-            candidates = Symbol.all_symbols.collect{|s| ":" + s.id2name}
-            candidates.grep(/^#{sym}/)
-          else
-            []
-          end
-
-        when /^::([A-Z][^:\.\(]*)$/
-          # Absolute Constant or class methods
-          receiver = $1
-          candidates = Object.constants.collect{|m| m.to_s}
-          candidates.grep(/^#{receiver}/).collect{|e| "::" + e}
-
-        when /^([A-Z].*)::([^:.]*)$/
-          # Constant or class methods
-          receiver = $1
-          message = Regexp.quote($2)
-          begin
-            candidates = eval("#{receiver}.constants.collect{|m| m.to_s}", bind)
-            candidates |= eval("#{receiver}.methods.collect{|m| m.to_s}", bind)
-          rescue RescuableException
-            candidates = []
-          end
-          candidates.grep(/^#{message}/).collect{|e| receiver + "::" + e}
-
-        when /^(:[^:.]+)\.([^.]*)$/
-          # Symbol
-          receiver = $1
-          message = Regexp.quote($2)
-
-          candidates = Symbol.instance_methods.collect{|m| m.to_s}
-          select_message(receiver, message, candidates)
+        begin
+          bind = target
+
+          case input
+          when /^(\/[^\/]*\/)\.([^.]*)$/
+            # Regexp
+            receiver = $1
+            message = Regexp.quote($2)
+
+            candidates = Regexp.instance_methods.collect{|m| m.to_s}
+            select_message(receiver, message, candidates)
+
+          when /^([^\]]*\])\.([^.]*)$/
+            # Array
+            receiver = $1
+            message = Regexp.quote($2)
+
+            candidates = Array.instance_methods.collect{|m| m.to_s}
+            select_message(receiver, message, candidates)
+
+          when /^([^\}]*\})\.([^.]*)$/
+            # Proc or Hash
+            receiver = $1
+            message = Regexp.quote($2)
+
+            candidates = Proc.instance_methods.collect{|m| m.to_s}
+            candidates |= Hash.instance_methods.collect{|m| m.to_s}
+            select_message(receiver, message, candidates)
+
+          when /^(:[^:.]*)$/
+            # Symbol
+            if Symbol.respond_to?(:all_symbols)
+              sym        = Regexp.quote($1)
+              candidates = Symbol.all_symbols.collect{|s| ":" + s.id2name}
+
+              candidates.grep(/^#{sym}/)
+            else
+              []
+            end
 
-        when /^(-?(0[dbo])?[0-9_]+(\.[0-9_]+)?([eE]-?[0-9]+)?)\.([^.]*)$/
-          # Numeric
-          receiver = $1
-          message = Regexp.quote($5)
+          when /^::([A-Z][^:\.\(]*)$/
+            # Absolute Constant or class methods
+            receiver = $1
+            candidates = Object.constants.collect{|m| m.to_s}
+            candidates.grep(/^#{receiver}/).collect{|e| "::" + e}
 
-          begin
-            candidates = eval(receiver, bind).methods.collect{|m| m.to_s}
-          rescue RescuableException
-            candidates = []
-          end
-          select_message(receiver, message, candidates)
+          when /^([A-Z].*)::([^:.]*)$/
+            # Constant or class methods
+            receiver = $1
+            message = Regexp.quote($2)
+            begin
+              candidates = eval("#{receiver}.constants.collect{|m| m.to_s}", bind)
+              candidates |= eval("#{receiver}.methods.collect{|m| m.to_s}", bind)
+            rescue RescuableException
+              candidates = []
+            end
+            candidates.grep(/^#{message}/).collect{|e| receiver + "::" + e}
 
-        when /^(-?0x[0-9a-fA-F_]+)\.([^.]*)$/
-          # Numeric(0xFFFF)
-          receiver = $1
-          message = Regexp.quote($2)
+          when /^(:[^:.]+)\.([^.]*)$/
+            # Symbol
+            receiver = $1
+            message = Regexp.quote($2)
 
-          begin
-            candidates = eval(receiver, bind).methods.collect{|m| m.to_s}
-          rescue RescuableException
-            candidates = []
-          end
-          select_message(receiver, message, candidates)
+            candidates = Symbol.instance_methods.collect{|m| m.to_s}
+            select_message(receiver, message, candidates)
 
-        when /^(\$[^.]*)$/
-          regmessage = Regexp.new(Regexp.quote($1))
-          candidates = global_variables.collect{|m| m.to_s}.grep(regmessage)
+          when /^(-?(0[dbo])?[0-9_]+(\.[0-9_]+)?([eE]-?[0-9]+)?)\.([^.]*)$/
+            # Numeric
+            receiver = $1
+            message = Regexp.quote($5)
 
-        when /^([^."].*)\.([^.]*)$/
-          # variable
-          receiver = $1
-          message = Regexp.quote($2)
+            begin
+              candidates = eval(receiver, bind).methods.collect{|m| m.to_s}
+            rescue RescuableException
+              candidates = []
+            end
+            select_message(receiver, message, candidates)
 
-          gv = eval("global_variables", bind).collect{|m| m.to_s}
-          lv = eval("local_variables", bind).collect{|m| m.to_s}
-          cv = eval("self.class.constants", bind).collect{|m| m.to_s}
+          when /^(-?0x[0-9a-fA-F_]+)\.([^.]*)$/
+            # Numeric(0xFFFF)
+            receiver = $1
+            message = Regexp.quote($2)
 
-          if (gv | lv | cv).include?(receiver) or /^[A-Z]/ =~ receiver && /\./ !~ receiver
-            # foo.func and foo is local var. OR
-            # Foo::Bar.func
             begin
-              candidates = eval("#{receiver}.methods", bind).collect{|m| m.to_s}
+              candidates = eval(receiver, bind).methods.collect{|m| m.to_s}
             rescue RescuableException
               candidates = []
             end
-          else
-            # func1.func2
-            candidates = []
-            ObjectSpace.each_object(Module){|m|
+            select_message(receiver, message, candidates)
+
+          when /^(\$[^.]*)$/
+            regmessage = Regexp.new(Regexp.quote($1))
+            candidates = global_variables.collect{|m| m.to_s}.grep(regmessage)
+
+          when /^([^."].*)\.([^.]*)$/
+            # variable
+            receiver = $1
+            message = Regexp.quote($2)
+
+            gv = eval("global_variables", bind).collect{|m| m.to_s}
+            lv = eval("local_variables", bind).collect{|m| m.to_s}
+            cv = eval("self.class.constants", bind).collect{|m| m.to_s}
+
+            if (gv | lv | cv).include?(receiver) or /^[A-Z]/ =~ receiver && /\./ !~ receiver
+              # foo.func and foo is local var. OR
+              # Foo::Bar.func
               begin
-                name = m.name.to_s
+                candidates = eval("#{receiver}.methods", bind).collect{|m| m.to_s}
               rescue RescuableException
-                name = ""
+                candidates = []
               end
-              next if name != "IRB::Context" and
-              /^(IRB|SLex|RubyLex|RubyToken)/ =~ name
-              candidates.concat m.instance_methods(false).collect{|x| x.to_s}
-            }
-            candidates.sort!
-            candidates.uniq!
-          end
-          select_message(receiver, message, candidates)
+            else
+              # func1.func2
+              candidates = []
+              ObjectSpace.each_object(Module){|m|
+                begin
+                  name = m.name.to_s
+                rescue RescuableException
+                  name = ""
+                end
+                next if name != "IRB::Context" and
+                /^(IRB|SLex|RubyLex|RubyToken)/ =~ name
+
+                # jruby doesn't always provide #instance_methods() on each
+                # object.
+                if m.respond_to?(:instance_methods)
+                  candidates.concat m.instance_methods(false).collect{|x| x.to_s}
+                end
+              }
+              candidates.sort!
+              candidates.uniq!
+            end
+            select_message(receiver, message, candidates)
 
-        when /^\.([^.]*)$/
-          # unknown(maybe String)
+          when /^\.([^.]*)$/
+            # unknown(maybe String)
 
-          receiver = ""
-          message = Regexp.quote($1)
+            receiver = ""
+            message = Regexp.quote($1)
 
-          candidates = String.instance_methods(true).collect{|m| m.to_s}
-          select_message(receiver, message, candidates)
+            candidates = String.instance_methods(true).collect{|m| m.to_s}
+            select_message(receiver, message, candidates)
 
-        else
-          candidates = eval("methods | private_methods | local_variables | self.class.constants", bind).collect{|m| m.to_s}
+          else
+            candidates = eval(
+              "methods | private_methods | local_variables | " \
+                "self.class.constants | instance_variables",
+              bind
+            ).collect{|m| m.to_s}
+
+            if eval("respond_to?(:class_variables)", bind)
+              candidates += eval("class_variables", bind).collect { |m| m.to_s }
+            end
 
-          (candidates|ReservedWords|commands).grep(/^#{Regexp.quote(input)}/)
+            (candidates|ReservedWords|commands).grep(/^#{Regexp.quote(input)}/)
+          end
+        rescue RescuableException
+          []
         end
       end
     end