interception 0.1.pre.1 → 0.1.pre.2

data/.gitignore

@@ -4,3 +4,6 @@ ext/Makefile
 *.o
 *.so
 *.gem
+*.lock
+doc/
+.yardoc

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 1.9.2
+  - jruby-18mode
+  - jruby-19mode
+  - rbx-18mode
+  - rbx-19mode
+  - 1.8.7
+  - ree

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/Rakefile

@@ -0,0 +1,32 @@
+
+task :clean do
+  sh 'rm -f ext/*.o ext/*.so ext/*.dylib'
+  sh 'rm -f ext/org/pryrepl/*.class'
+end
+
+desc "Compile *.c files"
+task :compile => [:clean] do
+  cd 'ext/' do
+    sh 'ruby extconf.rb'
+    sh 'make'
+  end
+end
+
+desc "Run example"
+task :example do
+  sh "ruby -I./lib/ ./examples/example.rb "
+end
+
+desc "Run example 2"
+task :example2 do
+  sh "ruby -I./lib/ ./examples/example2.rb "
+end
+
+desc "Run tests"
+task :test do
+  sh 'rspec spec -r ./spec/spec_helpers.rb'
+end
+
+task :default => [:compile, :test]
+
+

data/examples/example.rb

@@ -0,0 +1,21 @@
+$:.unshift File.expand_path '../../lib', __FILE__
+require 'pryception'
+
+Interception.prycept do
+
+  def a
+    begin
+      begin
+        raise "foo"
+
+      rescue => e
+        raise "bar"
+      end
+
+    rescue => e
+      1 / 0
+
+    end
+  end
+  a
+end

data/examples/example2.rb

@@ -0,0 +1,20 @@
+$:.unshift File.expand_path '../../lib', __FILE__
+require 'pryception'
+
+def alpha
+  x = 1
+  beta
+end
+
+def beta
+  y = 30
+  gamma(1, 2)
+end
+
+def gamma(x)
+  greeting = x
+end
+
+Interception.prycept do
+  alpha
+end

data/ext/extconf.rb

@@ -1,12 +1,13 @@
 require 'rbconfig'
 
+
 if RbConfig::CONFIG['ruby_install_name'] == 'jruby'
 
   File.open("Makefile", "w") do |f|
     f.write "install:\n\tjrubyc --javac org/pryrepl/InterceptionEventHook.java\n"
   end
 
-elsif RbConfig::CONFIG['ruby_install_name'] == 'ruby'
+elsif RbConfig::CONFIG['ruby_install_name'] =~ /^ruby/
 
   require 'mkmf'
   $CFLAGS += " -DRUBY_19" if  RUBY_VERSION =~ /^1.9/

data/ext/interception.c

@@ -2,12 +2,26 @@
 
 static VALUE rb_mInterception;
 
+extern struct FRAME {
+    VALUE self;
+    int argc;
+    ID last_func;
+    ID orig_func;
+    VALUE last_class;
+    struct FRAME *prev;
+    struct FRAME *tmp;
+    struct RNode *node;
+    int iter;
+    int flags;
+    unsigned long uniq;
+} *ruby_frame;
+
 #ifdef RUBY_19
 
 void
 interception_hook(rb_event_flag_t evflag, VALUE data, VALUE self, ID mid, VALUE klass)
 {
-    VALUE binding = rb_funcall(rb_mKernel, rb_intern("binding"), 0, NULL);
+    VALUE binding = rb_funcall(self, rb_intern("binding"), 0, NULL);
     rb_funcall(rb_mInterception, rb_intern("rescue"), 2, rb_errinfo(), binding);
 }
 
@@ -24,7 +38,12 @@ interception_start(VALUE self)
 void
 interception_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
 {
-    VALUE binding = rb_funcall(rb_mKernel, rb_intern("binding"), 0, NULL);
+    VALUE bself = ruby_frame->prev->self;
+    if (node == ruby_frame->node) {
+        bself = ruby_frame->prev->prev->self;
+    }
+
+    VALUE binding = rb_funcall(bself, rb_intern("binding"), 0, NULL);
     rb_funcall(rb_mInterception, rb_intern("rescue"), 2, ruby_errinfo, binding);
 }
 
