jackbox 0.9.6.6 → 0.9.6.8

data/spec/lib/jackbox/injector_inheritance_spec.rb

@@ -137,7 +137,7 @@ describe "Injector Inheritance" do
 
 	end
 
-	a "more complex example: effectively working Ruby's multiple inheritance" do
+	a "more complex example:" do
 
 		jack :player do                       
 			def sound                               
@@ -188,91 +188,138 @@ describe "Injector Inheritance" do
 	end
 
 
-	it "allows a just-in-time inheritance policy" do
-	
-		trait :Functionality
-		
-		# 
-		# Our Modular Closure
-		# 
-		Tag1 = Functionality do
-			def m1
-				1
+	describe 'jiti' do
+
+		it "follows a just-in-time inheritance policy" do
+
+			########################## important ############################
+			# For more information on JIT Inheritance (jiti), please see:   #
+			# the accompanying spec file jiti_rules_spec.rb in the specs    #
+			# directory.																										#
+			#################################################################
+
+			injector :Functionality
+
+			# 
+			# Our Modular Closure
+			# 
+			Tag1 = Functionality do
+				def m1
+					1
+				end
+
+				def m2
+					:m2
+				end
 			end
-			
-			def m2
-				:m2
+
+			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
-		end
-		
-		expect(Tag1.ancestors).to eql( [Tag1] )
-		expect(Functionality().ancestors).to eql( [Functionality()] )
 
+			# 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
+
+			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'
+
+	    expect(Functionality().ancestors).to eql( [Functionality(), Tag1] )
+	    expect(Tag2.ancestors).to eql( [Tag2, Tag1] )
+
+			Functionality(:implode)
 
-		# 
-		# 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
+	  but '#define_method skips all hard tags' do
+
+	    injector :J1
+	
+			J1Tag1 = J1 do
+				def m1
+					1
+				end
+			end
 			
-			def m3							
-				'em3'
+			J1Tag2 = J1 do
+				def m1
+					super * 3
+				end
 			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'
+			
+			o = Object.new.enrich(J1Tag2)
+			o.m1.should == 3
+			
+			J1Tag3 = J1 do
+				define_method :m1 do
+					super() + 4
+				end
+			end
+			
+			expect { o.m1.should == 5 }.to raise_error(RSpec::Expectations::ExpectationNotMetError)
+			assert( o.m1 == 3 )
+			
+			
+			p = Object.new.extend J1Tag3
+			p.m1.should == 7
 
-		Functionality(:implode)
-		
+			J1 do
+				define_method :m1 do
+					super() + 4
+				end
+			end
+			
+			expect{ p.m1.should == 9 }.to raise_error(RSpec::Expectations::ExpectationNotMetError)
+			assert( o.m1 == 3 )
+			assert( p.m1 == 7 )
+			
+	  end
 	end
 	
-	
-	########################## important ############################
-	# For more information on JIT Inheritance (jiti), please see:   #
-	# the accompanying spec file jiti_rules_spec.rb in the specs    #
-	# directory.																										#
-	#################################################################
-	
-
 end
 
 describe "the behavior of traits under class inheritance" do

data/spec/lib/jackbox/injector_introspection_spec.rb

@@ -239,7 +239,7 @@ describe "the introspection api in further detail" do
 
 			end
 
-			the ':all trait list for classes lists CLASS instance traits first and then OBJECT instance traits' do
+			the ':all option lists CLASS instance traits first and then OBJECT instance traits' do
 
 				trait :two
 				trait :one
@@ -252,32 +252,54 @@ describe "the introspection api in further detail" do
 				Array.traits(:all).sym_list.should == [:one, :two]
 				
 				Array.new.traits.sym_list.should == [:two] 	# :one is member of Array.singleton_class 
-																												# and does not become part of Array.instances
+																										# and does not become part of Array.instances
+			end
+			
+			it 'also works on injector instances' do
+				
+				trait :a, :b
+				
+				a do
+					def foo
+						:foo
+					end
+				end
+				o = Object.new.extend(a)
+				o.foo.should == :foo
+				
+				b do
+					def faa
+						:faa
+					end
+				end
+				a.extend b
+				a.faa.should == :faa
+				
 			end
 
 		end
 	end
 
 
