pry_debug 0.0.1

data/.gitignore

@@ -0,0 +1,2 @@
+*.gem
+*.rbc

data/README.md

@@ -0,0 +1,253 @@
+# PryDebug
+
+PryDebug is a pure-ruby debugger, It simply relies on ``set_trace_func`` and
+uses Pry (an alternative to IRB) to evaluate code on breakpoints. This means you
+have complete access to local variables (you can even change them!), and can get
+any information you want using methods and Pry's commands (find out the value of
+an instance variable, for example).
+
+If you wonder why using a debugger: how often have you written things like this?
+
+```ruby
+puts "HERE!!!"
+
+# add as many variables as needed until you find the source of the issue.
+p :foo => foo, :bar => bar, :baz => baz, :self => self
+```
+
+Adding a breakpoint on that line would tell you whether it was executed and let
+you see the value of all those variables and all the other without running your
+code again.
+
+## Installation
+
+```
+gem install pry_debug
+```
+
+PryDebug works has been tested with CRuby 1.9.2 and 1.8.7, and works with some
+glitches in JRuby.
+
+## Example
+
+Just use the ``pry_debug`` executable, configure the debugger (add breakpoints,
+...) and type ``run``.
+
+```
+$ pry_debug file.rb
+debugged file set to test_debug.rb
+pry(main)> b Foo.foo
+addded breakpoint 0 at Foo.foo
+pry(main)> r
+reached breakpoint 0 at Foo.foo
+
+From: /home/kilian/code/pry_debug/test_debug.rb @ line 2 in Class#foo:
+
+     1: class Foo
+ =>  2:   def self.foo
+     3:     a, b, c = 1, 2, 3
+     4:     @foo = a + b + c
+     5:   end
+     6:
+     7:   def initialize(name)
+pry(Foo):1> n
+stepped at /home/kilian/code/pry_debug/test_debug.rb:3
+
+From: /home/kilian/code/pry_debug/test_debug.rb @ line 3 in Class#foo:
+
+     1: class Foo
+     2:   def self.foo
+ =>  3:     a, b, c = 1, 2, 3
+     4:     @foo = a + b + c
+     5:   end
+     6:
+     7:   def initialize(name)
+     8:     @name = name
+pry(Foo):2> n
+stepped at /home/kilian/code/pry_debug/test_debug.rb:4
+
+From: /home/kilian/code/pry_debug/test_debug.rb @ line 4 in Class#foo:
+
+     1: class Foo
+     2:   def self.foo
+     3:     a, b, c = 1, 2, 3
+ =>  4:     @foo = a + b + c
+     5:   end
+     6:
+     7:   def initialize(name)
+     8:     @name = name
+     9:   end
+pry(Foo):3> p a
+1
+=> 1
+pry(Foo):3> ls -i
+Instance variables: []
+```
+
+## Features
+
+### Break on a line
+
+That's quite an important feature: just ``b file.rb:line`` to break whenever
+that line gets executed. Notice you can pass file.rb, path/to/file.rb, or
+/full/path/to/file.rb to refer to the same file.
+
+It will run Pry once the breakpoint is reached. When you're done, just type
+``c`` to continue.
+
+Breakpoints can be listed and removed whenever Pry is running:
+
+```
+pry(Foo):3> b test_debug.rb:10
+added breakpoint 1 at test_debug.rb:10
+pry(Foo):3> bl
+breakpoint 0 at Foo.foo
+breakpoint 1 at test_debug.rb:10
+pry(Foo):3> d 0
+breakpoint 0 deleted
+pry(Foo):3> bl
+breakpoint 1 at test_debug.rb:10
+```
+
+(You can use breakpoint instead of b, breakpoint-list instead of bl, delete
+or del instead of d, and continue instead of c; I'm sure most people can't stand
+typing the full command names, though)
+
+### Break on a method
+
+Often, you just want to break when a method gets called. Surely you can find the
+location of a method in your code most of the time, but that won't work for
+C-defined methods, and it is more work than just typing the name of the method,
+isn't it?
+
+```
+pry(Foo):3> b SomeClass#some_method
+addded breakpoint 2 at SomeClass#some_method
+```
+
+SomeClass#some_method is used to break on the instance method ``some_method`` of
+the class SomeClass. Both ``SomeClass.some_method`` and
+``SomeClass::some_method`` will break on a class method.
+
+Note that, due to implementation details, it is currently hard for PryDebug to
+identify that some call to Class#new was in fact a call to Foo.new. It still can
+find what was called in most other cases.
+
+### Conditional breakpoints
+
+You may want a breakpoint to be run only when a particular condition is met. You
+can add a condition to the breakpoint using ``cond breakpoint_id some code``,
+where some code will get run every time the breakpoint is reached. If it
+evaluated to nil or false, then PryDebug won't actually stop at that
+point. Conditions can also be removed using ``uncond breakpoint_id``.
+
+```
+pry(Foo):3> b foo.rb:15
+added breakpoint 3 at foo.rb:15
+pry(Foo):3> cond 3 @array.size > 10
+condition set to @array.size > 10
+pry(Foo):3> bl
+breakpoint 3 at foo.rb:15 (if @array.size > 10)
+```
+
+(Beware, exceptions in conditions are silently ignored)
+
+### Step and next
+
+Breaking at a given place is sometimes not enough. Sometimes, it is useful to
+execute each line to find out what changed. That's what the ``step`` command is for:
+it makes the debugger execute code until the next line before breaking. You can
+also use ``step`` instead of ``run``. It will then break on the first line of
+your code.
+
+``next`` is a similar command, that will break on the next line in the same
+file (though it would ideally break on the next line in the same method instead
+of stepping into it if it is defined in the same file).
+
+### Exceptions
+
+You don't need to do anything to benefit from this feature: whenever an
+exception isn't rescued, PryDebug will rescue it and bring you back to the place
+where it occured so you can find out why it was raised:
+
+```
+unrescued exception: RuntimeError: foo
+returning back to where the exception was raised
+
+From: /home/kilian/code/pry_debug/test_debug.rb @ line 22 in Object#N/A:
+
+    17:
+    18: 100.times.map do |n|
+    19:   n * 2
+    20: end
+    21:
+ => 22: raise "foo"
+    23:
+    24: __END__
+    25: b Foo.foo
+    26: b Class#inherted
+    27: b FooBar.jump
+pry(main):3>
+```
+
+### Break on raise
+
+This is disabled by default because it is annoying in code where an exception
+being raised and then rescued is normal. It can still be helpful: once enabled,
+raising an exception causes PryDebug to stop. This can be toggled using the
+``bor`` (``break-on-raise``) command.
+
+```
+pry(main):4> bor
+break on raise enabled
+pry(main):4> r
+exception raised: RuntimeError: foo
+
+From: /home/kilian/code/pry_debug/test_debug.rb @ line 22 in Object#N/A:
+
+    17:
+    18: 100.times.map do |n|
+    19:   n * 2
+    20: end
+    21:
+ => 22: raise "foo"
+    23:
+    24: __END__
+    25: b Foo.foo
+    26: b Class#inherted
+    27: b FooBar.jump
+pry(main):5>
+```
+
+### Start in an existing program
+
+Instead of starting your program from PryDebug, you can start PryDebug from your
+program. In this case, it won't handle unrescued exceptions automatically,
+though.
+
+```ruby
+require 'pry_debug'
+PryDebug.start(false) # true makes PryDebug load its own file
+
+# you can make it handle exceptions yourself (or break-on-raise instead):
+begin
+  # ...
+rescue SystemExit
+  # nothing
+rescue Exception => ex
+  # PryDebug can still be started
+
+  if binding = PryDebug.context_of_exception(ex)
+    PryDebug.start_pry binding
+  else
+    PryDebug.start_pry ex
+  end
+end
+```
+
+### Threads
+
+It is completely possible you will want to use PryDebug in code that uses
+Thread. PryDebug will ensure that only one thread uses Pry. It will also keep
+information about breakpoints and stepping on a thread basis, to avoid
+unexpected and undetermined results.

