include_complete 0.1.0-i386-mingw32

data/CHANGELOG

@@ -0,0 +1,20 @@
+1/11/2010 *NAME CHANGE* TO include_complete, version reset to 0.1.0
+* now called include_complete
+22/10/2010 version 0.2.2
+* refactored compat.h, incorporated test for 1.9
+* created inline static function create_class() in compat.h
+20/10/2010 version 0.2.1
+* constant lookup should now work
+* added real_extend and tests
+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
+* added 1.8 support
+* added bacon tests
+4/10/10 version 0.1.0
+* release! This is still beta, not 100% tested yet..but appears to work OK so far

data/README.markdown

@@ -0,0 +1,40 @@
+Include Complete
+----------------
+
+(c) John Mair (banisterfiend) 
+MIT license
+
+Removes the shackles from Module#include - use Module#real_include to
+bring in singleton classes from modules. No more ugly ClassMethods and
+included() hook hacks.
+
+** This is BETA software and has not yet been thoroughly tested, use
+   at own risk **
+
+install the gem: **for testing purposes only**
+`gem install include_complete`
+
+example: 
+
+    module M
+        # class method
+        def self.hello
+            puts "hello!"
+        end
+
+        # instance method
+        def bye
+            puts "bye!"
+        end
+    end
+
+    class A
+        include_complete M
+    end
+
+    # invoke class method
+    A.hello #=> hello!
+
+    # invoke instance method
+    A.new.bye #=> bye!
+

data/Rakefile

@@ -0,0 +1,59 @@
+$LOAD_PATH.unshift File.join(File.expand_path(__FILE__), '..')
+
+direc = File.dirname(__FILE__)
+dlext = Config::CONFIG['DLEXT']
+
+require 'rake/clean'
+require 'rake/gempackagetask'
+require './lib/include_complete/version'
+
+CLEAN.include("ext/**/*.#{dlext}", "ext/**/*.log", "ext/**/*.o", "ext/**/*~", "ext/**/*#*", "ext/**/*.obj", "ext/**/*.def", "ext/**/*.pdb")
+CLOBBER.include("**/*.#{dlext}", "**/*~", "**/*#*", "**/*.log", "**/*.o")
+
+def apply_spec_defaults(s)
+  s.name = "include_complete"
+  s.summary = "Fixing the limitations in traditional Module#include"
+  s.version = IncludeComplete::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 = 'yard'
+  s.files =  FileList["Rakefile", "README.markdown", "CHANGELOG", 
+                      "lib/**/*.rb", "ext/**/extconf.rb", "ext/**/*.h",
+                      "ext/**/*.c", "test/**/*.rb"].to_a 
+end
+
+task :test do
+  sh "bacon -k #{direc}/test/test.rb"
+end
+
+[:mingw32, :mswin32].each do |v|
+  namespace v do
+    spec = Gem::Specification.new do |s|
+      apply_spec_defaults(s)        
+      s.platform = "i386-#{v}"
+      s.files += FileList["lib/**/*.#{dlext}"].to_a
+    end
+
+    Rake::GemPackageTask.new(spec) do |pkg|
+      pkg.need_zip = false
+      pkg.need_tar = false
+    end
+  end
+end
+
+namespace :ruby do
+  spec = Gem::Specification.new do |s|
+    apply_spec_defaults(s)        
+    s.platform = Gem::Platform::RUBY
+    s.extensions = ["ext/include_complete/extconf.rb"]
+  end
+
+  Rake::GemPackageTask.new(spec) do |pkg|
+    pkg.need_zip = false
+    pkg.need_tar = false
+  end
+end

data/ext/include_complete/compat.h

@@ -0,0 +1,57 @@
+/* contains basic macros to facilitate ruby 1.8 and ruby 1.9 compatibility */
+
+#ifndef GUARD_COMPAT_H
+#define GUARD_COMPAT_H
+
+#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)
+
+#endif

data/ext/include_complete/extconf.rb

@@ -0,0 +1,6 @@
+require 'mkmf'
+
+# let's use c99
+$CFLAGS += " -std=c99"
+
+create_makefile('include_complete')

data/ext/include_complete/include_complete.c

