skiptrace 0.6.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b096ce5bb5b6dc3eaaa85da829ed81f679769d250832d69200cd436ede980f8e
+  data.tar.gz: 225309587a7ae71e880a4c0de379a4e7d648ada4d8174f780499c386102345dc
+SHA512:
+  metadata.gz: e343d3d59722bd66bf413607751fb8a24c3b7bcb1279191204bf2d626b06c16f9f275cc888a60979b2f6f0d676f3d245eb2feb06d6d063910d35a5fb74887b9d
+  data.tar.gz: 241c4e6944ca59877981f910f53c0fbf601640d54fb56fcc5c51da5a8ec4037cdae147dbc93bd59597b0fc6ed189d922bb93f66b38a21a9011ac5a33638234f8

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+.ycm_extra_conf.py*
+mkmf.log

data/.travis.yml

@@ -0,0 +1,27 @@
+language: ruby
+
+rvm:
+  - ruby-2.0.0-p648
+  - ruby-2.1.10
+  - ruby-2.1.0
+  - ruby-2.2.6
+  - ruby-2.3.3
+  - ruby-2.4.0
+  - ruby-head
+
+  - jruby-9.1.8.0
+  - jruby-head
+
+allow_failures:
+    - rvm: ruby-head
+    - rvm: jruby-head
+
+env:
+  global:
+    - JRUBY_OPTS=--dev
+
+before_install: gem install bundler
+
+sudo: false
+
+cache: bundler

data/CONTRIBUTING.md

@@ -0,0 +1,15 @@
+# Contributing
+
+1. Fork it ( https://github.com/gsamokovarov/skiptrace/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+## Etiquette
+
+If you want to contribute code, which is not your own or is heavily inspired by
+someone else's code, please give them a warm shoutout in the pull request (or
+the commit message) and the code itself.
+
+Of course, don't try to sneak in non MIT compatible code.

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+gemspec name: 'skiptrace'
+
+# Rubinius 2.2.2 travis tests complain about this one.
+platforms :rbx do
+  gem "rubysl-mutex_m"
+  gem "rubysl-open3"
+  gem "rubysl-singleton"
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014-2017 Genadi Samokovarov
+
+MIT License
+
+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,51 @@
+# Skiptrace [![Build Status](https://travis-ci.org/gsamokovarov/bindex.svg?branch=master)](https://travis-ci.org/gsamokovarov/bindex)
+
+When Ruby raises an exception, it leaves you a backtrace to help you figure out
+where did the exception originated in. Skiptrace gives you the bindings as well.
+This can help you introspect the state of the Ruby program when at the point
+the exception occurred.
+
+## Usage
+
+**Do not** use this gem on production environments. The performance penalty isn't
+worth it anywhere outside of development.
+
+### API
+
+Skiptrace defines the following API:
+
+#### Exception#bindings
+
+Returns all the bindings up to the one in which the exception originated in.
+
+#### Skiptrace.current_bindings
+
+Returns all of the current Ruby execution state bindings. The first one is the
+current one, the second is the caller one, the third is the caller of the
+caller one and so on.
+
+## Support
+
+### CRuby
+
+CRuby 2.0.0 and above is supported.
+
+### JRuby
+
+To get the best support, run JRuby in interpreted mode.
+
+```bash
+export JRUBY_OPTS=--dev
+```
+
+Only JRuby 9k is supported.
+
+### Rubinius
+
+Internal errors like `ZeroDevisionError` aren't caught.
+
+## Credits
+
+Thanks to John Mair for his work on binding_of_caller, which is a huge
+inspiration. Thanks to Charlie Somerville for better_errors where the idea
+comes from. Thanks to Koichi Sasada for the debug inspector API in CRuby.

data/Rakefile

