jackbox 0.9.6.2

data/spec/lib/jackbox/injector_versioning_spec.rb

@@ -0,0 +1,334 @@
+require "spec_helper"
+
+include Injectors
+
+describe 'Injector versioning:', :injectors do
+# subsequent redefinitions of methods constitute another version of the injector.  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 
+# 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
+	
+		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
+		# may contain internal references to newer versions of the target methods. This ensures to keep everyting working correctly.'
+		
+			#___________________
+			# injector declaration
+			injector :My_injector
+
+	    #___________________
+	    # injector first prolongation
+	    My_injector do 															
+	      def bar
+	        :a_bar                                  # version bar.1
+	      end
+	      def foo
+	      	# ...
+	      end
+	    end
+	
+			object1 = Object.new
+	    object1.enrich My_injector()                # apply the injector --first snapshot
+	    object1.bar.should == :a_bar                # pass the test
+
+	    #__________________
+	    # injector second prolongation
+	    My_injector do 																			
+	      def bar
+	        :some_larger_bar                        # version bar.2 ... re-defines bar
+	      end
+	      def some_other_function
+	      # ...
+	      end
+	    end
+    
+			object2 = Object.new
+	    object2.enrich My_injector()                # apply the injector --second snapshot
+	    object2.bar.should == :some_larger_bar
+
+	    # result
+	    ###########
+    
+	    object1.bar.should == :a_bar                # bar.1 is still the one
+
+	    ###########################################
+	    # The object has kept its preferred version
+		
+		end
+	
+		the 're-injection changes ("updates if you will") versions of methods in use' do
+			
+			#_________________
+			# re-injection
+			enrich My_injector()																	# 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
+		
+		end
+		
+		a 'different example with an explicit self' do
+			
+			o = Object.new
+			
+			injector :some_methods do
+				def meth arg
+					arg
+				end
+			end
+			
+			o.enrich some_methods
+			o.meth('cha cha').should == 'cha cha'
+			
+			some_methods do
+				def meth arg
+					arg * 2
+				end
+			end
+			
+			o.meth('cha cha').should == 'cha cha'
+			
+			oo = Object.new.enrich(some_methods)
+			oo.meth('cha cha').should == 'cha cha'+'cha cha'
+
+			o.meth('cha cha').should == 'cha cha'
+			
+		end
+
+	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 
+	# 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
+			
+			#___________________
+			# injector declaration:
+			injector :Versions 
+
+	    #___________________
+	    # injector first prolongation
+	    Version1 = Versions do
+	      def meth arg                              # version meth.1
+	        arg ** arg
+	      end
+	    end
+
+	    class One
+	      inject Version1                           # apply --first snapshot
+	    end
+
+	    #_________________
+	    # injector second prolongation                              
+	    Version2 = Versions do
+	      def meth arg1, arg2                       # version meth.2 ... redefines meth.1
+	        arg1 * arg2
+	      end
+	    end
+
+	    class Two
+	      inject Version2                           # apply --second snapshot
+	    end
+
+
+	    # result
+	    #############################
+	    Two.new.meth(2,4).should == 8               # meth.2 
+	                                                            # two different injector versions
+	    One.new.meth(3).should == 27                # meth.1
+	    #############################
+	    #
+			
+		end
+		
+		# we can update individual object instances but not classes directly
+		# this is unavailable because class injection is pervasive
+		the 'simple re-injection is different for classes: it fails ' do
+			
+			# re-injection can happen on individual object instances
+			One.new.enrich(Version2).meth(4,5).should == 20			# meth.2 works!!
+			
+			# re-injection applying version 2 to class One has no effect
+			One.inject Version2 												
+			expect{ One.new.meth(4,5) }.to raise_error(ArgumentError) 					# meth.2: fails!! 
+			
+		end
+		
+		the 'way to class level injector updates is through the Strategy Pattern' do
+					 
+			# DO NOT want to necessarily update older clients of the class
+			# but possible if needed
+
+			class One
+				eject Version1													# eject version 1
+			
+				inject Version2													# re-inject with prolonged injector -- can be any version
+			end
+			One.new.meth(4,5).should == 20							# meth.2 now available!!
+			
+			################################################
+			# We feel this is the correct approach but has #
+			# a sllight syntactical handicap/ambiguity     #
+			################################################
+			
+		end
+		
+		a 'preferred way as of late: private updates --could change' do
+			
+			Versions do
+				def meth(*args)
+					args.inject(&:+)
+				end
+			end
+			
+			class One
+				update Versions()													# changes strategy for you
+																									# by design a private method as sign of its delicate nature 
+			end
+			
+			# or ....
+			
+			One.send :update, Versions()
+			One.new.meth( 3,4,5,6 ).should == 18				# new version now available!
+			
+		end
+		
+		a 'different use case' do
+			
+			class Freak
+				
+				injector :freaky
+				freaky do
+					def twitch
+						'_-=-_-=-_-=-_-=-_'
+					end
+				end
+				inject freaky
+				
+			end
+			Freak.new.twitch.should == '_-=-_-=-_-=-_-=-_'
+			
+			class Freak
+				
+				freaky do
+					def twitch
+						'/\/\/\/\/\/\/\/\/\/'
+					end
+				end
+				update freaky
+				
+			end
+			Freak.new.twitch.should == '/\/\/\/\/\/\/\/\/\/'
+		
+		end
+
+		there 'is a different way todo global updates on Injectors: use define_method' do
+
+			SomeJack = jack :some_jack do
+				def foo_bar
+					'a foo and a bar'
+				end
+			end
+
+			class Client
+				inject SomeJack
+			end
+
+			Client.new.foo_bar.should == 'a foo and a bar'			# expected
+
+			some_jack do
+				define_method :foo_bar do
+					'fooooo and barrrrr'
+				end
+			end
+
+			Client.new.foo_bar.should == 'fooooo and barrrrr'		# different
+
+		end
+	end
+
+	describe "utility of injector versioning: " do
+		
+		it 'allows to easily override methods without affecting other parts of your program' do
+			
+			J1 = injector :j do
+				def meth(arg)
+					arg
+				end
+			end
+			
+			class AA4
+				inject J1
+			end
+			AA4.new.meth(3).should == 3
+			
+			J2 = j do
+				def meth(arg)
+					arg *arg
+				end
+			end
+			
+			class BBB
+				inject J2
+			end
+			BBB.new.meth(3).should == 9
+			
+			AA4.new.meth(3).should == 3
+			
+		end
+		
+		the "local binding of injectors" do
+
+	    #_____________________
+	    # injector declaration
+	    VersionOne = injector :functionality do
+	      def basic arg                             # version basic.1
+	        arg * 2
+	      end
+	    end
+
+	    o = Object.new.enrich VersionOne						# apply --first snapshot
+	    o.basic(1).should == 2                      # basic.1 
+
+
+	    #_____________________
+	    # injector prolongation
+	    VersionTwo = functionality do
+	      def basic arg                             # basic.2 ... basic.1 redefined
+	        arg * 3
+	      end
+
+	      def compound                              # compound.1 --bound locally to basic.2
+	        basic(3) + 2                                      
+	      end
+	    end                                         
+
+	    p = Object.new.enrich VersionTwo            # apply --second snapshot (like above)
+	    p.basic(1).should == 3                      # basic.2 
+	    p.compound.should == 11                     # compound.1 
+
+
+	    # result
+	    ###################################
+
+	    o.basic(1).should == 2                      # basic.1 
+	    o.compound.should == 11                     # compound.1 --local injector binding
+
+	    ###################################
+	    # This ensures #compound.1 keeps bound
+	    # to the right version #basic.2
+
+		end
+
+	end
+end
+
+

