jackbox 0.9.6.6 → 0.9.6.8

data/spec/lib/jackbox/injector_namespacing_spec.rb

@@ -256,19 +256,30 @@ end
 
 describe "tag scoping and naming" do
 	
-	it 'passes' do
+	before do
+		suppress_warnings do
+			A = Class.new
+			B = Class.new
+		end
+	end
+	after do
+		suppress_warnings do
+			A = nil
+			B = nil
+		end
+	end
+	it 'passes on top level' do
 		
 		jack :M0
 		
 		TopLevelTag = M0()
-		
 		extend TopLevelTag
 		
 		singleton_class.ancestors.to_s.should match(/TopLevelTag/)
 		
 	end
 	
-	it 'also passes' do
+	it 'passes for nested tags' do
 		
 		module M1
 			jack :j1
@@ -278,15 +289,15 @@ describe "tag scoping and naming" do
 			Atag = M1.j1
 		end
 		
-		class A4 
+		class A
 			include M2::Atag
 		end
 		
-		A4.ancestors.to_s.should match(/Atag/)
+		A.ancestors.to_s.should match(/Atag/)
 		
 	end
 	
-	it 'also passes' do
+	it 'also passes with deeper nesting' do
 		
 		module M3
 			module M4
@@ -294,12 +305,11 @@ describe "tag scoping and naming" do
 			end
 		end
 		
-		class B4
+		class B
 			include M3::M4::AnotherTag
 		end
 		
-		A4.ancestors.to_s.should match(/Atag/) 
-		B4.ancestors.to_s.should match(/AnotherTag/)
+		B.ancestors.to_s.should match(/AnotherTag/)
 		
 	end
 	

data/spec/lib/jackbox/injector_spec.rb

@@ -198,13 +198,13 @@ describe Injectors, :injectors do
 				
 				# define more stuff on the injector
 				stuff do
-					define_method :far do |miles|
+					def this_far miles
 						'My stuff is: ' + miles.to_s + ' miles away' 
 					end
 				end
 				
 				# program stiil works
-				some_thing.far(100).should == ('My stuff is: 100 miles away')
+				some_thing.this_far(100).should == ('My stuff is: 100 miles away')
 				
 			end
 			

data/spec/lib/jackbox/injector_versioning_spec.rb

@@ -230,32 +230,55 @@ describe 'Injector versioning:', :traits do
 		
 		end
 
-		there 'is a different way todo global updates on Injectors: use define_method' do
+		there 'is a different way todo global updates on Injectors (except for Tags): use define_method' do
 
-			SomeJack = jack :some_jack do
+			SomeJack = jack :Some_jack do
 				def foo_bar
 					'a foo and a bar'
 				end
 			end
 
-			class Client
-				inject SomeJack
+			class ClientA
+				inject SomeJack						# tag
+			end
+			class ClientB
+				inject Some_jack()				# regular versions
+			end
+			class ClientC
+				inject Some_jack()
 			end
 
-			Client.new.foo_bar.should == 'a foo and a bar'			# expected
+			ClientA.new.foo_bar.should == 'a foo and a bar'			# expected
+			ClientB.new.foo_bar.should == 'a foo and a bar'			# expected
+			ClientC.new.foo_bar.should == 'a foo and a bar'			# expected
 
-			some_jack do
+			Some_jack() do
 				define_method :foo_bar do
-					'fooooo and barrrrr'
+					'fooooo and barrrrr'		# use #define_method
 				end
 			end
 
-			Client.new.foo_bar.should == 'fooooo and barrrrr'		# different
+			ClientA.new.foo_bar.should == 'a foo and a bar'			# Tags are untouched 
+			ClientB.new.foo_bar.should == 'fooooo and barrrrr'		# changed
+			ClientC.new.foo_bar.should == 'fooooo and barrrrr'		# changed
 
 		end
 	end
 