@@ -0,0 +1,35 @@
+require 'rake/testtask'
+require "rake/clean"
+
+CLOBBER.include "pkg"
+
+Bundler::GemHelper.install_tasks name: ENV.fetch('GEM_NAME', 'skiptrace')
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.test_files = FileList['test/*_test.rb']
+  t.verbose = true
+end
+
+case RUBY_ENGINE
+when 'ruby'
+  require 'rake/extensiontask'
+
+  Rake::ExtensionTask.new('skiptrace') do |ext|
+    ext.name = 'cruby'
+    ext.lib_dir = 'lib/skiptrace'
+  end
+
+  task default: [:clean, :compile, :test]
+when 'jruby'
+  require 'rake/javaextensiontask'
+
+  Rake::JavaExtensionTask.new('skiptrace') do |ext|
+    ext.name = 'jruby_internals'
+    ext.lib_dir = 'lib/skiptrace'
+  end
+
+  task default: [:clean, :compile, :test]
+else
+  task default: [:test]
+end

data/bindex.gemspec

@@ -0,0 +1,27 @@
+$LOAD_PATH << File.expand_path('../lib', __FILE__)
+
+require 'skiptrace/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "bindex"
+  spec.version       = Skiptrace::VERSION
+  spec.authors       = ["Genadi Samokovarov"]
+  spec.email         = ["gsamokovarov@gmail.com"]
+  spec.extensions    = ["ext/skiptrace/extconf.rb"]
+  spec.summary       = "Bindings for your Ruby exceptions"
+  spec.homepage      = "https://github.com/gsamokovarov/bindex"
+  spec.license       = "MIT"
+
+  spec.required_ruby_version = ">= 2.0.0"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.extensions    = ["ext/skiptrace/extconf.rb"]
+
+  spec.add_development_dependency "minitest", "~> 5.4"
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rake-compiler"
+end

data/ext/skiptrace/com/gsamokovarov/skiptrace/BindingBuilder.java

@@ -0,0 +1,13 @@
+package com.gsamokovarov.skiptrace;
+
+import org.jruby.runtime.DynamicScope;
+import org.jruby.runtime.Binding;
+import org.jruby.runtime.Frame;
+import org.jruby.runtime.DynamicScope;
+import org.jruby.runtime.backtrace.BacktraceElement;
+
+class BindingBuilder {
+    public static Binding build(Frame frame, DynamicScope scope, BacktraceElement element) {
+        return new Binding(frame, scope, element.method, element.filename, element.line);
+    }
+}

data/ext/skiptrace/com/gsamokovarov/skiptrace/CurrentBindingsIterator.java

@@ -0,0 +1,54 @@
+package com.gsamokovarov.skiptrace;
+
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.DynamicScope;
+import org.jruby.runtime.Binding;
+import org.jruby.runtime.Frame;
+import org.jruby.runtime.DynamicScope;
+import org.jruby.runtime.backtrace.BacktraceElement;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+class CurrentBindingsIterator implements Iterator<Binding> {
+    private Frame[] frameStack;
+    private int frameIndex;
+
+    private DynamicScope[] scopeStack;
+    private int scopeIndex;
+
+    private BacktraceElement[] backtrace;
+    private int backtraceIndex;
+
+    CurrentBindingsIterator(ThreadContext context) {
+        ThreadContextInternals contextInternals = new ThreadContextInternals(context);
+
+        this.frameStack = contextInternals.getFrameStack();
+        this.frameIndex = contextInternals.getFrameIndex();
+
+        this.scopeStack = contextInternals.getScopeStack();
+        this.scopeIndex = contextInternals.getScopeIndex();
+
+        this.backtrace = contextInternals.getBacktrace();
+        this.backtraceIndex = contextInternals.getBacktraceIndex();
+    }
+
+    public boolean hasNext() {
+        return frameIndex >= 0 && scopeIndex >= 0 && backtraceIndex >= 0;
+    }
+
+    public Binding next() {
+        if (!hasNext()) {
+            throw new NoSuchElementException();
+        }
+
+        Frame frame = frameStack[frameIndex--];
+        DynamicScope scope = scopeStack[scopeIndex--];
+        BacktraceElement element = backtrace[backtraceIndex--];
+
+        return BindingBuilder.build(frame, scope, element);
+    }
+
+    public void remove() {
+        throw new UnsupportedOperationException();
+    }
+}

