pry-moves 0.1.9 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5c8495d3cd82bfbcb6772aa7c5ba21c06aa5528a5fe9bc064589b5291ddaf2e1
-  data.tar.gz: afe2e3ff6c378e2ea61c7bb21ea6814f68f64b31216f576868808ad6c41a6da2
+  metadata.gz: 2c08b34502f7649fecea8dbf09d8bbc04e917341a260c92bc1e1b50e70ad7fe3
+  data.tar.gz: 27be890e5b41dafdbdf58279c85618682ef8a3f24fa2a89094053ec8d5af9455
 SHA512:
-  metadata.gz: d7ecf92cbc18b7c6e8c1c245d10b9112c264b44a4c7617aa928bcc9a8b2f36f8b61728806b9483e65c2aa8fc5f9d1f13374c4614d92a360a9cec52102ab80166
-  data.tar.gz: 7da0796248828d36db8fcd305e95a28f7d3e1a517178d2e587785b9998fb42d33058f62a1e7d5fa890da965deaaab6a1c21af92366fbb673809100c28f4985c2
+  metadata.gz: b3d5d0a64ab6d910529b3e228154d609b638892913e66ea66c0403e152aea5aa9dceb8e66a46e8515978142af942bb7f59801ec233e1abcb2be44c2338279bc2
+  data.tar.gz: f288273d0b30e3bde39ec975e3bd5cb360a7d1a2f747cf8ab95d17e9190ac4f38797c9b21a90a3398383fd5b384dbd4df675a250ad23723360e60ccaed8ebf75

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,10 @@
 PATH
   remote: .
   specs:
-    pry-moves (0.1.8)
+    pry-moves (1.0.0)
       binding_of_caller (~> 0.7)
-      pry (>= 0.9.10, < 0.12.0)
+      colorize (~> 0.8)
+      pry (>= 0.10.4, < 0.13)
 
 GEM
   remote: https://rubygems.org/
@@ -11,6 +12,7 @@ GEM
     binding_of_caller (0.8.0)
       debug_inspector (>= 0.0.1)
     coderay (1.1.2)
+    colorize (0.8.1)
     debug_inspector (0.0.3)
     diff-lcs (1.3)
     method_source (0.9.0)
@@ -39,10 +41,10 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
-  pry
+  pry (= 0.11.3)
   pry-moves!
   pry-remote (~> 0.1.6)
   rspec
 
 BUNDLED WITH
-   1.16.6
+   1.17.3

data/README.md

@@ -9,26 +9,35 @@ _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**
-* `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`
+* `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 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 > foo` - write backtrace to file `log/backtrace_foo.log`
 * `up`/`down`/`top`/`bottom` - 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
 * `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
 
@@ -61,16 +70,25 @@ end
 
 ## 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\/)/
 ```
 
 ## Threads, helpers
 
+To allow traveling to parent thread, use:
+
+```ruby
+pre_callers = binding.callers
+Thread.new do
+  Thread.current[:pre_callers] = pre_callers
+  #...
+end
+```
+
 `pry-moves` can't stop other threads on `binding.pry`, so they will continue to run.
 This makes `pry-moves` not always suitable for debugging of multi-thread projects.
 
@@ -110,6 +128,8 @@ Please note that debugging functionality is implemented through
 
 ```
 bundle exec rspec
+
+DEBUG=true bundle exec rspec -e 'backtrace should backtrace'
 ```
 
 ## ToDo
@@ -126,7 +146,7 @@ bundle exec rspec
 * Ivo Anjo ([@ivoanjo](https://github.com/ivoanjo))
 
 Patches and bug reports are welcome. Just send a [pull request][pullrequests] or
-file an [issue][issues]. [Project changelog][changelog].
+file an [issue][issues]. 
 
 ## Acknowledgments
 

data/lib/commands/debug.rb

@@ -0,0 +1,17 @@
+class PryMoves::Debug < PryMoves::TraceCommand
+
+  def init(binding_)
+    #
+  end
+
+  def trace(event, file, line, method, binding_)
+    return unless event == 'line'
+    if @first_line_skipped
+      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