-	describe "utility of trait versioning: " do
+	describe "utility of injector versioning: " do
+		
+		before do
+			suppress_warnings do
+				A = Class.new
+				B = Class.new
+			end
+		end
+		after do
+			suppress_warnings do
+				A = nil
+				B = nil
+			end
+		end
 		
 		it 'allows to easily override methods without affecting other parts of your program' do
 			
@@ -265,10 +288,10 @@ describe 'Injector versioning:', :traits do
 				end
 			end
 			
-			class AA4
+			class A
 				inject J1
 			end
-			AA4.new.meth(3).should == 3
+			A.new.meth(3).should == 3
 			
 			J2 = j do
 				def meth(arg)
@@ -276,12 +299,12 @@ describe 'Injector versioning:', :traits do
 				end
 			end
 			
-			class BBB
+			class B
 				inject J2
 			end
-			BBB.new.meth(3).should == 9
+			B.new.meth(3).should == 9
 			
-			AA4.new.meth(3).should == 3
+			A.new.meth(3).should == 3
 			
 		end
 		

data/spec/lib/jackbox/jiti_rules_spec.rb

@@ -1,16 +1,17 @@
 require "spec_helper"
 
-describe 'jit inheriatnce' do
+# RubyProf.start
+
+describe 'jit inheriatnce with tagging' do
 
 	before do
 		
-		suppress_warnings do
-
-			# 
-			# Trait
-			# 
-			trait :Functionality
+		# 
+		# Trait
+		# 
+		trait :Functionality
 
+		suppress_warnings do
 			# 
 			# Works like class inheritance
 			# 
@@ -25,11 +26,12 @@ describe 'jit inheriatnce' do
 			end
 
 			Functionality do
-				def other  					# No overrides No inheritance
-					'other'						# -- same ancestors as before
-				end 								# -- normal trait inheritance
+				def other  												# No overrides No inheritance
+					'other'													# -- same ancestors as before
+				end 															# -- normal trait inheritance
 			end
 
+			# debugger
 			Tag2 = Functionality do
 				def m1														# The :m1 override invokes JIT inheritance
 					super + 1												# -- Tag1 is added as ancestor
@@ -40,10 +42,7 @@ describe 'jit inheriatnce' do
 				end
 			end
 
-			class AA6
-				inject Tag2
-			end
-
+			# debugger
 			Tag3 = 	Functionality() do
 				def m1
 					super * 2 											# second override to #m1 
@@ -53,9 +52,10 @@ describe 'jit inheriatnce' do
 				end 								
 			end
 
-			class AA7
-				inject Tag3 
-			end
+			A = Class.new
+			B = Class.new
+			C = Class.new
+			D = Class.new
 
 		end
 	end
@@ -64,9 +64,17 @@ describe 'jit inheriatnce' do
 
 		suppress_warnings do
 
+			A = nil
+			B = nil
+			C = nil
+			D = nil
+			
 			Tag1 = nil
 			Tag2 = nil
 			Tag3 = nil
+			Tag4 = nil
+			Tag5 = nil
+			Tag6 = nil
 
 		end
 
@@ -74,7 +82,19 @@ describe 'jit inheriatnce' do
 
 	end
 
-	it 'works under boejct extension' do
+	it 'keeps the main trait in sync with the last tag' do
+
+		o = Object.new.extend Tag3
+		p = Object.new.extend Functionality()
+
+		# test it
+
+		o.m1.should == 4
+		p.m1.should == 4
+
+	end
+
+	it 'works under object extension' do
 
 		o = Object.new.extend Tag3
 		o.m1.should == 4
@@ -86,18 +106,18 @@ describe 'jit inheriatnce' do
 		#
 		# Under Inclusion
 		# 
-		class AA6
+		class A
 			inject Tag2
 		end
-		aa6 = AA6.new
+		a = A.new
 
 		# JIT inherited
-		aa6.m1.should == 2
-		aa6.m3.should == 'em3'
+		a.m1.should == 2
+		a.m3.should == 'em3'
 
 		# Version inherited
