pry-debugger 0.1.0 → 0.2.0

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## 0.2.0 (2012-06-11)
+
+# Breakpoints.
+* **finish** command.
+* Internal cleanup and bug fixes.
+
+
 ## 0.1.0 (2012-06-07)
 
 * First release. **step**, **next**, and **continue** commands.

data/README.md

@@ -3,10 +3,10 @@ pry-debugger
 
 _Fast execution control in Pry_
 
-Adds **step**, **next**, and **continue** commands to [Pry][pry] using
-[debugger][debugger].
+Adds **step**, **next**, **finish**, and **continue** commands and
+**breakpoints** to [Pry][pry] using [debugger][debugger].
 
-To use, invoke pry normally:
+To use, invoke pry normally. No need to start your script or app differently.
 
 ```ruby
 def some_method
@@ -15,40 +15,128 @@ def some_method
 end
 ```
 
+For a complete debugging environment, add
+[pry-stack_explorer][pry-stack_explorer] for call-stack frame navigation.
+
+
+## Execution Commands
+
+**step:** Step execution into the next line or method. Takes an optional numeric
+argument to step multiple times.
+
+**next:** Step over to the next line within the same frame. Also takes an
+optional numeric argument to step multiple lines.
+
+**finish:** Execute until current stack frame returns.
+
+**continue:** Continue program execution and end the Pry session.
+
+
+## Breakpoints
+
+You can set and adjust breakpoints directly from a Pry session using the
+following commands:
+
+**break:** Set a new breakpoint from a line number in the current file, a file
+and line number, or a method. Pass an optional expression to create a
+conditional breakpoint. Edit existing breakpoints via various flags.
+
+Examples:
+
+```
+break SomeClass#run            Break at the start of `SomeClass#run`.
+break Foo#bar if baz?          Break at `Foo#bar` only if `baz?`.
+break app/models/user.rb:15    Break at line 15 in user.rb.
+break 14                       Break at line 14 in the current file.
+
+break --condition 4 x > 2      Change condition on breakpoint #4 to 'x > 2'.
+break --condition 3            Remove the condition on breakpoint #3.
+
+break --delete 5               Delete breakpoint #5.
+break --disable-all            Disable all breakpoints.
+
+break                          List all breakpoints. (Same as `breakpoints`)
+break --show 2                 Show details about breakpoint #2.
+```
+
+Type `break --help` from a Pry session to see all available options.
+
+
+**breakpoints**: List all defined breakpoints. Pass `-v` or `--verbose` to see
+the source code around each breakpoint.
+
+
+## Caveats
+
 **pry-debugger** is not yet thread-safe, so only use in single-threaded
 environments.
 
-Only supports MRI 1.9.2 and 1.9.3. For a pure-ruby approach not reliant on
+Only supports MRI 1.9.2 and 1.9.3. For a pure ruby approach not reliant on
 [debugger][debugger], check out [pry-nav][pry-nav]. Note: *pry-nav* and
 *pry-debugger* cannot be loaded together.
 
+
+## Remote debugging
+
 Support for [pry-remote][pry-remote] (>= 0.1.4) is also included. Requires
-explicity requiring pry-nav, not just relying on pry's plugin loader. For
-example, in a Gemfile:
+explicity requiring *pry-debugger*, not just relying on pry's plugin loader.
+
+Want to debug a Rails app running inside [foreman][foreman]? Add to your
+Gemfile:
 
 ```ruby
 gem 'pry'
-gem 'pry-nav'
+gem 'pry-remote'
+gem 'pry-stack_explorer'
+gem 'pry-debugger'
+```
+
+Then add `binding.remote_pry` where you want to pause:
+
+```ruby
+class UsersController < ApplicationController
+  def index
+    binding.remote_pry
+    ...
+  end
+end
+```
+
+Load a page that triggers the code. Connect to the session:
+
+```
+$ bundle exec pry-remote
 ```
 
+Using Pry with Rails? Check out [Jazz Hands][jazz_hands].
+
+
+## Tips
+
 Stepping through code often? Add the following shortcuts to `~/.pryrc`:
 
 ```ruby
 Pry.commands.alias_command 'c', 'continue'
 Pry.commands.alias_command 's', 'step'
 Pry.commands.alias_command 'n', 'next'
