pry 0.10.pre.1-java → 0.10.0.pre2-java

data/lib/pry/default_commands/hist.rb

@@ -1,120 +0,0 @@
-class Pry
-  module DefaultCommands
-    Hist = Pry::CommandSet.new do
-
-      create_command "hist", "Show and replay Readline history. Aliases: history" do
-        group "Editing"
-        banner <<-USAGE
-          Usage: hist
-                 hist --head N
-                 hist --tail N
-                 hist --show START..END
-                 hist --grep PATTERN
-                 hist --clear
-                 hist --replay START..END
-                 hist --save [START..END] FILE
-        USAGE
-
-        def options(opt)
-          opt.on :H, :head, "Display the first N items.", :optional_argument => true, :as => Integer
-          opt.on :T, :tail, "Display the last N items.", :optional_argument => true, :as => Integer
-          opt.on :s, :show, "Show the given range of lines.", :optional_argument => true, :as => Range
-          opt.on :G, :grep, "Show lines matching the given pattern.", :argument => true, :as => String
-          opt.on :c, :clear, "Clear the current session's history."
-          opt.on :r, :replay, "Replay a line or range of lines.", :argument => true, :as => Range
-          opt.on     :save, "Save history to a file.", :argument => true, :as => Range
-
-          opt.on :e, :'exclude-pry', "Exclude Pry commands from the history."
-          opt.on :n, :'no-numbers', "Omit line numbers."
-          opt.on :f, :flood, "Do not use a pager to view text longer than one screen."
-        end
-
-        def process
-          @history = Pry::Code(Pry.history.to_a)
-
-          if opts.present?(:show)
-            @history = @history.between(opts[:show])
-          end
-
-          if opts.present?(:grep)
-            @history = @history.grep(opts[:grep])
-          end
-
-          @history = case
-            when opts.present?(:head)
-              @history.take_lines(1, opts[:head] || 10)
-            when opts.present?(:tail)
-              @history.take_lines(-(opts[:tail] || 10), opts[:tail] || 10)
-            when opts.present?(:show)
-              @history.between(opts[:show])
-            else
-              @history
-            end
-
-          if opts.present?(:'exclude-pry')
-            @history = @history.select { |l, ln| !command_set.valid_command?(l) }
-          end
-
-          if opts.present?(:save)
-            process_save
-          elsif opts.present?(:clear)
-            process_clear
-          elsif opts.present?(:replay)
-            process_replay
-          else
-            process_display
-          end
-        end
-
-        def process_display
-          unless opts.present?(:'no-numbers')
-            @history = @history.with_line_numbers
-          end
-
-          render_output(@history, opts)
-        end
-
-        def process_save
-          case opts[:save]
-          when Range
-            @history = @history.between(opts[:save])
-
-            unless args.first
-              raise CommandError, "Must provide a file name."
-            end
-
-            file_name = File.expand_path(args.first)
-          when String
-            file_name = File.expand_path(opts[:save])
-          end
-
-          output.puts "Saving history in #{file_name}..."
-
-          File.open(file_name, 'w') { |f| f.write(@history.raw) }
-
-          output.puts "History saved."
-        end
-
-        def process_clear
-          Pry.history.clear
-          output.puts "History cleared."
-        end
-
-        def process_replay
-          @history = @history.between(opts[:r])
-
-          _pry_.input_stack.push _pry_.input
-          _pry_.input = StringIO.new(@history.raw)
-          # eval_string << "#{@history.raw}\n"
-          # run "show-input" unless _pry_.complete_expression?(eval_string)
-        end
-      end
-
-      alias_command "history", "hist"
-
-
-
-
-    end
-  end
-end

data/lib/pry/default_commands/input_and_output.rb

