An execution control add-on for Pry.

• Install: gem 'pry-moves'
• For non-rails (without auto-require), add to your script: require 'pry-moves'

• 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
• 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 > 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
• watch variable - display variable's value on each step
• ! - exit

To use, invoke pry normally:

def some_method
  binding.pry          # Execution will stop here.
  puts 'Hello, World!' # Run 'step' or 'next' in the console to move here.
end

Demo class source here

You can explicitly hide frames from backtrace and call stack by defining hide_from_stack variable:

def insignificant_method
  hide_from_stack = true
  something_insignificant
  yield
end

Here is default configuration, you can override it:

PryMoves::Backtrace::lines_count = 5
PryMoves::Backtrace::filter =
  /(\/gems\/|\/rubygems\/|\/bin\/|\/lib\/ruby\/|\/pry-moves\/)/

To allow traveling to parent thread, use:

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.

Though you can pause other threads with helper which will suspend execution on current line, until ongoing debug session will be finished with continue:

PryMoves.synchronize_threads

For example, you can put it into function which periodically reports status of thread (if you have such)

Other helpers:

• PryMoves.open? - if pry input dialog active. Can be used to suppress output from ongoing parallel threads

Rudimentary support for pry-remote (>= 0.1.1) is also included. Ensure pry-remote is loaded or required before pry-moves. For example, in a Gemfile:

gem 'pry'
gem 'pry-remote'
gem 'pry-moves'

Please note that debugging functionality is implemented through set_trace_func, which imposes heavy performance penalty while tracing (while running code within next/step/finish commands).

bundle exec rspec

• iterate - steps in into child sub-block - should skip

• Gopal Patel (@nixme)
• John Mair (@banister)
• Conrad Irwin (@ConradIrwin)
• Benjamin R. Haskell (@benizi)
• Jason R. Clark (@jasonrclark)
• Ivo Anjo (@ivoanjo)

Patches and bug reports are welcome. Just send a pull request or file an issue. Project changelog.

• Gopal Patel's pry-nav
• John Mair's pry-stack_explorer
• Ruby stdlib's debug.rb
• @Mon-Ouie's pry_debug