pry-byebug 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c079446464cffea15a38fd173ef57ef076bf9002
+  data.tar.gz: 38c27e09ca3c57a6a1e322e49589a47e0316d301
+SHA512:
+  metadata.gz: 3750ce1963ae9660c470a81afbea8864e3cb79297278816468c2fadf779f968c7033f49da92aa7e67863c95215dd0c0952067ac4d1680df9bbd221e1de603cd9
+  data.tar.gz: 27c62f7240695a1596a0c508211529f577ac6f9c6dcd6b5e91ab66132525c3e5d6a2e710b954b6f12c7ac28288b59ec8dbf9a38f3a36780f2c7a68933837996c

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.gdb_history
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.ruby-gemset

@@ -0,0 +1 @@
+pry-byebug

data/CHANGELOG.md

@@ -0,0 +1,31 @@
+## 1.0.0 (2013-05-07)
+
+* Forked from [pry-debugger](https://github.com/nixme/pry-debugger) to support
+  byebug
+
+## 0.2.2 (2013-03-07)
+
+* Relaxed [byebug][byebug] dependency.
+
+
+## 0.2.1 (2012-12-26)
+
+* Support breakpoints on methods defined in the pry console. (@banister)
+* Fix support for specifying breakpoints by *file:line_number*. (@nviennot)
+* Validate breakpoint conditionals are real Ruby expressions.
+* Support for debugger ~> 1.2.0. (@jshou)
+* Safer `alias_method_chain`-style patching of `Pry.start` and
+  `PryRemote::Server#teardown`. (@benizi)
+
+
+## 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.
+  [pry-remote 0.1.4][pry-remote] support.

data/Gemfile

@@ -0,0 +1,3 @@
+source 'http://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+MIT/Expat License
+
+Copyright (c) 2012 by Gopal Patel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,149 @@
+pry-byebug
+============
+
+_Fast execution control in Pry_
+
+Adds **step**, **next**, **finish**, and **continue** commands and
+**breakpoints** to [Pry][pry] using [byebug][byebug].
+
+To use, invoke pry normally. No need to start your script or app differently.
+
+```ruby
+def some_method
+  binding.pry          # Execution will stop here.
+  puts 'Hello World'   # Run 'step' or 'next' in the console to move here.
+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-byebug** 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
+[byebug][byebug], check out [pry-nav][pry-nav]. Note: *pry-nav* and
+*pry-byebug* cannot be loaded together.
+
+
+## Remote debugging
+
+Support for [pry-remote][pry-remote] (>= 0.1.4) is also included. Requires
+explicity requiring *pry-byebug*, 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-remote'
+gem 'pry-stack_explorer'
+gem 'pry-byebug'
+```
+
+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'
+```
+
+
+## Contributors
+
+* Gopal Patel (@nixme)
+* John Mair (@banister)
+* Nicolas Viennot (@nviennot)
+* Benjamin R. Haskell (@benizi)
+* Joshua Hou (@jshou)
+* ...and others who helped with [pry-nav][pry-nav]
+
+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
+[byebug]:           https://github.com/deivid-rodriguez/byebug
+[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-byebug/pulls
+[issues]:             https://github.com/nixme/pry-byebug/issues
+[changelog]:          https://github.com/nixme/pry-byebug/blob/master/CHANGELOG.md

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/lib/pry-byebug.rb

@@ -0,0 +1,3 @@
+require 'pry-byebug/base'
+require 'pry-byebug/pry_ext'
+require 'pry-byebug/commands'

data/lib/pry-byebug/base.rb

@@ -0,0 +1,13 @@
+module PryByebug
+  extend self
+
+  # Checks that a binding is in a local file context. Extracted from
+  # https://github.com/pry/pry/blob/master/lib/pry/default_commands/context.rb
+  def check_file_context(target)
+    file = target.eval('__FILE__')
+    file == Pry.eval_path || (file !~ /(\(.*\))|<.*>/ && file != '' && file != '-e')
+  end
+
+  # Reference to currently running pry-remote server. Used by the processor.
+  attr_accessor :current_remote_server
+end

data/lib/pry-byebug/breakpoints.rb

@@ -0,0 +1,96 @@
+module PryByebug
+
+  # Wrapper for Byebug.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)
+      real_file = (file != Pry.eval_path)
+      raise ArgumentError, 'Invalid file!' if real_file && !File.exist?(file)
+      validate_expression expression
+
+      Pry.processor.debugging = true
+
+      path = (real_file ? File.expand_path(file) : file)
+      Byebug.add_breakpoint(path, line, expression)
+    end
+
+    # Change the conditional expression for a breakpoint.
+    def change(id, expression = nil)
+      validate_expression expression
+
+      breakpoint = find_by_id(id)
+      breakpoint.expr = expression
+      breakpoint
+    end
+
+    # Delete an existing breakpoint with the given ID.
+    def delete(id)
+      unless Byebug.started? && Byebug.remove_breakpoint(id)
+        raise ArgumentError, "No breakpoint ##{id}"
+      end
+      Pry.processor.debugging = false if to_a.empty?
+    end
+
+    # Delete all breakpoints.
+    def clear
+      Byebug.breakpoints.clear if Byebug.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
+      Byebug.started? ? Byebug.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
+
+    def validate_expression(expression)
+      if expression &&   # `nil` implies no expression given, so pass
+          (expression.empty? || !Pry::Code.complete_expression?(expression))
+        raise "Invalid breakpoint conditional: #{expression}"
+      end
+    end
+  end
+end

data/lib/pry-byebug/commands.rb

@@ -0,0 +1,245 @@
+require 'pry'
+require 'pry-byebug/breakpoints'
+
+module PryByebug
+  Commands = Pry::CommandSet.new do
+    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
+
+
+    create_command 'finish' do
+      description 'Execute until current stack frame returns.'
+
+      def process
+        check_file_context
+        breakout_navigation :finish
+      end
+    end
+
+
+    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 PryByebug.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 = 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,
+          :pry    => _pry_
+        }
+      end
+
+      # Ensures that a command is executed in a local file context.
+      def check_file_context
+        unless PryByebug.check_file_context(target)
+          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
+
+Pry.commands.import PryByebug::Commands

data/lib/pry-byebug/processor.rb

@@ -0,0 +1,149 @@
+require 'pry'
+require 'byebug'
+
+module PryByebug
+  class Processor
+    attr_accessor :pry
+
+    def initialize
+      Byebug.handler = self
+      @always_enabled = true
+      @delayed = Hash.new(0)
+    end
+
+    # 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 PryByebug::Commands
+        return_value = yield
+        {}    # Nothing thrown == no navigational command
+      end
+
+      times = (command[:times] || 1).to_i   # Command argument
+      times = 1 if times <= 0
+
+      if [:step, :next, :finish].include? command[:action]
+        @pry = command[:pry]   # Pry instance to resume after stepping
+        Byebug.start unless Byebug.started?
+
+        if initial
+          # Movement when on the initial binding.pry line will have a frame
+          # inside Byebug. 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.
+          finish
+          @delayed[command[:action]] = times
+        end
+
+        if :next == command[:action]
+          step_over times
+
+        elsif :step == command[:action]
+          step times
+
+        elsif :finish == command[:action]
+          finish
+        end
+      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, byebug is always
+    # enabled.
+    def debugging=(enabled)
+      if enabled
+        @always_enabled = true
+        Byebug.start unless Byebug.started?
+      else
+        @always_enabled = false
+        # Byebug will get stopped if necessary in `stop` once the repl ends.
+      end
+    end
+
+
+    # --- Callbacks from byebug C extension ---
+
+    def at_line(context, file, line)
+      # 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.)
+      p "Stop_reason: #{context.stop_reason}"
+      @delayed = Hash.new(0) unless :step == context.stop_reason
+
+      if @delayed[:next] > 0     # If any delayed nexts/steps, do 'em.
+        step_over @delayed[:next]
+        @delayed = Hash.new(0)
+
+      elsif @delayed[:step] > 0
+        step @delayed[:step]
+        @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)
+      @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)
+      # TODO
+    end
+
+
+   private
+
+    # Resume an existing Pry REPL at the paused point. Binding extracted from
+    # the Byebug::Context.
+    def resume_pry(context)
+      new_binding = context.frame_binding(0)
+      Byebug.stop unless @always_enabled
+
+      @pry.binding_stack.clear
+      run(false) do
+        @pry.repl new_binding
+      end
+    end
+
+    # Move execution forward.
+    def step(times)
+      Byebug.context.step_into times
+    end
+
+    # Move execution forward a number of lines in the same frame.
+    def step_over(lines)
+      Byebug.context.step_over lines, 0
+    end
+
+    # Execute until specified frame returns.
+    def finish(frame = 0)
+      Byebug.context.step_out frame
+    end
+
+    # Cleanup when debugging is stopped and execution continues.
+    def stop
+      Byebug.stop if !@always_enabled && Byebug.started?
+      if PryByebug.current_remote_server   # Cleanup DRb remote if running
+        PryByebug.current_remote_server.teardown
+      end
+    end
+  end
+end

data/lib/pry-byebug/pry_ext.rb

@@ -0,0 +1,23 @@
+require 'pry'
+require 'pry-byebug/processor'
+
+class << Pry
+  alias_method :start_without_pry_byebug, :start
+  attr_reader :processor
+
+  def start_with_pry_byebug(target = TOPLEVEL_BINDING, options = {})
+    @processor ||= PryByebug::Processor.new
+
+    if target.is_a?(Binding) && PryByebug.check_file_context(target)
+      # Wrap the processer around the usual Pry.start to catch navigation
+      # commands.
+      @processor.run(true) do
+        start_without_pry_byebug(target, options)
+      end
+    else
+      # No need for the tracer unless we have a file context to step through
+      start_without_pry_byebug(target, options)
+    end
+  end
+  alias_method :start, :start_with_pry_byebug
+end

data/lib/pry-byebug/pry_remote_ext.rb

@@ -0,0 +1,41 @@
+require 'pry-remote'
+
+module PryRemote
+  class Server
+    # Override the call to Pry.start to save off current Server, and not
+    # teardown the server right after Pry.start finishes.
+    def run
+      if PryByebug.current_remote_server
+        raise 'Already running a pry-remote session!'
+      else
+        PryByebug.current_remote_server = self
+      end
+
+      setup
+      Pry.start @object, {
+        :input  => client.input_proxy,
+        :output => client.output
+      }
+    end
+
+    # Override to reset our saved global current server session.
+    alias_method :teardown_without_pry_byebug, :teardown
+    def teardown_with_pry_byebug
+      return if @torn
+
+      teardown_without_pry_byebug
+      PryByebug.current_remote_server = nil
+      @torn = true
+    end
+    alias_method :teardown, :teardown_with_pry_byebug
+  end
+end
+
+# Ensure cleanup when a program finishes without another break. For example,
+# 'next' on the last line of a program won't hit PryByebug::Processor#run,
+# which normally handles cleanup.
+at_exit do
+  if PryByebug.current_remote_server
+    PryByebug.current_remote_server.teardown
+  end
+end

data/lib/pry-byebug/version.rb

@@ -0,0 +1,3 @@
+module PryByebug
+  VERSION = '1.0.0'
+end

data/pry-byebug.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+
+require File.expand_path('../lib/pry-byebug/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = 'pry-byebug'
+  gem.version       = PryByebug::VERSION
+  gem.author        = 'Gopal Patel'
+  gem.email         = 'nixme@stillhope.com'
+  gem.license       = 'MIT'
+  gem.homepage      = 'https://github.com/deivid-rodriguez/pry-byebug'
+  gem.summary       = 'Fast debugging with Pry.'
+  gem.description   = "Combine 'pry' with 'byebug'. Adds 'step', 'next', and " \
+                      "'continue' commands to control execution."
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.require_paths = ["lib"]
+
+  # Dependencies
+  gem.required_ruby_version = '>= 2.0.0'
+  gem.add_runtime_dependency 'pry', '>= 0.9.10'
+  gem.add_runtime_dependency 'byebug', '~> 1.1.1'
+  gem.add_development_dependency 'bundler', '~> 1.3.5'
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: pry-byebug
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Gopal Patel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.10
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.10
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.5
+description: Combine 'pry' with 'byebug'. Adds 'step', 'next', and 'continue' commands
+  to control execution.
+email: nixme@stillhope.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .ruby-gemset
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/pry-byebug.rb
+- lib/pry-byebug/base.rb
+- lib/pry-byebug/breakpoints.rb
+- lib/pry-byebug/commands.rb
+- lib/pry-byebug/processor.rb
+- lib/pry-byebug/pry_ext.rb
+- lib/pry-byebug/pry_remote_ext.rb
+- lib/pry-byebug/version.rb
+- pry-byebug.gemspec
+homepage: https://github.com/deivid-rodriguez/pry-byebug
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Fast debugging with Pry.
+test_files: []