pry-moves 0.1.1 → 0.1.2

data/lib/pry-stack_explorer/frame_manager.rb

@@ -0,0 +1,88 @@
+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
+
+    def filter_bindings(vapid_frames: false)
+      bindings.reject do |binding|
+        !vapid_frames and
+          binding.local_variable_defined?(:vapid_frame)
+      end
+    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 < 0
+        raise Pry::CommandError, "At bottom of stack, cannot go further"
+      else
+        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/pry-stack_explorer.rb

@@ -0,0 +1,139 @@
+# pry-stack_explorer.rb
+# (C) John Mair (banisterfiend); MIT license
+
+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.commands.before_command("whereami") do |num|
+  if PryStackExplorer.frame_manager(_pry_) && !internal_binding?(target)
+    bindings      = PryStackExplorer.frame_manager(_pry_).bindings
+    binding_index = PryStackExplorer.frame_manager(_pry_).binding_index
+
+    info = "#{Pry::Helpers::Text.bold('Frame:')} "+
+        "#{binding_index}/#{bindings.size - 1} "+
+        "#{bindings[binding_index].frame_type}"
+
+    output.puts "\n"
+    output.puts info
+  end
+end

data/lib/pry-stack_explorer/when_started_hook.rb

@@ -0,0 +1,111 @@
+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)
+
+      mark_vapid_frames(bindings)
+
+      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
+
+    def mark_vapid_frames(bindings)
+      stepped_out = false
+      actual_file, actual_method = nil, nil
+
+      bindings.each do |binding|
+        if stepped_out
+          if actual_file == binding.eval("__FILE__") and actual_method == binding.eval("__method__")
+            stepped_out = false
+          else
+            binding.local_variable_set :vapid_frame, true
+          end
+        elsif binding.frame_type == :block
+          stepped_out = true
+          actual_file = binding.eval("__FILE__")
+          actual_method = binding.eval("__method__")
+        end
+
+        if binding.local_variable_defined? :hide_from_stack
+          binding.local_variable_set :vapid_frame, true
+        end
+      end
+    end
+
+    # 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 / pry-byebug frames
+    def remove_debugger_frames(bindings)
+      bindings.drop_while { |b| b.eval("__FILE__") =~ /\/pry-/ }
+    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/playground/demo.rb

@@ -10,23 +10,54 @@ class A
     self
   end
 
+  def pre_bb
+    [1,2,3].each do
+      bb
+    end
+    puts :prebb
+  end
+
   def bb
-    block do
-      c = :some_code
+    binding.pry
+    block_func do
+      #cc
+      ff
+      a = :some_code
     end
     d = :some_code
     e = :some_code
     self
   end
 
-  def block
+  def cc
+    dd_vapid
+  end
+
+  def dd_vapid
+    hide_from_stack = true
+    ee
+  end
+
+  def ee
+    binding.pry
+  end
+
+  def ff
+    e = :ff
+  end
+
+  def block_func
     e = :some_code
-    yield
+    [1,1].each do
+      yield
+    end
     f = :other_code
   end
 
 end
 
-binding.pry
-A.new.aa.bb
+#binding.pry
+puts :aaa
+A.new.aa.pre_bb
 c = :some_code
+puts :zzz

data/playground/sand.rb

@@ -1,9 +1,8 @@
-require 'pry'
 require 'pry-moves'
 #require 'pry-nav'
 require './tracer.rb'
 
-def debug?
+def debucher?
   binding.pry
   true
 end
@@ -34,19 +33,20 @@ end
 #trace_events
 
 a = 1123
+b = binding
 
 puts :prepare
 
 binding.pry
 
-A.new.aa.bb.cc
+a = A.new.aa.bb.cc
 
 bb = 1
 
 exit
 
-pp = 123 if debug?
-binding.pry if debug?
+pp = 123 if debucher?
+binding.pry if debucher?
 
 binding.pry
 

data/playground/threads.rb

@@ -0,0 +1,26 @@
+require 'pry-moves'
+
+Thread.current[:name] = 'main'
+
+a = Thread.new do
+  Thread.current[:name] = 'a'
+  sleep 0.2
+  puts 'a'
+  binding.pry
+  puts 'aaaa'
+  sleep 1
+  puts 'aaa'
+end
+
+b = Thread.new do
+  Thread.current[:name] = 'b'
+  20223000.times do
+    432 * 3232
+  end
+  puts '2'
+  binding.pry
+  puts '22'
+end
+
+a.join
+b.join

data/pry-moves.gemspec

@@ -20,6 +20,6 @@ Gem::Specification.new do |gem|
   # Dependencies
   gem.required_ruby_version = '>= 1.8.7'
   gem.add_runtime_dependency 'pry', '>= 0.9.10', '< 0.11.0'
-  gem.add_runtime_dependency 'pry-stack_explorer', '~> 0.4.9'
+  gem.add_runtime_dependency 'binding_of_caller', '>= 0.7'
   gem.add_development_dependency 'pry-remote', '~> 0.1.6'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pry-moves
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Garmoshka Mo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-20 00:00:00.000000000 Z
+date: 2017-08-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -31,19 +31,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.11.0
 - !ruby/object:Gem::Dependency
-  name: pry-stack_explorer
+  name: binding_of_caller
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.9
+        version: '0.7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.9
+        version: '0.7'
 - !ruby/object:Gem::Dependency
   name: pry-remote
   requirement: !ruby/object:Gem::Requirement
@@ -70,18 +70,28 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- dynamic_debug_experiments.rb
 - lib/pry-moves.rb
+- lib/pry-moves/backtrace.rb
 - lib/pry-moves/cli.rb
 - lib/pry-moves/commands.rb
+- lib/pry-moves/helpers.rb
 - lib/pry-moves/pry_ext.rb
 - lib/pry-moves/pry_remote_ext.rb
+- lib/pry-moves/pry_wrapper.rb
 - lib/pry-moves/tracer.rb
 - lib/pry-moves/version.rb
+- lib/pry-moves/watch.rb
+- lib/pry-stack_explorer/commands.rb
+- lib/pry-stack_explorer/frame_manager.rb
+- lib/pry-stack_explorer/pry-stack_explorer.rb
+- lib/pry-stack_explorer/when_started_hook.rb
 - playground/Gemfile
 - playground/README.md
 - playground/demo.rb
 - playground/recursions.rb
 - playground/sand.rb
+- playground/threads.rb
 - playground/tracer.rb
 - pry-moves.gemspec
 homepage: https://github.com/garmoshka-mo/pry-moves
@@ -104,7 +114,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Simple execution navigation for Pry.