boc 0.3.2-x86-mswin32

data/ext/boc/boc.c

@@ -0,0 +1,142 @@
+#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/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.3.2"
+end

data/lib/boc.rb

@@ -0,0 +1,88 @@
+
+require 'boc.so'
+
+module Boc
+  class << self
+    #
+    # enable_basic_object is provided so that live_ast may replace
+    # instance_eval. It may have no other legitimate use.
+    #
+    [: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
+
+          impl = "#{method_name}__impl"
+          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
+
+    #
+    # Returns the binding of the caller. May only be used within an
+    # <code>enable</code>d method.
+    #
+    def value
+      raise NotEnabledError if stack.empty?
+      stack.last
+    end
+
+    def stack  #:nodoc:
+      Thread.current[:_boc_stack] ||= []
+    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"
+    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

@@ -0,0 +1,160 @@
+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 == 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 edc4739da630326a8
+          ::Kernel.eval("z", ::Boc.value)
+        end
+      end
+
+      Boc.enable_basic_object BasicObject, :edc4739da630326a8
+      z = 77
+      assert_equal 77, BasicObject.new.edc4739da630326a8
+    ensure
+      BasicObject.module_eval do
+        remove_method :edc4739da630326a8
+      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)
+  end
+end

data/test/main.rb

@@ -0,0 +1,56 @@
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+require 'minitest/unit'
+require 'minitest/autorun' unless defined? Rake
+
+require 'pp'
+require 'boc'
+
+class JLMiniTest < MiniTest::Unit::TestCase
+  def self.test_methods
+    default = super
+    onlies = default.select { |m| m =~ %r!__only\Z! }
+    if onlies.empty?
+      default
+    else
+      puts "\nNOTE: running ONLY *__only tests for #{self}"
+      onlies
+    end
+  end
+
+  def delim(char)
+    "\n" << (char*72) << "\n"
+  end
+
+  def mu_pp(obj)
+    delim("_") <<
+    obj.pretty_inspect.chomp <<
+    delim("=")
+  end
+
+  def unfixable
+    begin
+      yield
+      raise "claimed to be unfixable, but assertion succeeded"
+    rescue MiniTest::Assertion
+    end
+  end
+
+  def assert_nothing_raised
+    yield
+    assert_nil nil
+  rescue => ex
+    raise MiniTest::Assertion,
+    exception_details(ex, "Expected nothing raised, but got:")
+  end
+
+  %w[
+    empty equal in_delta in_epsilon includes instance_of
+    kind_of match nil operator respond_to same
+  ].each { |name|
+    alias_method "assert_not_#{name}", "refute_#{name}"
+  }
+end
+
+BocTest = JLMiniTest
+

data/test/readme_test.rb

@@ -0,0 +1,5 @@
+require_relative 'main'
+require_relative '../devel/levitate'
+Levitate.doc_to_test("README.rdoc",
+                     "Synopsis",
+                     "<code>Binding.of_caller</code>")

data/test/shim_test.rb

@@ -0,0 +1,26 @@
+require_relative 'main'
+
+class ShimTest < BocTest
+  def initialize(*args)
+    super
+    require 'boc/binding_of_caller'
+  end
+
+  class A
+    def f
+      Binding.of_caller do |bind|
+        eval("x", bind) + 11
+      end
+    end
+    
+    def g
+      x = 33
+      f
+    end
+  end
+
+  def test_old_style
+    Boc.enable A, :f
+    assert_equal 44, A.new.g
+  end
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: boc
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.3.2
+platform: x86-mswin32
+authors: 
+- James M. Lawrence
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-16 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake-compiler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.7.6
+  type: :development
+  version_requirements: *id001
+description: "Binding of caller: obtain a caller's binding."
+email: 
+- quixoticsycophant@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- CHANGES.rdoc
+files: 
+- CHANGES.rdoc
+- 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
+- MANIFEST
+- lib/boc.so
+has_rdoc: true
+homepage: http://quix.github.com/boc
+licenses: []
+
+post_install_message: U got dat binary versionation of this gemination!
+rdoc_options: 
+- --main
+- README.rdoc
+- --title
+- "boc: Binding of caller"
+- --exclude
+- lib/boc/binding_of_caller.rb
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Binding of caller.
+test_files: []
+