jackbox 0.9.6.3 → 0.9.6.6

data/spec/lib/jackbox/prefs_spec.rb

@@ -172,14 +172,14 @@ describe 'what Prefs does' do
 	end
 
 	it 'should also allow classes to be used' do
-		class C
+		class PrefC
 			extend Prefs
 
 			pref :boo => "something"
 		end
-	  C.boo.should == 'something'
-		lambda{C.boo=(3)}.should_not raise_error
-		lambda{C.new.boo}.should raise_error(NoMethodError)
+	  PrefC.boo.should == 'something'
+		lambda{PrefC.boo=(3)}.should_not raise_error
+		lambda{PrefC.new.boo}.should raise_error(NoMethodError)
 	end
 
 	it 'should be possible to reset the prefs to their defaults' do

data/spec/lib/jackbox/reclassing_spec.rb

@@ -3,16 +3,15 @@ require "spec_helper"
 
 	This file represents a different approach to refining a class using Jackbox Modular Closures.
 	
+	The examples are necessarily long because we are testing lifecycle changes for these construct.
+	If we were to have simple unit testing we could have false positives form some of these tests.
+	
 	lha
 
 =end
 
-
-# Jackbox Reclassings
-############################################
-
 # RubyProf.start
-describe 're-classings' do
+describe 're-classes' do
 
 	it 'refines classes within namespaces' do
 		
@@ -38,444 +37,193 @@ describe 're-classings' do
 		str = String('Men-At-Work')										# Regular Kernel version
 		str = 'Men-At-Work'
 		
+		str = String.new('Men-At-Work')								# Regular class 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'
+	describe "interaction with Ruby Code Injector" do
+		before do
+			#
+			# Our first Injector
+			#
+			Sr1 = jack :StringRefinements do
+				lets String do
+					def self.new *args, &code
+						super + ' is a special string'
+					end
 				end
 			end
-		end
-
-		class OurClass
-			include Sr1																	# include Tag
 
-			def foo_bar
-				String('foo and bar')
+			#
+			# A second trait in the mix
+			#
+			jack :Log do
+				require 'logger'
+				def to_log arg
+					(@log ||= Logger.new($stdout)).warn(arg)
+				end
 			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)
+			#
+			# refine our re-class
+			StringRefinements do
+				String() do 											# add function to same String() reclass
+					inject Log()
+					
+					def glow
+						to_log self
+					end
+					def foo
+					end
+				end
+			end
 
-		#
-		# A second injector in the mix
-		#
-		jack :Log do
-			require 'logger'
-			def to_log arg
-				(@log ||= Logger.new($stdout)).warn(arg)
+			# 
+			# 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, &code
+						'--' + super + '--'
+					end
+					def glow
+						to_log self
+					end
+				end
 			end
-		end
-		
-		StringRefinements do
-			String() do
-				inject Log()
-				
-				def show
-					to_log self
+			
+			#
+			# refine our re-class
+			StringRefinements do
+				String() do 											# add function to same String() reclass
+					# inject Log()
+					# 				
+					# def glow
+					# 	to_log self
+					# end
+					def foo
+					end
 				end
 			end
+			
+		end
+		after do
+			StringRefinements(:implode)
 		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
+		it 'works with Ruby Code Injectors' do
 
-		# 
-		# 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 + '****'
+			
+			class OurClass
+				include Sr1												# Apply Tag
+			
+				def foo_bar
+					String('foo and bar')
 				end
 			end
-		end
-		
-		class OurOtherClass
-			include Sr2																# Apply new tag
+			
+			c = OurClass.new
+					
+			# test it with our object
+			c.foo_bar.should == 'foo and bar is a special string'
+			c.foo_bar.class.should == String
+			
+			# test stdout
+			$stdout.should_receive(:write).with(/foo and bar is a special string/).at_least(1) 
+			c.foo_bar.glow
 
-			def foo_bar
-				String('foo and bar')
+
+			class OurOtherClass
+				include Sr2											# Apply other tag
+			
+				def foo_bar
+					String('foo and bar')
+				end
 			end
+					
+			d = OurOtherClass.new
+					
+			# test it with our object
+			d.foo_bar.should == '--foo and bar--'
+			d.foo_bar.class.should == String
+			
+			# test stdout
+			$stdout.should_receive(:write).with(/foo and bar--/).at_least(1) 
+			d.foo_bar.glow
+					
+			#
+			# c is still the same
+			#
+			c.foo_bar.should == 'foo and bar is a special string'
+			c.foo_bar.class.should == String
+					
+			#
+			# String is untouched
+			#
+			String("foo").should == 'foo'
+			String.new("foo").should == 'foo'
+			
 		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