@@ -48,5 +67,5 @@ Init_interception()
 {
     rb_mInterception = rb_define_module("Interception");
     rb_define_singleton_method(rb_mInterception, "start", interception_start, 0);
-    rb_define_singleton_method(rb_mInterception, "stop", interception_start, 0);
+    rb_define_singleton_method(rb_mInterception, "stop", interception_stop, 0);
 }

data/interception.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "interception"
-  s.version = "0.1.pre.1"
+  s.version = "0.1.pre.2"
   s.author = "Conrad Irwin"
   s.email = "conrad.irwin@gmail.com"
   s.homepage = "http://github.com/ConradIrwin/interception"
@@ -12,4 +12,5 @@ Gem::Specification.new do |s|
   s.require_path = "lib"
 
   s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
 end

data/lib/cross_platform.rb

@@ -0,0 +1,67 @@
+# Platform specific implementations of Interception.start and Interception.stop
+class << Interception
+  private
+
+  # For Rubinius we just monkeypatch Kernel#raise_exception,
+  #
+  # This is normally a thin wrapper around raising an exception on the VM
+  # (so the layer of abstraction below Kernel#raise).
+  if defined? Rubinius
+
+    def start
+      class << Rubinius
+
+        alias raise_with_no_interception raise_exception
+
+        def raise_exception(exc)
+          bt = Rubinius::VM.backtrace(1, true).drop_while do |x|
+            x.variables.method.file.to_s.start_with?("kernel/")
+          end.first
+          b = Binding.setup(bt.variables, bt.variables.method, bt.constant_scope, bt.variables.self, bt)
+
+          Interception.rescue(exc, b)
+          raise_with_no_interception(exc)
+        end
+      end
+    end
+
+    def stop
+      class << Rubinius
+        alias raise_exception raise_with_no_interception
+      end
+    end
+
+  # For JRuby we use the underlying hooks mechanism.
+  #
+  # It seems to work even if I don't pass --debug, but it still
+  # warns about it. So disable the warnings and install the hook.
+  elsif defined?(JRuby)
+
+    require 'java'
+    $CLASSPATH << File.expand_path('../../ext/', __FILE__)
+    java_import org.pryrepl.InterceptionEventHook
+
+    def start
+      old_verbose = $VERBOSE
+      $VERBOSE = nil
+      JRuby.runtime.add_event_hook(hook)
+    ensure
+      $VERBOSE  = old_verbose
+    end
+
+    def stop
+      JRuby.runtime.remove_event_hook(hook)
+    end
+
+    def hook
+      @hook ||= InterceptionEventHook.new(proc do |e, b|
+        self.rescue(e, b)
+      end)
+    end
+
+  else #MRI
+
+    require File.expand_path('../../ext/interception', __FILE__)
+
+  end
+end

data/lib/interception.rb

@@ -1,19 +1,69 @@
 require 'thread'
 
+
+# Provides global facility for monitoring exceptions raised in your application.
 module Interception
 
   class << self
-    attr_accessor :mutex, :listeners
+    attr_accessor :mutex, :listeners, :rescueing
   end
-
   self.mutex = Mutex.new
   self.listeners = []
+  self.rescueing = false
 
