remix 0.1.0-i386-mingw32

data/CHANGELOG

@@ -0,0 +1,2 @@
+25/10/2010 version 0.1.0
+* release!

data/README.markdown

@@ -0,0 +1,40 @@
+Remix
+--------------
+
+(c) John Mair (banisterfiend) 
+MIT license
+
+Makes inheritance chains read/write
+
+** This is BETA software and has not yet been thoroughly tested, use
+   at own risk **
+
+Currently supports:
+
+* include_at(index)
+* include_before(BeforeMod, Mod)
+* include_after(AfterMod, Mod)
+* swap_modules(Mod1, Mod2)
+* remove_module(Mod)
+* ...more to come!
+
+example: 
+
+    module M end
+
+    class A; end
+
+    class B < A
+      include_after(A, M)
+    end
+
+    B.ancestors #=> [B, A, M, ...]
+    B.swap_modules A, M
+    B.ancestors #=> [B, M, A, ...]
+    module J end
+    B.include_before A, J
+    B.ancestors #=> [B, M, J, A, ...]
+    B.remove_module M
+    B.ancestors #=> [B, J, A, ...]
+    
+    

data/Rakefile

@@ -0,0 +1,37 @@
+$LOAD_PATH.unshift File.join(File.expand_path(__FILE__), '..')
+
+require 'rake/clean'
+require 'rake/gempackagetask'
+
+require 'lib/remix/version'
+
+$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")
+
+specification = Gem::Specification.new do |s|
+  s.name = "remix"
+  s.summary = "Ruby modules re-mixed and remastered"
+  s.version = Remix::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.platform = Gem::Platform::RUBY
+  s.platform = 'i386-mingw32'
+  s.homepage = "http://banisterfiend.wordpress.com"
+  s.has_rdoc = 'yard'
+
+  #s.extensions = ["ext/remix/extconf.rb"]
+  s.files =  ["Rakefile", "README.markdown", "CHANGELOG", 
+              "lib/remix.rb", "lib/remix/version.rb"] +
+    ["lib/1.9/remix.so", "lib/1.8/remix.so"] +
+  FileList["ext/**/extconf.rb", "ext/**/*.h", "ext/**/*.c"].to_a 
+end
+
+Rake::GemPackageTask.new(specification) do |package|
+  package.need_zip = false
+  package.need_tar = false
+end

data/ext/remix/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/remix/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+
+create_makefile('remix')

data/ext/remix/remix.c