data/Rakefile

@@ -0,0 +1,16 @@
+require 'rake'
+
+task :test do
+  path = File.expand_path("test/run_all.rb", File.dirname(__FILE__))
+
+  if defined? RUBY_ENGINE and RUBY_ENGINE =~ /jruby/i
+    ruby path
+  else
+    load path
+  end
+end
+
+task :install do
+  ruby "-S gem build pry_debug.gemspec"
+  ruby "-S gem install -l pry_debug"
+end

data/bin/pry_debug

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+require 'pry_debug'
+
+if ARGV[0]
+  PryDebug.file = ARGV[0]
+  puts "debugged file set to #{ARGV[0]}"
+end
+
+PryDebug.start

data/lib/pry_debug.rb

@@ -0,0 +1,279 @@
+require 'thread'
+
+require 'pry'
+
+require 'pry_debug/conditional_breakpoint'
+require 'pry_debug/line_breakpoint'
+require 'pry_debug/method_breakpoint'
+require 'pry_debug/commands'
+
+module PryDebug
+  DefinitionFile = File.expand_path(__FILE__)
+
+  class << self
+    # @return [Array<LineBreakpoint,MethodBreakpoint>] All the enabled breakpoints
+    attr_reader   :breakpoints
+
+    attr_accessor :breakpoint_count
+
+    # @return [String, nil] File that PryDebug loads
+    attr_accessor :file
+
+    # @return [String, nil] If not nil, the file where PryDebug needs to stop
+    #   (implying that next was called)
+    def stepped_file
+      Thread.current[:__pry_debug_stepped_file]
+    end
+
+    def stepped_file=(val)
+      Thread.current[:__pry_debug_stepped_file] = val
+    end
+
+    # @return [true, false]  True if stepping
+    def stepping
+      Thread.current[:__pry_debug_steppping]
+    end
+
+    def stepping=(val)
+      Thread.current[:__pry_debug_stepping] = val
+    end
+
+    # @return [Binding, nil] Binding where last_exception was raised
+    def exception_binding
+      Thread.current[:__pry_debug_exception_binding]
+    end
+
+    def exception_binding=(b)
+      Thread.current[:__pry_debug_exception_binding] = b
+    end
+
+    # @return [Exception, nil] Last exception that PryDebug has heard of
+    def last_exception
+      Thread.current[:__pry_debug_last_exception]
+    end
+
+    def last_exception=(ex)
+      Thread.current[:__pry_debug_last_exception] = ex
+    end
+
+    # @return [true, false] True if PryDebug breaks on raise
+    attr_accessor :break_on_raise
+
+    attr_accessor :debugging
+    attr_accessor :will_load
+
+    attr_reader :mutex
+
+    # @return [Array<LineBreakpoint>] Breakpoints on a line
+    def line_breakpoints
+      breakpoints.select { |bp| bp.is_a? LineBreakpoint }
+    end
+
+    # @return [Array<MethodBreakpoint>] Breakpoints on a method
+    def method_breakpoints
+      breakpoints.select { |bp| bp.is_a? MethodBreakpoint }
+    end
+
+    # @return [Binding, nil] Binding where the exception was raised, if still in
+    #   memory.
+    def context_of_exception(ex)
+      if ex.equal? last_exception
+        exception_binding
+      end
+    end
+
+    # Resets PryDebug to its default state.
+    def clean_up
+      @breakpoints      = []
+      @breakpoint_count = -1
+      @file             = nil
+
+      Thread.list.each do |th|
+        th[:__pry_debug_stepped_file] = nil
+        th[:__pry_debug_stepping]     = false
+
+        th[:__pry_debug_exception_binding] = nil
+        th[:__pry_debug_last_exception]    = nil
+      end
+
+      @break_on_raise    = false
+      @debugging         = false
+      @will_load         = true
+
+      @mutex             = Mutex.new
+    end
+  end
+
+  clean_up
+
+  module_function
+
+  # Starts the debguger.
+  #
+  # @param [true, false] load_file When set to false, PryDebug won't load
+  #   a file, and simply enable the tracing and let the user setup breakpoints.
+  def start(load_file = true)
+    PryDebug.will_load = load_file
+
+    # Importing user-defined commands.
+    # NB: what about commands defined in both sets? Currently, user-defined
+    # commands override PryDebug's. What about doing it the other way around?
+    Pry.load_rc if Pry.config.should_load_rc # user might change Pry.commands
+    Pry.config.should_load_rc = false # avoid loading config twice
+    ShortCommands.import Pry.commands
+
+    loop do
+      should_start = catch(:start_debugging!) do
+        Pry.start(TOPLEVEL_BINDING, :commands => ShortCommands)
+      end
+
+      if should_start == :now!
+        set_trace_func trace_proc
+        PryDebug.debugging = true
+
+        return unless load_file
+
+        begin
+          load PryDebug.file
+        rescue SystemExit
+          # let this go
+        rescue Exception => ex
+          set_trace_func nil
+          puts "unrescued exception: #{ex.class}: #{ex.message}"
+
+          if binding = PryDebug.context_of_exception(ex)
+            msg = "returning back to where the exception was raised"
+            start_pry binding, nil, msg
+          else
+            msg =  "context of the exception is unknown, starting pry into\n"
+            msg << "the exception."
+
+            start_pry ex, nil, msg
+          end
+        end
+
+        PryDebug.last_exception = PryDebug.exception_binding = nil
+        PryDebug.debugging = false
+
+        set_trace_func nil
+        puts "execution terminated"
+      else
+        break # debugger wasn't started, leave now
+      end
+    end
+  end
+
+  # Starts Pry with access to ShortCommands
+  # @param [Binding, object] binding Context to go to
+  # @param [String, nil] file Current file. Used for the next command.
+  # @param [String, nil] header Line to print before starting the debugger
+  def start_pry(binding, file = nil, header = nil)
+    PryDebug.synchronize do
+      puts header if header
+
+      ret = catch(:resume_debugging!) do
+        Pry.start(binding, :commands => ShortCommands)
+      end
+
+      if ret == :next
+        PryDebug.stepped_file = file
+      end
+
+      # In case trace_func was changed
+      set_trace_func trace_proc
+    end
+  end
+
+  def synchronize(&block)
+    PryDebug.mutex.synchronize(&block)
+  end
+
+  def trace_proc
+    proc do |*args|
+      PryDebug.trace_func(*args)
+    end
+  end
+
+  def trace_func(event, file, line, method, binding, klass)
+    # Ignore events in this file
+    return if file && File.expand_path(file) == DefinitionFile
+
+    case event
+    when 'line'
+      if PryDebug.stepped_file == file
+        PryDebug.stepped_file = nil
+        start_pry binding, file, "stepped at #{file}:#{line} in #{Thread.current}"
+      elsif PryDebug.stepping
+        PryDebug.stepping = false
+        start_pry binding, file, "stepped at #{file}:#{line} in #{Thread.current}"
+      elsif bp = PryDebug.line_breakpoints.find { |b| b.is_at?(file, line, binding) }
+        start_pry binding, file, "reached #{bp} in #{Thread.current}"
+      end
+    when 'c-call', 'call'
+      return unless Module === klass
+
+      # Whether we are calling a class method or an instance method, klass
+      # is the same thing, making it harder to guess if it's a class or an
+      # instance method.
+      #
+      # In case of C method calls, self cannot be trusted. Both will be tried,
+      # unless we can find out there is only an instance method of that name
+      # using instance_methods.
+      #
+      # Otherwise, assume it's an instance method if self is_a? klass
+      #
+      # Notice that since self could be a BasicObject, it may not respond to
+      # is_a? (even when not breaking on BasicObject#thing, this code may be
+      # triggered).
+      class_method, try_both = if event == "call"
+                                 [!(klass === binding.eval("self")), false]
+                               else
+                                 if (klass.instance_methods & klass.methods).include? method
+                                   [false, true]
+                                 elsif klass.instance_methods.include? method
+                                   [false, false]
+                                 elsif klass.methods.include? method
+                                   [true, false]
+                                 else # should never happen
+                                   [false, true]
+                                 end
+                               end
+
+      bp = PryDebug.method_breakpoints.find do |b|
+        if try_both
+          b.is_at?(klass, method.to_s, true, binding) ||
+            b.is_at?(klass, method.to_s, false, binding)
+        else
+          b.is_at?(klass, method.to_s, class_method, binding)
+        end
+      end
+
+      if bp
+        start_pry binding, file, "reached #{bp} in #{Thread.current}"
+      end
+    when 'raise'
+      return unless $!
+
+      PryDebug.last_exception    = $!
+      PryDebug.exception_binding = binding
+
+      if PryDebug.break_on_raise
+        msg = "exception raised in #{Thread.current}: #{$!.class}: #{$!.message} "
+        start_pry binding, file, msg
+      end
+    end
+  end
+
+  def add_line_breakpoint(file, line)
+    bp = LineBreakpoint.new(PryDebug.breakpoint_count += 1, file, line)
+    PryDebug.breakpoints << bp
+    bp
+  end
+
+  def add_method_breakpoint(klass, method, class_method)
+    bp = MethodBreakpoint.new(PryDebug.breakpoint_count += 1, klass, method,
+                              class_method)
+    PryDebug.breakpoints << bp
+    bp
+  end
+end