-		aa6.m2.should == :m2
-		aa6.other.should == 'other'
+		a.m2.should == :m2
+		a.other.should == 'other'
 
 		Functionality().tags.should == [Tag1, Tag2, Tag3]
 
@@ -108,95 +128,64 @@ describe 'jit inheriatnce' do
 		#
 		# Different client/Diferent Tag
 		# 
-		class AA7
+		class B
 			inject Tag3 
 		end
-		aa7 = AA7.new
+		b = B.new
 
 		# JIT inherited
-		aa7.m1.should == 4					
-		aa7.m3.should == 'em3em3'
+		b.m1.should == 4					
+		b.m3.should == 'em3em3'
 
 		# regular inheritance
-		aa7.m2.should == :m2
-		aa7.other.should == 'other'
+		b.m2.should == :m2
+		b.other.should == 'other'
 
 		Functionality().tags.should == [Tag1, Tag2, Tag3]
 
 	end
 
-	it 'keeps the main trait in sync with the last tag' do
-
-		o = Object.new.extend Tag3
-		p = Object.new.extend Functionality()
-
-		# test it
-
-		o.m1.should == 4
-		p.m1.should == 4
-
-	end
-
-	it 'allows rebasing individual methods' do 
-
-		# 
-		# Another prolongation: back to basics
-		# 
-		Tag4 = Functionality() do
-			def m1														# another override but no call to #super
-				:m1															# -- just simple override
-			end 															# -- could be tagged if needed
-		end
-
-		# test it
-
-		o = Object.new.extend( Tag4 )
-
-		# new version of #m1 !!
-		o.m1.should == :m1									
-
-		# JIT inherited
-		o.m3.should == 'em3em3'							# old jiti version of m3
-
-		# Version inherited
-		o.m2.should == :m2									# old version of m2
-		o.other.should == 'other'
-
-		# Total Tags
-
-		Functionality().tags.should == [Tag1, Tag2, Tag3, Tag4]
-
-	end
-
 	it 'still holds on to earlier tag definitions' do
 
+		class A
+			inject Tag2
+		end
+		class B
+			inject Tag3 
+		end
 		# 
 		# Test previous Tags are unaffected !!
 		# 
-		AA6.new.m1.should == 2							# includes Tag2
-		AA6.new.m2.should == :m2
-		AA6.new.m3.should == 'em3'
+		A.new.m1.should == 2							# includes Tag2
+		A.new.m2.should == :m2
+		A.new.m3.should == 'em3'
 
-		AA7.new.m1.should == 4							# includes Tag3
-		AA7.new.m2.should == :m2
-		AA7.new.m3.should == 'em3em3'
+		B.new.m1.should == 4							# includes Tag3
+		B.new.m2.should == :m2
+		B.new.m3.should == 'em3em3'
 
 		#
 		# other clients
 		#
-		class AA6B
+		class C
 			inject Tag2
 		end
-		aa6b = AA6B.new
+		c = C.new
 
-		aa6b.m1.should == 2
-		aa6b.m2.should == :m2
-		aa6b.m3.should == 'em3'
+		c.m1.should == 2
+		c.m2.should == :m2
+		c.m3.should == 'em3'
 
 	end
 
 	it 'keeps the VMC in proper working order' do
 
+		class A
+			inject Tag2
+		end
+		class B
+			inject Tag3 
+		end
 		#
 		# VMC (Virtual Method Cache) method
 		#
@@ -206,24 +195,57 @@ describe 'jit inheriatnce' do
 			end
 		end
 
-		class AA6B
+		class C
 			inject Tag2
 		end
-		aa6b = AA6B.new
+		c = C.new
 
 		# jit inherited
-		aa6b.m1.should == 2
-		aa6b.m3.should == 'em3'
+		c.m1.should == 2
+		c.m3.should == 'em3'
 
 		# version inherited
