pry-moves 0.1.9 → 1.0.0

data/lib/pry-moves/bindings_stack.rb

@@ -0,0 +1,97 @@
+class PryMoves::BindingsStack < Array
+
+  def initialize
+    @vapid_bindings = []
+    bindings = binding.callers # binding_of_caller has bug and always returns callers of current binding,
+      # no matter at which binding method is called. So no need to pass here binding
+    pre_callers = Thread.current[:pre_callers]
+    bindings = bindings + pre_callers if pre_callers
+    concat remove_internal_frames(bindings)
+    set_indices
+    mark_vapid_frames
+  end
+
+  def suggest_initial_frame_index
+    m = PryMoves::TracedMethod.last
+    return 0 if m and m.binding_inside?(first)
+    index{|b| not vapid? b} || 0
+  end
+  def initial_frame
+    find{|b| not vapid? b}
+  end
+
+  def each_with_details
+    self.reverse.each do |binding|
+      yield binding, vapid?(binding)
+    end
+  end
+
+  def vapid?(binding)
+    @vapid_bindings.include? binding
+  end
+
+  private
+
+  def set_indices
+    reverse.each_with_index do |binding, index|
+      binding.index = index
+    end
+  end
+
+  def mark_vapid_frames
+    stepped_out = false
+    actual_file, actual_method = nil, nil
+
+    # here calls checked in reverse order - from latest to parent:
+    each do |binding|
+      file, method, obj = binding.eval("[__FILE__, __method__, self]")
+
+      if file.match PryMoves::Backtrace::filter
+        @vapid_bindings << binding
+      elsif stepped_out
+        if actual_file == file and actual_method == method or
+            binding.local_variable_defined? :pry_moves_deferred_call
+          stepped_out = false
+        else
+          @vapid_bindings << binding
+        end
+      elsif binding.frame_type == :block
+        stepped_out = true
+        actual_file = file
+        actual_method = method
+      elsif obj and method and obj.method(method).source.strip.match /^delegate\s/
+        @vapid_bindings << binding
+      end
+
+      if binding.local_variable_defined? :hide_from_stack
+        @vapid_bindings << binding
+      end
+    end
+  end
+
+  # remove internal frames related to setting up the session
+  def remove_internal_frames(bindings)
+    i = top_internal_frame_index(bindings)
+    # DEBUG:
+    #bindings.each_with_index do |b, index|
+    #  puts "#{index}: #{b.eval("self.class")} #{b.eval("__method__")}"
+    #end
+    # puts "FOUND top internal frame in #{bindings.size} frames: [#{i}] #{bindings[i].ai}"
+
+    bindings.drop i+1
+  end
+
+  def top_internal_frame_index(bindings)
+    bindings.rindex do |b|
+      if b.frame_type == :method
+        method, self_ = b.eval("[__method__, self]")
+
+        self_.equal?(Pry) && method == :start ||
+          self_.class == Binding && method == :pry ||
+          self_.is_a?(PryMoves::TraceCommand) && method == :tracing_func ||
+          b.local_variable_defined?(:pry_moves_stack_root)
+      end
+    end
+  end
+
+end

data/lib/pry-moves/commands.rb

@@ -5,39 +5,48 @@ module PryMoves
     block_command 'step', 'Step execution into the next line or method.' do |param|
       breakout_navigation :step, param
     end
+    alias_command 's', 'step'
 
     block_command 'finish', 'Finish - xule tut neponyatnogo' do |param|
       breakout_navigation :finish, param
     end
+    alias_command 'f', 'finish'
 
     block_command 'next', 'Execute the next line stepping into blocks' do |param|
       breakout_navigation :next, param
     end
+    alias_command 'n', 'next'
 
     block_command 'nn', 'Execute the next line skipping blocks' do |param|
       breakout_navigation :next, 'blockless'
     end
 
+    block_command 'next_breakpoint', 'Go to next breakpoint' do |param|
+      breakout_navigation :next_breakpoint, param
+    end
+    alias_command 'b', 'next_breakpoint'
+
     block_command 'iterate', 'Go to next iteration of current block' do |param|
       breakout_navigation :iterate, param
     end
 