@@ -1,306 +0,0 @@
-require 'tempfile'
-require 'pry/default_commands/gist'
-
-class Pry
-  module DefaultCommands
-
-    InputAndOutput = Pry::CommandSet.new do
-      import Gist
-      command(/\.(.*)/, "All text following a '.' is forwarded to the shell.", :listing => ".<shell command>", :use_prefix => false, :takes_block => true) do |cmd|
-        if cmd =~ /^cd\s+(.+)/i
-          dest = $1
-          begin
-            Dir.chdir File.expand_path(dest)
-          rescue Errno::ENOENT
-            raise CommandError, "No such directory: #{dest}"
-          end
-        else
-          pass_block(cmd)
-
-          if command_block
-            command_block.call `#{cmd}`
-          else
-            Pry.config.system.call(output, cmd, _pry_)
-          end
-        end
-      end
-
-      command "shell-mode", "Toggle shell mode. Bring in pwd prompt and file completion." do
-        case _pry_.prompt
-        when Pry::SHELL_PROMPT
-          _pry_.pop_prompt
-          _pry_.custom_completions = Pry::DEFAULT_CUSTOM_COMPLETIONS
-        else
-          _pry_.push_prompt Pry::SHELL_PROMPT
-          _pry_.custom_completions = Pry::FILE_COMPLETIONS
-          Readline.completion_proc = Pry::InputCompleter.build_completion_proc target,
-          _pry_.instance_eval(&Pry::FILE_COMPLETIONS)
-        end
-      end
-      alias_command "file-mode", "shell-mode"
-
-      create_command "save-file", "Export to a file using content from the REPL."  do
-        banner <<-USAGE
-          Usage: save-file [OPTIONS] [FILE]
-          Save REPL content to a file.
-          e.g: save-file -m my_method -m my_method2 ./hello.rb
-          e.g: save-file -i 1..10 ./hello.rb --append
-          e.g: save-file -k show-method ./my_command.rb
-          e.g: save-file -f sample_file --lines 2..10 ./output_file.rb
-        USAGE
-
-        attr_accessor :content
-        attr_accessor :file_name
-
-        def setup
-          self.content = ""
-        end
-
-        def convert_to_range(n)
-          if !n.is_a?(Range)
-            (n..n)
-          else
-            n
-          end
-        end
-
-        def options(opt)
-          opt.on :m, :method, "Save a method's source.", :argument => true do |meth_name|
-            meth = get_method_or_raise(meth_name, target, {})
-            self.content << meth.source
-          end
-          opt.on :c, :class, "Save a class's source.", :argument => true do |class_name|
-            mod = Pry::WrappedModule.from_str(class_name, target)
-            self.content << mod.source
-          end
-          opt.on :k, :command, "Save a command's source.", :argument => true do |command_name|
-            command = find_command(command_name)
-            block = Pry::Method.new(command.block)
-            self.content << block.source
-          end
-          opt.on :f, :file, "Save a file.", :argument => true do |file|
-            self.content << File.read(File.expand_path(file))
-          end
-          opt.on :l, :lines, "Only save a subset of lines.", :optional_argument => true, :as => Range, :default => 1..-1
-          opt.on :o, :out, "Save entries from Pry's output result history. Takes an index or range.", :optional_argument => true,
-          :as => Range, :default => -5..-1 do |range|
-            range = convert_to_range(range)
-
-            range.each do |v|
-              self.content << Pry.config.gist.inspecter.call(_pry_.output_array[v])
-            end
-
-            self.content << "\n"
-          end
-          opt.on :i, :in, "Save entries from Pry's input expression history. Takes an index or range.", :optional_argument => true,
-          :as => Range, :default => -5..-1 do |range|
-            input_expressions = _pry_.input_array[range] || []
-            Array(input_expressions).each { |v| self.content << v }
-          end
-          opt.on :a, :append, "Append to the given file instead of overwriting it."
-        end
-
-        def process
-          if args.empty?
-            raise CommandError, "Must specify a file name."
-          end
-
-          self.file_name = File.expand_path(args.first)
-
-          save_file
-        end
-
-        def save_file
-          if self.content.empty?
-            raise CommandError, "Found no code to save."
-          end
-
-          File.open(file_name, mode) do |f|
-            if opts.present?(:lines)
-              f.puts restrict_to_lines(content, opts[:l])
-            else
-              f.puts content
-            end
-          end
-        end
-
-        def mode
-          if opts.present?(:append)
-            "a"
-          else
-            "w"
-          end
-        end
-      end
-
-      create_command "cat", "Show code from a file, Pry's input buffer, or the last exception." do
-        banner <<-USAGE
-          Usage: cat FILE
-                 cat --ex [STACK_INDEX]
-                 cat --in [INPUT_INDEX_OR_RANGE]
-
-          cat is capable of showing part or all of a source file, the context of the
-          last exception, or an expression from Pry's input history.
-
-          cat --ex defaults to showing the lines surrounding the location of the last
-          exception. Invoking it more than once travels up the exception's backtrace,
-          and providing a number shows the context of the given index of the backtrace.
-        USAGE
-
-        def options(opt)
-          opt.on :ex,        "Show the context of the last exception.", :optional_argument => true, :as => Integer
-          opt.on :i, :in,    "Show one or more entries from Pry's expression history.", :optional_argument => true, :as => Range, :default => -5..-1
-
-          opt.on :s, :start, "Starting line (defaults to the first line).", :optional_argument => true, :as => Integer
-          opt.on :e, :end,   "Ending line (defaults to the last line).", :optional_argument => true, :as => Integer
-          opt.on :l, :'line-numbers', "Show line numbers."
-          opt.on :t, :type,  "The file type for syntax highlighting (e.g., 'ruby' or 'python').", :argument => true, :as => Symbol
-
-          opt.on :f, :flood, "Do not use a pager to view text longer than one screen."
-        end
-
-        def process
-          handler = case
-                    when opts.present?(:ex)
-                      method :process_ex
-                    when opts.present?(:in)
-                      method :process_in
-                    else
-                      method :process_file
-                    end
-
-          output = handler.call do |code|
-            code.code_type = opts[:type] || :ruby
-
-            code.between(opts[:start] || 1, opts[:end] || -1).
-              with_line_numbers(opts.present?(:'line-numbers') || opts.present?(:ex))
-          end
-
-          render_output(output, opts)
-        end
-
-        def process_ex
-          window_size = Pry.config.default_window_size || 5
-          ex = _pry_.last_exception
-
-          raise CommandError, "No exception found." unless ex
-
-          if opts[:ex].nil?
-            bt_index = ex.bt_index
-            ex.inc_bt_index
-          else
-            bt_index = opts[:ex]
-            ex.bt_index = bt_index
-            ex.inc_bt_index
-          end
-
-          ex_file, ex_line = ex.bt_source_location_for(bt_index)
-
-          raise CommandError, "The given backtrace level is out of bounds." unless ex_file
-
-          if RbxPath.is_core_path?(ex_file)
-            ex_file = RbxPath.convert_path_to_full(ex_file)
-          end
-
-          set_file_and_dir_locals(ex_file)
-
-          start_line = ex_line - window_size
-          start_line = 1 if start_line < 1
-          end_line = ex_line + window_size
-
-          header = unindent <<-HEADER
-            #{text.bold 'Exception:'} #{ex.class}: #{ex.message}
-            --
-            #{text.bold('From:')} #{ex_file} @ line #{ex_line} @ #{text.bold("level: #{bt_index}")} of backtrace (of #{ex.backtrace.size - 1}).
-
-          HEADER
-
-          code = yield(Pry::Code.from_file(ex_file).
-                       between(start_line, end_line).
-                       with_marker(ex_line))
-
-          "#{header}#{code}"
-        end
-
-        def process_in
-          normalized_range = absolute_index_range(opts[:i], _pry_.input_array.length)
-          input_items = _pry_.input_array[normalized_range] || []
-
-          zipped_items = normalized_range.zip(input_items).reject { |_, s| s.nil? || s == "" }
-
-          unless zipped_items.length > 0
-            raise CommandError, "No expressions found."
-          end
-
-          if zipped_items.length > 1
-            contents = ""
-            zipped_items.each do |i, s|
-              contents << "#{text.bold(i.to_s)}:\n"
-              contents << yield(Pry::Code(s).with_indentation(2)).to_s
-            end
-          else
-            contents = yield(Pry::Code(zipped_items.first.last))
-          end
-
-          contents
-        end
-
-        def process_file
-          file_name = args.shift
-
-          unless file_name
-            raise CommandError, "Must provide a filename, --in, or --ex."
-          end
-
-          file_name, line_num = file_name.split(':')
-          file_name = File.expand_path(file_name)
-          set_file_and_dir_locals(file_name)
-
-          code = yield(Pry::Code.from_file(file_name))
-
-          code.code_type = opts[:type] || detect_code_type_from_file(file_name)
-          if line_num
-            code = code.around(line_num.to_i,
-                               Pry.config.default_window_size || 7)
-          end
-
-          code
-        end
-
-        def detect_code_type_from_file(file_name)
-          name, ext = File.basename(file_name).split('.', 2)
-
-          if ext
-            case ext
-            when "py"
-               :python
-            when "rb", "gemspec", "rakefile", "ru"
-               :ruby
-            when "js"
-              return :javascript
-            when "yml", "prytheme"
-              :yaml
-            when "groovy"
-              :groovy
-            when "c"
-              :c
-            when "cpp"
-              :cpp
-            when "java"
-              :java
-            else
-              :text
-            end
-          else
-            case name
-            when "Rakefile", "Gemfile"
-              :ruby
-            else
-              :text
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/pry/default_commands/introspection.rb

