jackbox 0.9.6.3 → 0.9.6.6

data/spec/lib/jackbox/injector_namespacing_spec.rb

@@ -1,34 +1,34 @@
 require "spec_helper"
 =begin rdoc
 	
-	Name spacing of injectors
+	Name spacing of traits
 	Author: LHA
 
 
 
-	Description of the difference between the different namespacing options of injectors:
+	Description of the difference between the different namespacing options of traits:
 	 
-	injector :Main
+	trait :Main
 				vs.
-	injector :main
+	trait :main
 
 	module X
-		injector :Some_Injector
+		trait :Some_Injector
 							vs.
-		injector :some_injector
+		trait :some_trait
 	end
 
 	class Y
-		injector :Other_Injector
+		trait :Other_Injector
 							vs.
-		injector :other_injector
+		trait :other_trait
 	end
 
 =end
 
 ###########################
-injector :Major
-injector :minor            
+trait :Major
+trait :minor            
 ###########################
 
 # upper case vs lower case: semantically equivalent
@@ -73,8 +73,8 @@ end
 
 ###############################
 module X
-	injector :Maxi																	# use sparringly
-	injector :mini
+	trait :Maxi																	# use sparringly
+	trait :mini
 end
 ################################
 
@@ -144,9 +144,9 @@ end
 # Should follow the same line
 # 
 class Y
-	injector :Other_Injector
+	trait :Other_Injector
 						# vs.
-	injector :other_injector
+	trait :other_trait
 end
 # 
 # No example needed!!
@@ -156,12 +156,12 @@ end
 
 
 # Tied to the idea of Injector Name Spaces is the one of Injector Version Naming/Tagging.  In order to make is easier to
-# work with injector versions there is a need to tag/name the different versions for later use.
-describe 'injector Tagging/Naming and its relationship to Injector Versioning' do
+# work with trait versions there is a need to tag/name the different versions for later use.
+describe 'trait Tagging/Naming and its relationship to Injector Versioning' do
 	
 	there 'is way to tag/name a particular version for later reuse' do
 
-		injector :Bar
+		trait :Bar
 		
 		Tag = Bar do
 			def foo_bar

data/spec/lib/jackbox/injector_spec.rb

@@ -839,6 +839,32 @@ describe Injectors, :injectors do
 				
 			end
 			
+			it 'ejects inherited tags' do
+				
+				EjectionTag1 = jack :ejection_test do
+					def m1
+						2
+					end
+				end
+				
+				EjectionTag2 = ejection_test do
+					def m1
+						super + 2										# override --jit inheritance
+					end
+				end
+				
+				o = Object.new.enrich EjectionTag2
+				o.m1.should == 4
+				# o.metaclass.ancestors.to_s.should match(/EjectionTag2.*EjectionTag1/)
+				
+				o.eject EjectionTag2
+				expect{o.m1}.to raise_error(NoMethodError)
+				o.metaclass.ancestors.to_s.should_not match(/EjectionTag2/)
+				o.metaclass.ancestors.to_s.should_not match(/EjectionTag2.*EjectionTag1/)
+				o.metaclass.ancestors.to_s.should_not match(/EjectionTag1/)
+				
+			end
+
 		end
 	end
 

data/spec/lib/jackbox/injector_versioning_spec.rb

@@ -2,29 +2,29 @@ require "spec_helper"
 
 include Injectors
 
-describe 'Injector versioning:', :injectors do
-# subsequent redefinitions of methods constitute another version of the injector.  Injector 
+describe 'Injector versioning:', :traits do
+# subsequent redefinitions of methods constitute another version of the trait.  Injector 
 # versioning is the term used to identify a feature in the code that produces an artifact of injection which contains a 
-# certain set of methods and their associated outputs and represents a snapshot of that injector up until the point it 
-# gets applied to an object.  From, that point on the object contains only that version of methods from that injector, and 
-# any subsequent overrides to those methods are only members of the "prolongation" of the injector and do not become part 
+# certain set of methods and their associated outputs and represents a snapshot of that trait up until the point it 
+# gets applied to an object.  From, that point on the object contains only that version of methods from that trait, and 
+# any subsequent overrides to those methods are only members of the "prolongation" of the trait and do not become part 
 # of the object of injection unless some form of reinjection occurs. Newer versions of methods only become part of newer 
 # objects or newer injections into existing targets'
 	
