jackbox 0.9.6.2 → 0.9.6.3

data/spec/lib/jackbox/injector_spec.rb

@@ -380,7 +380,7 @@ describe Injectors, :injectors do
 				include Color
 			
 			end
-			Widget.injectors.sym_list.should == [:layout, :color]
+			Widget.injectors.sym_list.should == [:color, :layout]
 
 			expect{Widget.new.expand}.to_not raise_error
 			expect{Widget.new.tint}.to_not raise_error
@@ -418,7 +418,7 @@ describe Injectors, :injectors do
 			injector :vanilla 
 		
 			cup = Coffee.new.enrich(milk).enrich(vanilla)
-			cup.injectors.sym_list.should == [:milk, :vanilla]
+			cup.injectors.sym_list.should == [:vanilla, :milk]
 		
 		end
 
@@ -428,14 +428,14 @@ describe Injectors, :injectors do
 				inject injector :one
 				inject injector :two
 			end
-			SomeClass.injectors.sym_list.should == [:one, :two]
+			SomeClass.injectors.sym_list.should == [:two, :one]
 		
 		end
 		
 		the 'same is true at the class instance level' do
 			
 			# from above
-			SomeClassInstance.injectors.sym_list.should == [:class_instance_injector]
+			SomeClassInstance.injectors(:all).sym_list.should == [:class_instance_injector]
 			
 		end
 		
@@ -480,7 +480,7 @@ describe Injectors, :injectors do
 			end
 			
 			the 'functionality removed from a class INSTANCE
-			Note: when applied via the enrich keywork on the class' do
+			Note: when applied via the enrich keyword on the class' do
 
 				injector :part do
 					def connector
@@ -492,7 +492,7 @@ describe Injectors, :injectors do
 				Whole.extend part
 				
 				Whole.connector.should == 'connected'
-				Whole.injectors.sym_list.should == [:part]
+				Whole.injectors(:all).sym_list.should == [:part]
 				
 				# eject the part
 				
@@ -526,7 +526,7 @@ describe Injectors, :injectors do
 						end
 					end
 				end
-				Home.injectors.sym_list.should == [:layout, :materials ]
+				Home.injectors.sym_list.should == [:materials, :layout ]
 
 				# build
 				my_home = Home.new
@@ -602,7 +602,7 @@ describe Injectors, :injectors do
 				tester1.order(50).should match( /|tester1| label for 50/ )  # call decorated method extended to self 
 
 
-				$stdout.should_receive(:puts).with("|tester1| label for 30")
+				$stdout.should_receive(:puts).with( /|tester1| label for 30/ )
 				with tester1 do 																							# with self(tester1)
 					puts order 30																								# execute method
 					def receive weight																					# define singleton method
@@ -685,49 +685,49 @@ describe Injectors, :injectors do
 
 				the 'following class injection forms are all equivalent' do
 
-					injector :First do
+					injector :Base do
 						def meth
 							:meth
 						end
 					end
-					Injected.inject First()
+					Injected.inject Base()
 					Injected.new.meth.should == :meth  
 				
-					Injected.eject First()
+					Injected.eject Base()
 				end
 				the 'following class injection forms are all equivalent' do
 
-					Injected.inject First() do
+					Injected.inject Base() do
 						def meth
 							:meth
 						end
 					end
 					Injected.new.meth.should == :meth
 
-					Injected.eject First()
+					Injected.eject Base()
 				end 
 				the 'following class injection forms are all equivalent' do
 
