remix 0.4.0-i386-mswin32 → 0.4.5-i386-mswin32

data/CHANGELOG

@@ -1,4 +1,10 @@
-11/11/201 version 0.4.0
+12/11/2010 versino 0.4.5
+* added tests to swap_module and replace_module to prevent
+  mod1 and mod2 being the same module
+* fixed bug in swap_module when ancestor chains were huge
+* added :before and :after hooks for temp_include and friends
+* added tests for hooks and for swap_module crashing bug
+11/11/2010 version 0.4.0
 * added temp_include and temp_extend, and threadsafe variants
 	temp_include_safe etc
 27/10/2010 version 0.2.5

data/Rakefile

@@ -28,7 +28,6 @@ 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|
@@ -57,3 +56,19 @@ namespace :ruby do
   end
 end
 
+desc "build all platform gems at once"
+task :gems => [:rmgems, "mingw32:gem", "mswin32:gem", "ruby:gem"]
+
+desc "remove all platform gems"
+task :rmgems => ["ruby:clobber_package"]
+
+task :pushgems => :gems do
+  chdir("#{direc}/pkg") do
+    Dir["*.gem"].each do |gemfile|
+      sh "gem push #{gemfile}"
+    end
+  end
+end
+
+  
+

data/ext/remix/remix.c

@@ -249,6 +249,7 @@ rb_swap_modules(VALUE self, VALUE mod1, VALUE mod2)
   VALUE included_mod1, included_mod2;
 
   if (mod1 == rb_cObject || mod2 == rb_cObject) rb_raise(rb_eRuntimeError, "can't swap Object");
+  if (mod1 == mod2) return self;
 
   included_mod1 = retrieve_imod_for_mod(self, mod1);
   included_mod2 = retrieve_imod_for_mod(self, mod2);
@@ -332,6 +333,8 @@ rb_replace_module(VALUE self, VALUE mod1, VALUE mod2)
 
   if (rb_classmod_include_p(self, mod2))
     return rb_swap_modules(self, mod1, mod2);
+
+  if (mod1 == mod2) return;
   
   VALUE before = retrieve_imod_before_mod(self, mod1);
   rb_uninclude(1, &mod1, self);

data/lib/remix.rb

@@ -10,154 +10,174 @@ require "#{direc}/remix/c_docs"
 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
+  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}"
+  require "#{direc}/remix.#{dlext}"
 end
 
 module Kernel
-  # define a `singleton_class` method for the 1.8 kids
+  # Define a `singleton_class` method for the 1.8 kids
   # @return [Class] The singleton class of the receiver
   def singleton_class
     class << self; self; end
   end if !respond_to?(:singleton_class)
 end
 
-module Remix::ObjectExtensions
-
-  # Temporarily extends a module for the duration of a block.
-  # Module will be unextended at end of block.
-  # @param [Module] mod Module to be temporarily extended
-  def temp_extend(mod, &block)
-    begin
-      extend(mod)
-      yield
-    ensure
-      unextend(mod, true)
-    end
-  end
+module Remix
 
-  # Temporarily extends a module for the duration of a block in a
-  # thread-safe manner.
-  # Module will be unextended at end of block.
-  # @param [Module] mod Module to be temporarily extended
-  def temp_extend_safe(mod, &block)
-    safe_code = proc do
-      begin
-        extend(mod)
-        yield
-      ensure
-        unextend(mod, true)
+  # Wraps a block of code so that `before` and `after` lambdas are invoked
+  # prior to and after the block.
+  # @return [Object] The return value of the block
+  def self.wrap_with_hooks(before, after, &block)
+    before.call if before
+    yield
+  ensure
+    after.call if after
+  end
+  
+  module ObjectExtensions
+
+    # Temporarily extends a module for the duration of a block.
+    # Module will be unextended at end of block.
+    # @param [Module] mod Module to be temporarily extended
+    def temp_extend(mod, options={}, &block)
+      Remix.wrap_with_hooks(options[:before], options[:after]) do
+        begin
+          extend(mod)
+          yield
+        ensure
+          unextend(mod, true)
+        end
       end
     end
-    
-    if !Thread.current[:__exclusive__]
-      Thread.exclusive { Thread.current[:__exclusive__] = true; safe_code.call }
-      Thread.current[:__exclusive__] = false
-    else
-      safe_code.call
-    end
-  end
 
