pryx 0.12.0 → 0.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32be9dee5f11b22b7cc96644943a86adf5ae51a1e634e4c16a5cdd01b8245b3a
-  data.tar.gz: 5b2d22c7c2177ccd9ef3ac0813ec67bc354e457cb5d0880ef2f20966e2062dfd
+  metadata.gz: c0a4fd9f677ce53582ab29d0aa651a8f882430ad9f38b3e09a4f0241b45258b3
+  data.tar.gz: 3ea2ef13871304a19da84298d3c69f8a8a7ff3988611927ae5827e2117dc3f8a
 SHA512:
-  metadata.gz: 6d77e2d271fe47d4b5028a7af1ea51cd1dd443220d12ce21e9c720fe356ea126607d65b3af260f902fe80efffeacf7998873dcdb5dac00ec0d2ea320dbb8d590
-  data.tar.gz: 1708bfeafb9e2c95e71887e7e64b7cadac8816b6797ec582dd40739629ecce302cb10340d1f5d78add4cace5151ae1a5c1f68cefc84ca6988084153bfee090bc
+  metadata.gz: b85934aaac5f9df4959d02f68d744e076f2a5d5bbd23bc0ec139727623899779500b214620608c57362348f70c274e241b45bcdb6acd9a0ff622dccb8d6e279e
+  data.tar.gz: a350c9b58d4b744611534709cf3aa0c63132cf3e68547801223a8c5baa70056440f89394ea8fa51c837fda44c18d3c7fefa3a507269d18474accc4c859eae022

data/lib/pry-stack_explorer/commands.rb

