pry 0.10.0.pre2-universal-mingw32

data/lib/pry/commands/raise_up.rb

@@ -0,0 +1,32 @@
+class Pry
+  # N.B. using a regular expresion here so that "raise-up 'foo'" does the right thing.
+  class Command::RaiseUp < Pry::ClassCommand
+    match(/raise-up(!?\b.*)/)
+    group 'Context'
+    description 'Raise an exception out of the current pry instance.'
+    command_options :listing => 'raise-up'
+
+    banner <<-BANNER
+      Raise up, like exit, allows you to quit pry. Instead of returning a value
+      however, it raises an exception. If you don't provide the exception to be
+      raised, it will use the most recent exception (in pry `_ex_`).
+
+      When called as raise-up! (with an exclamation mark), this command raises the
+      exception through any nested prys you have created by "cd"ing into objects.
+
+      raise-up "get-me-out-of-here"
+
+      # This is equivalent to the command above.
+      raise "get-me-out-of-here"
+      raise-up
+    BANNER
+
+    def process
+      return _pry.pager.page help if captures[0] =~ /(-h|--help)\b/
+      # Handle 'raise-up', 'raise-up "foo"', 'raise-up RuntimeError, 'farble' in a rubyesque manner
+      target.eval("_pry_.raise_up#{captures[0]}")
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::RaiseUp)
+end

data/lib/pry/commands/reload_code.rb

@@ -0,0 +1,62 @@
+class Pry
+  class Command::ReloadCode < Pry::ClassCommand
+    match 'reload-code'
+    group 'Misc'
+    description 'Reload the source file that contains the specified code object.'
+
+    banner <<-'BANNER'
+      Reload the source file that contains the specified code object.
+
+      e.g reload-code MyClass#my_method    #=> reload a method
+          reload-code MyClass              #=> reload a class
+          reload-code my-command           #=> reload a pry command
+          reload-code self                 #=> reload the current object
+          reload-code                      #=> reload the current file or object
+    BANNER
+
+    def process
+      if !args.empty?
+        reload_object(args.join(" "))
+      elsif internal_binding?(target)
+        reload_object("self")
+      else
+        reload_current_file
+      end
+    end
+
+    private
+
+    def current_file
+      File.expand_path target.eval("__FILE__")
+    end
+
+    def reload_current_file
+      if !File.exists?(current_file)
+        raise CommandError, "Current file: #{current_file} cannot be found on disk!"
+      end
+
+      load current_file
+      output.puts "The current file: #{current_file} was reloaded!"
+    end
+
+    def reload_object(identifier)
+      code_object = Pry::CodeObject.lookup(identifier, _pry_)
+      check_for_reloadability(code_object, identifier)
+      load code_object.source_file
+      output.puts "#{identifier} was reloaded!"
+    end
+
+    def check_for_reloadability(code_object, identifier)
+      if !code_object || !code_object.source_file
+        raise CommandError, "Cannot locate #{identifier}!"
+      elsif !File.exists?(code_object.source_file)
+        raise CommandError,
+          "Cannot reload #{identifier} as it has no associated file on disk. " \
+          "File found was: #{code_object.source_file}"
+      end
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::ReloadCode)
+  Pry::Commands.alias_command 'reload-method', 'reload-code'
+end

data/lib/pry/commands/reset.rb

@@ -0,0 +1,18 @@
+class Pry
+  class Command::Reset < Pry::ClassCommand
+    match 'reset'
+    group 'Context'
+    description 'Reset the REPL to a clean state.'
+
+    banner <<-'BANNER'
+      Reset the REPL to a clean state.
+    BANNER
+
+    def process
+      output.puts 'Pry reset.'
+      exec 'pry'
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::Reset)
+end

data/lib/pry/commands/ri.rb

@@ -0,0 +1,60 @@
+class Pry
+  class Command::Ri < Pry::ClassCommand
+    match 'ri'
+    group 'Introspection'
+    description 'View ri documentation.'
+
+    banner <<-'BANNER'
+      Usage: ri [spec]
+
+      View ri documentation. Relies on the "rdoc" gem being installed.
+      See also "show-doc" command.
+
+      ri Array#each
+    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 initialize(pager, opts)
+            @pager = pager
+            super opts
+          end
+          def page
+            paging_text = StringIO.new
+            yield paging_text
+            @pager.page(paging_text.string)
+          end
+
+          def formatter(io)
+            if @formatter_klass
+              @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 _pry_.pager, :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
+
+  Pry::Commands.add_command(Pry::Command::Ri)
+end