data/spec/lib/jackbox/patterns_spec.rb

@@ -0,0 +1,410 @@
+require "spec_helper"
+=begin rdoc
+	This file contains the specs for the GOF Decorator Pattern and 
+	Strategy Pattern use cases for injectors.
+=end
+
+include Injectors
+
+describe 'some use cases', :injectors do 
+
+	describe 'GOF Decortors is one use of this codebase. Traditionally this is only partially solved in Ruby through PORO 
+	decorators or the use of modules with the problems of loss of class identity for the former 
+	or the limitations on the times it can be re-applied for the latter. We solve that!!' do 
+	
+		the 'GOF class decorator' do
+
+			class Coffee
+				def cost
+					1.50
+				end
+			end
+
+			injector :milk do
+				def cost
+					super() + 0.30
+				end
+			end
+			injector :vanilla do
+				def cost
+					super() + 0.15
+				end
+			end
+
+			cup = Coffee.new.enrich(milk).enrich(vanilla)
+			cup.should be_instance_of(Coffee)
+			cup.cost.should == 1.95
+			
+		end
+
+		this 'can then be applied multiple times to the same receiver:' do
+			
+			class Coffee
+				def cost
+					1.50
+				end
+			end
+			
+			jack :milk do
+				def cost
+					super() + 0.30
+				end
+			end
+			jack :vanilla do
+				def cost
+					super() + 0.15
+				end
+			end
+
+			cup = Coffee.new.enrich(milk).enrich(vanilla).enrich(vanilla)
+			cup.injectors.sym_list.should == [:milk, :vanilla, :vanilla]
+			cup.cost.should == 2.10
+			cup.should be_instance_of(Coffee)
+			
+		end
+		
+		the 'a further workflow' do
+
+			class Coffee
+				def cost
+					1.50
+				end
+			end
+
+			jack :milk do
+				def cost
+					super() + 0.30
+				end
+			end
+			jack :vanilla do
+				def cost
+					super() + 0.15
+				end
+			end
+
+			cup = Coffee.new.enrich(milk).enrich(vanilla)
+			cup.should be_instance_of(Coffee)
+			cup.cost.should == 1.95
+			
+			user_input = 'extra red vanilla'
+			vanilla do
+				define_method :appearance do
+					user_input
+				end
+			end
+			
+			cup.enrich(vanilla)
+			cup.injectors.sym_list.should == [:milk, :vanilla, :vanilla]
+			cup.cost.should == 2.10
+			cup.appearance.should == 'extra red vanilla'
+			
+		end
+		
+		a 'bigger example' 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
+
+			injector :WidgetDecorator do
+				attr_reader :width, :height       
+
+				def dim(width, heigth)
+					@width, @heigth = width, heigth
+				end
+			end
+
+			DesktopDecorator = WidgetDecorator do
+				def render
+					dim '600px', '200px'
+					%{
+						<style>
+						#MyWidget{
+							font: 14px, helvetica;
+							width:#{@width};
+							height: #{@heigth}
+						}
+						</style>
+						#{super()}
+					}
+				end
+			end
+
+			MobileDecorator = WidgetDecorator do
+				def render content
+					dim '200px', '600px'
+					%{
+						<style>
+						#MyWidget{
+							font: 10px, arial
+							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/)
+				MyWidgetClass.new(@content).enrich(DesktopDecorator)
+			else
+				MyWidgetClass.new(@content).enrich(MobileDecorator)
+			end
+			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
+			)
+			 
+		end
+
+	end
+	
+	describe 'strategy pattern.' do
+
+		this 'is a pattern with changes the guts of an object as opposed to just changing its face. Traditional 
+		examples of this pattern use PORO component injection within constructors. Here is an alternate 
+		implementation' do
+			
+			class Coffee
+
+				attr_reader :strategy
+				def initialize
+				  @strategy = nil
+				end
+				def cost
+					1.50
+				end
+			  def brew
+					@strategy = 'normal-'
+			  end
+			end
+
+			injector :Sweedish do
+				def brew
+					@strategy = 'sweedish-'
+				end
+			end
+			injector :French do
+				def brew
+					@strategy ='french-'
+				end
+			end
+
+			cup = Coffee.new
+			cup.brew
+			cup.strategy.should == 'normal-'
+			
+			cup = Coffee.new.enrich(Sweedish())  # clobbers original strategy for this instance only
+			cup.brew
+			cup.strategy.should == ('sweedish-')
+		
+			cup.enrich(French())
+			cup.brew
+			cup.strategy.should == ('french-')
+		end
+		
+		this 'can be further enhanced by mixing it with the above decorator pattern' do
+
+			injector :Russian do
+				def brew
+					@strategy = super.to_s + 'vodka-'
+				end
+			end
+			injector :Scotish do
+				def brew
+					@strategy = super.to_s + 'wiskey-'
+				end
+			end
+			
+			cup = Coffee.new
+			cup.enrich(Russian()).enrich(Scotish()).enrich(Russian())
+			cup.brew
+			cup.strategy.should == 'normal-vodka-wiskey-vodka-'
+			
+		end
+		
+		it 'is even better or possible to have yet another implementation. This time we completely
+		replace the current strategy by actually ejecting it out of the class and then injecting
+		a new one' do
+			
+			class Tea < Coffee  # Tea is a type of coffee ;~Q)
+				injector :SpecialStrategy do
+					def brew
+						@strategy = 'special'
+					end
+				end
+				inject SpecialStrategy()
+			end
+			
+			cup = Tea.new
+			cup.brew
+			cup.strategy.should == 'special'
+			friends_cup = Tea.new
+			friends_cup.strategy == 'special'
+			
+			Tea.eject :SpecialStrategy
+			
+			Tea.inject Sweedish()
+			cup.brew
+			friends_cup.brew
+			cup.strategy.should == 'sweedish-'
+			friends_cup.strategy.should == 'sweedish-'
+			
+			Tea.eject Sweedish()
+			
+			Tea.inject French()
+			cup.brew
+			friends_cup.brew
+			cup.strategy == 'french-'
+			friends_cup.strategy.should == 'french-'
+			
+		end
+		
+	end
+
+	describe "further Jackbox Injector workflows" do
+		
+		it "allows adding decorators with function to be defined at later statge" do
+			
+			class Widget
+				def cost
+					1
+				end
+			end
+			w = Widget.new
+			
+			injector :decorator
+			w.enrich decorator, decorator, decorator, decorator
+			
+			# user input
+			bid = 3.5 
+
+			# define function
+			decorator do
+				# Global define
+				define_method :cost do
+					super() + bid
+				end
+			end
+			
+			w.cost.should == 15
+			
+		end
+		
+ 		it "allows for the following workflow using super" do
+
+			jack :Superb
+
+			Superb do
+				def process string, additives, index
+					str = string.gsub('o', additives.slice!(index))
+					super(string, additives, index) + str rescue str
+				end
+				extend Superb(), Superb(), Superb()
+			end   
+
+			Superb().process( 'food ', 'aeiu', 0 ).should == 'fuud fiid feed faad '
+			Superb(:implode)
+
+		end
+
+		it 'allows for the following strategy workflow using soft tags' do  
+
+			###########################################################################
+			# For a specific example of what can be accomplished using this workflow  #
+			# please refer to the examples directory under transformers spec          #
+			#                                                                         #
+			# #########################################################################
+			
+			jack :Solution
+
+			Solution( :tag ) do
+				def solution
+					1
+				end
+			end
+			Solution( :tag ) do
+				def solution
+					2
+				end
+			end
+			Solution( :tag ) do
+				def solution
+					3
+				end
+			end
+			
+
+			class Client
+				inject Solution()
+				
+				def self.solve
+					Solution().tags.each { |e|
+						update e 
+						puts new.solution rescue nil
+					}                              
+					
+					# or...
+					
+					solutions = Solution().tags.each
+					begin
+						update solutions.next
+						puts solved = new().solution()
+					end until solved
+					solved
+				end
+				
+			end
+
+			$stdout.should_receive(:puts).with(1)
+			$stdout.should_receive(:puts).with(2)
+			$stdout.should_receive(:puts).with(3)
+			$stdout.should_receive(:puts).with(1)
+			
+			Client.solve
+			
+		end
+		
+	end
+	
+	# describe 'use in rails' do
+	# 	
+	# 	it 'allows replacing draper'
+	# 	it 'allows decorating anything not just models'
+	# 	
+	# end 
+
+end
+