pry 0.10.0.pre2-universal-mingw32

data/lib/pry/commands/bang.rb

@@ -0,0 +1,20 @@
+class Pry
+  class Command::Bang < Pry::ClassCommand
+    match /^\s*!\s*$/
+    group 'Editing'
+    description 'Clear the input buffer.'
+    command_options :use_prefix => false
+
+    banner <<-'BANNER'
+      Clear the input buffer. Useful if the parsing process goes wrong and you get
+      stuck in the read loop.
+    BANNER
+
+    def process
+      output.puts 'Input buffer cleared!'
+      eval_string.replace('')
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::Bang)
+end

data/lib/pry/commands/bang_pry.rb

@@ -0,0 +1,17 @@
+class Pry
+  class Command::BangPry < Pry::ClassCommand
+    match '!pry'
+    group 'Navigating Pry'
+    description 'Start a Pry session on current self.'
+
+    banner <<-'BANNER'
+      Start a Pry session on current self. Also works mid multi-line expression.
+    BANNER
+
+    def process
+      target.pry
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::BangPry)
+end

data/lib/pry/commands/cat.rb

@@ -0,0 +1,62 @@
+class Pry
+  class Command::Cat < Pry::ClassCommand
+    require 'pry/commands/cat/abstract_formatter.rb'
+    require 'pry/commands/cat/input_expression_formatter.rb'
+    require 'pry/commands/cat/exception_formatter.rb'
+    require 'pry/commands/cat/file_formatter.rb'
+
+    match 'cat'
+    group 'Input and Output'
+    description "Show code from a file, Pry's input buffer, or the last exception."
+
+    banner <<-'BANNER'
+      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.
+    BANNER
+
+    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
+    end
+
+    def process
+      output = case
+               when opts.present?(:ex)
+                 ExceptionFormatter.new(_pry_.last_exception, _pry_, opts).format
+               when opts.present?(:in)
+                 InputExpressionFormatter.new(_pry_.input_array, opts).format
+               else
+                 FileFormatter.new(args.first, _pry_, opts).format
+               end
+
+      _pry_.pager.page output
+    end
+
+    def complete(search)
+      super | load_path_completions
+    end
+
+    def load_path_completions
+      $LOAD_PATH.flat_map do |path|
+        Dir[path + '/**/*'].map { |f|
+          next if File.directory?(f)
+          f.sub!(path + '/', '')
+        }
+      end
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::Cat)
+end

data/lib/pry/commands/cat/abstract_formatter.rb

@@ -0,0 +1,27 @@
+class Pry
+  class Command::Cat
+    class AbstractFormatter
+      include Pry::Helpers::CommandHelpers
+      include Pry::Helpers::BaseHelpers
+
+      private
+      def decorate(content)
+        content.code_type = code_type
+        content.between(*between_lines).
+          with_line_numbers(use_line_numbers?)
+      end
+
+      def code_type
+        opts[:type] || :ruby
+      end
+
+      def use_line_numbers?
+        opts.present?(:'line-numbers') || opts.present?(:ex)
+      end
+
+      def between_lines
+        [opts[:start] || 1, opts[:end] || -1]
+      end
+    end
+  end
+end

data/lib/pry/commands/cat/exception_formatter.rb

