real_include 0.1.6-i386-mingw32 → 0.1.7-i386-mingw32

data/CHANGELOG

@@ -1,4 +1,8 @@
-6/10/210 version 0.1.3
+15/10/2010 version 0.1.7
+* should be properly working with normal Module#include now
+* no more segfaults?
+* added more tests	
+6/10/2010 version 0.1.3
 * fixed native gem
 * moved more version-dependant code to compat.h
 5/10/2010 version 0.1.2

data/Rakefile

@@ -23,7 +23,7 @@ specification = Gem::Specification.new do |s|
   #s.platform = Gem::Platform::RUBY
   s.platform = 'i386-mingw32'
   s.homepage = "http://banisterfiend.wordpress.com"
-  s.has_rdoc = false
+  s.has_rdoc = 'yard'
 
   s.extensions = ["ext/real_include/extconf.rb"]
   s.files =  ["Rakefile", "README.markdown", "CHANGELOG", 

data/ext/real_include/patched_include.c

@@ -0,0 +1,130 @@
+/* (c) 2010 John Mair (banisterfiend), MIT license */
+/* patches Module#include to work correctly with real_include */
+
+#include <ruby.h>
+#include "compat.h"
+
+#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
+
+/* patched to work well with real_include */
+static VALUE
+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_singleton_class(rb_cModule), T_ICLASS);
+#endif
+  
+  if (BUILTIN_TYPE(module) == T_ICLASS) {
+
+    /***************************************************************************** */
+    /* This is the only change required, everything else is (pretty much) copypasta from class.c */
+    /* correct for real_include'd modules */
+    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;
+}
+
+static void
+rb_patched_include_module(VALUE klass, VALUE module)
+{
+  VALUE p, c;
+  int changed = 0;
+
+  rb_frozen_class_p(klass);
+  if (!OBJ_UNTRUSTED(klass)) {
+    rb_secure(4);
+  }
+
+  if (TYPE(module) != T_MODULE) {
+    Check_Type(module, T_MODULE);
+  }
+
+  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;
+      }
+    }
+    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();
+}
+
+static VALUE
+rb_patched_mod_append_features(VALUE module, VALUE include)
+{
+  switch (TYPE(include)) {
+  case T_CLASS:
+  case T_MODULE:
+    break;
+  default:
+    Check_Type(include, T_CLASS);
+    break;
+  }
+  rb_patched_include_module(include, module);
+
+  return module;
+}
+
+void
+Init_patched_include() {
+  rb_define_method(rb_cModule, "append_features", rb_patched_mod_append_features, 1);
+}

data/ext/real_include/real_include.c

@@ -1,161 +1,11 @@
 /* (c) 2010 John Mair (banisterfiend), MIT license */
 