-	describe :history do
+	describe :history, '#versions' do
 
 		
-		jack :Histample
+		jack :Hsample
 		             
 
 		it 'does not show original jack' do 
-			expect(Histample().history.first).to eq(nil)
+			expect(Hsample().history.first).to eq(nil)
 		end 
 		
 		it "shows additional jacks once hosted, i.e.: after extend/include" do
 			
-			extend(Histample(), Histample())					# host two items
+			extend(Hsample(), Hsample())					# host two items
 			
-			traits.should == Histample().history		# equal at this point
+			traits.should == Hsample().history		# equal at this point
 
-			expect(Histample().history.size).to eq(2)
-			expect(Histample().history.last).to eql(traits.last)
-			expect(Histample().history.first).to eq(traits.first)
+			expect(Hsample().history.size).to eq(2)
+			expect(Hsample().history.last).to eql(traits.last)
+			expect(Hsample().history.first).to eq(traits.first)
 			expect(traits.size).to eq(2)
 			
 			eject *traits
@@ -286,66 +308,102 @@ describe "the introspection api in further detail" do
 		
 		it "allows you to retreive items using an index" do
 			
-			extend Histample(), Histample()
+			extend Hsample(), Hsample()
 			
-			traits.should == Histample().history
+			traits.should == Hsample().history
 
-			expect(Histample().history.slice(0)).to be_instance_of(Injector)
-			expect(Histample().history.slice(1)).to be_instance_of(Injector) 
+			expect(Hsample().history.slice(0)).to be_instance_of(Injector)
+			expect(Hsample().history.slice(1)).to be_instance_of(Injector) 
 			
-			eject Histample(), Histample()
+			eject Hsample(), Hsample()
 			
 		end
 		
 		it 'swallows items once ejected' do
 			
-			extend(Histample(), Histample())
+			extend(Hsample(), Hsample())
 			
-			traits.should == Histample().history
+			traits.should == Hsample().history
 
-			expect(Histample().history.size).to eq(2)
+			expect(Hsample().history.size).to eq(2)
 			expect(traits.size).to eq(2)
 			
 			eject *traits
 			
 			expect(traits).to be_empty  							# target traits
-			expect(Histample().history).to be_empty			# Injector history
+			expect(Hsample().history).to be_empty			# Injector history
 			
 		end
 		
 		it 'swallows un-hosted elements other than original one' do
 			
-			Histample() #un-hosted Histample 
-			Histample() #un-hosted Histample
+			Hsample() #un-hosted Hsample 
+			Hsample() #un-hosted Hsample
 			
-			expect(Histample().history.size).to eq(0)
+			expect(Hsample().history.size).to eq(0)
 			
 		end
 		
 		it 'shows hosted items upon inspection' do
 
-			extend Histample()
+			extend Hsample()
+			
+			expect(Hsample().history.inspect).to match(/\[\(\|Hsample\|.+\)\]/)
+			expect(Hsample().history.size).to eq(1)
+			
+			eject Hsample()
 			
-			expect(Histample().history.inspect).to match(/\[\(\|Histample\|.+\)\]/)
-			expect(Histample().history.size).to eq(1)
+		end
+		
+		describe '#versions/#history under JITY' do
+			before do
+				trait :One
+				
+				suppress_warnings do
+					OneTag = One do
+						def foo
+							'foo'
+						end
+					end
+				end
+				
+				One do
+					def foo
+						super
+					end
+				end
+				
+			end
 			
-			eject Histample()
+			after do
+				suppress_warnings do
+					OneTag = nil
+				end
+				
+				One(:implode)
+			end
 			
+				
+			it 'should only have one version' do
+				
+				One().versions.size.should == 1 # OneTag
+				One().versions.should == [OneTag]
+			end
 		end
 		
 		describe :precedent do
 
 			it 'points to the previous trait in the history' do
 
