remix 0.2.0-i386-mingw32 → 0.2.5-i386-mingw32

data/CHANGELOG

@@ -1,3 +1,10 @@
+27/10/2010 version 0.2.5
+* added tests
+* reversed order of arguments for #include_at
+* made it so first index of #include_at is 1 (not 0, since 0 is host module)
+* added extend-based methods
+* reordered modules (Remix::ObjectExtenstions and Remix::ModuleExtensions)
+* added recursive uninclude
 26/10/2010 version 0.2.0
 * added include_at_top, replace_module, module_move_up, etc
 25/10/2010 version 0.1.0

data/README.markdown

@@ -1,54 +1,142 @@
 Remix
---------------
+=======
 
-(c) John Mair (banisterfiend) 
-MIT license
+(C) John Mair (banisterfiend) 2010
 
-Ruby modules re-mixed and remastered
+_Ruby modules remixed and remastered_
 
-** This is BETA software and has not yet been thoroughly tested, use
-   at own risk **
-   
-install the gem: **for testing purposes only**
-`gem install remix`
+Remix is a library to give you total control over class and module ancestor
+chains. 
 
-Currently supports:
+Using Remix you can add a module at any point in the chain,
+remove modules, replace modules, move modules around and otherwise
+'remix' your modules.
 
-* include_at(index)
-* include_at_top(Mod)
-* include_before(BeforeMod, Mod)
-* include_after(AfterMod, Mod)
-* swap_modules(Mod1, Mod2)
-* remove_module(Mod)
-* module_move_up(Mod)
-* module_move_down(Mod)
-* replace_module(Mod1, Mod2)
-* ...more to come!
+* Install the [gem](https://rubygems.org/gems/remix): `gem install remix`
+* Read the [documentation](http://rdoc.info/github/banister/remix/master/file/README.markdown)
+* See the [source code](http://github.com/banister/remix)
 
-example: 
+example: include_at_top():
+--------------------------
 
-    module M end
+Using `include_at_top` we can include a module at the top of a chain
+rather than at the bottom (the default).
+
+    # ... modules A, B, C, and J defined above...
+    
+    module M
+      include A, B, C
+    end
+    
+    M.ancestors #=> [M, A, B, C]
+    
+    # Now let's insert a module between A and B
+    M.include_at_top J
+    
+    # Modified ancestor chain
+    M.ancestors #=> [M, A, B, C, J]
+    
+example: unextend()
+--------------------
+
+Like the Mixico library Remix allows you to unextend
+(or uninclude) modules from inheritance chains; but also extends this
+functionality by (optionally) removing nested modules too:
+
+
+    # ...modules A, B defined above...
+    
+    module C
+      include A, B
+    end
+    
+    D = Object.new
+    D.extend C
+    D.singleton_class.ancestors #=> [C, A, B, Object, ...]
+    
+    # remove entire nested module C by passing true as second parameter
+    D.unextend C, true
+    
+    D.singleton_class.ancestors #=> [Object, ...]
+    
+Special features
+------------------
 
-    class A; end
+Remix is intelligent enough to manipulate classes as well as
+modules:
 
-    class B < A
-      include_after(A, M)
+    class D < C
+      include M
     end
+    
+    D.ancestors #=> [D, M, C]
+    
+    D.swap_modules C, M
+    
+    D.ancestors #=> [D, C, M]
+    
+It does this by first converting all superclasses to Included Modules
+before remixing takes place.
 
-    B.ancestors #=> [B, A, M, ...]
+How it works
+--------------
 
-    B.swap_modules A, M
+Remix is a C-based extension that directly manipulates the superclass
+pointers of Included Modules.
 
-    B.ancestors #=> [B, M, A, ...]
+Companion Libraries
+--------------------
 
-    module J end
+Remix is one of a series of experimental libraries that mess with
+the internals of Ruby to bring new and interesting functionality to
+the language, see also:
 
-    B.include_before A, J
+* [Real Include](http://github.com/banister/real_include) - Brings in
+  module singleton classes during an include. No more ugly ClassMethods and included() hook hacks.
+* [Object2module](http://github.com/banister/object2module) - Convert Classes and Objects to Modules so they can be extended/included
+* [Prepend](http://github.com/banister/prepend) - Prepends modules in front of a class; so method lookup starts with the module
+* [GenEval](http://github.com/banister/gen_eval) - A strange new breed of instance_eval
 
-    B.ancestors #=> [B, M, J, A, ...]
+Full list of functions
+----------------------
 
-    B.remove_module M
+**include-based functions:**
 
-    B.ancestors #=> [B, J, A, ...]
-    
-    
+* include_at(index)
+* include_at_top(mod)
+* include_before(before_mod, mod)
+* include_after(after_mod, mod)
+* swap_modules(mod1, mod2)
+* uninclude(mod, recurse=fale)
+* module_move_up(mod)
+* module_move_down(mod)
+* replace_module(mod1, mod2)
+
+**extend-based functions:**
+
+* extend_at(index)
+* extend_at_top(mod)
+* extend_before(before_mod, mod)
+* extend_after(after_mod, mod)
+* swap_extended_modules(mod1, mod2)
+* replace_module(mod1, mod2)
+* unextend(mod, recurse=false)
+* extended_module_move_up(mod)
+* extended_module_move_down(mod)
+
+Limitations
+------------
+
+Remix does not currently reorder the singleton classes of superclasses
+to reflect the new position of the class. This functionality is coming
+soon.
+
+Contact
+-------
+
+Problems or questions contact me at [github](http://github.com/banister)
+
+Dedication
+----------
+
+For Rue (1977-)

data/Rakefile

@@ -25,10 +25,10 @@ specification = Gem::Specification.new do |s|
   s.has_rdoc = 'yard'
 
   #s.extensions = ["ext/remix/extconf.rb"]
-  s.files =  ["Rakefile", "README.markdown", "CHANGELOG", 
-              "lib/remix.rb", "lib/remix/version.rb"] +
+  s.files =  
     ["lib/1.9/remix.so", "lib/1.8/remix.so"] +
-  FileList["ext/**/extconf.rb", "ext/**/*.h", "ext/**/*.c"].to_a 
+    FileList["ext/**/extconf.rb", "ext/**/*.h", "ext/**/*.c", "lib/**/*.rb", "test/*.rb",
+             "CHANGELOG", "README.markdown", "Rakefile"].to_a
 end
 
 Rake::GemPackageTask.new(specification) do |package|

data/ext/remix/remix.c

@@ -106,6 +106,9 @@ get_source_module(VALUE mod)
 static VALUE
 retrieve_before_mod(VALUE m, VALUE before)
 {
+  if (!RTEST(rb_obj_is_kind_of(before, rb_cModule)) && TYPE(before) != T_FALSE)
+    rb_raise(rb_eTypeError, "Must be a Module or Class type.");
+
   VALUE k = get_source_module(RCLASS_SUPER(m));
   while(k != before && m != 0 && m != rb_cObject) {
     m = RCLASS_SUPER(m);
@@ -120,6 +123,9 @@ retrieve_before_mod(VALUE m, VALUE before)
 static VALUE
 retrieve_mod(VALUE m, VALUE after)
 {
+  if (!RTEST(rb_obj_is_kind_of(after, rb_cModule)) && TYPE(after) != T_FALSE)
+    rb_raise(rb_eTypeError, "Must be a Module or Class type.");
+
   VALUE k = get_source_module(m);
   while(k != after && m != 0 && m != rb_cObject) {
     m = RCLASS_SUPER(m);
@@ -191,19 +197,25 @@ VALUE
 rb_include_before(VALUE self, VALUE before, VALUE mod)
 {
   rb_prepare_for_remix(self);
+
+  if (before == self)
+    rb_raise(rb_eRuntimeError, "Prepend not supported yet!");
+  
   rb_include_module(retrieve_before_mod(self, before), mod);
   return self;
 }
 
 VALUE
-rb_include_at(VALUE self, VALUE mod, VALUE rb_index)
+rb_include_at(VALUE self, VALUE rb_index, VALUE mod)
 {
   rb_prepare_for_remix(self);
+  
+  Check_Type(rb_index, T_FIXNUM);
 
   int index = FIX2INT(rb_index);
   VALUE m = self;
 
-  int i = 0;
+  int i = 1;
   while(i++ < index && RCLASS_SUPER(m) != 0 && RCLASS_SUPER(m) != rb_cObject)
     m = RCLASS_SUPER(m);
 
@@ -236,16 +248,40 @@ rb_swap_modules(VALUE self, VALUE mod1, VALUE mod2)
   return  self;
 }
 
+static void
+remove_nested_module(VALUE included_mod, VALUE module)
+{
+  VALUE source_mod = get_source_module(RCLASS_SUPER(included_mod));
+  
+  if (source_mod == rb_cObject || source_mod == Qfalse)
+    return;
+  else if (source_mod == get_source_module(RCLASS_SUPER(module))) {
+    remove_nested_module(RCLASS_SUPER(included_mod), RCLASS_SUPER(module));
+    RCLASS_SUPER(included_mod) = RCLASS_SUPER(RCLASS_SUPER(included_mod));
+  }
+}
+      
 VALUE
-rb_remove_module(VALUE self, VALUE mod1)
+rb_uninclude(int argc, VALUE * argv, VALUE self)
 {
   rb_prepare_for_remix(self);
 
+  VALUE mod1, recurse = Qfalse;
+  rb_scan_args(argc, argv, "11", &mod1, &recurse);
+
+  if (!RTEST(rb_mod_include_p(self, mod1)))
+    rb_raise(rb_eArgError, "Module not found");
+
   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");
+
+  if (RTEST(recurse))
+    remove_nested_module(included_mod, mod1);
+
   RCLASS_SUPER(before) = RCLASS_SUPER(included_mod);
+
   rb_clear_cache();
 
   return self;
@@ -260,7 +296,7 @@ rb_replace_module(VALUE self, VALUE mod1, VALUE mod2)
     return rb_swap_modules(self, mod1, mod2);
   
   VALUE before = retrieve_before_mod(self, mod1);
-  rb_remove_module(self, mod1);
+  rb_uninclude(1, &mod1, self);
   rb_include_module(before, mod2);
   return self;
 }
@@ -268,17 +304,25 @@ rb_replace_module(VALUE self, VALUE mod1, VALUE mod2)
 void
 Init_remix()
 {
-  rb_define_method(rb_cObject, "ready_remix", rb_prepare_for_remix, 0);
-  rb_define_method(rb_cModule, "module_move_up", rb_module_move_up, 1);
-  rb_define_method(rb_cModule, "module_move_down", rb_module_move_down, 1);
-
-  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, "include_at_top", rb_include_at_top, 1);
-
-  rb_define_method(rb_cModule, "swap_modules", rb_swap_modules, 2);
-  rb_define_method(rb_cModule, "remove_module", rb_remove_module, 1);
-  rb_define_method(rb_cModule, "replace_module", rb_replace_module, 2);
+  VALUE mRemix = rb_define_module("Remix");
+  VALUE mModuleExtensions = rb_define_module_under(mRemix, "ModuleExtensions");
+  
+  rb_define_method(mModuleExtensions, "ready_remix", rb_prepare_for_remix, 0);
+  rb_define_method(mModuleExtensions, "module_move_up", rb_module_move_up, 1);
+  rb_define_method(mModuleExtensions, "module_move_down", rb_module_move_down, 1);
+
+  rb_define_method(mModuleExtensions, "include_at", rb_include_at, 2);
+  rb_define_method(mModuleExtensions, "include_below", rb_include_before, 2);
+  rb_define_alias(mModuleExtensions, "include_before", "include_below");
+  rb_define_method(mModuleExtensions, "include_above", rb_include_after, 2);
+  rb_define_alias(mModuleExtensions, "include_after", "include_above");
+  rb_define_method(mModuleExtensions, "include_at_top", rb_include_at_top, 1);
+
+  rb_define_method(mModuleExtensions, "swap_modules", rb_swap_modules, 2);
+  rb_define_method(mModuleExtensions, "uninclude", rb_uninclude, -1);
+  rb_define_alias(mModuleExtensions, "remove_module", "uninclude");
+  rb_define_method(mModuleExtensions, "replace_module", rb_replace_module, 2);
+
+  rb_include_module(rb_cModule, mModuleExtensions);
 }
 

data/lib/remix.rb

@@ -2,6 +2,7 @@ direc = File.dirname(__FILE__)
 
 require 'rbconfig'
 require "#{direc}/remix/version"
+require "#{direc}/remix/c_docs"
 
 dlext = Config::CONFIG['DLEXT']
 
@@ -15,3 +16,74 @@ rescue LoadError => e
     require "#{direc}/remix.#{dlext}"
 end
 
+module Kernel
+  # :nodoc:
+  def singleton_class
+    class << self; self; end
+  end if !respond_to?(:singleton_class)
+end
+
+module Remix::ObjectExtensions
+
+  # Like `include_at()` but for the singleton class
+  # @see Module#include_at
+  def extend_at(index, mod)
+    singleton_class.include_at(index, mod)
+  end
+
+  # Like `include_below()` but for the singleton class
+  # @see Module#include_below
+  def extend_below(mod1, mod2)
+    singleton_class.include_below(mod1, mod2)
+  end
+  alias_method :extend_before, :extend_below
+
+  # Like `include_above()` but for the singleton class
+  # @see Module#include_above
+  def extend_above(mod1, mod2)
+    singleton_class.include_above(mod1, mod2)
+  end
+  alias_method :extend_after, :extend_above
+
+  # Like `uninclude()` but for the singleton class
+  # @see Module#uninclude
+  def unextend(mod, recurse = false)
+    singleton_class.uninclude(mod, recurse)
+  end
+  alias_method :remove_extended_module, :unextend
+
+  # Like `include_at_top()` but for the singleton class
+  # @see Module#include_at_top
+  def extend_at_top(mod)
+    singleton_class.include_at_top(mod)
+  end
+
+  # Like `swap_modules()` but for the singleton class
+  # @see Module#swap_modules
+  def swap_extended_modules(mod1, mod2)
+    singleton_class.swap_modules(mod1, mod2)
+  end
+
+  # Like `module_move_up()` but for the singleton class
+  # @see Module#module_move_up
+  def extended_module_move_up(mod)
+    singleton_class.module_move_up(mod)
+  end
+  
+  # Like `module_move_down()` but for the singleton class
+  # @see Module#module_move_down
+  def extended_module_move_down(mod)
+    singleton_class.module_move_down(mod)
+  end
+
+  # Like `replace_module()` but for the singleton class
+  # @see Module#replace_module_down
+  def replace_extended_module(mod1, mod2)
+    singleton_class.replace_module(mod1, mod2)
+  end
+end
+
+  
+class Object
+  include Remix::ObjectExtensions
+end

data/lib/remix/c_docs.rb

@@ -0,0 +1,114 @@
+module Remix
+  module ModuleExtensions
+    # Includes a module at a particular index in the ancestor
+    # chain.
+    #
+    # @param [Fixnum] index The index where the module will be included
+    # (must be > 1.)
+    # @param [Module] mod The module to include
+    # @return [Module] The receiver
+    # @example
+    #   module M end
+    #   module N end
+    #   module O end
+    #   module P
+    #     include M, N
+    #   end
+    #   P.include_at 2, O
+    #   P.ancestors #=> [P, M, O, N]
+    def include_at(index, mod) end
+
+    # Includes a module below a specific module in the ancestor chain.
+    # @param [Module] mod1 Module with position
+    # @param [Module] mod2 Module that will be included
+    # @return [Module] The receiver
+    # @example
+    #   M.ancestors #=> [M, A, B]
+    #   M.include_below B, J
+    #   M.ancestors #=> [M, A, J, B]
+    def include_below(mod1, mod2) end
+
+    # Includes a module above a specific module in the ancestor chain.
+    # @param [Module] mod1 Module with position
+    # @param [Module] mod2 Module that will be included
+    # @return [Module] The receiver
+    # @example
+    #   M.ancestors #=> [M, A, B]
+    #   M.include_above B, J
+    #   M.ancestors #=> [M, A, B, J]
+    def include_above(mod1, mod) end
+    
+    # Includes a module at top of ancestor chain
+    # @param [Module] mod Module that will be included
+    # @return [Module] The receiver
+    # @example
+    #   M.ancestors #=> [M, A, B]
+    #   M.include_at_top J
+    #   M.ancestors #=> [M, A, B, J]
+    def include_at_top(mod) end
+    
+    # Moves a module up one position in the ancestor chain.
+    # Module must already be in ancestor chain.
+    # @param [Module] Module to move up
+    # @return [Module] The receiver
+    # @example
+    #   M.ancestors #=> [M, A, B]
+    #   M.module_move_up A
+    #   M.ancestors #=> [M, B, A]
+    def module_move_up(mod) end
+
+    # Moves a module down one position in the ancestor chain.
+    # Module must already be in ancestor chain.
+    # @param [Module] Module to move down
+    # @return [Module] The receiver
+    # @example
+    #   M.ancestors #=> [M, A, B]
+    #   M.module_move_down B
+    #   M.ancestors #=> [M, B, A]
+    def module_move_down(mod) end
+
+    # Unincludes a module from an ancestor chain with optional recursion
+    # for nested modules.
+    # @param [Module] mod The module to uninclude
+    # @param [Boolean] recurse Set to true to remove nested modules
+    # @return [Module] The receiver
+    # @example
+    #   module C
+    #     include A, B
+    #   end
+    #   M.ancestors #=> [M, C, A, B]
+    #   M.uninclude C
+    #   M.ancestors #=> [M, A, B]
+    # @example With recursion
+    #   module C
+    #     include A, B
+    #   end
+    #   M.ancestors #=> [M, C, A, B]
+    #   M.uninclude C, true
+    #   M.ancestors #=> [M]
+    def uninclude(mod, recurse = false) end
+
+    # Swaps the position of two modules that already exist in an
+    # ancestor chain.
+    # @param [Module] mod1 Module to swap
+    # @param [Module] mod2 Module to swap
+    # @return [Module] The receiver
+    # @example
+    #   M.ancestors #=> [M, A, B, C, D]
+    #   M.swap_modules A, D
+    #   M.ancestors #=> [M, D, B, C, A]
+    def swap_modules(mod1, mod2) end
+
+    # Replaces a module with another module that is not already in the
+    # ancestor chain.
+    # @param [Module] mod1 The module to be replaced
+    # @param [Module] mod2 The module that will replace
+    # @return [Module] The receiver
+    # @example
+    #   J = Module.new
+    #   M.ancestors #=> [M, A, B]
+    #   M.replace_module B, J
+    #   M.ancestors #=> [M, A, J]
+    def replace_module(mod1, mod2) end
+  end
+end

data/lib/remix/version.rb

@@ -1,3 +1,3 @@
 module Remix
-  VERSION = "0.2.0"
+  VERSION = "0.2.5"
 end

data/test/test.rb

@@ -0,0 +1,137 @@
+require 'rubygems'
+require '../lib/remix'
+require 'bacon'
+
+class Module
+  public :include, :remove_const
+end
+
+describe 'Test basic remix functionality' do
+  before do
+    A = Module.new
+    B = Module.new
+    C = Module.new
+    J = Module.new
+    
+    M = Module.new
+
+    M.include A, B
+    M.extend A, B
+  end
+
+  after do
+    Object.remove_const(:A)
+    Object.remove_const(:B)
+    Object.remove_const(:C)
+    Object.remove_const(:M)
+    Object.remove_const(:J)
+  end
+
+  describe 'extend-based methods' do
+    describe 'extend_after' do
+      it 'should insert module into correct position in singleton class' do
+        M.extend_above B, J
+        M.singleton_class.ancestors
+        M.singleton_class.ancestors[0..2].should == [A, B, J]
+      end
+    end
+
+    describe 'unextend' do
+      it 'should unextend the module' do
+        C.include A, B
+        M.extend C
+        M.singleton_class.ancestors[0..2].should == [C, A, B]
+        M.unextend C
+        M.singleton_class.ancestors[0..1].should == [A, B]
+      end
+
+      it 'should unextend the nested module' do
+        C.include A, B
+        M.extend C
+        M.extend J
+        M.singleton_class.ancestors[0..3].should == [J, C, A, B]
+        M.unextend C, true
+        M.singleton_class.ancestors[0..1].should == [J, Module]
+      end      
+    end
+  end
+  
+  describe 'include-based methods' do
+    describe 'include_after' do
+      it 'should insert module into correct position' do
+        M.include_after A, C
+        M.ancestors[2].should == C
+      end
+    end
+
+    describe 'include_before' do
+      it 'should insert module into correct position' do
+        M.include_before B, C
+        M.ancestors[2].should == C
+      end
+    end
+
+    describe 'include_at_top' do
+      it 'should insert module at top of chain' do
+        M.include_at_top C
+        M.ancestors.last.should == C
+      end
+    end
+    
+    describe 'swap_modules' do
+      it 'should interchange modules' do
+        M.ancestors[1..2].should == [A, B]
+        M.swap_modules A, B
+        M.ancestors[1..2].should == [B, A]
+      end
+    end
+
+    describe 'module_move_up' do
+      it 'should move module up the chain' do
+        M.ancestors[1..2].should == [A, B]
+        M.module_move_up A
+        M.ancestors[1..2].should == [B, A]
+      end
+    end
+
+    describe 'module_move_down' do
+      it 'should move module down the chain' do
+        M.ancestors[1..2].should == [A, B]
+        M.module_move_down B
+        M.ancestors[1..2].should == [B, A]
+      end
+    end
+
+    describe 'include_at' do
+      it 'should include module at specified index' do
+        M.include_at(1, C)
+        M.ancestors[1].should == C
+      end
+    end
+
+    describe 'remove_module' do
+      it 'should remove the module' do
+        M.ancestors[1..2].should == [A, B]
+        M.remove_module A
+        M.ancestors[1..2].should == [B]
+      end
+
+      it 'should remove recursively if second parameter is true' do
+        klass = Module.new
+        klass.include J, M, C
+        klass.ancestors[1..-1].should == [J, M, A, B, C]
+        klass.remove_module M, true
+        klass.ancestors[1..-1].should == [J, C]
+      end
+    end
+
+    describe 'replace_module' do
+      it 'should replace the module with another' do
+        M.ancestors[1..2].should == [A, B]
+        M.replace_module B, C
+        M.ancestors[1..2].should == [A, C]
+      end
+    end
+    
+  end
+end

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: remix
 version: !ruby/object:Gem::Version 
-  hash: 23
   prerelease: false
   segments: 
   - 0
   - 2
-  - 0
-  version: 0.2.0
+  - 5
+  version: 0.2.5
 platform: i386-mingw32
 authors: 
 - John Mair (banisterfiend)
@@ -15,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-26 00:00:00 +13:00
+date: 2010-10-27 00:00:00 +13:00
 default_executable: 
 dependencies: []
 
@@ -28,16 +27,18 @@ 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
+- lib/remix/c_docs.rb
+- lib/remix/version.rb
+- lib/remix.rb
+- test/test.rb
+- CHANGELOG
+- README.markdown
+- Rakefile
 has_rdoc: yard
 homepage: http://banisterfiend.wordpress.com
 licenses: []
@@ -52,7 +53,6 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
@@ -61,7 +61,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"