remix 0.4.8-i386-mswin32 → 0.4.9-i386-mswin32

data/CHANGELOG

@@ -1,3 +1,5 @@
+16/11/2010 version 0.4.9
+* added __attached__ method 
 15/11/2010 version 0.4.8
 * all extend-based methods now return self
 * added documentation on blocks (@yield)

data/ext/remix/remix.c

@@ -21,6 +21,16 @@ VALUE rb_swap_modules(VALUE self, VALUE mod1, VALUE mod2);
     rb_raise(rb_eTypeError, "Must be a T_MODULE, T_CLASS, T_ICLASS, T_OBJECT, or T_FALSE type."); \
   } while(0)
 
+/* Tiny utility method to return an object attached to a singleton */
+static VALUE
+rb_singleton_attached(VALUE self)
+{
+  if(FL_TEST(self, FL_SINGLETON))
+    return rb_iv_get(self, "__attached__");
+  else
+    return Qnil;
+}
+
 /* a modified version of include_class_new from class.c */
 static VALUE
 j_class_new(VALUE module, VALUE sup)
@@ -365,5 +375,8 @@ Init_remix()
   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_define_method(mModuleExtensions, "__attached__", rb_singleton_attached, 0);
+
 }
 

data/lib/remix/c_docs.rb

@@ -1,5 +1,13 @@
 module Remix
   module ModuleExtensions
+
+    # Utility method to return object associated with a singleton class
+    # @return Object associated with singleton
+    # @example
+    #   class C; end
+    #   C.singleton_class.__attached__ #=> C
+    def __attached__() end
+      
     # Includes a module at a particular index in the ancestor
     # chain.
     #

data/lib/remix/c_docs_flymake.rb

@@ -0,0 +1,116 @@
+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
+    #   P.ancestors #=> [P, M, N]
+    #   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] mod The 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] mod The 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 Without recursion
+    #   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
+
+    # Prepares the receiver's ancestor chain for remixing. This method
+    # is called automatically by all remixing methods and should
+    # never need to be invoked by the user.
+    # @return [Object] The receiver
+    def ready_remix() end
+  end
+end

data/lib/remix/version.rb

@@ -1,4 +1,4 @@
 module Remix
-  VERSION = "0.4.8"
+  VERSION = "0.4.9"
 end
 

data/lib/remix/version_flymake.rb

@@ -0,0 +1,4 @@
+module Remix
+  VERSION = "0.4.9"
+end
+

data/test/test.rb

@@ -206,6 +206,13 @@ describe 'Test basic remix functionality' do
         end
       end
 
+      describe '__attached__' do
+        it 'should return the correct attached object' do
+          o = Object.new
+          o.singleton_class.__attached__.should == o
+        end
+      end
+
       describe 'module_move_up' do
         it 'should move module up the chain' do
           M.ancestors[1..2].should == [A, B]

data/test/test_flymake.rb

@@ -0,0 +1,269 @@
+direc = File.dirname(__FILE__)
+require 'rubygems'
+require "#{direc}/../lib/remix"
+require 'bacon'
+
+class Module
+  public :include, :remove_const
+end
+
+puts "testing Remix version #{Remix::VERSION}..." 
+puts "Ruby version: #{RUBY_VERSION}"
+
+describe 'Test basic remix functionality' do
+  before do
+    A = Module.new { def hello; :hello; end }
+    B = Module.new
+    C = Module.new 
+    J = Module.new
+    
+    M = Module.new
+
+    M.include A, B
+    M.extend A, B
+
+    C1 = Class.new
+    C2 = Class.new(C1)
+    C2.include A
+  end
+
+  after do
+    Object.remove_const(:A)
+    Object.remove_const(:B)
+    Object.remove_const(:C)
+    Object.remove_const(:M)
+    Object.remove_const(:J)
+    Object.remove_const(:C1)
+    Object.remove_const(:C2)
+  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 'temp_extend' do
+      it 'should temporarily extend the module for the duration of a block' do
+        lambda { B.hello }.should.raise NoMethodError
+        B.temp_extend(A) do
+          B.hello.should == :hello
+        end
+        lambda { B.hello }.should.raise NoMethodError
+      end
+
+      it 'should execute before and after hooks prior to and after running the temp_extend block' do
+        lambda { B.hello }.should.raise NoMethodError
+        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
+      
+      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 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
+      
+      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
+    
+    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 '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
+
+        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
+        
+      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
+          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
+        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
+
+        it 'should do a no-op when source/dest modules are the same' do
+          M.ancestors[1..2].should == [A, B]
+          M.swap_modules A, A
+          M.ancestors[1..2].should == [A, B]
+          M.swap_modules B, B
+          M.ancestors[1..2].should == [A, B]
+        end
+
+        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
+
+      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
+        
+
+        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
+
+        it 'should raise when replace_module target is the root module of the chain' do
+          M.ancestors[0..2].should == [M, A, B]
+          lambda { M.replace_module M, J }.should.raise RuntimeError
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: remix
 version: !ruby/object:Gem::Version 
+  hash: 29
   prerelease: false
   segments: 
   - 0
   - 4
-  - 8
-  version: 0.4.8
+  - 9
+  version: 0.4.9
 platform: i386-mswin32
 authors: 
 - John Mair (banisterfiend)
@@ -14,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-15 00:00:00 +13:00
+date: 2010-11-16 00:00:00 +13:00
 default_executable: 
 dependencies: []
 
@@ -31,9 +32,12 @@ files:
 - ext/remix/compat.h
 - ext/remix/remix.c
 - lib/remix/c_docs.rb
+- lib/remix/c_docs_flymake.rb
 - lib/remix/version.rb
+- lib/remix/version_flymake.rb
 - lib/remix.rb
 - test/test.rb
+- test/test_flymake.rb
 - test/test_with_object2module.rb
 - CHANGELOG
 - README.markdown
@@ -54,6 +58,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
@@ -62,6 +67,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"