pry-stack 0.5.0

data/lib/pry-stack/frame_manager.rb

@@ -0,0 +1,85 @@
+module PryStack
+
+  # This class represents a call-stack. It stores the
+  # frames that make up the stack and is responsible for updating the
+  # associated Pry instance to reflect the active frame. It is fully Enumerable.
+  class FrameManager
+    include Enumerable
+
+    # @return [Array<Binding>] The array of bindings that constitute
+    #   the call-stack.
+    attr_accessor :bindings
+
+    # @return [Fixnum] The index of the active frame (binding) in the call-stack.
+    attr_accessor :binding_index
+
+    # @return [Hash] A hash for user defined data
+    attr_reader :user
+
+    # @return [Binding] The binding of the Pry instance before the
+    #   FrameManager took over.
+    attr_reader :prior_binding
+
+    # @return [Array] The backtrace of the Pry instance before the
+    #   FrameManager took over.
+    attr_reader :prior_backtrace
+
+    def initialize(bindings, _pry_)
+      self.bindings      = bindings
+      self.binding_index = 0
+      @pry               = _pry_
+      @user              = {}
+      @prior_binding     = _pry_.binding_stack.last
+      @prior_backtrace   = _pry_.backtrace
+    end
+
+    # Iterate over all frames
+    def each(&block)
+      bindings.each(&block)
+    end
+
+    # Ensure the Pry instance's active binding is the frame manager's
+    # active binding.
+    def refresh_frame(run_whereami=true)
+      change_frame_to binding_index, run_whereami
+    end
+
+    # @return [Binding] The currently active frame
+    def current_frame
+      bindings[binding_index]
+    end
+
+    # Set the binding index (aka frame index), but raising an Exception when invalid
+    # index received. Also converts negative indices to their positive counterparts.
+    # @param [Fixnum] index The index.
+    def set_binding_index_safely(index)
+      if index > bindings.size - 1
+        raise Pry::CommandError, "At top of stack, cannot go further!"
+      elsif index < -bindings.size
+        raise Pry::CommandError, "At bottom of stack, cannot go further!"
+      else
+        # wrap around negative indices
+        index = (bindings.size - 1) + index + 1 if index < 0
+
+        self.binding_index = index
+      end
+    end
+
+    # Change active frame to the one indexed by `index`.
+    # Note that indexing base is `0`
+    # @param [Fixnum] index The index of the frame.
+    def change_frame_to(index, run_whereami=true)
+
+      set_binding_index_safely(index)
+
+      if @pry.binding_stack.empty?
+        @pry.binding_stack.replace [bindings[binding_index]]
+      else
+        @pry.binding_stack[-1] = bindings[binding_index]
+      end
+
+      @pry.run_command "whereami" if run_whereami
+    end
+
+  end
+end

data/lib/pry-stack/when_started_hook.rb