data/lib/pry/commands/save_file.rb

@@ -0,0 +1,61 @@
+require 'pry/commands/code_collector'
+
+class Pry
+  class Command::SaveFile < Pry::ClassCommand
+    match 'save-file'
+    group 'Input and Output'
+    description 'Export to a file using content from the REPL.'
+
+    banner <<-'BANNER'
+      Usage: save-file [OPTIONS] --to [FILE]
+
+      Export to a file using content from the REPL.
+
+      save-file my_method --to hello.rb
+      save-file -i 1..10 --to hello.rb --append
+      save-file show-method --to my_command.rb
+      save-file sample_file.rb --lines 2..10 --to output_file.rb
+    BANNER
+
+    def options(opt)
+      CodeCollector.inject_options(opt)
+
+      opt.on :to=,        "Specify the output file path"
+      opt.on :a, :append, "Append output to file"
+    end
+
+    def process
+      @cc = CodeCollector.new(args, opts, _pry_)
+      raise CommandError, "Found no code to save." if @cc.content.empty?
+
+      if !file_name
+        display_content
+      else
+        save_file
+      end
+    end
+
+    def file_name
+      opts[:to] || nil
+    end
+
+    def save_file
+      File.open(file_name, mode) do |f|
+        f.puts @cc.content
+      end
+      output.puts "#{file_name} successfully saved"
+    end
+
+    def display_content
+      output.puts @cc.content
+      output.puts "\n\n--\nPlease use `--to FILE` to export to a file."
+      output.puts "No file saved!\n--"
+    end
+
+    def mode
+      opts.present?(:append) ? "a" : "w"
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::SaveFile)
+end

data/lib/pry/commands/shell_command.rb

@@ -0,0 +1,48 @@
+class Pry
+  class Command::ShellCommand < Pry::ClassCommand
+    match(/\.(.*)/)
+    group 'Input and Output'
+    description "All text following a '.' is forwarded to the shell."
+    command_options :listing => '.<shell command>', :use_prefix => false,
+      :takes_block => true
+
+    banner <<-'BANNER'
+      Usage: .COMMAND_NAME
+
+      All text following a "." is forwarded to the shell.
+
+      .ls -aF
+      .uname
+    BANNER
+
+    def process(cmd)
+      if cmd =~ /^cd\s*(.*)/i
+        process_cd parse_destination($1)
+      else
+        pass_block(cmd)
+        if command_block
+          command_block.call `#{cmd}`
+        else
+          _pry_.config.system.call(output, cmd, _pry_)
+        end
+      end
+    end
+
+    private
+
+      def parse_destination(dest)
+        return "~" if dest.empty?
+        return dest unless dest == "-"
+        state.old_pwd || raise(CommandError, "No prior directory available")
+      end
+
+      def process_cd(dest)
+        state.old_pwd = Dir.pwd
+        Dir.chdir File.expand_path(dest)
+      rescue Errno::ENOENT
+        raise CommandError, "No such directory: #{dest}"
+      end
+  end
+
+  Pry::Commands.add_command(Pry::Command::ShellCommand)
+end

data/lib/pry/commands/shell_mode.rb

@@ -0,0 +1,25 @@
+class Pry
+  class Command::ShellMode < Pry::ClassCommand
+    match 'shell-mode'
+    group 'Input and Output'
+    description 'Toggle shell mode. Bring in pwd prompt and file completion.'
+
+    banner <<-'BANNER'
+      Toggle shell mode. Bring in pwd prompt and file completion.
+    BANNER
+
+    def process
+      case _pry_.prompt
+      when Pry::SHELL_PROMPT
+        _pry_.pop_prompt
+        _pry_.custom_completions = _pry_.config.file_completions
+      else
+        _pry_.push_prompt Pry::SHELL_PROMPT
+        _pry_.custom_completions = _pry_.config.command_completions
+      end
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::ShellMode)
+  Pry::Commands.alias_command 'file-mode', 'shell-mode'
+end

data/lib/pry/commands/show_doc.rb

