boc 0.4.2-java

data/ext/boc/boc.c

@@ -0,0 +1,136 @@
+#include "ruby.h"
+
+VALUE
+rb_funcall_passing_block(VALUE recv, ID mid, int argc, const VALUE *argv) ;
+
+static VALUE cBoc ;
+
+static VALUE basic_object_method_sym ;
+
+struct dispatch_args
+{
+    int argc ;
+    VALUE* argv ;
+    VALUE self ;
+    ID method_id ;
+} ;
+
+static VALUE
+begin_section( VALUE data )
+{
+    struct dispatch_args* dargs = (struct dispatch_args*)data ;
+
+    return rb_funcall_passing_block(
+        dargs->self,
+        dargs->method_id,
+        dargs->argc,
+        dargs->argv) ;
+}
+
+static VALUE
+ensure_section( VALUE unused )
+{
+    rb_ary_pop(
+        rb_funcall(
+            cBoc,
+            rb_intern("stack"),
+            0)) ;
+
+    return Qnil ;
+}
+
+static VALUE
+dispatch_common( VALUE method_sym, int argc, VALUE *argv, VALUE self )
+{
+    struct dispatch_args dargs ;
+
+    dargs.argc = argc ;
+    dargs.argv = argv ;
+    dargs.self = self ;
+
+    dargs.method_id = 
+        rb_to_id(
+            rb_str_plus(
+                 rb_sym_to_s(method_sym),
+                 rb_str_new2("__impl"))) ;
+
+    rb_ary_push(
+        rb_funcall(
+            cBoc,
+            rb_intern("stack"),
+            0),
+        rb_binding_new()) ;
+
+    return rb_ensure(
+        begin_section,
+        (VALUE)&dargs,
+        ensure_section,
+        Qnil) ;
+}
+
+static VALUE
+dispatch_normal( int argc, VALUE *argv, VALUE self )
+{
+    return dispatch_common(
+        rb_funcall(
+            self,
+            rb_intern("__method__"),
+            0),
+        argc,
+        argv,
+        self) ;
+}
+
+static VALUE
+dispatch_basic_object(int argc, VALUE *argv, VALUE self)
+{
+    return dispatch_common(
+        basic_object_method_sym,
+        argc,
+        argv,
+        self) ;
+}
+
+static VALUE
+enable_ext( VALUE self, VALUE klass, VALUE method_sym )
+{
+    rb_define_method(
+        klass,
+        RSTRING_PTR(rb_sym_to_s(method_sym)),
+        dispatch_normal,
+        -1) ;
+
+    return Qnil ;
+}
+
+static VALUE
+enable_basic_object_ext( VALUE self, VALUE klass, VALUE method_sym )
+{
+    basic_object_method_sym = method_sym ;
+        
+    rb_define_method(
+        klass,
+        RSTRING_PTR(rb_sym_to_s(method_sym)),
+        dispatch_basic_object,
+        -1) ;
+
+    return Qnil ;
+}
+
+void
+Init_boc()
+{
+    cBoc = rb_define_module("Boc") ;
+
+    rb_define_singleton_method(
+        cBoc,
+        "enable_ext",
+        enable_ext,
+        2) ;
+
+    rb_define_singleton_method(
+        cBoc,
+        "enable_basic_object_ext",
+        enable_basic_object_ext,
+        2) ;
+}

data/ext/boc/extconf.rb

@@ -0,0 +1,2 @@
+require 'mkmf'
+create_makefile('boc')

data/jext/boc/BocService.java