data/ext/skiptrace/com/gsamokovarov/skiptrace/JRubyIntegration.java

@@ -0,0 +1,49 @@
+package com.gsamokovarov.skiptrace;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyModule;
+import org.jruby.RubyClass;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.builtin.InstanceVariables;
+import org.jruby.anno.JRubyMethod;
+
+public class JRubyIntegration {
+    public static void setup(Ruby runtime) {
+        RubyModule skiptrace = runtime.defineModule("Skiptrace");
+        skiptrace.defineAnnotatedMethods(SkiptraceMethods.class);
+
+        RubyClass exception = runtime.getException();
+        exception.defineAnnotatedMethods(ExceptionExtensionMethods.class);
+
+        IRubyObject verbose = runtime.getVerbose();
+        try {
+            runtime.setVerbose(runtime.getNil());
+            runtime.addEventHook(new SetExceptionBindingsEventHook());
+        } finally {
+            runtime.setVerbose(verbose);
+        }
+    }
+
+    public static class SkiptraceMethods {
+        @JRubyMethod(name = "current_bindings", meta = true)
+        public static IRubyObject currentBindings(ThreadContext context, IRubyObject self) {
+            return RubyBindingsCollector.collectCurrentFor(context);
+        }
+    }
+
+    public static class ExceptionExtensionMethods {
+        @JRubyMethod
+        public static IRubyObject bindings(ThreadContext context, IRubyObject self) {
+            InstanceVariables instanceVariables = self.getInstanceVariables();
+
+            IRubyObject bindings = instanceVariables.getInstanceVariable("@bindings");
+            if (bindings != null && !bindings.isNil()) {
+                return bindings;
+            }
+
+            return RubyArray.newArray(context.getRuntime());
+        }
+    }
+}

data/ext/skiptrace/com/gsamokovarov/skiptrace/RubyBindingsCollector.java

@@ -0,0 +1,34 @@
+package com.gsamokovarov.skiptrace;
+
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.Binding;
+import org.jruby.runtime.DynamicScope;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.RubyBinding;
+import org.jruby.RubyArray;
+import org.jruby.Ruby;
+import java.util.Iterator;
+
+public class RubyBindingsCollector {
+    private final Ruby runtime;
+    private Iterator<Binding> iterator;
+
+    public static RubyArray collectCurrentFor(ThreadContext context) {
+        return new RubyBindingsCollector(context).collectCurrent();
+    }
+
+    private RubyBindingsCollector(ThreadContext context) {
+        this.iterator = new CurrentBindingsIterator(context);
+        this.runtime = context.getRuntime();
+    }
+
+    private RubyArray collectCurrent() {
+        RubyArray bindings = RubyArray.newArray(runtime);
+
+        while (iterator.hasNext()) {
+            bindings.append(((IRubyObject) RubyBinding.newBinding(runtime, iterator.next())));
+        }
+
+        return bindings;
+    }
+}

data/ext/skiptrace/com/gsamokovarov/skiptrace/SetExceptionBindingsEventHook.java

@@ -0,0 +1,24 @@
+package com.gsamokovarov.skiptrace;
+
+import org.jruby.runtime.EventHook;
+import org.jruby.runtime.RubyEvent;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.RubyArray;
+import org.jruby.RubyException;
+
+public class SetExceptionBindingsEventHook extends EventHook {
+    public boolean isInterestedInEvent(RubyEvent event) {
+        return event == RubyEvent.RAISE;
+    }
+
+    public void eventHandler(ThreadContext context, String eventName, String file, int line, String name, IRubyObject type) {
+        RubyArray bindings = RubyBindingsCollector.collectCurrentFor(context);
+        RubyException exception = (RubyException) context.runtime.getGlobalVariables().get("$!");
+
+        IRubyObject exceptionBindings = exception.getInstanceVariable("@bindings");
+        if (exceptionBindings == null || exceptionBindings.isNil()) {
+            exception.setInstanceVariable("@bindings", bindings);
+        }
+    }
+}