-		aa6b.m2.should == :m2
-		aa6b.other.should == 'other'
+		c.m2.should == :m2
+		c.other.should == 'other'
 
-		aa6b.m4.should == :m4		# vmc method
+		c.m4.should == :m4		# vmc method
 
 		# other clients of the VMC
-		AA6.new.m4.should == :m4
-		AA7.new.m4.should == :m4
+		A.new.m4.should == :m4
+		B.new.m4.should == :m4
+
+	end
+
+	it 'allows rebasing individual methods' do 
+
+		suppress_warnings do
+			# 
+			# Another prolongation: back to basics
+			# 
+			Tag4 = Functionality() do
+				def m1														# another override but no call to #super
+					:m1															# -- just simple override
+				end 															# -- could be tagged if needed
+			end
+		end
+
+		# test it
+
+		o = Object.new.extend( Tag4 )
+
+		# new version of #m1 !!
+		o.m1.should == :m1									
+
+		# JIT inherited
+		o.m3.should == 'em3em3'							# old jiti version of m3
+
+		# Version inherited
+		o.m2.should == :m2									# old version of m2
+		o.other.should == 'other'
+
+		# Total Tags
+
+		Functionality().tags.should == [Tag1, Tag2, Tag3, Tag4]
 
 	end
 
@@ -235,31 +257,34 @@ describe 'jit inheriatnce' do
 			end
 		end
 
-		Tag5 = Functionality(Mod1) do
+		suppress_warnings do
+			Tag4 = Functionality(Mod1) do
 
-			include Mod1											# alternatively
+				include Mod1											# alternatively
 
-			def m1
-				super * 2
-			end
-			def m3
-				:m3															# m3 is rebased
+				def m1
+					super * 2
+				end
+				def m3
+					:m3															# m3 is rebased
+				end
+				
 			end
 		end
-
+		
 		# test it 
 
 		# jit inherited
-		Object.new.extend(Tag5).m1.should == 8 # from Tag3
-
-		# version inherited
-		Object.new.extend(Tag5).m2.should == :m2 # from Tag1
-
-		# rebased
-		Object.new.extend(Tag5).m3.should == :m3 # from Tag5
-
-		# ancestor injection
-		Object.new.extend(Tag5).m4.should == :m4 # from Mod1
+		Object.new.extend(Tag4).m1.should == 8 # from Tag3
+                         
+		# version inherited  
+		Object.new.extend(Tag4).m2.should == :m2 # from Tag1
+                         
+		# rebased            
+		Object.new.extend(Tag4).m3.should == :m3 # from Tag5
+                         
+		# ancestor injection 
+		Object.new.extend(Tag4).m4.should == :m4 # from Mod1
 
 	end
 
@@ -302,34 +327,36 @@ describe 'jit inheriatnce' do
 		# Masks Ancestor intrussion
 		# 
 
-		Tag6 = Functionality do
-			def m1														# Injector has internal base
-				1
+		suppress_warnings do
+			Tag4 = Functionality do
+				def m1														# Injector has internal base method
+					1
+				end
 			end
-		end
 
-		module Mod1
-			def m1
-				'one'
+			module Mod1
+				def m1
+					'one'
+				end
 			end
-		end
 
-		Tag7 = Functionality(Mod1) do 						# Mod1 attempts to intrude on base
+			Tag5 = Functionality(Mod1) do 						# Mod1 attempts to intrude on base
 
-			include Mod1
+				include Mod1
 
-			def m1
-				super * 2
+				def m1
+					super * 2
+				end
 			end
 		end
-
+		
 		# test it
 
-		o = Object.new.extend(Tag7)			
+		o = Object.new.extend(Tag5)			
 		# jit inherited
 		o.m1.should == 2										# no such luck!!
 
-		p = Object.new.extend(Functionality())
+		p = Object.new.extend(Functionality(Mod1))
 		# jit inherited
 		p.m1.should == 2										# no such luck!!
 
