pry-moves 0.1.10 → 1.0.1

data/lib/pry-moves/add_suffix.rb

@@ -0,0 +1,87 @@
+module PryMoves
+
+  class AddSuffix < Pry::ClassCommand
+
+    group 'Input and Output'
+    description "Continue traversing of last object in history."
+
+    banner <<-'BANNER'
+      Usage: .method | 123 | :hash_key
+
+      Continue traversing of last object in history
+
+      E.g. `orders` will list array, then `3` will enter `orders[3]`, then `.price` will enter `orders[3].price`
+    BANNER
+
+    def process(cmd)
+      last_cmd = Pry.history.to_a[-1]
+      cmd = "#{last_cmd}#{wrap_suffix(cmd)}"
+      _pry_.pager.page "    > #{cmd}\n"
+      _pry_.eval cmd
+    end
+
+    private
+
+    def wrap_suffix(cmd)
+      cmd
+    end
+
+  end
+
+  class Method < AddSuffix
+    match(/^\.(.+)$/) # when \. moved into group - match doesn't work because it overlaps with pry internal command
+
+    def wrap_suffix(cmd)
+      ".#{cmd}"
+    end
+  end
+
+  class ArgumentCall < AddSuffix
+    match(/^(\(.*\).*)/)
+  end
+
+  class ArrayIndex < AddSuffix
+    match(/^(\d+)$/)
+
+    def wrap_suffix(cmd)
+      "[#{cmd}]"
+    end
+  end
+
+  class ArrayCall < AddSuffix
+    match(/^(\[\d+\].*)/)
+  end
+
+  class HashKey < AddSuffix
+    match(/^(:\w+)$/)
+
+    def wrap_suffix(cmd)
+      "[#{cmd}]"
+    end
+  end
+
+
+end
+
+SUFFIX_COMMANDS = [
+  PryMoves::Method,
+  PryMoves::ArrayIndex,
+  PryMoves::ArrayCall,
+  PryMoves::HashKey
+]
+
+SUFFIX_COMMANDS.each do |cmd|
+  Pry::Commands.add_command(cmd)
+end
+
+Pry::History.class_eval do
+
+  def <<(line)
+    return if ["!"].include? line
+    return if SUFFIX_COMMANDS.any? do |cls|
+      line.match(cls.match)
+    end
+    push line
+  end
+
+end

data/lib/pry-moves/backtrace.rb

@@ -2,12 +2,12 @@ require 'fileutils'
 
 class PryMoves::Backtrace
 
+  FILTERS = %w[/gems/ /rubygems/ /bin/ /lib/ruby/]
+
   class << self
-    def lines_count; @lines_count || 5; end
-    def lines_count=(f); @lines_count = f; end
 
     def filter
-      @filter || /(\/gems\/|\/rubygems\/|\/bin\/|\/lib\/ruby\/)/
+      @filter ||= Regexp.new FILTERS.join("|")
     end
     def filter=(f); @filter = f; end
 
@@ -20,77 +20,91 @@ class PryMoves::Backtrace
         # not used
       end
     end
+
   end
 
-  def initialize(binding, pry)
-     @binding, @pry = binding, pry
+  def initialize(pry)
+    @pry = pry
+    @formatter = PryMoves::Formatter.new
   end
 
   def run_command(param, param2)
     if param.is_a?(String) and (match = param.match /^>(.*)/)
       suffix = match[1].size > 0 ? match[1] : param2
+      @formatter.colorize = false
       write_to_file build, suffix
+    elsif param and param.match /\d+/
+      index = param.to_i
+      frame_manager.goto_index index
     else
-      @colorize = true
-      if param.is_a? String and param.match /\d+/
-        param = param.to_i
-      end
-      @lines_count = param || PryMoves::Backtrace::lines_count
-      @pry.output.puts build
+      print_backtrace param
     end
   end
 
   private
 
+  def print_backtrace filter
+    @colorize = true
+    @lines_numbers = true
+    @filter = filter if filter.is_a? String
+    @pry.output.puts build
+  end
+
   def build
+    show_all = %w(a all).include?(@filter)
+    show_vapid = %w(+ hidden vapid).include?(@filter) || show_all
     result = []