+		# introspecting on capabilities
 		
-		String("foo").should == 'foo'
-		String.new("foo").should == 'foo'
-			
-	end
-end
-
+		it 'should allow trait introspection' do
 
-# ################################# 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 ########################################
+			StringRefinements do
+				(reclass? String).should == true
 
-
-injector :StringExtensions do  										# define injector
-  def to_s
-		super + '++++'
-	end
-end
-
-# Note: This reclassing hides Kernel.String() -- use
-# fully qualified name to access original version
-lets String do 																		# apply injector
-	include StringExtensions()
-end
-
-assert( String('boo').to_s == 'boo++++' )	
-assert( String("").class == String )
-
-describe :String do
-	it 'should pass' do
-		String('boo').to_s.should == 'boo++++'
-	end
-	# introspecting on Type
-	it 'should be class String' do
-		String('boo').class.should be(String)
-	end 
-end
-
-              
-# Another Top-level Reclassing
-# Note: same as above
-
-jack :ArrayExtensions do
-	def to_s
-		super + '####'
-	end
-end
-
-lets Array do
-	inject ArrayExtensions()
-end
-
-assert(Array(3).to_s == "[nil, nil, nil]####")
-assert(Array(3).class == Array)
-
-describe :Array do
-	it 'allows the following' do
-  	Array(3).to_s.should == "[nil, nil, nil]####"
-	end
-	# introspecting on Type
-	it 'should be Array' do
-		Array(3).class.should be(Array)
-	end
-end
-
-# ORIGINAL CLASSES REMAIN UNTOUCHED!!!
-##################################################
-assert( String.new.to_s == '' )                  #
-assert( Array.new(3).to_s == '[nil, nil, nil]' ) #
-                                                 #
-describe String do                               #
-	it 'should remain untouched' do                #
-		String.new('bar').should == 'bar'            #
-	end                                            #
-end                                              #
-                                                 #
-describe Array do                                #
-	it 'should remain untouched' do                #
-		Array.new(3).should == [nil, nil, nil]       #
-	end                                            #
-end                                              #
-##################################################                  
-# ORIGINAL CLASSES REMAIN UNTOUCHED!!!           
-
-# ORIGINAL KERNEL METHODS REMAIN UNTOUCHED!!!
-##################################################
-assert( Kernel.String(123) == '123' )            #
-assert( Kernel.Array(3) == [3])                  #
-                                                 #
-describe :'Kernel.String' do                     #
-	it 'should reamain untouched' do               #
-		Kernel.String(123).should == '123'           #
-	end                                            #
-end                                              #
-                                                 #
-describe :'Kernel.Array' do                      #
-	it 'should reamain untouched' do               #
-		Kernel.Array([1,2,3]).should == [1,2,3]      #
-	end                                            #
-end                                              #
-##################################################                  
-# ORIGINAL KERNEL METHODS REMAIN UNTOUCHED!!!
-
-
-
-
-
-# Namespaced Reclassings
-##################################################
-
-jack :NameSpacedArrayExtensions do
-	def to_s 
-		super + '!!!!'
-	end
-end
-
-module M7
-	
-	# Internal reclassing 
-
-	lets Array do
-		inject NameSpacedArrayExtensions()
-	end
-	
-	def foo_bar
-		Array(2)
-	end
-	
-end 
-
-class A6
-	include M7
-end
-
-
-describe "Internal Array()" do
-	it 'should pass' do
-		A6.new.foo_bar.to_s.should == '[nil, nil]!!!!'
-	end
-	# introspecting on Type
-	it 'should be an Array' do
-		A6.new.foo_bar.class.should be(Array)
-	end
-end
-
-
-
-
-# Introspection
-##################################################
-
-assert( A6.new.foo_bar.injectors.by_name == [:NameSpacedArrayExtensions] )
-
-describe "introspection" do
-	
-	# introspecting on capabilities
-
-	it 'should allow injector introspection' do
-		
-		StringRefinements do
-			(reclass? String).should == true
-			
-			String() do
-				injectors.by_name.should == [:Log]
+				if reclass? String
+					String() do
+						traits.by_name.should == [:Log]
+					end
+				else
+					lets String do
+						#...
+					end
+				end
 			end
-		end
 		
-	end
-	
-	it 'should allow injector introspection' do
-		# top level re-class
-		Array() do
-			injectors.by_name.should == [:ArrayExtensions]
-		end
-
-		Array(){injectors.by_name}.should == [:ArrayExtensions]
+			class SRClass
+				inject StringRefinements()
 		
-		# top level re-class instances
-		Array(1).injectors.by_name == [:ArrayExtensions]
+				def m1
+					String('m1')
+				end
+			end
 		
