pry-exception_explorer 0.1.1pre5 → 0.1.1pre7

data/Rakefile

@@ -43,9 +43,14 @@ task :reinstall => :gems do
   sh "gem install #{direc}/pkg/pry-exception_explorer-#{PryExceptionExplorer::VERSION}.gem"
 end
 
-desc "Run example"
-task :example do
-  sh "ruby -I#{direc}/lib/ #{direc}/examples/example.rb "
+desc "Run example wrap"
+task :example_wrap do
+  sh "ruby -I#{direc}/lib/ #{direc}/examples/example_wrap.rb "
+end
+
+desc "Run example inline"
+task :example_inline do
+  sh "ruby -I#{direc}/lib/ #{direc}/examples/example_inline.rb "
 end
 
 task :default => :test

data/examples/example_inline.rb

@@ -0,0 +1,27 @@
+unless Object.const_defined? :PryExceptionExplorer
+  $:.unshift File.expand_path '../../lib', __FILE__
+  require 'pry'
+end
+
+require 'pry-exception_explorer'
+
+PryExceptionExplorer.enabled = true
+PryExceptionExplorer.intercept(RuntimeError)
+
+def alpha
+  name = "john"
+  beta
+  puts name
+end
+
+def beta
+  x = 20
+  gamma
+  puts x
+end
+
+def gamma
+  raise "oh my, an exception"
+end
+
+alpha

data/examples/{example.rb → example_wrap.rb}

@@ -4,7 +4,6 @@ unless Object.const_defined? :PryExceptionExplorer
 end
 
 require 'pry-exception_explorer'
-require 'pry-exception_explorer/exception_wrap'
 
 def alpha
   name = "john"

data/lib/pry-exception_explorer/cli.rb

@@ -1,8 +1,6 @@
 Pry::CLI.add_options do
 
   on :w, :wrap, "Run the script wrapped by the exception explorer", true do |file|
-    require 'pry-exception_explorer/exception_wrap'
-
     PryExceptionExplorer.wrap do
       require file
     end

data/lib/pry-exception_explorer/commands.rb

@@ -1,72 +1,99 @@
 require 'pry-stack_explorer'
 
-PryExceptionExplorer::Commands = Pry::CommandSet.new do
-
-  command "enter-exception", "Enter the context of the last exception" do
-    ex = _pry_.last_exception
-    if ex && ex.exception_call_stack
-      _pry_.backtrace = ex.backtrace
-      PryStackExplorer.create_and_push_frame_manager(ex.exception_call_stack, _pry_)
-      PryStackExplorer.frame_manager(_pry_).user[:exception] = ex
-      PryStackExplorer.frame_manager(_pry_).refresh_frame
-    elsif ex
-      output.puts "Current exception can't be entered! (perhaps a C exception)"
-    else
-      output.puts "No exception to enter!"
+module PryExceptionExplorer
+  module ExceptionHelpers
+    include PryStackExplorer::FrameHelpers
+
+    private
+    def in_exception?
+      frame_manager && frame_manager.user[:exception]
+    end
+
+    def last_exception
+      _pry_.last_exception
+    end
+
+    def enterable_exception?
+      last_exception && last_exception.exception_call_stack
     end
   end
 
-  command_class "exit-exception", "Leave the context of the current exception." do
-    banner <<-BANNER
-      Usage: exit-exception
-      Exit active exception and return to containing context.
-    BANNER
-
-    def process
-      if !in_exception?
-        raise Pry::CommandError, "You are not in an exception!"
-      elsif !prior_context_exists?
-        run "exit-all"
-      else
-        popped_fm = PryStackExplorer.pop_frame_manager(_pry_)
-        if frame_manager
-          frame_manager.refresh_frame
+  Commands = Pry::CommandSet.new do
+    create_command "enter-exception", "Enter the context of the last exception" do
+      include PryExceptionExplorer::ExceptionHelpers
+
+      banner <<-BANNER
+        Usage: enter-exception
+        Enter the context of the last exception
+      BANNER
+
+      def process
+        if enterable_exception?
+          PryStackExplorer.create_and_push_frame_manager(last_exception.exception_call_stack, _pry_)
+          PryExceptionExplorer.setup_exception_context(last_exception, _pry_)
+
+          # have to use _pry_.run_command instead of 'run' here as
+          # 'run' works on the current target which hasnt been updated
+          # yet, whereas _pry_.run_command operates on the newly
+          # updated target (the context of the exception)
+          _pry_.run_command "whereami"
+        elsif last_exception
+          raise Pry::CommandError, "Current exception can't be entered! (perhaps a C exception)"
         else
-          _pry_.binding_stack[-1] = popped_fm.prior_binding
+          raise Pry::CommandError,  "No exception to enter!"
         end
       end
     end
 
-    private
-    def frame_manager
-      PryStackExplorer.frame_manager(_pry_)
-    end
+    create_command "exit-exception", "Leave the context of the current exception." do
+      include ExceptionHelpers
 
-    def frame_managers
-      PryStackExplorer.frame_managers(_pry_)
-    end
+      banner <<-BANNER
+        Usage: exit-exception
+        Exit active exception and return to containing context.
+      BANNER
 