-    show_vapid = %w(+ all hidden vapid).include? @lines_count
-    stack = stack_bindings(show_vapid)
-              .reverse.reject do |binding|
-                binding.eval('__FILE__').match self.class::filter
-              end
-
-    if @lines_count.is_a?(Numeric) and stack.count > @lines_count
-      result << "Latest #{@lines_count} lines: (`bt all` for full tracing)"
-      stack = stack.last(@lines_count)
-    end
+    current_object, vapid_count = nil, 0
 
-    build_result stack, result
-  end
+    recursion = PryMoves::Recursion::Holder.new
+
+    frame_manager.bindings.each_with_details do |binding, vapid|
+      next if !show_all and binding.eval('__FILE__').match self.class::filter
 
-  def build_result(stack, result)
-    current_object = nil
-    stack.each do |binding|
-      obj = binding.eval 'self'
-      if current_object != obj
-        result << "#{format_obj(obj)}:"
+      if !show_vapid and vapid
+        vapid_count += 1
+        next
+      end
+
+      if vapid_count > 0
+        result << "👽  frames hidden: #{vapid_count}"
+        vapid_count = 0
+      end
+
+      obj, debug_snapshot = binding.eval '[self, (debug_snapshot rescue nil)]'
+      # Comparison of objects directly may raise exception
+      if current_object.object_id != obj.object_id
+        result << "#{debug_snapshot || @formatter.format_obj(obj)}"
         current_object = obj
       end
 
-      result << build_line(binding)
+      file, line = binding.eval('[__FILE__, __LINE__]')
+      recursion.track file, line, result.count, binding.index unless show_vapid
+      result << build_line(binding, file, line)
     end
-    result
-  end
 
-  def format_obj(obj)
-    if @colorize
-      PryMoves::Painter.colorize obj
-    else
-      obj.inspect
-    end
+    recursion.each { |t| t.apply result }
+
+    result << "👽  frames hidden: #{vapid_count}" if vapid_count > 0
+
+    result
   end
 
-  def build_line(binding)
-    file = "#{binding.eval('__FILE__')}"
-    file.gsub!( /^#{Rails.root.to_s}/, '') if defined? Rails
+  def build_line(binding, file, line)
+    file = @formatter.shorten_path "#{file}"
 
-    signature = PryMoves::Helpers.method_signature binding
+    signature = @formatter.method_signature binding
     signature = ":#{binding.frame_type}" if !signature or signature.length < 1
 
-    indent = frame_manager.current_frame == binding ?
-        ' => ': '    '
+    indent = if frame_manager.current_frame == binding
+      '==> '
+    elsif true #@lines_numbers
+      s = "#{binding.index}:".ljust(4, ' ')
+      @colorize ? "\e[2;49;90m#{s}\e[0m" : s
+    else
+      '    '
+    end
 
-    line = binding.eval('__LINE__')
     "#{indent}#{file}:#{line} #{signature}"
   end
 
@@ -98,10 +112,6 @@ class PryMoves::Backtrace
     PryStackExplorer.frame_manager(@pry)
   end
 
-  def stack_bindings(vapid_frames)
-    frame_manager.filter_bindings vapid_frames: vapid_frames
-  end
-
   def write_to_file(lines, file_suffix)
     log_path = log_path file_suffix
     File.write log_path, lines.join("\n")
@@ -115,4 +125,25 @@ class PryMoves::Backtrace
     "#{root}/backtrace_#{file_suffix}.log"
   end
 
-end
+end
+
+Pry.config.exception_handler = proc do |output, exception, _|
+  if Pry::UserError === exception && SyntaxError === exception
+    output.puts "SyntaxError: #{exception.message.sub(/.*syntax error, */m, '')}"
+  else
+
+    output.puts "#{exception.class}: #{exception.message}"
+    exception.backtrace.reject! {|l| l.match /sugar\.rb/}
+    output.puts "from #{exception.backtrace.first}"
+
+    if exception.respond_to? :cause
+      cause = exception.cause
+      while cause
+        output.puts "Caused by #{cause.class}: #{cause}\n"
+        cause.backtrace.reject! {|l| l.match /sugar\.rb/}
+        output.puts "from #{cause.backtrace.first}"
+        cause = cause.cause
+      end
+    end
+  end
+end

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,75 @@
+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
+    return str unless 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,11 +14,15 @@ module PryMoves::Painter
 
   def self.colorize(obj)
     colored_str = Canvas.new
-    obj = obj.class if obj.inspect.start_with? "#<"
+    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