-#include "compat.h"
-#include "ruby.h"
-
-#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
-
-
-static VALUE
-class_to_s(VALUE self)
-{
-  VALUE attached = rb_iv_get(self, "__attached__");
-  
-  if (attached) 
-    return rb_mod_name(rb_iv_get(attached, "__module__"));
-  else
-    return rb_mod_name(rb_iv_get(self, "__module__"));
-}
-
-static VALUE
-include_class_new(VALUE module, VALUE super)
-{
-  /* base case for recursion */
-  if (module == rb_singleton_class(rb_cModule))
-    return module;
-
-  if (TYPE(module) == T_ICLASS) {
-
-    /* real_include */
-    if (rb_iv_get(module, "__module__"))
-      module = rb_iv_get(module, "__module__");
-
-    /* ordinary Module#include */
-    else
-      module = KLASS_OF(module);
-  }
-    
-  /* allocate iclass */
-#ifdef RUBY_19
-  VALUE klass = class_alloc(T_ICLASS, rb_singleton_class(rb_cModule));
-#else
-  NEWOBJ(klass, struct RClass);
-  OBJSETUP(klass, rb_singleton_class(rb_cModule), T_ICLASS);
-#endif
-  /* we want a fresh ivtbl */
-  RCLASS_IV_TBL(klass) = st_init_numtable();
-
-  /* we want to copy the mtbl */
-  RCLASS_M_TBL(klass) = RCLASS_M_TBL(module);
-  RCLASS_SUPER(klass) = super;
-
-  if (TYPE(module) == T_MODULE ||  FL_TEST(module, FL_SINGLETON))
-    rb_iv_set(klass, "__module__", module);
-    
-  /* create IClass for module's singleton  */
-  /* if super is 0 then we're including into a module (not a class), so treat as special case */
-  VALUE meta = include_class_new(KLASS_OF(module), super ? KLASS_OF(super) : rb_cModule);
-
-  /* don't mess with (Module) */
-  if (meta != rb_singleton_class(rb_cModule)) {
-
-    /* set it as a singleton */
-    FL_SET(meta, FL_SINGLETON);
-
-    /* attach singleton to module */
-    rb_iv_set(meta, "__attached__", klass);
-
-    /* attach the #to_s method to the metaclass (so #ancestors doesn't look weird) */
-    rb_define_singleton_method(meta, "to_s", class_to_s, 0);
-  }
-  /* assign the metaclass to module's klass */
-  KLASS_OF(klass) = meta;
-        
-  OBJ_INFECT(klass, module);
-  OBJ_INFECT(klass, super);
-
-  return (VALUE)klass;
-}
-
-VALUE
-rb_real_include_module(VALUE klass, VALUE module)
-{
-  VALUE p, c;
-  int changed = 0;
-
-  rb_frozen_class_p(klass);
-  if (!OBJ_UNTRUSTED(klass)) {
-    rb_secure(4);
-  }
-
-  if (TYPE(module) != T_MODULE) {
-    Check_Type(module, T_MODULE);
-  }
-
-  OBJ_INFECT(klass, module);
-  c = klass;
-
-  /* ensure singleton classes exist, both for includer and includee */
-  rb_singleton_class(module);
-  rb_singleton_class(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;
-      }
-    }
-
-    /* we're including the module, so create the iclass */
-    VALUE imod = include_class_new(module, RCLASS_SUPER(c));
-
-    /* module gets included directly above c, so set the super */
-    RCLASS_SUPER(c) = imod;
-
-    /* also do the same for parallel inheritance chain (singleton classes) */
-    RCLASS_SUPER(KLASS_OF(c)) = KLASS_OF(imod);
-    c = imod;
-        
-    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;
-}
+void Init_patched_include(void);
+void Init_real_include_one(void);
 
 void