-    def prior_context_exists?
-      frame_managers.count > 1 || frame_manager.prior_binding
+      def process
+        if !in_exception?
+          raise Pry::CommandError, "You are not in an exception!"
+        elsif !prior_context_exists?
+          run "exit-all"
+        else
+          popped_fm = PryStackExplorer.pop_frame_manager(_pry_)
+          _pry_.last_exception = popped_fm.user[:exception]
+        end
+      end
     end
 
-    def in_exception?
-      frame_manager && frame_manager.user[:exception]
-    end
-  end
+    create_command "continue-exception", "Attempt to continue the current exception." do
+      include ExceptionHelpers
+
+      banner <<-BANNER
+        Usage: continue-exception
+        Attempt to continue the current exception.
+      BANNER
 
-  command "continue-exception", "Attempt to continue the current exception." do
-    fm = PryStackExplorer.frame_manager(_pry_)
-
-    if fm && fm.user[:exception] && fm.user[:inline_exception]
-      PryStackExplorer.pop_frame_manager(_pry_)
-      _pry_.run_command "exit-all PryExceptionExplorer::CONTINUE_INLINE_EXCEPTION"
-    elsif fm && fm.user[:exception] && fm.user[:exception].continuation
-      PryStackExplorer.pop_frame_manager(_pry_)
-      fm.user[:exception].continue
-    else
-      output.puts "No exception to continue!"
+      def process
+        if inline_exception?
+          PryStackExplorer.pop_frame_manager(_pry_)
+          run "exit-all PryExceptionExplorer::CONTINUE_INLINE_EXCEPTION"
+        elsif normal_exception?
+          popped_fm = PryStackExplorer.pop_frame_manager(_pry_)
+          popped_fm.user[:exception].continue
+        else
+          raise Pry::CommandError, "No exception to continue!"
+        end
+      end
+
+      private
+      def inline_exception?
+        frame_manager && frame_manager.user[:exception] && frame_manager.user[:inline_exception]
+      end
+
+      def normal_exception?
+        frame_manager && frame_manager.user[:exception] && frame_manager.user[:exception].continuation
+      end
     end
-  end
 
+  end
 end

data/lib/pry-exception_explorer/core_ext.rb

@@ -0,0 +1,54 @@
+# `PryExceptionExplorer` monkey-patches to `Exception`
+class Exception
+  NoContinuation = Class.new(StandardError)
+
+  attr_accessor :continuation
+  attr_accessor :exception_call_stack
+  attr_accessor :should_intercept
+
+  # This method enables us to continue an exception (using
+  # `callcc` internally)
+  def continue
+    raise NoContinuation unless continuation.respond_to?(:call)
+    continuation.call
+  end
+
+  alias_method :should_intercept?, :should_intercept
+end
+
+# `PryExceptionExplorer` monkey-patches to `Object`
+class Object
+
+  # We monkey-patch the `raise` method so we can intercept exceptions
+  def raise(exception = RuntimeError, string = nil, array = caller)
+
+    if exception.is_a?(String)
+      string = exception
+      exception = RuntimeError
+    end
+
+    ex = exception.exception(string)
+    ex.set_backtrace(array)
+
+    # revert to normal exception behaviour if EE not enabled.
+    if !PryExceptionExplorer.enabled?
+      return super(ex)
+    end
+
+    if PryExceptionExplorer.should_intercept_exception?(binding.of_caller(1), ex)
+      ex.exception_call_stack = binding.callers.tap { |v| v.shift(1 + PryExceptionExplorer.intercept_object.skip) }
+      ex.should_intercept     = true
+
+      if !PryExceptionExplorer.wrap_active?
+        retval = PryExceptionExplorer.enter_exception(ex, :inline => true)
+      end
+    end
+
+    if retval != PryExceptionExplorer::CONTINUE_INLINE_EXCEPTION
+      callcc do |cc|
+        ex.continuation = cc
+        super(ex)
+      end
+    end
+  end
+end

data/lib/pry-exception_explorer/intercept.rb

@@ -0,0 +1,43 @@
+module PryExceptionExplorer
+  class Intercept
+
+    # @return [Fixnum] Number of frames to skip when session starts.
+    attr_accessor :skip
+
+    # @return [Boolean] Whether to intercept exceptions raised inside the session.
+    attr_accessor :intercept_recurse
+    alias_method :intercept_recurse?, :intercept_recurse
+
+    # @return [Boolean] Whether this intercept object is active
+    #   If it's inactive then calling it will always return `false`
+    #   regardless of content inside block.
+    def active?() @active end
+
+    # Disable the intercept object.
+    def disable!() @active = false end
+
+    # Enable if the intercept object.
+    def enable!() @active = true end
+    
+    # @return [Proc] The predicate block that determines if
+    #   interception takes place.
+    attr_reader :block
+
+    def initialize(block, options={})
+      options = {
+        :skip              => 0,
+        :intercept_recurse => false
+      }.merge!(options)
+
+      @block = block
+      @skip  = options[:skip]
+      @intercept_recurse = options[:intercept_recurse]
+
+      @active = true
+    end
+
+    def call(*args)
+      active? && @block.call(*args)
+    end
+  end
+end

data/lib/pry-exception_explorer/lazy_frame.rb