-  # Like `include_at()` but for the singleton class
-  # @see Remix::ModuleExtensions#include_at
-  def extend_at(index, mod)
-    singleton_class.include_at(index, mod)
-  end
+    # Temporarily extends a module for the duration of a block in a
+    # thread-safe manner.
+    # Module will be unextended at end of block.
+    # @param [Module] mod Module to be temporarily extended
+    def temp_extend_safe(mod, options={}, &block)
+      safe_code = proc do
+        Remix.wrap_with_hooks(options[:before], options[:after]) do
+          begin
+            extend(mod)
+            yield
+          ensure
+            unextend(mod, true)
+          end
+        end
+      end
+      
+      if !Thread.current[:__exclusive__]
+        Thread.exclusive { Thread.current[:__exclusive__] = true; safe_code.call }
+        Thread.current[:__exclusive__] = false
+      else
+        safe_code.call
+      end
+    end
 
-  # Like `include_below()` but for the singleton class
-  # @see Remix::ModuleExtensions#include_below
-  def extend_below(mod1, mod2)
-    singleton_class.include_below(mod1, mod2)
-  end
-  alias_method :extend_before, :extend_below
+    # Like `include_at()` but for the singleton class
+    # @see Remix::ModuleExtensions#include_at
+    def extend_at(index, mod)
+      singleton_class.include_at(index, mod)
+    end
 
-  # Like `include_above()` but for the singleton class
-  # @see Remix::ModuleExtensions#include_above
-  def extend_above(mod1, mod2)
-    singleton_class.include_above(mod1, mod2)
-  end
-  alias_method :extend_after, :extend_above
+    # Like `include_below()` but for the singleton class
+    # @see Remix::ModuleExtensions#include_below
+    def extend_below(mod1, mod2)
+      singleton_class.include_below(mod1, mod2)
+    end
+    alias_method :extend_before, :extend_below
 
-  # Like `uninclude()` but for the singleton class
-  # @see Remix::ModuleExtensions#uninclude
-  def unextend(mod, recurse = false)
-    singleton_class.uninclude(mod, recurse)
-  end
-  alias_method :remove_extended_module, :unextend
+    # Like `include_above()` but for the singleton class
+    # @see Remix::ModuleExtensions#include_above
+    def extend_above(mod1, mod2)
+      singleton_class.include_above(mod1, mod2)
+    end
+    alias_method :extend_after, :extend_above
 
-  # Like `include_at_top()` but for the singleton class
-  # @see Remix::ModuleExtensions#include_at_top
-  def extend_at_top(mod)
-    singleton_class.include_at_top(mod)
-  end
+    # Like `uninclude()` but for the singleton class
+    # @see Remix::ModuleExtensions#uninclude
+    def unextend(mod, recurse = false)
+      singleton_class.uninclude(mod, recurse)
+    end
+    alias_method :remove_extended_module, :unextend
 
-  # Like `swap_modules()` but for the singleton class
-  # @see Remix::ModuleExtensions#swap_modules
-  def swap_extended_modules(mod1, mod2)
-    singleton_class.swap_modules(mod1, mod2)
-  end
+    # Like `include_at_top()` but for the singleton class
+    # @see Remix::ModuleExtensions#include_at_top
+    def extend_at_top(mod)
+      singleton_class.include_at_top(mod)
+    end
 
-  # Like `module_move_up()` but for the singleton class
-  # @see Remix::ModuleExtensions#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 Remix::ModuleExtensions#module_move_down
-  def extended_module_move_down(mod)
-    singleton_class.module_move_down(mod)
-  end
+    # Like `swap_modules()` but for the singleton class
+    # @see Remix::ModuleExtensions#swap_modules
+    def swap_extended_modules(mod1, mod2)
+      singleton_class.swap_modules(mod1, mod2)
+    end
 
-  # Like `replace_module()` but for the singleton class
-  # @see Remix::ModuleExtensions#replace_module_down
-  def replace_extended_module(mod1, mod2)
-    singleton_class.replace_module(mod1, mod2)
-  end
-end
+    # Like `module_move_up()` but for the singleton class
+    # @see Remix::ModuleExtensions#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 Remix::ModuleExtensions#module_move_down
+    def extended_module_move_down(mod)
+      singleton_class.module_move_down(mod)
+    end
 