-	describe 'injector versioning and its relationship to object instances' do
+	describe 'trait versioning and its relationship to object instances' do
 	
-		the 'injector versioning uses a snapshot of the injector`s existing methods up to the point of injection' do
-		# using only that version of	methods as the object of injection.  AA4ny overrides to methods in any subsequent injector prolongations 
-		# do not take effect in this target.  AA4ny new methods added to the injector do become available to the target, although
+		the 'trait versioning uses a snapshot of the trait`s existing methods up to the point of injection' do
+		# using only that version of	methods as the object of injection.  AA4ny overrides to methods in any subsequent trait prolongations 
+		# do not take effect in this target.  AA4ny new methods added to the trait do become available to the target, although
 		# may contain internal references to newer versions of the target methods. This ensures to keep everyting working correctly.'
 		
 			#___________________
-			# injector declaration
-			injector :My_injector
+			# trait declaration
+			trait :My_trait
 
 	    #___________________
-	    # injector first prolongation
-	    My_injector do 															
+	    # trait first prolongation
+	    My_trait do 															
 	      def bar
 	        :a_bar                                  # version bar.1
 	      end
@@ -34,12 +34,12 @@ describe 'Injector versioning:', :injectors do
 	    end
 	
 			object1 = Object.new
-	    object1.enrich My_injector()                # apply the injector --first snapshot
+	    object1.enrich My_trait()                # apply the trait --first snapshot
 	    object1.bar.should == :a_bar                # pass the test
 
 	    #__________________
-	    # injector second prolongation
-	    My_injector do 																			
+	    # trait second prolongation
+	    My_trait do 																			
 	      def bar
 	        :some_larger_bar                        # version bar.2 ... re-defines bar
 	      end
@@ -49,7 +49,7 @@ describe 'Injector versioning:', :injectors do
 	    end
     
 			object2 = Object.new
-	    object2.enrich My_injector()                # apply the injector --second snapshot
+	    object2.enrich My_trait()                # apply the trait --second snapshot
 	    object2.bar.should == :some_larger_bar
 
 	    # result
@@ -66,7 +66,7 @@ describe 'Injector versioning:', :injectors do
 			
 			#_________________
 			# re-injection
-			enrich My_injector()																	# re-injection on any object instance
+			enrich My_trait()																	# re-injection on any object instance
 			bar.should == :some_larger_bar												# bar.2 now available
 			
 			expect{some_other_function}.to_not raise_error				# some_other_function.1 is present
@@ -77,7 +77,7 @@ describe 'Injector versioning:', :injectors do
 			
 			o = Object.new
 			
-			injector :some_methods do
+			trait :some_methods do
 				def meth arg
 					arg
 				end
@@ -103,19 +103,19 @@ describe 'Injector versioning:', :injectors do
 
 	end
 	
-	describe "injector versioning and its relationship to classes" do
-	# similar to object level versioning in that it uses a snapshot of the injector`s existing methods up to the point of injection, using only 
+	describe "trait versioning and its relationship to classes" do
+	# similar to object level versioning in that it uses a snapshot of the trait`s existing methods up to the point of injection, using only 
 	# that version of methods as the object of injection.  But, unlike object level versioning, because class injection is static, reinjection 
 	# does not change the class unless we use the Strategy Pattern which completely changes the class's strategy of methods" 
 		
-		the "class injector versioning is similar to object injector versioning" do
+		the "class trait versioning is similar to object trait versioning" do
 			
 			#___________________
-			# injector declaration:
-			injector :Versions 
+			# trait declaration:
+			trait :Versions 
 
 	    #___________________
-	    # injector first prolongation
+	    # trait first prolongation
 	    Version1 = Versions do
 	      def meth arg                              # version meth.1
 	        arg ** arg
@@ -127,7 +127,7 @@ describe 'Injector versioning:', :injectors do
 	    end
 
 	    #_________________