@@ -0,0 +1,111 @@
+package boc ;
+
+import org.jruby.Ruby ;
+import org.jruby.RubyModule ;
+import org.jruby.RubyBinding ;
+import org.jruby.RubySymbol ;
+import org.jruby.RubyClass ;
+import org.jruby.anno.JRubyMethod ;
+import org.jruby.exceptions.RaiseException ;
+import org.jruby.runtime.Arity ;
+import org.jruby.runtime.Block ;
+import org.jruby.runtime.ThreadContext ;
+import org.jruby.runtime.callback.Callback ;
+import org.jruby.runtime.builtin.IRubyObject ;
+import org.jruby.runtime.load.BasicLibraryService ;
+
+public class BocService implements BasicLibraryService
+{
+    static RubyModule s_boc ;
+    static RubyClass s_removed_error ;
+
+    public boolean basicLoad( Ruby ruby )
+    {
+        s_boc = ruby.defineModule("Boc") ;
+
+        s_boc.getSingletonClass().
+            defineAnnotatedMethods(SingletonMethods.class) ;
+
+        s_removed_error = ruby.defineClassUnder(
+            "InformationRemovedError",
+            ruby.getException(),
+            ruby.getException().getAllocator(),
+            s_boc) ;
+
+        return true ;
+    }
+
+    public static class SingletonMethods
+    {
+        @JRubyMethod( name = "enable_ext", alias = {"enable_basic_object_ext"} )
+        public static IRubyObject
+        s_enable_ext( IRubyObject recv, IRubyObject klass, IRubyObject sym )
+        {
+            String method_name = ((RubySymbol)sym).toString() ;
+
+            ((RubyModule)klass).defineMethod(
+                method_name,
+                new Dispatcher(method_name + "__impl")) ;
+
+            return recv.getRuntime().getNil() ;
+        }
+    }
+
+    public static class Dispatcher implements Callback
+    {
+        String m_impl ;
+
+        public Dispatcher( String impl )
+        {
+            m_impl = impl ;
+        }
+        
+        public IRubyObject
+        execute( IRubyObject recv, IRubyObject[] args, Block block )
+        {
+            Ruby ruby = recv.getRuntime() ;
+            ThreadContext context = ruby.getCurrentContext() ;
+            IRubyObject stack = s_boc.callMethod(context, "stack") ;
+
+            stack.callMethod(
+                context,
+                "push", 
+                RubyBinding.newBinding(ruby, context.previousBinding())) ;
+
+            try
+            {
+                return recv.callMethod(context, m_impl, args, block) ;
+            }
+            catch( java.lang.NullPointerException e )
+            {
+                throw new RaiseException(
+                    ruby, s_removed_error, s_error_msg, true) ;
+            }
+            finally
+            {
+                stack.callMethod(context, "pop") ;
+            }
+        }
+
+        public Arity getArity()
+        {
+            return Arity.OPTIONAL ;
+        }
+    }
+
+    static String s_error_msg = "\n" +
+    "\n" +
+    "__________________________________________________________________\n" +
+    "Boc (binding of caller) failed because JRuby removed the necessary\n" +
+    "information. To prevent this from happening, pass the following\n" +
+    "command-line flag to jruby:\n" +
+    "\n" +
+    "    -J-Djruby.astInspector.enabled=false\n" +
+    "\n" +
+    "Alternatively, place a do-nothing block somewhere in the caller:\n" +
+    "\n" +
+    "    p { }\n" +
+    "    # ...your code...\n" +
+    "\n" +
+    "==================================================================\n" ;
+}

data/lib/boc.rb

@@ -0,0 +1,108 @@
+require 'boc/boc'
+
+module Boc
+  #
+  # :singleton-method: enable
+  # :call-seq: enable(klass, method_name)
+  #
+  # Enable <code>Boc.value</code> for the given instance method.
+  #
+  #   class A
+  #     def f
+  #       p eval("x", Boc.value)
+  #     end
+  #     
+  #     def self.g
+  #       p eval("x", Boc.value)
+  #     end
+  #   end
+  #
+  #   Boc.enable A, :f
+  #   Boc.enable A.singleton_class, :g
+  #
+  #   x = 33
+  #   A.new.f  # => 33
+  #   A.g  # => 33
+  #
+
+  #
+  # <code>Boc.value</code> was called outside of an
+  # <code>enable</code>d method.
+  #
+  class NotEnabledError < StandardError
+  end
+
+  #
+  # The method given to <code>Boc.enable</code> appears to have been
+  # already enabled.
+  #
+  class AlreadyEnabledError < StandardError
+  end
+
+  class << self
+    #
+    # Returns the binding of the caller. May only be used within an
+    # <code>enable</code>d method.
+    #
+    def value
+      if stack.empty?
+        raise NotEnabledError, "Boc.value called outside of an enabled method"
+      end
+      stack.last
+    end
+
+    [:enable, :enable_basic_object].each do |def_method|
+      define_method def_method do |klass, method_name|
+        MODULE_EVAL.bind(klass).call do
+          visibility = Boc.visibility klass, method_name
+
+          impl = "#{method_name}__impl"
+          Boc.check_enabled klass, method_name, impl
+
+          Boc.no_warn { alias_method impl, method_name }
+          Boc.send "#{def_method}_ext", klass, method_name
+          
+          send visibility, method_name
+          public impl  # needs to work with rb_funcall_passing_block
+        end
+      end
+    end
+
+    def stack  #:nodoc:
+      Thread.current[:_boc_stack] ||= []
+    end
+
+    #
+    # squelch alias warnings
+    #
+    def no_warn  #:nodoc:
+      prev = $VERBOSE
+      $VERBOSE = nil
+      begin
+        yield
+      ensure
+        $VERBOSE = prev
+      end
+    end
+    
+    def visibility(klass, method_name)  #:nodoc:
+      if klass.public_instance_methods.include?(method_name)
+        :public
+      elsif klass.protected_instance_methods.include?(method_name)
+        :protected
+      else
+        :private
+      end
+    end
+
+    def check_enabled(klass, method_name, impl)  #:nodoc:
+      if klass.method_defined?(impl) or klass.private_method_defined?(impl)
+        raise AlreadyEnabledError,
+        "Boc.enable: refusing to overwrite `#{impl}' -- " <<
+          "method `#{method_name}' appears to be already enabled"
+      end
+    end
+  end
+
+  MODULE_EVAL = Module.instance_method(:module_eval)  #:nodoc:
+end

data/lib/boc/binding_of_caller.rb

