jackbox 0.9.6.3 → 0.9.6.6

data/spec/lib/jackbox/injector_directives_spec.rb

@@ -4,10 +4,10 @@ include Injectors
 
 describe 'Injector Directives: ' do
 	
-	describe "<injector> :implode, the entire injector and all instances eliminated.  Produces different results than 
-	ejecting individual injectors, or from using <injector> :collapse and then restored using <injector> :rebuild" do
+	describe "<trait> :implode, the entire trait and all instances eliminated.  Produces different results than 
+	ejecting individual traits, or from using <trait> :collapse and then restored using <trait> :rebuild" do
 	
-		an 'example of complete injector implosion' do
+		an 'example of complete trait implosion' do
 		
 			class Model
 				def feature
@@ -15,7 +15,7 @@ describe 'Injector Directives: ' do
 				end
 			end
 
-			injector :extras do
+			trait :extras do
 				def feature
 					super() + ' plus some extras'
 				end
@@ -43,20 +43,20 @@ describe 'Injector Directives: ' do
 			
 		end
 
-		describe 'difference between injector ejection/implosion' do
+		describe 'difference between trait ejection/implosion' do
 
 			the 'Injector reconstitution after ejection is possible through reinjection
-			but reconstitution after injector implosion is NOT AVAILABLE' do
+			but reconstitution after trait implosion is NOT AVAILABLE' do
 
 				# code defined
 				class Job
-					injector :agent do
+					trait :agent do
 						def call
 						end
 					end
 					inject agent
 				end
-				Job.injectors.sym_list.should == [:agent]
+				Job.traits.sym_list.should == [:agent]
 
 				# normal use
 				expect{Job.new.call}.to_not raise_error
@@ -106,12 +106,12 @@ describe 'Injector Directives: ' do
 	end
 end
 
-describe '<injector> :collapse.  Injectors can be silenced. This description produces similar results to 
-the previous except that further injector method calls DO NOT raise an error they just quietly return nil' do
+describe '<trait> :collapse.  Injectors can be silenced. This description produces similar results to 
+the previous except that further trait method calls DO NOT raise an error they just quietly return nil' do
 	
 	the 'case with objects' do
 
-		injector :copiable do
+		trait :copiable do
 			def object_copy
 				'a dubious copy'
 			end
@@ -133,7 +133,7 @@ the previous except that further injector method calls DO NOT raise an error the
 	the 'case with classes' do
 
 		class SomeClass
-			injector :code do
+			trait :code do
 				def tester
 					'boo'
 				end
@@ -168,7 +168,7 @@ the previous except that further injector method calls DO NOT raise an error the
 			end
 		end				
 		
-		injector :somecode do 																				# share member name with container
+		trait :somecode do 																				# share member name with container
 			def fun
 				super + ' and more fun'
 			end
@@ -177,23 +177,23 @@ the previous except that further injector method calls DO NOT raise an error the
 		bc = BumperCar.new.enrich(somecode).enrich(somecode)					# decorator pattern
 		bc.fun.should == 'this is fun and more fun and more fun'
 	
-		somecode :collapse																						# collapse the injector
+		somecode :collapse																						# collapse the trait
 		
 		bc.fun.should == 'this is fun'																# class memeber foo intact
 	                                                                    
-		# eject all injectors                                             
-		bc.injectors.sym_list.each { |ij| bc.eject ij }								# same as before
+		# eject all traits                                             
+		bc.traits.sym_list.each { |ij| bc.eject ij }								# same as before
 		bc.fun.should == 'this is fun' 
 
 	end
 end
 
-describe '<injector> :rebuild.  Quieted injectors restored without having
+describe '<trait> :rebuild.  Quieted traits restored without having
 to re-inject them into every object they modify' do
 	
 	the 'case with objects' do
 
-		injector :reenforcer do
+		trait :reenforcer do
 			def thick_walls
 				'=====  ====='
 			end
@@ -217,7 +217,7 @@ to re-inject them into every object they modify' do
 	the 'case with classes' do
 	
 		class SomeBloatedObject
-			injector :ThinFunction do
+			trait :ThinFunction do
 				def perform
 					'do the deed'
 				end
@@ -234,14 +234,14 @@ to re-inject them into every object they modify' do
 	
 	end
 
-	the 'rebuild reconstructs the entire injector and all applications' do
+	the 'rebuild reconstructs the entire trait and all applications' do
 
 		class BumperCar
 			def fun
 				'this is fun'
 			end
 		end
-		injector :othercode do 																				# share memeber name with container
+		trait :othercode do 																				# share memeber name with container
 			def fun
 				super + ' and more fun'
 			end
@@ -250,7 +250,7 @@ to re-inject them into every object they modify' do
 		bc = BumperCar.new.enrich(othercode).enrich(othercode)				# decorator pattern
 		bc.fun.should == 'this is fun and more fun and more fun'
 
-		othercode :silence																						# declare injector silence
+		othercode :silence																						# declare trait silence
 		
 		bc.fun.should == 'this is fun'																# class member un-affected
 		
@@ -258,7 +258,7 @@ to re-inject them into every object they modify' do
 		bc.fun.should == 'this is fun and more fun and more fun'			# restores all decorations !!!
 		
 		# restore the original
-		bc.injectors.sym_list.each { |ij| bc.eject ij }								# same as before
+		bc.traits.sym_list.each { |ij| bc.eject ij }								# same as before
 		bc.fun.should == 'this is fun' 
 
 	end
@@ -269,13 +269,13 @@ describe 'more interesting uses' do
 	
 	it 'allows the following' do
 		
-		facet :PreFunction do
+		jack :PreFunction do
 			def pre_function
 				puts '++++++++++'
 			end
 		end
 		
-		facet :PosFunction do
+		jack :PosFunction do
 			def pos_function
 				puts '=========='
 			end
@@ -307,6 +307,4 @@ describe 'more interesting uses' do
 		obj.meth( 2 )
 
 	end
-	
-	
 end

data/spec/lib/jackbox/injector_inheritance_spec.rb

@@ -22,14 +22,13 @@ include Injectors
 
 
 
-# RubyProf.start
 describe "ancestor chains" do
 
 	it 'updates the ancestor chains accordingly based on: injections and ejections' do
 
     # LifeCycle Start
 
-		injector :Parent															# capitalized method
+		trait :Parent															# capitalized method
 		
 		class Child
 			include Parent()
@@ -55,7 +54,7 @@ describe "ancestor chains" do
 		Child.ancestors.to_s.should match( /Child, Object.*BasicObject/ )
 
 
-		# Note: cannot update empty injector
+		# Note: cannot update empty trait
 		expect{ Child.send :update, Child.parent }.to raise_error(NoMethodError) 
 
 
@@ -93,119 +92,390 @@ describe "ancestor chains" do
 	end
 end
 
