boc 0.3.2-x86-mswin32 → 0.4.2-x86-mswin32

data/ext/boc/boc.c

@@ -15,8 +15,7 @@ struct dispatch_args
     ID method_id ;
 } ;
 
-static
-VALUE
+static VALUE
 begin_section( VALUE data )
 {
     struct dispatch_args* dargs = (struct dispatch_args*)data ;
@@ -28,8 +27,7 @@ begin_section( VALUE data )
         dargs->argv) ;
 }
 
-static
-VALUE
+static VALUE
 ensure_section( VALUE unused )
 {
     rb_ary_pop(
@@ -70,8 +68,7 @@ dispatch_common( VALUE method_sym, int argc, VALUE *argv, VALUE self )
         Qnil) ;
 }
 
-static
-VALUE
+static VALUE
 dispatch_normal( int argc, VALUE *argv, VALUE self )
 {
     return dispatch_common(
@@ -84,8 +81,7 @@ dispatch_normal( int argc, VALUE *argv, VALUE self )
         self) ;
 }
 
-static
-VALUE
+static VALUE
 dispatch_basic_object(int argc, VALUE *argv, VALUE self)
 {
     return dispatch_common(
@@ -95,8 +91,7 @@ dispatch_basic_object(int argc, VALUE *argv, VALUE self)
         self) ;
 }
 
-static
-VALUE
+static VALUE
 enable_ext( VALUE self, VALUE klass, VALUE method_sym )
 {
     rb_define_method(
@@ -108,8 +103,7 @@ enable_ext( VALUE self, VALUE klass, VALUE method_sym )
     return Qnil ;
 }
 
-static
-VALUE
+static VALUE
 enable_basic_object_ext( VALUE self, VALUE klass, VALUE method_sym )
 {
     basic_object_method_sym = method_sym ;

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/version.rb

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

data/lib/boc.rb

@@ -1,30 +1,65 @@
-
-require 'boc.so'
+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
     #
-    # enable_basic_object is provided so that live_ast may replace
-    # instance_eval. It may have no other legitimate use.
+    # 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 is saved so that live_ast may replace it.
-        # Boc does not touch module_eval.
-        #
         MODULE_EVAL.bind(klass).call do
-          visibility =
-            if public_instance_methods.include?(method_name)
-              :public
-            elsif protected_instance_methods.include?(method_name)
-              :protected
-            else
-              :private
-            end
+          visibility = Boc.visibility klass, method_name
 
           impl = "#{method_name}__impl"
-          alias_method impl, method_name
+          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
@@ -33,56 +68,41 @@ module Boc
       end
     end
 
+    def stack  #:nodoc:
+      Thread.current[:_boc_stack] ||= []
+    end
+
     #
-    # Returns the binding of the caller. May only be used within an
-    # <code>enable</code>d method.
+    # squelch alias warnings
     #
-    def value
-      raise NotEnabledError if stack.empty?
-      stack.last
+    def no_warn  #:nodoc:
+      prev = $VERBOSE
+      $VERBOSE = nil
+      begin
+        yield
+      ensure
+        $VERBOSE = prev
+      end
     end
-
-    def stack  #:nodoc:
-      Thread.current[:_boc_stack] ||= []
+    
+    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
-  end
 
-  #
-  # Boc.value was called outside of an <code>enable</code>d method.
-  #
-  class NotEnabledError < StandardError
-    def message  #:nodoc:
-      "Boc.value was called outside of an enabled method"
+    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 is saved so that live_ast may replace it.
-  # Boc does not touch module_eval.
-  #
   MODULE_EVAL = Module.instance_method(:module_eval)  #:nodoc:
-
-  #
-  # :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
-  #
 end

data/test/basic_test.rb

@@ -93,11 +93,13 @@ class BasicTest < BocTest
 
   module R
     def self.factorial_of_x
-      x = eval("x", Boc.value) - if caller.grep(/#{__method__}/).size == 1
-                                   0
-                                 else
-                                   1
-                                 end
+      x = eval("x", Boc.value) -
+        if caller.grep(/#{__method__}/).size == (RUBY_ENGINE == "jruby" ? 0 : 1)
+          0
+        else
+          1
+        end
+      
       if x == 0
         1
       else
@@ -122,17 +124,17 @@ class BasicTest < BocTest
   def test_basic_object
     begin
       BasicObject.module_eval do
-        def edc4739da630326a8
+        def zoofoo
           ::Kernel.eval("z", ::Boc.value)
         end
       end
 
-      Boc.enable_basic_object BasicObject, :edc4739da630326a8
+      Boc.enable_basic_object BasicObject, :zoofoo
       z = 77
-      assert_equal 77, BasicObject.new.edc4739da630326a8
+      assert_equal 77, BasicObject.new.zoofoo
     ensure
       BasicObject.module_eval do
-        remove_method :edc4739da630326a8
+        remove_method :zoofoo
       end
     end
   end
@@ -156,5 +158,52 @@ class BasicTest < BocTest
     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

data/test/jruby_trial.rb

@@ -0,0 +1,20 @@
+require_relative 'main'
+
+class JrubyTest < BocTest
+  require 'jruby'
+  prop = "jruby.astInspector.enabled"
+  puts("#{prop}: " + java.lang.System.get_properties[prop].inspect)
+
+  class A
+    def f
+      eval("x", Boc.value)
+    end
+  end
+
+  def test_explosion
+    #p { }
+    Boc.enable A, :f
+    x = 33
+    assert_equal 33, A.new.f
+  end
+end if RUBY_ENGINE == "jruby"

data/test/readme_test.rb

@@ -1,5 +1,9 @@
 require_relative 'main'
 require_relative '../devel/levitate'
-Levitate.doc_to_test("README.rdoc",
-                     "Synopsis",
-                     "<code>Binding.of_caller</code>")
+
+if RUBY_ENGINE == "ruby"
+  Levitate.doc_to_test(
+    "README.rdoc",
+    "Synopsis",
+    "<code>Binding.of_caller</code>")
+end

metadata

@@ -2,7 +2,7 @@
 name: boc
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.3.2
+  version: 0.4.2
 platform: x86-mswin32
 authors: 
 - James M. Lawrence
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-16 00:00:00 -04:00
+date: 2011-03-21 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -41,20 +41,21 @@ files:
 - devel/levitate.rb
 - ext/boc/boc.c
 - ext/boc/extconf.rb
+- jext/boc/BocService.java
 - lib/boc.rb
 - lib/boc/binding_of_caller.rb
 - lib/boc/version.rb
 - test/basic_test.rb
+- test/jruby_trial.rb
 - test/main.rb
 - test/readme_test.rb
 - test/shim_test.rb
-- MANIFEST
-- lib/boc.so
+- lib/boc/boc.so
 has_rdoc: true
 homepage: http://quix.github.com/boc
 licenses: []
 
-post_install_message: U got dat binary versionation of this gemination!
+post_install_message: 
 rdoc_options: 
 - --main
 - README.rdoc

data/MANIFEST

@@ -1,14 +0,0 @@
-CHANGES.rdoc
-MANIFEST
-README.rdoc
-Rakefile
-devel/levitate.rb
-ext/boc/boc.c
-ext/boc/extconf.rb
-lib/boc.rb
-lib/boc/binding_of_caller.rb
-lib/boc/version.rb
-test/basic_test.rb
-test/main.rb
-test/readme_test.rb
-test/shim_test.rb