jackbox 0.9.6.3 → 0.9.6.6

data/spec/lib/jackbox/vmc_spec.rb

@@ -4,7 +4,7 @@ require "spec_helper"
 	VIRTUAL METHOD CACHE
 	
 	Virtual methods are methods that have not beeen applied as part of any injection as of yet.  They are not part of a version, execpt for the current one.
-	In as such, they are common to all injectors, and can service any of them.  They stop being virtual when they become part of an injector application.
+	In as such, they are common to all traits, and can service any of them.  They stop being virtual when they become part of an trait application.
 =end
 include Injectors
 
@@ -155,7 +155,7 @@ describe "VMC (Virtual Method Cache)" do
 		  def j1																			# they becomen part of the
 				:j1
 		  end 																				# following application of 
-		end 																					# this injector
+		end 																					# this trait
 		
 		K1 do
 		  def k1
@@ -163,7 +163,7 @@ describe "VMC (Virtual Method Cache)" do
 		  end
 		end
 		J1 do
-		  inject K1()															# injector application!
+		  inject K1()															# trait application!
 		end
 		
 		L1 do
@@ -172,7 +172,7 @@ describe "VMC (Virtual Method Cache)" do
 			end
 		end
 		K1 do
-			inject L1()															# injector application
+			inject L1()															# trait application
 		end
 		
 		M1() do
@@ -205,26 +205,28 @@ describe "VMC (Virtual Method Cache)" do
 		Object.inject J1()
 		
 		J1 do
-			def j1																			# virtual methods
+			def j1																			# virtual cache methods
 				:j1
 			end
 			def meth
-				super + "#{j1}"
+				"#{j1}-" + super 
 			end
+			inject(K1())
 		end
 
-		J1().inject K1()
+		expect{J1().inject K1()}.to raise_error(NoMethodError)
 		
 		K1 do
 			def k1																			# virtual methods
 				:k1
 			end
 			def meth
-				super + "#{k1}"
+				"#{k1}-" + super
 			end
+			inject(L1())
 		end
 		
-		K1().inject L1() 
+		expect{K1().inject L1()}.to raise_error(NoMethodError) 
 		
 		L1 do
 			def meth																		# virtual methods
@@ -233,10 +235,167 @@ describe "VMC (Virtual Method Cache)" do
 		end
 		
 		o = Object.new
-		o.meth.should == 'l1k1j1'											# this call is on the VMC!!!
+		o.meth.should == 'j1-k1-l1'											# this call is on the VMC!!!
 		
 	end
 
+	it 'works accross compound traits' 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       													# trait pipeline!
+
+
+			# Apply the traits
+
+			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 in different ways' do
+
+		expect{
+			
+		 	trait :J1
+		 	trait :J2
+		 	trait :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{
+			
+			trait :K1
+			trait :K2
+			trait :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{
+			
+			trait :M1
+			trait :M2
+			trait :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
 
 end
 

data/spec/lib/jackbox_spec.rb

@@ -39,27 +39,6 @@ describe Jackbox, 'jackbox library', :library do
 		
 		end
 		
-		it 'allows decorating the same method multiple times' do
-
-			class T
-				def bar
-					'bar '
-				end
-			end
-			class T
-				decorate :bar do 																# <- GETS CLOBERED 
-					super() + 'none '
-				end
-			end
-			class T
-				decorate :bar do
-					super() + 'and then some'
-				end
-			end
-			expect{T.new.bar.should == 'bar and then some'}.to_not raise_error 
-
-		end			
-		
 		it 'is available at the object instance level during execution' do
 
 			class One
@@ -80,99 +59,58 @@ describe Jackbox, 'jackbox library', :library do
 		
 		end
 		
+		it 'also works like so' do
+		
+			Object.decorate :to_s do
+				super() + " is your object"
+			end
+			Object.new.to_s.should match(/is your object/)
+		
+		end
+
 		it 'allows ruby_c objects and singleton classes to be decorated as well' do
 
-			STDOUT.should_receive(:puts).with("Changing directory...")
-			
-			Dir.singleton_class.instance_eval do
-				decorate :chdir do |*args|
-					puts 'Changing directory...'
-					super(*args)
-				end
+			Dir.singleton_class.decorate :chdir do |*args|
+				puts 'Changing directory...'
+				super(*args)
 			end
+			
+			STDOUT.should_receive(:puts).with("Changing directory...")
 			Dir.chdir('.').should == 0
-			Dir.singleton_class.instance_eval { undecorate :chdir }
+			
+			Dir.metaclass.undecorate :chdir
 
+			STDOUT.should_not_receive(:puts).with("Changing directory...")
+			Dir.chdir('.').should == 0
+			
 		end
 		
 		it 'raises an error when decorating singleton classes without returning them properly' do
 
 			expect {
 				
-				class File
+				class File 											# MUST USE #singleton_class or #metaclass
 					class << self
 						decorate :chown do |*args| end
 					end
 				end
 				
-			}.to raise_error
+			}.to raise_error(UserError)
+
 			expect {
 				
 				class File
-					singleton_class.instance_eval do  # MUST USE #singleton_class or #metaclass
-						decorate :chown do |*args| end
+					metaclass.decorate :chown do |*args| 
+						puts 'Changing ownership...'
+						super(*args)
 					end
 				end
 				
+				File.metaclass.undecorate :chown
+				
 			}.to_not raise_error		
 				
 		end
-		
-		the 'decoration can be rolled back' do
-			
-			class F
-				def bar
-					'bar '
-				end
-			end
-			class F
-				decorate :bar do
-					super() + 'the unforseen'
-				end
-			end
-			F.new.bar.should == 'bar the unforseen'	
-			class F
-				# remove_method :bar
-				undecorate :bar
-			end
-			F.new.bar.should == 'bar '		 
-			
-		end
-		
-		this 'roll-back works on singleton_class also' do
-			
-			class G
-				class << self
-					def moo
-						'moooo'
-					end
-				end
-			end
-			class G
-				singleton_class.instance_eval do
-					decorate :moo do
-						super() + ' maaaa'
-					end
-				end
-			end
-			G.moo.should == 'moooo maaaa'
-			class G
-				singleton_class.instance_eval do
-					undecorate :moo
-				end
-			end
-			G.moo.should == 'moooo'
-			
-		end			
-		
-		it 'also works like so' do
-			
-			Object.decorate :inspect do
-				super() + " is your object"
-			end
-			Object.new.inspect.should =~ /is your object/
-			
-		end
 
 		it 'does not work on undefined methods' do
 			
@@ -185,7 +123,7 @@ describe Jackbox, 'jackbox library', :library do
 					:boo
 				end
 			end
-			}.to raise_error
+			}.to raise_error(NameError)
 		end
 		
 		it 'is not intended to work on plain modules' do
