pry 0.9.10pre1-i386-mswin32 → 0.9.11-i386-mswin32

data/lib/pry/commands/show_info.rb

@@ -0,0 +1,139 @@
+class Pry
+  class Command::ShowInfo < Pry::ClassCommand
+    extend Pry::Helpers::BaseHelpers
+
+    command_options :shellwords => false
+    command_options :requires_gem => "ruby18_source_location" if mri_18?
+
+    def setup
+      require 'ruby18_source_location' if mri_18?
+    end
+
+    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 :f, :flood, "Do not use a pager to view text longer than one screen"
+      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 Pry::CommandError, "Couldn't locate #{obj_name}!" if !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
+        result = content_and_header_for_code_object(code_object)
+      end
+
+      set_file_and_dir_locals(code_object.source_file)
+      stagger_output result
+    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
+
+    # 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 << method_header(code_object, line_num) if code_object.real_method_object?
+      h << "\n#{Pry::Helpers::Text.bold('Number of lines:')} " <<
+        "#{content_for(code_object).lines.count}\n\n"
+    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 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 => e
+                    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

data/lib/pry/commands/show_input.rb

@@ -0,0 +1,17 @@
+class Pry
+  class Command::ShowInput < Pry::ClassCommand
+    match 'show-input'
+    group 'Editing'
+    description 'Show the contents of the input buffer for the current multi-line expression.'
+
+    banner <<-'BANNER'
+      Show the contents of the input buffer for the current multi-line expression.
+    BANNER
+
+    def process
+      output.puts Code.new(eval_string).with_line_numbers
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::ShowInput)
+end

data/lib/pry/commands/show_source.rb

@@ -0,0 +1,37 @@
+require 'pry/commands/show_info'
+
+class Pry
+  class Command::ShowSource < Command::ShowInfo
+    match 'show-source'
+    group 'Introspection'
+    description 'Show the source for a method or class.'
+
+    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.
+
+      show-source hi_method
+      show-source hi_method
+      show-source Pry#rep     # source for Pry#rep method
+      show-source Pry         # for Pry class
+      show-source Pry -a      # for all Pry class definitions (all monkey patches)
+      show-source Pry --super # for superclass of Pry (Object class)
+
+      https://github.com/pry/pry/wiki/Source-browsing#wiki-Show_method
+    BANNER
+
+    # The source for code_object prepared for display.
+    def content_for(code_object)
+      raise CommandError, "Cannot locate source!" if !code_object.source
+      Code.new(code_object.source, start_line_for(code_object)).
+        with_line_numbers(use_line_numbers?).to_s
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::ShowSource)
+  Pry::Commands.alias_command 'show-method', 'show-source'
+  Pry::Commands.alias_command '$', 'show-source'
+end

data/lib/pry/commands/simple_prompt.rb

@@ -0,0 +1,22 @@
+class Pry
+  class Command::SimplePrompt < Pry::ClassCommand
+    match 'simple-prompt'
+    group 'Misc'
+    description 'Toggle the simple prompt.'
+
+    banner <<-'BANNER'
+      Toggle the simple prompt.
+    BANNER
+
+    def process
+      case _pry_.prompt
+      when Pry::SIMPLE_PROMPT
+        _pry_.pop_prompt
+      else
+        _pry_.push_prompt Pry::SIMPLE_PROMPT
+      end
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::SimplePrompt)
+end

data/lib/pry/commands/stat.rb

@@ -0,0 +1,40 @@
+class Pry
+  class Command::Stat < Pry::ClassCommand
+    match 'stat'
+    group 'Introspection'
+    description 'View method information and set _file_ and _dir_ locals.'
+    command_options :shellwords => false
+
+    banner <<-'BANNER'
+        Usage: stat [OPTIONS] [METH]
+
+        Show method information for method METH and set _file_ and _dir_ locals.
+
+        stat hello_method
+    BANNER
+
+    def options(opt)
+      method_options(opt)
+    end
+
+    def process
+      meth = method_object
+      aliases = meth.aliases
+
+      output.puts unindent <<-EOS
+        Method Information:
+        --
+        Name: #{meth.name}
+        Alias#{ "es" if aliases.length > 1 }: #{ aliases.any? ? aliases.join(", ") : "None." }
+        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
+
+  Pry::Commands.add_command(Pry::Command::Stat)
+end

data/lib/pry/commands/switch_to.rb

@@ -0,0 +1,23 @@
+class Pry
+  class Command::SwitchTo < Pry::ClassCommand
+    match 'switch-to'
+    group 'Navigating Pry'
+    description 'Start a new subsession on a binding in the current stack.'
+
+    banner <<-'BANNER'
+      Start a new subsession on a binding in the current stack (numbered by nesting).
+    BANNER
+
+    def process(selection)
+      selection = selection.to_i
+
+      if selection < 0 || selection > _pry_.binding_stack.size - 1
+        raise CommandError, "Invalid binding index #{selection} - use `nesting` command to view valid indices."
+      else
+        Pry.start(_pry_.binding_stack[selection])
+      end
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::SwitchTo)
+end

data/lib/pry/commands/toggle_color.rb

