force_bind 0.1.0 → 0.1.1

data/README

@@ -3,32 +3,36 @@
 Adds UnboundMethod#force_bind to bind an unbound method to class (or any object of any type).
 It basically bypasses the argument type checking that #bind has.
 
+== Requirements
+
+* Ruby 1.9.1 or greater (does not work in Ruby 1.8.x)
+
 == Example
 
 Bind an instance method to its class (making it act like a class method):
 
-    class Foo
-      def bar
-        puts "I'm inside #{self}"
-      end
+  class Foo
+    def bar
+      puts "I'm inside #{self}"
     end
-    
-    Foo.new.bar
-    #=> "I'm inside #<Foo:0x123456>"
-    
-    meth = Foo.instance_method(:bar).force_bind(Foo)
-    meth.call
-    #=> "I'm inside Foo"
+  end
+  
+  Foo.new.bar
+  #=> "I'm inside #<Foo:0x123456>"
+  
+  meth = Foo.instance_method(:bar).force_bind(Foo)
+  meth.call
+  #=> "I'm inside Foo"
     
 You can also use this to rebind the instance method of any object to any
 other object:
 
-    class A
-      def foo; self end
-    end
-    
-    class B; end
-    
-    meth = A.instance_method(:foo).force_bind(B.new)
-    meth.call
-    #=> #<B:0x123456>
+  class A
+    def foo; self end
+  end
+  
+  class B; end
+  
+  meth = A.instance_method(:foo).force_bind(B.new)
+  meth.call
+  #=> #<B:0x123456>

data/Rakefile

@@ -4,15 +4,18 @@ require 'rake/gempackagetask'
 WINDOWS = (PLATFORM =~ /win32|cygwin/ ? true : false) rescue false
 SUDO = WINDOWS ? '' : 'sudo'
 
-load 'force_bind.gemspec'
-Rake::GemPackageTask.new(SPEC) do |pkg|
-  pkg.gem_spec = SPEC
-  pkg.need_zip = true
-  pkg.need_tar = true
+desc "Builds the gem"
+task :gem => :build do
+  load 'force_bind.gemspec'
+  Gem::Builder.new(SPEC).build
 end
 
-desc "Install the gem locally"
-task :install => :package do 
-  sh "#{SUDO} gem install pkg/#{SPEC.name}-#{SPEC.version}.gem --local"
-  sh "rm -rf pkg/#{SPEC.name}-#{SPEC.version}" unless ENV['KEEP_FILES']
+desc "Installs the gem"
+task :install => :gem do 
+  sh "#{SUDO} gem install #{SPEC.name}-#{SPEC.version}.gem --no-rdoc --no-ri"
 end
+
+desc 'Build the extension'
+task :build do
+  sh "cd ext && ruby extconf.rb && make"
+end

data/ext/extconf.rb

@@ -1,5 +1,4 @@
 require 'mkmf'
-$CPPFLAGS += " -DRUBY_19" if RUBY_VERSION =~ /1.9/
-ext = 'force_bind'
-dir_config(ext)
-create_makefile(ext)
+
+$defs << "-DRUBY192_OR_GREATER" if RUBY_VERSION >= "1.9.2"
+create_makefile('force_bind')

data/ext/force_bind.c

@@ -1,29 +1,68 @@
 #include "ruby.h"
 
+#ifdef RUBY192_OR_GREATER
+
+#include "method.h"
+
+struct METHOD {
+	VALUE recv;
+	VALUE rclass;
+	ID id;
+	rb_method_entry_t me;
+};
+
+/*
+ * Similar to +UnboundMethod#bind+, but forces the bind regardless of the type.
+ * @return [Method]
+ */
+VALUE
+umethod_force_bind(VALUE method, VALUE recv)
+{
+	struct METHOD *data, *bound;
+	const rb_data_type_t *type;
+
+	type = RTYPEDDATA_TYPE(method);
+	TypedData_Get_Struct(method, struct METHOD, type, data);
+	method = TypedData_Make_Struct(rb_cMethod, struct METHOD, type, bound);
+	*bound = *data;
+	if (bound->me.def) bound->me.def->alias_count++;
+	bound->recv = recv;
+	bound->rclass = CLASS_OF(recv);
+
+	return method;
+}
+
+#else
+
 struct METHOD {
-    VALUE oclass;
-    VALUE rclass;
-    VALUE recv;
-    ID id, oid;
-    struct RNode *body;
+	VALUE oclass;
+	VALUE rclass;
+	VALUE recv;
+	ID id, oid;
+	struct RNode *body;
 };
 