@@ -212,13 +150,13 @@ describe Jackbox, 'jackbox library', :library do
 				
 				B.new.off.should == 'offon'			#fails!!
 				
-			}.to raise_error
+			}.to raise_error(RSpec::Expectations::ExpectationNotMetError)
 			
 		end
 		
-		it 'is not intended for plain injectors either' do
+		it 'is not intended for plain traits either' do
 			
-			Aj = injector :aj do
+			Aj = trait :aj do
 				def off
 					'off'
 				end
@@ -241,33 +179,177 @@ describe Jackbox, 'jackbox library', :library do
 				
 				Bj.new.off.should == 'offon'			#fails!!
 				
-			}.to raise_error
+			}.to raise_error(RSpec::Expectations::ExpectationNotMetError)
 			
 		end
 		
-		it 'does work on self-extended injectors/modules' do
+		it 'does work on trait/module metaclass' do
 			
-			include Injectors
-
-			injector :tester
+			trait :tester
 
 			tester do
 				extend self																									# extend self
-																																		# Note: you cannot self enrich an injector
+																																		# Note: you cannot self enrich an trait
 				def order weight
-					lets manus =->(){"manus for #{weight}"}
-					manus[]
+					lets price =->(weight){ 10 * weight }
+					"price for #{weight} is #{price[weight]}"
 				end
 			end
-			tester.order(50).should == 'manus for 50'											# call method extended to self
+			tester.order(50).should == 'price for 50 is 500'							# call method extended to self
 
 
 			tester do
 				decorate :order do |num|																		# decorate the same method
-					self.to_s + super(num)
+					"#{self} says: " + super(num) + ' dollars'
 				end	
 			end