@@ -0,0 +1,94 @@
+module PryStack
+  class WhenStartedHook
+    include Pry::Helpers::BaseHelpers
+
+    def caller_bindings(target)
+      bindings = binding.callers
+
+      bindings = remove_internal_frames(bindings)
+      bindings = remove_debugger_frames(bindings)
+      bindings = bindings.drop(1) if pry_method_frame?(bindings.first)
+
+      # Use the binding returned by #of_caller if possible (as we get
+      # access to frame_type).
+      # Otherwise stick to the given binding (target).
+      if !PryStack.bindings_equal?(target, bindings.first)
+        bindings.shift
+        bindings.unshift(target)
+      end
+
+      bindings
+    end
+
+    def call(target, options, _pry_)
+      target ||= _pry_.binding_stack.first if _pry_
+      options = {
+        :call_stack    => true,
+        :initial_frame => 0
+      }.merge!(options)
+
+      return if !options[:call_stack]
+
+      if options[:call_stack].is_a?(Array)
+        bindings = options[:call_stack]
+
+        if !valid_call_stack?(bindings)
+          raise ArgumentError, ":call_stack must be an array of bindings"
+        end
+      else
+        bindings = caller_bindings(target)
+      end
+
+      PryStack.create_and_push_frame_manager bindings, _pry_, :initial_frame => options[:initial_frame]
+    end
+
+    private
+
+    # remove internal frames related to setting up the session
+    def remove_internal_frames(bindings)
+      start_frames = internal_frames_with_indices(bindings)
+      start_frame_index = start_frames.first.last
+
+      if start_frames.size >= 2
+        # god knows what's going on in here
+        idx1, idx2 = start_frames.take(2).map(&:last)
+        start_frame_index = idx2 if !nested_session?(bindings[idx1..idx2])
+      end
+
+      bindings.drop(start_frame_index + 1)
+    end
+
+    # remove pry-nav / pry-debugger frames
+    def remove_debugger_frames(bindings)
+      bindings.drop_while { |b| b.eval("__FILE__") =~ /pry-(?:nav|debugger)/ }
+    end
+
+    # binding.pry frame
+    # @return [Boolean]
+    def pry_method_frame?(binding)
+      safe_send(binding.eval("__method__"), :==, :pry)
+    end
+
+    # When a pry session is started within a pry session
+    # @return [Boolean]
+    def nested_session?(bindings)
+      bindings.detect do |b|
+        safe_send(b.eval("__method__"), :==, :re) &&
+          safe_send(b.eval("self.class"), :equal?, Pry)
+      end
+    end
+
+    # @return [Array<Array<Binding, Fixnum>>]
+    def internal_frames_with_indices(bindings)
+      bindings.each_with_index.select do |b, i|
+        b.frame_type == :method &&
+          safe_send(b.eval("self"), :equal?, Pry) &&
+          safe_send(b.eval("__method__"), :==, :start)
+      end
+    end
+
+    def valid_call_stack?(bindings)
+      bindings.any? && bindings.all? { |v| v.is_a?(Binding) }
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,92 @@
+require 'rubygems'
+require 'ostruct'
+require 'pry'
+
+PRY_STACK_VERSION = File.read(File.expand_path '../../VERSION', __FILE__)
+
+unless Object.const_defined? 'PryStack'
+  $:.unshift File.expand_path '../../lib', __FILE__
+  require 'pry-stack'
+end
+
+require 'bacon'
+
+puts "---------------------------------------------------------"
+puts "Testing"
+puts "---------------------------------------------------------"
+puts "pry-stack version: #{PRY_STACK_VERSION}"
+puts "Ruby version: #{RUBY_VERSION}"
+
+PE = PryStack
+
+class << Pry
+  alias_method :orig_reset_defaults, :reset_defaults
+  def reset_defaults
+    orig_reset_defaults
+
+    Pry.color = false
+    Pry.pager = false
+    Pry.config.should_load_rc      = false
+    Pry.config.should_load_plugins = false
+    Pry.config.history.should_load = false
+    Pry.config.history.should_save = false
+    Pry.config.auto_indent         = false
+    Pry.config.hooks               = Pry::Hooks.new
+    Pry.config.collision_warning   = false
+  end
+end
+
+AfterSessionHook = Pry.config.hooks.get_hook(:after_session, :delete_frame_manager)
+WhenStartedHook  = Pry.config.hooks.get_hook(:when_started, :save_caller_bindings)
+
+Pry.reset_defaults
+
+class InputTester
+  def initialize(*actions)
+    if actions.last.is_a?(Hash) && actions.last.keys == [:history]
+      @hist = actions.pop[:history]
+    end
+    @orig_actions = actions.dup
+    @actions = actions
+  end
+
+  def readline(*)
+    @actions.shift.tap{ |line| @hist << line if @hist }
+  end
+
+  def rewind
+    @actions = @orig_actions.dup
+  end
+end
+
+# Set I/O streams.
+#
+# Out defaults to an anonymous StringIO.
+#
+def redirect_pry_io(new_in, new_out = StringIO.new)
+  old_in = Pry.input
+  old_out = Pry.output
+
+  Pry.input = new_in
+  Pry.output = new_out
+  begin
+    yield
+  ensure
+    Pry.input = old_in
+    Pry.output = old_out
+  end
+end
+
+def mock_pry(*args)
+
+  binding = args.first.is_a?(Binding) ? args.shift : binding()
+
+  input = InputTester.new(*args)
+  output = StringIO.new
+
+  redirect_pry_io(input, output) do
+    binding.pry
+  end
+
+  output.string
+end