@@ -0,0 +1,77 @@
+class Pry
+  class Command::Cat
+    class ExceptionFormatter < AbstractFormatter
+      attr_reader :ex
+      attr_reader :opts
+      attr_reader :_pry_
+
+      def initialize(exception, _pry_, opts)
+        @ex = exception
+        @opts = opts
+        @_pry_ = _pry_
+      end
+
+      def format
+        check_for_errors
+        set_file_and_dir_locals(backtrace_file, _pry_, _pry_.current_context)
+        code = decorate(Pry::Code.from_file(backtrace_file).
+                                    between(*start_and_end_line_for_code_window).
+                                    with_marker(backtrace_line)).to_s
+        "#{header}#{code}"
+      end
+
+      private
+
+      def code_window_size
+        _pry_.config.default_window_size || 5
+      end
+
+      def backtrace_level
+        return @backtrace_level if @backtrace_level
+
+        bl =  if opts[:ex].nil?
+                ex.bt_index
+              else
+                ex.bt_index = absolute_index_number(opts[:ex], ex.backtrace.size)
+              end
+
+        increment_backtrace_level
+        @backtrace_level = bl
+      end
+
+      def increment_backtrace_level
+        ex.inc_bt_index
+      end
+
+      def backtrace_file
+        Array(ex.bt_source_location_for(backtrace_level)).first
+      end
+
+      def backtrace_line
+        Array(ex.bt_source_location_for(backtrace_level)).last
+      end
+
+      def check_for_errors
+        raise CommandError, "No exception found." unless ex
+        raise CommandError, "The given backtrace level is out of bounds." unless backtrace_file
+      end
+
+      def start_and_end_line_for_code_window
+        start_line = backtrace_line - code_window_size
+        start_line = 1 if start_line < 1
+
+        [start_line, backtrace_line + code_window_size]
+      end
+
+      def header
+        unindent %{
+        #{Helpers::Text.bold 'Exception:'} #{ex.class}: #{ex.message}
+        --
+        #{Helpers::Text.bold('From:')} #{backtrace_file} @ line #{backtrace_line} @ #{Helpers::Text.bold("level: #{backtrace_level}")} of backtrace (of #{ex.backtrace.size - 1}).
+
+      }
+      end
+
+    end
+  end
+end

data/lib/pry/commands/cat/file_formatter.rb

@@ -0,0 +1,67 @@
+class Pry
+  class Command::Cat
+    class FileFormatter < AbstractFormatter
+      attr_reader :file_with_embedded_line
+      attr_reader :opts
+      attr_reader :_pry_
+
+      def initialize(file_with_embedded_line, _pry_, opts)
+        @file_with_embedded_line = file_with_embedded_line
+        @opts = opts
+        @_pry_ = _pry_
+        @code_from_file = Pry::Code.from_file(file_name)
+      end
+
+      def format
+        raise CommandError, "Must provide a filename, --in, or --ex." if !file_with_embedded_line
+
+        set_file_and_dir_locals(file_name, _pry_, _pry_.current_context)
+        decorate(@code_from_file)
+      end
+
+      def file_and_line
+        file_name, line_num = file_with_embedded_line.split(/:(?!\/|\\)/)
+
+        [file_name, line_num ? line_num.to_i : nil]
+      end
+
+      private
+
+      def file_name
+        file_and_line.first
+      end
+
+      def line_number
+        file_and_line.last
+      end
+
+      def code_window_size
+        _pry_.config.default_window_size || 7
+      end
+
+      def decorate(content)
+        line_number ? super.around(line_number, code_window_size) : super
+      end
+
+      def code_type
+        opts[:type] || detect_code_type_from_file(file_name)
+      end
+
+      def detect_code_type_from_file(file_name)
+        code_type = @code_from_file.code_type
+
+        if code_type == :unknown
+          name, ext = File.basename(file_name).split('.', 2)
+          case name
+          when "Rakefile", "Gemfile"
+            :ruby
+          else
+            :text
+          end
+        else
+          code_type
+        end
+      end
+    end
+  end
+end

data/lib/pry/commands/cat/input_expression_formatter.rb

@@ -0,0 +1,43 @@
+class Pry
+  class Command::Cat
+    class InputExpressionFormatter < AbstractFormatter
+      attr_accessor :input_expressions
+      attr_accessor :opts
+
+      def initialize(input_expressions, opts)
+        @input_expressions = input_expressions
+        @opts = opts
+      end
+
+      def format
+        raise CommandError, "No input expressions!" if numbered_input_items.length < 1
+
+        if numbered_input_items.length > 1
+          content = ""
+          numbered_input_items.each do |i, s|
+            content << "#{Helpers::Text.bold(i.to_s)}:\n" << decorate(Pry::Code(s).with_indentation(2)).to_s
+          end
+
+          content
+        else
+          decorate(Pry::Code(selected_input_items.first)).to_s
+        end
+      end
+
+      private
+
+      def selected_input_items
+        input_expressions[normalized_expression_range] || []
+      end
+
+      def numbered_input_items
+        @numbered_input_items ||= normalized_expression_range.zip(selected_input_items).
+          reject { |_, s| s.nil? || s == "" }
+      end
+
+      def normalized_expression_range
+        absolute_index_range(opts[:i], input_expressions.length)
+      end
+    end
+  end
+end