@@ -0,0 +1,83 @@
+require 'pry/commands/show_info'
+
+class Pry
+  class Command::ShowDoc < Command::ShowInfo
+    include Pry::Helpers::DocumentationHelpers
+
+    match 'show-doc'
+    group 'Introspection'
+    description 'Show the documentation for a method or class.'
+
+    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.
+
+      show-doc hi_method # docs for hi_method
+      show-doc Pry       # for Pry class
+      show-doc Pry -a    # for all definitions of Pry class (all monkey patches)
+    BANNER
+
+    # The docs for code_object prepared for display.
+    def content_for(code_object)
+      Code.new(render_doc_markup_for(code_object),
+               start_line_for(code_object), :text).
+        with_line_numbers(use_line_numbers?).to_s
+    end
+
+    # process the markup (if necessary) and apply colors
+    def render_doc_markup_for(code_object)
+      docs = docs_for(code_object)
+
+      if code_object.command?
+        # command '--help' shouldn't use markup highlighting
+        docs
+      else
+        if docs.empty?
+          raise CommandError, "No docs found for: #{
+            obj_name ? obj_name : 'current context'
+          }"
+        end
+        process_comment_markup(docs)
+      end
+    end
+
+    # Return docs for the code_object, adjusting for whether the code_object
+    # has yard docs available, in which case it returns those.
+    # (note we only have to check yard docs for modules since they can
+    # have multiple docs, but methods can only be doc'd once so we
+    # dont need to check them)
+    def docs_for(code_object)
+      if code_object.module_with_yard_docs?
+        # yard docs
+        code_object.yard_doc
+      else
+        # normal docs (i.e comments above method/module/command)
+        code_object.doc
+      end
+    end
+
+    # Which sections to include in the 'header', can toggle: :owner,
+    # :signature and visibility.
+    def header_options
+      super.merge :signature => true
+    end
+
+    # figure out start line of docs by back-calculating based on
+    # number of lines in the comment and the start line of the code_object
+    # @return [Fixnum] start line of docs
+    def start_line_for(code_object)
+      if code_object.command? || opts.present?(:'base-one')
+         1
+      else
+        code_object.source_line.nil? ? 1 :
+          (code_object.source_line - code_object.doc.lines.count)
+      end
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::ShowDoc)
+  Pry::Commands.alias_command '?', 'show-doc'
+end

data/lib/pry/commands/show_info.rb