-				extend Histample(), Histample()
+				extend Hsample(), Hsample()
 				
 				# Given that
-				traits.should == Histample().history
+				traits.should == Hsample().history
 				
 				# Then 
-				expect(Histample().history.last.precedent).to equal(Histample().history.first)
-				expect(Histample().history.last.pre).to equal(traits.first)
-				expect(traits.last.precedent).to equal(Histample().history.first)
+				expect(Hsample().history.last.precedent).to equal(Hsample().history.first)
+				expect(Hsample().history.last.pre).to equal(traits.first)
+				expect(traits.last.precedent).to equal(Hsample().history.first)
 				expect(traits.last.pre).to equal(traits.first)
 				
 				eject *traits
@@ -354,12 +412,12 @@ describe "the introspection api in further detail" do
 			
 			it 'has spec as the first precedent' do
 				
-				extend Histample(), Histample()
+				extend Hsample(), Hsample()
 				
-				traits.should == Histample().history
+				traits.should == Hsample().history
 				
-				expect(Histample().history.first.precedent).to equal(Histample().spec)
-				expect(traits.first.precedent).to equal(Histample().spec)
+				expect(Hsample().history.first.precedent).to equal(Hsample().spec)
+				expect(traits.first.precedent).to equal(Hsample().spec)
 				
 				eject *traits
 
@@ -369,13 +427,13 @@ describe "the introspection api in further detail" do
 
 			it 'has the latest version as the precedent to spec' do
 				
-				extend Histample(), Histample()
+				extend Hsample(), Hsample()
 				
-				traits.should == Histample().history
+				traits.should == Hsample().history
 				
-				expect(Histample().history.first.precedent).to equal(Histample().spec)
-				expect(Histample().precedent.pre.pre).to equal(Histample().spec)
-				expect(Histample().spec.pre).to eq(Histample().history.last) 
+				expect(Hsample().history.first.precedent).to equal(Hsample().spec)
+				expect(Hsample().precedent.pre.pre).to equal(Hsample().spec)
+				expect(Hsample().spec.pre).to eq(Hsample().history.last) 
 				
 				eject *traits
 				
@@ -384,149 +442,6 @@ describe "the introspection api in further detail" do
 		end
 	end 
 	