data/lib/pry_debug/commands.rb

@@ -0,0 +1,141 @@
+module PryDebug
+  Commands = Pry::CommandSet.new do
+    command "breakpoint", "adds a breakpoint" do |argument, *|
+      if argument =~ /(.+):(\d+)/
+        file, line = $1, $2.to_i
+
+        bp = PryDebug.add_line_breakpoint(file, line)
+        output.puts "added #{bp}"
+      elsif argument =~ /(.+)(#|\.|::)([^#\.:]+)/
+        klass, separator, meth = $1, $2, $3
+        class_method = (separator != "#")
+
+        bp = PryDebug.add_method_breakpoint(klass, meth, class_method)
+        output.puts "added #{bp}"
+      else
+        output.puts "usage: breakpoint FILE:LINE"
+        output.puts "    or breakpoint CLASS(#|.|::)METHOD"
+        output.puts
+        output.puts "FILE can be foo.rb or /full/path/to/foo.rb."
+        output.puts "# as a separator means instance method. . and :: both mean"
+        output.puts "class method."
+      end
+    end
+
+    command "breakpoint-list", "prints breakpoint list" do
+      output.puts PryDebug.breakpoints
+    end
+
+    command "delete", "deletes a breakpoint" do |id, *|
+      PryDebug.breakpoints.reject! { |b| b.id == id.to_i }
+      output.puts "breakpoint #{id} deleted"
+    end
+
+    command "cond", "adds a condition to a breakpoint" do
+      id = string = nil
+      if arg_string =~ /^(\d+) (.+)$/
+        id, string = [$1.to_i, $2]
+      else
+        output.puts "usage: cond ID CODE"
+        next
+      end
+
+      if bp = PryDebug.breakpoints.find { |b| b.id == id }
+        bp.condition = string
+        output.puts "condition set to #{bp.condition}"
+      else
+        output.puts "error: could not find breakpoint #{id}"
+      end
+    end
+
+    command "uncond", "removes the condition of a breakpoint" do |id, *|
+      if id =~ /^\d+$/ && (bp = PryDebug.breakpoints.find { |b| b.id == id.to_i })
+        bp.condition = nil
+        output.puts "condition unset"
+      else
+        output.puts "error: could not find breakpoint #{id}"
+      end
+    end
+
+    command "file", "sets the file to start the debugger at" do |file, *|
+      PryDebug.file = file
+      output.puts "debugged file set to #{file}"
+    end
+
+    command "run", "starts the debugger" do |file, *|
+      if PryDebug.debugging
+        output.puts "error: debugger already started"
+        next
+      end
+
+      PryDebug.file = file if file
+
+      if !PryDebug.will_load || (PryDebug.file and File.exist? PryDebug.file)
+        throw :start_debugging!, :now!
+      else
+        if PryDebug.file
+          output.puts "error: file does not exist: #{PryDebug.file}"
+        else
+          output.puts "error: file is not set: #{PryDebug.file}"
+        end
+
+        output.puts "create it or set a new file using the 'file' command."
+      end
+    end
+
+    command "continue", "resumes execution" do
+      if !PryDebug.debugging
+        output.puts "error: debugger hasn't been started yet"
+      else
+        throw :resume_debugging!
+      end
+    end
+
+    command "next", "resumes execution until next line in the same file" do
+      if !PryDebug.debugging
+        output.puts "error: debugger hasn't been started yet"
+      else
+        throw :resume_debugging!, :next
+      end
+    end
+
+    command "step", "resumes execution until next line gets executed" do
+      PryDebug.stepping = true
+
+      if PryDebug.debugging
+        throw :resume_debugging!
+      else # just start debugging with stepping set to true
+        if !PryDebug.will_load || (PryDebug.file and File.exist? PryDebug.file)
+          throw :start_debugging!, :now!
+        else
+          output.puts "error: file does not exist: #{PryDebug.file}"
+          output.puts "create it or set a new file using the 'file' command."
+        end
+      end
+    end
+
+    command "break-on-raise", "toggles break on raise" do
+      PryDebug.break_on_raise = !PryDebug.break_on_raise
+
+      if PryDebug.break_on_raise
+        output.puts "break on raise enabled"
+      else
+        output.puts "break on raise disabled"
+      end
+    end
+  end
+
+  ShortCommands = Pry::CommandSet.new Commands do
+    alias_command "f",   "file"
+    alias_command "b",   "breakpoint"
+    alias_command "bp",  "breakpoint"
+    alias_command "bl",  "breakpoint-list"
+    alias_command "del", "delete"
+    alias_command "d",   "delete"
+    alias_command "r",   "run"
+    alias_command "c",   "continue"
+    alias_command "n",   "next"
+    alias_command "s",   "step"
+    alias_command "bor", "break-on-raise"
+  end
+end

data/lib/pry_debug/conditional_breakpoint.rb

@@ -0,0 +1,15 @@
+module PryDebug
+  module ConditionalBreakpoint
+    attr_accessor :condition
+
+    def is_at?(binding)
+      condition ? binding.eval(condition) : true
+    rescue Exception # error in the code
+      false
+    end
+
+    def to_s
+      condition ? " (if #{condition})" : ""
+    end
+  end
+end

data/lib/pry_debug/line_breakpoint.rb

@@ -0,0 +1,44 @@
+module PryDebug
+  LineBreakpoint = Struct.new(:id, :file, :line) do
+    include ConditionalBreakpoint
+
+    def at_location?(other_file, other_line)
+      return false unless line == other_line
+
+      path = ""
+      split_file(other_file).any? do |part|
+        path = File.join(part, path).chomp('/')
+        path == file
+      end
+    end
+
+    def is_at?(other_file, other_line, binding)
+      at_location?(other_file, other_line) && super(binding)
+    end
+
+    def split_file(file)
+      ary = []
+
+      loop do
+        dirname, filename = File.split(file)
+
+        ary << filename
+
+        if dirname == '.'
+          break
+        elsif dirname == '/'
+          ary << '/'
+          break
+        else
+          file = dirname
+        end
+      end
+
+      ary
+    end
+
+    def to_s
+      "breakpoint #{id} at #{file}:#{line}#{super}"
+    end
+  end
+end

data/lib/pry_debug/method_breakpoint.rb

@@ -0,0 +1,89 @@
+module PryDebug
+  MethodBreakpoint = Struct.new(:id, :klass, :name, :class_method) do
+    include ConditionalBreakpoint
+
+    alias class_method? class_method
+
+    def at_method?(other_class, other_name, other_class_method)
+      return false unless Module === other_class
+
+      if klass == other_class.to_s && name == other_name &&
+          class_method == other_class_method
+        true # exactly the same parameters
+      else # find out if the method we are referring to is the same as the one
+           # that was called.
+        if klass = actual_class
+          other_method = if other_class_method && has_class_method?(other_class, other_name)
+                           (class << other_class; self; end).instance_method(other_name)
+                         elsif !other_class_method && has_instance_method?(other_class, other_name)
+                           other_class.instance_method(other_name)
+                         end
+
+          if referred_method && other_method
+            singleton_class = (class << klass; self; end)
+            (other_class < klass || other_class == klass ||
+             (singleton_class == other_class || singleton_class < klass)) &&
+              ((referred_method == other_method) ||
+               (referred_method.name  == other_method.name &&
+                referred_method.owner == other_method.owner))
+          else
+            false
+          end
+        else
+          false # can't get information about the class
+        end
+      end
+    end
+
+    def is_at?(other_class, other_name, other_class_method, binding)
+      at_method?(other_class, other_name, other_class_method) && super(binding)
+    end
+
+    def to_s
+      "breakpoint #{id} at #{method_name}#{super}"
+    end
+
+    def separator
+      class_method ? "." : "#"
+    end
+
+    def method_name
+      klass + separator + name
+    end
+
+    def referred_method
+      if klass = actual_class
+        @referred_method ||= if class_method? && has_class_method?(klass, name)
+                               (class << klass; self; end).instance_method(name)
+                             elsif !class_method && has_instance_method?(klass, name)
+                               klass.instance_method(name)
+                             end
+      end
+    end
+
+    def actual_class
+      # this method uses Module#=== to be BasicObject safe
+      @actual_class ||= klass.split('::').inject(Object) do |mod, const_name|
+        if (Module === mod) && mod.const_defined?(const_name)
+          mod.const_get const_name
+        else
+          break
+        end
+      end
+
+      (Module === @actual_class) ? @actual_class : nil
+    end
+
+    def has_instance_method?(klass, method)
+      (klass.private_instance_methods + klass.instance_methods).any? do |m|
+        m.to_s == method
+      end
+    end
+
+    def has_class_method?(klass, method)
+      (klass.private_methods + klass.methods).any? do |m|
+        m.to_s == method
+      end
+    end
+  end
+end

data/pry_debug.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+Gem::Specification.new do |s|
+  s.name        = "pry_debug"
+  s.version     = "0.0.1"
+  s.authors     = ["Mon ouïe"]
+  s.email       = ["mon.ouie@gmail.com"]
+  s.homepage    = "http://github.com/Mon-Ouie/pry_debug"
+
+  s.summary     = "A pure-ruby debugger"
+  s.description = <<EOD
+A pure-ruby debugger. No more puts "HERE!!!" or p :var => var, :other => other
+until you find what caused the bug. Just add a breakpoint and see the value of
+any variable.
+EOD
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- test/*`.split("\n")
+  s.executables   = %w[pry_debug]
+  s.require_paths = %w[lib]
+
+  s.add_dependency "pry", "~> 0.9.0"
+  s.add_development_dependency "riot"
+end

data/test/conditional_breakpoint_test.rb

@@ -0,0 +1,59 @@
+require File.expand_path("helpers.rb", File.dirname(__FILE__))
+
+context "a conditional line breakpoint" do
+  setup do
+    bp = PryDebug::LineBreakpoint.new(1, "test.rb", 10)
+    bp.condition = "n == 0"
+    bp
+  end
+
+  asserts(:condition).equals "n == 0"
+  asserts(:to_s).equals "breakpoint 1 at test.rb:10 (if n == 0)"
+
+  context "when causing an exception" do
+    denies(:is_at?, "test.rb", 10, binding)
+  end
+
+  context "when condition isn't met" do
+    n = -1
+    denies(:is_at?, "test.rb", 10, binding)
+  end
+
+  context "when condition is met" do
+    n = 0
+    asserts(:is_at?, "test.rb", 10, binding)
+    denies(:is_at?, "test.rb", 11, binding)
+    denies(:is_at?, "foo.rb", 10, binding)
+  end
+end
+
+context "a conditional method breakpoint" do
+  setup do
+    bp = PryDebug::MethodBreakpoint.new(1, "String", "try_convert", true)
+    bp.condition = "n == 0"
+    bp
+  end
+
+  asserts(:condition).equals "n == 0"
+  asserts(:to_s).equals "breakpoint 1 at String.try_convert (if n == 0)"
+
+  context "when causing an exception" do
+    denies(:is_at?, String, "try_convert", true, binding)
+  end
+
+  context "when condition isn't met" do
+    n = -1
+    denies(:is_at?, String, "try_convert", true, binding)
+  end
+
+  context "when condition is met" do
+    n = 0
+    asserts(:is_at?, String, "try_convert", true, binding)
+
+    denies(:is_at?, Array, "try_convert", true, binding)
+    denies(:is_at?, String, "new", true, binding)
+    denies(:is_at?, String, "try_convert", false, binding)
+  end
+end
+
+run_tests if $0 == __FILE__

data/test/helpers.rb

@@ -0,0 +1,19 @@
+$:.unshift File.expand_path('../lib', File.dirname(__FILE__))
+
+require 'riot'
+require 'pry_debug'
+
+Riot.reporter = Riot::PrettyDotMatrixReporter
+Riot.alone!
+
+Pry.config.should_load_rc  = false
+Pry.config.plugins.enabled = false
+Pry.config.history.load    = false
+Pry.config.history.save    = false
+
+Pry.color = false
+Pry.pager = false
+
+def run_tests
+  exit Riot.run.success?
+end

data/test/line_breakpoint_test.rb

@@ -0,0 +1,24 @@
+require File.expand_path("helpers.rb", File.dirname(__FILE__))
+
+context "a line breakpoint" do
+  setup { PryDebug::LineBreakpoint.new(4, "test/foo.rb", 16) }
+
+  asserts(:condition).nil
+  asserts(:file).equals "test/foo.rb"
+  asserts(:line).equals 16
+  asserts(:id).equals 4
+
+  asserts(:to_s).equals "breakpoint 4 at test/foo.rb:16"
+
+  asserts(:is_at?, "test/foo.rb", 16, binding)
+  asserts(:is_at?, "foo/test/foo.rb", 16, binding)
+  asserts(:is_at?, "/bar/test/foo.rb", 16, binding)
+
+  denies(:is_at?, "test/foo.rb", 17, binding)
+  denies(:is_at?, "foo.rb", 16, binding)
+  denies(:is_at?, "oo.rb", 16, binding)
+  denies(:is_at?, "est/foo.rb", 16, binding)
+  denies(:is_at?, "test/bar.rb", 16, binding)
+end
+
+run_tests if $0 == __FILE__

data/test/method_breakpoint_test.rb

@@ -0,0 +1,90 @@
+require File.expand_path("helpers.rb", File.dirname(__FILE__))
+
+context "a method breakpoint" do
+  setup { PryDebug::MethodBreakpoint.new(2, "Time", "new", true) }
+
+  asserts(:condition).nil
+  asserts(:klass).equals "Time"
+  asserts(:name).equals "new"
+  asserts(:id).equals 2
+
+  asserts(:actual_class).equals Time
+  asserts(:referred_method).equals((class << Time; self; end).instance_method(:new))
+
+  asserts(:to_s).equals "breakpoint 2 at Time.new"
+
+  asserts(:is_at?, Time, "new", true, binding)
+  asserts(:is_at?, Class.new(Time), "new", true, binding)
+
+  asserts(:is_at?, (class << Time; self; end), "new", false, binding)
+
+  denies(:is_at?, Class, "new", false, binding)
+  denies(:is_at?, Time, "new", false, binding)
+  denies(:is_at?, String, "new", true, binding)
+  # "now" doesn't pass on rbx because it's an alias
+  denies(:is_at?, Time, "parse", true, binding)
+  denies(:is_at?, Class.new(Time) {def self.new;end}, "new", true, binding)
+end
+
+context "a method breakpoint on an instance method" do
+  setup { PryDebug::MethodBreakpoint.new(2, "String", "size", false) }
+
+  asserts(:condition).nil
+  asserts(:klass).equals "String"
+  asserts(:name).equals "size"
+  asserts(:id).equals 2
+
+  asserts(:actual_class).equals String
+  asserts(:referred_method).equals String.instance_method(:size)
+
+  asserts(:to_s).equals "breakpoint 2 at String#size"
+
+  asserts(:is_at?, String, "size", false, binding)
+  # in 1.8, aliased methods aren't equal
+  asserts(:is_at?, String, "length", false, binding) if RUBY_VERSION >= "1.9"
+  asserts(:is_at?, Class.new(String), "size", false, binding)
+
+  denies(:is_at?, String, "size", true, binding)
+  denies(:is_at?, Time, "size", false, binding)
+  denies(:is_at?, String, "foo", false, binding)
+  denies(:is_at?, Class.new(String) {def size;end}, "size", false, binding)
+end
+
+context "a method breakpoint with unknown method" do
+  setup { PryDebug::MethodBreakpoint.new(2, "Time", "foo", true) }
+
+  asserts(:actual_class).equals Time
+  asserts(:referred_method).nil
+
+  denies(:is_at?, Class.new(Time), "foo", true, binding)
+  denies(:is_at?, Time, "now", false, binding)
+  denies(:is_at?, String, "now", true, binding)
+  denies(:is_at?, Time, "new", true, binding)
+  denies(:is_at?, Class.new(Time) {def self.now;end}, "now", true, binding)
+end
+
+context "a method breakpoint with unknown class" do
+  setup { PryDebug::MethodBreakpoint.new(2, "Bar", "foo", true) }
+
+  asserts(:actual_class).nil
+  asserts(:referred_method).nil
+
+  denies(:is_at?, Time, "foo", true, binding)
+  denies(:is_at?, Class.new(Time), "foo", true, binding)
+  denies(:is_at?, Time, "now", false, binding)
+  denies(:is_at?, String, "now", true, binding)
+  denies(:is_at?, Time, "new", true, binding)
+  denies(:is_at?, Class.new {def self.now;end}, "foo", true, binding)
+end
+
+context "a method breakpoint with a non-class" do
+  setup { PryDebug::MethodBreakpoint.new(2, "File::SEPARATOR", "size", true) }
+
+  asserts(:actual_class).nil
+  asserts(:referred_method).nil
+
+  denies(:is_at?, File::SEPARATOR, "size", true, binding)
+  denies(:is_at?, String, "size", false, binding)
+end
+
+run_tests if $0 == __FILE__

data/test/run_all.rb

@@ -0,0 +1,7 @@
+require File.expand_path("helpers.rb", File.dirname(__FILE__))
+
+Dir.glob("#{File.dirname(__FILE__)}/**/*_test.rb") do |file|
+  load file
+end
+
+run_tests

data/test/session_test.rb

@@ -0,0 +1,177 @@
+require File.expand_path("helpers.rb", File.dirname(__FILE__))
+
+class InputTester
+  def initialize(actions)
+    @orig_actions = actions.dup
+    @actions = actions
+  end
+
+  def readline(*)
+    @actions.shift
+  end
+
+  def rewind
+    @actions = @orig_actions.dup
+  end
+end
+
+context "a PryDebug session" do
+  helper(:clean_up) { PryDebug.clean_up }
+
+  helper(:run_debugger) do |input|
+    input  = InputTester.new(input)
+    output = StringIO.new
+
+    pry = Pry.new(:input => input, :output => output,
+                  :commands => PryDebug::ShortCommands)
+    pry.repl(TOPLEVEL_BINDING)
+
+    output.string
+  end
+
+  setup { PryDebug }
+
+  asserts(:breakpoints).size 0
+  asserts(:line_breakpoints).size 0
+  asserts(:method_breakpoints).size 0
+
+  asserts(:file).nil
+
+  denies(:stepping)
+  asserts(:stepped_file).nil
+
+  denies(:break_on_raise)
+  denies(:debugging)
+
+  context "after adding two breakpoints" do
+    hookup do
+      @output          = run_debugger(["b foo.rb:15", "b Foo#bar"]).split("\n")
+      @breakpoint_list = run_debugger ["bl"]
+    end
+
+    asserts(:breakpoints).size 2
+    asserts(:line_breakpoints).size 1
+    asserts(:method_breakpoints).size 1
+
+    asserts(:breakpoints).same_elements {
+      topic.line_breakpoints + topic.method_breakpoints
+    }
+
+    asserts("output") { @output[0] }.matches "added breakpoint 0 at foo.rb:15"
+    asserts("output") { @output[1] }.matches "added breakpoint 1 at Foo#bar"
+
+    asserts("breakpoint list") { @breakpoint_list }.matches "breakpoint 0 at foo.rb:15"
+    asserts("breakpoint list") { @breakpoint_list }.matches "breakpoint 1 at Foo#bar"
+
+    context "line breakpoint" do
+      setup do
+        topic.line_breakpoints.first
+      end
+
+      asserts_topic.kind_of PryDebug::LineBreakpoint
+
+      asserts(:condition).nil
+      asserts(:file).equals "foo.rb"
+      asserts(:line).equals 15
+      asserts(:id).equals 0
+    end
+
+    context "method breakpoint" do
+      setup do
+        topic.method_breakpoints.first
+      end
+
+      asserts_topic.kind_of PryDebug::MethodBreakpoint
+
+      asserts(:condition).nil
+      asserts(:klass).equals "Foo"
+      asserts(:name).equals "bar"
+      asserts(:id).equals 1
+    end
+
+    context "method breakpoint after adding a condition" do
+      setup do
+        @output          = run_debugger [%{cond 1 @var == "foo"}]
+        @breakpoint_list = run_debugger ["bl"]
+
+        topic.method_breakpoints.first
+      end
+
+      asserts(:condition).equals %{@var == "foo"}
+      asserts("output") { @output }.matches /condition set to @var == "foo"/
+      asserts("breakpoint list") { @breakpoint_list }.matches <<desc.chomp
+breakpoint 1 at Foo#bar (if @var == "foo")
+desc
+
+      context "and disabling it" do
+        hookup do
+          @output = run_debugger [%{uncond 1}]
+          @breakpoint_list = run_debugger ["bl"]
+        end
+
+        asserts(:condition).nil
+
+        asserts("output") { @output }.matches /condition unset/
+        denies("breakpoint list") { @breakpoint_list }.matches /\(if .+\)/
+      end
+    end
+
+    context "and deleting one" do
+      hookup do
+        @output          = run_debugger ["del 0"]
+        @breakpoint_list = run_debugger ["bl"]
+      end
+
+      asserts(:breakpoints).size 1
+      asserts(:line_breakpoints).size 0
+      asserts(:method_breakpoints).size 1
+
+      asserts("output") { @output }.matches /breakpoint 0 deleted/
+      asserts("breakpoint list") { @breakpoint_list }.matches /breakpoint 1/
+      denies("breakpoint list") { @breakpoint_list }.matches /breakpoint 0/
+    end
+  end
+
+  context "after disabling condition on an unknown breakpoint" do
+    hookup do
+      @output = run_debugger ["uncond 0"]
+    end
+
+    asserts("output") { @output }.matches "error: could not find breakpoint 0"
+  end
+
+  context "after enableing condition on an unknown breakpoint" do
+    hookup do
+      @output = run_debugger ["cond 0 foo"]
+    end
+
+    asserts("output") { @output }.matches "error: could not find breakpoint 0"
+  end
+
+  context "after changing file" do
+    hookup do
+      @output = run_debugger ["f #{__FILE__}"]
+    end
+
+    asserts("output") { @output }.matches "debugged file set to #{__FILE__}"
+    asserts(:file).equals __FILE__
+  end
+
+  context "after enabling break-on-raise" do
+    hookup { @output = run_debugger ["bor"] }
+
+    asserts("output") { @output }.matches "break on raise enabled"
+    asserts(:break_on_raise)
+
+    context "and disabling it" do
+      hookup { @output = run_debugger ["bor"] }
+
+      asserts("output") { @output }.matches "break on raise disabled"
+      denies(:break_on_raise)
+    end
+  end
+
+  teardown { clean_up }
+end
+
+run_tests if $0 == __FILE__

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification 
+name: pry_debug
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- "Mon ou\xC3\xAFe"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-16 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: pry
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.9.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: riot
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: |
+  A pure-ruby debugger. No more puts "HERE!!!" or p :var => var, :other => other
+  until you find what caused the bug. Just add a breakpoint and see the value of
+  any variable.
+
+email: 
+- mon.ouie@gmail.com
+executables: 
+- pry_debug
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gemtest
+- .gitignore
+- README.md
+- Rakefile
+- bin/pry_debug
+- lib/pry_debug.rb
+- lib/pry_debug/commands.rb
+- lib/pry_debug/conditional_breakpoint.rb
+- lib/pry_debug/line_breakpoint.rb
+- lib/pry_debug/method_breakpoint.rb
+- pry_debug.gemspec
+- test/conditional_breakpoint_test.rb
+- test/helpers.rb
+- test/line_breakpoint_test.rb
+- test/method_breakpoint_test.rb
+- test/run_all.rb
+- test/session_test.rb
+homepage: http://github.com/Mon-Ouie/pry_debug
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.5
+signing_key: 
+specification_version: 3
+summary: A pure-ruby debugger
+test_files: 
+- test/conditional_breakpoint_test.rb
+- test/helpers.rb
+- test/line_breakpoint_test.rb
+- test/method_breakpoint_test.rb
+- test/run_all.rb
+- test/session_test.rb