@@ -0,0 +1,195 @@
+class Pry
+  class Command::ShowInfo < Pry::ClassCommand
+    extend Pry::Helpers::BaseHelpers
+
+    command_options :shellwords => false, :interpolate => false
+
+    def options(opt)
+      opt.on :s, :super, "Select the 'super' method. Can be repeated to traverse the ancestors", :as => :count
+      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 :a, :all,  "Show all definitions and monkeypatches of the module/class"
+    end
+
+    def process
+      code_object = Pry::CodeObject.lookup(obj_name, _pry_, :super => opts[:super])
+      raise CommandError, no_definition_message if !code_object
+      @original_code_object = code_object
+
+      if show_all_modules?(code_object)
+        # show all monkey patches for a module
+
+        result = content_and_headers_for_all_module_candidates(code_object)
+      else
+        # show a specific code object
+        co = code_object_with_accessible_source(code_object)
+        result = content_and_header_for_code_object(co)
+      end
+
+      set_file_and_dir_locals(code_object.source_file)
+      _pry_.pager.page result
+    end
+
+    # This method checks whether the `code_object` is a WrappedModule,
+    # if it is, then it returns the first candidate (monkeypatch) with
+    # accessible source (or docs). If `code_object` is not a WrappedModule (i.e a
+    # method or a command) then the `code_object` itself is just
+    # returned.
+    #
+    # @return [Pry::WrappedModule, Pry::Method, Pry::Command]
+    def code_object_with_accessible_source(code_object)
+      if code_object.is_a?(WrappedModule)
+        candidate = code_object.candidates.find(&:source)
+        if candidate
+          return candidate
+        else
+          raise CommandError, no_definition_message if !valid_superclass?(code_object)
+
+          @used_super = true
+          code_object_with_accessible_source(code_object.super)
+        end
+      else
+        code_object
+      end
+    end
+
+    def valid_superclass?(code_object)
+      code_object.super && code_object.super.wrapped != Object
+    end
+
+    def content_and_header_for_code_object(code_object)
+      header(code_object) << content_for(code_object)
+    end
+
+    def content_and_headers_for_all_module_candidates(mod)
+      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.source_file} @ line #{candidate.source_line}:\n"
+          content = content_for(candidate)
+
+          result << "Number of lines: #{content.lines.count}\n\n" << content
+        rescue Pry::RescuableException
+          result << "\nNo content found.\n"
+          next
+        end
+      end
+      result
+    end
+
+    def no_definition_message
+      "Couldn't locate a definition for #{obj_name}!"
+    end
+
+    # Generate a header (meta-data information) for all the code
+    # object types: methods, modules, commands, procs...
+    def header(code_object)
+      file_name, line_num = file_and_line_for(code_object)
+      h = "\n#{Pry::Helpers::Text.bold('From:')} #{file_name} "
+      h << code_object_header(code_object, line_num)
+      h << "\n#{Pry::Helpers::Text.bold('Number of lines:')} " <<
+        "#{content_for(code_object).lines.count}\n\n"
+      h << Helpers::Text.bold('** Warning:') << " Cannot find code for #{@original_code_object.nonblank_name}. Showing superclass #{code_object.nonblank_name} instead. **\n\n" if @used_super
+      h
+    end
+
+    def code_object_header(code_object, line_num)
+      if code_object.real_method_object?
+        method_header(code_object, line_num)
+
+        # It sucks we have to test for both Pry::WrappedModule and WrappedModule::Candidate,
+        # probably indicates a deep refactor needs to happen in those classes.
+      elsif code_object.is_a?(Pry::WrappedModule) || code_object.is_a?(Pry::WrappedModule::Candidate)
+        module_header(code_object, line_num)
+      else
+        ""
+      end
+    end
+
+    def method_header(code_object, line_num)
+      h = ""
+      h << (code_object.c_method? ? "(C Method):" : "@ line #{line_num}:")
+      h << method_sections(code_object)[:owner]
+      h << method_sections(code_object)[:visibility]
+      h << method_sections(code_object)[:signature]
+      h
+    end
+
+    def module_header(code_object, line_num)
+      h = ""
+      h << "@ line #{line_num}:\n"
+      h << text.bold(code_object.module? ? "Module" : "Class")
+      h << " #{text.bold('name:')} #{code_object.nonblank_name}"
+
+      if code_object.number_of_candidates > 1
+        h << (text.bold("\nNumber of monkeypatches: ") << code_object.number_of_candidates.to_s)
+        h << ". Use the `-a` option to display all available monkeypatches"
+      end
+      h
+    end
+
+    def method_sections(code_object)
+      {
+        :owner => "\n#{text.bold("Owner:")} #{code_object.owner || "N/A"}\n",
+        :visibility => "#{text.bold("Visibility:")} #{code_object.visibility}",
+        :signature => "\n#{text.bold("Signature:")} #{code_object.signature}"
+      }.merge(header_options) { |key, old, new| (new && old).to_s }
+    end
+
+    def header_options
+      {
+        :owner => true,
+        :visibility => true,
+        :signature => nil
+      }
+    end
+
+    def show_all_modules?(code_object)
+      code_object.is_a?(Pry::WrappedModule) && opts.present?(:all)
+    end
+
+    def obj_name
+      @obj_name ||= args.empty? ? nil : args.join(' ')
+    end
+
+    def use_line_numbers?
+      opts.present?(:b) || opts.present?(:l)
+    end
+
+    def start_line_for(code_object)
+      if opts.present?(:'base-one')
+        1
+      else
+        code_object.source_line || 1
+      end
+    end
+
+    # takes into account possible yard docs, and returns yard_file / yard_line
+    # Also adjusts for start line of comments (using start_line_for), which it has to infer
+    # by subtracting number of lines of comment from start line of code_object
+    def file_and_line_for(code_object)
+      if code_object.module_with_yard_docs?
+        [code_object.yard_file, code_object.yard_line]
+      else
+        [code_object.source_file, start_line_for(code_object)]
+      end
+    end
+
+    def complete(input)
+      if input =~ /([^ ]*)#([a-z0-9_]*)\z/
+        prefix, search = [$1, $2]
+        methods = begin
+                    Pry::Method.all_from_class(binding.eval(prefix))
+                  rescue RescuableException
+                    return super
+                  end
+        methods.map do |method|
+          [prefix, method.name].join('#') if method.name.start_with?(search)
+        end.compact
+      else
+        super
+      end
+    end
+  end
+end