@@ -1,410 +0,0 @@
-require 'tempfile'
-
-class Pry
-  module DefaultCommands
-
-    # For show-doc and show-source
-    module ModuleIntrospectionHelpers
-      attr_accessor :module_object
-
-      def module?(name)
-        self.module_object = Pry::WrappedModule.from_str(name, target)
-      end
-
-      def method?
-        !!method_object
-      rescue CommandError
-        false
-      end
-
-      def process(name)
-        if module?(name)
-          code_or_doc = process_module
-        elsif method?
-          code_or_doc = process_method
-        else
-          code_or_doc = process_alternatives
-        end
-
-        render_output(code_or_doc, opts)
-      end
-
-      def process_alternatives
-        if args.empty? && internal_binding?(target)
-          mod = target_self.is_a?(Module) ? target_self : target_self.class
-          self.module_object = Pry::WrappedModule(mod)
-
-          process_module
-        else
-          process_method
-        end
-      end
-
-      def module_start_line(mod, candidate_rank=0)
-        if opts.present?(:'base-one')
-          1
-        else
-          mod.candidate(candidate_rank).line
-        end
-      end
-
-      def use_line_numbers?
-        opts.present?(:b) || opts.present?(:l)
-      end
-
-      def attempt
-        rank = 0
-        begin
-          yield(rank)
-        rescue Pry::CommandError
-          raise if rank > (module_object.number_of_candidates - 1)
-          rank += 1
-          retry
-        end
-      end
-    end
-
-    Introspection = Pry::CommandSet.new do
-
-      create_command "show-doc", "Show the documentation for a method or class. Aliases: \?", :shellwords => false do
-        include ModuleIntrospectionHelpers
-        include Helpers::DocumentationHelpers
-        extend Helpers::BaseHelpers
-
-        banner <<-BANNER
-          Usage: show-doc [OPTIONS] [METH]
-          Aliases: ?
-
-          Show the documentation for a method or class. Tries instance methods first and then methods by default.
-          e.g show-doc hello_method    # docs for hello_method
-          e.g show-doc Pry             # docs for Pry class
-          e.g show-doc Pry -a          # docs for all definitions of Pry class (all monkey patches)
-        BANNER
-
-        options :requires_gem => "ruby18_source_location" if mri_18?
-
-        def setup
-          require 'ruby18_source_location' if mri_18?
-        end
-
-        def options(opt)
-          method_options(opt)
-          opt.on :l, "line-numbers", "Show line numbers."
-          opt.on :b, "base-one", "Show line numbers but start numbering at 1 (useful for `amend-line` and `play` commands)."
-          opt.on :f, :flood, "Do not use a pager to view text longer than one screen."
-          opt.on :a, :all, "Show docs for all definitions and monkeypatches of the module/class"
-        end
-
-        def process_module
-          if opts.present?(:all)
-            all_modules
-          else
-            normal_module
-          end
-        end
-
-        def normal_module
-          doc = ""
-          if module_object.yard_docs?
-            file_name, line = module_object.yard_file, module_object.yard_line
-            doc << module_object.yard_doc
-            start_line = 1
-          else
-            attempt do |rank|
-              file_name, line = module_object.candidate(rank).source_location
-              set_file_and_dir_locals(file_name)
-              doc << module_object.candidate(rank).doc
-              start_line = module_start_line(module_object, rank)
-            end
-          end
-
-          doc = Code.new(doc, start_line, :text).
-            with_line_numbers(use_line_numbers?).to_s
-
-          doc.insert(0, "\n#{Pry::Helpers::Text.bold('From:')} #{file_name} @ line #{line ? line : "N/A"}:\n\n")
-        end
-
-        def all_modules
-          doc = ""
-          doc << "Found #{module_object.number_of_candidates} candidates for `#{module_object.name}` definition:\n"
-          module_object.number_of_candidates.times do |v|
-            candidate = module_object.candidate(v)
-            begin
-              doc << "\nCandidate #{v+1}/#{module_object.number_of_candidates}: #{candidate.file} @ #{candidate.line}:\n\n"
-              doc << candidate.doc
-            rescue Pry::RescuableException
-              doc << "No documentation found.\n"
-              next
-            end
-          end
-          doc
-        end
-
-        def process_method
-          raise Pry::CommandError, "No documentation found." if method_object.doc.nil? || method_object.doc.empty?
-
-          doc = process_comment_markup(method_object.doc, method_object.source_type)
-          output.puts make_header(method_object, doc)
-          output.puts "#{text.bold("Owner:")} #{method_object.owner || "N/A"}"
-          output.puts "#{text.bold("Visibility:")} #{method_object.visibility}"
-          output.puts "#{text.bold("Signature:")} #{method_object.signature}"
-          output.puts
-
-          if use_line_numbers?
-            doc = Code.new(doc, start_line, :text).
-              with_line_numbers(true).to_s
-          end
-
-          doc
-        end
-
-        def module_start_line(mod, candidate=0)
-          if opts.present?(:'base-one')
-            1
-          else
-            if mod.candidate(candidate).line
-              mod.candidate(candidate).line - mod.candidate(candidate).doc.lines.count
-            else
-              1
-            end
-          end
-        end
-
-        def start_line
-          if opts.present?(:'base-one')
-             1
-          else
-            (method_object.source_line - method_object.doc.lines.count) || 1
-          end
-        end
-      end
-
-      alias_command "?", "show-doc"
-
-      create_command "stat", "View method information and set _file_ and _dir_ locals.", :shellwords => false do
-        banner <<-BANNER
-            Usage: stat [OPTIONS] [METH]
-            Show method information for method METH and set _file_ and _dir_ locals.
-            e.g: stat hello_method
-        BANNER
-
-        def options(opt)
-          method_options(opt)
-        end
-
-        def process
-          meth = method_object
-          output.puts unindent <<-EOS
-            Method Information:
-            --
-            Name: #{meth.name}
-            Owner: #{meth.owner ? meth.owner : "Unknown"}
-            Visibility: #{meth.visibility}
-            Type: #{meth.is_a?(::Method) ? "Bound" : "Unbound"}
-            Arity: #{meth.arity}
-            Method Signature: #{meth.signature}
-            Source Location: #{meth.source_location ? meth.source_location.join(":") : "Not found."}
-          EOS
-        end
-      end
-
-      create_command "show-source" do
-        include ModuleIntrospectionHelpers
-        extend Helpers::BaseHelpers
-
-        description "Show the source for a method or class. Aliases: $, show-method"
-
-        banner <<-BANNER
-          Usage: show-source [OPTIONS] [METH|CLASS]
-          Aliases: $, show-method
-
-          Show the source for a method or class. Tries instance methods first and then methods by default.
-
-          e.g: `show-source hello_method`
-          e.g: `show-source -m hello_method`
-          e.g: `show-source Pry#rep`         # source for Pry#rep method
-          e.g: `show-source Pry`             # source for Pry class
-          e.g: `show-source Pry -a`          # source for all Pry class definitions (all monkey patches)
-
-          https://github.com/pry/pry/wiki/Source-browsing#wiki-Show_method
-        BANNER
-
-        options :shellwords => false
-        options :requires_gem => "ruby18_source_location" if mri_18?
-
-        def setup
-          require 'ruby18_source_location' if mri_18?
-        end
-
-        def options(opt)
-          method_options(opt)
-          opt.on :l, "line-numbers", "Show line numbers."
-          opt.on :b, "base-one", "Show line numbers but start numbering at 1 (useful for `amend-line` and `play` commands)."
-          opt.on :f, :flood, "Do not use a pager to view text longer than one screen."
-          opt.on :a, :all, "Show source for all definitions and monkeypatches of the module/class"
-        end
-
-        def process_method
-          raise CommandError, "Could not find method source" unless method_object.source
-
-          code = ""
-          code << make_header(method_object)
-          code << "#{text.bold("Owner:")} #{method_object.owner || "N/A"}\n"
-          code << "#{text.bold("Visibility:")} #{method_object.visibility}\n"
-          code << "\n"
-
-          code << Code.from_method(method_object, start_line).
-                   with_line_numbers(use_line_numbers?).to_s
-        end
-
-        def process_module
-          if opts.present?(:all)
-            all_modules
-          else
-            normal_module
-          end
-        end
-
-        def normal_module
-          file_name = line = code = nil
-          attempt do |rank|
-            file_name, line = module_object.candidate(rank).source_location
-            set_file_and_dir_locals(file_name)
-            code = Code.from_module(module_object, module_start_line(module_object, rank), rank).
-              with_line_numbers(use_line_numbers?).to_s
-          end
-
-          result = ""
-          result << "\n#{Pry::Helpers::Text.bold('From:')} #{file_name} @ line #{line}:\n"
-          result << "#{Pry::Helpers::Text.bold('Number of lines:')} #{code.lines.count}\n\n"
-          result << code
-        end
-
-        def all_modules
-          mod = module_object
-
-          result = ""
-          result << "Found #{mod.number_of_candidates} candidates for `#{mod.name}` definition:\n"
-          mod.number_of_candidates.times do |v|
-            candidate = mod.candidate(v)
-            begin
-              result << "\nCandidate #{v+1}/#{mod.number_of_candidates}: #{candidate.file} @ line #{candidate.line}:\n"
-              code = Code.from_module(mod, module_start_line(mod, v), v).
-                with_line_numbers(use_line_numbers?).to_s
-              result << "Number of lines: #{code.lines.count}\n\n"
-              result << code
-            rescue Pry::RescuableException
-              result << "\nNo code found.\n"
-              next
-            end
-          end
-          result
-        end
-
-        def use_line_numbers?
-          opts.present?(:b) || opts.present?(:l)
-        end
-
-        def start_line
-          if opts.present?(:'base-one')
-            1
-          else
-            method_object.source_line || 1
-          end
-        end
-      end
-
-      alias_command "show-method", "show-source"
-      alias_command "$", "show-source"
-
-      command "show-command", "Show the source for CMD." do |*args|
-        target = target()
-
-        opts = Slop.parse!(args) do |opt|
-          opt.banner unindent <<-USAGE
-            Usage: show-command [OPTIONS] [CMD]
-            Show the source for command CMD.
-            e.g: show-command show-method
-          USAGE
-
-          opt.on :l, "line-numbers", "Show line numbers."
-          opt.on :f, :flood, "Do not use a pager to view text longer than one screen."
-          opt.on :h, :help, "This message." do
-            output.puts opt.help
-          end
-        end
-
-        next if opts.present?(:help)
-
-        command_name = args.shift
-        if !command_name
-          raise CommandError, "You must provide a command name."
-        end
-
-        if find_command(command_name)
-          block = Pry::Method.new(find_command(command_name).block)
-
-          next unless block.source
-          set_file_and_dir_locals(block.source_file)
-
-          output.puts make_header(block)
-          output.puts
-
-          code = Code.from_method(block).with_line_numbers(opts.present?(:'line-numbers')).to_s
-
-          render_output(code, opts)
-        else
-          raise CommandError, "No such command: #{command_name}."
-        end
-      end
-
-      create_command "ri", "View ri documentation. e.g `ri Array#each`" do
-        banner <<-BANNER
-          Usage: ri [spec]
-          e.g. ri Array#each
-
-          Relies on the rdoc gem being installed. See also: show-doc.
-        BANNER
-
-        def process(spec)
-          # Lazily load RI
-          require 'rdoc/ri/driver'
-
-          unless defined? RDoc::RI::PryDriver
-
-            # Subclass RI so that it formats its output nicely, and uses `lesspipe`.
-            subclass = Class.new(RDoc::RI::Driver) # the hard way.
-
-            subclass.class_eval do
-              def page
-                Pry::Helpers::BaseHelpers.lesspipe {|less| yield less}
-              end
-
-              def formatter(io)
-                if @formatter_klass then
-                  @formatter_klass.new
-                else
-                  RDoc::Markup::ToAnsi.new
-                end
-              end
-            end
-
-            RDoc::RI.const_set :PryDriver, subclass   # hook it up!
-          end
-
-          # Spin-up an RI insance.
-          ri = RDoc::RI::PryDriver.new :use_stdout => true, :interactive => false
-
-          begin
-            ri.display_names [spec]  # Get the documentation (finally!)
-          rescue RDoc::RI::Driver::NotFoundError => e
-            output.puts "error: '#{e.name}' not found"
-          end
-        end
-
-      end
-
-    end
-  end
-end
-