pry-moves 0.1.1 → 0.1.2

data/lib/pry-moves/tracer.rb

@@ -2,82 +2,71 @@ require 'pry' unless defined? Pry
 
 module PryMoves
 class Tracer
-  def initialize(pry_start_options = {}, &block)
-    @pry_start_options = pry_start_options   # Options to use for Pry.start
-  end
 
-  def run(&block)
-    # For performance, disable any tracers while in the console.
-    # Unfortunately doesn't work in 1.9.2 because of
-    # http://redmine.ruby-lang.org/issues/3921. Works fine in 1.8.7 and 1.9.3.
-    stop_tracing unless RUBY_VERSION == '1.9.2'
+  def initialize(command, pry_start_options)
+    @command = command
+    @pry_start_options = pry_start_options
+  end
 
-    return_value = nil
-    command = catch(:breakout_nav) do      # Coordinates with PryMoves::Commands
-      return_value = yield
-      {}    # Nothing thrown == no navigational command
-    end
+  def trace
+    @action = @command[:action]
+    binding_ = @command[:binding]
+    set_traced_method binding_
 
-    # Adjust tracer based on command
-    if process_command(command)
-      start_tracing command
-    else
-      stop_tracing if RUBY_VERSION == '1.9.2'
-      if @pry_start_options[:pry_remote] && PryMoves.current_remote_server
-        PryMoves.current_remote_server.teardown
+    case @action
+    when :step
+      @step_info_funcs = nil
+      if (func = @command[:param])
+        @step_info_funcs = [func]
+        @step_info_funcs << 'initialize' if func == 'new'
       end
+    when :finish
+      @method_to_finish = @method
+      @block_to_finish =
+          (binding_.frame_type == :block) &&
+              frame_digest(binding_)
     end
 
-    return_value
+    start_tracing
   end
 
-  def start_tracing(command)
+  private
+
+  def start_tracing
+    #puts "##trace_obj #{trace_obj}"
     Pry.config.disable_breakpoints = true
-    set_traced_method command[:binding]
-    case @action
-      when :finish
-        @method_to_finish = @method
-    end
-    set_trace_func method(:tracer).to_proc
+    trace_obj.set_trace_func method(:tracing_func).to_proc
   end
 
   def stop_tracing
     Pry.config.disable_breakpoints = false
-    set_trace_func nil
+    trace_obj.set_trace_func nil
   end
 
-  def process_command(command = {})
-    @action = command[:action]
-
-    case @action
-      when :step
-        @step_info_funcs = nil
-        if command[:param]
-          func = command[:param].to_sym
-          @step_info_funcs = [func]
-          @step_info_funcs << :initialize if func == :new
-        end
-    end
-
-    [:step, :next, :finish].include? @action
+  # You can't call set_trace_func or Thread.current.set_trace_func recursively
+  # even in different threads 😪
+  # But! 💡
+  # The hack is - you can call Thread.current.set_trace_func
+  # from inside of set_trace_func! 🤗
+  def trace_obj
+    Thread.current[:pry_moves_debug] ?
+        Thread.current : Kernel
   end
 
-
-  private
-
   def set_traced_method(binding)
     @recursion_level = 0
 
     method = binding.eval 'method(__method__) if __method__'
-    return set_method({file: binding.eval('__FILE__')}) unless method
-
-    source = method.source_location
-    set_method({
-        file: source[0],
-        start: source[1],
-        end: (source[1] + method.source.count("\n") - 1)
-        #thread: binding.eval 'Thread.current' # todo: Нужна проверка по треду?
-    })
+    if method
+      source = method.source_location
+      set_method({
+       file: source[0],
+       start: source[1],
+       end: (source[1] + method.source.count("\n") - 1)
+     })
+    else
+      set_method({file: binding.eval('__FILE__')})
+    end
   end
 
   def set_method(method)
@@ -85,26 +74,66 @@ class Tracer
     @method = method
   end
 
-  def tracer(event, file, line, id, binding_, klass)
-    #printf "%8s %s:%-2d %10s %8s\n", event, file, line, id, klass
+  def frame_digest(binding_)
+    #puts "frame_digest for: #{binding_.eval '__callee__'}"
+    Digest::MD5.hexdigest binding_.instance_variable_get('@iseq').disasm
+  end
+
+  def tracing_func(event, file, line, id, binding_, klass)
+    #printf "#{trace_obj}: %8s %s:%-2d %10s %8s rec:#{@recursion_level}\n", event, file, line, id, klass
+
     # Ignore traces inside pry-moves code
     return if file && TRACE_IGNORE_FILES.include?(File.expand_path(file))
 