@@ -2,29 +2,34 @@ module PryExceptionExplorer
   class LazyFrame
 
     # we need to jump over a few irrelevant frames to begin with
-    START_FRAME_OFFSET = 5
-    
+    START_FRAME_OFFSET = 6
+
     def initialize(frame, frame_counter = 0)
       @frame         = frame
       @frame_counter = frame_counter
     end
 
+    # @return [Binding] The `Binding` object that represents the frame.
     def raw_frame
       @frame
     end
 
+    # @return [Class] The class of the `self` of the frame.
     def klass
       @frame.eval("self.class")
     end
 
+    # @return [Object] The object context of the frame (the `self`).
     def self
       @frame.eval("self")
     end
 
+    # @return [Symbol, nil] The name of the active method in the frame (or `nil`)
     def method_name
       @frame.eval("__method__")
     end
 
+    # @return [LazyFrame] The caller frame.
     def prev
       LazyFrame.new(binding.of_caller(@frame_counter + START_FRAME_OFFSET), @frame_counter + 1)
     end

data/lib/pry-exception_explorer/version.rb

@@ -1,3 +1,3 @@
 module PryExceptionExplorer
-  VERSION = "0.1.1pre5"
+  VERSION = "0.1.1pre7"
 end

data/lib/pry-exception_explorer.rb

@@ -1,138 +1,194 @@
 # pry-exception_explorer.rb
-# (C) John Mair (banisterfiend); MIT license
+# (C) 2012 John Mair (banisterfiend); MIT license
 
 require 'pry-stack_explorer'
 require "pry-exception_explorer/version"
 require "pry-exception_explorer/lazy_frame"
 require "pry-exception_explorer/commands"
-require "pry"
+require "pry-exception_explorer/core_ext"
+require "pry-exception_explorer/intercept"
 
 if RUBY_VERSION =~ /1.9/
   require 'continuation'
 end
 
 module PryExceptionExplorer
+
+  # short-hand for `PryExceptionExplorer`
+  ::EE = self
+
+  # special constant
   CONTINUE_INLINE_EXCEPTION = Object.new
 
   class << self
 
-    # @return [Boolean] Whether `PryStackExplorer` is enabled.
-    attr_accessor :enabled
+    # @return [Hash] A thread-local hash.
+    def local_hash
+      Thread.current[:__pry_exception_explorer_hash__] ||= {}
+    end
+
+    # @param [Boolean] v Whether Exception Explorer is enabled.
+    def enabled=(v)
+      local_hash[:enabled] = v
+    end
 
+    # @return [Boolean] Whether Exception Explorer is enabled.
+    def enabled
+      !!local_hash[:enabled]
+    end
+
+    # @param [Boolean] v Whether to intercept only those exceptions that bubble out of
+    #   `EE.wrap` block.
     def wrap_active=(v)
-      Thread.current[:__pry_exception_explorer_wrap__] = v
+      local_hash[:wrap_active] = v
     end
 
+    # @return [Boolean] Whether to intercept only those exceptions that bubble out of
+    #   `EE.wrap` block.
     def wrap_active
-      !!Thread.current[:__pry_exception_explorer_wrap__]
+      !!local_hash[:wrap_active]
     end
 
     alias_method :wrap_active?, :wrap_active
     alias_method :enabled?, :enabled
-  end
 
-  self.wrap_active = false
 
-  def self.should_capture_exception?(ex)
-    true
-  end
-
-  def self.intercept(*exceptions, &block)
-    if !exceptions.empty?
-      block = proc { |_, ex| exceptions.any? { |v| v === ex } }
+    # Wrap the provided block - intercepting all exceptions
+    # that bubble out, provided they satisfy the
+    # assertion in `PryExceptionExplorer.intercept`.
+    # @yield The block to wrap.
+    def wrap
+      old_enabled, old_wrap_active = enabled, wrap_active
+      self.enabled     = true
+      self.wrap_active = true
+      yield
+    rescue Exception => ex
+      if ex.should_intercept?
+        enter_exception(ex)
+      else
+        raise ex
+      end
+    ensure
+      self.enabled     = old_enabled
+      self.wrap_active = old_wrap_active
     end
 
-    Thread.current[:__pry_exception_explorer_intercept_block__] = block
-  end
-
-  def self.intercept_block
-    Thread.current[:__pry_exception_explorer_intercept_block__]
-  end
+    # This method allows the user to assert the situations where an
+    # exception interception occurs.
+    # This method can be invoked in two ways. The general form takes a
+    # block, the block is passed both the frame where the exception was
+    # raised, and the exception itself. The user then creates an
+    # assertion (a stack-assertion)
+    # based on these attributes. If the assertion is later satisfied by
+    # a raised exception, that exception will be intercepted.
+    # In the second form, the method simply takes an exception class, or
+    # a number of exception classes. If one of these exceptions is
+    # raised, it will be intercepted.
+    # @param [Array] exceptions The exception classes that will be intercepted.
+    # @yield [lazy_frame, exception] The block that determines whether an exception will be intercepted.
+    # @yieldparam [PryExceptionExplorer::Lazyframe] frame The frame
+    #   where the exception was raised.
+    # @yieldparam [Exception] exception The exception that was raised.
+    # @yieldreturn [Boolean] The result of the stack assertion.
+    # @example First form: Assert method name is `toad` and exception is an `ArgumentError`
+    #   PryExceptionExplorer.intercept do |frame, ex|
+    #     frame.method_name == :toad && ex.is_a?(ArgumentError)
+    #   end
+    # @example Second form: Assert exception is either `ArgumentError` or `RuntimeError`
+    #   PryExceptionExplorer.intercept(ArgumentError, RuntimeError)
+    def intercept(*exceptions, &block)
+      return if exceptions.empty? && block.nil?
+
+      options = (exceptions.pop if exceptions.last.is_a?(Hash)) || {}
+
+      if !exceptions.empty?
+        block = proc { |_, ex| exceptions.any? { |v| v === ex } }
+      end
 
