pry-moves 0.1.13 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8826581b1684b35099d08f56064e2f3b38ccf3e0d24e3bf40779de9da58151f1
-  data.tar.gz: d73a5a0b30ac023416e901a3a965d95b4d232bdef5c0f44ab49ec4dfc7708585
+  metadata.gz: a9dc991b1aed888cf23fd1e9a76b29d274ce56989119f802982e9fbdc46cc034
+  data.tar.gz: 25e331897d83de799b696e84d1de474166095d4e80853a7f9cde99ba64290432
 SHA512:
-  metadata.gz: 2ade46c2440bcd4e14a296b9f3785ce0fff501abe953670ce19c9851d0b52488795113179717dffab6b57221c81839317236417bd1ce76380ceed96c3ed4a596
-  data.tar.gz: b5b959011051e252cb8a65c1b049f0cdfd8dcd6056b47b7cc7ba87052bb84ec5e1fd767d641385ab2ac1c162f0230d6a7bc760f77ac2699bc5fdbd5d6e812a05
+  metadata.gz: fbaa701da70c665fe7795de825db1540e5a1ab2d4f2021c41d4294c14bce3429b34b7e64d21949f51fd08dbbc24b6ffc047776bb7207b8c73834893e0e03ced7
+  data.tar.gz: 169ee4d3b3e40f8f63c7969c2b709c82dfc23881c994a335b25635fbf90b798ea21616bc33c08dd0bd44418a2c996f0b5eb6079732d769ff5c061757af35f5e7

data/Gemfile

@@ -4,6 +4,6 @@ source 'https://rubygems.org'
 gemspec
 
 group :development, :test do
-  gem 'pry'
+  gem 'pry', '0.11.3'
   gem 'rspec'
 end

data/Gemfile.lock

@@ -1,9 +1,11 @@
 PATH
   remote: .
   specs:
-    pry-moves (0.1.13)
+    pry-moves (1.0.2)
       binding_of_caller (~> 0.7)
-      pry (>= 0.10.4, < 0.12.0)
+      colorize (~> 0.8)
+      diffy (~> 3.4.0)
+      pry (>= 0.10.4, < 0.13)
 
 GEM
   remote: https://rubygems.org/
@@ -11,8 +13,10 @@ GEM
     binding_of_caller (0.8.0)
       debug_inspector (>= 0.0.1)
     coderay (1.1.2)
-    debug_inspector (0.0.3)
+    colorize (0.8.1)
+    debug_inspector (1.1.0)
     diff-lcs (1.3)
+    diffy (3.4.0)
     method_source (0.9.0)
     pry (0.11.3)
       coderay (~> 1.1.0)
@@ -39,10 +43,10 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
-  pry
+  pry (= 0.11.3)
   pry-moves!
   pry-remote (~> 0.1.6)
   rspec
 
 BUNDLED WITH
-   2.1.1
+   1.17.3

data/README.md

@@ -9,28 +9,39 @@ _An execution control add-on for [Pry][pry]._
 
 ## Commands:
 