@@ -0,0 +1,365 @@
+module PryStackExplorer
+  module FrameHelpers
+    private
+
+    # @return [PryStackExplorer::FrameManager] The active frame manager for
+    #   the current `Pry` instance.
+    def frame_manager
+      PryStackExplorer.frame_manager(pry_instance)
+    end
+
+    # @return [Array<PryStackExplorer::FrameManager>] All the frame
+    #   managers for the current `Pry` instance.
+    def frame_managers
+      PryStackExplorer.frame_managers(pry_instance)
+    end
+
+    # @return [Boolean] Whether there is a context to return to once
+    #   the current `frame_manager` is popped.
+    def prior_context_exists?
+      frame_managers.count > 1 || frame_manager.prior_binding
+    end
+
+    # Return a description of the frame (binding).
+    # This is only useful for regular old bindings that have not been
+    # enhanced by `#of_caller`.
+    # @param [Binding] b The binding.
+    # @return [String] A description of the frame (binding).
+    def frame_description(b)
+      b_self = b.eval('self')
+      b_method = b.eval('__method__')
+
+      if b_method && b_method != :__binding__ && b_method != :__binding_impl__
+        b_method.to_s
+      elsif b_self.instance_of?(Module)
+        "<module:#{b_self}>"
+      elsif b_self.instance_of?(Class)
+        "<class:#{b_self}>"
+      else
+        "<main>"
+      end
+    end
+
+    # Return a description of the passed binding object. Accepts an
+    # optional `verbose` parameter.
+    # @param [Binding] b The binding.
+    # @param [Boolean] verbose Whether to generate a verbose description.
+    # @return [String] The description of the binding.
+    def frame_info(b, verbose = false)
+      meth = b.eval('__method__')
+      b_self = b.eval('self')
+      meth_obj = Pry::Method.from_binding(b) if meth
+
+      type = b.frame_type ? "[#{b.frame_type}]".ljust(9) : ""
+      desc = b.frame_description ? "#{b.frame_description}" : "#{frame_description(b)}"
+      sig = meth_obj ? "<#{signature_with_owner(meth_obj)}>" : ""
+
+      self_clipped = "#{Pry.view_clip(b_self)}"
+      path = '@ ' + b.source_location.join(':')
+
+      if !verbose
+        "#{type} #{desc} #{sig}"
+      else
+        "#{type} #{desc} #{sig}\n      in #{self_clipped} #{path}"
+      end
+    end
+
+    # @param [Pry::Method] meth_obj The method object.
+    # @return [String] Signature for the method object in Class#method format.
+    def signature_with_owner(meth_obj)
+      if !meth_obj.undefined?
+        args = meth_obj.parameters.inject([]) do |arr, (type, name)|
+          name ||= (type == :block ? 'block' : "arg#{arr.size + 1}")
+          arr << case type
+                 when :req   then name.to_s
+                 when :opt   then "#{name}=?"
+                 when :rest  then "*#{name}"
+                 when :block then "&#{name}"
+                 else '?'
+                 end
+        end
+        "#{meth_obj.name_with_owner}(#{args.join(', ')})"
+      else
+        "#{meth_obj.name_with_owner}(UNKNOWN) (undefined method)"
+      end
+    end
+
+    #  Regexp.new(args[0])
+    def find_frame_by_regex(regex, up_or_down)
+      frame_index = find_frame_by_block(up_or_down) do |b|
+        b.eval("__method__").to_s =~ regex
+      end
+
+      if frame_index
+        frame_index
+      else
+        raise Pry::CommandError, "No frame that matches #{regex.source} found!"
+      end
+    end
+
+    def find_frame_by_object_regex(class_regex, method_regex, up_or_down)
+      frame_index = find_frame_by_block(up_or_down) do |b|
+        class_match = b.eval("self.class").to_s =~ class_regex
+        meth_match = b.eval("__method__").to_s =~ method_regex
+
+        class_match && meth_match
+      end
+
+      if frame_index
+        frame_index
+      else
+        raise Pry::CommandError, "No frame that matches #{class_regex.source}" + '#' + "#{method_regex.source} found!"
+      end
+    end
+
+    def find_frame_by_block(up_or_down)
+      start_index = frame_manager.binding_index
+
+      if up_or_down == :down
+        enum = frame_manager.bindings[0..start_index - 1].reverse_each
+      else
+        enum = frame_manager.bindings[start_index + 1..-1]
+      end
+
+      new_frame = enum.find do |b|
+        yield(b)
+      end
+
+      frame_manager.bindings.index(new_frame)
+    end
+  end
+
+
+  Commands = Pry::CommandSet.new do
+    create_command "up", "Go up to the caller's context." do
+      include FrameHelpers
+
+      banner <<-BANNER
+        Usage: up [OPTIONS]
+          Go up to the caller's context. Accepts optional numeric parameter for how many frames to move up.
+          Also accepts a string (regex) instead of numeric; for jumping to nearest parent method frame which matches the regex.
+          e.g: up      #=> Move up 1 stack frame.
+          e.g: up 3    #=> Move up 2 stack frames.
+          e.g: up meth #=> Jump to nearest parent stack frame whose method matches /meth/ regex, i.e `my_method`.
+      BANNER
+
+      def process
+        inc = args.first.nil? ? "1" : args.first
+
+        if !frame_manager
+          raise Pry::CommandError, "Nowhere to go!"
+        else
+          if inc =~ /\d+/
+            frame_manager.change_frame_to frame_manager.binding_index + inc.to_i
+          elsif match = /^([A-Z]+[^#.]*)(#|\.)(.+)$/.match(inc)
+            new_frame_index = find_frame_by_object_regex(Regexp.new(match[1]), Regexp.new(match[3]), :up)
+            frame_manager.change_frame_to new_frame_index
+          elsif inc =~ /^[^-].*$/
+            new_frame_index = find_frame_by_regex(Regexp.new(inc), :up)
+            frame_manager.change_frame_to new_frame_index
+          end
+        end
+      end
+    end
+
+    create_command "down", "Go down to the callee's context." do
+      include FrameHelpers
+
+      banner <<-BANNER
+        Usage: down [OPTIONS]
+          Go down to the callee's context. Accepts optional numeric parameter for how many frames to move down.
+          Also accepts a string (regex) instead of numeric; for jumping to nearest child method frame which matches the regex.
+          e.g: down      #=> Move down 1 stack frame.
+          e.g: down 3    #=> Move down 2 stack frames.
+          e.g: down meth #=> Jump to nearest child stack frame whose method matches /meth/ regex, i.e `my_method`.
+      BANNER
+
+      def process
+        inc = args.first.nil? ? "1" : args.first
+
+        if !frame_manager
+          raise Pry::CommandError, "Nowhere to go!"
+        else
+          if inc =~ /\d+/
+            if frame_manager.binding_index - inc.to_i < 0
+              raise Pry::CommandError, "At bottom of stack, cannot go further!"
+            else
+              frame_manager.change_frame_to frame_manager.binding_index - inc.to_i
+            end
+          elsif match = /^([A-Z]+[^#.]*)(#|\.)(.+)$/.match(inc)
+            new_frame_index = find_frame_by_object_regex(Regexp.new(match[1]), Regexp.new(match[3]), :down)
+            frame_manager.change_frame_to new_frame_index
+          elsif inc =~ /^[^-].*$/
+            new_frame_index = find_frame_by_regex(Regexp.new(inc), :down)
+            frame_manager.change_frame_to new_frame_index
+          end
+        end
+      end
+    end
+
+    create_command "frame", "Switch to a particular frame." do
+      include FrameHelpers
+
+      banner <<-BANNER
+        Usage: frame [OPTIONS]
+          Switch to a particular frame. Accepts numeric parameter (or regex for method name) for the target frame to switch to (use with show-stack).
+          Negative frame numbers allowed. When given no parameter show information about the current frame.
+
+          e.g: frame 4         #=> jump to the 4th frame
+          e.g: frame meth      #=> jump to nearest parent stack frame whose method matches /meth/ regex, i.e `my_method`
+          e.g: frame -2        #=> jump to the second-to-last frame
+          e.g: frame           #=> show information info about current frame
+      BANNER
+
+      def process
+        if !frame_manager
+          raise Pry::CommandError, "nowhere to go!"
+        else
+
+          if args[0] =~ /\d+/
+            frame_manager.change_frame_to args[0].to_i
+          elsif match = /^([A-Z]+[^#.]*)(#|\.)(.+)$/.match(args[0])
+            new_frame_index = find_frame_by_object_regex(Regexp.new(match[1]), Regexp.new(match[3]), :up)
+            frame_manager.change_frame_to new_frame_index
+          elsif args[0] =~ /^[^-].*$/
+            new_frame_index = find_frame_by_regex(Regexp.new(args[0]), :up)
+            frame_manager.change_frame_to new_frame_index
+          else
+            output.puts "##{frame_manager.binding_index} #{frame_info(target, true)}"
+          end
+        end
+      end
+    end
+
+    create_command "stack", "Show all frames" do
+      include FrameHelpers
+
+      banner <<-BANNER
+        Usage: stack [OPTIONS]
+          Show all accessible stack frames.
+          e.g: stack -v
+
+          alias: show-stack
+      BANNER
+
+      def options(opt)
+        opt.on :v, :verbose, "Include extra information."
+        opt.on :H, :head, "Display the first N stack frames (defaults to 10).", :optional_argument => true, :as => Integer, :default => 10
+        opt.on :T, :tail, "Display the last N stack frames (defaults to 10).", :optional_argument => true, :as => Integer, :default => 10
+        opt.on :c, :current, "Display N frames either side of current frame (default to 5).", :optional_argument => true, :as => Integer, :default => 5
+        opt.on :a, :app, "Display application frames only", optional_argument: true
+      end
+
+      def memoized_info(index, b, verbose)
+        frame_manager.user[:frame_info] ||= Hash.new { |h, k| h[k] = [] }
+
+        if verbose
+          frame_manager.user[:frame_info][:v][index]      ||= frame_info(b, verbose)
+        else
+          frame_manager.user[:frame_info][:normal][index] ||= frame_info(b, verbose)
+        end
+      end
+
+      private :memoized_info
+
+      # @return [Array<Fixnum, Array<Binding>>] Return tuple of
+      #   base_frame_index and the array of frames.
+      def selected_stack_frames
+        if opts.present?(:head)
+          [0, frame_manager.bindings[0..(opts[:head] - 1)]]
+
+        elsif opts.present?(:tail)
+          tail = opts[:tail]
+          if tail > frame_manager.bindings.size
+            tail = frame_manager.bindings.size
+          end
+
+          base_frame_index = frame_manager.bindings.size - tail
+          [base_frame_index, frame_manager.bindings[base_frame_index..-1]]
+
+        elsif opts.present?(:current)
+          first_frame_index = frame_manager.binding_index - (opts[:current])
+          first_frame_index = 0 if first_frame_index < 0
+          last_frame_index = frame_manager.binding_index + (opts[:current])
+          [first_frame_index, frame_manager.bindings[first_frame_index..last_frame_index]]
+
+        else
+          [0, frame_manager.bindings]
+        end
+      end
+
+      private :selected_stack_frames
+
+      def process
+        return no_stack_available! unless frame_manager
+
+        title = "Showing all accessible frames in stack (#{frame_manager.bindings.size} in total):"
+
+        content = [
+          bold(title),
+          "---",
+          make_stack_lines
+        ].join("\n")
+
+        stagger_output content
+      end
+
+      private
+
+      def make_stack_lines
+        frames_with_indices.map do |b, i|
+          make_stack_line(b, i, (i == frame_manager.binding_index))
+        end.join("\n")
+      end
+
+      def frames_with_indices
+        if opts.present?(:app) && defined?(ActiveSupport::BacktraceCleaner)
+          app_frames
+        else
+          offset_frames
+        end
+      end
+
+      # "=> #0  method_name <Class#method(...)>"
+      def make_stack_line(b, i, active)
+        arw = active ? "=>" : "  "
+
+        "#{arw} ##{i} #{memoized_info(i, b, opts[:v])}"
+      end
+
+      def offset_frames
+        base_frame_index, frames = selected_stack_frames
+
+        frames.each_with_index.map do |frame, index|
+          [frame, index + base_frame_index]
+        end
+      end
+
+      def no_stack_available!
+        output.puts "No caller stack available!"
+      end
+
+      LOCATION_LAMBDA = ->(_binding){ _binding.source_location[0] }
+
+      def app_frames
+        locations = frame_manager.bindings.map(&LOCATION_LAMBDA)
+        filtered = backtrace_cleaner.clean(locations)
+
+        frame_manager.bindings
+          .each_with_index
+          .map
+          .select do |_binding, _index|
+            LOCATION_LAMBDA.call(_binding).in?(filtered)
+          end
+      end
+
+      # also see Rails::BacktraceCleaner
+      def backtrace_cleaner
+        @backtrace_cleaner ||= ActiveSupport::BacktraceCleaner.new
+      end
+    end
+
+    alias_command "show-stack", "stack"
+
+  end
+end

data/lib/pry-stack_explorer/frame_manager.rb

@@ -0,0 +1,85 @@
+module PryStackExplorer
+
+  # 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_explorer/version.rb

@@ -0,0 +1,3 @@
+module PryStackExplorer
+  VERSION = '0.6.1'
+end

data/lib/pry-stack_explorer/when_started_hook.rb

@@ -0,0 +1,96 @@
+module PryStackExplorer
+  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 !PryStackExplorer.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
+
+      PryStackExplorer.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)
+      return bindings if start_frames.empty?
+
+      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 / pry-byebug frames
+    def remove_debugger_frames(bindings)
+      bindings.drop_while { |b| b.source_location[0] =~ /pry-(?:nav|debugger|byebug)/ }
+    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/lib/pry-stack_explorer.rb

@@ -0,0 +1,138 @@
+# pry-stack_explorer.rb
+# (C) John Mair (banisterfiend); MIT license
+
+require "pry" unless defined?(::Pry)
+require "pry-stack_explorer/version"
+require "pry-stack_explorer/commands"
+require "pry-stack_explorer/frame_manager"
+require "pry-stack_explorer/when_started_hook"
+require "binding_of_caller"
+
+module PryStackExplorer
+
+  # short-hand for `PryStackExplorer`
+  ::SE = self
+
+  class << self
+    # @return [Hash] The hash storing all frames for all Pry instances for
+    #   the current thread.
+    def frame_hash
+      Thread.current[:__pry_frame_managers__] ||= Hash.new { |h, k| h[k] = [] }
+    end
+
+    # Return the complete frame manager stack for the Pry instance
+    # @param [Pry] _pry_ The Pry instance associated with the frame
+    #   managers
+    # @return [Array] The stack of Pry::FrameManager objections
+    def frame_managers(_pry_)
+      frame_hash[_pry_]
+    end
+
+    # Create a `Pry::FrameManager` object and push it onto the frame
+    # manager stack for the relevant `_pry_` instance.
+    # @param [Array] bindings The array of bindings (frames)
+    # @param [Pry] _pry_ The Pry instance associated with the frame manager
+    def create_and_push_frame_manager(bindings, _pry_, options={})
+      fm = FrameManager.new(bindings, _pry_)
+      frame_hash[_pry_].push fm
+      push_helper(fm, options)
+      fm
+    end
+
+    # Update the Pry instance to operate on the specified frame for the
+    # current frame manager.
+    # @param [PryStackExplorer::FrameManager] fm The active frame manager.
+    # @param [Hash] options The options hash.
+    def push_helper(fm, options={})
+      options = {
+        :initial_frame => 0
+      }.merge!(options)
+
+      fm.change_frame_to(options[:initial_frame], false)
+    end
+
+    private :push_helper
+
+    # Delete the currently active frame manager
+    # @param [Pry] _pry_ The Pry instance associated with the frame
+    #   managers.
+    # @return [Pry::FrameManager] The popped frame manager.
+    def pop_frame_manager(_pry_)
+      return if frame_managers(_pry_).empty?
+
+      popped_fm = frame_managers(_pry_).pop
+      pop_helper(popped_fm, _pry_)
+      popped_fm
+    end
+
+    # Restore the Pry instance to operate on the previous
+    # binding. Also responsible for restoring Pry instance's backtrace.
+    # @param [Pry::FrameManager] popped_fm The recently popped frame manager.
+    # @param [Pry] _pry_ The Pry instance associated with the frame managers.
+    def pop_helper(popped_fm, _pry_)
+      if frame_managers(_pry_).empty?
+        if _pry_.binding_stack.empty?
+          _pry_.binding_stack.push popped_fm.prior_binding
+        else
+          _pry_.binding_stack[-1] = popped_fm.prior_binding
+        end
+
+        frame_hash.delete(_pry_)
+      else
+        frame_manager(_pry_).refresh_frame(false)
+      end
+
+      # restore backtrace
+      _pry_.backtrace = popped_fm.prior_backtrace
+    end
+
+    private :pop_helper
+
+    # Clear the stack of frame managers for the Pry instance
+    # @param [Pry] _pry_ The Pry instance associated with the frame managers
+    def clear_frame_managers(_pry_)
+      pop_frame_manager(_pry_) until frame_managers(_pry_).empty?
+      frame_hash.delete(_pry_) # this line should be unnecessary!
+    end
+
+    alias_method :delete_frame_managers, :clear_frame_managers
+
+    # @return [PryStackExplorer::FrameManager] The currently active frame manager
+    def frame_manager(_pry_)
+      frame_hash[_pry_].last
+    end
+
+    # Simple test to check whether two `Binding` objects are equal.
+    # @param [Binding] b1 First binding.
+    # @param [Binding] b2 Second binding.
+    # @return [Boolean] Whether the `Binding`s are equal.
+    def bindings_equal?(b1, b2)
+      (b1.eval('self').equal?(b2.eval('self'))) &&
+        (b1.eval('__method__') == b2.eval('__method__')) &&
+        (b1.eval('local_variables').map { |v| b1.eval("#{v}") }.equal?(
+         b2.eval('local_variables').map { |v| b2.eval("#{v}") }))
+    end
+  end
+end
+
+Pry.config.hooks.add_hook(:after_session, :delete_frame_manager) do |_, _, _pry_|
+  PryStackExplorer.clear_frame_managers(_pry_)
+end
+
+Pry.config.hooks.add_hook(:when_started, :save_caller_bindings, PryStackExplorer::WhenStartedHook.new)
+
+# Import the StackExplorer commands
+Pry.config.commands.import PryStackExplorer::Commands
+
+# monkey-patch the whereami command to show some frame information,
+# useful for navigating stack.
+Pry.config.hooks.add_hook(:before_whereami, :stack_explorer) do
+  if PryStackExplorer.frame_manager(pry_instance) && !internal_binding?(target)
+    bindings      = PryStackExplorer.frame_manager(pry_instance).bindings
+    binding_index = PryStackExplorer.frame_manager(pry_instance).binding_index
+
+    output.puts "\n"
+    output.puts "#{Pry::Helpers::Text.bold('Frame number:')} #{binding_index}/#{bindings.size - 1}"
+    output.puts "#{Pry::Helpers::Text.bold('Frame type:')} #{bindings[binding_index].frame_type}" if bindings[binding_index].frame_type
+  end
+end

data/lib/pryx/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Pryx
-  VERSION = [0, 12, 0]
+  VERSION = [0, 12, 1]
 
   class << VERSION
     include Comparable

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pryx
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.12.1
 platform: ruby
 authors:
 - Billy.Zheng(zw963)
@@ -136,19 +136,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.6'
 - !ruby/object:Gem::Dependency
-  name: pry-stack_explorer
+  name: binding_of_caller
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: m
   requirement: !ruby/object:Gem::Requirement
@@ -222,6 +222,11 @@ files:
 - lib/pry-nav/tracer.rb
 - lib/pry-nav/version.rb
 - lib/pry-remote.rb
+- lib/pry-stack_explorer.rb
+- lib/pry-stack_explorer/commands.rb
+- lib/pry-stack_explorer/frame_manager.rb
+- lib/pry-stack_explorer/version.rb
+- lib/pry-stack_explorer/when_started_hook.rb
 - lib/pry-state.rb
 - lib/pry-state/hook_action.rb
 - lib/pry-state/printer.rb