+    catch (:skip) do
+      if send "trace_#{@action}", event, file, line, binding_
+        stop_tracing
+        Pry.start(binding_, @pry_start_options)
+
+      # for cases when currently traced method called more times recursively
+      elsif %w(call return).include?(event) and within_current_method?(file, line)
+        @recursion_level += event == 'call' ? 1 : -1
+      end
+    end
+  end
+
+  def trace_step(event, file, line, binding_)
+    return unless event == 'line'
+    if @step_info_funcs
+      method = binding_.eval('__callee__').to_s
+      @step_info_funcs.any? {|pattern| method.include? pattern}
+    else
+      true
+    end
+  end
+
+  def trace_next(event, file, line, binding_)
     traced_method_exit = (@recursion_level < 0 and %w(line call).include? event)
-    # Set new traced method, because we left previous one
-    set_traced_method binding_ if traced_method_exit
-
-    case event
-      when 'line'
-        #debug_info file, line, id
-        if break_here?(file, line, binding_, traced_method_exit)
-          Pry.start(binding_, @pry_start_options)
-        end
-      when 'call', 'return'
-        if within_current_method?(file, line) and !traced_method_exit
-          recursion_step event
-        end
+    if traced_method_exit
+      # Set new traced method, because we left previous one
+      set_traced_method binding_
+      throw :skip if event == 'call'
     end
+
+    event == 'line' and
+      @recursion_level == 0 and
+      within_current_method?(file, line)
+  end
+
+  def trace_finish(event, file, line, binding_)
+    return unless event == 'line'
+    return true if @recursion_level < 0 or @method_to_finish != @method
+
+    # for finishing blocks inside current method
+    if @block_to_finish
+      within_current_method?(file, line) and
+          @block_to_finish != frame_digest(binding_.of_caller(3))
+    end
+  end
+
+  def trace_debug(event, file, line, binding_)
+    event == 'line' and file == 'sand.rb' and
+        not [47, 48, 49, 50].include?(line)
   end
 
   def debug_info(file, line, id)
@@ -112,19 +141,6 @@ class Tracer
     puts "#{id} #{@method[:start]} > #{line} > #{@method[:end]}"
   end
 
-  def break_here?(file, line, binding_, traced_method_exit)
-    case @action
-      when :step
-        @step_info_funcs ?
-            @step_info_funcs.include?(binding_.eval('__callee__'))
-            : true
-      when :finish
-        @method_to_finish = @method if @method_to_finish != @method
-      when :next
-        @recursion_level == 0 and within_current_method?(file, line)
-    end
-  end
-
   def within_current_method?(file, line)
     @method[:file] == file and (
       @method[:start].nil? or
@@ -132,10 +148,5 @@ class Tracer
     )
   end
 
-  def recursion_step(event)
-    #puts "recursion_step #{event} #{'call' ? 1 : -1}"
-    @recursion_level += event == 'call' ? 1 : -1
-  end
-
 end
 end

data/lib/pry-moves/version.rb

@@ -1,3 +1,3 @@
 module PryMoves
-  VERSION = '0.1.1'
+  VERSION = '0.1.2'
 end

data/lib/pry-moves/watch.rb

@@ -0,0 +1,57 @@
+require 'singleton'
+
+class PryMoves::Watch
+
+  include Singleton
+
+  attr_reader :list
+
+  def initialize
+    @list = Set.new
+  end
+
+  def process_cmd(cmd, binding_)
+    case cmd
+      when nil, ''
+        if @list.count > 0
+          print binding_
+        else
+          puts "Watch list is empty"
+        end
+      when '-clear', '-c'
+        @list.clear
+      else
+        add cmd, binding_
+    end
+  end
+
+  def add(cmd, binding_)
+    @list << cmd
+    puts eval_cmd(cmd, binding_)
+  end
+
+  def print(binding_)
+    puts output(binding_) if @list.count > 0
+  end
+
+  def output(binding_)
+    @list.map do |cmd|
+      eval_cmd(cmd, binding_)
+    end.join "; "
+  end
+
+  def eval_cmd(cmd, binding_)
+    "\033[1m#{cmd}\033[0m: #{format binding_.eval(cmd)}"
+  rescue NameError
+    "\033[1m#{cmd}\033[0m: <undefined>"
+  end
+
+  def format(text)
+    Pry::ColorPrinter.pp(text, "").strip
+  end
+
+  def empty?
+    @list.empty?
+  end
+
+end

data/lib/pry-moves.rb

@@ -1,8 +1,13 @@
 require 'pry-moves/version'
 require 'pry-moves/pry_ext'
 require 'pry-moves/commands'
+require 'pry-moves/pry_wrapper'
 require 'pry-moves/tracer'
 require 'pry-moves/backtrace'
+require 'pry-moves/watch'
+require 'pry-moves/helpers'
+
+require 'pry-stack_explorer/pry-stack_explorer'
 
 # Optionally load pry-remote monkey patches
 require 'pry-moves/pry_remote_ext' if defined? PryRemote
@@ -12,6 +17,8 @@ module PryMoves
 
   extend self
 
+  attr_accessor :is_open
+
   # Checks that a binding is in a local file context. Extracted from
   # https://github.com/pry/pry/blob/master/lib/pry/default_commands/context.rb
   def check_file_context(target)
@@ -19,6 +26,26 @@ module PryMoves
     file == Pry.eval_path || (file !~ /(\(.*\))|<.*>/ && file != '' && file != '-e')
   end
 