-  def self.should_capture_exception?(ex, frame)
-    if intercept_block
-      intercept_block.call(LazyFrame.new(frame), ex)
-    else
-      false
+      local_hash[:intercept_object] = Intercept.new(block, options)
     end
-  end
-
-  def self.enter_exception_inline(ex)
-    _pry_ = Pry.new
-
-    Pry.initial_session_setup
-    PryStackExplorer.create_and_push_frame_manager(ex.exception_call_stack, _pry_)
-    PryStackExplorer.frame_manager(_pry_).user[:exception]        = ex
-    PryStackExplorer.frame_manager(_pry_).user[:inline_exception] = true
-    _pry_.repl(ex.exception_call_stack.first)
-
-  ensure
-    PryStackExplorer.clear_frame_managers(_pry_)
-  end
-end
 
-class Exception
-  NoContinuation = Class.new(StandardError)
-
-  attr_accessor :continuation
-  attr_accessor :exception_call_stack
-  attr_accessor :should_capture
-
-  def continue
-    raise NoContinuation unless continuation.respond_to?(:call)
-    continuation.call
-  end
+    # @return [PryExceptionExplorer::Intercept] The object defined earlier by a call to `PryExceptionExplorer.intercept`.
+    def intercept_object=(b)
+      local_hash[:intercept_object] = b
+    end
 
-  alias_method :should_capture?, :should_capture
-end
+    # @return [PryExceptionExplorer::Intercept] The object defined earlier by a call to `PryExceptionExplorer.intercept`.
+    def intercept_object
+      local_hash[:intercept_object]
+    end
 
-class Object
-  def raise(exception = RuntimeError, string = nil, array = caller)
+    # This method invokes the `PryExceptionExplorer.intercept_object`,
+    # passing in the exception's frame and the exception object itself.
+    # @param [Binding] frame The stack frame where the exception occurred.
+    # @param [Exception] ex The exception that was raised.
+    # @return [Boolean] Whether the exception should be intercepted.
+    def should_intercept_exception?(frame, ex)
+      if intercept_object
+        intercept_object.call(LazyFrame.new(frame), ex)
+      else
+        false
+      end
+    end
 
-    if exception.is_a?(String)
-      string = exception
-      exception = RuntimeError
+    # Prepare the `Pry` instance and associated call-stack when entering
+    # into an exception context.
+    # @param [Exception] ex The exception.
+    # @param [Pry] _pry_ The relevant `Pry` instance.
+    # @param [Hash] options The optional configuration parameters.
+    # @option options [Boolean] :inline Whether the exception is being
+    #   entered inline (i.e within the `raise` method itself)
+    def setup_exception_context(ex, _pry_, options={})
+      _pry_.last_exception = ex
+      _pry_.backtrace = ex.backtrace
+
+      PryStackExplorer.frame_manager(_pry_).user[:exception]        = ex
+      PryStackExplorer.frame_manager(_pry_).user[:inline_exception] = !!options[:inline]
     end
 
-    ex = exception.exception(string)
-    ex.set_backtrace(array)
+    # Enter the exception context.
+    # @param [Exception] ex The exception.
+    # @param [Hash] options The optional configuration parameters.
+    # @option options [Boolean] :inline Whether the exception is being
+    #   entered inline (i.e within the `raise` method itself)
+    def enter_exception(ex, options={})
+      hooks = Pry.config.hooks.dup.add_hook(:before_session, :set_exception_flag) do |_, _, _pry_|
+        setup_exception_context(ex, _pry_, options)
+      end.add_hook(:before_session, :manage_intercept_recurse) do 
+        PryExceptionExplorer.intercept_object.disable! if !PryExceptionExplorer.intercept_object.intercept_recurse?
+      end.add_hook(:after_session, :manage_intercept_recurse) do
+        PryExceptionExplorer.intercept_object.enable! if !PryExceptionExplorer.intercept_object.active?
+      end
 
-    # revert to normal exception behaviour if EE not enabled.
-    if !PryExceptionExplorer.enabled?
-      return super(ex)
+      Pry.start self, :call_stack => ex.exception_call_stack, :hooks => hooks
     end
 
-    if PryExceptionExplorer.should_capture_exception?(ex, binding.of_caller(1))
-      ex.exception_call_stack = binding.callers.tap(&:shift)
-      ex.should_capture       = true
+    # Set initial state
+    def init
+      # disable by default (intercept exceptions inline)
+      PryExceptionExplorer.wrap_active = false
 