-Init_real_include() {
-  rb_define_method(rb_cModule, "real_include", rb_real_include_module, 1);
+Init_real_include()
+{
+  Init_real_include_one();
+  Init_patched_include();
 }

data/ext/real_include/real_include_one.c

@@ -0,0 +1,164 @@
+/* (c) 2010 John Mair (banisterfiend), MIT license */
+/* include a module (and its singleton) into an inheritance chain */
+/* only includes a single module, see real_include.rb for multi-module version */
+
+#include <ruby.h>
+#include "compat.h"
+
+#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
+
+
+static VALUE
+class_to_s(VALUE self)
+{
+  VALUE attached = rb_iv_get(self, "__attached__");
+  
+  if (attached) 
+    return rb_mod_name(rb_iv_get(attached, "__module__"));
+  else
+    return rb_mod_name(rb_iv_get(self, "__module__"));
+}
+
+/* totally hacked up version of include_class_new() from class.c; brings in singletons into inheritance chain */
+static VALUE
+include_class_new(VALUE module, VALUE super)
+{
+  /* base case for recursion */
+  if (module == rb_singleton_class(rb_cModule))
+    return module;
+
+  if (TYPE(module) == T_ICLASS) {
+
+    /* real_include */
+    if (!NIL_P(rb_iv_get(module, "__module__")))
+      module = rb_iv_get(module, "__module__");
+
+    /* ordinary Module#include */
+    else
+      module = KLASS_OF(module);
+  }
+    
+  /* allocate iclass */
+#ifdef RUBY_19
+  VALUE klass = class_alloc(T_ICLASS, rb_singleton_class(rb_cModule));
+#else
+  NEWOBJ(klass, struct RClass);
+  OBJSETUP(klass, rb_singleton_class(rb_cModule), T_ICLASS);
+#endif
+  /* we want a fresh ivtbl */
+  RCLASS_IV_TBL(klass) = st_init_numtable();
+
+  /* we want to copy the mtbl */
+  RCLASS_M_TBL(klass) = RCLASS_M_TBL(module);
+  RCLASS_SUPER(klass) = super;
+
+  if (TYPE(module) == T_MODULE ||  FL_TEST(module, FL_SINGLETON))
+    rb_iv_set((VALUE)klass, "__module__", module);
+    
+  /* create IClass for module's singleton  */
+  /* if super is 0 then we're including into a module (not a class), so treat as special case */
+  VALUE meta = include_class_new(KLASS_OF(module), super ? KLASS_OF(super) : rb_cModule);
+
+  /* don't mess with (Module) */
+  if (meta != rb_singleton_class(rb_cModule)) {
+
+    /* set it as a singleton */
+    FL_SET(meta, FL_SINGLETON);
+
+    /* attach singleton to module */
+    rb_iv_set(meta, "__attached__", (VALUE)klass);
+
+    /* attach the #to_s method to the metaclass (so #ancestors doesn't look weird) */
+    rb_define_singleton_method(meta, "to_s", class_to_s, 0);
+  }
+  /* assign the metaclass to module's klass */
+  KLASS_OF(klass) = meta;
+        
+  OBJ_INFECT(klass, module);
+  OBJ_INFECT(klass, super);
+
+  return (VALUE)klass;
+}
+
+static VALUE
+rb_real_include_module_one(VALUE klass, VALUE module)
+{
+  VALUE p, c;
+  int changed = 0;
+
+  rb_frozen_class_p(klass);
+  if (!OBJ_UNTRUSTED(klass)) {
+    rb_secure(4);
+  }
+
+  if (TYPE(module) != T_MODULE) {
+    Check_Type(module, T_MODULE);
+  }
+
+  OBJ_INFECT(klass, module);
+  c = klass;
+
+  /* ensure singleton classes exist, both for includer and includee */
+  rb_singleton_class(module);
+  rb_singleton_class(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;
+      }
+    }
+
+    /* we're including the module, so create the iclass */
+    VALUE imod = include_class_new(module, RCLASS_SUPER(c));
+
+    /* module gets included directly above c, so set the super */
+    RCLASS_SUPER(c) = imod;
+
+    /* also do the same for parallel inheritance chain (singleton classes) */
+    RCLASS_SUPER(KLASS_OF(c)) = KLASS_OF(imod);
+    c = imod;
+        
+    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;
+}
+
+void
+Init_real_include_one() {
+  rb_define_method(rb_cModule, "real_include_one", rb_real_include_module_one, 1);
+}

data/lib/real_include/version.rb

@@ -1,3 +1,3 @@
 module RealInclude
-  VERSION = "0.1.6"
+  VERSION = "0.1.7"
 end

data/lib/real_include.rb

@@ -1,3 +1,5 @@
+# (c) 2010 John Mair (banisterfiend), MIT license
+
 direc = File.dirname(__FILE__)
 
 begin
@@ -13,3 +15,28 @@ rescue LoadError => e
 end
 
 require "#{direc}/real_include/version"
+
+
+class Module
+
+  # include multiple modules (and their singletons) into an
+  # inheritance chain
+  # @param [Module] mods Modules to real_include
+  # @return Returns the receiver
+  # @example
+  #   module M
+  #     def self.hello
+  #       puts "hello"
+  #     end
+  #   end
+  #   class C
+  #     real_include M
+  #   end
+  #   C.hello #=> "hello"
+  def real_include(*mods)
+    mods.each do |mod|
+      real_include_one mod
+    end
+    self
+  end
+end

data/test/test.rb

@@ -51,7 +51,6 @@ describe 'Including a module into a module and then into a class using real_incl
         :instance_method2
       end
     }
-
     @m2.send(:real_include, @m1)
 
     @c = Class.new