-module Remix::ModuleExtensions
-
-  # Temporarily includes a module for the duration of a block.
-  # Module will be unincluded at end of block.
-  # @param [Module] mod Module to be temporarily included
-  def temp_include(mod, &block)
-    begin
-      include(mod)
-      yield
-    ensure
-      uninclude(mod, true)
+    # Like `replace_module()` but for the singleton class
+    # @see Remix::ModuleExtensions#replace_module_down
+    def replace_extended_module(mod1, mod2)
+      singleton_class.replace_module(mod1, mod2)
     end
   end
 
-  # Temporarily includes a module for the duration of a block in a
-  # thread-safe manner.
-  # Module will be unincluded at end of block.
-  # @param [Module] mod Module to be temporarily included
-  def temp_include_safe(mod, &block)
-    safe_code = proc do
-      begin
-        include(mod)
-        yield
-      ensure
-        uninclude(mod, true)
+  module Remix::ModuleExtensions
+
+    # Temporarily includes a module for the duration of a block.
+    # Module will be unincluded at end of block.
+    # @param [Module] mod Module to be temporarily included
+    def temp_include(mod, options={}, &block)
+      Remix.wrap_with_hooks(options[:before], options[:after]) do
+        begin
+          include(mod)
+          yield
+        ensure
+          uninclude(mod, true)
+        end
       end
     end
-    
-    if !Thread.current[:__exclusive__]
-      Thread.exclusive { Thread.current[:__exclusive__] = true; safe_code.call }
-      Thread.current[:__exclusive__] = false
-    else
-      safe_code.call
+
+    # Temporarily includes a module for the duration of a block in a
+    # thread-safe manner.
+    # Module will be unincluded at end of block.
+    # @param [Module] mod Module to be temporarily included
+    def temp_include_safe(mod, options={}, &block)
+      safe_code = proc do
+        Remix.wrap_with_hooks(options[:before], options[:after]) do
+          begin
+            include(mod)
+            yield
+          ensure
+            uninclude(mod, true)
+          end
+        end
+      end
+      
+      if !Thread.current[:__exclusive__]
+        Thread.exclusive { Thread.current[:__exclusive__] = true; safe_code.call }
+        Thread.current[:__exclusive__] = false
+      else
+        safe_code.call
+      end
     end
   end
 end
-  
 
 # bring extend-based methods into Object  
 class Object

data/lib/remix/version.rb

@@ -1,4 +1,4 @@
 module Remix
-  VERSION = "0.4.0"
+  VERSION = "0.4.5"
 end
 

data/test/test.rb

@@ -54,156 +54,202 @@ describe 'Test basic remix functionality' do
         end
         lambda { B.hello }.should.raise NoMethodError
       end
-    end
 
-    describe 'temp_extend_safe' do
-      it 'should temporarily extend the module for the duration of a block in a threadsafe manner' do
+      it 'should execute before and after hooks prior to and after running the temp_extend block' do
         lambda { B.hello }.should.raise NoMethodError
-        B.temp_extend_safe(A) do
+        B.instance_variable_defined?(:@before).should == false
+        B.instance_variable_defined?(:@after).should == false
+        B.temp_extend(A,
+                      :before => proc { B.instance_variable_set(:@before, true) },
+                      :after => proc { B.instance_variable_set(:@after, true) } ) do
+          B.instance_variable_get(:@before).should == true
+          B.instance_variable_defined?(:@after).should == false
           B.hello.should == :hello
         end
+        B.instance_variable_get(:@after).should == true
+        B.instance_variable_get(:@before).should == true
         lambda { B.hello }.should.raise NoMethodError
       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]
+      
+      describe 'temp_extend_safe' do
+        it 'should temporarily extend the module for the duration of a block in a threadsafe manner' do
+          lambda { B.hello }.should.raise NoMethodError
+          B.temp_extend_safe(A) do
+            B.hello.should == :hello
+          end
+          lambda { B.hello }.should.raise NoMethodError
+        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
+        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
 
-      it 'should unextend the class of the object' do
-        o = C2.new
-        o.singleton_class.ancestors.first.should == C2
-        o.unextend(C2)
-        o.singleton_class.ancestors.first.should == A
+        it 'should unextend the class of the object' do
+          o = C2.new
+          o.singleton_class.ancestors.first.should == C2
+          o.unextend(C2)
+          o.singleton_class.ancestors.first.should == A
+        end
       end
