object2module 0.3.0 → 0.4.0

data/Rakefile

@@ -1,10 +1,12 @@
- # Rakefile added by John Mair (banisterfiend)
+# Rakefile added by John Mair (banisterfiend)
 
 require 'rake/gempackagetask'
+require 'rake/rdoctask'
 require 'rake/clean'
-require 'lib/object2module/version.rb'
+require './lib/object2module/version.rb'
 
 dlext = Config::CONFIG['DLEXT']
+direc = File.dirname(__FILE__)
 
 CLEAN.include("ext/**/*.#{dlext}", "ext/**/.log", "ext/**/.o", "ext/**/*~", "ext/**/*#*", "ext/**/.obj", "ext/**/.def", "ext/**/.pdb")
 CLOBBER.include("**/*.#{dlext}", "**/*~", "**/*#*", "**/*.log", "**/*.o", "doc/**")
@@ -24,30 +26,48 @@ def apply_spec_defaults(s)
 end
 
 
-# common tasks
-task :compile => :clean
+task :test do
+  sh "bacon -k #{direc}/test/test.rb"
+end
 
-# spec = Gem::Specification.new do |s|
-#   apply_spec_defaults(s)        
-#   s.platform = 'i386-mswin32'
-#   s.files = ["Rakefile", "README", "LICENSE",
-#   "lib/object2module.rb", "lib/1.8/object2module.#{dlext}",
-#   "lib/1.9/object2module.#{dlext}", "lib/object2module/version.rb", "test/test_object2module.rb"] 
-# end
+[:mingw32, :mswin32].each do |v|
+  task v do
+    spec = Gem::Specification.new do |s|
+      apply_spec_defaults(s)        
+      s.platform = "i386-#{v}"
+      s.files = FileList["Rakefile", "README", "LICENSE",
+                         "lib/object2module.rb", "lib/1.8/object2module.#{dlext}",
+                         "lib/1.9/object2module.#{dlext}", "lib/object2module/version.rb", "test/*.rb"].to_a
+    end
 
+    Rake::GemPackageTask.new(spec) do |pkg|
+      pkg.need_zip = false
+      pkg.need_tar = false
+    end
 
+    Rake::Task[:gem].invoke
+  end
+end
 
+task :ruby do
+  spec = Gem::Specification.new do |s|
+    apply_spec_defaults(s)        
+    s.platform = Gem::Platform::RUBY
+    s.files = FileList["Rakefile", "README", "LICENSE",
+                       "lib/object2module.rb","lib/object2module/version.rb",
+                       "test/*.rb", "ext/**/extconf.rb", "ext/**/*.h", "ext/**/*.c"].to_a
+    s.extensions = ["ext/object2module/extconf.rb"]
+  end
 
+  Rake::GemPackageTask.new(spec) do |pkg|
+    pkg.need_zip = false
+    pkg.need_tar = false
+  end
 
-spec = Gem::Specification.new do |s|
-  apply_spec_defaults(s)
-  s.platform = Gem::Platform::RUBY
-  s.extensions = FileList["ext/**/extconf.rb"]
-  s.files = ["Rakefile", "README", "LICENSE", "lib/object2module.rb", "lib/object2module/version.rb", "test/test_object2module.rb"] +
-    FileList["ext/**/extconf.rb", "ext/**/*.h", "ext/**/*.c"].to_a
+  Rake::Task[:gem].invoke
 end
 
-Rake::GemPackageTask.new(spec) do |pkg|
-  pkg.need_zip = false
-  pkg.need_tar = false
+Rake::RDocTask.new do |rd|
+  rd.main = "README.rdoc"
+  rd.rdoc_files.include("README.rdoc", "lib/object2module.rb")
 end

data/ext/object2module/compat.h

@@ -5,13 +5,52 @@
 
 #include <ruby.h>
 
+/* test for 1.9 */
+#if !defined(RUBY_19) && defined(ROBJECT_EMBED_LEN_MAX)
+# define RUBY_19
+#endif
+
 /* macros for backwards compatibility with 1.8 */
 #ifndef RUBY_19
 # define RCLASS_M_TBL(c) (RCLASS(c)->m_tbl)
 # define RCLASS_SUPER(c) (RCLASS(c)->super)
 # define RCLASS_IV_TBL(c) (RCLASS(c)->iv_tbl)
