pry-moves 0.1.13 → 1.0.0

data/lib/commands/traced_method.rb

@@ -0,0 +1,71 @@
+class PryMoves::TracedMethod < Hash
+
+  @@last = nil
+  def self.last
+    @@last
+  end
+
+  def initialize(binding_)
+    super()
+
+    method = find_method_definition binding_
+    if method
+      source = method.source_location
+      set_method({
+        file: source[0],
+        start: source[1],
+        name: method.name,
+        end: (source[1] + method.source.count("\n") - 1)
+      })
+    else
+      set_method({file: binding_.eval('__FILE__')})
+    end
+  end
+
+  def within?(file, line, id = nil)
+    return unless self[:file] == file
+    return unless self[:start].nil? or
+      line.between?(self[:start], self[:end])
+    return unless id.nil? or self[:name] == id # fix for bug in traced_method: return for dynamic methods has line number inside of caller
+
+    true
+  end
+
+  def binding_inside?(binding)
+    within? *binding.eval('[__FILE__, __LINE__, __method__]')
+  end
+
+  def before_end?(line)
+    self[:end] and line < self[:end]
+  end
+
+  private
+
+  def find_method_definition(binding)
+    method_name, obj, file =
+      binding.eval '[__method__, self, __FILE__]'
+    return unless method_name
+
+    method = obj.method(method_name)
+    return method if method.source_location[0] == file
+
+    # If found file was different - search definition at superclasses:
+    obj.class.ancestors.each do |cls|
+      if cls.instance_methods(false).include? method_name
+        method = cls.instance_method method_name
+        return method if method.source_location[0] == file
+      end
+    end
+
+    PryMoves.messages << "⚠️  Unable to find definition for method #{method_name} in #{obj}"
+
+    nil
+  end
+
+  def set_method(method)
+    #puts "set_traced_method #{method}"
+    merge! method
+    @@last = self
+  end
+
+end

data/lib/debug_sugar.rb

@@ -0,0 +1,72 @@
+def debug *args
+  pry_moves_stack_root = true
+  PryMoves.debug *args
+end
+
+def error(msg, debug_object = nil)
+  pry_moves_stack_root = true
+  err = "😱  #{msg}"
+  unless PryMoves.open?
+    if PryMoves.stop_on_breakpoints
+      lines = [err.red]
+      lines.prepend debug_object.ai if debug_object
+      PryMoves.debug lines.join("\n")
+    else
+      STDERR.puts debug_object.ai if debug_object
+      STDERR.puts err.ljust(80, ' ').red
+    end
+  end
+  raise msg
+end
+
+def shit!(err = 'Oh, shit!', debug_object = nil)
+  pry_moves_stack_root = true
+  message = "💩  #{err.is_a?(String) ? err : err.message}"
+  raise err unless PryMoves.stop_on_breakpoints
+  lines = [message.red]
+  lines.prepend debug_object.ai if debug_object
+  PryMoves.debug lines.join("\n")
+  nil
+end
+
+def required(var)
+  pry_moves_stack_root = true
+  error("required parameter is missing") if var.nil?
+  var
+end
+
+RSpec.configure do |config|
+
+  config.before(:each) do
+    PryMoves.launched_specs_examples += 1
+    PryMoves.stop_on_breakpoints =
+      PryMoves.launched_specs_examples < 2
+  end
+
+  config.around(:each) do |example|
+    PryMoves.restartable do
+      example.run
+    end
+  end
+
+end if defined? RSpec
+
+Rake::Task.class_eval do
+
+  alias execute_origin_for_pry_moves execute
+
+  def execute(args=nil)
+    args ||= EMPTY_TASK_ARGS
+    PryMoves.restartable do
+      reload_actions if PryMoves.reload_rake_tasks
+      execute_origin_for_pry_moves args
+    end
+  end
+
+  def reload_actions
+    rake_task_path = actions[0].source_location[0]
+    actions.clear
+    load rake_task_path
+  end
+
+end if defined? Rake and defined? Rake::Task

data/lib/pry-moves/add_suffix.rb

@@ -0,0 +1,88 @@
+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::ArgumentCall,
+  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

@@ -3,8 +3,6 @@ require 'fileutils'
 class PryMoves::Backtrace
 
   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\/)/
@@ -20,75 +18,84 @@ 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_vapid = %w(+ a all hidden vapid).include?(@filter)
+    show_all = %w(a all).include?(@filter)
     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
+    frame_manager.bindings.each_with_details do |binding, vapid|
+      next if !show_all and binding.eval('__FILE__').match self.class::filter
+
+      if !show_vapid and vapid
+        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)
     end
-    result
-  end
 
-  def format_obj(obj)
-    if @colorize
-      PryMoves::Painter.colorize obj
-    else
-      obj.inspect
-    end
+    result << "👽  frames hidden: #{vapid_count}" if vapid_count > 0
+
+    result
   end
 
   def build_line(binding)
-    file = PryMoves::Helpers.shorten_path "#{binding.eval('__FILE__')}"
+    file = @formatter.shorten_path "#{binding.eval('__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}"
@@ -98,10 +105,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 +118,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