@@ -0,0 +1,20 @@
+class Pry
+  class Command::ToggleColor < Pry::ClassCommand
+    match 'toggle-color'
+    group 'Misc'
+    description 'Toggle syntax highlighting.'
+
+    banner <<-'BANNER'
+      Usage: toggle-color
+
+      Toggle syntax highlighting.
+    BANNER
+
+    def process
+      Pry.color = !Pry.color
+      output.puts "Syntax highlighting #{Pry.color ? "on" : "off"}"
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::ToggleColor)
+end

data/lib/pry/commands/whereami.rb

@@ -0,0 +1,114 @@
+class Pry
+  class Command::Whereami < Pry::ClassCommand
+    match 'whereami'
+    description 'Show code surrounding the current context.'
+    group 'Context'
+
+    banner <<-'BANNER'
+      Usage: whereami [-qn] [N]
+
+      Describe the current location. If you use `binding.pry` inside a method then
+      whereami will print out the source for that method.
+
+      If a number is passed, then N lines before and after the current line will be
+      shown instead of the method itself.
+
+      The `-q` flag can be used to suppress error messages in the case that there's
+      no code to show. This is used by pry in the default before_session hook to show
+      you when you arrive at a `binding.pry`.
+
+      The `-n` flag can be used to hide line numbers so that code can be copy/pasted
+      effectively.
+
+      When pry was started on an Object and there is no associated method, whereami
+      will instead output a brief description of the current object.
+    BANNER
+
+    def setup
+      @method = Pry::Method.from_binding(target)
+      @file = target.eval('__FILE__')
+      @line = target.eval('__LINE__')
+    end
+
+    def options(opt)
+      opt.on :q, :quiet,             "Don't display anything in case of an error"
+      opt.on :n, :"no-line-numbers", "Do not display line numbers"
+    end
+
+    def code
+      @code ||= if show_method?
+                  Pry::Code.from_method(@method)
+                else
+                  Pry::Code.from_file(@file).around(@line, window_size)
+                end
+    end
+
+    def location
+      "#{@file} @ line #{@line} #{@method && @method.name_with_owner}"
+    end
+
+    def process
+      if nothing_to_do?
+        return
+      elsif internal_binding?(target)
+        handle_internal_binding
+        return
+      end
+
+      set_file_and_dir_locals(@file)
+
+      output.puts "\n#{text.bold('From:')} #{location}:\n\n"
+      output.puts code.with_line_numbers(use_line_numbers?).with_marker(marker)
+      output.puts
+    end
+
+    private
+
+    def nothing_to_do?
+      opts.quiet? && (internal_binding?(target) || !code?)
+    end
+
+    def use_line_numbers?
+      !opts.present?(:n)
+    end
+
+    def marker
+      !opts.present?(:n) && @line
+    end
+
+    def top_level?
+      target_self == TOPLEVEL_BINDING.eval("self")
+    end
+
+    def handle_internal_binding
+      if top_level?
+        output.puts "At the top level."
+      else
+        output.puts "Inside #{Pry.view_clip(target_self)}."
+      end
+    end
+
+    def show_method?
+      args.empty? && @method && @method.source? && @method.source_range.count < 20 &&
+      # These checks are needed in case of an eval with a binding and file/line
+      # numbers set to outside the function. As in rails' use of ERB.
+      @method.source_file == @file && @method.source_range.include?(@line)
+    end
+
+    def code?
+      !!code
+    rescue MethodSource::SourceNotFoundError
+      false
+    end
+
+    def window_size
+      if args.empty?
+        Pry.config.default_window_size
+      else
+        args.first.to_i
+      end
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::Whereami)
+end

data/lib/pry/commands/wtf.rb

@@ -0,0 +1,57 @@
+class Pry
+  class Command::Wtf < Pry::ClassCommand
+    match /wtf([?!]*)/
+    group 'Context'
+    description 'Show the backtrace of the most recent exception.'
+    options :listing => 'wtf?'
+
+    banner <<-'BANNER'
+      Usage: wtf[?|!]
+
+      Show's a few lines of the backtrace of the most recent exception (also available
+      as `_ex_.backtrace`). If you want to see more lines, add more question marks or
+      exclamation marks.
+
+      wtf?
+      wtf?!???!?!?
+
+      # To see the entire backtrace, pass the `-v` or `--verbose` flag.
+      wtf -v
+    BANNER
+
+    def options(opt)
+      opt.on :v, :verbose, "Show the full backtrace"
+    end
+
+    def process
+      raise Pry::CommandError, "No most-recent exception" unless exception
+
+      output.puts "#{text.bold('Exception:')} #{exception.class}: #{exception}\n--"
+      if opts.verbose?
+        output.puts with_line_numbers(backtrace)
+      else
+        output.puts with_line_numbers(backtrace.first(size_of_backtrace))
+      end
+    end
+
+    private
+
+    def exception
+      _pry_.last_exception
+    end
+
+    def with_line_numbers(bt)
+      Pry::Code.new(bt, 0, :text).with_line_numbers.to_s
+    end
+
+    def backtrace
+      exception.backtrace
+    end
+
+    def size_of_backtrace
+      [captures[0].size, 0.5].max * 10
+  end
+end
+
+Pry::Commands.add_command(Pry::Command::Wtf)
+end