-static VALUE
+VALUE
 umethod_force_bind(VALUE method, VALUE recv)
 {
-    struct METHOD *data, *bound;
+	struct METHOD *data, *bound;
 
-    Data_Get_Struct(method, struct METHOD, data);
-    method = Data_Make_Struct(rb_cMethod, struct METHOD, free, -1, bound);
-    *bound = *data;
-    bound->recv = recv;
-    bound->rclass = TYPE(recv) == T_CLASS ? RCLASS(recv) : CLASS_OF(recv);
+	Data_Get_Struct(method, struct METHOD, data);
+	method = Data_Make_Struct(rb_cMethod, struct METHOD, free, -1, bound);
+	*bound = *data;
+	bound->recv = recv;
+	bound->rclass = TYPE(recv) == T_CLASS ? RCLASS(recv) : CLASS_OF(recv);
 
-    return method;
+	return method;
 }
 
+#endif /* RUBY192_OR_GREATER */
+
 void
 Init_force_bind()
 {
-    rb_define_method(rb_cUnboundMethod, "force_bind", umethod_force_bind, 1);
-}
+	rb_define_method(rb_cUnboundMethod, "force_bind", umethod_force_bind, 1);
+#if 0
+	rb_cUnboundMethod = rb_define_class("UnboundMethod", rb_cObject); /* for docs */
+#endif
+}

data/ext/method.h

@@ -0,0 +1,103 @@
+/**********************************************************************
+
+  method.h -
+
+  $Author: ko1 $
+  created at: Wed Jul 15 20:02:33 2009
+
+  Copyright (C) 2009 Koichi Sasada
+
+**********************************************************************/
+#ifndef METHOD_H
+#define METHOD_H
+
+typedef enum {
+    NOEX_PUBLIC    = 0x00,
+    NOEX_NOSUPER   = 0x01,
+    NOEX_PRIVATE   = 0x02,
+    NOEX_PROTECTED = 0x04,
+    NOEX_MASK      = 0x06,
+    NOEX_BASIC     = 0x08,
+    NOEX_UNDEF     = NOEX_NOSUPER,
+    NOEX_MODFUNC   = 0x12,
+    NOEX_SUPER     = 0x20,
+    NOEX_VCALL     = 0x40,
+    NOEX_RESPONDS  = 0x80
+} rb_method_flag_t;
+
+#define NOEX_SAFE(n) ((int)((n) >> 8) & 0x0F)
+#define NOEX_WITH(n, s) ((s << 8) | (n) | (ruby_running ? 0 : NOEX_BASIC))
+#define NOEX_WITH_SAFE(n) NOEX_WITH(n, rb_safe_level())
+
+/* method data type */
+
+typedef enum {
+    VM_METHOD_TYPE_ISEQ,
+    VM_METHOD_TYPE_CFUNC,
+    VM_METHOD_TYPE_ATTRSET,
+    VM_METHOD_TYPE_IVAR,
+    VM_METHOD_TYPE_BMETHOD,
+    VM_METHOD_TYPE_ZSUPER,
+    VM_METHOD_TYPE_UNDEF,
+    VM_METHOD_TYPE_NOTIMPLEMENTED,
+    VM_METHOD_TYPE_OPTIMIZED, /* Kernel#send, Proc#call, etc */
+    VM_METHOD_TYPE_MISSING   /* wrapper for method_missing(id) */
+} rb_method_type_t;
+
+typedef struct rb_method_cfunc_struct {
+    VALUE (*func)(ANYARGS);
+    int argc;
+} rb_method_cfunc_t;
+
+typedef struct rb_method_attr_struct {
+    ID id;
+    VALUE location;
+} rb_method_attr_t;
+
+typedef struct rb_iseq_struct rb_iseq_t;
+
+typedef struct rb_method_definition_struct {
+    rb_method_type_t type; /* method type */
+    ID original_id;
+    union {
+	rb_iseq_t *iseq;            /* should be mark */
+	rb_method_cfunc_t cfunc;
+	rb_method_attr_t attr;
+	VALUE proc;                 /* should be mark */
+	enum method_optimized_type {
+	    OPTIMIZED_METHOD_TYPE_SEND,
+	    OPTIMIZED_METHOD_TYPE_CALL
+	} optimize_type;
+    } body;
+    int alias_count;
+} rb_method_definition_t;
+
+typedef struct rb_method_entry_struct {
+    rb_method_flag_t flag;
+    char mark;
+    rb_method_definition_t *def;
+    ID called_id;
+    VALUE klass;                    /* should be mark */
+} rb_method_entry_t;
+
+struct unlinked_method_entry_list_entry {
+    struct unlinked_method_entry_list_entry *next;
+    rb_method_entry_t *me;
+};
+
+#define UNDEFINED_METHOD_ENTRY_P(me) (!(me) || !(me)->def || (me)->def->type == VM_METHOD_TYPE_UNDEF)
+
+void rb_add_method_cfunc(VALUE klass, ID mid, VALUE (*func)(ANYARGS), int argc, rb_method_flag_t noex);
+rb_method_entry_t *rb_add_method(VALUE klass, ID mid, rb_method_type_t type, void *option, rb_method_flag_t noex);
+rb_method_entry_t *rb_method_entry(VALUE klass, ID id);
+
+rb_method_entry_t *rb_method_entry_get_without_cache(VALUE klass, ID id);
+rb_method_entry_t *rb_method_entry_set(VALUE klass, ID mid, const rb_method_entry_t *, rb_method_flag_t noex);
+
+int rb_method_entry_arity(const rb_method_entry_t *me);
+
+void rb_mark_method_entry(const rb_method_entry_t *me);
+void rb_free_method_entry(rb_method_entry_t *me);
+void rb_sweep_method_entry(void *vm);
+
+#endif /* METHOD_H */