+Pry.commands.alias_command 'f', 'finish'
 ```
 
+
 ## Contributions
 
 Patches and bug reports are welcome. Just send a [pull request][pullrequests] or
 file an [issue][issues]. [Project changelog][changelog].
 
 
-[pry]:            http://pry.github.com
-[debugger]:       https://github.com/cldwalker/debugger
-[pry-nav]:        https://github.com/nixme/pry-nav
-[pry-remote]:     https://github.com/Mon-Ouie/pry-remote
-[pullrequests]:   https://github.com/nixme/pry-debugger/pulls
-[issues]:         https://github.com/nixme/pry-debugger/issues
-[changelog]:      https://github.com/nixme/pry-debugger/blob/master/CHANGELOG.md
+
+[pry]:                http://pry.github.com
+[debugger]:           https://github.com/cldwalker/debugger
+[pry-stack_explorer]: https://github.com/pry/pry-stack_explorer
+[pry-nav]:            https://github.com/nixme/pry-nav
+[pry-remote]:         https://github.com/Mon-Ouie/pry-remote
+[foreman]:            https://github.com/ddollar/foreman
+[jazz_hands]:         https://github.com/nixme/jazz_hands
+[pullrequests]:       https://github.com/nixme/pry-debugger/pulls
+[issues]:             https://github.com/nixme/pry-debugger/issues
+[changelog]:          https://github.com/nixme/pry-debugger/blob/master/CHANGELOG.md

data/lib/pry-debugger/breakpoints.rb

@@ -0,0 +1,83 @@
+module PryDebugger
+
+  # Wrapper for Debugger.breakpoints that respects our Processor and has better
+  # failure behavior. Acts as an Enumerable.
+  #
+  module Breakpoints
+    extend Enumerable
+    extend self
+
+
+    # Add a new breakpoint.
+    def add(file, line, expression = nil)
+      raise ArgumentError, 'Invalid file!' unless File.exist?(file)
+      Pry.processor.debugging = true
+      Debugger.add_breakpoint(File.expand_path(file), line, expression)
+    end
+
+    # Change the conditional expression for a breakpoint.
+    def change(id, expression = nil)
+      breakpoint = find_by_id(id)
+      breakpoint.expr = expression
+      breakpoint
+    end
+
+    # Delete an existing breakpoint with the given ID.
+    def delete(id)
+      unless Debugger.started? && Debugger.remove_breakpoint(id)
+        raise ArgumentError, "No breakpoint ##{id}"
+      end
+      Pry.processor.debugging = false if to_a.empty?
+    end
+
+    # Delete all breakpoints.
+    def clear
+      Debugger.breakpoints.clear if Debugger.started?
+      Pry.processor.debugging = false
+    end
+
+    # Enable a disabled breakpoint with the given ID.
+    def enable(id)
+      change_status id, true
+    end
+
+    # Disable a breakpoint with the given ID.
+    def disable(id)
+      change_status id, false
+    end
+
+    # Disable all breakpoints.
+    def disable_all
+      each do |breakpoint|
+        breakpoint.enabled = false
+      end
+    end
+
+    def to_a
+      Debugger.started? ? Debugger.breakpoints : []
+    end
+
+    def size
+      to_a.size
+    end
+
+    def each(&block)
+      to_a.each(&block)
+    end
+
+    def find_by_id(id)
+      breakpoint = find { |b| b.id == id }
+      raise ArgumentError, "No breakpoint ##{id}!" unless breakpoint
+      breakpoint
+    end
+
+
+   private
+
+    def change_status(id, enabled = true)
+      breakpoint = find_by_id(id)
+      breakpoint.enabled = enabled
+      breakpoint
+    end
+  end
+end

data/lib/pry-debugger/commands.rb

@@ -1,28 +1,215 @@
 require 'pry'
+require 'pry-debugger/breakpoints'
 
 module PryDebugger
   Commands = Pry::CommandSet.new do
-    block_command 'step', 'Step execution into the next line or method.' do |steps|
-      check_file_context
-      breakout_navigation :step, steps
+    create_command 'step' do
+      description 'Step execution into the next line or method.'
+
+      banner <<-BANNER
+        Usage: step [TIMES]
+
+        Step execution forward. By default, moves a single step.
+
+        Examples:
+
+          step                           Move a single step forward.
+          step 5                         Execute the next 5 steps.
+      BANNER
+
+      def process
+        check_file_context
+        breakout_navigation :step, args.first
+      end
+    end
+
+
+    create_command 'next' do
+      description 'Execute the next line within the current stack frame.'
+
+      banner <<-BANNER
+        Usage: next [LINES]
+
+        Step over within the same frame. By default, moves forward a single
+        line.
+
+        Examples:
+
+          next                           Move a single line forward.
+          next 4                         Execute the next 4 lines.
+      BANNER
+
+      def process
+        check_file_context
+        breakout_navigation :next, args.first
+      end
     end
 
-    block_command 'next', 'Execute the next line within the same stack frame.' do |lines|
-      check_file_context
-      breakout_navigation :next, lines
+
+    create_command 'finish' do
+      description 'Execute until current stack frame returns.'
+
+      def process
+        check_file_context
+        breakout_navigation :finish
+      end
     end
 
-    block_command 'continue', 'Continue program execution and end the Pry session.' do
-      check_file_context
-      run 'exit-all'
+
+    create_command 'continue' do
+      description 'Continue program execution and end the Pry session.'
+
+      def process
+        check_file_context
+        run 'exit-all'
+      end
     end
 
+
+    create_command 'break' do
+      description 'Set or edit a breakpoint.'
+
+      banner <<-BANNER
+        Usage:   break <METHOD | FILE:LINE | LINE> [if CONDITION]
+                 break --condition N [CONDITION]
+                 break [--show | --delete | --enable | --disable] N
+                 break [--delete-all | --disable-all]
+        Aliases: breakpoint
+
+        Set a breakpoint. Accepts a line number in the current file, a file and
+        line number, or a method, and an optional condition.
+
+        Pass appropriate flags to manipulate existing breakpoints.
+
+        Examples:
+
+          break SomeClass#run            Break at the start of `SomeClass#run`.
+          break Foo#bar if baz?          Break at `Foo#bar` only if `baz?`.
+          break app/models/user.rb:15    Break at line 15 in user.rb.
+          break 14                       Break at line 14 in the current file.
+
+          break --condition 4 x > 2      Add/change condition on breakpoint #4.
+          break --condition 3            Remove the condition on breakpoint #3.
+
+          break --delete 5               Delete breakpoint #5.
+          break --disable-all            Disable all breakpoints.
+
+          break                          List all breakpoints. (Same as `breakpoints`)
+          break --show 2                 Show details about breakpoint #2.
+      BANNER
+
+      def options(opt)
+        opt.on :c, :condition,     'Change the condition of a breakpoint.', :argument => true, :as => Integer
+        opt.on :s, :show,          'Show breakpoint details and source.',   :argument => true, :as => Integer
+        opt.on :D, :delete,        'Delete a breakpoint.',                  :argument => true, :as => Integer
+        opt.on :d, :disable,       'Disable a breakpoint.',                 :argument => true, :as => Integer
+        opt.on :e, :enable,        'Enable a disabled breakpoint.',         :argument => true, :as => Integer
+        opt.on     :'disable-all', 'Disable all breakpoints.'
+        opt.on     :'delete-all',  'Delete all breakpoints.'
+        method_options(opt)
+      end
+
+      def process
+        Pry.processor.pry = _pry_
+
+        { :delete        => :delete,
+          :disable       => :disable,
+          :enable        => :enable,
+          :'disable-all' => :disable_all,
+          :'delete-all'  => :clear
+        }.each do |action, method|
+          if opts.present?(action)
+            Breakpoints.__send__ method, *(method == action ? [opts[action]] : [])
+            return run 'breakpoints'
+          end
+        end
+
+        if opts.present?(:condition)
+          Breakpoints.change(opts[:condition], args.empty? ? nil : args.join(' '))
+          run 'breakpoints'
+        elsif opts.present?(:show)
+          print_full_breakpoint Breakpoints.find_by_id(opts[:show])
+        elsif args.empty?
+          run 'breakpoints'
+        else
+          new_breakpoint
+        end
+      end
+
+      def new_breakpoint
+        place = args.shift
+        condition = args.join(' ') if 'if' == args.shift
+
+        file, line =
+          case place
+          when /(\d+)/       # Line number only
+            line = $1
+            unless PryDebugger.check_file_context(target)
+              raise ArgumentError, 'Line number declaration valid only in a file context.'
+            end
+            [target.eval('__FILE__'), line]
+          when /(.+):(\d+)/  # File and line number
+            [$1, $2]
+          else               # Method or class name
+            self.args = [place]
+            method_object.source_location
+          end
+
+        print_full_breakpoint Breakpoints.add(file, line.to_i, condition)
+      end
+    end
+    alias_command 'breakpoint', 'break'
+
+
+    create_command 'breakpoints' do
+      description 'List defined breakpoints.'
+
+      banner <<-BANNER
+        Usage:   breakpoints [OPTIONS]
+        Aliases: breaks
+
+        List registered breakpoints and their current status.
+      BANNER
+
+      def options(opt)
+        opt.on :v, :verbose, 'Print source around each breakpoint.'
+      end
+
+      def process
+        if Breakpoints.count > 0
+          if opts.verbose?   # Long-form with source output
+            Breakpoints.each { |b| print_full_breakpoint(b) }
+          else               # Simple table output
+            max_width = [Math.log10(Breakpoints.count).ceil, 1].max
+            header = "#{' ' * (max_width - 1)}#  Enabled  At "
+
+            output.puts
+            output.puts text.bold(header)
+            output.puts text.bold('-' * header.size)
+            Breakpoints.each do |breakpoint|
+              output.printf "%#{max_width}d  ", breakpoint.id
+              output.print  breakpoint.enabled? ? 'Yes      ' : 'No       '
+              output.print  "#{breakpoint.source}:#{breakpoint.pos}"
+              output.print  " (if #{breakpoint.expr})" if breakpoint.expr
+              output.puts
+            end
+            output.puts
+          end
+        else
+          output.puts text.bold('No breakpoints defined.')
+        end
+      end
+    end
+    alias_command 'breaks', 'breakpoints'
+
+
     helpers do