-      if !PryExceptionExplorer.wrap_active?
-        retval = PryExceptionExplorer.enter_exception_inline(ex)
-      end
-    end
+      # default is to capture all exceptions
+      PryExceptionExplorer.intercept { true }
 
-    if retval != PryExceptionExplorer::CONTINUE_INLINE_EXCEPTION
-      callcc do |cc|
-        ex.continuation = cc
-        super(ex)
-      end
+      # disable by default
+      PryExceptionExplorer.enabled = false
     end
   end
 end
 
+# Add a hook to enable EE when invoked via `pry` executable
+Pry.config.hooks.add_hook(:when_started, :try_enable_exception_explorer) do
+  if Pry.cli
+    PryExceptionExplorer.wrap_active = true
+    PryExceptionExplorer.enabled     = true
+  end
+end
 
-# Let exceptions get caught by Pry REPL loop (i.e dont catch
-# immediately at point of 'raise')
-PryExceptionExplorer.wrap_active = true
-
-# default is to capture all exceptions that bubble to the top
-PryExceptionExplorer.intercept { true }
-
+# Bring in commands
 Pry.config.commands.import PryExceptionExplorer::Commands
 
-# disable by default
-PryExceptionExplorer.enabled = false
+# Set initial state
+PryExceptionExplorer.init
+
 
-Pry.config.hooks.add_hook(:when_started, :try_enable_exception_explorer) do
-  PryExceptionExplorer.enabled = true if Pry.cli
-end

data/pry-exception_explorer.gemspec

@@ -2,14 +2,14 @@
 
 Gem::Specification.new do |s|
   s.name = "pry-exception_explorer"
-  s.version = "0.1.1pre5"
+  s.version = "0.1.1pre6"
 
   s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
   s.authors = ["John Mair (banisterfiend)"]
-  s.date = "2012-01-12"
+  s.date = "2012-01-28"
   s.description = "Enter the context of exceptions"
   s.email = "jrmair@gmail.com"
-  s.files = [".gemtest", ".gitignore", ".travis.yml", ".yardopts", "CHANGELOG", "Gemfile", "LICENSE", "README.md", "Rakefile", "examples/example.rb", "lib/pry-exception_explorer.rb", "lib/pry-exception_explorer/cli.rb", "lib/pry-exception_explorer/commands.rb", "lib/pry-exception_explorer/exception_wrap.rb", "lib/pry-exception_explorer/lazy_frame.rb", "lib/pry-exception_explorer/shim_builder.rb", "lib/pry-exception_explorer/version.rb", "pry-exception_explorer.gemspec", "test/helper.rb", "test/test_exceptions_in_pry.rb", "test/test_inline_exceptions.rb", "test/test_wrapped_exceptions.rb"]
+  s.files = [".gemtest", ".gitignore", ".travis.yml", ".yardopts", "CHANGELOG", "Gemfile", "LICENSE", "README.md", "Rakefile", "examples/example_inline.rb", "examples/example_wrap.rb", "lib/pry-exception_explorer.rb", "lib/pry-exception_explorer/cli.rb", "lib/pry-exception_explorer/commands.rb", "lib/pry-exception_explorer/core_ext.rb", "lib/pry-exception_explorer/intercept.rb", "lib/pry-exception_explorer/lazy_frame.rb", "lib/pry-exception_explorer/shim_builder.rb", "lib/pry-exception_explorer/version.rb", "pry-exception_explorer.gemspec", "test/helper.rb", "test/test_exceptions_in_pry.rb", "test/test_inline_exceptions.rb", "test/test_wrapped_exceptions.rb"]
   s.homepage = "https://github.com/banister/pry-exception_explorer"
   s.require_paths = ["lib"]
   s.rubygems_version = "1.8.11"

data/test/helper.rb

@@ -17,8 +17,6 @@ class OpenStruct
   end
 end
 
-EE = PryExceptionExplorer
-
 class Ratty
   def ratty
     Weasel.new.weasel
@@ -45,7 +43,7 @@ class << Pry
     Pry.color = false
     Pry.pager = false
     Pry.config.should_load_rc      = false
-    Pry.config.plugins.enabled     = false
+    Pry.config.should_load_plugins = false
     Pry.config.history.should_load = false
     Pry.config.history.should_save = false
     Pry.config.auto_indent         = false

data/test/test_exceptions_in_pry.rb

@@ -44,6 +44,36 @@ describe PryExceptionExplorer do
         mock_pry("Ratty.new.ratty", "enter-exception", "show-stack", "exit").should =~ /toad.*?weasel.*?ratty/m
       end
 
+      describe "enabled = false" do
+        it 'should prevent moving into an exception' do
+          old_e = PryExceptionExplorer.enabled
+          PryExceptionExplorer.enabled = false
+
+          mock_pry("Ratty.new.ratty", "enter-exception", "exit-all").should =~ /can't be entered/
+
+          PryExceptionExplorer.enabled = old_e
+        end
+      end
+
+      describe "continue-exception" do
+        it 'should continue the exception' do
+          o = OpenStruct.new
+          def o.test_method
+            raise "baby likes to raise an exception"
+            self.value = 10
+          end
+
+          redirect_pry_io(InputTester.new("test_method",
+                                          "enter-exception",
+                                          "continue-exception",
+                                          "exit-all")) do
+            Pry.start(o)
+          end
+
+          o.value.should == 10
+        end
+      end
+
       describe "exit-exception" do
         it 'should display error message when exit-exception used outside of exception context' do
           mock_pry("exit-exception").should =~ /You are not in an exception!/