@@ -341,133 +368,156 @@ describe 'jit inheriatnce' do
 
 	it 'allows overriding methods further down the tree' do
 
-		Tag8 = Functionality do
-		  def m1
-		    1
-		  end
-		  def m2 							# original definition
-		    2
-		  end
-		end
-		Tag9 = Functionality do
-		  def m1
-		    'm1'
-		  end 								# skipped #m2
-		end
-		Tag10 = Functionality do
-		  def m1
-		    super * 2
-		  end
-		  def m2
-		    super * 2					# override # m2 two levels down
-		  end
+		suppress_warnings do
+			Tag4 = Functionality do
+			  def m1
+			    1
+			  end
+			  def m2 							# original definition
+			    2
+			  end
+			end
+			Tag5 = Functionality do
+			  def m1
+			    'm1'
+			  end 								# skipped #m2
+			end
+			Tag6 = Functionality do
+			  def m1
+			    super * 2
+			  end
+			  def m2
+			    super * 2					# override # m2 two levels down
+			  end
+			end
 		end
-		class AA10
-		  inject Tag10
+		
+		class A
+		  inject Tag6
 		end
 
 		# test it
 
-		AA10.new.m1.should == 'm1m1'
-		AA10.new.m2 == 4
+		A.new.m1.should == 'm1m1'
+		A.new.m2 == 4
 
 	end
 
 	it 'allows rebasing (start fresh) methods at any level' do
 
-		Tag11 = Functionality do
-			def m1
-				1																# rebase Tag3
+		suppress_warnings do
+			Tag4 = Functionality do
+				def m1
+					1																# rebase Tag3
+				end
 			end
-		end
 
-		class AA11
-			inject Functionality() do
-				def m1
-					super + 1											# override
+			class A
+				inject Functionality() do
+					def m1
+						super + 1											# override
+					end
 				end
 			end
-		end
 
-		# test it
+			# test it
 
-		AA11.new.m1.should == 2
+			A.new.m1.should == 2
 
 
-		Tag12 = Functionality do
-			def m1
-				5																# rebase m1 again
+			Tag5 = Functionality do
+				def m1
+					5																# rebase m1 again
+				end
 			end
-		end
 
-		class BB11
-			inject Functionality() do
-				def m1
-					super * 2											# new override
+			class B
+				inject Functionality() do
+					def m1
+						super * 2											# new override
+					end
 				end
 			end
 		end
-
+		
 		# test it
 
-		BB11.new.m1.should == 10
+		B.new.m1.should == 10
 
 
 	end
 
-	it 'slloed Injector Directives likr sll traits' do
+	it 'works with Trait Directives' do
 
-		Tag13 = Functionality do
-			def m1
-				1
+		suppress_warnings do
+			Tag4 = Functionality do
+				def m1
+					1
+				end
 			end
-		end
 
-		class AA12
-			inject Functionality() do
-				def m1
-					super + 1
+			class A
+				inject Functionality() do
+					def m1
+						super + 1
+					end
 				end
 			end
-		end
 
-		AA12.new.m1.should == 2
+			A.new.m1.should == 2
 
 
-		Tag14 = Functionality do
-			def m1
-				5									# rebase m1
+			Tag5 = Functionality do
+				def m1
+					5									# rebase m1
+				end
 			end
-		end
 
-		class BB12
-			inject Functionality() do
-				def m1
-					super * 2				# new override
+			class B
+				inject Functionality() do
+					def m1
+						super * 2				# new override
+					end
 				end
 			end
 		end
-
-		BB12.new.m1.should == 10
+		
+		B.new.m1.should == 10
 
 		# test directives
 
 		Functionality(:silence)
 
-		AA12.new.m1.should == nil										# both bases affected
-		BB12.new.m1.should == nil
+		A.new.m1.should == nil										# both bases affected
+		B.new.m1.should == nil
 
 		Functionality(:active)
 