@@ -0,0 +1,11 @@
+#
+# compatibility with the old-style Binding.of_caller from 1.8
+# 
+
+require 'boc'
+
+class Binding
+  def self.of_caller
+    yield Boc.value
+  end
+end

data/lib/boc/version.rb

@@ -0,0 +1,3 @@
+module Boc
+  VERSION = "0.4.2"
+end

data/test/basic_test.rb

@@ -0,0 +1,209 @@
+require_relative 'main'
+
+class BasicTest < BocTest
+  MEMO = {}
+
+  def setup
+    MEMO.clear
+  end
+
+  class A
+    def f(y, z)
+      MEMO[:x] = eval("x", Boc.value)
+      MEMO[:y] = y
+      MEMO[:z] = z
+      66
+    end
+    
+    def g
+      x = 33
+      f(44, 55)
+    end
+  end
+
+  def test_basic
+    assert_raises Boc::NotEnabledError do
+      Boc.value
+    end
+
+    Boc.enable A, :f
+
+    assert_nil MEMO[:x]
+    assert_nil MEMO[:y]
+    assert_nil MEMO[:z]
+
+    assert_equal 66, A.new.g
+
+    assert_equal 33, MEMO[:x]
+    assert_equal 44, MEMO[:y]
+    assert_equal 55, MEMO[:z]
+
+    assert_raises Boc::NotEnabledError do
+      Boc.value
+    end
+  end
+
+  class B
+    def foo(*args, &block)
+      MEMO[:args] = args
+      MEMO[:block] = block
+      eval("u", Boc.value) ;
+    end
+    
+    def bar
+      u = 66
+      foo(77, 88) { |s| s + "zzz" }
+    end
+  end
+
+  def test_explicit_block
+    Boc.enable B, :foo
+
+    assert_nil MEMO[:args]
+    assert_nil MEMO[:block]
+
+    assert_equal 66, B.new.bar
+    assert_equal [77, 88], MEMO[:args]
+    assert_equal "zoozzz", MEMO[:block].call("zoo")
+  end
+
+  class C
+    def foo(*args)
+      MEMO[:args] = args
+      MEMO[:yield_result] = yield "moo"
+      eval("u", Boc.value) ;
+    end
+    
+    def bar
+      u = 66
+      foo(77, 88) { |s| s + "zzz" }
+    end
+  end
+
+  def test_implicit_block
+    Boc.enable C, :foo
+
+    assert_nil MEMO[:args]
+    assert_nil MEMO[:yield_result]
+
+    assert_equal 66, C.new.bar
+    assert_equal [77, 88], MEMO[:args]
+    assert_equal "moozzz", MEMO[:yield_result]
+  end
+
+  module R
+    def self.factorial_of_x
+      x = eval("x", Boc.value) -
+        if caller.grep(/#{__method__}/).size == (RUBY_ENGINE == "jruby" ? 0 : 1)
+          0
+        else
+          1
+        end
+      
+      if x == 0
+        1
+      else
+        x*factorial_of_x
+      end
+    end
+  end
+
+  def test_recursive
+    Boc.enable R.singleton_class, :factorial_of_x
+
+    x = 5
+    assert_equal 120, R.factorial_of_x
+    x = 4
+    assert_equal 24, R.factorial_of_x
+    x = 1
+    assert_equal 1, R.factorial_of_x
+    x = 0
+    assert_equal 1, R.factorial_of_x
+  end
+
+  def test_basic_object
+    begin
+      BasicObject.module_eval do
+        def zoofoo
+          ::Kernel.eval("z", ::Boc.value)
+        end
+      end
+
+      Boc.enable_basic_object BasicObject, :zoofoo
+      z = 77
+      assert_equal 77, BasicObject.new.zoofoo
+    ensure
+      BasicObject.module_eval do
+        remove_method :zoofoo
+      end
+    end
+  end
+
+  class D
+    public
+    def f ; end
+    
+    protected
+    def g ; end
+
+    private
+    def h ; end
+  end
+
+  def test_visibility
+    Boc.enable D, :f
+    Boc.enable D, :g
+    Boc.enable D, :h
+
+    assert D.public_instance_methods.include?(:f)
+    assert D.protected_instance_methods.include?(:g)
+    assert D.private_instance_methods.include?(:h)
+
+    D.new.f
+    D.new.instance_eval { g }
+    D.new.instance_eval { h }
+  end
+
+  class K
+    def f(bind)
+      eval("self", bind)
+    end
+
+    def self.g
+      self.new.f(binding)
+    end
+  end
+
+  def test_self_control
+    Boc.enable K, :f
+    assert_equal K, K.g
+  end
+
+  class L
+    def f
+      eval("self", Boc.value)
+    end
+
+    def self.g
+      self.new.f
+    end
+  end
+
+  def test_self
+    Boc.enable L, :f
+    assert_equal L, L.g
+  end
+
+  class K
+    def k
+    end
+  end
+
+  def test_double_enable
+    Boc.enable K, :k
+    error = assert_raises Boc::AlreadyEnabledError do
+      Boc.enable K, :k
+    end
+    assert_match(/method `k'.*already/, error.message)
+  end
+end