-	    # injector second prolongation                              
+	    # trait second prolongation                              
 	    Version2 = Versions do
 	      def meth arg1, arg2                       # version meth.2 ... redefines meth.1
 	        arg1 * arg2
@@ -142,7 +142,7 @@ describe 'Injector versioning:', :injectors do
 	    # result
 	    #############################
 	    Two.new.meth(2,4).should == 8               # meth.2 
-	                                                            # two different injector versions
+	                                                            # two different trait versions
 	    One.new.meth(3).should == 27                # meth.1
 	    #############################
 	    #
@@ -162,7 +162,7 @@ describe 'Injector versioning:', :injectors do
 			
 		end
 		
-		the 'way to class level injector updates is through the Strategy Pattern' do
+		the 'way to class level trait updates is through the Strategy Pattern' do
 					 
 			# DO NOT want to necessarily update older clients of the class
 			# but possible if needed
@@ -170,7 +170,7 @@ describe 'Injector versioning:', :injectors do
 			class One
 				eject Version1													# eject version 1
 			
-				inject Version2													# re-inject with prolonged injector -- can be any version
+				inject Version2													# re-inject with prolonged trait -- can be any version
 			end
 			One.new.meth(4,5).should == 20							# meth.2 now available!!
 			
@@ -205,7 +205,7 @@ describe 'Injector versioning:', :injectors do
 			
 			class Freak
 				
-				injector :freaky
+				trait :freaky
 				freaky do
 					def twitch
 						'_-=-_-=-_-=-_-=-_'
@@ -255,11 +255,11 @@ describe 'Injector versioning:', :injectors do
 		end
 	end
 
-	describe "utility of injector versioning: " do
+	describe "utility of trait versioning: " do
 		
 		it 'allows to easily override methods without affecting other parts of your program' do
 			
-			J1 = injector :j do
+			J1 = trait :j do
 				def meth(arg)
 					arg
 				end
@@ -285,11 +285,11 @@ describe 'Injector versioning:', :injectors do
 			
 		end
 		
-		the "local binding of injectors" do
+		the "local binding of traits" do
 
 	    #_____________________
-	    # injector declaration
-	    VersionOne = injector :functionality do
+	    # trait declaration
+	    VersionOne = trait :functionality do
 	      def basic arg                             # version basic.1
 	        arg * 2
 	      end
@@ -300,7 +300,7 @@ describe 'Injector versioning:', :injectors do
 
 
 	    #_____________________
-	    # injector prolongation
+	    # trait prolongation
 	    VersionTwo = functionality do
 	      def basic arg                             # basic.2 ... basic.1 redefined
 	        arg * 3
@@ -321,7 +321,7 @@ describe 'Injector versioning:', :injectors do
 
 	    o.basic(1).should == 2                      # basic.1 
 			# debugger
-	    o.compound.should == 11                     # compound.1 --local injector binding
+	    o.compound.should == 11                     # compound.1 --local trait binding
 
 	    ###################################
 	    # This ensures #compound.1 keeps bound

data/spec/lib/jackbox/jiti_rules_spec.rb

