object2module 0.1.0

data/README.rdoc

@@ -0,0 +1,18 @@
+# Object2module
+
+-   converts a Class (or the Singleton of an Object) to a Module
+-   Includes gen\_extend and gen\_include methods: generalizations
+    of Object#extend and Module#include that work with Objects and
+    Classes as well as Modules
+
+How it works:
+
+-   First creates an IClass for the Class in question and sets the
+    T\_MODULE flag
+-   Recursively converts superclasses of the Class to IClasses
+    creating a modulified version of the Class's inheritance chain
+-   gen\_include/gen\_extend automatically call #to\_module on the
+    Class/Object before inclusion/extension.
+
+
+

data/Rakefile

@@ -0,0 +1,84 @@
+require 'rake/clean'
+
+OBJECT2MODULE_VERSION = "0.1.0"
+
+$dlext = Config::CONFIG['DLEXT']
+
+CLEAN.include("ext/*.#{$dlext}", "ext/*.log", "ext/*.o", "ext/*~", "ext/*#*", "ext/*.obj", "ext/*.def", "ext/*.pdb")
+CLOBBER.include("**/*.#{$dlext}", "**/*~", "**/*#*", "**/*.log", "**/*.o", "doc/**")
+
+$make_program = if RUBY_PLATFORM =~ /win/ 
+                    "nmake"
+                else
+                    "make"
+                end
+
+task :default => [:build]
+
+desc "Build Object2module"
+task :build => :clean do
+    chdir("./ext/") do
+        ruby "extconf.rb"
+        sh "#{$make_program}"
+        cp "cobject2module.#{$dlext}", "../lib" , :verbose => true
+
+        if RUBY_PLATFORM =~ /mswin/
+            if RUBY_VERSION =~ /1.9/
+                File.rename("../lib/cobject2module.#{$dlext}",
+                            "../lib/cobject2module.19.#{$dlext}")
+            else
+                File.rename("../lib/cobject2module.#{$dlext}",
+                            "../lib/cobject2module.18.#{$dlext}")
+            end
+        end
+    end
+end
+
+require 'rake/gempackagetask'
+specification = Gem::Specification.new do |s|
+    s.name = "object2module"
+    s.summary = "object2module enables ruby classes and objects to be used as modules"
+    s.version = OBJECT2MODULE_VERSION
+    s.date = Time.now.strftime '%Y-%m-%d'
+    s.author = "John Mair (banisterfiend)"
+    s.email = 'jrmair@gmail.com'
+    s.description = s.summary
+    s.require_path = 'lib'
+    s.homepage = "http://banisterfiend.wordpress.com"
+    s.has_rdoc = true
+    s.extra_rdoc_files = ["README.rdoc", "ext/object2module.c"]
+    s.rdoc_options << '--main' << 'README.rdoc'
+    s.files =  ["Rakefile", "lib/object2module.rb", "README.rdoc"] +
+        FileList["ext/*.c", "ext/*.h", "ext/*.rb", "test/*.rb"].to_a
+
+    if RUBY_PLATFORM =~ /mswin/
+        s.platform = Gem::Platform::CURRENT
+        s.files += ["lib/cobject2module.18.so", "lib/cobject2module.19.so"]
+        
+    else
+        s.platform = Gem::Platform::RUBY
+        s.extensions = ["ext/extconf.rb"]
+    end
+end
+
+# gem, rdoc, and test tasks below
+
+Rake::GemPackageTask.new(specification) do |package|
+    package.need_zip = false
+    package.need_tar = false
+end
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rd|
+  rd.main = "README.rdoc"
+  rd.rdoc_files.include("README.rdoc", "ext/*.c")
+end
+
+require 'rake/testtask'
+Rake::TestTask.new do |t|
+    t.test_files = FileList['test/test*.rb']
+    t.verbose = true
+end
+
+
+

data/ext/compat.h

@@ -0,0 +1,18 @@
+/* contains basic macros to facilitate ruby 1.8 and ruby 1.9 compatibility */
+
+#ifndef GUARD_COMPAT_H
+#define GUARD_COMPAT_H
+
+#include <ruby.h>
+
+/* 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)
+#endif
+
+/* a useful macro. cannot use ordinary CLASS_OF as it does not return an lvalue */
+#define KLASS_OF(c) (RBASIC(c)->klass)
+
+#endif

data/ext/extconf.rb

@@ -0,0 +1,6 @@
+require 'mkmf'
+
+# 1.9 compatibility
+$CPPFLAGS += " -DRUBY_19" if RUBY_VERSION =~ /1.9/
+
+create_makefile('cobject2module')

data/ext/object2module.c