-	end
-	
-	it 'works on namespaced reclassings' do
+			SRClass.new.m1.should == '--m1--'
 		
-		module M7
+		end
 
-			Array() do
-				injectors.by_name.should == [:NameSpacedArrayExtensions]
+		it 'should allow trait introspection' do
+			
+			lets Array do
+				inject jack :ArrayExtensions do
+					def to_s
+						super + '--boo'
+					end
+				end
 			end
 			
-		end
-	end
-	
-	it 'can test the existence of a re-classing' do
-
-		reclass?(String).should == true
-		reclass?(Array).should == true
-		
-		module M7 
-			reclass? Array
-		end.should == true
+			# re-class
+			Array() do
+				traits.by_name.should == [:ArrayExtensions]
+			end
 		
-		module M8 
-			reclass? Array
-		end.should == false
+			Array(){traits.by_name}.should == [:ArrayExtensions]
 		
-		module M9
-			reclass? String
-		end.should == false
+			# re-class instances
+			Array(1).traits.by_name == [:ArrayExtensions]
+			
+			Array(2).to_s.should == '[nil, nil]--boo'
 		
-	end
-	
-end
-
-
-
-
-
-# Calls deeper down the hierarchy
-##################################################
-
-module M5
-	def self.foo 
-		String('foo').to_s
-	end
-end
-
-assert( M5.foo == 'foo++++' )
-
-describe M5 do
-	it 'works' do
-		M5.foo.should == 'foo++++'          
-	end
-	it 'should be String' do
-		M5.foo.class.should be(String)
-	end
-end
-
-# even deeper
-
-class A5
-	module M6
-		def meth arg
-			String(arg).to_s
 		end
-	end
-	include M6
-end
-
-assert(A5.new.meth("meth")== 'meth++++')
-
-describe A5 do
-	it "shold pass" do
-		A5.new.meth("meth").should == 'meth++++'
-	end
-	# introspecting on Type
-	it 'should be a String' do
-		A5.new.meth("meth").class.should be(String)
-	end
-	
-	it 'should hold access to top level re-class' do
-		class A5
-			module M6
-				String(){injectors.by_name}.should == [:StringExtensions]
-			end
-		end
-	end 
-end
-
-
-
-
-# re- Reclassing
-################################################
-
-MyStringExtensions = StringExtensions() do
-	def to_s
-		super + '----'
-	end
-end
-
-describe 're-reclassing' do
-	it 'should pass' do
-		String() do 																	
-			update MyStringExtensions
-		end
-
-		String('standard').to_s.should == 'standard----'
-	end
-	# introspecting on Type
-	it 'should be a String' do
-		String('standard').class.should be(String)
-	end
-	
-	it 'should introspect' do
-		String(){injectors}.first.should == MyStringExtensions
+		
 	end
 end
 
 
-
-# TOP LEVEL RECLASSINGS REMAIN UNTOUCHED!!!
-##################################################
-                                                 #
-assert( String('test').to_s == 'test++++' )      #
-assert( Array(3).to_s == '[nil, nil, nil]####' ) #
-                                                 #
-##################################################                  
-# TOP LEVEL RECLASSINGS REMAIN UNTOUCHED!!!
-
-# TOP LEVEL RECLASSING TYPES REMAIN UNTOUCHED!!!
-##################################################
-                                                 #
-assert( String('test').class == String )         #
-assert( Array(3).class == Array )                #
-                                                 #
-##################################################                  
-# TOP LEVEL RECLASSING TYPES REMAIN UNTOUCHED!!!
-
-# ORIGINAL CLASSES REMAIN UNTOUCHED!!!
-##################################################
-                                                 #
-assert(String.new.to_s == '')                    #
-assert(Array.new(3).to_s == '[nil, nil, nil]')   #
-                                                 #
-##################################################                  
-# ORIGINAL CLASSES REMAIN UNTOUCHED!!!
-
-# ORIGINAL KERNEL METHODS REMAIN UNTOUCHED!!!
-##################################################
-                                                 #
-assert( Kernel.String(123) == '123' )            #
-assert( Kernel.Array(3) == [3])                  #
-                                                 #
-##################################################                  
-# ORIGINAL KERNEL METHODS REMAIN UNTOUCHED!!!
-
-# profile = RubyProf.stop
-# RubyProf::FlatPrinter.new(profile).print(STDOUT)
-# RubyProf::GraphHtmlPrinter.new(profile).print(open('profile.html', 'w+'))
-# RubyProf::CallStackPrinter.new(profile).print(open('profile.html', 'w+'))
-
-