-      def breakout_navigation(action, times)
+      def breakout_navigation(action, times = nil)
         _pry_.binding_stack.clear     # Clear the binding stack.
         throw :breakout_nav, {        # Break out of the REPL loop and
           :action => action,          #   signal the tracer.
-          :times =>  times
+          :times  =>  times,
+          :pry    => _pry_
         }
       end
 
@@ -32,6 +219,25 @@ module PryDebugger
           raise Pry::CommandError, 'Cannot find local context. Did you use `binding.pry`?'
         end
       end
+
+      # Print out full information about a breakpoint including surrounding code
+      # at that point.
+      def print_full_breakpoint(breakpoint)
+        line = breakpoint.pos
+        output.print text.bold("Breakpoint #{breakpoint.id}: ")
+        output.print "#{breakpoint.source} @ line #{line} "
+        output.print breakpoint.enabled? ? '(Enabled)' : '(Disabled)'
+        output.puts  ' :'
+        if (expr = breakpoint.expr)
+          output.puts "#{text.bold('Condition:')} #{expr}"
+        end
+        output.puts
+        output.puts  Pry::Code.from_file(breakpoint.source).
+                       around(line, 3).
+                       with_line_numbers.
+                       with_marker(line).to_s
+        output.puts
+      end
     end
   end
 end