data/lib/pry/commands/cd.rb

@@ -0,0 +1,41 @@
+class Pry
+  class Command::Cd < Pry::ClassCommand
+    match 'cd'
+    group 'Context'
+    description 'Move into a new context (object or scope).'
+
+    banner <<-'BANNER'
+      Usage: cd [OPTIONS] [--help]
+
+      Move into new context (object or scope). As in UNIX shells use `cd ..` to go
+      back, `cd /` to return to Pry top-level and `cd -` to toggle between last two
+      scopes. Complex syntax (e.g `cd ../@x/@y`) also supported.
+
+      cd @x
+      cd ..
+      cd /
+      cd -
+
+      https://github.com/pry/pry/wiki/State-navigation#wiki-Changing_scope
+    BANNER
+
+    def process
+      state.old_stack ||= []
+
+      if arg_string.strip == "-"
+        unless state.old_stack.empty?
+          _pry_.binding_stack, state.old_stack = state.old_stack, _pry_.binding_stack
+        end
+      else
+        stack = ObjectPath.new(arg_string, _pry_.binding_stack).resolve
+
+        if stack && stack != _pry_.binding_stack
+          state.old_stack = _pry_.binding_stack
+          _pry_.binding_stack = stack
+        end
+      end
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::Cd)
+end

data/lib/pry/commands/change_inspector.rb

@@ -0,0 +1,27 @@
+class Pry::Command::ChangeInspector < Pry::ClassCommand
+  match 'change-inspector'
+  group 'Input and Output'
+  description 'Change the current inspector proc.'
+  command_options argument_required: true
+  banner <<-BANNER
+    Usage: change-inspector NAME
+
+    Change the proc used to print return values. See list-inspectors for a list
+    of available procs and a short description of what each one does.
+  BANNER
+
+  def process(inspector)
+    if inspector_map.key?(inspector)
+      _pry_.print = inspector_map[inspector][:value]
+      output.puts "Switched to the '#{inspector}' inspector!"
+    else
+      raise Pry::CommandError, "'#{inspector}' isn't a known inspector!"
+    end
+  end
+
+private
+  def inspector_map
+    Pry::Inspector::MAP
+  end
+  Pry::Commands.add_command(self)
+end

data/lib/pry/commands/change_prompt.rb

@@ -0,0 +1,26 @@
+class Pry::Command::ChangePrompt < Pry::ClassCommand
+  match 'change-prompt'
+  group 'Input and Output'
+  description 'Change the current prompt.'
+  command_options argument_required: true
+  banner <<-BANNER
+    Usage: change-prompt NAME
+
+    Change the current prompt. See list-prompts for a list of available
+    prompts.
+  BANNER
+
+  def process(prompt)
+    if prompt_map.key?(prompt)
+      _pry_.prompt = prompt_map[prompt][:value]
+    else
+      raise Pry::CommandError, "'#{prompt}' isn't a known prompt!"
+    end
+  end
+
+private
+  def prompt_map
+    Pry::Prompt::MAP
+  end
+  Pry::Commands.add_command(self)
+end

data/lib/pry/commands/code_collector.rb