-	describe :progenitor do
-
-		before do
-			trait :Progample
-		end
-		after do
-			Progample(:implode)
-		end
-
-		it 'points to its progenitor: the version of trait generating it' do
-
-			expect(Progample().history).to be_empty
-			expect(Progample().progenitor).to equal(Progample().spec)
-
-			# apply the trait
-			
-			extend Progample(), Progample()       
-			
-			expect(Progample().history.size).to eq(2)
-			
-			
-			# both generated form spec
-			
-			expect(Progample().history.first.progenitor).to equal(Progample().spec)
-			expect(Progample().history.last.progenitor).to equal(Progample().spec)
-
-
-			# create a tag
-			
-			suppress_warnings do # used because of rspec
-				ProgenitorsTag = Progample()
-			end
-
-			expect(Progample().history.size).to eq(3)
-			
-			expect(Progample().history.first.progenitor).to equal(Progample().spec)
-			expect(Progample().history.last).to equal(ProgenitorsTag)
-			expect(Progample().history.last.progenitor).to equal(Progample().spec)
-			expect(ProgenitorsTag.progenitor).to equal(Progample().spec)
-
-
-			# apply the tag
-			
-			extend ProgenitorsTag
-
-			expect(Progample().history.size).to eq(4)
-			expect(Progample().history.last).to equal(traits.first)
-			 
-			expect(Progample().history.last.progenitor).to equal(ProgenitorsTag) 
-			expect(Progample().history.first.progenitor).to equal(Progample().spec)
-
-		end
-		
-		it 'points the last progenitor to nil' do
-			
-			expect(Progample().spec.progenitor).to equal(nil)
-
-		end
-
-		it 'works the same with soft tags' do
-
-			suppress_warnings do
-				ProgenitorsTag = Progample()
-			end
-
-			expect(Progample().history.size).to eq(1)
-
-
-			# soft tag
-			# debugger
-			Progample(:tag) { 'some code'}       			
-
-			expect(Progample().history.size).to eq(2)
-
-			# progenitors are the same
-			
-			expect(Progample().history.first.progenitor).to eq(Progample().spec)
-			expect(Progample().history.last.progenitor).to eq(Progample().spec)
-			expect(Progample().history.first.progenitor.progenitor).to eq(nil)
-			expect(Progample().history.last.progenitor.progenitor).to eq(nil)
-
-			# tags call
-			
-			expect(Progample().tags.size).to eq(2)
-
-		end
-
-		it 'carries on the metaphor with traits are shared from other objects' do
-      
-			suppress_warnings do
-				ProgenitorsTag = Progample()
-			end
-
-			class ProgenitorTester1
-				 include ProgenitorsTag
-			end
-			
-			class ProgenitorTester2
-				include *ProgenitorTester1.traits   # copying traits from second class
-			end
-			
-			expect(ProgenitorTester2.traits.first.progenitor).to equal(ProgenitorTester1.traits.first)
-			expect(ProgenitorTester1.traits.first.progenitor).to equal(ProgenitorsTag)
-			expect(ProgenitorsTag.progenitor).to equal(Progample().spec)  
-			
-		end
-		
-	end 
-
-	describe :lineage do 
-		
-		before do
-			trait :Lineample
-		end
-		after do
-			Lineample(:implode)
-		end
-		
-		it 'collects all the progenitors of a line of traits' do 
-			
-			LineagesTag = Lineample()
-
-			class LineageTester1
-				 include LineagesTag
-			end
-			
-			class LineageTester2
-				include *LineageTester1.traits
-			end
-			
-			expect(LineageTester2.traits.first.progenitor).to equal(LineageTester1.traits.first)
-			expect(LineageTester1.traits.first.progenitor).to equal(LineagesTag)
-			expect(LineagesTag.progenitor).to equal(Lineample().spec)  
-			
-			expect(Lineample().lineage).to eq([Lineample().spec, Lineample()])
-			expect(LineageTester2.traits.first.lineage).to eq([Lineample().spec, LineagesTag, LineageTester1.traits.first, LineageTester2.traits.first])
-			expect(Lineample().spec.lineage).to eq([Lineample().spec])
-			expect(Lineample().spec.progenitor).to eq(nil)
-			
-		end
-
-	end
-
 	describe 'equality of Injectors' do
 		
 		before do
@@ -569,7 +484,7 @@ describe "the introspection api in further detail" do
 				# inequality
 				##################################
 		    
-				E().should_not == F()
+				E().should_not eql F()
 
 		    # if E () definitions **
 		    E() do
@@ -592,6 +507,19 @@ describe "the introspection api in further detail" do
 
 			end
 			
+			it 'has case equality showing its presence in an instance' do
+				
+				o = Object.new.extend E()
+				
+				E().should === o
+				
+				case E()
+				when o
+					should be_true
+				end
+				
+			end
+			
 		end
 		
 		describe :diff do
@@ -632,7 +560,7 @@ describe "the introspection api in further detail" do
 				
 			end
 				
-			it 'differs once a definition is present' do
+			it 'differs once injector specalization is present' do
 				
 		    # difference
 		    ##################################
@@ -732,7 +660,7 @@ describe "the introspection api in further detail" do
 				
 			end
 			
-			it 'creates traits for inclusion' do
+			it 'exposes join and delta sub-traits for inclusion/extension' do
 				
 	  		# a tag as precedent
 	  		ETag5 = E()
@@ -777,8 +705,22 @@ describe "the introspection api in further detail" do
 				
 			end
 			
+			it 'accepts a negative index' do
+				
+				extend E(), E(), E()
+				
+				E() do
+					def foo
+					end
+				end
+				
+				E().diff( -1 ).should == [[],[:foo]]
+				E().diff( -3 ).should == [[],[:foo]]
+				E().diff( -4 ).should == [[:foo], []] # self
+				
+			end
+			
 		end
-	
 	end
 
 end