@@ -74,4 +73,141 @@ describe 'Including a module into a module and then into a class using real_incl
     obj.instance_method1.should.equal :instance_method1
     obj.instance_method2.should.equal :instance_method2
   end
+
+  it 'should make ancestor chain "look" accurate' do
+    @m1 = Module.new {
+      def self.class_method1
+        :class_method1
+      end
+
+      def instance_method1
+        :instance_method1
+      end
+    }
+
+    Object.const_set(:M1, @m1) 
+
+    @m2 = Module.new {
+      def self.class_method2
+        :class_method2
+      end
+
+      def instance_method2
+        :instance_method2
+      end
+    }
+    Object.const_set(:M2, @m2) 
+
+    @m2.send(:real_include, @m1)
+
+    @c = Class.new
+
+    @c.send(:real_include, @m2)
+    
+    @c.ancestors[1].to_s.should.equal M2.name
+    @c.class_method1.should.equal :class_method1
+    @c.class_method2.should.equal :class_method2
+  end
+
+  it 'should work if real_including a module that has another module included using Module#include' do
+    @m1 = Module.new {
+      def self.class_method1
+        :class_method1
+      end
+
+      def instance_method1
+        :instance_method1
+      end
+    }
+
+    Object.const_set(:N1, @m1) 
+
+    @m2 = Module.new {
+      def self.class_method2
+        :class_method2
+      end
+
+      def instance_method2
+        :instance_method2
+      end
+    }
+    Object.const_set(:N2, @m2) 
+
+    @m2.send(:include, @m1)
+
+    @c = Class.new
+
+    @c.send(:real_include, @m2)
+    
+    @c.ancestors[1].to_s.should.equal N2.name
+    @c.ancestors[2].to_s.should.equal N1.name
+    @c.class_method1.should.equal :class_method1
+    @c.class_method2.should.equal :class_method2
+  end
+
+  it 'should work if Module#including a module that has another module included using real_include' do
+    @m1 = Module.new {
+      def self.class_method1
+        :class_method1
+      end
+
+      def instance_method1
+        :instance_method1
+      end
+    }
+
+    Object.const_set(:K1, @m1) 
+
+    @m2 = Module.new {
+      def self.class_method2
+        :class_method2
+      end
+
+      def instance_method2
+        :instance_method2
+      end
+    }
+    Object.const_set(:K2, @m2) 
+
+    @m2.send(:real_include, @m1)
+
+    @c = Class.new
+
+    @c.send(:include, @m2)
+    
+    @c.ancestors[1].should.equal K2
+    @c.ancestors[2].should.equal K1
+    @c.new.instance_method1.should.equal :instance_method1
+    @c.new.instance_method2.should.equal :instance_method2
+  end
+  
+
+  it 'should work with multiple modules passed to real_include' do
+    @m1 = Module.new {
+      def self.class_method1
+        :class_method1
+      end
+
+      def instance_method1
+        :instance_method1
+      end
+    }
+
+    @m2 = Module.new {
+      def self.class_method2
+        :class_method2
+      end
+
+      def instance_method2
+        :instance_method2
+      end
+    }
+
+    @c = Class.new
+    @c.send(:real_include, @m2, @m1)
+    
+    @c.class_method1.should.equal :class_method1
+    @c.class_method2.should.equal :class_method2
+  end
+    
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: real_include
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 21
   prerelease: false
   segments: 
   - 0
   - 1
-  - 6
-  version: 0.1.6
+  - 7
+  version: 0.1.7
 platform: i386-mingw32
 authors: 
 - John Mair (banisterfiend)
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-12 00:00:00 +13:00
+date: 2010-10-16 00:00:00 +13:00
 default_executable: 
 dependencies: []
 
@@ -37,9 +37,11 @@ files:
 - lib/1.8/real_include.so
 - ext/real_include/extconf.rb
 - ext/real_include/compat.h
+- ext/real_include/patched_include.c
 - ext/real_include/real_include.c
+- ext/real_include/real_include_one.c
 - test/test.rb
-has_rdoc: false
+has_rdoc: yard
 homepage: http://banisterfiend.wordpress.com
 licenses: []