-		AA12.new.m1.should == 2											# both bases restored
-		BB12.new.m1.should == 10
+		A.new.m1.should == 2											# both bases restored
+		B.new.m1.should == 10
 
 	end
 
 end
 
-describe 'jiti external basing' do
-
+describe 'jiti soft external basing' do
+
+	####################################################################
+	# Soft external basing should be the preferred way of doing things #
+	# . The alternative hard internal basins (see below) is not as     #
+	# flexible and inrtoduces fixed ancestor ordering --once the       #
+	# the ancestors are layout the keep their precedence unlsess you   #
+	# stick only to injectors.																				 #
+	# . Soft ancestors don't suffer from this like: 									 #
+	# 																																 #
+	# 	trait :a, :b, :c 																							 #
+	# 																																 #
+	# 	x = a b c																											 #
+	# 	y = a c b																											 #
+	# 																																 @
+	# For more on this see the compostion spec												 #
+	# ##################################################################
+	
 	before do
 		
 		#
@@ -475,33 +525,34 @@ describe 'jiti external basing' do
 		# 
 		trait :Functionality
 
-		suppress_warnings do
 
-			module Base1												# EXTERNAL BASEs!!
-				def m1
-					2
-				end
+		module Base1												# EXTERNAL BASEs!!
+			def m1
+				2
 			end
+		end
 
-			module Base2
-				def m1
-					3
-				end
+		module Base2
+			def m1
+				3
 			end
+		end
 
+		suppress_warnings do
 			# 
 			# Similar to Above
 			# 
 			Tag1 = Functionality(Base1) do
 
-				# include Base1										# alternatively
+				# include Base1										# NO INTERNAL BASE!! for #m1
 
 				def m2
 					:m2
 				end
 			end
 
-			Tag2 = Functionality do
+			# debugger
+			Tag2 = Functionality(Base2) do
 				def m1														# The :m1 override invokes JIT inheritance
 					super + 1												# -- Tag1 is added as ancestor
 				end 															# -- allows the use of super
@@ -511,7 +562,8 @@ describe 'jiti external basing' do
 				end
 			end
 
-			Tag3 = 	Functionality() do
+			# debugger
+			Tag3 = 	Functionality(Base1) do
 				def m1
 					super * 2 											# second override to #m1 
 				end                   						# -- Tag2 added as ancestor
@@ -530,50 +582,66 @@ describe 'jiti external basing' do
 			Tag1 = nil
 			Tag2 = nil
 			Tag3 = nil
+			Tag4 = nil
+			Tag5 = nil
+			Tag6 = nil
 
 		end
 
 		Functionality(:implode)
 
 	end
+	
+	it 'works for Tag1' do
+
+		o = Object.new.extend(Tag1)
+		o.m1.should == 2
+		
+	end
+	
+	it 'works for Tag2' do
+		
+		o = Object.new.extend(Tag2)
+		o.m1.should == 4
+		
+	end
 
 	it 'works with initial external basing' do
 
 		o = Object.new.extend(Tag3)
+		# debugger
 		o.m1.should == 6										# from Base1 thru Tag3
 
 	end
 
 	it 'also keeps the main trait in sync with the last tag' do
 
-		o = Object.new.extend(Tag3)
-		o.m1.should == 6
-
-		p = Object.new.extend(Functionality())
+		p = Object.new.extend(Functionality(Base1))
 		p.m1.should == 6
 
 	end
 
-	it 'follows the other normal rules' do
+	it 'allows external base substitution --keeps the Trait Injector shell/jacket' do
 
-		Tag15 = Functionality do
-			def m1
-				super() * 2											# on top of Tag3
-			end
-			def m2
-				:m2
-			end
-		end
-
-		p = Object.new.extend(Tag15)
-		p.m1.should == 12
+		q = Object.new.extend(Functionality(Base2))	# on top or Tag3 thru Tag2....
+		q.m1.should == 8
 
 	end
 