@@ -0,0 +1,165 @@
+class Pry
+  class Command::CodeCollector
+    include Helpers::CommandHelpers
+
+    attr_reader :args
+    attr_reader :opts
+    attr_reader :_pry_
+
+    # The name of the explicitly given file (if any).
+    attr_accessor :file
+
+    class << self
+      attr_accessor :input_expression_ranges
+      attr_accessor :output_result_ranges
+    end
+
+    @input_expression_ranges = []
+    @output_result_ranges = []
+
+    def initialize(args, opts, _pry_)
+      @args = args
+      @opts = opts
+      @_pry_ = _pry_
+    end
+
+    # Add the `--lines`, `-o`, `-i`, `-s`, `-d` options.
+    def self.inject_options(opt)
+      @input_expression_ranges = []
+      @output_result_ranges = []
+
+      opt.on :l, :lines, "Restrict to a subset of lines. Takes a line number or range",
+                         :optional_argument => true, :as => Range, :default => 1..-1
+      opt.on :o, :out,   "Select lines from Pry's output result history. Takes an index or range",
+      :optional_argument => true, :as => Range, :default => -5..-1 do |r|
+        output_result_ranges << (r || (-5..-1))
+      end
+      opt.on :i, :in,    "Select lines from Pry's input expression history. Takes an index or range",
+      :optional_argument => true, :as => Range, :default => -5..-1 do |r|
+        input_expression_ranges << (r || (-5..-1))
+      end
+      opt.on :s, :super, "Select the 'super' method. Can be repeated to traverse the ancestors",
+                         :as => :count
+      opt.on :d, :doc,   "Select lines from the code object's documentation"
+    end
+
+    # The content (i.e code/docs) for the selected object.
+    # If the user provided a bare code object, it returns the source.
+    # If the user provided the `-i` or `-o` switches, it returns the
+    # selected input/output lines joined as a string. If the user used
+    # `-d CODE_OBJECT` it returns the docs for that code object.
+    #
+    # @return [String]
+    def content
+      return @content if @content
+      raise CommandError, "Only one of --out, --in, --doc and CODE_OBJECT may be specified." if bad_option_combination?
+
+      content = case
+                when opts.present?(:o)
+                  pry_output_content
+                when opts.present?(:i)
+                  pry_input_content
+                when opts.present?(:d)
+                  code_object_doc
+                else
+                  code_object_source_or_file
+                end
+
+      @content ||= restrict_to_lines(content, line_range)
+    end
+
+    # The code object
+    #
+    # @return [Pry::WrappedModule, Pry::Method, Pry::Command]
+    def code_object
+      Pry::CodeObject.lookup(obj_name, _pry_,  :super =>  opts[:super])
+    end
+
+    # Given a string and a range, return the `range` lines of that
+    # string.
+    #
+    # @param [String] content
+    # @param [Range, Fixnum] range
+    # @return [String] The string restricted to the given range
+    def restrict_to_lines(content, range)
+      Array(content.lines.to_a[range]).join
+    end
+
+    # The selected `_pry_.output_array` as a string, as specified by
+    # the `-o` switch.
+    #
+    # @return [String]
+    def pry_output_content
+      pry_array_content_as_string(_pry_.output_array, self.class.output_result_ranges) do |v|
+        _pry_.config.gist.inspecter.call(v)
+      end
+    end
+
+    # The selected `_pry_.input_array` as a string, as specified by
+    # the `-i` switch.
+    #
+    # @return [String]
+    def pry_input_content
+      pry_array_content_as_string(_pry_.input_array, self.class.input_expression_ranges) { |v| v }
+    end
+
+    # The line range passed to `--lines`, converted to a 0-indexed range.
+    def line_range
+      opts.present?(:lines) ? one_index_range_or_number(opts[:lines]) : 0..-1
+    end
+
+    # Name of the object argument
+    def obj_name
+      @obj_name ||= args.empty? ? "" : args.join(" ")
+    end
+
+    private
+
+    def bad_option_combination?
+      [opts.present?(:in), opts.present?(:out),
+       !args.empty?].count(true) > 1
+    end
+
+    def pry_array_content_as_string(array, ranges, &block)
+      all = ''
+      ranges.each do |range|
+        raise CommandError, "Minimum value for range is 1, not 0." if convert_to_range(range).first == 0
+
+        ranged_array = Array(array[range]) || []
+        ranged_array.compact.each { |v| all << block.call(v) }
+      end
+
+      all
+    end
+
+    def code_object_doc
+      (code_object && code_object.doc) or could_not_locate(obj_name)
+    end
+
+    def code_object_source_or_file
+      (code_object && code_object.source) || file_content
+    end
+
+    def file_content
+      if File.exists?(obj_name)
+        # Set the file accessor.
+        self.file = obj_name
+        File.read(obj_name)
+      else
+        could_not_locate(obj_name)
+      end
+    end
+
+    def could_not_locate(name)
+      raise CommandError, "Cannot locate: #{name}!"
+    end
+
+    def convert_to_range(n)
+      if !n.is_a?(Range)
+        (n..n)
+      else
+        n
+      end
+    end
+  end
+end