pry-moves 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0f79cd377ce0604df7803f55544d00d04f2e8342
-  data.tar.gz: fcff3fd9d786930d8468dc2f5d81912702cb1b70
+  metadata.gz: 9397716c77781c90d1a1130b30a780226ac44aac
+  data.tar.gz: 9f26eae9c3731f48c93c875f3af90c5e6025c749
 SHA512:
-  metadata.gz: 0ccc6ebb0b80454c784cfb7ef9e27b22fb1f700f42c0abfdc2f7eeca89bfc9cf5796b6c809fc76e9dd3641ec333c4b1dd878e50aebf660f3ddc139355e22c924
-  data.tar.gz: 92dbe779b01e9fdaee2f48291c37e0e22d5ed9e3197ae75e370d085a3ac11e3bd044a3167ac3fc7165c6b732bdf6bd4bccfce8d0f39fca739eb23ff308577517
+  metadata.gz: b2b54ca87a8935f49de7a9d016446db8dd1a065af3e98062db580afd0ef95de7597c15def6bfc9048cfca5e1ffaeb386c315ddaf2dbf79ab14f031122c81f4e0
+  data.tar.gz: 6b2039aadade2fb859e382edcb38080d33c3bf4d3b8d025d0a783f7029607445d05744372156462bc9de0c0045772266ae12a0039d597abafc200662362cc912

data/README.md

@@ -11,13 +11,17 @@ _An execution control add-on for [Pry][pry]._
 
 * `n` - **next** line in current frame, including block lines (moving to next line goes as naturally expected)
 * `s` - **step** into function execution
-  * `s func_name` - steps into first method called by name `func_name`
-* `f` - **finish** execution of current frame and stop at next line on higher level
+  * `s func_name` - step into first method called by name `func_name`
+* `f` - **finish** execution of current frame (block or method) and stop at next line on higher level
 * `c` - **continue**
-* `bt` - shows latest 5 lines from backtrace 
+* `bt` - show latest 5 lines from backtrace
   * `bt 10` - latest 10 lines
-  * `bt all`- full backtrace
-* `up`/`down` - move over call stack
+  * `bt all` - full backtrace
+  * `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(param, param2)` - call `some_method(param, param2)` and interactively step into it
 * `!` - exit
 
 
@@ -38,22 +42,46 @@ end
 
 _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:
+
+```ruby
+def insignificant_method
+  hide_from_stack = true
+  something_insignificant
+  yield
+end
+```
+
 ## Configuration
 
 Here is default configuration, you can override it:
 
 ```ruby
-PryMoves::Backtrace::filter = 
+PryMoves::Backtrace::lines_count = 5
+PryMoves::Backtrace::filter =
   /(\/gems\/|\/rubygems\/|\/bin\/|\/lib\/ruby\/|\/pry-moves\/)/
-  
-PryMoves::Backtrace::format do |line|
-    defined?(Rails) : line.gsub( /^#{Rails.root.to_s}/, '') : line
-  end
 ```
 
-## Technical info
+## Threads, helpers
+
+`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`:
+
+```ruby
+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 
 
-`pry-moves` is not yet thread-safe, so only use in single-threaded environments.
+## pry-remote
 
 Rudimentary support for [`pry-remote`][pry-remote] (>= 0.1.1) is also included.
 Ensure `pry-remote` is loaded or required before `pry-moves`. For example, in a
@@ -65,9 +93,10 @@ gem 'pry-remote'
 gem 'pry-moves'
 ```
 
+## Performance
+
 Please note that debugging functionality is implemented through
-[`set_trace_func`][set_trace_func], which imposes a large performance
-penalty.
+[`set_trace_func`][set_trace_func], which imposes certain performance penalty.
 
 ## Contributors
 

data/dynamic_debug_experiments.rb

@@ -0,0 +1,42 @@
+if @command[:action] == :ababa
+  puts 'catch debug'
+
+
+  set_trace_func (
+                     Proc.new { |event, file, line, id, binding_, classname|
+                       #if file == '(pry)'
+                       #unless file.match /\/gems\/|\/ruby\//
+                       printf "%8s %s:%-2d %10s %8s\n", event, file, line, id, classname
+                       if event=='line' and file == 'sand.rb' and line != 47
+                         set_trace_func nil
+                         Pry.start(binding_, @pry_start_options)
+                       end
+                     })
+
+  puts "CALLER:\n#{caller.join "\n"}\n"
+
+  #Pry.start(command[:binding], @pry_start_options)
+  return return_value
+end
+
+TracePoint.new(:line) {|tp|p [tp.lineno, tp.event]}.enable
+
+set_trace_func proc { |event, file, line, id, binding, classname|
+                 printf "%8s %s:%-2d %10s %8s\n", event, file, line, id, classname
+               }
+
+
+set_trace_func proc { |event, file, line, id, binding, classname|
+                 printf "%8s %s:%-2d %10s %8s\n", event, file, line, id, classname	unless file.match /\/gems\/|\/ruby\//
+               }
+
+
+set_trace_func proc { |event, file, line, id, binding, classname|
+                 printf "%8s %s:%-2d %10s %8s\n", event, file, line, id, classname if file == '(pry)'
+               }
+
+
+
+
+
+