@@ -88,6 +118,115 @@ describe PryExceptionExplorer do
           # Ratty -> Weasel -> Toad (raise is here)
           O.exception_self.is_a?(Toad).should == true
         end
+
+
+        describe "_ex_" do
+          it  "should correctly update _ex_ to reflect exception context" do
+            o = Object.new
+            class << o
+              attr_accessor :first_backtrace, :actual_first_backtrace
+              attr_accessor :second_backtrace, :actual_second_backtrace
+            end
+
+
+            redirect_pry_io(InputTester.new("raise ArgumentError, 'yo yo'",
+                                            "self.first_backtrace = _ex_.backtrace",
+                                            "enter-exception",
+                                            "self.actual_first_backtrace = _ex_.backtrace",
+                                            "raise RuntimeError, 'bing bong'",
+                                            "self.second_backtrace = _ex_.backtrace",
+                                            "enter-exception",
+                                            "self.actual_second_backtrace = _ex_.backtrace",
+                                            "exit-all", StringIO.new)) do
+              Pry.start(o)
+            end
+
+            o.first_backtrace.should == o.actual_first_backtrace
+            o.second_backtrace.should == o.actual_second_backtrace
+
+            # ensure nothing weird going on
+            o.first_backtrace.should.not == o.second_backtrace
+          end
+
+          it  "should correctly restore _ex_ when exiting out of exceptions" do
+            o = Object.new
+            class << o
+              attr_accessor :first_backtrace, :restored_first_backtrace
+              attr_accessor :second_backtrace, :restored_second_backtrace
+            end
+
+            redirect_pry_io(InputTester.new("raise ArgumentError, 'yo yo'",
+                                            "enter-exception",
+                                            "self.first_backtrace = _ex_.backtrace",
+                                            "raise RuntimeError, 'bing bong'",
+                                            "enter-exception",
+                                            "self.second_backtrace = _ex_.backtrace",
+                                            "exit-exception",
+                                            "exit-exception",
+                                            "self.restored_first_backtrace = _ex_.backtrace",
+                                            "exit-all", StringIO.new)) do
+              Pry.start(o)
+            end
+
+            # just ensure nothing weird is happening (probably unnecessary)
+            o.first_backtrace.should.not == o.second_backtrace
+
+            o.first_backtrace.should == o.restored_first_backtrace
+          end
+        end
+
+        describe "_pry_.backtrace" do
+          it  "should correctly update _pry_.backtrace to reflect exception context" do
+            o = Object.new
+            class << o
+              attr_accessor :first_backtrace, :ex_first_backtrace
+              attr_accessor :second_backtrace, :ex_second_backtrace
+            end
+
+            redirect_pry_io(InputTester.new("raise ArgumentError, 'yo yo'",
+                                            "enter-exception",
+                                            "self.first_backtrace = _pry_.backtrace",
+                                            "self.ex_first_backtrace = _ex_.backtrace",
+                                            "raise RuntimeError, 'bing bong'",
+                                            "enter-exception",
+                                            "self.second_backtrace = _pry_.backtrace",
+                                            "self.ex_second_backtrace = _ex_.backtrace",
+                                            "exit-all", StringIO.new)) do
+              Pry.start(o)
+            end
+
+            o.first_backtrace.should == o.ex_first_backtrace
+            o.second_backtrace.should == o.ex_second_backtrace
+
+            o.first_backtrace.should.not == o.second_backtrace
+          end
+
+          it  "should correctly restore _pry_.backtrace when exiting out of exceptions" do
+            o = Object.new
+            class << o
+              attr_accessor :first_backtrace, :restored_first_backtrace
+              attr_accessor :second_backtrace, :restored_second_backtrace
+            end
+
+            redirect_pry_io(InputTester.new("raise ArgumentError, 'yo yo'",
+                                            "enter-exception",
+                                            "self.first_backtrace = _pry_.backtrace",
+                                            "raise RuntimeError, 'bing bong'",
+                                            "enter-exception",
+                                            "self.second_backtrace = _pry_.backtrace",
+                                            "exit-exception",
+                                            "self.restored_first_backtrace = _pry_.backtrace",
+                                            "exit-all", StringIO.new)) do
+
+              Pry.start(o)
+            end
+
+            o.first_backtrace.should.not == o.second_backtrace
+            o.first_backtrace.should == o.restored_first_backtrace
+          end
+        end
+
+
       end
     end
   end

data/test/test_inline_exceptions.rb

@@ -7,7 +7,7 @@ O = OpenStruct.new
 prev_wrap_state = PryExceptionExplorer.wrap_active
 PryExceptionExplorer.wrap_active = false
 
-prev_intercept_state = PryExceptionExplorer.intercept_block
+prev_intercept_state = PryExceptionExplorer.intercept_object
 
 describe PryExceptionExplorer do
 
@@ -19,14 +19,102 @@ describe PryExceptionExplorer do
     # started) that this is registered by setting state on `O`
     Pry.config.input = StringIO.new("O.exception_intercepted = true\ncontinue-exception")
     Pry.config.output = StringIO.new