-    end
-    
-    describe 'replace_extended_module' do
-      it 'should replace the class of the object with a module' do
-        o = C2.new
-        o.singleton_class.ancestors.first.should == C2
-        o.replace_extended_module C2, J
-        o.singleton_class.ancestors.first.should == J
+      
+      describe 'replace_extended_module' do
+        it 'should replace the class of the object with a module' do
+          o = C2.new
+          o.singleton_class.ancestors.first.should == C2
+          o.replace_extended_module C2, J
+          o.singleton_class.ancestors.first.should == J
+        end
       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
+    
+    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
-    end
 
-    describe 'temp_include' do
-      it 'should temporarily include the module for the duration of a block' do
-        lambda { "john".hello }.should.raise NoMethodError
-        String.temp_include(A) do
-          "john".hello.should == :hello
+      describe 'temp_include' do
+        it 'should temporarily include the module for the duration of a block' do
+          lambda { "john".hello }.should.raise NoMethodError
+          String.temp_include(A) do
+            "john".hello.should == :hello
+          end
+          lambda { "john".hello }.should.raise NoMethodError
         end
-        lambda { "john".hello }.should.raise NoMethodError
-      end
-    end
 
-    describe 'temp_include_safe' do
-      it 'should temporarily include the module for the duration of a block in a threadsafe manner' do
-        lambda { "john".hello }.should.raise NoMethodError
-        String.temp_include_safe(A) do
-          "john".hello.should == :hello
+        it 'should execute before and after hooks prior to and after running the temp_include block' do
+          lambda { B.hello }.should.raise NoMethodError
+          B.instance_variable_defined?(:@before).should == false
+          B.instance_variable_defined?(:@after).should == false
+          B.temp_include(A,
+                        :before => proc { B.instance_variable_set(:@before, true) },
+                        :after => proc { B.instance_variable_set(:@after, true) } ) do
+            B.instance_variable_get(:@before).should == true
+            B.instance_variable_defined?(:@after).should == false
+          end
+          B.instance_variable_get(:@after).should == true
+          B.instance_variable_get(:@before).should == true
+          lambda { B.hello }.should.raise NoMethodError
         end
-        lambda { "john".hello }.should.raise NoMethodError
+        
       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
+      describe 'temp_include_safe' do
+        it 'should temporarily include the module for the duration of a block in a threadsafe manner' do
+          lambda { "john".hello }.should.raise NoMethodError
+          String.temp_include_safe(A) do
+            "john".hello.should == :hello
+          end
+          lambda { "john".hello }.should.raise NoMethodError
+        end
       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]
+      
+      describe 'include_before' do
+        it 'should insert module into correct position' do
+          M.include_before B, C
+          M.ancestors[2].should == C
+        end
       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]
+      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
-    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
 
-    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]
+        it 'should handle huge ancestor chains without crashing or returning the wrong result' do
+          size = 100
+          m = Module.new
+          size.times do
+            m.include Module.new
+          end
+
+          m.ancestors.size.should == size + 1
+          size.times do
+            m.swap_modules(m.ancestors[rand(size - 1) + 1],
+                           m.ancestors[rand(size - 1) + 1])
+          end
+          m.ancestors.size.should == size + 1
+        end
       end
-    end
 
-    describe 'include_at' do
-      it 'should include module at specified index' do
-        M.include_at(1, C)
-        M.ancestors[1].should == C
+      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
-    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]
+      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
 
-      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]
+      describe 'include_at' do
+        it 'should include module at specified index' do
+          M.include_at(1, C)
+          M.ancestors[1].should == C
+        end
       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]
+      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
 
-      it 'should replace a class with a module' do
-        C2.ancestors[0..2].should == [C2, A, C1]
-        C2.replace_module C1, B
-        C2.ancestors[0..2].should == [C2, A, B]
+      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
+
+        it 'should replace a class with a module' do
+          C2.ancestors[0..2].should == [C2, A, C1]
+          C2.replace_module C1, B
+          C2.ancestors[0..2].should == [C2, A, B]
+        end
       end
     end
-    
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: remix
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 5
   prerelease: false
   segments: 
   - 0
   - 4
-  - 0
-  version: 0.4.0
+  - 5
+  version: 0.4.5
 platform: i386-mswin32
 authors: 
 - John Mair (banisterfiend)
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-11 00:00:00 +13:00
+date: 2010-11-12 00:00:00 +13:00
 default_executable: 
 dependencies: []