data/ext/skiptrace/com/gsamokovarov/skiptrace/ThreadContextInterfaceException.java

@@ -0,0 +1,14 @@
+package com.gsamokovarov.skiptrace;
+
+class ThreadContextInterfaceException extends RuntimeException {
+    private static final String MESSAGE_TEMPLATE =
+        "Expected private field %s in ThreadContext is missing";
+
+    ThreadContextInterfaceException(String fieldName) {
+        super(String.format(MESSAGE_TEMPLATE, fieldName));
+    }
+
+    ThreadContextInterfaceException(String fieldName, Throwable cause) {
+        super(String.format(MESSAGE_TEMPLATE, fieldName), cause);
+    }
+}

data/ext/skiptrace/com/gsamokovarov/skiptrace/ThreadContextInternals.java

@@ -0,0 +1,54 @@
+package com.gsamokovarov.skiptrace;
+
+import java.lang.reflect.Field;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.DynamicScope;
+import org.jruby.runtime.Frame;
+import org.jruby.runtime.backtrace.BacktraceElement;
+import org.jruby.runtime.builtin.IRubyObject;
+
+public class ThreadContextInternals {
+    private ThreadContext context;
+
+    public ThreadContextInternals(ThreadContext context) {
+        this.context = context;
+    }
+
+    public Frame[] getFrameStack() {
+        return (Frame[]) getPrivateField("frameStack");
+    }
+
+    public int getFrameIndex() {
+        return (Integer) getPrivateField("frameIndex");
+    }
+
+    public DynamicScope[] getScopeStack() {
+        return (DynamicScope[]) getPrivateField("scopeStack");
+    }
+
+    public int getScopeIndex() {
+        return (Integer) getPrivateField("scopeIndex");
+    }
+
+    public BacktraceElement[] getBacktrace() {
+        return (BacktraceElement[]) getPrivateField("backtrace");
+    }
+
+    public int getBacktraceIndex() {
+        return (Integer) getPrivateField("backtraceIndex");
+    }
+
+    private Object getPrivateField(String fieldName) {
+        try {
+            Field field = ThreadContext.class.getDeclaredField(fieldName);
+
+            field.setAccessible(true);
+
+            return field.get(context);
+        } catch (NoSuchFieldException exc) {
+            throw new ThreadContextInterfaceException(fieldName, exc);
+        } catch (IllegalAccessException exc) {
+            throw new ThreadContextInterfaceException(fieldName, exc);
+        }
+    }
+}

data/ext/skiptrace/cruby.c

@@ -0,0 +1,80 @@
+#include <ruby.h>
+#include <ruby/debug.h>
+
+static VALUE st_mSkiptrace;
+static ID id_bindings;
+
+static VALUE
+current_bindings_callback(const rb_debug_inspector_t *context, void *data)
+{
+  VALUE locations = rb_debug_inspector_backtrace_locations(context);
+  VALUE binding, bindings = rb_ary_new();
+  long i, length = RARRAY_LEN(locations);
+
+  for (i = 0; i < length; i++) {
+    binding = rb_debug_inspector_frame_binding_get(context, i);
+
+    if (!NIL_P(binding)) {
+      rb_ary_push(bindings, binding);
+    }
+  }
+
+  return bindings;
+}
+
+static VALUE
+current_bindings(void)
+{
+  return rb_debug_inspector_open(current_bindings_callback, NULL);
+}
+
+static void
+set_exception_bindings_callback(VALUE tpval, void *data)
+{
+  rb_trace_arg_t *trace_arg = rb_tracearg_from_tracepoint(tpval);
+  VALUE exception = rb_tracearg_raised_exception(trace_arg);
+  VALUE bindings = rb_attr_get(exception, id_bindings);
+
+  /* Set the bindings, only if they haven't been set already. This may reset
+   * the binding during reraise. */
+  if (NIL_P(bindings)) {
+    rb_ivar_set(exception, id_bindings, current_bindings());
+  }
+}
+
+static void
+set_exception_bindings_on_raise(void)
+{
+  VALUE tpval = rb_tracepoint_new(0, RUBY_EVENT_RAISE, set_exception_bindings_callback, 0);
+  rb_tracepoint_enable(tpval);
+}
+
+static VALUE
+st_current_bindings(VALUE self)
+{
+  return current_bindings();
+}
+
+static VALUE
+st_exc_bindings(VALUE self)
+{
+  VALUE bindings = rb_attr_get(self, id_bindings);
+
+  if (NIL_P(bindings)) {
+    bindings = rb_ary_new();
+  }
+
+  return bindings;
+}
+
+void
+Init_cruby(void)
+{
+  st_mSkiptrace = rb_define_module("Skiptrace");
+  id_bindings = rb_intern("bindings");
+
+  rb_define_singleton_method(st_mSkiptrace, "current_bindings", st_current_bindings, 0);
+  rb_define_method(rb_eException, "bindings", st_exc_bindings, 0);
+
+  set_exception_bindings_on_raise();
+}

data/ext/skiptrace/extconf.rb

@@ -0,0 +1,15 @@
+case RUBY_ENGINE
+when "ruby"
+  require "mkmf"
+
+  $CFLAGS << " -Wall"
+  $CFLAGS << " -g3 -O0" if ENV["DEBUG"]
+
+  create_makefile("skiptrace/cruby")
+else
+  IO.write(File.expand_path("../Makefile", __FILE__), <<-END)
+    all install static install-so install-rb: Makefile
+    .PHONY: all install static install-so install-rb
+    .PHONY: clean clean-so clean-static clean-rb
+  END
+end

data/lib/bindex.rb

@@ -0,0 +1,4 @@
+require_relative "skiptrace"
+
+# Keep backwards compatibility with the previous name.
+Bindex = Skiptrace

data/lib/skiptrace/jruby.rb

@@ -0,0 +1,5 @@
+require 'skiptrace/jruby_internals'
+
+java_import com.gsamokovarov.skiptrace.JRubyIntegration
+
+JRubyIntegration.setup(JRuby.runtime)

data/lib/skiptrace/rubinius.rb

@@ -0,0 +1,66 @@
+module Skiptrace
+  module Rubinius
+    # Filters internal Rubinius locations.
+    #
+    # There are a couple of reasons why we wanna filter out the locations.
+    #
+    # * ::Kernel.raise, is implemented in Ruby for Rubinius. We don't wanna
+    #   have the frame for it to align with the CRuby and JRuby implementations.
+    #
+    # * For internal methods location variables can be nil. We can't create a
+    #   bindings for them.
+    #
+    # * Bindings from the current file are considered internal and ignored.
+    #
+    # We do that all that so we can align the bindings with the backtraces
+    # entries.
+    class InternalLocationFilter
+      def initialize(locations)
+        @locations = locations
+      end
+
+      def filter
+        @locations.reject do |location|
+          location.file.start_with?('kernel/delta/kernel.rb') ||
+            location.file == __FILE__ ||
+            location.variables.nil?
+        end
+      end
+    end
+  end
+end
+
+# Gets the current bindings for all available Ruby frames.
+#
+# Filters the internal Rubinius and Skiptrace frames.
+def Skiptrace.current_bindings
+  locations = ::Rubinius::VM.backtrace(1, true)
+
+  Skiptrace::Rubinius::InternalLocationFilter.new(locations).filter.map do |location|
+    Binding.setup(
+      location.variables,
+      location.variables.method,
+      location.constant_scope,
+      location.variables.self,
+      location
+    )
+  end
+end
+
+::Exception.class_eval do
+  def bindings
+    @bindings || []
+  end
+end
+
+::Rubinius.singleton_class.class_eval do
+  raise_exception = instance_method(:raise_exception)
+
+  define_method(:raise_exception) do |exc|
+    if exc.bindings.empty?
+      exc.instance_variable_set(:@bindings, Skiptrace.current_bindings)
+    end
+
+    raise_exception.bind(self).call(exc)
+  end
+end

data/lib/skiptrace/version.rb

@@ -0,0 +1,3 @@
+module Skiptrace
+  VERSION = "0.6.0"
+end

data/lib/skiptrace.rb

@@ -0,0 +1,11 @@
+case RUBY_ENGINE
+when 'rbx'
+  require 'skiptrace/rubinius'
+when 'jruby'
+  require 'skiptrace/jruby'
+when 'ruby'
+  require 'skiptrace/cruby'
+end
+
+require "skiptrace/version"
+

data/skiptrace.gemspec

@@ -0,0 +1,27 @@
+$LOAD_PATH << File.expand_path('../lib', __FILE__)
+
+require 'skiptrace/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "skiptrace"
+  spec.version       = Skiptrace::VERSION
+  spec.authors       = ["Genadi Samokovarov"]
+  spec.email         = ["gsamokovarov@gmail.com"]
+  spec.extensions    = ["ext/skiptrace/extconf.rb"]
+  spec.summary       = "Bindings for your Ruby exceptions"
+  spec.homepage      = "https://github.com/gsamokovarov/skiptrace"
+  spec.license       = "MIT"
+
+  spec.required_ruby_version = ">= 2.0.0"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.extensions    = ["ext/skiptrace/extconf.rb"]
+
+  spec.add_development_dependency "minitest", "~> 5.4"
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rake-compiler"
+end

data/test/current_bindings_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+class CurrentBindingsTest < BaseTest
+  test 'first binding returned is the current one' do
+    assert_equal __LINE__, Skiptrace.current_bindings.first.eval('__LINE__')
+  end
+end

data/test/exception_test.rb

@@ -0,0 +1,51 @@
+require 'test_helper'
+
+class ExceptionTest < BaseTest
+  test 'bindings returns all the bindings of where the error originated' do
+    exc = FlatFixture.new.call
+
+    assert_equal 3, exc.bindings.first.eval('__LINE__')
+  end
+
+  test 'bindings returns all the bindings of where a custom error originate' do
+    exc = CustomErrorFixture.new.call
+
+    assert_equal 5, exc.bindings.first.eval('__LINE__')
+  end
+
+  test 'bindings goes down the_stack' do
+    exc = BasicNestedFixture.new.call
+
+    assert_equal 11, exc.bindings.first.eval('__LINE__')
+  end
+
+  test 'bindings inside_of_an_eval' do
+    exc = EvalNestedFixture.new.call
+
+    assert_equal 11, exc.bindings.first.eval('__LINE__')
+  end
+
+  test "re-raising doesn't lose bindings information" do
+    exc = ReraisedFixture.new.call
+
+    assert_equal 3, exc.bindings.first.eval('__LINE__')
+  end
+
+  test 'bindings is_empty_when_exception_is_still_not_raised' do
+    exc = RuntimeError.new
+
+    assert_equal [], exc.bindings
+  end
+
+  test 'bindings is_empty_when_set_backtrace_is_badly_called' do
+    exc = RuntimeError.new
+
+    # Exception#set_backtrace expects a string or array of strings. If the
+    # input isn't like this it will raise a TypeError.
+    assert_raises(TypeError) do
+      exc.set_backtrace([nil])
+    end
+
+    assert_equal [], exc.bindings
+  end
+end

data/test/fixtures/basic_nested_fixture.rb

@@ -0,0 +1,13 @@
+class BasicNestedFixture
+  def call
+    raise_an_error
+  rescue => exc
+    exc
+  end
+
+  private
+
+    def raise_an_error
+      raise
+    end
+end

data/test/fixtures/custom_error_fixture.rb

@@ -0,0 +1,9 @@
+class CustomErrorFixture
+  Error = Class.new(StandardError)
+
+  def call
+    raise Error
+  rescue => exc
+    exc
+  end
+end

data/test/fixtures/eval_nested_fixture.rb

@@ -0,0 +1,13 @@
+class EvalNestedFixture
+  def call
+    tap { raise_an_error_in_eval }
+  rescue => exc
+    exc
+  end
+
+  private
+
+    def raise_an_error_in_eval
+      eval 'raise', binding, __FILE__, __LINE__
+    end
+end

data/test/fixtures/flat_fixture.rb

@@ -0,0 +1,7 @@
+class FlatFixture
+  def call
+    raise
+  rescue => exc
+    exc
+  end
+end

data/test/fixtures/reraised_fixture.rb

@@ -0,0 +1,19 @@
+class ReraisedFixture
+  def call
+    reraise_an_error
+  rescue => exc
+    exc
+  end
+
+  private
+
+    def raise_an_error_in_eval
+      method_that_raises
+    rescue => exc
+      raise exc
+    end
+
+    def method_that_raises
+      raise
+    end
+end

data/test/test_helper.rb

@@ -0,0 +1,17 @@
+$LOAD_PATH << File.expand_path('../lib', __FILE__)
+
+require 'minitest/autorun'
+require 'skiptrace'
+
+current_directory = File.dirname(File.expand_path(__FILE__))
+
+# Fixtures are plain classes that respond to #call.
+Dir["#{current_directory}/fixtures/**/*.rb"].each do |fixture|
+  require fixture
+end
+
+class BaseTest < MiniTest::Test
+  def self.test(name, &block)
+    define_method("test_#{name}", &block)
+  end
+end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: skiptrace
+version: !ruby/object:Gem::Version
+  version: 0.6.0
+platform: ruby
+authors:
+- Genadi Samokovarov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-03-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.4'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- gsamokovarov@gmail.com
+executables: []
+extensions:
+- ext/skiptrace/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CONTRIBUTING.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bindex.gemspec
+- ext/skiptrace/com/gsamokovarov/skiptrace/BindingBuilder.java
+- ext/skiptrace/com/gsamokovarov/skiptrace/CurrentBindingsIterator.java
+- ext/skiptrace/com/gsamokovarov/skiptrace/JRubyIntegration.java
+- ext/skiptrace/com/gsamokovarov/skiptrace/RubyBindingsCollector.java
+- ext/skiptrace/com/gsamokovarov/skiptrace/SetExceptionBindingsEventHook.java
+- ext/skiptrace/com/gsamokovarov/skiptrace/ThreadContextInterfaceException.java
+- ext/skiptrace/com/gsamokovarov/skiptrace/ThreadContextInternals.java
+- ext/skiptrace/cruby.c
+- ext/skiptrace/extconf.rb
+- lib/bindex.rb
+- lib/skiptrace.rb
+- lib/skiptrace/jruby.rb
+- lib/skiptrace/jruby_internals.jar
+- lib/skiptrace/rubinius.rb
+- lib/skiptrace/version.rb
+- skiptrace.gemspec
+- test/current_bindings_test.rb
+- test/exception_test.rb
+- test/fixtures/basic_nested_fixture.rb
+- test/fixtures/custom_error_fixture.rb
+- test/fixtures/eval_nested_fixture.rb
+- test/fixtures/flat_fixture.rb
+- test/fixtures/reraised_fixture.rb
+- test/test_helper.rb
+homepage: https://github.com/gsamokovarov/skiptrace
+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: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Bindings for your Ruby exceptions
+test_files:
+- test/current_bindings_test.rb
+- test/exception_test.rb
+- test/fixtures/basic_nested_fixture.rb
+- test/fixtures/custom_error_fixture.rb
+- test/fixtures/eval_nested_fixture.rb
+- test/fixtures/flat_fixture.rb
+- test/fixtures/reraised_fixture.rb
+- test/test_helper.rb