-describe "the behavior of injectors under class inheritance" do
+describe "Injector Inheritance" do
+
+	it 'carries current methods onto Injector Versions/Tags' do
+
+		# Define trait
+		
+		jack :bounce
+
+		bounce do
+			def sound
+				'splat splat'
+			end
+		end
+    
+		
+		# Define Tag with new methods
+		
+		TagOne = bounce do 
+			def bounce
+				'boing boing'
+			end
+		end       
+		
+		
+		# Apply Tag
+
+		class Ball
+			inject TagOne 
+		end
+		Ball.new.bounce.should == 'boing boing'
+
+
+		class Spring
+			inject TagOne
+		end
+		Spring.new.bounce.should == 'boing boing'
+
+
+		# Inherited methods from :bounce
+
+		Ball.new.sound.should == 'splat splat'
+		Spring.new.sound.should == 'splat splat'
+
+	end
+
+	a "more complex example: effectively working Ruby's multiple inheritance" do
+
+		jack :player do                       
+			def sound                               
+				'Lets make some music'                
+			end                                     
+		end                                       
+
+		TapePlayer = player do                 
+			def play                                
+				return 'Tape playing...' + sound()                          
+			end                                     
+		end                                       
+
+		CDPlayer = player do
+			def play
+				return 'CD playing...' + sound()
+			end
+		end
+
+		class BoomBox
+			include TapePlayer
+
+			def on
+				play
+			end
+		end
+
+		class JukeBox < BoomBox
+			inject CDPlayer
+		end
+
+		BoomBox.new.on.should == 'Tape playing...Lets make some music'
+		JukeBox.new.on.should == 'CD playing...Lets make some music'
+        
+		#...                       
+
+		jack :speakers
+
+		Bass = speakers do                   
+			def sound                               
+				super + '...boom boom boom...'        
+			end                                     
+		end                   
+		                    
+		JukeBox.inject Bass
+		JukeBox.new.on.should == 'CD playing...Lets make some music...boom boom boom...'
+
+	end
+
+
+	it "allows a just-in-time inheritance policy" do
+	
+		trait :Functionality
+		
+		# 
+		# Our Modular Closure
+		# 
+		Tag1 = Functionality do
+			def m1
+				1
+			end
+			
+			def m2
+				:m2
+			end
+		end
+		
+		expect(Tag1.ancestors).to eql( [Tag1] )
+		expect(Functionality().ancestors).to eql( [Functionality()] )
+
+
+		# 
+		# Normal Injector inheritance
+		# 
+		Functionality do
+			def other  					# No overrides No inheritance
+				'other'						# -- same ancestors as before
+			end 								# -- normal trait inheritance
+		end
+		
+		# test it
+
+		expect(Tag1.ancestors).to eql( [Tag1] )
+		expect(Functionality().ancestors).to eql( [Functionality()] )
+		
+		o  = Object.new.extend(Functionality())
+		
+		# inherited
+		o.m1.should == 1
+		o.m2.should == :m2
+		
+		# current
+		o.other.should == 'other'
+		
+		
+		#
+		# JIT inheritance
+		# 
+		Tag2 = Functionality do
+			def m1														# The :m1 override invokes JIT inheritance
+				super + 1												# -- Tag1 is added as ancestor
+			end 															# -- allows the use of super
+			
+			def m3							
+				'em3'
+			end
+		end
+		
+		# test it
+		
+		expect(Tag2.ancestors).to eq([Tag2])
+		expect(Functionality().ancestors).to eq([Functionality()])
+		
+		p = Object.new.extend(Tag2)
+		
+		# JIT inherited
+		p.m1.should == 2										# using inherited function
+		
+		# regular inheritance
+		p.m2.should == :m2
+		p.m3.should == 'em3'
+		p.other.should == 'other'
+
+		Functionality(:implode)
+		
+	end
 	
-	example "working accross class hierarchies and the effects of ejection" do
 	
+	########################## important ############################
+	# For more information on JIT Inheritance (jiti), please see:   #
+	# the accompanying spec file jiti_rules_spec.rb in the specs    #
+	# directory.																										#
+	#################################################################
 	
-		###########################################
-		# injection
-		###########################################
-    injector :j
 
-    class C
-    end
-    C.inject j { 																	# #foo pre-defined at time of injection
-      def m1
-        'foo'
-      end
-    }
-    C.injectors.sym_list.should == [:j]
-    C.new.injectors.sym_list.should == [:j]
+end
+
+describe "the behavior of traits under class inheritance" do
+	
+	before do
+		
+		suppress_warnings do
+			
+	    C = Class.new
+			D = Class.new(C)
+			E = Class.new(D)
+			
+	    trait :j
 
-    injector :k
+	    C.inject j { 																	# #m1 pre-defined at time of injection
+	      def m1
+	        'foo'
+	      end
+	    }
 
-    C.inject k { 																	# #faa pre-defined at injection
-      def m2
-        'faa'
-      end
-    }
-    C.injectors.sym_list.should == [:k, :j]
-    C.new.injectors.sym_list.should == [:k, :j]
+	    trait :k
+
+	    C.inject k do 																# #m2 pre-defined at injection
+	      def m2
+	        'faa'
+	      end
+	    end
+
+		end
+
+	end
 	
-    C.new.m1.should == 'foo'
-    C.new.m2.should == 'faa'
+	after do
+
+		suppress_warnings do
+			
+			j(:implode)
+			k(:implode)
+
+			C = nil
+			D = nil
+			E = nil
+			
+		end
+		
+	end
+	
+	it 'works on a first level' do
+		
+    C.traits.sym_list.should == [:k, :j]
+    C.new.traits.sym_list.should == [:k, :j]
     c = C.new
 
+		# New Objects
+    with C.new do
+			m1.should == 'foo'											
+    	m2.should == 'faa'
+		end
+		# Existing objects
+		with c do
+			m1.should == 'foo'											
+    	m2.should == 'faa'
+		end
+		
+	end
+	
+	example "adding another level" do
+	
+	
+		####################################
+    # Preamble
+		####################################
+    c = C.new														# carry over from above
 
-		########################################
+		####################################
     # D inherits from C
-		########################################
-    class D < C																		# methods are inherited from j and k
+		####################################
+    class D < C													# methods are inherited from j and k
     end
-    C.injectors.sym_list.should == [:k, :j]
-    C.new.injectors.sym_list.should == [:k, :j]
-    D.injectors.sym_list.should == []
-    D.new.injectors.sym_list.should == []
 
+    D.traits(:all).sym_list.should == [:k, :j]					
+    D.new.traits(:all).sym_list.should == [:k, :j]					
+		d = D.new
+		
 		# New Objects