+  # Listen for any exceptions raised.
+  #
+  # The listener block that you pass in will be executed as though inside Kernel#raise,
+  # so your entire program is still actively running. If you have a gem like
+  # pry-stack_explorer you can access the stack frames that lead to the exception
+  # occurring.
+  #
+  # NOTE: Be careful when writing a listener, if your listener raises an
+  # exception it will mask the original exception (though it will not recursively
+  # call your listener).
+  #
+  # @example
+  #
+  #   # To report exceptions for the entire run of the program:
+  #   Interception.listen do |exception, binding|
+  #     Emailer.spam!('on-duty@startup.com', exception, binding.eval('self.class.name'))
+  #   end
+  #
+  # @example
+  #
+  #   # To log exceptions for the duration of a given block.
+  #   def log_exceptions(&block)
+  #     Interception.listen(block) do |exception, binding|
+  #       puts "#{binding.eval("self.inspect")} raised #{exception.inspect}"
+  #     end
+  #   end
+  #
+  # @example
+  #
+  #   # You can also turn listeners on and off manually
+  #
+  #   listener = Proc.new{ |exception, binding|
+  #     binding.pry
+  #   }
+  #   Interception.listen(listener)
+  #   Async::Redis.get("foo") do
+  #     Interception.unlisten(listener)
+  #   end
+  #
+  # @param [Proc] for_block (nil) If you pass for_block in, then you will only
+  #                               intercept exceptions raised while that block
+  #                               is running.
+  # @param [Proc] listen_block    The block to call when an exception occurs,
+  #                               takes two arguments, the exception and the
+  #                               binding
+  # @return [Object]              The return value of the for_block (if present)
+  # @yield [exception, binding]
+  # @see .unlisten
   def self.listen(for_block=nil, &listen_block)
-    raise "no block given" unless listen_block || for_block
+    raise ArgumentError, "no block given" unless listen_block || for_block
     mutex.synchronize{
-      listeners << listen_block || for_block
-      start
+      start if listeners.empty?
+      listeners << (listen_block || for_block)
     }
 
     if listen_block && for_block
@@ -22,9 +72,15 @@ module Interception
       ensure
         unlisten listen_block
       end
+    else
+      listen_block
     end
   end
 
+  # Disable a previously added listener
+  #
+  # @param [Proc] listen_block  The listen block you wish to remove.
+  # @see .listen
   def self.unlisten(listen_block)
     mutex.synchronize{
       listeners.delete listen_block
@@ -32,53 +88,33 @@ module Interception
     }
   end
 
-  def self.rescue(e, binding)
+  # Called by platform-specific implementations whenever an exception is raised.
+  #
+  # The arguments will be forwarded on to all listeners added via {listen} that
+  # haven't been removed via {unlisten}.
+  #
+  # For efficiency, this block will never be called unless there are active
+  # listeners.
+  #
+  # @param [Exception] exception  The exception that was raised
+  # @param [Binding] binding  The binding from which it was raised
+  def self.rescue(exception, binding)
+    return if rescueing
+    self.rescueing = true
     listeners.each do |l|
-      l.call(e, binding)
+      l.call(exception, binding)
     end
+  ensure
+    self.rescueing = false
   end
 
-  if defined? Rubinius
-    def self.start
-      class << Rubinius
-        alias raise_with_no_interception raise_exception
-
-        def raise_exception(exc)
-          bt = Rubinius::VM.backtrace(1, true).drop_while do |x|
-            x.variables.method.file.to_s.start_with?("kernel/")
-          end.first
-          b = Binding.setup(bt.variables, bt.variables.method, bt.constant_scope, bt.variables.self, bt)
-
-          Interception.rescue(exc, b)
-          raise_with_no_interception(exc)
-        end
-      end
-    end
+  # Start sending events to rescue.
+  # Implemented per-platform
+  def self.start; raise NotImplementedError end
 
-    def self.stop
-      class << Rubinius
-        alias raise_exception raise_with_no_interception
-      end
-    end
-  elsif defined?(JRuby)
-    $CLASSPATH << File.expand_path('../../ext/', __FILE__)
-    java_import org.pryrepl.InterceptionEventHook
+  # Stop sending events to rescue.
+  # Implemented per-platform
+  def self.stop; raise NotImplementedError end
 
