binding_of_caller 0.6.3-universal-rubinius

data/.gitignore

@@ -0,0 +1,7 @@
+Makefile
+*.so
+*.o
+*.def
+doc/
+pkg/
+.yardoc/

data/.yardopts

@@ -0,0 +1 @@
+--markup markdown

data/LICENSE

@@ -0,0 +1,25 @@
+License
+-------
+
+(The MIT License) 
+
+Copyright (c) 2011 John Mair (banisterfiend)
+
+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,86 @@
+binding_of_caller
+===========
+
+(C) John Mair (banisterfiend) 2011
+
+_Retrieve the binding of a method's caller in MRI 1.9.2_
+
+The `binding_of_caller` gem provides the `Binding#of_caller` method.
+
+Using `binding_of_caller` we can grab bindings from higher up the call
+stack and evaluate code in that context. Allows access to bindings arbitrarily far up the
+call stack, not limited to just the immediate caller.
+
+**Recommended for use only in debugging situations. Do not use this in production apps.**
+
+**Only works in MRI Ruby 1.9.2 and 1.9.3**
+
+* Install the [gem](https://rubygems.org/gems/binding_of_caller): `gem install binding_of_caller`
+* See the [source code](http://github.com/banister/binding_of_caller)
+
+Example: Modifying a local inside the caller of a caller
+--------
+
+```ruby
+def a
+  var = 10
+  b
+  puts var
+end
+
+def b
+  c
+end
+
+def c
+  binding.of_caller(2).eval('var = :hello')
+end
+
+a()
+
+# OUTPUT
+# => hello
+```
+
+Spinoff project
+-------
+
+This project is a spinoff from the [Pry REPL project.](http://pry.github.com)
+
+Features and limitations
+-------------------------
+
+* Only works with MRI 1.9.2 and 1.9.3
+* Does not work in 1.8.7, but there is a well known (continuation-based) hack to get a `Binding#of_caller` there.
+
+Contact
+-------
+
+Problems or questions contact me at [github](http://github.com/banister)
+
+
+License
+-------
+
+(The MIT License)
+
+Copyright (c) 2011 (John Mair)
+
+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/Rakefile

@@ -0,0 +1,112 @@
+dlext = Config::CONFIG['DLEXT']
+direc = File.dirname(__FILE__)
+
+$:.unshift 'lib'
+
+PROJECT_NAME = "binding_of_caller"
+
+require 'rake/clean'
+require 'rubygems/package_task'
+
+require "#{PROJECT_NAME}/version"
+
+CLOBBER.include("**/*.#{dlext}", "**/*~", "**/*#*", "**/*.log", "**/*.o")
+CLEAN.include("ext/**/*.#{dlext}", "ext/**/*.log", "ext/**/*.o",
+              "ext/**/*~", "ext/**/*#*", "ext/**/*.obj", "**/*#*", "**/*#*.*",
+              "ext/**/*.def", "ext/**/*.pdb", "**/*_flymake*.*", "**/*_flymake", "**/*.rbc")
+
+def apply_spec_defaults(s)
+  s.name = PROJECT_NAME
+  s.summary = "Retrieve the binding of a method's caller. Can also retrieve bindings even further up the stack. Currently only works for MRI 1.9.2+"
+  s.version = BindingOfCaller::VERSION
+  s.date = Time.now.strftime '%Y-%m-%d'
+  s.author = "John Mair (banisterfiend)"
+  s.email = 'jrmair@gmail.com'
+  s.description = s.summary
+  s.require_path = 'lib'
+  s.add_development_dependency("bacon","~>1.1")
+  s.homepage = "http://github.com/banister/binding_of_caller"
+  s.has_rdoc = 'yard'
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- test/*`.split("\n")
+end
+
+desc "Run tests"
+task :test do
+  sh "bacon -Itest -rubygems test.rb -q"
+end
+
+task :pry do
+  puts "loading binding_of_caller into pry"
+  sh "pry -r ./lib/binding_of_caller"
+end
+
+desc "generate gemspec"
+task :gemspec => "ruby:gemspec"
+
+namespace :ruby do
+  spec = Gem::Specification.new do |s|
+    apply_spec_defaults(s)
+    s.platform = Gem::Platform::RUBY
+    s.extensions = ["ext/#{PROJECT_NAME}/extconf.rb"]
+  end
+
+  Gem::PackageTask.new(spec) do |pkg|
+    pkg.need_zip = false
+    pkg.need_tar = false
+  end
+
+  desc  "Generate gemspec file"
+  task :gemspec do
+    File.open("#{spec.name}.gemspec", "w") do |f|
+      f << spec.to_ruby
+    end
+  end
+end
+
+namespace :rbx do
+  spec = Gem::Specification.new do |s|
+    apply_spec_defaults(s)
+    s.platform = Gem::Platform.new(["universal", "rubinius"])
+  end
+
+  Gem::PackageTask.new(spec) do |pkg|
+    pkg.need_zip = false
+    pkg.need_tar = false
+  end
+end
+
+desc "build the binaries"
+task :compile do
+  chdir "./ext/#{PROJECT_NAME}/" do
+    sh "ruby extconf.rb"
+    sh "make clean"
+    sh "make"
+    sh "cp *.#{dlext} ../../lib/"
+  end
+end
+
+desc "reinstall gem"
+task :reinstall => :gems do
+  sh "gem uninstall binding_of_caller" rescue nil
+  sh "gem install #{direc}/pkg/#{PROJECT_NAME}-#{BindingOfCaller::VERSION}.gem"
+end
+
+desc "build all platform gems at once"
+task :gems => [:clean, :rmgems, "ruby:gem", "rbx:gem"]
+
+task :gem => [:gems]
+
+task :rbxgem => "rbx:gem"
+
+desc "remove all platform gems"
+task :rmgems => ["ruby:clobber_package"]
+
+desc "build and push latest gems"
+task :pushgems => :gems do
+  chdir("./pkg") do
+    Dir["*.gem"].each do |gemfile|
+      sh "gem push #{gemfile}"
+    end
+  end
+end

data/examples/example.rb

@@ -0,0 +1,41 @@
+unless Object.const_defined? :BindingOfCaller
+  $:.unshift File.expand_path '../../lib', __FILE__
+  require 'binding_of_caller'
+  require 'binding_of_caller/version'
+end
+
+outer = 10
+
+class Z
+  def z
+    u = 10
+    A.new.a
+  end
+end
+
+class A
+  def a
+    y = 10
+    B.new.b
+  end
+end
+
+class B
+  def b
+    x = 10
+    puts binding.of_caller(0).eval('local_variables')
+    puts binding.of_caller(1).eval('local_variables')
+    puts binding.of_caller(2).eval('local_variables')
+    puts binding.of_caller(3).eval('local_variables')
+    puts binding.of_caller(400).eval('local_variables')
+  end
+end
+
+Z.new.z
+
+# output:
+# => x
+# => y
+# => u
+# => outer
+# Exception

data/ext/binding_of_caller/binding_of_caller.c

@@ -0,0 +1,220 @@
+/* (c) 2011 John Mair (banisterfiend), MIT license */
+
+#include <ruby.h>
+#include "vm_core.h"
+#include "gc.h"
+
+typedef enum { false, true } bool;
+
+static VALUE
+string2sym(const char * string)
+{
+  return ID2SYM(rb_intern(string));
+}
+
+static inline const rb_data_type_t *
+threadptr_data_type(void)
+{
+  static const rb_data_type_t *thread_data_type;
+  if (!thread_data_type) {
+    VALUE current_thread = rb_thread_current();
+    thread_data_type = RTYPEDDATA_TYPE(current_thread);
+  }
+  return thread_data_type;
+}
+
+#define ruby_thread_data_type *threadptr_data_type()
+
+#define ruby_current_thread ((rb_thread_t *)RTYPEDDATA_DATA(rb_thread_current()))
+
+static size_t
+binding_memsize(const void *ptr)
+{
+  return ptr ? sizeof(rb_binding_t) : 0;
+}
+
+static void
+binding_free(void *ptr)
+{
+  rb_binding_t *bind;
+  RUBY_FREE_ENTER("binding");
+  if (ptr) {
+    bind = ptr;
+    ruby_xfree(ptr);
+  }
+  RUBY_FREE_LEAVE("binding");
+}
+
+static void
+binding_mark(void *ptr)
+{
+  rb_binding_t *bind;
+  RUBY_MARK_ENTER("binding");
+  if (ptr) {
+    bind = ptr;
+    RUBY_MARK_UNLESS_NULL(bind->env);
+
+#ifdef RUBY_192
+    RUBY_MARK_UNLESS_NULL(bind->filename);
+#endif
+
+  }
+  RUBY_MARK_LEAVE("binding");
+}
+
+static const rb_data_type_t binding_data_type = {
+  "binding",
+  binding_mark,
+  binding_free,
+  binding_memsize,
+};
+
+static VALUE
+binding_alloc(VALUE klass)
+{
+  VALUE obj;
+  rb_binding_t *bind;
+  obj = TypedData_Make_Struct(klass, rb_binding_t, &binding_data_type, bind);
+  return obj;
+}
+
+static bool valid_frame_p(rb_control_frame_t * cfp, rb_control_frame_t * limit_cfp) {
+  return cfp->iseq && !NIL_P(cfp->self);
+}
+
+static rb_control_frame_t * find_valid_frame(rb_control_frame_t * cfp, rb_control_frame_t * limit_cfp) {
+  while (cfp < limit_cfp) {
+    cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
+
+    if (cfp >= limit_cfp)
+      return NULL;
+
+    if (valid_frame_p(cfp, limit_cfp))
+      return cfp;
+  }
+
+  // beyond end of stack
+  return NULL;
+}
+
+static VALUE
+frametype_name(VALUE flag)
+{
+  switch (flag & VM_FRAME_MAGIC_MASK) {
+  case VM_FRAME_MAGIC_METHOD: return string2sym("method");
+  case VM_FRAME_MAGIC_BLOCK:  return string2sym("block");
+  case VM_FRAME_MAGIC_CLASS:  return string2sym("class");
+  case VM_FRAME_MAGIC_TOP:    return string2sym("top");
+  case VM_FRAME_MAGIC_FINISH: return string2sym("finish");
+  case VM_FRAME_MAGIC_CFUNC:  return string2sym("cfunc");
+  case VM_FRAME_MAGIC_PROC:   return string2sym("proc");
+  case VM_FRAME_MAGIC_IFUNC:  return string2sym("ifunc");
+  case VM_FRAME_MAGIC_EVAL:   return string2sym("eval");
+  case VM_FRAME_MAGIC_LAMBDA: return string2sym("lambda");
+  default:
+    rb_raise(rb_eRuntimeError, "Unknown frame type! got flag: %d", FIX2INT(flag));
+  }
+}
+
+static VALUE binding_of_caller(VALUE self, VALUE rb_level)
+{
+  rb_thread_t *th;
+  GetThreadPtr(rb_thread_current(), th);
+
+  rb_control_frame_t *cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(th->cfp);
+  rb_control_frame_t *limit_cfp = (void *)(th->stack + th->stack_size);
+  int level = FIX2INT(rb_level);
+
+  // attempt to locate the nth parent control frame
+  for (int i = 0; i < level; i++) {
+    cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
+
+    if (cfp >= limit_cfp)
+      rb_raise(rb_eRuntimeError, "Invalid frame, gone beyond end of stack!");
+
+    // skip invalid frames
+    if (!valid_frame_p(cfp, limit_cfp))
+      cfp = find_valid_frame(cfp, limit_cfp);
+  }
+
+  VALUE bindval = binding_alloc(rb_cBinding);
+  rb_binding_t *bind;
+
+  if (cfp == 0)
+    rb_raise(rb_eRuntimeError, "Can't create Binding Object on top of Fiber.");
+
+  GetBindingPtr(bindval, bind);
+  bind->env = rb_vm_make_env_object(th, cfp);
+  bind->filename = cfp->iseq->filename;
+  bind->line_no = rb_vm_get_sourceline(cfp);
+
+  rb_iv_set(bindval, "@frame_type", frametype_name(cfp->flag));
+  rb_iv_set(bindval, "@frame_description", cfp->iseq->name);
+
+  return bindval;
+}
+
+static VALUE
+frame_type(VALUE self)
+{
+  return rb_iv_get(self, "@frame_type");
+}
+
+static VALUE
+frame_description(VALUE self)
+{
+  return rb_iv_get(self, "@frame_description");
+}
+
+static VALUE frame_count(VALUE self)
+{
+  rb_thread_t *th;
+  GetThreadPtr(rb_thread_current(), th);
+
+  rb_control_frame_t *cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(th->cfp);
+  rb_control_frame_t *limit_cfp = (void *)(th->stack + th->stack_size);
+
+  int i = 1;
+  while (cfp < limit_cfp) {
+    cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
+
+    if (cfp >= limit_cfp)
+      return INT2FIX(i);
+
+    // skip invalid frames
+    if (!valid_frame_p(cfp, limit_cfp))
+      cfp = find_valid_frame(cfp, limit_cfp);
+
+    if (!cfp)
+      break;
+
+    i++;
+  }
+
+  return INT2FIX(i);
+}
+
+static VALUE
+callers(VALUE self)
+{
+  VALUE ary = rb_ary_new();
+
+  for (int i = 0; i < FIX2INT(frame_count(self)); i++)
+    rb_ary_push(ary, binding_of_caller(self, INT2FIX(i)));
+
+  return ary;
+}
+
+void
+Init_binding_of_caller()
+{
+  VALUE mBindingOfCaller = rb_define_module("BindingOfCaller");
+
+  rb_define_method(mBindingOfCaller, "of_caller", binding_of_caller, 1);
+  rb_define_method(mBindingOfCaller, "frame_count", frame_count, 0);
+  rb_define_method(mBindingOfCaller, "frame_type", frame_type, 0);
+  rb_define_method(mBindingOfCaller, "frame_description", frame_description, 0);
+  rb_define_method(mBindingOfCaller, "callers", callers, 0);
+  rb_include_module(rb_cBinding, mBindingOfCaller);
+}
+