@@ -0,0 +1,241 @@
+/* object2module.c */
+/* (C) John Mair 2009
+ * This program is distributed under the terms of the MIT License
+ *                                                                */
+
+#include <ruby.h>
+#include "compat.h"
+
+/* a modified version of include_class_new from class.c */
+static VALUE
+j_class_new(VALUE module, VALUE sup)
+{
+
+  VALUE klass = create_class(T_ICLASS, rb_cClass);
+
+  if (TYPE(module) == T_ICLASS) {
+    klass = 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);
+
+  if (TYPE(module) == T_ICLASS) {
+    if (!RTEST(rb_iv_get(module, "__module__")))
+      rb_iv_set(klass, "__module__", KLASS_OF(module));
+  }
+  else if (TYPE(module) == T_MODULE || TYPE(module) == T_CLASS)
+    rb_iv_set(klass, "__module__", 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) = rb_iv_get(klass, "__module__");
+  }
+  else {
+    KLASS_OF(klass) = module;
+  }
+
+  if(TYPE(module) != T_OBJECT) {
+    OBJ_INFECT(klass, module);
+    OBJ_INFECT(klass, sup);
+  }
+
+  return (VALUE)klass;
+}
+
+static VALUE
+set_supers(VALUE c)
+{
+  if (RCLASS_SUPER(c) == rb_cObject || RCLASS_SUPER(c) == Qnil) {
+    return RCLASS_SUPER(c);
+  }
+  else {
+    return j_class_new(RCLASS_SUPER(c), set_supers(RCLASS_SUPER(c)));
+  }
+}
+
+VALUE
+rb_prepare_for_remix(VALUE klass)
+{
+  if (!RTEST(rb_obj_is_kind_of(klass, rb_cModule)))
+    rb_raise(rb_eTypeError, "Must be a Module or Class type.");
+
+  RCLASS_SUPER(klass) = set_supers(klass);
+
+  rb_clear_cache();
+  return klass;
+}
+
+inline static VALUE
+get_source_module(VALUE mod)
+{
+  switch (TYPE(mod)) {
+  case T_ICLASS:
+    if (RTEST(rb_iv_get(mod, "__module__")))
+      return rb_iv_get(mod, "__module__");
+    else
+      return KLASS_OF(mod);
+    break;
+  case T_CLASS:
+  case T_MODULE:
+    return mod;
+    break;
+  default:
+    rb_raise(rb_eRuntimeError, "get_source_module: mod is not a class or iclass!");
+  }
+  
+  /* never reached */
+  return Qnil;
+}
+
+static VALUE
+retrieve_before_mod(VALUE m, VALUE before)
+{
+  VALUE k = get_source_module(RCLASS_SUPER(m));
+  while(k != before && m != Qnil && m != rb_cObject) {
+    m = RCLASS_SUPER(m);
+    k = get_source_module(RCLASS_SUPER(m));
+  }
+  if (get_source_module(RCLASS_SUPER(m)) != before)
+    rb_raise(rb_eRuntimeError, "'before' module not found");
+
+  return m;
+}
+
+static VALUE
+retrieve_mod(VALUE m, VALUE after)
+{
+  VALUE k = get_source_module(m);
+  while(k != after && m != Qnil && m != rb_cObject) {
+    m = RCLASS_SUPER(m);
+    k = get_source_module(m);
+  }
+
+  if (k != after)
+    rb_raise(rb_eRuntimeError, "'after' module not found");
+
+  return m;
+}
+
+VALUE
+rb_include_after(VALUE self, VALUE after, VALUE mod)
+{
+  rb_prepare_for_remix(self);
+
+  VALUE k, m = self;
+
+  k = get_source_module(m);
+  while(k != after && m != Qnil && m != rb_cObject) {
+    m = RCLASS_SUPER(m);
+    k = get_source_module(m);
+  }
+
+  if (k != after)
+    rb_raise(rb_eRuntimeError, "'after' module not found");
+
+  rb_include_module(m, mod);
+
+  return self;
+}
+
+VALUE
+rb_include_before(VALUE self, VALUE before, VALUE mod)
+{
+  rb_prepare_for_remix(self);
+
+  VALUE k, m = self;
+
+  k = get_source_module(RCLASS_SUPER(m));
+  while(k != before && m != Qnil && m != rb_cObject) {
+    m = RCLASS_SUPER(m);
+    k = get_source_module(RCLASS_SUPER(m));
+  }
+
+  if (get_source_module(RCLASS_SUPER(m)) != before)
+    rb_raise(rb_eRuntimeError, "'before' module not found");
+
+  rb_include_module(m, mod);
+
+  return self;
+}
+
+VALUE
+rb_include_at(VALUE self, VALUE mod, VALUE rb_index)
+{
+  rb_prepare_for_remix(self);
+
+  int index = FIX2INT(rb_index);
+  VALUE m = self;
+
+  int i = 0;
+  while(i++ < index && RCLASS_SUPER(m) != Qnil && RCLASS_SUPER(m) != rb_cObject)
+    m = RCLASS_SUPER(m);
+
+  rb_include_module(m, mod);
+  return self;
+}
+
+#define SWAP(X, Y)  {(X) ^= (Y); (Y) ^= (X); (X) ^= (Y);}
+
+VALUE
+rb_swap_modules(VALUE self, VALUE mod1, VALUE mod2)
+{
+  rb_prepare_for_remix(self);
+
+  VALUE before_mod1, before_mod2;
+  VALUE included_mod1, included_mod2;
+
+  if (mod1 == rb_cObject || mod2 == rb_cObject) rb_raise(rb_eRuntimeError, "can't swap Object");
+
+  included_mod1 = retrieve_mod(self, mod1);
+  included_mod2 = retrieve_mod(self, mod2);
+  before_mod1 = retrieve_before_mod(self, mod1);
+  before_mod2 = retrieve_before_mod(self, mod2);
+
+  SWAP(RCLASS_SUPER(before_mod1), RCLASS_SUPER(before_mod2));
+  SWAP(RCLASS_SUPER(included_mod1), RCLASS_SUPER(included_mod2));
+
+  rb_clear_cache();
+
+  return  self;
+}
+
+VALUE
+rb_remove_module(VALUE self, VALUE mod1)
+{
+  rb_prepare_for_remix(self);
+
+  VALUE before = retrieve_before_mod(self, mod1);
+  VALUE included_mod = retrieve_mod(self, mod1);
+  
+  if (mod1 == rb_cObject) rb_raise(rb_eRuntimeError, "can't delete Object");
+  RCLASS_SUPER(before) = RCLASS_SUPER(included_mod);
+  rb_clear_cache();
+
+  return self;
+}
+
+void
+Init_remix()
+{
+  rb_define_method(rb_cObject, "ready_remix", rb_prepare_for_remix, 0);
+  rb_define_method(rb_cModule, "include_at", rb_include_at, 2);
+  rb_define_method(rb_cModule, "include_before", rb_include_before, 2);
+  rb_define_method(rb_cModule, "include_after", rb_include_after, 2);
+  rb_define_method(rb_cModule, "swap_modules", rb_swap_modules, 2);
+  rb_define_method(rb_cModule, "remove_module", rb_remove_module, 1);
+}
+

data/lib/remix/version.rb

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

data/lib/remix.rb

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

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: remix
+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-10-25 00:00:00 +13:00
+default_executable: 
+dependencies: []
+
+description: Ruby modules re-mixed and remastered
+email: jrmair@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- README.markdown
+- CHANGELOG
+- lib/remix.rb
+- lib/remix/version.rb
+- lib/1.9/remix.so
+- lib/1.8/remix.so
+- ext/remix/extconf.rb
+- ext/remix/compat.h
+- ext/remix/remix.c
+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: Ruby modules re-mixed and remastered
+test_files: []
+