-					injector( :First ){
+					injector( :Base ){
 						def meth
 							:meth
 						end
 					}
-					Injected.inject First()
+					Injected.inject Base()
 					Injected.new.meth.should == :meth
 
-					Injected.eject First()
+					Injected.eject Base()
 				end
 				the 'following class injection forms are all equivalent' do
 
-					Injected.inject injector( :First ){
+					Injected.inject injector( :Base ){
 						def meth
 							:meth
 						end
 					}
 					Injected.new.meth.should == :meth
 
-					Injected.eject First()
+					Injected.eject Base()
 				end
       end
 
@@ -735,49 +735,49 @@ describe Injectors, :injectors do
 				
 				the 'following instance enrichment forms are all equvalent' do
 
-					injector :second do
+					injector :base do
 						def meth
 							:meth
 						end
 					end
-					enrich second
+					enrich base
 					meth.should == :meth
 
-					eject second
+					eject base
 				end
 				the 'following instance enrichment forms are all equvalent' do
 
-					enrich injector :second do
+					enrich injector :base do
 						def meth
 							:meth
 						end
 					end
 					meth.should == :meth
 
-					eject second
+					eject base
 				end
 				the 'following instance enrichment forms are all equvalent' do
 
-					injector( :second ){
+					injector( :base ){
 						def meth
 							:meth
 						end
 					}
-					enrich second
+					enrich base
 					meth.should == :meth
 
-					eject second
+					eject base
 				end
 				the 'following instance enrichment forms are all equvalent' do
 
-					enrich injector( :second ){
+					enrich injector( :base ){
 						def meth
 							:meth
 						end
 					}
 					meth.should == :meth
 
-					eject second
+					eject base
 				end 
 				
 			end

data/spec/lib/jackbox/injector_versioning_spec.rb

@@ -320,6 +320,7 @@ describe 'Injector versioning:', :injectors do
 	    ###################################
 
 	    o.basic(1).should == 2                      # basic.1 
+			# debugger
 	    o.compound.should == 11                     # compound.1 --local injector binding
 
 	    ###################################

data/spec/lib/jackbox/patterns_spec.rb

@@ -1,4 +1,5 @@
 require "spec_helper"
+
 =begin rdoc
 	This file contains the specs for the GOF Decorator Pattern and 
 	Strategy Pattern use cases for injectors.
@@ -19,7 +20,8 @@ describe 'some use cases', :injectors do
 					1.50
 				end
 			end
-
+			
+			# debugger
 			injector :milk do
 				def cost
 					super() + 0.30
@@ -57,7 +59,7 @@ describe 'some use cases', :injectors do
 			end
 
 			cup = Coffee.new.enrich(milk).enrich(vanilla).enrich(vanilla)
-			cup.injectors.sym_list.should == [:milk, :vanilla, :vanilla]
+			cup.injectors.sym_list.should == [:vanilla, :vanilla, :milk]
 			cup.cost.should == 2.10
 			cup.should be_instance_of(Coffee)
 			
@@ -94,13 +96,13 @@ describe 'some use cases', :injectors do
 			end
 			
 			cup.enrich(vanilla)
-			cup.injectors.sym_list.should == [:milk, :vanilla, :vanilla]
+			cup.injectors.sym_list.should == [:vanilla, :vanilla, :milk]
 			cup.cost.should == 2.10
 			cup.appearance.should == 'extra red vanilla'
 			
 		end
 		
-		a 'bigger example' do
+		a 'bigger example using normal Injector inheritance' do
 		             
 			# some data
 
@@ -130,7 +132,7 @@ describe 'some use cases', :injectors do
 
 			DesktopDecorator = WidgetDecorator do
 				def render
-					dim '600px', '200px'
+					dim '600px', '200px'										# inherited
 					%{
 						<style>
 						#MyWidget{
@@ -146,7 +148,7 @@ describe 'some use cases', :injectors do
 
 			MobileDecorator = WidgetDecorator do
 				def render content
-					dim '200px', '600px'
+					dim '200px', '600px'										# inherited
 					%{
 						<style>
 						#MyWidget{
@@ -165,6 +167,8 @@ describe 'some use cases', :injectors do
 
 			browser = 'Safari'
 			@content = database_content
+			
+			# apply the decorators
 
 			my_widget = case browser
 			when match(/Safari|Firefox|IE/)
@@ -187,8 +191,144 @@ describe 'some use cases', :injectors do
 				}.split.join
 			)
 			 
+			WidgetDecorator(:implode)
+			
 		end
 
+		a 'different way of doing it using: JIT inheritance' do
+		             
+			# some data
+
+			def database_content
+				%{car truck airplane boat}
+			end 
+
+			# rendering helper controls
+
+			class MyWidgetClass
+				def initialize(content)
+					@content = content
+				end       
+
+				def render
+					"<div id='MyWidget'>#{@content}</div>"
+				end
+			end
+
+			
+			MainDecorator = injector :WidgetDecorator do
+				
+				attr_accessor :font, :width, :height       
+
+				def dim(width, heigth)
+					@width, @heigth = width, heigth
+				end
+				
+				def render
+					%{
+						<style>
+						#MyWidget{
+							font: 14px, #{@font};
+							width:#{@width};
+							height: #{@heigth}
+						}
+						</style>
+						#{super()}
+					}
+				end
+			end
+
+			# somewhere in a view
+
+			browser = 'Safari'
+			@content = database_content
+
+			my_widget = case browser
+			when match(/Safari|Firefox|IE/)
+				# debugger
+				MyWidgetClass.new(@content).enrich(WidgetDecorator() do
+					
+					def render															# override invoking JIT inheritance
+						dim '600px', '200px'									# normal inherited method call
+						@font = 'helvetica'
+
+						super()
+					end
+				end)
+
+			else
+				MyWidgetClass.new(@content).enrich(WidgetDecorator() do
+					
+					def render															# override invoking JIT inheritance
+						dim '200px', '600px'                  # normal inherited method call
+						@font ='arial'
+
+						super()
+					end
+				end)
+			end
+
+			expect(WidgetDecorator().ancestors).to eq([WidgetDecorator(), MainDecorator])
+
+			expect(                      
+				my_widget.render.split.join).to  eq(		# split.join used for comparison
+					%{  
+						<style>
+						#MyWidget {
+							font: 14px, helvetica; 
+							width:600px; 
+							height:200px 
+						}
+						</style>
+						<div id='MyWidget'>car truck airplane boat</div>
+					}.split.join
+			)
+
+			
+			# browser = 'mobile'
+			# @content = database_content
+			# 
+			# my_widget = case browser
+			# when match(/Safari|Firefox|IE/)
+			# 	# debugger
+			# 	MyWidgetClass.new(@content).enrich(WidgetDecorator() do
+			# 		
+			# 		def render
+			# 			dim '600px', '200px'
+			# 			@font ='helvetica'
+			# 
+			# 			super()
+			# 		end
+			# 	end)
+			# else
+			# 	MyWidgetClass.new(@content).enrich(WidgetDecorator() do
+			# 		def render
+			# 			dim '200px', '600px'
+			# 			@font ='arial'
+			# 
+			# 			super()
+			# 		end
+			# 	end)
+			# end
+			# expect(                      
+			# 
+			# 	my_widget.render.split.join).to  eq(		# split.join used for comparison
+			# 		%{  
+			# 			<style>
+			# 			#MyWidget {
+			# 				font: 14px, arial; 
+			# 				width:200px; 
+			# 				height:600px 
+			# 			}
+			# 			</style>
+			# 			<div id='MyWidget'>car truck airplane boat</div>
+			# 		}.split.join
+			# )
+			
+			WidgetDecorator(:implode)
+			 
+		end
+		
 	end
 	
 	describe 'strategy pattern.' do
@@ -396,15 +536,7 @@ describe 'some use cases', :injectors do
 			Client.solve
 			
 		end
-		
 	end
 	
-	# describe 'use in rails' do
-	# 	
-	# 	it 'allows replacing draper'
-	# 	it 'allows decorating anything not just models'
-	# 	
-	# end 
-
 end
 

data/spec/lib/jackbox/reclassing_spec.rb

@@ -1,14 +1,153 @@
 require "spec_helper"
 =begin rdoc
-	This file represents a new approach to refining a class using Jackbox modular closures.
+
+	This file represents a different approach to refining a class using Jackbox Modular Closures.
 	
 	lha
+
 =end
 
+
 # Jackbox Reclassings
 ############################################
 
 # RubyProf.start
+describe 're-classings' do
+
+	it 'refines classes within namespaces' do
+		
+		module Work
+			lets String do
+				def self.new(*args)
+					"+++#{super}+++"
+				end
+			end
+		end
+		
+		class WorkAholic
+			include Work
+			
+			def work_method
+				String('Men-At-Work')
+			end
+		end
+	
+		str = WorkAholic.new.work_method
+		str.should == '+++Men-At-Work+++'
+		
+		str = String('Men-At-Work')										# Regular Kernel version
+		str = 'Men-At-Work'
+		
+	end
+	
+	it 'works with Ruby Code Injectors' do
+		#
+		# Our first Injector
+		#
+		Sr1 = jack :StringRefinements do
+			lets String do
+				def self.new *args, &code
+					super(*args, &code) + ' is a special string'
+				end
+			end
+		end
+
+		class OurClass
+			include Sr1																	# include Tag
+
+			def foo_bar
+				String('foo and bar')
+			end
+		end
+
+		c = OurClass.new
+		
+		c.foo_bar.class.should == String
+		c.foo_bar.should == 'foo and bar is a special string'
+		expect{c.foo_bar.extra.should == :extra}.to raise_error(NoMethodError)
+
+		#
+		# A second injector in the mix
+		#
+		jack :Log do
+			require 'logger'
+			def to_log arg
+				(@log ||= Logger.new($stdout)).warn(arg)
+			end
+		end
+		
+		StringRefinements do
+			String() do
+				inject Log()
+				
+				def show
+					to_log self
+				end
+			end
+		end
+
+		c.foo_bar.class.should == String
+		c.foo_bar.should == 'foo and bar is a special string'
+		
+		$stdout.should_receive(:write).with(/foo and bar is a special string/).at_least(1) 
+
+		c.foo_bar.show
+
+		# 
+		# lets redfine our first String() 
+		# -- SR1 and SR2 are different injectable String()
+		# 
+		Sr2 = StringRefinements do 										# New String refinement
+			lets String do
+				inject Log()
+				
+				def self.new *args
+					super + '****'
+				end
+			end
+		end
+		
+		class OurOtherClass
+			include Sr2																# Apply new tag
+
+			def foo_bar
+				String('foo and bar')
+			end
+		end
+		
+		d = OurOtherClass.new
+		
+		d.foo_bar.class.should == String
+		d.foo_bar.should == 'foo and bar****'
+
+		expect{ d.foo_bar.show }.to raise_error(NoMethodError)
+		$stdout.should_receive(:write).with(/foo/).at_least(1) 
+		expect{ d.foo_bar.to_log 'foo' }.to_not raise_error
+		
+		# c is still the same
+		
+		c.foo_bar.class.should == String
+		c.foo_bar.should == 'foo and bar is a special string'
+		
+
+		# String is untouched
+		
+		String("foo").should == 'foo'
+		String.new("foo").should == 'foo'
+			
+	end
+end
+
+
+# ################################# IMPORTANT ########################################
+# 																																									 #
+# Although the above is for what reclassings are designed, in the following exmaples #
+# we test some of the more basic and ruby integration aspects of re-classings.       #
+# Note: reclassings used on a top level will hide any Kernel methods by the same     #
+# type name.  Their use case is like the above or in some name space.  See below.    #
+#                                                                                    #
+# ################################# IMPORTANT ########################################
+
 
 injector :StringExtensions do  										# define injector
   def to_s
@@ -16,8 +155,9 @@ injector :StringExtensions do  										# define injector
 	end
 end
 
-# debugger
-lets String do 																		# apply to class
+# Note: This reclassing hides Kernel.String() -- use
+# fully qualified name to access original version
+lets String do 																		# apply injector
 	include StringExtensions()
 end
 
@@ -35,7 +175,8 @@ describe :String do
 end
 
               
-# Another Reclassing
+# Another Top-level Reclassing
+# Note: same as above
 
 jack :ArrayExtensions do
 	def to_s
@@ -122,6 +263,7 @@ module M7
 	def foo_bar
 		Array(2)
 	end
+	
 end 
 
 class A6
@@ -142,9 +284,9 @@ end
 
 
 
-# Further Introspection
+# Introspection
 ##################################################
-# debugger
+
 assert( A6.new.foo_bar.injectors.by_name == [:NameSpacedArrayExtensions] )
 
 describe "introspection" do
@@ -152,11 +294,23 @@ describe "introspection" do
 	# introspecting on capabilities
 
 	it 'should allow injector introspection' do
-		# # top level re-class
+		
+		StringRefinements do
+			(reclass? String).should == true
+			
+			String() do
+				injectors.by_name.should == [:Log]
+			end
+		end
+		
+	end
+	
+	it 'should allow injector introspection' do
+		# top level re-class
 		Array() do
 			injectors.by_name.should == [:ArrayExtensions]
 		end
-		# debugger
+
 		Array(){injectors.by_name}.should == [:ArrayExtensions]
 		
 		# top level re-class instances
@@ -165,11 +319,13 @@ describe "introspection" do
 	end
 	
 	it 'works on namespaced reclassings' do
+		
 		module M7
-			# debugger
+
 			Array() do
 				injectors.by_name.should == [:NameSpacedArrayExtensions]
 			end
+			
 		end
 	end
 	
@@ -192,75 +348,6 @@ describe "introspection" do
 		
 	end
 	
-	it 'works' do
-		
-		# Injector declaration
-
-		jack :StringRefinements do
-			lets String do
-				with singleton_class do
-					alias _new new
-					def new *args, &code
-						super(*args, &code) + ' is a special string'
-					end
-				end
-			end
-		end
-
-		class OurClass
-			include StringRefinements()
-
-			def foo_bar
-				String('foo and bar')
-			end
-		end
-
-		c = OurClass.new
-		c.foo_bar.class.should == String
-		c.foo_bar.should == 'foo and bar is a special string'
-		expect{c.foo_bar.extra.should == :extra}.to raise_error(NoMethodError)
-
-		StringRefinements do
-			String() do
-				def extra
-					:extra
-				end
-			end
-		end
-
-		c.foo_bar.should == 'foo and bar is a special string'
-		c.foo_bar.class.should == String
-		c.foo_bar.extra.should == :extra
-
-		SR = StringRefinements do 										# New Version
-			lets String do
-				def to_s
-					super + '****'
-				end
-			end
-		end
-
-		# c is still the same
-
-		c.foo_bar.should == 'foo and bar is a special string'
-		c.foo_bar.class.should == String
-		c.foo_bar.extra.should == :extra
-
-
-		class OurOtherClass
-			include SR																# Apply new version
-			# to another class
-			def foo_bar
-				String('foo and bar')
-			end
-		end
-
-		d = OurOtherClass.new
-		d.foo_bar.should == 'foo and bar'
-		d.foo_bar.to_s.should == 'foo and bar****'
-		expect{ d.extra }.to raise_error(NoMethodError)
-			
-	end
 end