pry-stack_explorer 0.6.1 → 0.6.2

data/test/commands_test.rb

@@ -0,0 +1,353 @@
+require_relative 'test_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 "Commands" do
+  let(:bingbong){ BingBong.new }
+
+  include ResetHelper
+
+  before do
+    method_list = []
+    @top = Top.new method_list
+  end
+
+
+  describe "stack" do
+    it "outputs the call stack" do
+      output = issue_pry_commands("stack"){ bingbong.bing }
+
+      expect(output).to match(/bang.*?bong.*?bing/m)
+    end
+
+    it "supports 'show-stack' as an alias" do
+      output = issue_pry_commands("show-stack"){ bingbong.bing }
+
+      expect(output).to match(/bang.*?bong.*?bing/m)
+    end
+  end
+
+  describe "up" do
+    it 'should move up the call stack one frame at a time' do
+      redirect_pry_io(InputTester.new("@methods << __method__",
+                                      "up",
+                                      "@methods << __method__",
+                                      "up",
+                                      "@methods << __method__",
+                                      "exit-all"), out=StringIO.new) do
+        bingbong.bing
+      end
+
+      expect(bingbong.methods).to eq [:bang, :bong, :bing]
+    end
+
+    it 'should move up the call stack two frames at a time' do
+      redirect_pry_io(InputTester.new("@methods << __method__",
+                                      "up 2",
+                                      "@methods << __method__",
+                                      "exit-all"), out=StringIO.new) do
+        bingbong.bing
+      end
+
+      expect(bingbong.methods).to eq [:bang, :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("@methods << __method__",
+                                        "up bi",
+                                        "@methods << __method__",
+                                        "exit-all"), out=StringIO.new) do
+          bingbong.bing
+        end
+
+        expect(bingbong.methods).to eq [:bang, :bing]
+      end
+
+      it 'should move through all methods that match regex in order' do
+        redirect_pry_io(InputTester.new("@methods << __method__",
+                                        "up b",
+                                        "@methods << __method__",
+                                        "up b",
+                                        "@methods << __method__",
+                                        "exit-all"), out=StringIO.new) do
+          bingbong.bing
+        end
+
+        expect(bingbong.methods).to eq [:bang, :bong, :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
+          bingbong.bing
+        end
+
+        expect(out.string).to match(/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
+
+        expect(@top.method_list).to eq(['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
+
+        expect(@top.method_list).to eq(['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
+
+        expect(@top.method_list).to eq(['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
+
+        expect(out.string).to match(/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 bingbong.bang() Pry.start(binding, :initial_frame => 1) end
+
+      redirect_pry_io(InputTester.new("@methods << __method__",
+                                      "down",
+                                      "@methods << __method__",
+                                      "exit-all"), out=StringIO.new) do
+        bingbong.bing
+      end
+
+      expect(bingbong.methods).to eq [:bong, :bang]
+    end
+
+    it 'should move down the call stack two frames at a time' do
+      def bingbong.bang() Pry.start(binding, :initial_frame => 2) end
+
+      redirect_pry_io(InputTester.new("@methods << __method__",
+                                      "down 2",
+                                      "@methods << __method__",
+                                      "exit-all"), out=StringIO.new) do
+        bingbong.bing
+      end
+
+      expect(bingbong.methods).to eq [:bing, :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",
+                                        "@methods << __method__",
+                                        "exit-all"), out=StringIO.new) do
+          bingbong.bing
+        end
+
+        expect(bingbong.methods[0]).to eq(:bong)
+      end
+
+      it 'should move through all methods that match regex in order' do
+        redirect_pry_io(InputTester.new("frame bing",
+                                        "@methods << __method__",
+                                        "down b",
+                                        "@methods << __method__",
+                                        "down b",
+                                        "@methods << __method__",
+                                        "exit-all"), out=StringIO.new) do
+          bingbong.bing
+        end
+
+        expect(bingbong.methods).to eq [:bing, :bong, :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
+          bingbong.bing
+        end
+
+        expect(out.string).to match(/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
+
+        expect(@top.method_list).to eq(['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
+
+        expect(out.string).to match(/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",
+                                        "@methods << __method__",
+                                        "exit-all"), out=StringIO.new) do
+          bingbong.bing
+        end
+
+        expect(bingbong.methods[0]).to eq(: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
+          bingbong.bing
+        end
+
+        expect(out.string).to match(/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",
+                                      "@methods << __method__",
+                                      "exit-all"), out=StringIO.new) do
+        bingbong.bing
+      end
+
+      expect(bingbong.methods[0]).to eq(: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
+        bingbong.bing
+      end
+
+      expect(out.string).to match(/\#0.*?bang/)
+      expect(out.string).not_to match(/\#1/)
+    end
+
+    describe "negative indices" do
+      class AlphaBetaGamma
+        attr_accessor :frame, :frame_number
+
+        def alpha; binding; end
+        def beta; binding; end
+        def gamma; binding; end
+      end
+
+      let(:alphabetagamma){ AlphaBetaGamma.new }
+
+      it 'should work with negative frame numbers' do
+        o = AlphaBetaGamma.new
+
+        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
+          expect(o.frame).to eq(method_names[idx])
+        end
+      end
+
+      it 'should convert negative indices to their positive counterparts' do
+        o = AlphaBetaGamma.new
+
+        call_stack = [o.alpha, o.beta, o.gamma]
+
+        (1..3).each_with_index do |v, idx|
+          issue_pry_commands(
+            "frame -#{v}",
+            "@frame_number = PryStackExplorer.frame_manager(pry_instance).binding_index",
+            "exit-all"
+          ){ Pry.start(o, call_stack: call_stack) }
+
+          expect(o.frame_number).to eq(call_stack.size - v)
+        end
+      end
+    end
+  end
+end

data/test/frame_manager_test.rb

@@ -0,0 +1,68 @@
+require_relative 'test_helper'
+
+describe PryStackExplorer::FrameManager do
+  before :all do
+    redirect_pry_output!
+  end
+
+  before do
+    @pry_instance = Pry.new
+    @bindings = [binding, binding, binding, binding]
+    @bindings.each_with_index { |v, i| v.eval("x = #{i}") }
+    @pry_instance.binding_stack.push @bindings.last
+    @frame_manager = PE::FrameManager.new(@bindings, @pry_instance)
+  end
+
+  describe "creation" do
+    it "should make bindings accessible via 'bindings' method" do
+      expect(@frame_manager.bindings).to eq(@bindings)
+    end
+
+    it "should set binding_index to 0" do
+      expect(@frame_manager.binding_index).to eq(0)
+    end
+
+    it "should set current_frame to first frame" do
+      expect(@frame_manager.current_frame).to eq(@bindings.first)
+    end
+  end
+
+  describe "FrameManager#change_frame_to" do
+    it 'should change the frame to the given one' do
+      @frame_manager.change_frame_to(1)
+
+      expect(@frame_manager.binding_index).to eq(1)
+      expect(@frame_manager.current_frame).to eq(@bindings[1])
+      expect(@pry_instance.binding_stack.last).to eq(@frame_manager.current_frame)
+    end
+
+    it 'should accept negative indices when specifying frame' do
+      @frame_manager.change_frame_to(-1)
+
+      # negative index is converted to a positive one inside change_frame_to
+      expect(@frame_manager.binding_index).to eq(@bindings.size - 1)
+      expect(@frame_manager.current_frame).to eq(@bindings[-1])
+      expect(@pry_instance.binding_stack.last).to eq(@frame_manager.current_frame)
+    end
+  end
+
+  describe "FrameManager#refresh_frame" do
+    it 'should change the Pry frame to the active one in the FrameManager' do
+      @frame_manager.binding_index = 2
+      @frame_manager.refresh_frame
+
+      expect(@pry_instance.binding_stack.last).to eq(@frame_manager.current_frame)
+    end
+  end
+
+  describe "FrameManager is Enumerable" do
+    it 'should perform an Enumerable#map on the frames' do
+      result = @frame_manager.map { |v| v.eval("x") }
+
+      expect(result).to eq(
+        (0..(@bindings.size - 1)).to_a
+      )
+    end
+  end
+
+end