data/lib/pry-debugger/processor.rb

@@ -3,12 +3,16 @@ require 'debugger'
 
 module PryDebugger
   class Processor
-    def initialize(pry_start_options = {}, &block)
+    attr_accessor :pry
+
+    def initialize
       Debugger.handler = self
-      @pry_start_options = pry_start_options
+      @always_enabled = false
+      @delayed = Hash.new(0)
     end
 
-    def run(&block)
+    # Wrap a Pry REPL to catch navigational commands and act on them.
+    def run(initial = true, &block)
       return_value = nil
       command = catch(:breakout_nav) do  # Throws from PryDebugger::Commands
         return_value = yield
@@ -18,41 +22,86 @@ module PryDebugger
       times = (command[:times] || 1).to_i   # Command argument
       times = 1 if times <= 0
 
-      remote = @pry_start_options[:pry_remote] && PryDebugger.current_remote_server
-
-      if [:step, :next].include? command[:action]
-        Debugger.start
-        if Debugger.current_context.frame_self.is_a? Debugger::Context
-          # The first binding.pry call will have a frame inside Debugger. If we
-          # step normally, it'll stop inside this Processor instead. So jump it
-          # out to the above frame.
-          #
-          # TODO: times isn't respected
-          Debugger.current_context.stop_frame = 1 # (remote ? 2 : 1)
-        else
-          if :next == command[:action]
-            Debugger.current_context.step_over(times, 0)
-          else  # step
-            Debugger.current_context.step(times)
-          end
+      if [:step, :next, :finish].include? command[:action]
+        @pry = command[:pry]   # Pry instance to resume after stepping
+        Debugger.start unless Debugger.started?
+
+        if initial
+          # Movement when on the initial binding.pry line will have a frame
+          # inside Debugger. If we step normally, it'll stop inside this
+          # Processor. So jump out and stop at the above frame, then step/next
+          # from our callback.
+          Debugger.current_context.stop_frame = 1
+          @delayed[command[:action]] = times
+
+        elsif :next == command[:action]
+          step_over times
+
+        elsif :step == command[:action]
+          step times
+
+        elsif :finish == command[:action]
+          finish
         end
