interception 0.1.pre.1

data/.gitignore

@@ -0,0 +1,6 @@
+.rbx
+ext/Makefile
+*.class
+*.o
+*.so
+*.gem

data/ext/extconf.rb

@@ -0,0 +1,23 @@
+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'
+
+  require 'mkmf'
+  $CFLAGS += " -DRUBY_19" if  RUBY_VERSION =~ /^1.9/
+  extension_name = "interception"
+  dir_config(extension_name)
+  create_makefile(extension_name)
+
+else
+
+  File.open("Makefile", "w") do |f|
+    f.write "install:\n\t:\n"
+  end
+
+end

data/ext/interception.c

@@ -0,0 +1,52 @@
+#include "ruby.h"
+
+static VALUE rb_mInterception;
+
+#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);
+    rb_funcall(rb_mInterception, rb_intern("rescue"), 2, rb_errinfo(), binding);
+}
+
+VALUE
+interception_start(VALUE self)
+{
+    rb_add_event_hook(interception_hook, RUBY_EVENT_RAISE, rb_mInterception);
+}
+
+#else
+
+#include "node.h"
+
+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);
+    rb_funcall(rb_mInterception, rb_intern("rescue"), 2, ruby_errinfo, binding);
+}
+
+VALUE
+interception_start(VALUE self)
+{
+    rb_add_event_hook(interception_hook, RUBY_EVENT_RAISE);
+}
+
+#endif
+
+VALUE
+interception_stop(VALUE self)
+{
+    rb_remove_event_hook(interception_hook);
+    return Qnil;
+}
+
+void
+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);
+}

data/ext/org/pryrepl/InterceptionEventHook.java

@@ -0,0 +1,29 @@
+package org.pryrepl;
+
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.EventHook;
+import org.jruby.runtime.RubyEvent;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.RubyException;
+import org.jruby.RubyBinding;
+import org.jruby.RubyProc;
+
+public class InterceptionEventHook extends EventHook {
+
+    private RubyProc proc;
+
+    public InterceptionEventHook(RubyProc proc) {
+        super();
+        this.proc = proc;
+    }
+
+    public boolean isInterestedInEvent(RubyEvent event) {
+        return event.getName().equals(RubyEvent.RAISE.getName());
+    }
+
+    public void eventHandler(ThreadContext context, String eventName, String file, int line, String name, IRubyObject type) {
+        RubyBinding binding = RubyBinding.newBinding(context.runtime, context.currentBinding());
+        RubyException exception = (RubyException)context.runtime.getGlobalVariables().get("$!");
+        proc.call(context, new IRubyObject[] {exception, binding});
+    }
+}

data/interception.gemspec

@@ -0,0 +1,15 @@
+Gem::Specification.new do |s|
+  s.name = "interception"
+  s.version = "0.1.pre.1"
+  s.author = "Conrad Irwin"
+  s.email = "conrad.irwin@gmail.com"
+  s.homepage = "http://github.com/ConradIrwin/interception"
+  s.summary = "Intercept exceptions as they are being raised"
+  s.description = "Provides a cross-platform ability to intercept all exceptions as they are raised."
+
+  s.files = `git ls-files`.split("\n")
+  s.extensions = "ext/extconf.rb"
+  s.require_path = "lib"
+
+  s.add_development_dependency 'rake'
+end

data/lib/interception.rb

@@ -0,0 +1,84 @@
+require 'thread'
+
+module Interception
+
+  class << self
+    attr_accessor :mutex, :listeners
+  end
+
+  self.mutex = Mutex.new
+  self.listeners = []
+
+  def self.listen(for_block=nil, &listen_block)
+    raise "no block given" unless listen_block || for_block
+    mutex.synchronize{
+      listeners << listen_block || for_block
+      start
+    }
+
+    if listen_block && for_block
+      begin
+        for_block.call
+      ensure
+        unlisten listen_block
+      end
+    end
+  end
+
+  def self.unlisten(listen_block)
+    mutex.synchronize{
+      listeners.delete listen_block
+      stop if listeners.empty?
+    }
+  end
+
+  def self.rescue(e, binding)
+    listeners.each do |l|
+      l.call(e, binding)
+    end
+  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
+
+    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
+
+    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
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: interception
+version: !ruby/object:Gem::Version
+  prerelease: 4
+  version: 0.1.pre.1
+platform: ruby
+authors:
+- Conrad Irwin
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2012-08-11 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  version_requirements: &2056 !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  requirement: *2056
+  prerelease: false
+  type: :development
+description: Provides a cross-platform ability to intercept all exceptions as they are raised.
+email: conrad.irwin@gmail.com
+executables: []
+extensions:
+- ext/extconf.rb
+extra_rdoc_files: []
+files:
+- .gitignore
+- ext/extconf.rb
+- ext/interception.c
+- ext/org/pryrepl/InterceptionEventHook.java
+- interception.gemspec
+- lib/interception.rb
+homepage: http://github.com/ConradIrwin/interception
+licenses: []
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+  none: false
+requirements: []
+rubyforge_project:
+rubygems_version: 1.8.15
+signing_key:
+specification_version: 3
+summary: Intercept exceptions as they are being raised
+test_files: []
+...