data/lib/pry-moves/backtrace.rb

@@ -0,0 +1,110 @@
+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\/|\/pry-moves\/)/
+    end
+    def filter=(f); @filter = f; end
+
+    def format(&block)
+      @formatter = block
+    end
+
+    def formatter
+      @formatter || lambda do |line|
+        # not used
+      end
+    end
+  end
+
+  def initialize(binding, pry)
+     @binding, @pry = binding, pry
+  end
+
+  def build(lines_count = nil)
+    result = []
+    show_vapid = lines_count == 'all'
+    stack = stack_bindings(show_vapid)
+              .reverse.reject do |binding|
+                binding.eval('__FILE__').match self.class::filter
+              end
+
+    if lines_count.is_a? String and lines_count.match /\d+/
+      lines_count = lines_count.to_i
+    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
+
+    build_result stack, result
+  end
+
+  def run_command(param)
+    if param.is_a?(String) and (match = param.match /^>(.*)/)
+      write_to_file build, match[1]
+    else
+      puts build(param || PryMoves::Backtrace::lines_count)
+    end
+  end
+
+  private
+
+  def build_result(stack, result)
+    current_object = nil
+    stack.each do |binding|
+      obj = binding.eval 'self'
+      if current_object != obj
+        colored_obj = ""
+        Pry::ColorPrinter.pp obj, colored_obj
+        result << "#{colored_obj.chomp}:"
+        current_object = obj
+      end
+
+      result << build_line(binding)
+    end
+    result
+  end
+
+  def build_line(binding)
+    file = "#{binding.eval('__FILE__')}"
+    file.gsub!( /^#{Rails.root.to_s}/, '') if defined? Rails
+
+    signature = PryMoves::Helpers.method_signature_with_owner binding
+
+    indent = frame_manager.current_frame == binding ?
+        ' => ': '    '
+
+    "#{indent}#{file}:#{binding.eval('__LINE__')} "+
+      " #{signature} :#{binding.frame_type}"
+  end
+
+  def frame_manager
+    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.open(log_path, "w") do |f|
+      f.puts lines
+    end
+    puts "Backtrace logged to #{log_path}"
+  end
+
+  def log_path(file_suffix)
+    root = defined?(Rails) ? Rails.root.to_s : '.'
+    root += '/log'
+    FileUtils.mkdir_p root
+    "#{root}/backtrace_#{file_suffix}.log"
+  end
+
+end

data/lib/pry-moves/commands.rb

@@ -22,15 +22,25 @@ module PryMoves
       run 'exit-all'
     end
 
-    block_command 'bt', 'Backtrace' do |param|
-      PryMoves::Backtrace.new(target).print param
-    end
-
     alias_command 'c', 'continue'
     alias_command 's', 'step'
     alias_command 'n', 'next'
     alias_command 'f', 'finish'
 
+    block_command 'watch', 'Display value of expression on every move' do |param|
+      PryMoves::Watch.instance.process_cmd param, target
+    end
+
+    block_command 'bt', 'Backtrace' do |param|
+      PryMoves::Backtrace.new(target, _pry_).run_command param
+    end
+
+    block_command 'debug', '' do |*command_parts|
+      check_file_context
+      cmd = command_parts.join ' '
+      breakout_navigation :debug, cmd
+    end
+
     # Hit Enter to repeat last command
     command /^$/, "repeat last command" do
       _pry_.run_command Pry.history.to_a.last

data/lib/pry-moves/helpers.rb

@@ -0,0 +1,28 @@
+module PryMoves::Helpers
+
+  extend self
+
+  # @return [String] Signature for the method object in Class#method format.
+  def method_signature_with_owner(binding)
+    meth = binding.eval('__method__')
+    meth_obj = meth ? Pry::Method.from_binding(binding) : nil
+    if !meth_obj
+      ""
+    elsif meth_obj.undefined?
+      "#{meth_obj.name_with_owner}(UNKNOWN) (undefined method)"
+    else
+      args = meth_obj.parameters.inject([]) do |arr, (type, name)|
+        name ||= (type == :block ? 'block' : "arg#{arr.size + 1}")
+        arr << case type
+                 when :req   then name.to_s
+                 when :opt   then "#{name}=?"
+                 when :rest  then "*#{name}"
+                 when :block then "&#{name}"
+                 else '?'
+               end
+      end
+      "#{meth_obj.name_with_owner}(#{args.join(', ')})"
+    end
+  end
+
+end

data/lib/pry-moves/pry_ext.rb

@@ -9,7 +9,7 @@ class << Pry
 
     if target.is_a?(Binding) && PryMoves.check_file_context(target)
       # Wrap the tracer around the usual Pry.start
-      PryMoves::Tracer.new(options).run do
+      PryMoves::PryWrapper.new(target, options).run do
         start_without_pry_nav(target, old_options)
       end
     else
@@ -23,20 +23,58 @@ end
 
 Binding.class_eval do
 
-  alias original_pry pry
+  alias pry_forced pry
 
   def pry
-    original_pry unless Pry.config.disable_breakpoints
+    unless Pry.config.disable_breakpoints
+      PryMoves.synchronize_threads
+      pry_forced
+    end
   end
 
 end
 
-require 'pry-stack_explorer'
+Pry.config.pager = false
+
+Pry::Command::Whereami.class_eval do
+  # Negligent function from Pry - evidently poor output format
+  # would be wanted to be changed often by developers,
+  # but definition so long... :(
+  def process
+    if bad_option_combination?
+      raise CommandError, "Only one of -m, -c, -f, and  LINES may be specified."
+    end
+
+    if nothing_to_do?
+      return
+    elsif internal_binding?(target)
+      handle_internal_binding
+      return
+    end
 
-PryStackExplorer::WhenStartedHook.class_eval do
+    set_file_and_dir_locals(@file)
 
-  def remove_debugger_frames(bindings)
-    bindings.drop_while { |b| b.eval("__FILE__") =~ /\/pry-/ }
+    _pry_.pager.page build_output
   end
 
+  def build_output
+    lines = []
+    lines << "#{text.bold('From:')} #{location}"
+    lines << PryMoves::Watch.instance.output(target) unless PryMoves::Watch.instance.empty?
+    lines << ''
+    lines << "#{code.with_line_numbers(use_line_numbers?).with_marker(marker).highlighted}"
+    lines << ''
+    lines.join "\n"
+  end
+
+  def location
+    me = target.eval 'self' rescue nil
+    if me
+      colored_str = ''
+      Pry::ColorPrinter.pp me, colored_str
+      me = colored_str.chomp
+    end
+    file = defined?(Rails) ? @file.gsub(Rails.root.to_s, '') : @file
+    "#{file}:#{@line} #{me}"
+  end
 end

data/lib/pry-moves/pry_wrapper.rb

@@ -0,0 +1,69 @@
+require 'pry' unless defined? Pry
+
+module PryMoves
+class PryWrapper
+  def initialize(binding_, pry_start_options = {})
+    @init_binding = binding_
+    @pry_start_options = pry_start_options   # Options to use for Pry.start
+  end
+
+  def run(&block)
+    PryMoves.lock
+
+    return_value = nil
+    PryMoves.is_open = true
+    @command = catch(:breakout_nav) do      # Coordinates with PryMoves::Commands
+      return_value = yield
+      nil    # Nothing thrown == no navigational command
+    end
+    PryMoves.is_open = false
+
+    if @command
+      trace_command
+    else
+      PryMoves.unlock
+      if @pry_start_options[:pry_remote] && PryMoves.current_remote_server
+        PryMoves.current_remote_server.teardown
+      end
+    end
+
+    return_value
+  end
+
+  private
+
+  def trace_command
+    if @command[:action] == :debug
+      wrap_debug
+    else
+      start_tracing
+    end
+  end
+
+  def wrap_debug
+    #puts "##wrap debug"
+    #puts "CALLER:\n#{caller.join "\n"}\n"
+    #      Thread.abort_on_exception=true
+    Thread.new do
+      Thread.current[:pry_moves_debug] = true
+      #@command[:binding].eval 'puts "###########"'
+      start_tracing
+      begin
+        @command[:binding].eval @command[:param]
+      rescue => e
+        Thread.current.set_trace_func nil
+        puts e
+      end
+    end.join
+    binding_ = @last_runtime_binding || @init_binding
+    Pry.start(binding_, @pry_start_options)
+  end
+
+  def start_tracing
+    @last_runtime_binding = @command[:binding]
+    @tracer = PryMoves::Tracer.new @command, @pry_start_options
+    @tracer.trace
+  end
+
+end
+end