-      elsif remote  # Continuing execution... cleanup DRb remote if running
-        PryDebugger.current_remote_server.teardown
+      else
+        stop
       end
 
       return_value
     end
 
+    # Adjust debugging. When set to false, the Processor will manage enabling
+    # and disabling the debugger itself. When set to true, the debugger is
+    # always enabled.
+    def debugging=(enabled)
+      if enabled
+        @always_enabled = true
+        Debugger.start unless Debugger.started?
+      else
+        @always_enabled = false
+        # Debugger will get stopped if necessary in `stop` once the repl ends.
+      end
+    end
+
 
     # --- Callbacks from debugger C extension ---
 
     def at_line(context, file, line)
       return if file && TRACE_IGNORE_FILES.include?(File.expand_path(file))
-      start_pry context
+
+      # If stopped for a breakpoint or catchpoint, can't play any delayed steps
+      # as they'll move away from the interruption point. (Unsure if scenario is
+      # possible, but just keeping assertions in check.)
+      @delayed = Hash.new(0) unless :step == context.stop_reason
+
+      if @delayed[:next] > 1     # If any delayed nexts/steps, do 'em.
+        step_over @delayed[:next] - 1
+        @delayed = Hash.new(0)
+
+      elsif @delayed[:step] > 1
+        step @delayed[:step] - 1
+        @delayed = Hash.new(0)
+
+      elsif @delayed[:finish] > 0
+        finish
+        @delayed = Hash.new(0)
+
+      else  # Otherwise, resume the pry session at the stopped line.
+        resume_pry context
+      end
     end
 
+    # Called when a breakpoint is triggered. Note: `at_line`` is called
+    # immediately after with the context's `stop_reason == :breakpoint`.
     def at_breakpoint(context, breakpoint)
-      # TODO
+      @pry.output.print Pry::Helpers::Text.bold("\nBreakpoint #{breakpoint.id}. ")
+      @pry.output.puts  (breakpoint.hit_count == 1 ?
+                           'First hit.' :
+                           "Hit #{breakpoint.hit_count} times." )
+      if (expr = breakpoint.expr)
+        @pry.output.print Pry::Helpers::Text.bold("Condition: ")
+        @pry.output.puts  expr
+      end
     end
 
     def at_catchpoint(context, exception)
@@ -62,8 +111,39 @@ module PryDebugger
 
    private
 