+  def semaphore
+    @semaphore ||= Mutex.new
+  end
+
+  def lock
+    semaphore.lock unless semaphore.locked?
+  end
+
+  def unlock
+    semaphore.unlock unless Thread.current[:pry_moves_debug]
+  end
+
+  def open?
+    @is_open
+  end
+
+  def synchronize_threads
+    semaphore.synchronize {} unless Thread.current[:pry_moves_debug]
+  end
+
   # Reference to currently running pry-remote server. Used by the tracer.
   attr_accessor :current_remote_server
 end

data/lib/pry-stack_explorer/commands.rb

@@ -0,0 +1,276 @@
+module PryStackExplorer
+  module FrameHelpers
+    private
+
+    # @return [PryStackExplorer::FrameManager] The active frame manager for
+    #   the current `Pry` instance.
+    def frame_manager
+      PryStackExplorer.frame_manager(_pry_)
+    end
+
+    # @return [Array<PryStackExplorer::FrameManager>] All the frame
+    #   managers for the current `Pry` instance.
+    def frame_managers
+      PryStackExplorer.frame_managers(_pry_)
+    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)
+      b_self = b.eval('self')
+      type = b.frame_type ? "[#{b.frame_type}]".ljust(9) : ""
+      desc = b.frame_description ? "#{b.frame_description}" : "#{frame_description(b)}"
+      sig = PryMoves::Helpers.method_signature_with_owner b
+
+      self_clipped = "#{Pry.view_clip(b_self)}"
+      path = "@ #{b.eval('__FILE__')}:#{b.eval('__LINE__')}"
+
+      if !verbose
+        "#{type} #{desc} #{sig}"
+      else
+        "#{type} #{desc} #{sig}\n      in #{self_clipped} #{path}"
+      end
+    end
+
+    def find_frame_by_regex(regex, up_or_down)
+      frame_index = find_frame_by_block(up_or_down) do |b|
+        (b.eval('"#{__FILE__}:#{__LINE__}"') =~ regex) or
+          (b.eval("__method__").to_s =~ regex)
+      end
+
+      frame_index || raise(Pry::CommandError, "No frame that matches #{regex.source} found")
+    end
+
+    def find_frame_by_block(up_or_down)
+      start_index = frame_manager.binding_index
+
+      if up_or_down == :down
+        enum = start_index == 0 ? [].each :
+            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
+
+    def find_frame_by_direction(up_or_down, step_into_vapid: false)
+      frame_index = find_frame_by_block(up_or_down) do |b|
+          step_into_vapid or
+            not b.local_variable_defined?(:vapid_frame)
+        end
+
+      frame_index ||
+        raise(Pry::CommandError, "At #{up_or_down == :up ? 'top' : 'bottom'} of stack, cannot go further")
+    end
+
+    def move(direction, param)
+      raise Pry::CommandError, "Nowhere to go" unless frame_manager
+
+      if param == '+' or param.nil?
+        index = find_frame_by_direction direction, step_into_vapid: param == '+'
+        frame_manager.change_frame_to index
+      else
+        index = find_frame_by_regex(Regexp.new(param), direction)
+        frame_manager.change_frame_to index
+      end
+    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 normally
+          e.g: up +    #=> Move up including vapid frames
+          e.g: up meth #=> Jump to nearest parent stack frame whose method matches /meth/ regex, i.e `my_method`.
+      BANNER
+
+      def process
+        move :up, args.first
+      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 normally
+          e.g: down +    #=> Move down including vapid frames
+          e.g: down meth #=> Jump to nearest child stack frame whose method matches /meth/ regex, i.e `my_method`.
+      BANNER
+
+      def process
+        move :down, args.first
+      end
+    end
+
+    create_command "top", "Top" do
+      include FrameHelpers
+      def process
+        frame_manager.change_frame_to frame_manager.bindings.size - 1
+      end
+    end
+
+    create_command "bottom", "Bottom" do
+      include FrameHelpers
+      def process
+        frame_manager.change_frame_to 0
+      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 "show-stack", "Show all frames" do
+      include FrameHelpers
+
+      banner <<-BANNER
+        Usage: show-stack [OPTIONS]
+          Show all accessible stack frames.
+          e.g: show-stack -v
+      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
+      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
+        if !frame_manager
+          output.puts "No caller stack available!"
+        else
+          content = ""
+          content << "\n#{text.bold("Showing all accessible frames in stack (#{frame_manager.bindings.size} in total):")}\n--\n"
+
+          base_frame_index, frames = selected_stack_frames
+          frames.each_with_index do |b, index|
+            i = index + base_frame_index
+            if i == frame_manager.binding_index
+              content << "=> ##{i} #{memoized_info(i, b, opts[:v])}\n"
+            else
+              content << "   ##{i} #{memoized_info(i, b, opts[:v])}\n"
+            end
+          end
+
+          stagger_output content
+        end
+      end
+
+    end
+  end
+end