-    def self.start
-      JRuby.runtime.add_event_hook(hook)
-    end
-
-    def self.stop
-      JRuby.runtime.remove_event_hook(hook)
-    end
-
-    def self.hook
-      @hook ||= InterceptionEventHook.new(proc do |e, b|
-        self.rescue(e, b)
-      end)
-    end
-
-  else
-    require File.expand_path('../../ext/interception.so', __FILE__)
-  end
+  require File.expand_path('../cross_platform.rb', __FILE__)
 end

data/lib/pryception.rb

@@ -0,0 +1,66 @@
+require 'rubygems'
+require 'interception'
+require 'pry'
+
+begin
+  require 'pry-stack_explorer'
+rescue LoadError
+end
+
+module Interception
+
+  class << self
+
+    # Intercept all exceptions that arise in the block and start a Pry session
+    # at the fail site.
+    def prycept(&block)
+      raised = []
+
+      Interception.listen(block) do |exception, binding|
+        if defined?(PryStackExplorer)
+          raised << [exception, binding.callers]
+        else
+          raised << [exception, Array(binding)]
+        end
+      end
+
+    ensure
+      if raised.any?
+        exception, bindings = raised.last
+        enter_exception_context(exception, bindings)
+      end
+    end
+
+    private
+
+    # Sanitize the call stack.
+    # @param [Array<Binding>] bindings The call stack.
+    def prune_call_stack!(bindings)
+      bindings.delete_if { |b| b.eval("self") == self || b.eval("__method__") == :prycept }
+    end
+
+    # Start a Pry session in the context of the exception.
+    # @param [Exception] exception The exception.
+    # @param [Array<Binding>] bindings The call stack.
+    def enter_exception_context(exception, bindings)
+      inject_local("_ex_", exception, bindings.first)
+      inject_local("_raised_", [exception, bindings.first], bindings.first)
+
+      prune_call_stack!(bindings)
+      if defined?(PryStackExplorer)
+        pry :call_stack => bindings
+      else
+        bindings.first.pry
+      end
+    end
+
+    # Inject a local variable into a binding.
+    def inject_local(var, object, binding)
+      Thread.current[:__intercept_var__] = object
+      binding.eval("#{var} = Thread.current[:__intercept_var__]")
+    ensure
+      Thread.current[:__intercept_var__] = nil
+    end
+  end
+end
+

data/pryly.rb

@@ -0,0 +1,41 @@
+require 'rubygems'
+require 'interception'
+require 'pry'
+require 'pry-stack_explorer'
+def pryly(&block)
+  raised = []
+
+  Interception.listen(block) do |exception, binding|
+    raised << [exception, binding.callers]
+  end
+
+ensure
+  if raised.last
+    e, bindings = raised.last
+    $foo = e
+    $bar = raised
+    bindings.first.eval("_ex_ = $foo")
+    bindings.first.eval("_raised_ = $bar")
+    bindings = bindings.drop_while { |b| b.eval("self") == Interception || b.eval("__method__") == :pryly }
+    pry :call_stack => bindings
+  end
+end
+
+pryly do
+
+  def a
+    begin
+      begin
+        raise "foo"
+
+      rescue => e
+        raise "bar"
+      end
+
+    rescue => e
+      1 / 0
+
+    end
+  end
+  a
+end

data/spec/interception_spec.rb