data/test/test_commands.rb

@@ -0,0 +1,358 @@
+require 'helper'
+
+
+class Top
+  attr_accessor :method_list, :middle
+  def initialize method_list
+    @method_list = method_list
+  end
+  def bing
+    @middle = Middle.new method_list
+    @middle.bong
+  end
+end
+
+class Middle
+  attr_accessor :method_list, :bottom
+  def initialize method_list
+    @method_list = method_list
+  end
+  def bong
+    @bottom = Bottom.new method_list
+    @bottom.bang
+  end
+end
+
+class Bottom
+  attr_accessor :method_list
+  def initialize method_list
+    @method_list = method_list
+  end
+  def bang
+    Pry.start(binding)
+  end
+end
+
+
+describe PryStack::Commands do
+
+  before do
+    Pry.config.hooks.add_hook(:when_started, :save_caller_bindings, WhenStartedHook)
+    Pry.config.hooks.add_hook(:after_session, :delete_frame_manager, AfterSessionHook)
+
+    @o = Object.new
+    class << @o; attr_accessor :first_method, :second_method, :third_method; end
+    def @o.bing() bong end
+    def @o.bong() bang end
+    def @o.bang() Pry.start(binding) end
+
+    method_list = []
+    @top = Top.new method_list
+  end
+
+  after do
+    Pry.config.hooks.delete_hook(:when_started, :save_caller_bindings)
+    Pry.config.hooks.delete_hook(:after_session, :delete_frame_manager)
+  end
+
+  describe "up" do
+    it 'should move up the call stack one frame at a time' do
+      redirect_pry_io(InputTester.new("@first_method = __method__",
+                                      "up",
+                                      "@second_method = __method__",
+                                      "up",
+                                      "@third_method = __method__",
+                                      "exit-all"), out=StringIO.new) do
+        @o.bing
+      end
+
+      @o.first_method.should  == :bang
+      @o.second_method.should == :bong
+      @o.third_method.should  == :bing
+    end
+
+    it 'should move up the call stack two frames at a time' do
+      redirect_pry_io(InputTester.new("@first_method = __method__",
+                                      "up 2",
+                                      "@second_method = __method__",
+                                      "exit-all"), out=StringIO.new) do
+        @o.bing
+      end
+
+      @o.first_method.should  == :bang
+      @o.second_method.should == :bing
+    end
+
+    describe "by method name regex" do
+      it 'should move to the method name that matches the regex' do
+        redirect_pry_io(InputTester.new("@first_method = __method__",
+                                        "up bi",
+                                        "@second_method = __method__",
+                                        "exit-all"), out=StringIO.new) do
+          @o.bing
+        end
+
+        @o.first_method.should  == :bang
+        @o.second_method.should == :bing
+      end
+
+      it 'should move through all methods that match regex in order' do
+        redirect_pry_io(InputTester.new("@first_method = __method__",
+                                        "up b",
+                                        "@second_method = __method__",
+                                        "up b",
+                                        "@third_method = __method__",
+                                        "exit-all"), out=StringIO.new) do
+          @o.bing
+        end
+
+        @o.first_method.should  == :bang
+        @o.second_method.should == :bong
+        @o.third_method.should  == :bing
+      end
+
+      it 'should error if it cant find frame to match regex' do
+        redirect_pry_io(InputTester.new("up conrad_irwin",
+                                        "exit-all"), out=StringIO.new) do
+          @o.bing
+        end
+
+        out.string.should =~ /Error: No frame that matches/
+      end
+    end
+
+
+    describe 'by Class#method name regex' do
+      it 'should move to the method and class that matches the regex' do
+        redirect_pry_io(InputTester.new("@method_list << self.class.to_s + '#' + __method__.to_s",
+                                        'up Middle#bong',
+                                        "@method_list << self.class.to_s + '#' + __method__.to_s",
+                                        "exit-all"), out=StringIO.new) do
+          @top.bing
+        end
+
+        @top.method_list.should  == ['Bottom#bang', 'Middle#bong']
+      end
+
+      ### ????? ###
+      # it 'should be case sensitive' do
+      # end
+      ### ????? ###
+
+      it 'should allow partial class names' do
+          redirect_pry_io(InputTester.new("@method_list << self.class.to_s + '#' + __method__.to_s",
+                                        'up Mid#bong',
+                                        "@method_list << self.class.to_s + '#' + __method__.to_s",
+                                        "exit-all"), out=StringIO.new) do
+          @top.bing
+        end
+
+        @top.method_list.should  == ['Bottom#bang', 'Middle#bong']
+
+      end
+
+      it 'should allow partial method names' do
+          redirect_pry_io(InputTester.new("@method_list << self.class.to_s + '#' + __method__.to_s",
+                                        'up Middle#bo',
+                                        "@method_list << self.class.to_s + '#' + __method__.to_s",
+                                        "exit-all"), out=StringIO.new) do
+          @top.bing
+        end
+
+        @top.method_list.should  == ['Bottom#bang', 'Middle#bong']
+
+      end
+
+      it 'should error if it cant find frame to match regex' do
+        redirect_pry_io(InputTester.new('up Conrad#irwin',
+                                        "exit-all"), out=StringIO.new) do
+          @top.bing
+        end
+
+        out.string.should =~ /Error: No frame that matches/
+      end
+    end
+  end
+
+  describe "down" do
+    it 'should move down the call stack one frame at a time' do
+      def @o.bang() Pry.start(binding, :initial_frame => 1) end
+
+      redirect_pry_io(InputTester.new("@first_method = __method__",
+                                      "down",
+                                      "@second_method = __method__",
+                                      "exit-all"), out=StringIO.new) do
+        @o.bing
+      end
+
+      @o.first_method.should  == :bong
+      @o.second_method.should == :bang
+    end
+
+    it 'should move down the call stack two frames at a time' do
+      def @o.bang() Pry.start(binding, :initial_frame => 2) end
+
+      redirect_pry_io(InputTester.new("@first_method = __method__",
+                                      "down 2",
+                                      "@second_method = __method__",
+                                      "exit-all"), out=StringIO.new) do
+        @o.bing
+      end
+
+      @o.first_method.should  == :bing
+      @o.second_method.should == :bang
+    end
+
+    describe "by method name regex" do
+      it 'should move to the method name that matches the regex' do
+        redirect_pry_io(InputTester.new("frame -1",
+                                        "down bo",
+                                        "@first_method = __method__",
+                                        "exit-all"), out=StringIO.new) do
+          @o.bing
+        end
+
+        @o.first_method.should == :bong
+      end
+
+      it 'should move through all methods that match regex in order' do
+        redirect_pry_io(InputTester.new("frame bing",
+                                        "@first_method = __method__",
+                                        "down b",
+                                        "@second_method = __method__",
+                                        "down b",
+                                        "@third_method = __method__",
+                                        "exit-all"), out=StringIO.new) do
+          @o.bing
+        end
+
+        @o.first_method.should  == :bing
+        @o.second_method.should == :bong
+        @o.third_method.should  == :bang
+      end
+
+      it 'should error if it cant find frame to match regex' do
+        redirect_pry_io(InputTester.new("frame -1",
+                                        "down conrad_irwin",
+                                        "exit-all"), out=StringIO.new) do
+          @o.bing
+        end
+
+        out.string.should =~ /Error: No frame that matches/
+      end
+    end
+
+    describe 'by Class#method name regex' do
+      it 'should move to the method and class that matches the regex' do
+        redirect_pry_io(InputTester.new('frame Top#bing',
+                                        "@method_list << self.class.to_s + '#' + __method__.to_s",
+                                        'down Middle#bong',
+                                        "@method_list << self.class.to_s + '#' + __method__.to_s",
+                                        "exit-all"), out=StringIO.new) do
+          @top.bing
+        end
+
+        @top.method_list.should == ['Top#bing', 'Middle#bong']
+      end
+
+      ### ????? ###
+      # it 'should be case sensitive' do
+      # end
+      ### ????? ###
+
+      it 'should error if it cant find frame to match regex' do
+        redirect_pry_io(InputTester.new('down Conrad#irwin',
+                                        "exit-all"), out=StringIO.new) do
+          @top.bing
+        end
+
+        out.string.should =~ /Error: No frame that matches/
+      end
+    end
+
+  end
+
+  describe "frame" do
+    describe "by method name regex" do
+      it 'should jump to correct stack frame when given method name' do
+        redirect_pry_io(InputTester.new("frame bi",
+                                        "@first_method = __method__",
+                                        "exit-all"), out=StringIO.new) do
+          @o.bing
+        end
+
+        @o.first_method.should == :bing
+      end
+
+      it 'should NOT jump to frames lower down stack when given method name' do
+        redirect_pry_io(InputTester.new("frame -1",
+                                        "frame bang",
+                                        "exit-all"), out=StringIO.new) do
+          @o.bing
+        end
+
+        out.string.should =~ /Error: No frame that matches/
+      end
+
+    end
+
+    it 'should move to the given frame in the call stack' do
+      redirect_pry_io(InputTester.new("frame 2",
+                                      "@first_method = __method__",
+                                      "exit-all"), out=StringIO.new) do
+        @o.bing
+      end
+
+      @o.first_method.should == :bing
+    end
+
+    it 'should return info on current frame when given no parameters' do
+      redirect_pry_io(InputTester.new("frame",
+                                      "exit-all"), out=StringIO.new) do
+        @o.bing
+      end
+
+      out.string.should =~ /\#0.*?bang/
+      out.string.should.not =~ /\#1/
+    end
+
+    describe "negative indices" do
+      it 'should work with negative frame numbers' do
+        o = Object.new
+        class << o; attr_accessor :frame; end
+        def o.alpha() binding end
+        def o.beta()  binding end
+        def o.gamma() binding end
+
+        call_stack   = [o.alpha, o.beta, o.gamma]
+        method_names = call_stack.map { |v| v.eval('__method__') }.reverse
+        (1..3).each_with_index do |v, idx|
+          redirect_pry_io(InputTester.new("frame -#{v}",
+                                          "@frame = __method__",
+                                          "exit-all"), out=StringIO.new) do
+            Pry.start(o, :call_stack => call_stack)
+          end
+          o.frame.should == method_names[idx]
+        end
+      end
+
+      it 'should convert negative indices to their positive counterparts' do
+        o = Object.new
+        class << o; attr_accessor :frame_number; end
+        def o.alpha() binding end
+        def o.beta()  binding end
+        def o.gamma() binding end
+
+        call_stack   = [o.alpha, o.beta, o.gamma]
+        (1..3).each_with_index do |v, idx|
+          redirect_pry_io(InputTester.new("frame -#{v}",
+                                          "@frame_number = PryStack.frame_manager(_pry_).binding_index",
+                                          "exit-all"), out=StringIO.new) do
+            Pry.start(o, :call_stack => call_stack)
+          end
+          o.frame_number.should == call_stack.size - v
+        end
+      end
+    end
+  end
+end