-    C.new.m1.should == 'foo'											
-    C.new.m2.should == 'faa'
-    D.new.m1.should == 'foo'
-    D.new.m2.should == 'faa'
-		# Existing Objects
-    d = D.new
-    c.m1.should == 'foo'
-    c.m2.should == 'faa'
+    with D.new do
+			m1.should == 'foo'
+    	m2.should == 'faa'
+		end
+		# Existing objects
+		with c, d do
+			m1.should == 'foo'											
+    	m2.should == 'faa'
+		end
+	
+	end
 	
+	example 'traits on second level' do
 	
-		########################################
-		# inject D and override C
-		########################################
-		D.inject j { 																	# new version of j pre-defined at injection
+		####################################
+    # Preamble
+		####################################
+    c = C.new
+
+		####################################
+		# inject into D overriding C
+		####################################
+		D.inject j { 												# new version of j pre-defined at injection
 			def m1
 				'foooo'
 			end
 		}
-    C.injectors.sym_list.should == [:k, :j]
-    C.new.injectors.sym_list.should == [:k, :j]
-    D.injectors.sym_list.should == [:j]
-    D.new.injectors.sym_list.should == [:j]
+    D.traits(:all).sym_list.should == [:j, :k, :j]
+    D.new.traits(:all).sym_list.should == [:j, :k, :j]
+    d = D.new
 
 		# New Objects
-    D.new.m1.should == 'foooo'										# new version of #foo
-		# still the same
-    D.new.m2.should == 'faa'
-    C.new.m1.should == 'foo'
-    C.new.m2.should == 'faa'
+		with D.new do
+	    m1.should == 'foooo'							# new version of #m1
+	    m2.should == 'faa'								# still the same
+		end
 		# Existing Objects
-    c.m1.should == 'foo'
-    c.m2.should == 'faa'
-    d.m1.should == 'foooo'
-    d.m2.should == 'faa'
+		with c do
+	    m1.should == 'foo'
+	    m2.should == 'faa'
+		end
+		with d do
+	    m1.should == 'foooo'
+	    m2.should == 'faa'
+		end
+	end
 	
+	it 'class overrides at second level' do
 	
 		########################################
-		# D class overrides j
+    # Preamble (from above)
 		########################################
+    c = C.new
+
+		D.inject j { 												# new version of j pre-defined at injection
+			def m1
+				'foooo'
+			end
+		}
+
+		####################################
+    # Override injections at class level
+		####################################
     class D < C
-      def m1                                     # overrides foo from j
+      def m1                            # overrides foo from j
         'fuu'
       end
     end
-    C.injectors.sym_list.should == [:k, :j]
-    C.new.injectors.sym_list.should == [:k, :j]
-    D.injectors.sym_list.should == [:j]
-    D.new.injectors.sym_list.should == [:j]
+    C.traits.sym_list.should == [:k, :j]
+    C.new.traits.sym_list.should == [:k, :j]
+    D.traits.sym_list.should == [:j]
+    D.new.traits.sym_list.should == [:j]
+    d = D.new
 
 		# New Objects
-    D.new.m1.should == 'fuu'											# overrided last version from j
-		# still the same
-    D.new.m2.should == 'faa'
-    C.new.m1.should == 'foo'
-    C.new.m2.should == 'faa'
+		with D.new do
+	   	m1.should == 'fuu'								# overrided last version from j
+	    m2.should == 'faa'								# still the same
+		end
+		with C.new do
+	    m1.should == 'foo'
+	    m2.should == 'faa'
+		end
 		# Existing Objects
-    c.m1.should == 'foo'
-    c.m2.should == 'faa'
-    d.m1.should == 'fuu'													# overrided
-    d.m2.should == 'faa'
+		with c do
+	    c.m1.should == 'foo'
+	    c.m2.should == 'faa'
+		end
+		with d do
+	    d.m1.should == 'fuu'							# overrided
+	    d.m2.should == 'faa'
+		end
+
+	end
 	
+	it 'allows updates to methods at their respective level' do
 		
-		########################################
-		# update C and inherit into D
-		########################################
-		C.send :update, k { 													# new version of k pre-defined at update
-			def m2																			# -- no other version of k in hierarchy
+		####################################
+    # Preamble ( carry from above)
+		####################################
+    c = C.new
+
+		D.inject j { 												# new version of j pre-defined at injection
+			def m1
+				'foooo'
+			end
+		}
+    class D < C
+      def m1                            # overrides foo from j
+        'fuu'
+      end
+    end
+
+		####################################
+		# update K and inherit into D
+		####################################
+		C.send :update, k { 								# new version of k pre-defined at update
+			def m2														# -- no other version of k in hierarchy
 				'faaxx'
 			end
 		}
@@ -213,70 +483,126 @@ describe "the behavior of injectors under class inheritance" do
 		# class C
 		# 	update k 				# providing k is in scope
 		# end
-    C.injectors.sym_list.should == [:k, :j]
-    C.new.injectors.sym_list.should == [:k, :j]
-    D.injectors.sym_list.should == [:j]
-    D.new.injectors.sym_list.should == [:j]
-	
+		
+    C.traits.sym_list.should == [:k, :j]
+    C.new.traits.sym_list.should == [:k, :j]
+    D.traits.sym_list.should == [:j]
+    D.new.traits.sym_list.should == [:j]
+		d = D.new
+		
 		# New Objects
-    C.new.m2.should == 'faaxx'										# new version of #faa
-    D.new.m2.should == 'faaxx'
-		# still the same
-    C.new.m1.should == 'foo'
-    D.new.m1.should == 'fuu'
+		with D.new do
+	    m2.should == 'faaxx'
+	    m1.should == 'fuu'
+		end
+    with C.new do
+			m2.should == 'faaxx'							# new version of m1faa
+	    m1.should == 'foo'								# still the same
+		end
 		# Existing Objects
-    c.m1.should == 'foo'
-    c.m2.should == 'faaxx'
-    d.m1.should == 'fuu'
-    d.m2.should == 'faaxx'
+		with c do
+	    m1.should == 'foo'
+	    m2.should == 'faaxx'
+		end
+		with d do
+	    m1.should == 'fuu'
+	    m2.should == 'faaxx'
+		end
+
+	end
 	
+	it 'goes on to other levels' do
 	
-		########################################
+		####################################
+    # Preamble (carry from above)
+		####################################
+    c = C.new
+
+		D.inject j { 												# new version of j pre-defined at injection
+			def m1
+				'foooo'
+			end
+		}
+    class D < C
+      def m1                            # overrides foo from j
+        'fuu'
+      end
+    end
+		C.send :update, k { 								# new version of k pre-defined at update
+			def m2														# -- no other version of k in hierarchy
+				'faaxx'
+			end
+		}
+
+		####################################
     # E inherits from D
-		########################################
-    class E < D																		# methods are inherited from j at C, D and k update at C
+		####################################
+    class E < D													# methods are inherited from j at C, D and k update at C
     end
-    C.injectors.sym_list.should == [:k, :j]
-    C.new.injectors.sym_list.should == [:k, :j]
-    D.injectors.sym_list.should == [:j]
-    D.new.injectors.sym_list.should == [:j]
-    E.injectors.sym_list.should == []
-    E.new.injectors.sym_list.should == []
+    C.traits.sym_list.should == [:k, :j]
+    C.new.traits.sym_list.should == [:k, :j]
+    D.traits.sym_list.should == [:j]
+    D.new.traits.sym_list.should == [:j]
+    E.traits.sym_list.should == []
+    E.new.traits.sym_list.should == []
+
+		d = D.new
+		e = E.new
 
 		# New Objects
     C.new.m1.should == 'foo'
     C.new.m2.should == 'faaxx'
     D.new.m1.should == 'fuu'
-    D.new.m2.should == 'faaxx'                   # new objects pass
+    D.new.m2.should == 'faaxx'          # new objects pass
     E.new.m1.should == 'fuu'
     E.new.m2.should == 'faaxx'
 		# Existing Objects
-    e = E.new
     c.m1.should == 'foo'
-    c.m2.should == 'faaxx'                       # existing objects pass
+    c.m2.should == 'faaxx'              # existing objects pass
     d.m1.should == 'fuu'
     d.m2.should == 'faaxx'
+		e.m1.should == 'fuu'
+		e.m2.should == 'faaxx'
+	end
 	
-	
+	this 'new class level override' do
+		
 		########################################
-		# E overrides D
+    # Preamble (carry from above)
 		########################################
-    class E < D
-      def m1																			# overrides #foo from j at C, D
-        'fuuuu'
-      end
-    end
-    C.injectors.sym_list.should == [:k, :j]
-    C.new.injectors.sym_list.should == [:k, :j]
-    D.injectors.sym_list.should == [:j]
-    D.new.injectors.sym_list.should == [:j]
-    E.injectors.sym_list.should == []
-    E.new.injectors.sym_list.should == []
+    c = C.new
 
-		# New Objects
-    C.new.m1.should == 'foo'
-    C.new.m2.should == 'faaxx'
-    D.new.m1.should == 'fuu'
+		D.inject j { 																	# new version of j pre-defined at injection
+			def m1
+				'foooo'
+			end
+		}
+    class D < C
+      def m1                                     # overrides foo from j
+        'fuu'
+      end
+    end
+		C.send :update, k { 													# new version of k pre-defined at update
+			def m2																			# -- no other version of k in hierarchy
+				'faaxx'
+			end
+		}
+
+		########################################
+		# E overrides D
+		########################################
+    class E < D
+      def m1																			# overrides #foo from j at C, D
+        'fuuuu'
+      end
+    end
+		d = D.new
+		e = E.new
+
+		# New Objects
+    C.new.m1.should == 'foo'
+    C.new.m2.should == 'faaxx'
+    D.new.m1.should == 'fuu'
     D.new.m2.should == 'faaxx'
     E.new.m1.should == 'fuuuu'
     E.new.m2.should == 'faaxx'
@@ -287,92 +613,133 @@ describe "the behavior of injectors under class inheritance" do
     d.m2.should == 'faaxx'
     e.m1.should == 'fuuuu'
     e.m2.should == 'faaxx'
-	
-	
-    #######################################
-    # ejection                                  
-		#######################################
-    C.eject :j                                    # eject j from C
-    
-    C.new.injectors.sym_list.should == [:k]
-    C.injectors.sym_list.should == [:k]
-    D.new.injectors.sym_list.should == [:j]
-    D.injectors.sym_list.should == [:j]
-    E.new.injectors.sym_list.should == []
-    E.injectors.sym_list.should == []
 
-		# New Objects
-    expect{ C.new.m1.should == 'foo'}.to raise_error(NoMethodError)  # m1 errors out on C
-    C.new.m2.should == 'faaxx'
-    D.new.m1.should == 'fuu' 
-    D.new.m2.should == 'faaxx'                   # all else is the same...
-    E.new.m1.should == 'fuuuu' 
-    E.new.m2.should == 'faaxx'
-    # Existing Objects
-    expect{c.m1.should == 'foo'}.to raise_error(NoMethodError)   # m1 errors out on C
-    c.m2.should == 'faaxx'
-    d.m1.should == 'fuu'
-    d.m2.should == 'faaxx'
-    e.m1.should == 'fuuuu'
-    e.m2.should == 'faaxx'
+	end
 
+	describe 'ejection' do
 		
-		########################################
-    # more ejection
-		########################################
-    C.eject :k                                    # eject the only k
-    
-    C.new.injectors.sym_list.should == []
-    C.injectors.sym_list.should == []
-    D.new.injectors.sym_list.should == [:j]
-    D.injectors.sym_list.should == [:j]
-    E.new.injectors.sym_list.should == []
-    E.injectors.sym_list.should == []
+		before do
+			########################################
+	    # Preamble (carry from above)
+			########################################
 
-		# New Objects
-    expect{ C.new.m1.should == 'foo'}.to raise_error(NoMethodError) 
-    expect{ C.new.m2.should == 'faaxx'}.to raise_error(NoMethodError) # # faa errors out
-    D.new.m1.should == 'fuu' 										
-    expect{ D.new.m2.should == 'faaxx'}.to raise_error(NoMethodError) #faa errors out 
-    E.new.m1.should == 'fuuuu' 
-    expect{ E.new.m2.should == 'faaxx'}.to raise_error(NoMethodError) #faa was only available thru k at C 
-    # Existing Objects
-    expect{c.m1.should == 'foo'}.to raise_error(NoMethodError)
-    expect{c.m2.should == 'faaxx'}.to raise_error(NoMethodError)
-    d.m1.should == 'fuu'													# same thing for pre-existing objects
-    expect{d.m2.should == 'faaxx'}.to raise_error(NoMethodError)
-    e.m1.should == 'fuuuu'
-    expect{e.m2.should == 'faaxx'}.to raise_error(NoMethodError)
-    
-	
-		########################################
-    # more ejection
-		########################################
-    D.eject :j                                    # eject j from D: the only one remaining
-    																							# -- everything should revert back to class level
-    C.injectors.sym_list.should == []
-    C.new.injectors.sym_list.should == []
-    D.injectors.sym_list.should == []
-    D.new.injectors.sym_list.should == []
-    E.injectors.sym_list.should == []
-    E.new.injectors.sym_list.should == []
-		
-		# New Objects
-    expect{ C.new.m1.should == 'foo'}.to raise_error(NoMethodError) # no actual #foo on class 
-    expect{ C.new.m2.should == 'faaxx'}.to raise_error(NoMethodError) #         ''
-    D.new.m1.should == 'fuu' 										# retains overrides from D
-    expect{ D.new.m2.should == 'faaxx'}.to raise_error(NoMethodError) 
-    E.new.m1.should == 'fuuuu' 									# retains overrides from E
-    expect{ E.new.m2.should == 'faaxx'}.to raise_error(NoMethodError) 
-    # Existing Objects
-    expect{c.m1.should == 'foo'}.to raise_error(NoMethodError)
-    expect{c.m2.should == 'faaxx'}.to raise_error(NoMethodError)
-    d.m1.should == 'fuu'													# same for pre-existing objects
-    expect{d.m2.should == 'faaxx'}.to raise_error(NoMethodError)
-    e.m1.should == 'fuuuu'												
-    expect{e.m2.should == 'faaxx'}.to raise_error(NoMethodError)
-
-  end
+			D.inject j { 																	# new version of j pre-defined at injection
+				def m1
+					'foooo'
+				end
+			}
+	    class D < C
+	      def m1                                     # overrides foo from j
+	        'fuu'
+	      end
+	    end
+			C.send :update, k { 													# new version of k pre-defined at update
+				def m2																			# -- no other version of k in hierarchy
+					'faaxx'
+				end
+			}
+
+			########################################
+			# E overrides D
+			########################################
+	    class E < D
+	      def m1																			# overrides #foo from j at C, D
+	        'fuuuu'
+	      end
+	    end
+		end
+
+		it 'works with ejection' do
+
+	    c = C.new
+			d = D.new
+			e = E.new
+			
+	    #######################################
+	    # ejection                                  
+			#######################################
+	    C.eject :j                                    # eject j from C
+
+	    C.new.traits.sym_list.should == [:k]
+	    C.traits.sym_list.should == [:k]
+	    D.new.traits.sym_list.should == [:j]
+	    D.traits.sym_list.should == [:j]
+	    E.new.traits.sym_list.should == []
+	    E.traits.sym_list.should == []
+
+			# New Objects
+	    expect{ C.new.m1.should == 'foo'}.to raise_error(NoMethodError)  # m1 errors out on C
+	    C.new.m2.should == 'faaxx'
+	    D.new.m1.should == 'fuu' 
+	    D.new.m2.should == 'faaxx'                   # all else is the same...
+	    E.new.m1.should == 'fuuuu' 
+	    E.new.m2.should == 'faaxx'
+	    # Existing Objects
+	    expect{c.m1.should == 'foo'}.to raise_error(NoMethodError)   # m1 errors out on C
+	    c.m2.should == 'faaxx'
+	    d.m1.should == 'fuu'
+	    d.m2.should == 'faaxx'
+	    e.m1.should == 'fuuuu'
+	    e.m2.should == 'faaxx'
+
+
+			########################################
+	    # more ejection
+			########################################
+	    C.eject :k                                    # eject the only k
+
+	    C.new.traits.sym_list.should == []
+	    C.traits.sym_list.should == []
+	    D.new.traits.sym_list.should == [:j]
+	    D.traits.sym_list.should == [:j]
+	    E.new.traits.sym_list.should == []
+	    E.traits.sym_list.should == []
+
+			# New Objects
+	    expect{ C.new.m1.should == 'foo'}.to raise_error(NoMethodError) 
+	    expect{ C.new.m2.should == 'faaxx'}.to raise_error(NoMethodError) # # faa errors out
+	    D.new.m1.should == 'fuu' 										
+	    expect{ D.new.m2.should == 'faaxx'}.to raise_error(NoMethodError) #faa errors out 
+	    E.new.m1.should == 'fuuuu' 
+	    expect{ E.new.m2.should == 'faaxx'}.to raise_error(NoMethodError) #faa was only available thru k at C 
+	    # Existing Objects
+	    expect{c.m1.should == 'foo'}.to raise_error(NoMethodError)
+	    expect{c.m2.should == 'faaxx'}.to raise_error(NoMethodError)
+	    d.m1.should == 'fuu'													# same thing for pre-existing objects
+	    expect{d.m2.should == 'faaxx'}.to raise_error(NoMethodError)
+	    e.m1.should == 'fuuuu'
+	    expect{e.m2.should == 'faaxx'}.to raise_error(NoMethodError)
+
+
+			########################################
+	    # more ejection
+			########################################
+	    D.eject :j                                    # eject j from D: the only one remaining
+	    																							# -- everything should revert back to class level
+	    C.traits.sym_list.should == []
+	    C.new.traits.sym_list.should == []
+	    D.traits.sym_list.should == []
+	    D.new.traits.sym_list.should == []
+	    E.traits.sym_list.should == []
+	    E.new.traits.sym_list.should == []
+
+			# New Objects
+	    expect{ C.new.m1.should == 'foo'}.to raise_error(NoMethodError) # no actual #foo on class 
+	    expect{ C.new.m2.should == 'faaxx'}.to raise_error(NoMethodError) #         ''
+	    D.new.m1.should == 'fuu' 										# retains overrides from D
+	    expect{ D.new.m2.should == 'faaxx'}.to raise_error(NoMethodError) 
+	    E.new.m1.should == 'fuuuu' 									# retains overrides from E
+	    expect{ E.new.m2.should == 'faaxx'}.to raise_error(NoMethodError) 
+	    # Existing Objects
+	    expect{c.m1.should == 'foo'}.to raise_error(NoMethodError)
+	    expect{c.m2.should == 'faaxx'}.to raise_error(NoMethodError)
+	    d.m1.should == 'fuu'													# same for pre-existing objects
+	    expect{d.m2.should == 'faaxx'}.to raise_error(NoMethodError)
+	    e.m1.should == 'fuuuu'												
+	    expect{e.m2.should == 'faaxx'}.to raise_error(NoMethodError)
+
+	  end
+	end
 
 	describe 'some special cases' do
 		
@@ -383,12 +750,11 @@ describe "the behavior of injectors under class inheritance" do
 
 			# Define a blanck Injector
 
-			injector :j1
+			trait :j1
 
+			# Apply to hierarchy while defining
 
-			# Apply to hierarchy root as defined
-
-			C1.inject j1	do 															# apply definitions
+			C1.inject j1	do 															# same as pre-defined
 				def m1                                     
 					'm1'                                     
 				end                                         
@@ -411,11 +777,11 @@ describe "the behavior of injectors under class inheritance" do
 
 
 			############################
-			# Re-define methods
+			# NEW VERSION! 
 			############################
-			j1 do 																				# NEW VERSION! because previous had an application
-				def m1                                     	# -- was applied to C1 in the hierarchy
-					'm1xx'                                   	# Methods only defined in the Virtual Method Cache
+			j1 do 																				
+				def m1                                     	# -- previous was applied to C1
+					'm1xx'                                   	# this #m1 only defined in the Virtual Method Cache
 				end
 			end                                          
 
@@ -426,7 +792,7 @@ describe "the behavior of injectors under class inheritance" do
 			E1.new.m1.should == 'm1'
 
 
-			E1.inject j1                      						# apply to hierarchy on E
+			E1.inject j1                      						# APPLY to hierarchy on E!
 
 			C1.new.m1.should == 'm1'                  		# same
 			D1.new.m1.should == 'm1'                  		# same
@@ -441,34 +807,30 @@ describe "the behavior of injectors under class inheritance" do
 
 			# Define a blank Injector
 
-			injector :j2
-
+			trait :j2
 
-			# Apply <full> Injector definition to an ancestor
+			# Apply full definition to an ancestor
 
 			Object.inject j2 do
 				def m1
 					'm1xx'
 				end
 			end
-
-
-			# Call on the Injector
-
+			# same effect as above
 			C2.new.m1.should == 'm1xx'                	# call Injector
 
 
 			############################
-			# Re-define methods
+			# NEW VERSION! 
 			############################
 
-			j2 do 																				# NEW VERSION! because previous had an application
-				def m1                                      # -- was applied to Object in the hierarchy
-					'm1'                                      # Methods only defined in the Virtual Method Cache
+			j2 do 																				# NEW VERSION! 
+				def m1                                      # -- previous was applied to Object in the hierarchy
+					'm1'                                      # this #m1 only defined in the Virtual Method Cache
 				end
 			end
 
-			# Calls un-afffected 
+			# Calls un-afffected !!
 
 			C2.new.m1.should == 'm1xx'									# still using the previous version --no changes
 
@@ -488,12 +850,11 @@ describe "the behavior of injectors under class inheritance" do
 
 
 			###########################
-	    # Finally apply new version
+	    # Apply new version on C
 			###########################
 
 			C2.inject j2												
 
-
 			# Calls changed from C on up
 
 			C2.new.m1.should == 'm1'
@@ -519,40 +880,41 @@ describe "the behavior of injectors under class inheritance" do
 
 			# Define a Blank Injector
 
-			injector :j3
+			trait :j3
 
 
-			# Apply the blank injector
+			# Apply the blank trait
 
 			C3.inject j3													
 
+			############################
+			# NEW VERSION! 
+			############################
 
-			# Define function after the application
-
-			j3 do 																				# NEW VERSION!
+			j3 do 																				# 
 				def m1                                      # -- never applied to Object in the hierarchy
-					'm1'                                      # Methods only defined in the Virtual Method Cache
+					'm1'                                      # this #m1 only defined in the Virtual Method Cache
 				end
 			end
 
 
 			# C3 calls
 
-			C3.new.m1.should == 'm1'											# call works as normal from VMC
+			C3.new.m1.should == 'm1'											# call works from VMC
 
 
 			# D3 inherits from C3
 
 			class D3 < C3
 			end
-			D3.new.m1.should == 'm1'											# inherited call 
+			D3.new.m1.should == 'm1'											# inherited call from VMC
 
 
 			# E3 inherits from D3
 
 			class E3 < D3
 			end
-			E3.new.m1.should == 'm1'											# inherited call
+			E3.new.m1.should == 'm1'											# inherited call from VMC
 
 
 			###################################
@@ -562,19 +924,20 @@ describe "the behavior of injectors under class inheritance" do
 
 			j3 do 																				# NEW VERSION!
 				def m1                                      # -- never applied to Object in the hierarchy
-					'm1xx'                                    # Methods only defined in the Virtual Method Cache
+					'm1xx'                                    # this #m1 only defined in the Virtual Method Cache
 				end
 			end                 
 
-
+			##############################
 			# Calls are also re-defined
-
+			##############################
+			
 			C3.new.m1.should == 'm1xx'                  	# call is redefined
 			D3.new.m1.should == 'm1xx'                  	#      '' 
 			E3.new.m1.should == 'm1xx'                  	#      ''
 
 
-			# Apply the <full> Injector onto E3
+			# Apply the full Injector onto E3
 
 			E3.inject j3                      						# Attaches this version onto E only!!
 
@@ -586,13 +949,13 @@ describe "the behavior of injectors under class inheritance" do
 			E3.new.m1.should == 'm1xx'                  	# =>  from applied version
 
 
-			################################
-			# Re-define cached methods
-			#################################
+			############################
+			# NEW VERSION! 
+			############################
 
-			j3 do 																				# NEW VERSION!
+			j3 do 																				
 				def m1                                      # -- never applied to Object in the hierarchy
-					'-----'                                   # Methods only defined in the Virtual Method Cache
+					'-----'                                   # this #m1 only defined in the Virtual Method Cache
 				end
 			end
 
@@ -603,767 +966,10 @@ describe "the behavior of injectors under class inheritance" do
 			D3.new.m1.should == '-----'                 #      ''
 
 			E3.new.m1.should == 'm1xx'                  # NOT REDEFINED!!
-																									# from applied version
-
-		end
-
-	end
-end
-
-describe "regular Injector internal inheritance" do
-
-	it 'carries current methods onto Injector Versions/Tags' do
-
-		# Define injector
-		
-		jack :bounce
-
-		bounce do
-			def sound
-				'splat splat'
-			end
-		end
-    
-		
-		# Define Tag with new methods
-		
-		TagOne = bounce do 
-			def bounce
-				'boing boing'
-			end
-		end       
-		
-		
-		# Apply Tag
-
-		class Ball
-			inject TagOne 
-		end
-		Ball.new.bounce.should == 'boing boing'
-
-
-		class Spring
-			inject TagOne
-		end
-		Spring.new.bounce.should == 'boing boing'
-
-
-		# Inherited methods from :bounce
-
-		Ball.new.sound.should == 'splat splat'
-		Spring.new.sound.should == 'splat splat'
-
-	end
-
-	a "more complex example: effectively working Ruby's multiple inheritance" do
+																									# from full applied version
 
-		jack :player do                       
-			def sound                               
-				'Lets make some music'                
-			end                                     
-		end                                       
-
-		TapePlayer = player do                 
-			def play                                
-				return 'Tape playing...' + sound()                          
-			end                                     
-		end                                       
-
-		CDPlayer = player do
-			def play
-				return 'CD playing...' + sound()
-			end
-		end
-
-		class BoomBox
-			include TapePlayer
-
-			def on
-				play
-			end
-		end
-
-		class JukeBox < BoomBox
-			inject CDPlayer
 		end
 
-		BoomBox.new.on.should == 'Tape playing...Lets make some music'
-		JukeBox.new.on.should == 'CD playing...Lets make some music'
-        
-		#...                       
-
-		jack :speakers
-
-		Bass = speakers do                   
-			def sound                               
-				super + '...boom boom boom...'        
-			end                                     
-		end                   
-		                    
-		JukeBox.inject Bass
-		JukeBox.new.on.should == 'CD playing...Lets make some music...boom boom boom...'
-
-	end
-
-
-	it 'works accross compound injectors' do
-
-			jack :S1
-
-			S1 do
-				include jack :s2 do
-					def s2m1
-						:s2m1
-					end
-					include jack :s3 do
-						def s3m1
-							:s3m1
-						end
-						include jack :s4 do
-							def s4m1
-								:s4m1
-							end
-						end
-					end
-				end
-			end
-			
-			S1().s2.s3.s4       													# injector pipeline!
-
-
-			# Apply the injectors
-
-			class CompoundContainer
-				include S1()
-			end
-
-			CompoundContainer.new.s2m1.should == :s2m1
-			CompoundContainer.new.s3m1.should == :s3m1
-			CompoundContainer.new.s4m1.should == :s4m1
-
-
-			# Add methods to the VMC of s3
-
-			S1().s2.s3 do
-				def s3m2
-					:s3m2
-				end
-			end
-
-			CompoundContainer.new.s3m2.should == :s3m2
-
-
-			# Create a version Tag
-
-			AccessTag = S1() 
-
-			class SecondContainer
-				include AccessTag
-			end
-
-			SecondContainer.new.s3m2.should == :s3m2
-			
-	end
-
-	it 'works accross the VMC' do
-
-		expect{
-			
-		 	injector :J1
-		 	injector :J2
-		 	injector :J3
-
-			class AA1
-			end
-			J1 do
-				include J2()
-			end
-			J2 do
-				def mJ2						# virtual cache method
-					:mJ2
-				end
-			end
-			J1 do
-				def mJ1						# applied method
-					:mJ1
-				end
-			end
-			class AA1
-				include J1()
-			end
-
-			AA1.new.mJ2.should == :mJ2
-			AA1.new.mJ1.should == :mJ1
-
-		}.not_to raise_error
-		
-	end 
-
-	a 'different example' do
-
-		expect{
-			
-			injector :K1
-			injector :K2
-			injector :K3
-
-			K1 do
-			  include K2() do
-			    def mj2						# applied method
-						:mj2
-			    end
-			  end
-			end
-			class AA2
-			  include K1()
-			end
-			AA2.new.mj2.should == :mj2
-			K2 do
-			  include K3() do
-			    def mj3						# virtual cache method with another indirect
-						:mj3
-			    end
-			  end
-			end
-			AA2.new.mj3.should == :mj3
-
-		}.not_to raise_error
-		
-	end
-
-	a 'yet different one' do
-
-		expect{
-			
-			injector :M1
-			injector :M2
-			injector :M3
-
-			M1 do
-				include M2() do
-					def mk2						# applied method
-						:mk2
-					end
-				end
-			end
-			class AA3
-				include M1()
-			end
-			AA3.new.mk2.should == :mk2
-			M2 do
-				include M3()
-			end
-			M3 do
-				def mk3							# virtual cache method
-					:mk3
-				end
-			end
-			AA3.new.mk3.should == :mk3
-
-		}.not_to raise_error
-		
-	end
-
-	describe 'jit inheriatnce' do
-
-		before do
-			injector :Tagger
-
-		end
-		
-		after do
-			Tagger(:implode)
-			
-		end
-		
-		
-		
-		it "follows a just-in-time inheritance policy" do
-		
-			# 
-			# Our Modular Closure
-			# 
-			Tag1 = Tagger do
-				def m1
-					1
-				end
-				
-				def m2
-					:m2
-				end
-			end
-			
-			expect(Tag1.ancestors).to eql( [Tag1] )
-			expect(Tagger().ancestors).to eql( [Tagger()] )
-
-
-			# 
-			# Normal Injector inheritance
-			# 
-			Tagger do
-				def other  					# No overrides No inheritance
-					'other'						# -- same ancestors as before
-				end 								# -- normal injector inheritance
-			end
-			
-			# test it
-
-			expect(Tag1.ancestors).to eql( [Tag1] )
-			expect(Tagger().ancestors).to eql( [Tagger()] )
-			
-			o  = Object.new.extend(Tagger())
-			
-			# inherited
-			o.m1.should == 1
-			o.m2.should == :m2
-			
-			# current
-			o.other.should == 'other'
-			
-			
-			#
-			# JIT inheritance
-			# 
-			Tag2 = Tagger do
-				def m1							# The :m1 override invokes JIT inheritance
-					super + 1					# -- Tag1 is added as ancestor
-				end 								# -- allows the use of super
-				
-				def m3							
-					'em3'
-				end
-			end
-			
-			# test it
-			
-			expect(Tagger().ancestors).to eql( [Tagger(), Tag1] )
-			expect(Tag2.ancestors).to eql( [Tag2, Tag1] )
-			
-			p = Object.new.extend(Tag2)
-			
-			# JIT inherited
-			p.m1.should == 2
-			
-			# regular inheritance
-			p.m2.should == :m2
-			p.m3.should == 'em3'
-			p.other.should == 'other'
-
-			
-			#
-			# Under Inclusion
-			# 
-			class AA6
-				inject Tag2
-			end
-			aa6 = AA6.new
-			
-			# test it
-			
-			aa6.m1.should == 2
-			aa6.m2.should == :m2
-			aa6.m3.should == 'em3'
-
-
-			#
-			# One more level: mixed level inheritance
-			# 
-			Tag3 = 	Tagger() do
-				def m1
-					super * 2 					# second override to #m1 
-				end                   # -- Tag2 added as ancestor
-				def m3
-					super * 2						# first override to #m3
-				end 								
-			end
-			
-			# test it
-
-			expect(Tagger().ancestors).to eql( [Tagger(), Tag2, Tag1] )
-			expect(Tag3.ancestors).to eql( [Tag3, Tag2, Tag1] )
-			expect(Tag2.ancestors).to eql( [Tag2, Tag1] )
-			
-			class AA7
-				inject Tag3 
-			end
-			aa7 = AA7.new
-
-			# JIT inheritance
-			aa7.m1.should == 4					
-			aa7.m3.should == 'em3em3'
-			
-			# regular inheritance
-			aa7.m2.should == :m2
-			aa7.other.should == 'other'
-
-			
-			# 
-			# Another version: back to basics
-			# 
-			Tagger() do
-				def m1							# another override but no call to #super
-					:m1								# -- ancestor added
-				end 								
-			end
-			n = Object.new.extend(Tagger())
-			
-			# test it
-			
-			expect(Tagger().ancestors).to eql( [Tagger(), Tag3, Tag2, Tag1] )
-			expect(Tag3.ancestors).to eql( [Tag3, Tag2, Tag1] )
-			expect(Tag2.ancestors).to eql( [Tag2, Tag1] )
-			
-			
-			n.m1.should == :m1		# new version of #m1
-			
-			# JIT
-			n.m3.should == 'em3em3'
-			
-			# regular
-			n.m2.should == :m2
-
-			
-			# 
-			# Test previous versions
-			# 
-			aa6.m1.should == 2
-			aa6.m2.should == :m2
-			aa6.m3.should == 'em3'
-			
-			aa66 = AA6.new
-			
-			aa66.m1.should == 2
-			aa66.m2.should == :m2
-			aa66.m3.should == 'em3'
-
-			aa7.m1.should == 4
-			aa7.m2.should == :m2
-			aa7.m3.should == 'em3em3'
-
-			aa77 = AA7.new
-
-			aa77.m1.should == 4
-			aa77.m2.should == :m2
-			aa77.m3.should == 'em3em3'
-
-
-			#
-			# other clients
-			#
-			class AA6B
-				inject Tag2
-			end
-			aa6b = AA6B.new
-			
-			aa6b.m1.should == 2
-			aa6b.m2.should == :m2
-			aa6b.m3.should == 'em3'
-			
-			#
-			# VMC (Virtual Method Cache) method
-			#
-			Tagger() do
-				def m4							
-					:m4
-				end
-			end
-
-			# test it
-			
-			expect(Tagger().ancestors).to eql([Tagger(), Tag3, Tag2, Tag1])
-			expect(Tag3.ancestors).to eql( [Tag3, Tag2, Tag1] )
-			expect(Tag2.ancestors).to eql( [Tag2, Tag1] )
-			
-			aa6b.m1.should == 2
-			aa6b.m2.should == :m2
-			aa6b.m3.should == 'em3'
-			aa6b.m4.should == :m4		# vmc method
-			
-			
-			# Total Tags
-			
-			Tagger().tags.should == [Tag1, Tag2, Tag3]
-			
-		end
-		
-		it "also allows further ancestor injection" do
-			
-			Tag4 = Tagger do
-				def m1
-					1
-				end
-				def m2
-					:m2
-				end
-			end
-		
-			module Mod1
-				def m1
-					'one'
-				end
-			end
-		
-			Tag5 = Tagger(Mod1) do
-				
-				# include Mod1											# alternatively
-				
-				def m1
-					super * 2					# invoking inheritance for Tag5 !!
-				end
-				def m3
-					:m3
-				end
-			end
-
-			expect(Tagger().ancestors).to eql([Tagger(), Mod1, Tag4])
-			expect(Tag4.ancestors).to eql([Tag4])
-			expect(Tag5.ancestors).to eql([Tag5, Mod1, Tag4])
-
-			# test it 
-		
-			Object.new.extend(Tag5).m1.should == 'oneone'
-			Object.new.extend(Tag5).m2.should == :m2
-			Object.new.extend(Tag5).m3.should == :m3
-			
-			# other prolongation
-			
-			Object.new.extend(Tagger(){
-				def m4
-					:m4
-				end
-			}).m4.should == :m4
-			
-		end
-		
-		it 'also works like this' do
-			
-			Tag6 = Tagger do
-				def m1
-					super() * 2
-				end
-				def m2
-					:m2
-				end
-			end
-			
-			module Mod2
-				def m1
-					3
-				end
-			end
-			
-			Object.new.extend(Tagger(Mod2)).m1.should == 6
-			Object.new.extend(Tagger(Mod2)).m2.should == :m2
-			
-		end
-		
-		this "also possible" do
-			
-			Tag7 = Tagger do
-				def m1
-					1
-				end
-				def m2
-					:m2
-				end
-			end
-			
-			Tag8 = Tagger do
-				def m1
-					super * 2
-				end
-				def m3
-					:m3
-				end
-			end
-			
-			# test it
-		
-			Object.new.extend(Tag8).m1.should == 2
-
-
-			#
-			# On the fly overrides
-			# 
-			obj = Object.new.extend(
-				Tagger {
-					def m1
-						super + 3
-					end
-					def m4
-						:m4
-					end
-				})
-			obj.m1.should == 5
-			obj.m2.should == :m2
-			obj.m3.should == :m3
-			obj.m4.should == :m4
-				
-		end
-		
-		this "one is a bit tricky" do
-			
-			Tag9 = Tagger do
-				def m1
-					1
-				end
-			end
-		
-			module Mod1
-				def m1
-					'one'
-				end
-			end
-			
-			Tag10 = Tagger() do
-				
-				include Mod1
-				
-				def m1
-					super * 2
-				end
-			end
-			
-			# test it
-		
-			Object.new.extend(Tag10).m1.should == 'oneone'
-			Object.new.extend(Tagger()).m1.should == 'oneone'
-			
-			Tag10.ancestors.should == [Tag10, Mod1, Tag9]
-			
-		end
-		
-		this 'further trick' do
-			
-			Tag11 = Tagger do
-			  def m1
-			    1
-			  end
-			  def m2 							# original definition
-			    2
-			  end
-			end
-			Tag12 = Tagger do
-			  def m1
-			    'm1'
-			  end 								# skipped #m2
-			end
-			Tag13 = Tagger do
-			  def m1
-			    super * 2
-			  end
-			  def m2
-			    super * 2					# override # m2 two levels down
-			  end
-			end
-			class AA10
-			  inject Tag13
-			end
-			
-			# test it
-			
-			AA10.new.m1.should == 'm1m1'
-			AA10.new.m2 == 4
-			
-			Tag13.ancestors.should == [Tag13, Tag12, Tag11]
-
-		end
-		
-		it 'rebases' do
-			
-			Tag14 = Tagger do
-				def m1
-					1
-				end
-			end
-			
-			class AA11
-				inject Tagger() do
-					def m1
-						super + 1
-					end
-				end
-			end
-			
-			# test it
-			
-			AA11.new.m1.should == 2
-			
-			
-			Tag15 = Tagger do
-				def m1
-					5									# rebase m1
-				end
-			end
-			
-			class BB11
-				inject Tagger() do
-					def m1
-						super * 2				# new override
-					end
-				end
-			end
-			
-			# test it
-			
-			BB11.new.m1.should == 10
-			
-			
-		end
-		
-		it 'takes Injector Directives' do
-			
-			Tag16 = Tagger do
-				def m1
-					1
-				end
-			end
-			
-			class AA12
-				inject Tagger() do
-					def m1
-						super + 1
-					end
-				end
-			end
-			
-			AA12.new.m1.should == 2
-			
-			
-			Tag17 = Tagger do
-				def m1
-					5									# rebase m1
-				end
-			end
-			
-			class BB12
-				inject Tagger() do
-					def m1
-						super * 2				# new override
-					end
-				end
-			end
-			
-			BB12.new.m1.should == 10
-			
-			# test directives
-			
-			Tagger(:silence)
-
-			AA12.new.m1.should == nil										# both bases affected
-			BB12.new.m1.should == nil
-			
-			Tagger(:active)
-			
-			AA12.new.m1.should == 2											# both bases restored
-			BB12.new.m1.should == 10
-			
-		end
-		
 	end
 end
 
-# profile = RubyProf.stop
-# RubyProf::FlatPrinter.new(profile).print(STDOUT)
-# RubyProf::GraphHtmlPrinter.new(profile).print(open('profile.html', 'w+'))
-# RubyProf::CallStackPrinter.new(profile).print(open('profile.html', 'w+'))