@@ -0,0 +1,215 @@
+/* object2module.c */
+/* (C) John Mair 2009
+ * This program is distributed under the terms of the MIT License
+ *                                                                */
+
+#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) {
+
+#ifdef RUBY_19
+    VALUE klass = class_alloc(T_ICLASS, rb_cClass);
+#else
+    NEWOBJ(klass, struct RClass);
+    OBJSETUP(klass, rb_cClass, T_ICLASS);
+#endif
+
+    if (BUILTIN_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;
+}
+
+static VALUE
+rb_to_module(VALUE self) {
+    VALUE rclass, chain_start, jcur, klass;
+
+    switch(BUILTIN_TYPE(self)) {
+    case T_MODULE:
+        return self;
+    case T_CLASS:
+        klass = self;
+        break;
+    case T_OBJECT:
+    default:
+        klass = rb_singleton_class(self);            
+    }
+            
+    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);
+    }
+
+    RCLASS_SUPER(jcur) = (VALUE)NULL;
+
+    return chain_start;
+}
+
+static VALUE
+rb_reset_tbls(VALUE self) {
+    RCLASS_IV_TBL(self) = (struct st_table *) 0;
+    RCLASS_M_TBL(self) = (struct st_table *) st_init_numtable();
+    
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *     obj.gen_extend(other, ...)    => obj
+ *  
+ *  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"
+ */
+
+static VALUE
+rb_gen_extend(int argc, VALUE * argv, VALUE self) {
+    int i;
+
+    if (argc == 0) rb_raise(rb_eArgError, "wrong number of arguments (0 for 1)");
+    
+    rb_singleton_class(self);
+
+    for(i = 0; i < argc; i++) {
+        VALUE mod = rb_to_module(argv[i]);
+        rb_funcall(mod, rb_intern("extend_object"), 1, self);
+        rb_funcall(mod, rb_intern("extended"), 1, self);
+        
+        /* only redirect if argv[i] is not a module */
+        if(argv[i] != mod) rb_reset_tbls(mod);
+    }
+
+    return self;
+}
+
+/*
+ *  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"
+ */
+
+static VALUE
+rb_gen_include(int argc, VALUE * argv, VALUE self) {
+    int i;
+
+    if (argc == 0) rb_raise(rb_eArgError, "wrong number of arguments (0 for 1)");
+
+    for(i = 0; i < argc; i++) {
+        VALUE mod = rb_to_module(argv[i]);
+        rb_funcall(mod, rb_intern("append_features"), 1, self);
+        rb_funcall(mod, rb_intern("included"), 1, self);
+
+        if(argv[i] != mod) rb_reset_tbls(mod);       
+    }
+
+    return self;
+}
+ 
+
+void Init_cobject2module() {
+
+    /* too dangerous as may result in double free. */
+    rb_define_method(rb_cObject, "to_module", rb_to_module , 0);
+
+    /* these methods are fine */
+    rb_define_method(rb_cObject, "gen_extend", rb_gen_extend, -1);
+    rb_define_method(rb_cModule, "gen_include", rb_gen_include, -1);
+    rb_define_method(rb_cModule, "reset_tbls", rb_reset_tbls, 0);
+}
+

data/ext/object2module.h

@@ -0,0 +1,11 @@
+/* object2module.h */
+
+#ifndef GUARD_OBJECT2MODULE_H
+#define GUARD_OBJECT2MODULE_H
+        
+VALUE rb_gen_include(int argc, VALUE * argv, VALUE self);
+VALUE rb_gen_extend(int argc, VALUE * argv, VALUE self);
+VALUE rb_to_module(VALUE self);
+VALUE rb_reset_tbls(VALUE self);
+
+#endif

data/lib/object2module.rb

@@ -0,0 +1,13 @@
+require 'rbconfig'
+
+direc = File.dirname(__FILE__)
+dlext = Config::CONFIG['DLEXT']
+begin
+    if RUBY_VERSION && RUBY_VERSION =~ /1.9/
+        require "#{direc}/cobject2module.19.#{dlext}"
+    else
+        require "#{direc}/cobject2module.18.#{dlext}"
+    end
+rescue LoadError => e
+    require "#{direc}/cobject2module.#{dlext}"
+end

data/test/test_object2module.rb

@@ -0,0 +1,145 @@
+require 'test/unit'
+require '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                                        

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification 
+name: object2module
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- John Mair (banisterfiend)
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-25 00:00:00 +12:00
+default_executable: 
+dependencies: []
+
+description: object2module enables ruby classes and objects to be used as modules
+email: jrmair@gmail.com
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: 
+- README.rdoc
+- ext/object2module.c
+files: 
+- Rakefile
+- lib/object2module.rb
+- README.rdoc
+- ext/object2module.c
+- ext/object2module.h
+- ext/compat.h
+- ext/extconf.rb
+- test/test_object2module.rb
+has_rdoc: true
+homepage: http://banisterfiend.wordpress.com
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: object2module enables ruby classes and objects to be used as modules
+test_files: []
+