-			tester.order(50).should =~ /^|manus| for 50/ 				# call decorated method extended to self 
+			tester.order(50).should match(/^\(|tester|.+\) says: price for 50 is 500 dollars/) 				# call decorated method extended to self 
+			
+			# undecorate
+			
+			tester.undecorate :order
+			tester.order(30).should == 'price for 30 is 300'
+		end
+		
+	end
+
+	describe 'redecoration' do
+		
+		before do
+			class T
+				def bar
+					'bar '
+				end
+			end
+			class U
+				def bar
+					'bar'
+				end
+			end
+		end
+		
+		it 'allows decorating the same method multiple times' do
+
+			class T
+				decorate :bar do 																# <- GETS CLOBERED 
+					super() + 'none '
+				end
+			end
+			class T
+				decorate :bar do
+					super() + 'and then some'
+				end
+			end
+			expect{T.new.bar.should == 'bar and then some'}.to_not raise_error 
+
+		end			
+		
+		it 'also works on instances' do
+			
+			u = U.new
+			
+			u.decorate :bar do
+				'large ' + super()
+			end
+			
+			u.bar.should == 'large bar'
+			
+			u.decorate :bar do
+				'small ' + super()
+			end
+			
+			u.bar.should == 'small bar'
+			
+		end
+		
+
+	end
+	
+	describe 'undecoration' do
+		
+		the 'decoration can be rolled back' do
+
+			class F
+				def bar
+					'bar '
+				end
+			end
+			class F
+				decorate :bar do
+					super() + 'the unforseen'
+				end
+			end
+			F.new.bar.should == 'bar the unforseen'	
+			class F
+				undecorate :bar
+			end
+			F.new.bar.should == 'bar '		 
+
+		end
+
+		this 'roll-back works on singleton_class also' do
+
+			class G
+				class << self
+					def moo
+						'moooo'
+					end
+				end
+			end
+			class G
+				singleton_class.instance_eval do
+					decorate :moo do
+						super() + ' maaaa'
+					end
+				end
+			end
+			G.moo.should == 'moooo maaaa'
+			class G
+				singleton_class.instance_eval do
+					undecorate :moo
+				end
+			end
+			G.moo.should == 'moooo'
+
+		end			
+
+		it 'also works like so' do
+
+			Object.decorate :to_s do
+				super() + " is your object"
+			end
+			Object.new.to_s.should match(/is your object/)
+
+			# undecorate
+
+			Object.undecorate :to_s
+			Object.new.to_s.should_not match(/is your object/)
+
+		end
+		
+		it 'also works on object instances' do
+			
+			class Base
+				def foo
+					'foo'
+				end
+			end
+			
+			o = Base.new
+			o.decorate :foo do
+				super() + 'oof'
+			end
+			o.foo.should == 'foooof'
+
+			o.decorate :foo do
+				super() + 'foo'
+			end
+			o.foo.should == 'foofoo'
+			
+			# undecorate
+			
+			o.undecorate :foo
+			o.foo.should == 'foo'
 			
 		end
 		
@@ -312,6 +394,7 @@ describe Jackbox, 'jackbox library', :library do
 		end
 
 		it 'should not forbid the following' do
+			
 			# does work at the instance level
 			expect {
 				
@@ -319,7 +402,7 @@ describe Jackbox, 'jackbox library', :library do
 					lets(:foo){ 'foo bar'}
 				}
 				
-			}.to_not raise_error(Jackbox::UserError)
+			}.to_not raise_error
 			
 		end
 		
@@ -331,7 +414,7 @@ describe Jackbox, 'jackbox library', :library do
 			
 			expect{
 				make[:nothing]
-			}.to raise_error
+			}.to raise_error(TypeError)
 			
 		end
 	end
@@ -367,51 +450,51 @@ describe Jackbox, 'jackbox library', :library do
 			
 		end
 		
-		it 'allows passing instance variables' do
-			
-			STDOUT.should_receive(:puts).with('in One#foo with arg tester')
-			STDOUT.should_receive(:puts).with('in One#foo with arg mester')
-			STDOUT.should_receive(:puts).with('in One#foo with arg in Two#faa with arg me')
+		it 'allows the following' do
 			
-			class One
-				def foo(arg)
-					'in One#foo with arg ' + arg
+			a = Object.new
+			with a do
+				def m1
 				end
 			end
-			class Two
-				
-				def faa arg='nothing'
-					'in Two#faa with arg ' + arg
-				end
-
-				def fii
-					@tester = 'tester'
-					@mester = 'mester'
-				
-					with One.new, @tester, @mester do  |*args|
-						args.each { |e| puts foo e }
-						puts foo faa 'me'
-					end
+			b = Object.new 
+			with b do
+				def m1
 				end
-				
 			end
-			Two.new.fii
+			
+			with a, b do
+				m1
+			end
+			
 		end
 		
 		it 'raises an error if used with no block' do
+			
 			expect{with Object.new}.to raise_error(LocalJumpError)
+			
 		end
 		
 		it 'raises an error if used on self' do
 			expect{
 				
 				with self do
-					
+					# ...
 				end
 				
 			}.to raise_error(ArgumentError)
 		end
 		
+		describe "with and include" do
+			it "should raise error" do
+				expect{
+					with Object.new do
+						include Module.new
+					end
+				}.to raise_error(NoMethodError)
+			end
+		end
+
 		it 'works with decorate on an object multiple times' do
 			
 			class Object
@@ -431,7 +514,26 @@ describe Jackbox, 'jackbox library', :library do
 			end
 			o.foo.should == 'foo'
 			o.moo.should == 'moo'
+			
 		end	
+		
+		it 'works with method_missing' do
+			
+			o = Object.new
+			def o.method_missing sym, *args, &code
+				:mm
+			end
+			#existing mm
+			o.crap.should == :mm
+			
+			with o do
+				crap.should == :mm
+			end
+			
+			# still working
+			o.crap.should == :mm
+			
+		end
 	
 	end
 	
@@ -508,6 +610,14 @@ describe Jackbox, 'jackbox library', :library do
 			
 		end
 		
+		it 'is porous to warnings' do
+			
+			with Object.new do
+				warn 'test warning'  # it works (check standard output)
+			end
+			
+		end
+		
 	end