+    Pry.config.hooks.add_hook(:when_started, :save_caller_bindings, WhenStartedHook)
+    Pry.config.hooks.add_hook(:after_session, :delete_frame_manager, AfterSessionHook)
   end
 
   after do
     Pry.config.input.rewind
+    Pry.config.hooks.delete_hook(:when_started, :save_caller_bindings)
+    Pry.config.hooks.delete_hook(:after_session, :delete_frame_manager)
     O.clear
   end
 
+  describe "enabled = false" do
+    it 'should prevent interception of an exception' do
+      old_e = PryExceptionExplorer.enabled
+      PryExceptionExplorer.enabled = false
+
+      my_error = Class.new(StandardError)
+      EE.intercept(my_error)
+
+      begin
+        raise my_error
+      rescue => ex
+        exception = ex
+      end
+
+      exception.is_a?(my_error).should == true
+
+      PryExceptionExplorer.enabled = old_e
+    end
+  end
+
   describe "PryExceptionExplorer.intercept" do
+    it 'should be a no-op when intercept called with no parameters' do
+      b = proc {}
+      old = EE.intercept_object
+      EE.intercept &b
+      EE.intercept
+      EE.intercept_object.block.should == b
+      EE.intercept_object = old
+    end
+
+    describe "intercept_recurse" do
+      it 'should NOT allow recursive (in-session) interceptions by default' do
+        EE.intercept { |frame, ex| frame.klass == Toad }
+
+        redirect_pry_io(InputTester.new("O.before_self = self",
+                                        "Ratty.new.ratty",
+                                        "O.after_self = self",
+                                        "continue-exception",
+                                        "continue-exception")) do
+          Ratty.new.ratty 
+        end
+
+        O.before_self.should == O.after_self
+      end
+
+      it 'should allow recursive (in-session) interceptions when :intercept_recurse => true' do
+        EE.intercept(:intercept_recurse => true) { |frame, ex| frame.klass == Toad }
+
+        redirect_pry_io(InputTester.new("O.before_self = self",
+                                        "Ratty.new.ratty",
+                                        "O.after_self = self",
+                                        "continue-exception",
+                                        "continue-exception")) do
+          Ratty.new.ratty 
+        end
+
+        O.before_self.should.not == O.after_self
+      end
+      
+    end
+
+    describe "skip" do
+      it 'should skip first frame with :skip => 1' do
+        EE.intercept(:skip => 1) { |frame, ex| frame.klass == Toad }
+
+        redirect_pry_io(InputTester.new("O.method_name = __method__",
+                                        "continue-exception")) do
+          Ratty.new.ratty
+        end
+
+        O.method_name.should == :weasel
+      end
+
+      it 'should skip first two framed with :skip => 2' do
+        EE.intercept(:skip => 2) { |frame, ex| frame.klass == Toad }
+
+        redirect_pry_io(InputTester.new("O.method_name = __method__",
+                                        "continue-exception")) do
+          Ratty.new.ratty
+        end
+
+        O.method_name.should == :ratty
+      end
+    end
+
     describe "special case exception-only syntax" do
 
       describe "single exception" do
@@ -101,7 +189,12 @@ describe PryExceptionExplorer do
       describe "second frame" do
         it  "should intercept exception based on second frame's method name" do
           EE.intercept { |frame, ex| frame.prev.klass == Weasel }
-          Ratty.new.ratty
+          begin
+            Ratty.new.ratty
+          rescue => ex
+            Pry.new(:input => Readline, :output =>
+                    $stdout).repl(binding)
+          end
           O.exception_intercepted.should == true
         end
 
@@ -251,12 +344,29 @@ describe PryExceptionExplorer do
 
     end
 
+    describe "exit-exception" do
+      it 'should exit session and raise exception' do
+        my_error = Class.new(StandardError)
+        EE.intercept(my_error)
+
+        begin
+          redirect_pry_io(InputTester.new("exit-exception")) do
+            raise my_error
+          end
+        rescue => ex
+          exception = ex
+        end
+
+        exception.is_a?(my_error).should == true
+      end
+    end
+
   end
 
 end
 
 # restore to default
 PryExceptionExplorer.wrap_active = prev_wrap_state
-PryExceptionExplorer.intercept &prev_intercept_state
+PryExceptionExplorer.intercept_object = prev_intercept_state
 
 Object.send(:remove_const, :O)

data/test/test_wrapped_exceptions.rb

@@ -1,19 +1,15 @@
 require 'helper'
 
-require 'pry-exception_explorer/exception_wrap'
-
 CaughtException   = Class.new(StandardError)
 UncaughtException = Class.new(StandardError)
 
-
 describe PryExceptionExplorer do
 
-
   before do
     Pry.config.input = StringIO.new("exit :caught\n")
     Pry.config.output = StringIO.new
-    Pry.config.hooks.add_hook(:when_started, :save_caller_bindings, &WhenStartedHook)
-    Pry.config.hooks.add_hook(:after_session, :delete_frame_manager, &AfterSessionHook)
+    Pry.config.hooks.add_hook(:when_started, :save_caller_bindings, WhenStartedHook)
+    Pry.config.hooks.add_hook(:after_session, :delete_frame_manager, AfterSessionHook)
   end
 
   after do