@@ -0,0 +1,141 @@
+Interception.listen(proc {
+  begin; raise "fooo"; rescue; end
+}) do |e, b|
+  $initial_eb = [e,b]
+end
+
+describe Interception do
+
+  before do
+    @exceptions = []
+    Interception.listen do |e, b|
+      @exceptions << [e, b]
+    end
+  end
+
+  after do
+    Interception.listeners.each do |l|
+      Interception.unlisten l
+    end
+  end
+
+  it "should allow keeping a log of all exceptions raised" do
+    begin
+      raise "foo"
+    rescue => e
+      #
+    end
+
+    @exceptions.map(&:first).should == [e]
+  end
+
+  it "should catch the correct binding" do
+    shoulder = :bucket
+    begin
+      raise "foo"
+    rescue => e
+      #
+    end
+
+    @exceptions.map{ |e, b| b.eval('shoulder') }.should == [:bucket]
+  end
+
+  it "should catch the binding on the correct line" do
+    shoulder = :bucket
+
+    line = nil
+    begin
+      line = __LINE__; raise "foo"
+    rescue => e
+      #
+    end
+
+    @exceptions.map{ |e, b| b.eval('__LINE__') }.should == [line]
+  end
+
+  it "should catch all nested exceptions" do
+
+    begin
+      begin
+        raise "foo"
+      rescue => e1
+        raise "bar"
+      end
+    rescue => e2
+      #
+    end
+
+    @exceptions.map(&:first).should == [e1, e2]
+  end
+
+  it "should be able to listen for the duration of a block" do
+
+    e1, e2 = nil
+    block = proc{
+      begin
+        line = __LINE__; raise "foo"
+      rescue => e1
+        #
+      end
+    }
+    Interception.listen(block) do |e, b|
+      e2 = e
+    end
+
+    e1.should == e2
+  end
+
+  it "should allow nested calls to listen with a block" do
+    e1, e2 = nil
+    b1, b2 = nil
+    block = proc{
+      begin
+        raise "foo"
+      rescue => e1
+        #
+      end
+    }
+    block2 = proc{
+      Interception.listen(block) do |e, b|
+        e2 = e
+        b1 = b
+      end
+    }
+    Interception.listen(block2) do |e, b|
+      b2 = b
+    end
+
+    e1.should == e2
+    b1.should == b2
+  end
+
+  it "should be able to handle NoMethodErrors" do
+    shoulder = :bucket
+
+    begin
+      line = __LINE__; "snorkle".desnrok
+    rescue => e1
+      #
+    end
+
+    @exceptions.map{ |e, b| [e] + b.eval('[__LINE__, shoulder, self]') }.should == [[e1, line, :bucket, self]]
+    e1.message.should =~ /desnrok/
+  end
+
+  it "should be able to handle division by 0 errors" do
+    shoulder = :bucket
+
+    begin
+      line = __LINE__; 1 / 0
+    rescue => e1
+      #
+    end
+
+    @exceptions.map{ |e, b| [e] + b.eval('[__LINE__, shoulder, self]') }.should == [[e1, line, :bucket, self]]
+    ZeroDivisionError.should === e1
+  end
+
+  it "should have the right exception and binding at the top level" do
+    $initial_eb.last.eval("self").should == TOPLEVEL_BINDING.eval("self")
+  end
+end

data/spec/spec_helpers.rb

@@ -0,0 +1 @@
+require File.expand_path('../../lib/interception', __FILE__)

metadata

@@ -2,7 +2,7 @@
 name: interception
 version: !ruby/object:Gem::Version
   prerelease: 4
-  version: 0.1.pre.1
+  version: 0.1.pre.2
 platform: ruby
 authors:
 - Conrad Irwin
@@ -22,6 +22,17 @@ dependencies:
   requirement: *2056
   prerelease: false
   type: :development
+- !ruby/object:Gem::Dependency
+  name: rspec
+  version_requirements: &2074 !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  requirement: *2074
+  prerelease: false
+  type: :development
 description: Provides a cross-platform ability to intercept all exceptions as they are raised.
 email: conrad.irwin@gmail.com
 executables: []
@@ -30,11 +41,21 @@ extensions:
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
+- Gemfile
+- Rakefile
+- examples/example.rb
+- examples/example2.rb
 - ext/extconf.rb
 - ext/interception.c
 - ext/org/pryrepl/InterceptionEventHook.java
 - interception.gemspec
+- lib/cross_platform.rb
 - lib/interception.rb
+- lib/pryception.rb
+- pryly.rb
+- spec/interception_spec.rb
+- spec/spec_helpers.rb
 homepage: http://github.com/ConradIrwin/interception
 licenses: []
 post_install_message: