ed-precompiled_bindex 0.8.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c2dad15030466ddbaa2ef4febddc0388db5d4c0a13584c1595fd3bad76bcbed8
+  data.tar.gz: 580698c6ad91d39e0c542615a208d33230d92a083db9b2c613abbded01794544
+SHA512:
+  metadata.gz: 174a03db11f91ee12f742d44b09fc28f608d22dc659d315cbeeb03f99c82c13523de62f4a3a031b85fed3769e733940a3b12102908c7398e872c28820a2a6a60
+  data.tar.gz: a542158bb41607ce71def8964df9404c2fc1dddb3213286842ac98b03a03ea50f10acec6e87c4f319c4975c53f893009fa052a9e1be22a35c0f9011f3cee10fe

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,18 @@
+language: ruby
+
+rvm:
+  - ruby-2.5
+  - ruby-2.6
+  - ruby-head
+
+allow_failures:
+    - rvm: ruby-head
+    - rvm: jruby-head
+
+env:
+  global:
+    - JRUBY_OPTS=--dev
+
+before_install: gem install bundler
+
+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
+
+# 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,56 @@
+# Skiptrace [![Build Status](https://travis-ci.org/gsamokovarov/skiptrace.svg?branch=master)](https://travis-ci.org/gsamokovarov/skiptrace)
+
+When Ruby raises an exception, it leaves a backtrace to help you figure out
+where the exception originated in. Skiptrace gives you the bindings as well.
+This can help you introspect the state of the Ruby program when 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.
+
+#### Exception#binding_locations
+
+Returns an array of `Skiptrace::Location` objects that are like [`Thread::Backtrace::Location`](https://ruby-doc.org/core-2.6.3/Thread/Backtrace/Location.html)
+but also carry a `Binding` object for that frame through the `#binding` method.
+
+#### 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.5.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,37 @@
+require 'rake/testtask'
+require "rake/clean"
+
+CLOBBER.include "pkg"
+
+require "bundler/gem_tasks"
+
+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/internal'
+  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/internal'
+    ext.source_version = '1.8'
+    ext.target_version = '1.8'
+  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          = "ed-precompiled_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/internal/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/binding_ext.rb

@@ -0,0 +1,5 @@
+class Binding
+  def source_location
+    eval '[__FILE__, __LINE__.to_i]'
+  end unless method_defined?(:source_location)
+end

data/lib/skiptrace/binding_locations.rb

@@ -0,0 +1,34 @@
+module Skiptrace
+  class BindingLocations < BasicObject
+    def initialize(locations, bindings)
+      @locations = locations
+      @bindings = bindings
+      @cached_locations = {}
+    end
+
+    private
+
+    def cached_location(location)
+      @cached_locations[location.to_s] ||= Location.new(location, guess_binding_around(location))
+    end
+
+    def guess_binding_around(location)
+      location && @bindings.find do |binding|
+        binding.source_location == [location.path, location.lineno]
+      end
+    end
+
+    def method_missing(name, *args, &block)
+      case maybe_location = @locations.public_send(name, *args, &block)
+      when ::Thread::Backtrace::Location
+        cached_location(maybe_location)
+      else
+        maybe_location
+      end
+    end
+
+    def respond_to_missing?(name, include_all = false)
+      @locations.respond_to?(name, include_all)
+    end
+  end
+end

data/lib/skiptrace/exception_ext.rb

@@ -0,0 +1,5 @@
+class Exception
+  def binding_locations
+    @binding_locations ||= Skiptrace::BindingLocations.new(backtrace_locations, bindings)
+  end
+end

data/lib/skiptrace/internal/jruby.rb

@@ -0,0 +1,7 @@
+require 'skiptrace/internal/jruby_internals'
+
+module Skiptrace
+  java_import com.gsamokovarov.skiptrace.JRubyIntegration
+
+  JRubyIntegration.setup(JRuby.runtime)
+end

data/lib/skiptrace/internal/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/location.rb

@@ -0,0 +1,34 @@
+module Skiptrace
+  class Location
+    attr_reader :binding
+
+    def initialize(location, binding)
+      @location = location
+      @binding = binding
+    end
+
+    def absolute_path
+      @location.absolute_path
+    end
+
+    def base_label
+      @location.base_label
+    end
+
+    def inspect
+      @location.inspect
+    end
+
+    def label
+      @location.label
+    end
+
+    def lineno
+      @location.lineno
+    end
+
+    def to_s
+      @location.to_s
+    end
+  end
+end

data/lib/skiptrace/version.rb

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

data/lib/skiptrace.rb

@@ -0,0 +1,19 @@
+case RUBY_ENGINE
+when 'rbx'
+  require 'skiptrace/internal/rubinius'
+when 'jruby'
+  require 'skiptrace/internal/jruby'
+when 'ruby'
+  begin
+    ruby_version = /(\d+\.\d+)/.match(::RUBY_VERSION)
+    require "skiptrace/internal/#{ruby_version}/cruby"
+  rescue LoadError
+    require 'skiptrace/internal/cruby'
+  end
+end
+
+require 'skiptrace/location'
+require 'skiptrace/binding_locations'
+require 'skiptrace/binding_ext'
+require 'skiptrace/exception_ext'
+require 'skiptrace/version'

data/test/fixtures/basic_nested_fixture.rb

@@ -0,0 +1,17 @@
+module Skiptrace
+  module BasicNestedFixture
+    extend self
+
+    def call
+      raise_an_error
+    rescue => exc
+      exc
+    end
+
+    private
+
+    def raise_an_error
+      raise
+    end
+  end
+end

data/test/fixtures/custom_error_fixture.rb

@@ -0,0 +1,11 @@
+module Skiptrace
+  module CustomErrorFixture
+    Error = Class.new(StandardError)
+
+    def self.call
+      raise Error
+    rescue => exc
+      exc
+    end
+  end
+end

data/test/fixtures/eval_nested_fixture.rb

@@ -0,0 +1,17 @@
+module Skiptrace
+  module EvalNestedFixture
+    extend self
+
+    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
+end

data/test/fixtures/flat_fixture.rb

@@ -0,0 +1,9 @@
+module Skiptrace
+  module FlatFixture
+    def self.call
+      raise
+    rescue => exc
+      exc
+    end
+  end
+end

data/test/fixtures/reraised_fixture.rb

@@ -0,0 +1,23 @@
+module Skiptrace
+  module ReraisedFixture
+    extend self
+
+    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
+end

data/test/skiptrace/current_bindings_test.rb

@@ -0,0 +1,11 @@
+require 'test_helper'
+
+module Skiptrace
+  class CurrentBindingsTest < Test
+    test 'first binding returned is the current one' do
+      _, lineno = Skiptrace.current_bindings.first.source_location
+
+      assert_equal __LINE__ - 2, lineno
+    end
+  end
+end

data/test/skiptrace/exception_test.rb

@@ -0,0 +1,67 @@
+require 'test_helper'
+
+module Skiptrace
+  class ExceptionTest < Test
+    test 'bindings returns all the bindings of where the error originated' do
+      exc = FlatFixture.()
+
+      assert_equal 4, exc.bindings.first.source_location.last
+    end
+
+    test 'bindings returns all the bindings of where a custom error originate' do
+      exc = CustomErrorFixture.()
+
+      assert_equal 6, exc.bindings.first.source_location.last
+    end
+
+    test 'bindings goes down the stack' do
+      exc = BasicNestedFixture.()
+
+      assert_equal 14, exc.bindings.first.source_location.last
+    end
+
+    test 'bindings inside of an eval' do
+      exc = EvalNestedFixture.()
+
+      assert_equal 14, exc.bindings.first.source_location.last
+    end
+
+    test "re-raising doesn't lose bindings information" do
+      exc = ReraisedFixture.()
+
+      assert_equal 6, exc.bindings.first.source_location.last
+    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
+
+    test 'binding_locations maps closely to backtrace_locations' do
+      exc = FlatFixture.()
+
+      exc.binding_locations.first.tap do |location|
+        assert_equal 4, location.lineno
+        assert_equal exc, location.binding.eval('exc')
+      end
+
+      exc.binding_locations[1].tap do |location|
+        assert_equal 54, location.lineno
+        assert_equal exc, location.binding.eval('exc')
+      end
+    end
+  end
+end

data/test/skiptrace/location_test.rb

@@ -0,0 +1,18 @@
+require 'test_helper'
+
+module Skiptrace
+  class LocationTest < Test
+    test 'behaves like Thread::Backtrace::Location' do
+      native_location = caller_locations.first
+      location = Skiptrace::Location.new(native_location, binding)
+
+      assert_equal native_location.absolute_path, location.absolute_path
+      assert_equal native_location.base_label, location.base_label
+      assert_equal native_location.inspect, location.inspect
+      assert_equal native_location.label, location.label
+      assert_equal native_location.to_s, location.to_s
+
+      assert_equal [__FILE__, __LINE__ - 8], location.binding.source_location
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,19 @@
+$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
+
+module Skiptrace
+  class Test < Minitest::Test
+    def self.test(name, &block)
+      define_method("test_#{name}", &block)
+    end
+  end
+end

metadata

@@ -0,0 +1,141 @@
+--- !ruby/object:Gem::Specification
+name: ed-precompiled_bindex
+version: !ruby/object:Gem::Version
+  version: 0.8.1
+platform: ruby
+authors:
+- Genadi Samokovarov
+bindir: bin
+cert_chain: []
+date: 1980-01-02 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'
+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/binding_ext.rb
+- lib/skiptrace/binding_locations.rb
+- lib/skiptrace/exception_ext.rb
+- lib/skiptrace/internal/jruby.rb
+- lib/skiptrace/internal/jruby_internals.jar
+- lib/skiptrace/internal/rubinius.rb
+- lib/skiptrace/location.rb
+- lib/skiptrace/version.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/skiptrace/current_bindings_test.rb
+- test/skiptrace/exception_test.rb
+- test/skiptrace/location_test.rb
+- test/test_helper.rb
+homepage: https://github.com/gsamokovarov/bindex
+licenses:
+- MIT
+metadata: {}
+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.6.7
+specification_version: 4
+summary: Bindings for your Ruby exceptions
+test_files:
+- 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/skiptrace/current_bindings_test.rb
+- test/skiptrace/exception_test.rb
+- test/skiptrace/location_test.rb
+- test/test_helper.rb