@@ -0,0 +1,11 @@
+/* (c) 2010 John Mair (banisterfiend), MIT license */
+
+void Init_patched_include(void);
+void Init_include_complete_one(void);
+
+void
+Init_include_complete()
+{
+  Init_include_complete_one();
+  Init_patched_include();
+}

data/ext/include_complete/include_complete_one.c

@@ -0,0 +1,151 @@
+/* (c) 2010 John Mair (banisterfiend), MIT license */
+/* */
+/* include a module (and its singleton) into an inheritance chain */
+/* only includes a single module, see include_complete.rb for multi-module version */
+
+#include <ruby.h>
+#include "compat.h"
+
+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) {
+
+    /* include_complete */
+    if (!NIL_P(rb_iv_get(module, "__module__")))
+      module = rb_iv_get(module, "__module__");
+
+    /* ordinary Module#include */
+    else
+      module = KLASS_OF(module);
+  }
+    
+  /* allocate iclass */
+  VALUE klass = create_class(T_ICLASS, rb_singleton_class(rb_cModule));
+
+  /* if the module hasn't yet got an ivtbl, create it */
+  if (!RCLASS_IV_TBL(module))
+    RCLASS_IV_TBL(module) = st_init_numtable();
+
+  /* we want to point to the original ivtbl for normal modules, so that we bring in constants */
+  RCLASS_IV_TBL(klass) = RCLASS_IV_TBL(module);
+  
+  /* we want to point to the original module's 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);
+
+    /* we want a fresh ivtbl for singleton classes (so we can redefine __attached__) */
+    RCLASS_IV_TBL(meta) = st_init_numtable();
+
+    /* 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_include_complete_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_include_complete_one() {
+  rb_define_method(rb_cModule, "include_complete_one", rb_include_complete_module_one, 1);
+}

data/ext/include_complete/patched_include.c

@@ -0,0 +1,109 @@
+/* (c) 2010 John Mair (banisterfiend), MIT license */
+/* patches Module#include to work correctly with real_include */
+
+#include <ruby.h>
+#include "compat.h"
+
+/* patched to work well with real_include */
+static VALUE
+include_class_new(VALUE module, VALUE super)
+{
+  VALUE klass = create_class(T_ICLASS, rb_cClass);
+  
+  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/lib/include_complete/version.rb

@@ -0,0 +1,3 @@
+module IncludeComplete
+  VERSION = "0.1.0"
+end

data/lib/include_complete.rb

@@ -0,0 +1,62 @@
+# (c) 2010 John Mair (banisterfiend), MIT license
+
+direc = File.dirname(__FILE__)
+
+begin
+  if RUBY_VERSION && RUBY_VERSION =~ /1.9/
+    require "#{direc}/1.9/include_complete"
+  else
+    require "#{direc}/1.8/include_complete"
+  end
+rescue LoadError => e
+  require 'rbconfig'
+  dlext = Config::CONFIG['DLEXT']
+  require "#{direc}/include_complete.#{dlext}"
+end
+
+require "#{direc}/include_complete/version"
+
+
+class Module
+
+  # include modules (and their singletons) into an
+  # inheritance chain
+  # @param [Module] mods Modules to include_complete
+  # @return Returns the receiver
+  # @example
+  #   module M
+  #     def self.hello
+  #       puts "hello"
+  #     end
+  #   end
+  #   class C
+  #     include_complete M
+  #   end
+  #   C.hello #=> "hello"
+  def include_complete(*mods)
+    mods.each do |mod|
+      include_complete_one mod
+    end
+    self
+  end
+end
+
+class Object
+
+  # extend modules (and their singletons) into an
+  # inheritance chain
+  # @param [Module] mods Modules to extend_complete
+  # @return Returns the receiver
+  # @example
+  #   module M
+  #     def self.hello
+  #       puts "hello"
+  #     end
+  #   end
+  #   o = Object.new
+  #   o.extend_complete M
+  #   o.singleton_class.hello #=> "hello"
+  def extend_complete(*mods)
+    class << self; self; end.send(:include_complete, *mods)
+  end
+end

data/test/stress_test.rb

@@ -0,0 +1,14 @@
+require '../lib/real_include'
+
+5000.times {
+  m = Module.new
+  n = Module.new
+  k = Module.new
+  n.real_include m
+  k.real_include n
+
+  c = Class.new
+  c.real_include k
+}
+
+"stress test passed!".display

data/test/test.rb

@@ -0,0 +1,262 @@
+direc = File.dirname(__FILE__)
+
+require 'rubygems'
+require "#{direc}/../lib/include_complete"
+require 'bacon'
+
+puts "Testing IncludeComplete version #{IncludeComplete::VERSION}..."
+puts "Ruby version #{RUBY_VERSION}"
+
+describe 'Including a module into a class using include_complete' do
+  before do
+    @m = Module.new {
+      def self.class_method
+        :class_method
+      end
+
+      def instance_method
+        :instance_method
+      end
+    }
+
+    @m::CONST = :const
+
+    @c = Class.new
+
+    @c.send(:include_complete, @m)
+  end
+
+  it 'should make class methods accessible to class' do
+    @c.class_method.should.equal :class_method
+  end
+
+  it 'should make instance methods accessible to instances of the class' do
+    obj = @c.new
+    obj.instance_method.should.equal :instance_method
+  end
+
+  it 'should make constants accessible to the class' do
+    lambda { @c::CONST }.should.not.raise NameError
+  end
+end
+
+describe 'Extending a module into a class using extend_complete' do
+  before do
+    @m = Module.new {
+      def self.class_method
+        :class_method
+      end
+
+      def instance_method
+        :instance_method
+      end
+    }
+
+    @m::CONST = :const
+
+    @c = Class.new
+
+    @c.send(:extend_complete, @m)
+  end
+
+  it 'should make instance methods from the module available as class methods on the class' do
+    @c.instance_method.should.equal :instance_method
+  end
+
+  it 'should make class methods from the module available as class methods on the singleton class' do
+    class << @c; self; end.class_method.should.equal :class_method
+  end
+end
+
+    
+describe 'Including a module into a module and then into a class using include_complete' do
+    before do
+    @m1 = Module.new {
+      def self.class_method1
+        :class_method1
+      end
+
+      def instance_method1
+        :instance_method1
+      end
+    }
+
+    @m1::CONST1 = :const1
+
+    @m2 = Module.new {
+      def self.class_method2
+        :class_method2
+      end
+
+      def instance_method2
+        :instance_method2
+      end
+    }
+    @m2.send(:include_complete, @m1)
+
+    @m2::CONST2 = :const2
+
+    @c = Class.new
+
+    @c.send(:include_complete, @m2)
+  end
+
+  it 'should make class methods on m1 accessible to m2' do
+    @m2.class_method1.should.equal :class_method1
+  end
+
+  it 'should make constants on m1 and m2 accessible to class' do
+    lambda { @c::CONST1 == :const1 }.should.not.raise NameError
+    lambda { @m2::CONST1 == :const1 }.should.not.raise NameError
+    lambda { @c::CONST2 == :const2 }.should.not.raise NameError
+  end
+
+  it 'should make class methods on modules m1 and m2 accessible to class' do
+    @c.class_method1.should.equal :class_method1
+    @c.class_method2.should.equal :class_method2
+  end
+
+  it 'should make instance methods on modules m1 and m2 accessible to instances of class' do
+    obj = @c.new
+
+    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(:include_complete, @m1)
+
+    @c = Class.new
+
+    @c.send(:include_complete, @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(:include_complete, @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 include_complete' 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(:include_complete, @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 include_complete' 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(:include_complete, @m2, @m1)
+    
+    @c.class_method1.should.equal :class_method1
+    @c.class_method2.should.equal :class_method2
+  end
+    
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: include_complete
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: i386-mingw32
+authors: 
+- John Mair (banisterfiend)
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-01 00:00:00 +13:00
+default_executable: 
+dependencies: []
+
+description: Fixing the limitations in traditional Module#include
+email: jrmair@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- README.markdown
+- CHANGELOG
+- lib/include_complete/version.rb
+- lib/include_complete.rb
+- ext/include_complete/extconf.rb
+- ext/include_complete/compat.h
+- ext/include_complete/include_complete.c
+- ext/include_complete/include_complete_one.c
+- ext/include_complete/patched_include.c
+- test/stress_test.rb
+- test/test.rb
+- lib/1.8/include_complete.so
+- lib/1.9/include_complete.so
+has_rdoc: yard
+homepage: http://banisterfiend.wordpress.com
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Fixing the limitations in traditional Module#include
+test_files: []
+