pry-moves 0.1.10 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 59d8dcb4799c37a91cfa512e77b630ec5db8f4bb13e03c16c0d446fd18c6b671
-  data.tar.gz: 55ce87ad4d54f91a3d132ca29e208a5291d596ef443c5f9cb4263b24a7cf8ddd
+  metadata.gz: 47c7a7529bee28ca664536458891b00f6a1bee574869106686cd2abef9b57adb
+  data.tar.gz: 13d671c5f8ed4005304da6d4201908c0857d19e8ee3fe85631d18cea5c109580
 SHA512:
-  metadata.gz: e82f7cae3194b3e3246066c940474c98a68e12f20efdb2552bbef97746935468fc864bac5aead31f14405a7976385b0cc315a0292c01c41667a55252022077a4
-  data.tar.gz: 5ce34a40af72680b9d28441ce67e9da713104c73c8cf9d6b2c82860ad7e452551fbb35b11a0226e36a6a624483cea8c177a0a68681af8fcab1450054386bb922
+  metadata.gz: addaf61aa995184e49f3b655f1d4fa863fa0554d1fb00f022fce7a9e1d8671595c03056e37754fd394bf9a204e32c91b3005a00fac3287f2803bafb66273e2d6
+  data.tar.gz: 9ba407049732e75c27e8cc87936e25967a30798212098fce844e948e7986912874137088fc87ffc8d9ef48ca09a3c2445da545132109a58ed47d5c4577775db4

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.1)
       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,7 +12,8 @@ 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)
     method_source (0.9.0)
     pry (0.11.3)
@@ -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,10 +70,9 @@ 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\/)/
 ```
@@ -120,6 +128,8 @@ Please note that debugging functionality is implemented through
 
 ```
 bundle exec rspec
+
+DEBUG=true bundle exec rspec -e 'backtrace should backtrace'
 ```
 
 ## ToDo
@@ -136,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

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,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