data/spec/force_bind_spec.rb

@@ -0,0 +1,94 @@
+require 'rspec'
+require_relative '../ext/force_bind'
+
+describe 'UnboundMethod#force_bind' do
+  class Mock
+    def the_method
+      self
+    end
+  end
+
+  it 'binds an instance method on a class' do
+    Mock.instance_method(:the_method).force_bind(Mock).call.should be Mock
+  end
+
+  it 'binds an instance method on an instance of the same class' do
+    Mock.instance_method(:the_method).force_bind(mock = Mock.new).call.should be mock
+  end
+
+  it 'binds an instance method on an instance of another class' do
+    Mock.instance_method(:the_method).force_bind(object = Object.new).call.should be object
+  end
+
+  context 'environment' do
+    class C
+      def initialize(n) @n = n end
+      def n; @n end
+    end
+    class D
+      def initialize(n) @n = n end
+    end
+
+    it 'refers dynamically to instance variables' do
+      C.instance_method(:n).force_bind(D.new(4)).call.should == 4
+    end
+
+    it 'refers dynamically to methods' do
+      C.send(:define_method, :each) { |&b| (1..@n).each(&b) }
+      Enumerable.instance_method(:select).force_bind(C.new(5)).call(&:even?).should == [2,4]
+    end
+
+    it 'can transplant methods on instances' do
+      (d = D.new(4)).define_singleton_method(:attr_n, &C.instance_method(:n).force_bind(d))
+      d.attr_n.should == 4
+    end
+
+    it 'can transplant methods on classes with a specific instance' do
+      D.send(:define_method, :attr_n, &C.instance_method(:n).force_bind(d = D.new(4)))
+      d.attr_n.should == 4
+      D.new(:whatever).attr_n.should == 4
+    end
+
+    it 'can transplant methods from a class to another by rebinding' do
+      class Source
+        def steal_me
+          [self, @a]
+        end
+      end
+      class Target
+        def initialize(a) @a = a end
+      end
+
+      steal = lambda do |source_method, target_class, method_name|
+        target_class.class_exec do
+          define_method(method_name) do |*a,&b|
+            source_method.force_bind(self).call(*a,&b)
+          end
+        end
+      end
+
+      target = Target.new(2)
+      steal.call(Source.instance_method(:steal_me), Target, :stolen)
+      target.stolen.should == [target, 2]
+      (t = Target.new(3)).stolen.should == [t, 3]
+    end
+
+    it 'can not (yet) bind methods using super on other instances' do
+      class Parent
+        def meth
+          :meth
+        end
+      end
+      class Child < Parent
+        def meth
+          super
+        end
+      end
+
+      lambda {
+        Child.instance_method(:meth).force_bind(C.new(1)).call
+      }.should raise_error(NotImplementedError,
+        'super from singleton method that is defined to multiple classes is not supported; this will be fixed in 1.9.3 or later')
+    end
+  end
+end

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: force_bind
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
 - Loren Segal
@@ -9,10 +14,22 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-15 00:00:00 -04:00
+date: 2011-01-10 00:00:00 -05:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
 description: 
 email: lsegal@soen.ca
 executables: []
@@ -25,8 +42,9 @@ files:
 - Rakefile
 - README
 - ext/force_bind.c
+- ext/method.h
 - ext/extconf.rb
-- test/test_force_bind.rb
+- spec/force_bind_spec.rb
 has_rdoc: false
 homepage: http://github.com/lsegal/force_bind
 licenses: []
@@ -37,23 +55,27 @@ rdoc_options: []
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: Adds UnboundMethod#force_bind to bind an unbound method to class (or any object of any type)
+summary: Adds UnboundMethod#force_bind to bind an unbound method to a class (or any object of any type)
 test_files: []
 

data/test/test_force_bind.rb

@@ -1,25 +0,0 @@
-require 'test/unit'
-require File.dirname(__FILE__) + '/../force_bind'
-
-class Mock
-  def the_method; self end
-end
-
-class TestForceBind < Test::Unit::TestCase
-  def test_force_bind_class
-    proc = Mock.instance_method(:the_method).force_bind(Mock)
-    assert_equal Mock, proc.call
-  end
-  
-  def test_force_bind_object
-    mock = Mock.new
-    proc = Mock.instance_method(:the_method).force_bind(mock)
-    assert_equal mock, proc.call
-  end
-  
-  def test_force_bind_object_from_other_class
-    arr = Array.new
-    proc = Mock.instance_method(:the_method).force_bind(arr)
-    assert_equal arr, proc.call
-  end
-end