+# define OBJ_UNTRUSTED OBJ_TAINTED
+# include "st.h"
+#endif
+
+#ifdef RUBY_19
+inline static VALUE
+class_alloc(VALUE flags, VALUE klass)
+{
+  rb_classext_t *ext = ALLOC(rb_classext_t);
+  NEWOBJ(obj, struct RClass);
+  OBJSETUP(obj, klass, flags);
+  obj->ptr = ext;
+  RCLASS_IV_TBL(obj) = 0;
+  RCLASS_M_TBL(obj) = 0;
+  RCLASS_SUPER(obj) = 0;
+  RCLASS_IV_INDEX_TBL(obj) = 0;
+  return (VALUE)obj;
+}
 #endif
 
+inline static VALUE
+create_class(VALUE flags, VALUE klass)
+{
+#ifdef RUBY_19
+  VALUE new_klass = class_alloc(flags, klass);
+#else
+  NEWOBJ(new_klass, struct RClass);
+  OBJSETUP(new_klass, klass, flags);
+#endif
+
+  return (VALUE)new_klass;
+}
+  
+# define FALSE 0
+# define TRUE 1
+
 /* a useful macro. cannot use ordinary CLASS_OF as it does not return an lvalue */
 #define KLASS_OF(c) (RBASIC(c)->klass)
 

data/ext/object2module/object2module.c

@@ -6,126 +6,92 @@
 #include <ruby.h>
 #include "compat.h"
 
-#ifdef RUBY_19
-# include <ruby/st.h>
-#else
-# include <st.h>
-#endif
-
-/* class creation. from class.c in 1.9.1 */
-#ifdef RUBY_19
-static VALUE
-class_alloc(VALUE flags, VALUE klass)
-{
-    rb_classext_t *ext = ALLOC(rb_classext_t);
-    NEWOBJ(obj, struct RClass);
-    OBJSETUP(obj, klass, flags);
-    obj->ptr = ext;
-    RCLASS_IV_TBL(obj) = 0;
-    RCLASS_M_TBL(obj) = 0;
-    RCLASS_SUPER(obj) = 0;
-    RCLASS_IV_INDEX_TBL(obj) = 0;
-    return (VALUE)obj;
-}
-#endif
-
-/* a modified version of include_class_new from class.c */
 static VALUE
-j_class_new(VALUE module, VALUE sup)
+include_class_new(VALUE module, VALUE super)
 {
-
-#ifdef RUBY_19
-    VALUE klass = class_alloc(T_ICLASS, rb_cClass);
-#else
-    NEWOBJ(klass, struct RClass);
-    OBJSETUP(klass, rb_cClass, T_ICLASS);
-#endif
-
-    if (TYPE(module) == T_ICLASS) {
-        module = KLASS_OF(module);
-    }
-
-    if (!RCLASS_IV_TBL(module)) {
-        RCLASS_IV_TBL(module) = (struct st_table *)st_init_numtable();
-    }
-
-    /* assign iv_tbl, m_tbl and super */
-    RCLASS_IV_TBL(klass) = RCLASS_IV_TBL(module);
-    RCLASS_SUPER(klass) = sup;
-    if(TYPE(module) != T_OBJECT) {
-        RCLASS_M_TBL(klass) = RCLASS_M_TBL(module);
-    }
-    else {
-        RCLASS_M_TBL(klass) = RCLASS_M_TBL(CLASS_OF(module));
-    }
-
-    /* */
-
-    if (TYPE(module) == T_ICLASS) {
-        KLASS_OF(klass) = KLASS_OF(module);
-    }
-    else {
-        KLASS_OF(klass) = module;
-    }
-
-    if(TYPE(module) != T_OBJECT) {
-        OBJ_INFECT(klass, module);
-        OBJ_INFECT(klass, sup);
-    }
-
-    return (VALUE)klass;
+  VALUE klass = create_class(T_ICLASS, rb_cClass);
+
+  if (BUILTIN_TYPE(module) == T_ICLASS) {
+
+    /* for real_include compat */
+    if (!NIL_P(rb_iv_get(module, "__module__")))
+      module = rb_iv_get(module, "__module__");
+    else
+      module = RBASIC(module)->klass;
+  }
+
+  if (!RCLASS_IV_TBL(module)) {
+    RCLASS_IV_TBL(module) = st_init_numtable();
+  }
+  RCLASS_IV_TBL(klass) = RCLASS_IV_TBL(module);
+  RCLASS_M_TBL(klass) = RCLASS_M_TBL(module);
+  RCLASS_SUPER(klass) = super;
+  if (TYPE(module) == T_ICLASS) {
+    RBASIC(klass)->klass = RBASIC(module)->klass;
+  }
+  else {
+    RBASIC(klass)->klass = module;
+  }
+
+  OBJ_INFECT(klass, module);
+  OBJ_INFECT(klass, super);
+
+  return (VALUE)klass;
 }
 
 VALUE