@@ -23,6 +19,56 @@ describe PryExceptionExplorer do
 
   describe "PryExceptionExplorer.wrap" do
 
+    describe "_ex_" do
+      it 'should correctly set _ex_ inside session (set to raised exception)' do
+        ex = Class.new(StandardError)
+        o = Object.new
+        class << o; attr_accessor :ex; self; end.class_eval { define_method(:raze) { raise ex } }
+
+        PryExceptionExplorer.intercept { true }
+
+        redirect_pry_io(InputTester.new("@ex = _ex_", "exit-all")) do
+          PryExceptionExplorer.wrap do
+            o.raze
+          end
+        end
+
+        o.ex.is_a?(ex).should == true
+      end
+    end
+
+    describe "_pry_.backtrace" do
+      it 'should correctly set _pry_ inside session to backtrace of raised exception' do
+        ex = Class.new(StandardError)
+        o = Object.new
+        class << o; attr_accessor :ex, :pry_bt; self; end.class_eval { define_method(:raze) { raise ex } }
+
+        PryExceptionExplorer.intercept { true }
+
+        redirect_pry_io(InputTester.new("@ex = _ex_", "@pry_bt = _pry_.backtrace", "exit-all")) do
+          PryExceptionExplorer.wrap do
+            o.raze
+          end
+        end
+
+        o.pry_bt.should == o.ex.backtrace
+      end
+    end
+
+    describe "enabled = false" do
+      it 'should have no effect for wrap block (which sets enabled=true internally)' do
+        old_e = PryExceptionExplorer.enabled
+        PryExceptionExplorer.enabled = false
+
+        PryExceptionExplorer.wrap do
+          raise CaughtException, "catch me if u can"
+        end.should == :caught
+
+        PryExceptionExplorer.enabled.should == false
+        PryExceptionExplorer.enabled = old_e
+      end
+    end
+
     # use of exit-exception inside a wrapped exception is weird
     # (because exit-exception is really designed for pry exceptions)
     # but when we do receive one, we should exit out of pry

metadata

@@ -1,59 +1,55 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: pry-exception_explorer
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 0.1.1pre7
   prerelease: 5
-  version: 0.1.1pre5
 platform: ruby
-authors: 
+authors:
 - John Mair (banisterfiend)
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-01-12 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2012-01-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: pry-stack_explorer
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &70111600095300 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: bacon
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: *70111600095300
+- !ruby/object:Gem::Dependency
+  name: bacon
+  requirement: &70111600094500 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
+      - !ruby/object:Gem::Version
         version: 1.1.0
   type: :development
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: rake
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  version_requirements: *70111600094500
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70111600093540 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        version: "0.9"
+      - !ruby/object:Gem::Version
+        version: '0.9'
   type: :development
-  version_requirements: *id003
+  prerelease: false
+  version_requirements: *70111600093540
 description: Enter the context of exceptions
 email: jrmair@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .gemtest
 - .gitignore
 - .travis.yml
@@ -63,11 +59,13 @@ files:
 - LICENSE
 - README.md
 - Rakefile
-- examples/example.rb
+- examples/example_inline.rb
+- examples/example_wrap.rb
 - lib/pry-exception_explorer.rb
 - lib/pry-exception_explorer/cli.rb
 - lib/pry-exception_explorer/commands.rb
-- lib/pry-exception_explorer/exception_wrap.rb
+- lib/pry-exception_explorer/core_ext.rb
+- lib/pry-exception_explorer/intercept.rb
 - lib/pry-exception_explorer/lazy_frame.rb
 - lib/pry-exception_explorer/shim_builder.rb
 - lib/pry-exception_explorer/version.rb
@@ -78,32 +76,29 @@ files:
 - test/test_wrapped_exceptions.rb
 homepage: https://github.com/banister/pry-exception_explorer
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-
 rubyforge_project: 
 rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
 summary: Enter the context of exceptions
-test_files: 
+test_files:
 - test/helper.rb
 - test/test_exceptions_in_pry.rb
 - test/test_inline_exceptions.rb

data/lib/pry-exception_explorer/exception_wrap.rb

@@ -1,33 +0,0 @@
-require 'pry-exception_explorer'
-
-#Pry.config.hooks.delete_hook(:when_started, :save_caller_bindings)
-
-# default is to capture all exceptions that bubble to the top
-PryExceptionExplorer.intercept { true }
-
-module PryExceptionExplorer
-
-  def self.wrap
-    old_enabled, old_wrap_active = enabled, wrap_active
-    self.enabled     = true
-    self.wrap_active = true
-    yield
-  rescue Exception => ex
-    if ex.should_capture?
-      hooks = Pry.config.hooks.dup.add_hook(:before_session, :set_exception_flag) do |_, _, _pry_|
-        PryStackExplorer.frame_manager(_pry_).user[:exception] = ex
-
-        _pry_.last_exception = ex
-        _pry_.backtrace = ex.backtrace
-      end
-
-      Pry.start self, :call_stack => ex.exception_call_stack, :hooks => hooks
-    else
-      raise ex
-    end
-  ensure
-    self.enabled     = old_enabled
-    self.wrap_active = old_wrap_active
-  end
-end
-