pry-moves 0.1.13 → 1.0.2

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,98 @@ 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 /^>(.*)/)
+    if param == 'save'
+      @filter = 'hidden'
+      @@backtrace = build_backtrace
+      @pry.output.puts "💾 Backtrace saved (#{@@backtrace.count} lines)"
+    elsif param == 'diff'
+      @filter = 'hidden'
+      diff
+    elsif param.is_a?(String) and (match = param.match /^>(.*)/)
       suffix = match[1].size > 0 ? match[1] : param2
-      write_to_file build, suffix
+      @formatter.colorize = false
+      write_to_file build_backtrace, 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 build
+  def print_backtrace filter
+    @colorize = true
+    @lines_numbers = true
+    @filter = filter if filter.is_a? String
+    @pry.output.puts build_backtrace
+  end
+
+  def build_backtrace
+    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.reverse.each do |binding|
+      next if !show_all and binding.eval('__FILE__').match self.class::filter
+
+      if !show_vapid and binding.hidden
+        vapid_count += 1
+        next
+      end
+
+      if vapid_count > 0
+        result << "👽  frames hidden: #{vapid_count}"
+        vapid_count = 0
+      end
 
-  def build_result(stack, result)
-    current_object = nil
-    stack.each do |binding|
       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 || format_obj(obj)}:"
+        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 = PryMoves::Helpers.shorten_path "#{binding.eval('__FILE__')}"
+  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 +119,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 +132,36 @@ class PryMoves::Backtrace
     "#{root}/backtrace_#{file_suffix}.log"
   end
 
-end
+  def diff
+    return STDERR.puts "No backtrace saved. Use `bt save` first".yellow unless defined? @@backtrace
+
+    diff = Diffy::Diff.new(@@backtrace.join("\n"), build_backtrace.join("\n")).to_s "color"
+    diff = 'Backtraces are equal' if diff.strip.empty?
+    @pry.output.puts diff
+  end
+
+end
+
+Pry.config.exception_handler = proc do |output, exception, _|
+
+  def print_error message, exception, output
+    output.puts message.red
+    exception.backtrace.reject! {|l| l.match /sugar\.rb/}
+    exception.backtrace.first(3).each { output.puts _1.white }
+  end
+
+  if Pry::UserError === exception && SyntaxError === exception
+    output.puts "SyntaxError: #{exception.message.sub(/.*syntax error, */m, '')}"
+  else
+
+    print_error "#{exception.class}: #{exception.message}", exception, output
+
+    if exception.respond_to? :cause
+      cause = exception.cause
+      while cause
+        print_error "Caused by #{cause.class}: #{cause}\n", exception, output
+        cause = cause.cause
+      end
+    end
+  end
+end

data/lib/pry-moves/bindings_stack.rb

@@ -0,0 +1,106 @@
+class PryMoves::BindingsStack < Array
+
+  def initialize options
+    @options = options
+    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| for_for_initial_frame b} || 0
+  end
+  def initial_frame
+    find {|b| for_for_initial_frame b}
+  end
+
+  def for_for_initial_frame b
+    not b.hidden and (
+      @options[:is_error] or b.eval("__method__") != :initialize
+    )
+  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
+        binding.hidden = true
+      elsif stepped_out
+        if actual_file == file and actual_method == method or
+            binding.local_variable_defined? :pry_moves_deferred_call
+          stepped_out = false
+        else
+          binding.hidden = true
+        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/
+        binding.hidden = true
+      end
+
+      if binding.local_variable_defined? :hide_from_stack
+        binding.hidden = true
+      end
+    end
+
+    stack_tip_met = false
+    stack_tips = PryMoves.stack_tips || []
+    reverse.each do |binding|
+      if binding.local_variable_defined?(:pry_moves_stack_tip) ||
+          stack_tips.include?(binding.eval("__method__"))
+        stack_tip_met = true
+      end
+      binding.hidden = true if stack_tip_met
+    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)
+    pry_moves_debug = Thread.current[:pry_moves_debug]
+    bindings.rindex do |b|
+      if not pry_moves_debug and b.frame_type == :eval
+        true
+      elsif b.frame_type == :method
+        method, self_ = b.eval("[__method__, self, __FILE__]")
+
+        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_end)
+      end
+    end
+  end
+
+end

data/lib/pry-moves/commands.rb

@@ -21,6 +21,11 @@ module PryMoves
       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
@@ -41,7 +46,7 @@ module PryMoves
     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
@@ -49,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
@@ -62,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)
@@ -79,6 +117,7 @@ module PryMoves
         end
       end
     end
+
   end
 end
 

data/lib/pry-moves/error_with_data.rb

@@ -0,0 +1,10 @@
+class PryMoves::ErrorWithData < StandardError
+
+  attr_reader :metadata
+
+  def initialize(msg, metadata)
+    super msg
+    @metadata = metadata
+  end
+
+end

data/lib/pry-moves/formatter.rb

@@ -0,0 +1,79 @@
+class PryMoves::Formatter
+
+  attr_accessor :colorize
+
+  def initialize colorize = true
+    @colorize = colorize
+  end
+
+  MAX_PARAMS = 5
+  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
+      if args.count > MAX_PARAMS
+        args = args.first(MAX_PARAMS) + ["(#{args.count - MAX_PARAMS} more params)…"]
+      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,13 +14,14 @@ 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" +
+    "⛔️ Inspect error: #{e}\n" +
       "#{e.backtrace.first(3).join("\n")}"
   end