+Documentation for latest version. For [v0.1.12 see documentation here](https://github.com/garmoshka-mo/pry-moves/tree/v0.1.12#commands)
+
 * `n` - **next** line in current frame, including block lines (moving to next line goes as naturally expected)
   * `nn` - **next** line in current frame, skipping block lines
 * `s` - **step** into function execution
   * `s method_name` - step into method `method_name` (For example from `User.new.method_name`). Partial name match supported.
   * `s +` - step into function, including hidden frames
 * `f` - **finish** execution of current frame (block or method) and stop at next line on higher level
-* `iterate` - go to next iteration of current block
 * `c` - **continue**
+* `b` - go to next breakpoint (breakpoints currently are methods which contain "debug" in their name)
+* `iterate` - go to next iteration of current block
 * `g 10` - **goto** line 10
-* `bt` - show latest 5 lines from backtrace
-  * `bt 10` - latest 10 lines
-  * `bt full` - full backtrace
-  * `bt +` - full backtrace with hidden frames. Aliases: `bt hidden` `bt vapid` `bt all`
+* `bt` - show backtrace, excluding hidden frames
+  * `bt +` `bt hidden` - show backtrace including hidden frames
+  * `bt a` `bt all` - full backtrace with system and hidden frames
+  * `bt 10` - go to backtrace line 10
+  * `bt save` - save backtrace to memory
+  * `bt diff` - diff with saved backtrace
   * `bt > foo` - write backtrace to file `log/backtrace_foo.log`
-* `up`/`down`/`top`/`bottom` - move over call stack
+* `up`/`down`/`top`/`bottom` (`bm`) - move over call stack
   * `up +` - move up, including vapid frames (block callers, hidden frames)
   * `up pattern` - move up till first frame which method name or file position in format `folder/script.rb:12` matches regexp pattern
+* `%` - print current frame of call stack (alias to `whereami`)
+* `$` - fully print current function without line numbers
 * `debug some_method(some_param)` - call `some_method(some_param)` and interactively step into it. This way you can virtually "step back" by executing previous pieces of code from current method
 * `.method` or `123` or `: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`
 * `watch variable` - display variable's value on each step
+* `@` - restart. Set config `PryMoves.reload_rake_tasks = true` to automatically reload rake tasks
+* `#` - exit with code 3, can be wrapped in bash script to fully reload ruby scripts
 * `!` - exit
 
+Variable & methods names takes precedence over commands. 
+So if you have variable named `step`, to execute command `step` type `cmd step` or command's alias, e.g. `s` 
 
 ## Examples
 
@@ -51,7 +62,7 @@ _Demo class source [here](https://github.com/garmoshka-mo/pry-moves/issues/1)_
 
 ## Backtrace and call stack
 
-You can explicitly hide frames from backtrace and call stack by defining `hide_from_stack` variable:
+You can explicitly hide frames from call stack by defining variables like this:
 
 ```ruby
 def insignificant_method
@@ -61,12 +72,15 @@ def insignificant_method
 end
 ```
 
+* `hide_from_stack` - hide this function from stack
+* `pry_moves_stack_tip` -  stop on first frame above this function  
+* `pry_moves_stack_end` - limits stack from bottom, not possible to step below this frame  
+
 ## Configuration
 
-Here is default configuration, you can override it:
+Here is default configuration, you can reassign it:
 
 ```ruby
-PryMoves::Backtrace::lines_count = 5
 PryMoves::Backtrace::filter =
   /(\/gems\/|\/rubygems\/|\/bin\/|\/lib\/ruby\/|\/pry-moves\/)/
 ```
@@ -122,6 +136,8 @@ Please note that debugging functionality is implemented through
 
 ```
 bundle exec rspec
+
+DEBUG=true bundle exec rspec -e 'backtrace should backtrace'
 ```
 
 ## ToDo

data/lib/commands/debug.rb

@@ -0,0 +1,21 @@
+class PryMoves::Debug < PryMoves::TraceCommand
+
+  def init(binding_)
+    #
+  end
+
+  def trace(event, file, line, method, binding_)
+    return if event != 'line' or @cancel_debug
+    if @first_line_skipped
+      if binding_.local_variable_defined?(:pry_cancel_debug)
+        @cancel_debug = true
+        return
+      end
+      true
+    else
+      @first_line_skipped = true
+      false
+    end
+  end
+
+end

data/lib/commands/finish.rb

@@ -0,0 +1,26 @@
+class PryMoves::Finish < PryMoves::TraceCommand
+
+  def init(binding_)
+    @block_to_finish = frame_digest(binding_) if binding_.frame_type == :block
+  end
+
+  def trace(event, file, line, method, binding_)
+    return true if @on_exit_from_method
+    return if @call_depth > 0 or event == 'c-return'
+
+    return true if @call_depth < 0
+
+    # early return:
+    return true if event == 'return' and
+      @call_depth == 0 and @method.within?(file, line) and
+      method == @method[:name] and @method.before_end?(line)
+
+    # for finishing blocks inside current method
+    if @block_to_finish
+      ((@call_depth == 0) ^ (event == 'return')) and
+        @method.within?(file, line) and
+        @block_to_finish != current_frame_digest
+    end
+  end
+
+end

data/lib/commands/goto.rb

@@ -0,0 +1,19 @@
+class PryMoves::Goto < PryMoves::TraceCommand
+
+  def init(binding_)
+    @goto_line = @command[:param].to_i
+  end
+
+  def trace(event, file, line, method, binding_)
+    if @call_depth < 0 or
+        @call_depth == 0 and event == 'return' and @method.within?(file, line)
+      PryMoves.messages << "⚠️  Unable to reach line #{@goto_line} in current frame"
+      return true
+    end
+
+    event == 'line' && @goto_line == line and
+      @method[:file] == file and
+      @call_depth == 0
+  end
+
+end

data/lib/commands/iterate.rb

@@ -0,0 +1,22 @@
+class PryMoves::Iterate < PryMoves::TraceCommand
+
+  def init(binding_)
+    @iteration_start_line = binding_.eval('__LINE__')
+    @caller_digest = frame_digest(binding_)
+  end
+
+  def trace(event, file, line, method, binding_)
+    return true if event == 'return' and
+      @method.within?(file, line)
+
+    # промотка итерации -
+    # попасть на ту же или предыдущую строку или выйти из дайджеста
+    # будучи в том же методе
+    event == 'line' and @call_depth == 0 and
+      @method.within?(file, line) and
+      (line <= @iteration_start_line or
+        @caller_digest != current_frame_digest
+      )
+  end
+
+end

data/lib/commands/next.rb

@@ -0,0 +1,37 @@
+class PryMoves::Next < PryMoves::TraceCommand
+
+  def init(binding_)
+    @start_line = binding_.eval('__LINE__')
+    @start_digest = frame_digest(binding_)
+    if @command[:param] == 'blockless'
+      @stay_at_frame = @start_digest
+    end
+    @events_traced = 0
+  end
+
+  def trace(event, file, line, method, binding_)
+    @events_traced += 1
+
+    return true if @call_depth < 0
+
+    return unless @call_depth == 0 and @method.within?(file, line)
+
+      if event == 'line'
+        if @stay_at_frame
+          return (
+            @stay_at_frame == current_frame_digest or
+            @c_stack_level < 0
+          )
+        elsif @start_line != line or (
+            @events_traced > 1 and # чтобы не застревало на while (vx = shift)
+            @start_digest == current_frame_digest # for correct iterating over one_line_in_block
+          )
+          return true
+        end
+      end
+
+      true if event == 'return' and
+        method == @method[:name] and @method.before_end?(line)
+  end
+
+end

data/lib/commands/next_breakpoint.rb

@@ -0,0 +1,22 @@
+class PryMoves::NextBreakpoint < PryMoves::TraceCommand
+
+  def init(binding_)
+    @reach_digest = frame_digest(binding_)
+  end
+
+  def trace(event, file, line, method, binding_)
+    if @reach_digest
+      if @reach_digest == current_frame_digest
+        @reach_digest = nil
+      else
+        return
+      end
+    end
+
+    if method.to_s.include? "debug"
+      @pry_start_options[:initial_frame] = 1
+      true
+    end
+  end
+
+end

data/lib/commands/step.rb

@@ -0,0 +1,83 @@
+class PryMoves::Step < PryMoves::TraceCommand
+
+  def init(binding_)
+    @step_into_funcs = nil
+    @start_line = binding_.eval('__LINE__')
+    @caller_digest = frame_digest(binding_)
+    func = @command[:param]
+    redirect_step? binding_ # set @step_into_funcs from initial binding
+    if func == '+'
+      @step_in_everywhere = true
+    elsif func
+      @find_straight_descendant = true
+      @step_into_funcs = [func]
+      @step_into_funcs << '=initialize' if ['new', '=new'].include? func
+    end
+  end
+
+  def trace(event, file, line, method, binding_)
+    if binding_.local_variable_defined? :pry_moves_skip
+      finish_cmd = {binding: binding_}
+      PryMoves::Finish.new finish_cmd, @pry_start_options do |binding|
+        start_tracing
+      end
+      return
+    end
+
+    @const_missing_level ||= 0
+    if method == :const_missing
+      if event == 'call'
+        @const_missing_level += 1
+      elsif event == 'return'
+        @const_missing_level -= 1
+      end
+    end
+    return if @const_missing_level > 0
+
+    return unless event == 'line'
+
+    if @step_in_everywhere
+      return true
+    elsif @step_into_funcs
+      if @call_depth < 0
+        PryMoves.messages << "⚠️  Unable to find function with name #{@step_into_funcs.join(',')}"
+        return true
+      end
+
+      return false if keep_search_method? binding_
+    elsif redirect_step? binding_
+      return false
+    elsif binding_.local_variable_defined? :hide_from_stack and
+          not @method.within?(file, line, method)
+      return false
+    end
+
+    true
+  end
+
+  def keep_search_method? binding_
+    return true unless method_matches? binding_.eval('__callee__')
+
+    return true if @find_straight_descendant &&
+      # if we want to step-in only into straight descendant
+      @caller_digest != current_frame_digest(upward: 1 + 1) # 1 for getting parent and 1 for 'def keep_search_method?'
+    @find_straight_descendant = false
+
+    return true if redirect_step? binding_
+  end
+
+  def method_matches?(method)
+    @step_into_funcs.any? do |pattern|
+      if pattern.is_a? Symbol
+        method == pattern
+      elsif pattern.is_a? Regexp
+        method.to_s.match pattern
+      elsif pattern.start_with? '='
+        "=#{method}" == pattern
+      else
+        method.to_s.include? pattern
+      end
+    end
+  end
+
+end

data/lib/commands/trace_command.rb

@@ -0,0 +1,87 @@
+require 'digest'
+require 'pry' unless defined? Pry
+
+module PryMoves
+class TraceCommand
+
+  include PryMoves::TraceHelpers
+
+  def self.trace(command, pry_start_options, &callback)
+    cls = command[:action].to_s.split('_').collect(&:capitalize).join
+    cls = Object.const_get "PryMoves::#{cls}"
+    cls.new command, pry_start_options, &callback
+  end
+
+  def initialize(command, pry_start_options, &callback)
+    @command = command
+    @pry_start_options = pry_start_options
+    @pry_start_options[:pry_moves_loop] = true
+    @callback = callback
+    @call_depth = 0
+    @c_stack_level = 0
+
+    binding_ = @command[:binding] # =Command.target - more rich, contains required @iseq
+    unless binding_.instance_variable_get('@iseq')
+      binding_ = PryMoves::BindingsStack.new.initial_frame
+    end
+    @method = PryMoves::TracedMethod.new binding_
+
+    if @pry_start_options.delete :exit_from_method
+      @on_exit_from_method = true
+      @call_depth -= 1
+    end
+    @pry_start_options.delete :initial_frame
+
+    init binding_
+    start_tracing
+  end
+
+  def start_tracing
+    #puts "##trace_obj #{trace_obj}"
+    Pry.config.disable_breakpoints = true
+    trace_obj.set_trace_func method(:tracing_func).to_proc
+  end
+
+  def stop_tracing
+    trace_obj.set_trace_func nil
+    Pry.config.disable_breakpoints = false
+  end
+
+  # 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
+
+  def tracing_func(event, file, line, id, binding_, klass)
+
+    # Ignore traces inside pry-moves code
+    return if file && TRACE_IGNORE_FILES.include?(File.expand_path(file))
+    return unless binding_ # ignore strange cases
+
+    # for cases when currently traced method called more times recursively
+    if event == "call" and @method.within?(file, line, id)
+      @call_depth += 1
+    elsif %w(c-call c-return).include?(event)
+      # todo: может быть, c-return тоже правильнее делать после trace
+      delta = event == 'c-call' ? 1 : -1
+      @c_stack_level += delta
+    end
+
+    printf "👟 %8s %s:%-2d %10s %8s dep:#{@call_depth} c_st:#{@c_stack_level}\n", event, file, line, id, klass if PryMoves.trace # TRACE_MOVES=1
+
+    if trace event, file, line, id, binding_
+      @pry_start_options[:exit_from_method] = true if event == 'return'
+      stop_tracing
+      @callback.call binding_
+    elsif event == "return" and @method.within?(file, line, id)
+      @call_depth -= 1
+    end
+  end
+
+end
+end

data/lib/commands/trace_helpers.rb

@@ -0,0 +1,49 @@
+module PryMoves::TraceHelpers
+
+  def redirect_step?(binding_)
+    return false unless binding_.local_variable_defined? :debug_redirect
+
+    debug_redirect = binding_.local_variable_get(:debug_redirect)
+    @step_into_funcs = [debug_redirect] if debug_redirect
+    true
+  end
+
+  def debug_info(file, line, id)
+    puts "📽  call_depth:#{@call_depth} #{@method[:file]}:#{file}"
+    puts "#{id} #{@method[:start]} > #{line} > #{@method[:end]}"
+  end
+
+  def current_frame_digest(upward: 0)
+    # binding_ from tracing_func doesn't have @iseq,
+    # therefore binding should  be re-retrieved using 'binding_of_caller' lib
+    frame_digest(binding.of_caller(3 + upward))
+  end
+
+  def frame_digest(binding_)
+    #puts "frame_digest for: #{binding_.eval '__callee__'}"
+    iseq = binding_.instance_variable_get('@iseq')
+    Digest::MD5.hexdigest iseq.disasm
+  end
+
+  def current_frame_type(upward: 0)
+    # binding_ from tracing_func doesn't have @iseq,
+    # therefore binding should  be re-retrieved using 'binding_of_caller' lib
+    frame_type(binding.of_caller(3 + upward))
+  end
+
+  def frame_type(binding_)
+    line = binding_.instance_variable_get('@iseq').disasm.split("\n").first
+    m = line.match /\== disasm: #<ISeq:([\w ]+)@/
+    if m
+      str = m[1]
+      if str.start_with? 'block in '
+        :block
+      else
+        :method
+      end
+    else
+      :unknown
+    end
+  end
+
+end

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,73 @@
+def debug *args
+  pry_moves_stack_end = true
+  PryMoves.debug *args
+end
+
+def error(msg = "Error", debug_object = nil)
+  pry_moves_stack_end = true
+  err = "😱  #{msg}"
+  unless PryMoves.open?
+    if PryMoves.stop_on_breakpoints
+      lines = [err.red]
+      lines.prepend debug_object.ai if debug_object
+      PryMoves.error lines.join("\n")
+    else
+      STDERR.puts debug_object.ai if debug_object
+      STDERR.puts err.ljust(80, ' ').red
+    end
+  end
+  raise PryMoves::ErrorWithData.new(msg, debug_object)
+end
+
+def shit!(err = 'Oh, shit!', debug_object = nil)
+  return if ENV['NO_SHIT']
+  pry_moves_stack_end = 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.error lines.join("\n")
+  nil
+end
+
+def required(var)
+  pry_moves_stack_end = 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(rspec_example: example) 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(rake_args: args) 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