+    block_command 'goto', 'goto line' do |param|
+      breakout_navigation :goto, param
+    end
+    alias_command 'g', 'goto'
+
     block_command 'continue', 'Continue program execution and end the Pry session' do
       check_file_context
       run 'exit-all'
     end
-
     alias_command 'c', 'continue'
-    alias_command 's', 'step'
-    alias_command 'n', 'next'
-    alias_command 'f', 'finish'
 
     block_command 'watch', 'Display value of expression on every move' do |param|
       PryMoves::Watch.instance.process_cmd param, target
     end
 
     block_command 'bt', 'Backtrace' do |param, param2|
-      PryMoves::Backtrace.new(target, _pry_).run_command param, param2
+      PryMoves::Backtrace.new(_pry_).run_command param, param2
     end
 
     block_command 'debug', '' do
@@ -45,6 +54,23 @@ module PryMoves
       breakout_navigation :debug, cmd
     end
 
+    block_command :restart, '' do
+      PryMoves.restart_requested = true
+      run 'continue'
+    end
+    alias_command '@', 'restart'
+
+    block_command :reload, '' do
+      PryMoves.reload_requested = true
+      run 'continue'
+    end
+    alias_command '#', 'reload'
+
+    block_command /^\\(\w+)$/, 'Execute command explicitly' do |param|
+      Pry.config.ignore_once_var_precedence = true
+      run param
+    end
+
     block_command '!', 'exit' do
       PryMoves.unlock
       Pry.config.exit_requested = true
@@ -58,16 +84,32 @@ module PryMoves
 
     helpers do
       def breakout_navigation(action, param)
+        return if var_precedence action
+
         check_file_context
         _pry_.binding_stack.clear     # Clear the binding stack.
         throw :breakout_nav, {        # Break out of the REPL loop and
           action: action,          #   signal the tracer.
           param:  param,
-          binding: target,
-          pry: _pry_
+          binding: target
         }
       end
 
+      def var_precedence action
+        if Pry.config.ignore_once_var_precedence
+          Pry.config.ignore_once_var_precedence = false
+          return
+        end
+
+        input = Pry.config.original_user_input || action
+        binding_value = target.eval(input) rescue nil
+        unless binding_value.nil?
+          puts "ℹ️️  Variable \"#{input}\" found. To execute command type its alias or \\#{input}"
+          puts PryMoves::Painter.colorize binding_value
+          true
+        end
+      end
+
       # Ensures that a command is executed in a local file context.
       def check_file_context
         unless PryMoves.check_file_context(target)
@@ -75,6 +117,7 @@ module PryMoves
         end
       end
     end
+
   end
 end
 

data/lib/pry-moves/formatter.rb