-rb_to_module(VALUE self)
+rb_gen_include_one(VALUE klass, VALUE module)
 {
-    VALUE rclass, chain_start, jcur, klass;
+  VALUE p, c;
+  int changed = 0;
 
-    switch(BUILTIN_TYPE(self)) {
-    case T_MODULE:
-        return self;
-    case T_CLASS:
-        klass = self;
-        break;
-    case T_OBJECT:
-    default:
-        klass = rb_singleton_class(self);            
-    }
+  rb_frozen_class_p(klass);
+  if (!OBJ_UNTRUSTED(klass)) {
+    rb_secure(4);
+  }
 
-    if (self == rb_cObject || self == rb_cClass || self == rb_cModule)
-      rb_raise(rb_eArgError, "cannot convert Object, Class or Module to module.");
+  /* when including an object, include its singleton class */
+  if (TYPE(module) == T_OBJECT)
+    module = rb_singleton_class(module);
     
-    chain_start = j_class_new(klass, rb_cObject);
-
-    KLASS_OF(chain_start) = rb_cModule;
-    RBASIC(chain_start)->flags = T_MODULE;
-
-    jcur = chain_start;
-    for(rclass = RCLASS_SUPER(klass); rclass != rb_cObject;
-        rclass = RCLASS_SUPER(rclass)) {
-                
-        RCLASS_SUPER(jcur) = j_class_new(rclass, rb_cObject);
-        jcur = RCLASS_SUPER(jcur);
+  OBJ_INFECT(klass, module);
+  c = klass;
+  while (module) {
+    int superclass_seen = FALSE;
+
+    if (RCLASS_M_TBL(klass) == RCLASS_M_TBL(module))
+      rb_raise(rb_eArgError, "cyclic include detected");
+    /* ignore if the module included already in superclasses */
+    for (p = RCLASS_SUPER(klass); p; p = RCLASS_SUPER(p)) {
+      switch (BUILTIN_TYPE(p)) {
+      case T_ICLASS:
+        if (RCLASS_M_TBL(p) == RCLASS_M_TBL(module)) {
+          if (!superclass_seen) {
+            c = p;  /* move insertion point */
+          }
+          goto skip;
+        }
+        break;
+      case T_CLASS:
+        superclass_seen = TRUE;
+        break;
+      }
     }
-
-    RCLASS_SUPER(jcur) = (VALUE)NULL;
-
-    return chain_start;
+    c = RCLASS_SUPER(c) = include_class_new(module, RCLASS_SUPER(c));
+    if (RMODULE_M_TBL(module) && RMODULE_M_TBL(module)->num_entries)
+      changed = 1;
+  skip:
+    module = RCLASS_SUPER(module);
+  }
+  if (changed) rb_clear_cache();
+
+  return Qnil;
 }
 
-VALUE
-reset_tbls(VALUE self)
-{
-    RCLASS_IV_TBL(self) = (struct st_table *) 0;
-    RCLASS_M_TBL(self) = (struct st_table *) st_init_numtable();
-
-    return Qnil;
-}
 
 void
 Init_object2module()
 {
-    rb_define_method(rb_cObject, "__to_module__", rb_to_module, 0);
-    rb_define_method(rb_cObject, "__reset_tbls__", reset_tbls, 0);
+  rb_define_method(rb_cModule, "gen_include_one", rb_gen_include_one, 1);
 }
 

data/lib/object2module.rb

@@ -15,79 +15,75 @@ rescue LoadError => e
     require "#{direc}/object2module.#{dlext}"
 end
 
+module Kernel
 
-# call-seq:
-#    obj.gen_extend(other, ...)    => obj
+  # define a `singleton_class` method for the 1.8 kids
+  # @return [Class] The singleton class of the receiver
+  def singleton_class
+    class << self; self; end
+  end if !respond_to?(:singleton_class)
+end
 
-# Adds to _obj_ the instance methods from each object given as a
-# parameter.
-   
-#    class C
-#      def hello
-#        "Hello from C.\n"
-#      end
-#    end
-   
-#    class Klass
-#      def hello
-#        "Hello from Klass.\n"
-#      end
-#    end
-   
-#    k = Klass.new
-#    k.hello         #=> "Hello from Klass.\n"
-#    k.gen_extend(C)   #=> #<Klass:0x401b3bc8>
-#    k.hello         #=> "Hello from C.\n"
 class Object
-  def gen_extend(*objs)
-    raise ArgumentError, "wrong number of arguments (0 for 1)" if objs.empty?
+  def __gen_extend_or_include__(extend_or_include, *objs)  #:nodoc:
+    raise ArgumentError, "wrong number of arguments (at least 1)" if objs.empty?
 
-    objs.each { |o|
-      begin
-        mod = o.__to_module__
-        extend(mod)
-      ensure
-        mod.__reset_tbls__ if mod != o &&o != Object && o != Class && o != Module
-      end
+    objs.each { |mod|
+        send(extend_or_include, mod)
     }
 
     self
   end
-end
 
+  # Adds to the singleton class of receiver the instance methods from each object given as a
+  # parameter.
+  # 
+  # @param [Array] objs The array of objects to `gen_extend`
+  # @return [Object] The receiver
+  # @example  
+  #    class C
+  #      def hello
+  #        "Hello from C.\n"
+  #      end
+  #    end
+  #   
+  #    class Klass
+  #      def hello
+  #        "Hello from Klass.\n"
+  #      end
+  #    end
+  #   
+  #    k = Klass.new
+  #    k.hello         #=> "Hello from Klass.\n"
+  #    k.gen_extend(C)   #=> #<Klass:0x401b3bc8>
+  #    k.hello         #=> "Hello from C.\n"
+  def gen_extend(*objs)
+    singleton_class.__gen_extend_or_include__(:gen_include_one, *objs)
+  end
+end
 
-# call-seq:
-#    gen_include(other, ...)    => self
-
-# Adds to the implied receiver the instance methods from each object given as a
-# parameter.
-   
-#    class C
-#      def hello
-#        "Hello from C.\n"
-#      end
-#    end
-   
-#    class Klass
-#      gen_include(C)
-#    end
-   
-#    k = Klass.new
-#    k.hello         #=> "Hello from C.\n"
 class Module
+  
+  # Adds to the implied receiver the instance methods from each object given as a
+  # parameter.
+  # 
+  # @param [Array] objs The array of objects to `gen_include`
+  # @return [Object] The receiver
+  # @example  
+  #    class C
+  #      def hello
+  #        "Hello from C.\n"
+  #      end
+  #    end
+  #   
+  #    class Klass
+  #      gen_include(C)
+  #    end
+  #   
+  #    k = Klass.new
+  #    k.hello         #=> "Hello from C.\n"
   def gen_include(*objs)
-    raise ArgumentError, "wrong number of arguments (0 for 1)" if objs.empty?
-    
-    objs.each { |o|
-      begin
-        mod = o.__to_module__
-        include(mod)
-      ensure
-        mod.__reset_tbls__ if mod != o && o != Object && o != Class && o != Module
-      end
-    }
-
-    self
+    __gen_extend_or_include__(:gen_include_one, *objs)
   end
 end
 

data/lib/object2module/version.rb

@@ -1,3 +1,3 @@
 module Object2module
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/test/test.rb

@@ -0,0 +1,165 @@
+direc = File.dirname(__FILE__)
+require 'rubygems'
+require 'bacon'
+require "#{direc}/../lib/object2module"
+
+
+class Module
+  public :include, :remove_const
+end
+
+describe Object2module do
+  before do
+    class A
+      def a
+        :a
+      end
+    end
+
+    class B
+      def b
+        :b
+      end
+    end
+
+    module M
+      def m
+        :m
+      end
+    end
+
+    O = Object.new
+    class << O
+      def o
+        :o
+      end
+    end
+
+    C = Class.new
+  end
+
+  after do
+    Object.remove_const(:A)
+    Object.remove_const(:B)
+    Object.remove_const(:C)
+    Object.remove_const(:M)
+    Object.remove_const(:O)
+  end
+
+  describe 'gen_include' do
+    it 'includes a module' do
+      C.gen_include M
+      C.new.m.should == :m
+    end
+
+    it 'includes a class' do
+      C.gen_include A
+      C.new.a.should == :a
+    end
+
+    it 'includes an object' do
+      C.gen_include O
+      C.new.o.should == :o
+    end
+
+    it 'includes a class that includes a class' do
+      A.gen_include B
+      C.gen_include A
+      C.new.b.should == :b
+      C.new.a.should == :a
+    end
+
+    it 'includes an object that includes a class that includes a class' do
+      A.gen_include B
+      O.gen_extend A
+      C.gen_include O
+      C.new.o.should == :o
+      C.new.a.should == :a
+      C.new.b.should == :b
+    end
+
+    it 'includes an object that includes an object' do
+      n = Object.new
+      class << n
+        def n
+          :n
+        end
+      end
+
+      l = Object.new
+      class << l
+        def l
+          :l
+        end
+        self
+      end.gen_include n
+
+      C.gen_include l
+      C.new.l.should == :l
+      C.new.n.should == :n
+    end
+  end
+
+  describe 'gen_extend' do
+    it 'extends a module' do
+      O.gen_extend M
+      O.m.should == :m
+    end
+
+    it 'extends a class' do
+      O.gen_extend A
+      O.a.should == :a
+    end
+
+    it 'extends an object' do
+      n = Object.new
+      class << n
+        def n
+          :n
+        end
+      end
+      O.gen_extend n
+      O.n.should == :n
+    end
+
+    it 'extends a class that includes a class' do
+      A.gen_include B
+      O.gen_extend A
+      O.b.should == :b
+      O.a.should == :a
+    end
+
+    it 'extends an object that includes a class that includes a class' do
+      A.gen_include B
+      C.gen_include A
+      O.gen_extend C
+      O.o.should == :o
+      O.a.should == :a
+      O.b.should == :b
+    end
+
+    it 'extends an object that extends an object' do
+      n = Object.new
+      class << n
+        def n
+          :n
+        end
+      end
+
+      l = Object.new
+      class << l
+        def l
+          :l
+        end
+        self
+      end
+
+      l.gen_extend n
+
+      O.gen_extend l
+      O.l.should == :l
+      O.n.should == :n
+    end    
+  end
+end
+      

data/test/test_stress.rb

@@ -0,0 +1,6 @@
+require '../lib/object2module'
+
+80_000.times {
+  Object.new.gen_extend Object.new, Module.new, Class.new
+  Class.new.gen_include Object.new, Module.new, Class.new
+}

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: object2module
 version: !ruby/object:Gem::Version 
-  hash: 19
   prerelease: false
   segments: 
   - 0
-  - 3
+  - 4
   - 0
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors: 
 - John Mair (banisterfiend)
@@ -15,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-29 00:00:00 +12:00
+date: 2010-10-31 00:00:00 +13:00
 default_executable: 
 dependencies: []
 
@@ -33,7 +32,8 @@ files:
 - LICENSE
 - lib/object2module.rb
 - lib/object2module/version.rb
-- test/test_object2module.rb
+- test/test.rb
+- test/test_stress.rb
 - ext/object2module/extconf.rb
 - ext/object2module/compat.h
 - ext/object2module/object2module.h
@@ -52,7 +52,6 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
@@ -61,7 +60,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"

data/test/test_object2module.rb

@@ -1,147 +0,0 @@
-direc = File.dirname(__FILE__)
-
-require 'test/unit'
-require "#{direc}/../lib/object2module"
-
-module M
-    def m
-        "m"
-    end
-end
-
-class A
-    include M
-
-    def a
-        "a"
-    end
-end
-
-class B < A
-    def b
-        "b"
-    end
-end
-
-class C < B
-    def c
-        "c"
-    end
-end
-
-# stand-alone class
-class K
-    def k
-        "k"
-    end
-end
-
-# another stand-alone class
-class J
-    def j
-        "j"
-    end
-end
-
-class Object2ModuleTest < Test::Unit::TestCase
-    def test_class_to_module
-        assert_instance_of(Module, C.__to_module__)    
-    end
-
-    def test_class_heirarchy
-        c = C.__to_module__
-        
-        h = c.ancestors
-        assert_equal(B, h[1])
-        assert_equal(A, h[2])
-        assert_equal(M, h[3])
-    end
-
-    def test_class_extend
-        o = Object.new
-        assert_equal(o, o.gen_extend(C))
-    end
-
-    def test_class_extended_methods
-        h = C.__to_module__
-        o = Object.new
-        o.extend(h)
-        assert_equal("a", o.a)
-        assert_equal("b", o.b)
-        assert_equal("c", o.c)
-        assert_equal("m", o.m)
-    end                                                       
-
-    def test_object_to_module
-        o = C.new
-        assert_instance_of(Module, o.__to_module__)    
-    end
-
-    def test_object_heirarchy                                  
-        o = C.new
-        h = o.__to_module__.ancestors                           
-        assert_equal(C, h[1])                                   
-        assert_equal(B, h[2])                                   
-        assert_equal(A, h[3])                                   
-        assert_equal(M, h[4])                                  
-    end                                                       
-    
-    def test_object_extend                                           
-        h = C.__to_module__                                     
-        o = Object.new                                          
-        assert_equal(o, o.extend(h))                            
-    end                                                       
-    
-    def test_object_extended_methods                                 
-        o = C.new
-        h = o.__to_module__                                     
-        l = Object.new                                          
-        l.extend(h)                                             
-        assert_equal("a", l.a)                                        
-        assert_equal("b", l.b)                                        
-        assert_equal("c", l.c)                                        
-        assert_equal("m", l.m)                                        
-    end    
-    
-    def test_gen_extend
-        o = Object.new
-        o.gen_extend(C)
-        assert_equal("a", o.a)                                        
-        assert_equal("b", o.b)                                        
-        assert_equal("c", o.c)                                        
-        assert_equal("m", o.m)  
-    end
-
-    def test_gen_include
-        k = Class.new
-        k.gen_include(C)
-        o = k.new
-        assert_equal("a", o.a)                                        
-        assert_equal("b", o.b)                                        
-        assert_equal("c", o.c)                                        
-        assert_equal("m", o.m)  
-    end
-
-    def test_gen_extend_multi
-        o = Object.new
-        o.gen_extend(C, K, J)
-        assert_equal("a", o.a)                                        
-        assert_equal("b", o.b)                                        
-        assert_equal("c", o.c)                                        
-        assert_equal("m", o.m)
-        assert_equal("k", o.k)
-        assert_equal("j", o.j)
-    end
-
-    def test_gen_include_multi
-        k = Class.new
-        k.gen_include(C, K, J)
-        o = k.new
-        assert_equal("a", o.a)                                        
-        assert_equal("b", o.b)                                        
-        assert_equal("c", o.c)                                        
-        assert_equal("m", o.m)
-        assert_equal("k", o.k)
-        assert_equal("j", o.j)
-    end
-end