-	it 'allows external base substitution --keeps the Trait Injector shell/casing' do
+	it 'follows the other normal rules' do
 
-		q = Object.new.extend(Functionality(Base2))	# on top or Tag3 thru Tag2....
-		q.m1.should == 8
+		suppress_warnings do
+			Tag4 = Functionality(Base1) do
+				def m1
+					super() * 2											# on top of Tag3
+				end
+				def m2
+					:m2
+				end
+			end
+		end
+		p = Object.new.extend(Tag4)
+		p.m1.should == 12
 
 	end
 
@@ -585,79 +653,275 @@ describe 'jiti external basing' do
 			end
 		end
 
-		Tag16 = Functionality(Base2) do
-			def m1
-				super / 2
-			end
-			def m2
-				super
+		suppress_warnings do
+			Tag4 = Functionality(Base2) do
+				
+				# inject Base2
+				def m1
+					super / 2
+				end
+				def m2
+					super
+				end
 			end
 		end
-
-		p = Object.new.extend(Tag16)
+		# p = Object.new.extend(Tag4, Base2)
+		p = Object.new.extend(Tag4)
 
 		p.m1.should == 4										# external rebase and thru Tag16, Tag3 and Tag2
 		p.m2.should == :m2
 		p.m4.should == 'new'								# new function
+		
+		module Base3
+			def m1
+				5
+			end
+		end
+		
+		suppress_warnings do
+			Tag5 = Functionality(Base3) do
+				
+				# inject Base3
+				def m1
+					super + 1
+				end
+			end
+		end
+		# q = Object.new.extend(Tag5, Base3)
+		q = Object.new.extend(Tag5)
+		
+		# debugger
+		q.m1.should == 7
 
 	end
 
 	it 'enforces internal basing once applied --blocks further external intrusion (like above)' do
 
-		Tag17 = Functionality(Base2) do
-			def m2 
-				6																# rebase #m2
+		suppress_warnings do
+			Tag4 = Functionality() do
+				# ...															# on top of Tag3
+				def m2 
+					6																# rebase #m2
+				end
 			end
-		end
+			o = Object.new.extend(Functionality(Base2))
+			
+			o.m1.should == 8										
+			o.m2.should == 6										
 
-		o = Object.new.extend(Functionality())
-		o.m1.should == 8										# Base2 thru Tag3 casing
-		o.m2.should == 6										# new #m2
+			Functionality() do
+				def m1
+					super + 1												# thru Tag4 on top of Tag3
+				end
+			end
+			p = Object.new.extend Functionality(Base2)
 
-		Functionality() do
-			def m1
-				super + 1												# on top of Tag17
+			p.m1.should == 9
+			p.m2.should == 6
+
+
+			module Base3 												# EXTERNAL NEW BASE!!
+				def m1
+					0																# rebase #m1
+				end
+				def m3														
+					:m3															# muted by internal basing
+				end
 			end
+			p = Object.new.extend(Functionality(Base3))
+
+			p.m1.should == 3
+			p.m2.should == 6
+			p.m3.should == 'em3em3'
+
+
+			q = Object.new.extend(							# INTERNAL NEW BASE!!
+				Functionality() do
+					def m1
+						2															# internal rebase blocks outside one
+					end
+				end)
+				
+			q.m1.should == 2
+			q.m2.should == 6
+
+			module Base4												# EXTERNAL NEW BASE 
+				def m1
+					'em1'														# muted by internal rebasing
+				end
+			end
+			r = Object.new.extend(Functionality(Base4))
+
+			r.m1.should == 2
+			r.m2.should == 6
 		end
 		
-		p = Object.new.extend Functionality()
-		p.m1.should == 9
+	end
+	
+end
 