@@ -0,0 +1,74 @@
+class PryMoves::Formatter
+
+  attr_accessor :colorize
+
+  def initialize colorize = true
+    @colorize = colorize
+  end
+
+  def method_signature(binding)
+    meth = binding.eval('__method__')
+    meth_obj = meth ? Pry::Method.from_binding(binding) : nil
+    if !meth_obj
+      ""
+    elsif meth_obj.undefined?
+      "#{meth_obj.name}(UNKNOWN) (undefined method)"
+    else
+      args = meth_obj.parameters.map.with_index do |(type, name), i|
+        if name
+          value = format_arg binding, name.to_s
+          show_value = true
+        else
+          name = (type == :block ? 'block' : "arg#{i + 1}")
+        end
+        name = case type
+          when :req   then "#{name} ="
+          when :key   then "#{name}:"
+          when :opt   then "#{name}=?"
+          when :rest  then "*#{name}"
+          when :block then "&#{name}"
+          else '?'
+        end
+        show_value ? "#{name} #{value}" : name
+      end
+      "#{meth_obj.name}(#{args.join(', ')})"
+    end
+  end
+
+  def format_arg binding, arg_name
+    arg = binding.eval(arg_name.to_s)
+    format_obj arg
+  end
+
+  def first_line str
+    str.split("\n").first
+  end
+
+  def cut_string str
+    str.length > 50 ? "#{str.first 50}..." : str
+  end
+
+  PATH_TRASH = defined?(Rails) ? Rails.root.to_s : Dir.pwd
+
+  def shorten_path(path)
+    path.gsub( /^#{PATH_TRASH}\//, '')
+  end
+
+  def format_obj(obj)
+    if obj.is_a? String
+      format_obj2 cut_string first_line obj
+    else
+      first_line format_obj2 obj
+    end
+  end
+
+  def format_obj2(obj)
+    if @colorize
+      PryMoves::Painter.colorize obj
+    else
+      i = obj.inspect
+      i.start_with?('#<') ? obj.class.to_s : i
+    end
+  end
+
+end

data/lib/pry-moves/painter.rb

@@ -14,10 +14,15 @@ module PryMoves::Painter
 
   def self.colorize(obj)
     colored_str = Canvas.new
+    i = obj.inspect
+    obj = obj.class if i.is_a?(String) && i.start_with?("#<")
     catch (:cut) do
       Pry::ColorPrinter.pp obj, colored_str
     end
     colored_str.chomp
+  rescue => e
+    "⛔️ Inspect error: #{e}\n" +
+      "#{e.backtrace.first(3).join("\n")}"
   end
 
 end

data/lib/pry-moves/pry_ext.rb

@@ -1,31 +1,31 @@
 class << Pry
-  alias_method :start_without_pry_nav, :start
-
-  def start_with_pry_nav(target = TOPLEVEL_BINDING, options = {})
-    old_options = options.reject { |k, _| k == :pry_remote }
+  alias pry_moves_origin_start start
 
+  def start(target = TOPLEVEL_BINDING, options = {})
     if target.is_a?(Binding) && PryMoves.check_file_context(target)
       # Wrap the tracer around the usual Pry.start
-      PryMoves::PryWrapper.new(target, options).run do
-        start_without_pry_nav(target, old_options)
-      end
+      original_verbosity = $VERBOSE
+      $VERBOSE = nil # Disable warnings for pry-moves
+      PryMoves::PryWrapper.new(target, options, self).run
+      $VERBOSE = original_verbosity
     else
       # No need for the tracer unless we have a file context to step through
-      start_without_pry_nav(target, old_options)
+      pry_moves_origin_start(target, options)
     end
   end
 
-  alias_method :start, :start_with_pry_nav
 end
 
 Binding.class_eval do
 
+  attr_accessor :index
+
   alias pry_forced pry
 
   def pry
-    unless Pry.config.disable_breakpoints
-      PryMoves.synchronize_threads ||
-        return # Don't start binding.pry when semaphore locked by current thread
+    if !Pry.config.disable_breakpoints and
+        # Don't start binding.pry when semaphore locked by current thread
+        PryMoves.synchronize_threads
       pry_forced
     end
   end
@@ -34,6 +34,32 @@ end
 
 Pry.config.pager = false
 
+Pry::Command.class_eval do
+  class << self
+    attr_accessor :original_user_input
+  end
+
+  alias run_origin_for_pry_moves run
+  def run(command_string, *args)
+    Pry.config.original_user_input = self.class.original_user_input
+    result = run_origin_for_pry_moves command_string, *args
+    Pry.config.original_user_input = nil
+    result
+  end
+end
+
+Pry::CommandSet.class_eval do
+
+  alias alias_command_origin_for_pry_moves alias_command
+
+  def alias_command(match, action, options = {})
+    cmd = alias_command_origin_for_pry_moves match, action, options
+    cmd.original_user_input = match
+    cmd
+  end
+
+end
+
 Pry::Command::Whereami.class_eval do
   # Negligent function from Pry - evidently poor output format
   # would be wanted to be changed often by developers,
@@ -56,11 +82,19 @@ Pry::Command::Whereami.class_eval do
   end
 
   def build_output
-    lines = []
-    lines << "#{text.bold('From:')} #{location}"
-    lines << PryMoves::Watch.instance.output(target) unless PryMoves::Watch.instance.empty?
+    lines = ['']
+
+    formatter = PryMoves::Formatter.new
+    prefix = Thread.current[:pry_moves_debug] ? "👾 " : ""
+    lines << "#{prefix}#{formatter.shorten_path location}"
+    lines << "   ." + formatter.method_signature(target)
     lines << ''
     lines << "#{code.with_line_numbers(use_line_numbers?).with_marker(marker).highlighted}"
+
+    lines << PryMoves::Watch.instance.output(target) unless PryMoves::Watch.instance.empty?
+    lines.concat PryMoves.messages
+    PryMoves.messages.clear
+
     lines << ''
     lines.join "\n"
   end
@@ -82,4 +116,18 @@ Pry::Code::LOC.class_eval do
     tuple[0] = " #{marker} #{ line }"
   end
 
-end
+end
+
+Pry::Output.class_eval do
+
+  alias pry_moves_origin_for_puts puts
+
+  def puts *args
+    first = args[0]
+    if first.is_a? String and first.start_with? "(pry) output error"
+      first.slice! 400..-1
+    end
+    pry_moves_origin_for_puts *args
+  end
+
+end if defined? Pry::Output

data/lib/pry-moves/pry_wrapper.rb

@@ -2,24 +2,24 @@ require 'pry' unless defined? Pry
 
 module PryMoves
 class PryWrapper
-  def initialize(binding_, pry_start_options = {})
+  def initialize(binding_, pry_start_options, pry)
     @init_binding = binding_
     @pry_start_options = pry_start_options   # Options to use for Pry.start
+    @pry = pry
   end
 
-  def run(&block)
+  def run
     PryMoves.lock
 
-    Pry.config.marker = "⛔️" if @pry_start_options[:exit_from_method]
-
-    return_value = nil
-    PryMoves.is_open = true
-    @command = catch(:breakout_nav) do      # Coordinates with PryMoves::Commands
-      return_value = yield
-      nil    # Nothing thrown == no navigational command
+    initial_frame = PryMoves::BindingsStack.new.initial_frame
+    if not @pry_start_options[:pry_moves_loop] and
+        initial_frame.local_variable_defined? :debug_redirect
+      debug_redirect = initial_frame.local_variable_get(:debug_redirect)
+      PryMoves.messages << "⏩ redirected to #{debug_redirect}"
+      @command = {action: :step, binding: initial_frame}
+    else
+      start_pry
     end
-    PryMoves.is_open = false
-    Pry.config.marker = "=>"
 
     if @command
       trace_command
@@ -30,11 +30,24 @@ class PryWrapper
       end
     end
 
-    return_value
+    @return_value
   end
 
   private
 
+  def start_pry
+    Pry.config.marker = "⛔️" if @pry_start_options[:exit_from_method]
+    PryMoves.is_open = true
+
+    @command = catch(:breakout_nav) do      # Coordinates with PryMoves::Commands
+      @return_value = @pry.pry_moves_origin_start(@init_binding, @pry_start_options)
+      nil    # Nothing thrown == no navigational command
+    end
+
+    PryMoves.is_open = false
+    Pry.config.marker = "=>"
+  end
+
   def trace_command
     if @command[:action] == :debug
       wrap_debug
@@ -61,9 +74,9 @@ class PryWrapper
       tracer = start_tracing
       begin
         @command[:binding].eval @command[:param]
-      rescue => e
+      rescue StandardError, SyntaxError => e
         Thread.current.set_trace_func nil
-        puts e
+        puts "❌️ #{e}"
       end
       tracer.stop_tracing
     end.join
@@ -73,9 +86,9 @@ class PryWrapper
 
   def start_tracing
     @last_runtime_binding = @command[:binding]
-    tracer = PryMoves::Tracer.new @command, @pry_start_options
-    tracer.trace
-    tracer
+    PryMoves::TraceCommand.trace @command, @pry_start_options do |binding|
+      Pry.start(binding, @pry_start_options)
+    end
   end
 
 end