-    def start_pry(context)
-      Pry.start(context.frame_binding(0), @pry_start_options)
+    # Resume an existing Pry REPL at the paused point. Binding extracted from
+    # the Debugger::Context.
+    def resume_pry(context)
+      new_binding = context.frame_binding(0)
+      Debugger.stop unless @always_enabled
+
+      @pry.binding_stack.clear
+      run(false) do
+        @pry.repl new_binding
+      end
+    end
+
+    # Move execution forward.
+    def step(times)
+      Debugger.current_context.step(times)
+    end
+
+    # Move execution forward a number of lines in the same frame.
+    def step_over(lines)
+      Debugger.current_context.step_over(lines, 0)
+    end
+
+    # Execute until current frame returns.
+    def finish
+      Debugger.current_context.stop_frame = 0
+    end
+
+    # Cleanup when debugging is stopped and execution continues.
+    def stop
+      Debugger.stop if !@always_enabled && Debugger.started?
+      if PryDebugger.current_remote_server   # Cleanup DRb remote if running
+        PryDebugger.current_remote_server.teardown
+      end
     end
   end
 end

data/lib/pry-debugger/pry_ext.rb

@@ -3,19 +3,20 @@ require 'pry-debugger/processor'
 
 class << Pry
   alias_method :start_existing, :start
+  attr_reader :processor
 
   def start(target = TOPLEVEL_BINDING, options = {})
-    old_options = options.reject { |k, _| k == :pry_remote }
+    @processor ||= PryDebugger::Processor.new
 
     if target.is_a?(Binding) && PryDebugger.check_file_context(target)
       # Wrap the processer around the usual Pry.start to catch navigation
       # commands.
-      PryDebugger::Processor.new(options).run do
-        start_existing(target, old_options)
+      @processor.run(true) do
+        start_existing(target, options)
       end
     else
       # No need for the tracer unless we have a file context to step through
-      start_existing(target, old_options)
+      start_existing(target, options)
     end
   end
 end

data/lib/pry-debugger/pry_remote_ext.rb

@@ -2,9 +2,8 @@ require 'pry-remote'
 
 module PryRemote
   class Server
-    # Override the call to Pry.start to save off current Server, pass a
-    # pry_remote flag so pry-debugger knows this is a remote session, and not
-    # kill the server right away.
+    # Override the call to Pry.start to save off current Server, and not
+    # teardown the server right after Pry.start finishes.
     def run
       if PryDebugger.current_remote_server
         raise 'Already running a pry-remote session!'
@@ -15,8 +14,7 @@ module PryRemote
       setup
       Pry.start @object, {
         :input  => client.input_proxy,
-        :output => client.output,
-        :pry_remote => true
+        :output => client.output
       }
     end
 

data/lib/pry-debugger/version.rb

@@ -1,3 +1,3 @@
 module PryDebugger
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pry-debugger
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-07 00:00:00.000000000 Z
+date: 2012-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &70204822544220 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,15 +21,10 @@ dependencies:
         version: 0.9.9
   type: :runtime
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 0.9.9
+  version_requirements: *70204822544220
 - !ruby/object:Gem::Dependency
   name: debugger
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &70204822543060 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -37,15 +32,10 @@ dependencies:
         version: 1.1.3
   type: :runtime
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 1.1.3
+  version_requirements: *70204822543060
 - !ruby/object:Gem::Dependency
   name: pry-remote
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &70204822541940 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -53,12 +43,7 @@ dependencies:
         version: 0.1.4
   type: :development
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 0.1.4
+  version_requirements: *70204822541940
 description: Combine 'pry' with 'debugger'. Adds 'step', 'next', and 'continue' commands
   to control execution.
 email: nixme@stillhope.com
@@ -74,6 +59,7 @@ files:
 - Rakefile
 - lib/pry-debugger.rb
 - lib/pry-debugger/base.rb
+- lib/pry-debugger/breakpoints.rb
 - lib/pry-debugger/cli.rb
 - lib/pry-debugger/commands.rb
 - lib/pry-debugger/processor.rb
@@ -102,7 +88,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
 summary: Fast debugging with Pry.