@@ -0,0 +1,663 @@
+require "spec_helper"
+
+describe 'jit inheriatnce' do
+
+	before do
+		
+		suppress_warnings do
+
+			# 
+			# Trait
+			# 
+			trait :Functionality
+
+			# 
+			# Works like class inheritance
+			# 
+			Tag1 = Functionality do
+				def m1
+					1
+				end
+
+				def m2
+					:m2
+				end
+			end
+
+			Functionality do
+				def other  					# No overrides No inheritance
+					'other'						# -- same ancestors as before
+				end 								# -- normal trait inheritance
+			end
+
+			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
+
+			class AA6
+				inject Tag2
+			end
+
+			Tag3 = 	Functionality() do
+				def m1
+					super * 2 											# second override to #m1 
+				end                   						# -- Tag2 added as ancestor
+				def m3
+					super * 2												# first override to #m3
+				end 								
+			end
+
+			class AA7
+				inject Tag3 
+			end
+
+		end
+	end
+
+	after do
+
+		suppress_warnings do
+
+			Tag1 = nil
+			Tag2 = nil
+			Tag3 = nil
+
+		end
+
+		Functionality(:implode)
+
+	end
+
+	it 'works under boejct extension' do
+
+		o = Object.new.extend Tag3
+		o.m1.should == 4
+
+	end
+
+	it 'also works under class inclusion' do
+
+		#
+		# Under Inclusion
+		# 
+		class AA6
+			inject Tag2
+		end
+		aa6 = AA6.new
+
+		# JIT inherited
+		aa6.m1.should == 2
+		aa6.m3.should == 'em3'
+
+		# Version inherited
+		aa6.m2.should == :m2
+		aa6.other.should == 'other'
+
+		Functionality().tags.should == [Tag1, Tag2, Tag3]
+
+	end
+
+	it 'goes on down the levels' do
+
+		#
+		# Different client/Diferent Tag
+		# 
+		class AA7
+			inject Tag3 
+		end
+		aa7 = AA7.new
+
+		# JIT inherited
+		aa7.m1.should == 4					
+		aa7.m3.should == 'em3em3'
+
+		# regular inheritance
+		aa7.m2.should == :m2
+		aa7.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
+
+		# 
+		# Test previous Tags are unaffected !!
+		# 
+		AA6.new.m1.should == 2							# includes Tag2
+		AA6.new.m2.should == :m2
+		AA6.new.m3.should == 'em3'
+
+		AA7.new.m1.should == 4							# includes Tag3
+		AA7.new.m2.should == :m2
+		AA7.new.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'
+
+	end
+
+	it 'keeps the VMC in proper working order' do
+
+		#
+		# VMC (Virtual Method Cache) method
+		#
+		Functionality() do
+			def m4							
+				:m4
+			end
+		end
+
+		class AA6B
+			inject Tag2
+		end
+		aa6b = AA6B.new
+
+		# jit inherited
+		aa6b.m1.should == 2
+		aa6b.m3.should == 'em3'
+
+		# version inherited
+		aa6b.m2.should == :m2
+		aa6b.other.should == 'other'
+
+		aa6b.m4.should == :m4		# vmc method
+
+		# other clients of the VMC
+		AA6.new.m4.should == :m4
+		AA7.new.m4.should == :m4
+
+	end
+
+	it "allows further ancestor injection" do
+
+		module Mod1
+			def m4
+				:m4
+			end
+		end
+
+		Tag5 = Functionality(Mod1) do
+
+			include Mod1											# alternatively
+
+			def m1
+				super * 2
+			end
+			def m3
+				:m3															# m3 is rebased
+			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
+
+	end
+
+	it "also allows on the fly overrides" do
+
+		#
+		# On the fly overrides
+		# 
+		obj = Object.new.extend(
+			Functionality {
+				def m1
+					super + 3											# on top of Tag1, Tag2, Tag3
+				end
+				def m4
+					:m4
+				end
+			})
+
+		# new jiti override
+		obj.m1.should == 7
+
+		# version inherited
+		obj.m2.should == :m2
+		obj.m3.should == 'em3em3'
+		obj.m4.should == :m4
+
+		# other prolongation
+
+		Object.new.extend(Functionality(){
+			def m3
+				super * 2
+			end
+		}).m3.should == 'em3em3em3em3'
+
+	end
+
+	it "blocks external ancestor intrusion enforcing internal trait consistency" do
+
+		#########################################
+		# Masks Ancestor intrussion
+		# 
+
+		Tag6 = Functionality do
+			def m1														# Injector has internal base
+				1
+			end
+		end
+
+		module Mod1
+			def m1
+				'one'
+			end
+		end
+
+		Tag7 = Functionality(Mod1) do 						# Mod1 attempts to intrude on base
+
+			include Mod1
+
+			def m1
+				super * 2
+			end
+		end
+
+		# test it
+
+		o = Object.new.extend(Tag7)			
+		# jit inherited
+		o.m1.should == 2										# no such luck!!
+
+		p = Object.new.extend(Functionality())
+		# jit inherited
+		p.m1.should == 2										# no such luck!!
+
+		# version inherited
+		o.m2.should == :m2 # from Tag1
+		p.m2.should == :m2
+
+	end
+
+	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
+		end
+		class AA10
+		  inject Tag10
+		end
+
+		# test it
+
+		AA10.new.m1.should == 'm1m1'
+		AA10.new.m2 == 4
+
+	end
+
+	it 'allows rebasing (start fresh) methods at any level' do
+
+		Tag11 = Functionality do
+			def m1
+				1																# rebase Tag3
+			end
+		end
+
+		class AA11
+			inject Functionality() do
+				def m1
+					super + 1											# override
+				end
+			end
+		end
+
+		# test it
+
+		AA11.new.m1.should == 2
+
+
+		Tag12 = Functionality do
+			def m1
+				5																# rebase m1 again
+			end
+		end
+
+		class BB11
+			inject Functionality() do
+				def m1
+					super * 2											# new override
+				end
+			end
+		end
+
+		# test it
+
+		BB11.new.m1.should == 10
+
+
+	end
+
+	it 'slloed Injector Directives likr sll traits' do
+
+		Tag13 = Functionality do
+			def m1
+				1
+			end
+		end
+
+		class AA12
+			inject Functionality() do
+				def m1
+					super + 1
+				end
+			end
+		end
+
+		AA12.new.m1.should == 2
+
+
+		Tag14 = Functionality do
+			def m1
+				5									# rebase m1
+			end
+		end
+
+		class BB12
+			inject Functionality() do
+				def m1
+					super * 2				# new override
+				end
+			end
+		end
+
+		BB12.new.m1.should == 10
+
+		# test directives
+
+		Functionality(:silence)
+
+		AA12.new.m1.should == nil										# both bases affected
+		BB12.new.m1.should == nil
+
+		Functionality(:active)
+
+		AA12.new.m1.should == 2											# both bases restored
+		BB12.new.m1.should == 10
+
+	end
+
+end
+
+describe 'jiti external basing' do
+
+	before do
+		
+		#
+		# Injector
+		# 
+		trait :Functionality
+
+		suppress_warnings do
+
+			module Base1												# EXTERNAL BASEs!!
+				def m1
+					2
+				end
+			end
+
+			module Base2
+				def m1
+					3
+				end
+			end
+
+			# 
+			# Similar to Above
+			# 
+			Tag1 = Functionality(Base1) do
+
+				# include Base1										# alternatively
+
+				def m2
+					:m2
+				end
+			end
+
+			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
+
+			Tag3 = 	Functionality() do
+				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
+
+		end
+
+		Functionality(:implode)
+
+	end
+
+	it 'works with initial external basing' do
+
+		o = Object.new.extend(Tag3)
+		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.m1.should == 6
+
+	end
+
+	it 'follows the other normal rules' 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
+
+	end
+
+	it 'allows external base substitution --keeps the Trait Injector shell/casing' do
+
+		q = Object.new.extend(Functionality(Base2))	# on top or Tag3 thru Tag2....
+		q.m1.should == 8
+
+	end
+
+	it 'also allows other external base function' do
+
+		module Base2
+			def m4
+				'new'
+			end
+		end
+
+		Tag16 = Functionality(Base2) do
+			def m1
+				super / 2
+			end
+			def m2
+				super
+			end
+		end
+
+		p = Object.new.extend(Tag16)
+
+		p.m1.should == 4										# external rebase and thru Tag16, Tag3 and Tag2
+		p.m2.should == :m2
+		p.m4.should == 'new'								# new function
+
+	end
+
+	it 'enforces internal basing once applied --blocks further external intrusion (like above)' do
+
+		Tag17 = Functionality(Base2) do
+			def m2 
+				6																# rebase #m2
+			end
+		end
+
+		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												# on top of Tag17
+			end
+		end
+		
+		p = Object.new.extend Functionality()
+		p.m1.should == 9
+
+		module Base3
+			def m1
+				0																# new base
+			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(
+			Functionality() do
+				def m1
+					2															# internal rebase
+				end
+			end)
+		q.m1.should == 2
+		q.m2.should == 6
+		
+		Tag18 = Functionality()
+		
+		module Base4
+			def m1
+				'em1'														# muted by internal rebasing
+			end
+		end
+		
+		r = Object.new.extend(Functionality(Base4))
+		r.m1.should == 2
+		r.m2.should == 6
+
+	end
+	
+end