-		module Base3
+describe 'jiti hard external basing' do
+
+	####################################################################
+	# Soft external basing should be the preferred way of doing things #
+	# . The alternative hard internal basing (see below) is not as     #
+	# flexible and inrtoduces fixed ancestor ordering --once the       #
+	# the ancestors are layout the keep their precedence unlsess you   #
+	# stick only to injectors.																				 #
+	# . Soft ancestors don't suffer from this like: 									 #
+	# 																																 #
+	# 	trait :a, :b, :c 																							 #
+	# 																																 #
+	# 	x = a b c																											 #
+	# 	y = a c b																											 #
+	# 																																 @
+	# For more on this see the compostion spec												 #
+	# ##################################################################
+	
+	before do
+		
+		#
+		# Injector
+		# 
+		trait :Functionality
+
+
+		module Base1												# EXTERNAL BASEs!!
 			def m1
-				0																# new base
+				2
 			end
-			def m3														
-				:m3															# muted by internal basing
+		end
+
+		module Base2
+			def m1
+				3
 			end
 		end
 
-		p = Object.new.extend(Functionality(Base3))
-		p.m1.should == 3
-		p.m2.should == 6
-		p.m3.should == 'em3em3'
+		suppress_warnings do
+			# 
+			# Similar to Above
+			# 
+			Tag1 = Functionality() do
+
+				include Base1										# SAME AS AN INTERNAL BASE PRACTICALLY!!
 
-		q = Object.new.extend(
-			Functionality() do
-				def m1
-					2															# internal rebase
+				def m2
+					:m2
 				end
-			end)
-		q.m1.should == 2
-		q.m2.should == 6
+			end
+
+			Tag2 = Functionality() do
+				
+				include Base2
+				
+				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
+
+			Tag3 = 	Functionality() do
+				
+				include Base1											# THIS DOESN'T WORK!!!
+																					# Base1 was already an ancestor before Base2
+				def m1
+					super * 2 											# second override to #m1 
+				end                   						# -- Tag2 added as ancestor
+				def m3
+					super * 2												# first override to #m3
+				end 								
+			end
+
+		end
+	end
+
+	after do
+
+		suppress_warnings do
+
+			Tag1 = nil
+			Tag2 = nil
+			Tag3 = nil
+			Tag4 = nil
+			Tag5 = nil
+			Tag6 = nil
+
+		end
+
+		Functionality(:implode)
+
+	end
+	
+	it 'works for Tag1' do
 		
-		Tag18 = Functionality()
+		# SAME AS ABOVE
 		
-		module Base4
-			def m1
-				'em1'														# muted by internal rebasing
+		o = Object.new.extend(Tag1)
+		o.m1.should == 2
+		
+	end
+	
+	it 'works for Tag2' do
+		
+		# SAME AS ABOVE
+		
+		o = Object.new.extend(Tag2)
+		o.m1.should == 4
+		
+	end
+
+	it 'works with initial external basing' do
+		
+		# DIFFERENT THAN ABOVE
+		
+		o = Object.new.extend(Tag3)
+		o.m1.should == 8              
+
+	end
+
+	it 'also keeps the main trait in sync with the last tag' do
+
+		# SAME AS ABOVE
+		
+		p = Object.new.extend(Functionality(Base1))	# THIS DOESN'T WORK EITHER!!!
+		p.m1.should == 8
+
+	end
+
+	it 'allows external base substitution --keeps the Trait Injector shell/jacket' do
+
+		# SAME AS ABOVE
+		
+		q = Object.new.extend(Functionality())	# Base2 comming from internal spec!!!!
+		q.m1.should == 8
+
+	end
+
+	it 'follows the other normal rules' do
+
+		# DIFFERENT THAN ABOVE
+		
+		suppress_warnings do
+			Tag4 = Functionality(Base1) do 				# THIS DOESN'T WORK EITHER!!!
+				def m1
+					super() * 2											
+				end
+				def m2
+					:m2
+				end
 			end
 		end
-		
-		r = Object.new.extend(Functionality(Base4))
-		r.m1.should == 2
-		r.m2.should == 6
+		p = Object.new.extend(Tag4)
+		p.m1.should == 16
 
 	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+'))