jackbox 0.9.6.2

data/spec/lib/jackbox/prefs_spec.rb

@@ -0,0 +1,212 @@
+require "spec_helper"
+=begin rdoc
+	prefs_spec
+	author: Lou Henry
+	:nodoc:all
+=end
+
+include Injectors
+
+describe 'what Prefs does' do
+
+	it 'creates module level attribute methods' do
+		module Tester
+			extend Prefs
+		
+			pref :pref1 => 10
+		end
+
+		lambda{
+			Tester.pref1.should == 10
+			
+			}.should_not raise_error()
+		lambda{
+			Tester.pref1=( 2 )
+			
+			}.should_not raise_error()
+		Tester.pref1.should == 2
+	end
+
+	it 'should work the same on inclusion' do
+		lambda {
+			module Fester
+				include Prefs
+				
+				pref :location => :file_system
+			end
+			}.should_not raise_error()
+		Fester.location.should == :file_system
+	end
+
+	it 'allows resetting prefs to their original/default values' do
+		module Jester
+			extend Prefs
+			
+			pref :value => 10
+		end
+		Jester.value.should == 10
+		Jester.value = 3
+		Jester.value.should == 3
+		Jester.reset :value
+		Jester.value.should == 10 
+	end
+
+	it 'persists across processes' do
+		# we run a process and make settings
+		launch %{
+			require 'jackbox'
+
+			class Application
+				include Prefs
+
+				pref :data_path => "#{ENV['HOME']}/tmp/jackbox"
+
+				def foo
+				end
+			end
+			
+			#...
+			
+			Application.data_path = "#{ENV['HOME']}/tmp/foo"
+		}
+		Process.waitall
+		
+		# After the previous invocation
+		class Application
+			include Prefs
+			
+			pref :data_path => "#{ENV['HOME']}/tmp/jackbox"
+			
+			def foo
+			end
+		end
+		
+		# ...
+		
+		Application.data_path.should == "#{ENV['HOME']}/tmp/foo"
+
+		# ...
+
+		Application.reset
+		Application.data_path.should == "#{ENV['HOME']}/tmp/jackbox"
+	end
+
+	it 'should allow definition of prefs outside the module definition' do
+		lambda{
+			Tester.pref :new_prop => 3 
+		
+			}.should_not raise_error()
+		Tester.pref :someprop => 'tester'
+		
+		lambda{
+			Tester.someprop 
+			
+			}.should_not raise_error
+		Tester.someprop.should == 'tester'
+	end
+
+	it 'should not pass-on definitions to descendants' do
+		module Tester
+			include Prefs
+			pref :pref1 => 10
+		end
+		lambda{Tester.pref1}.should_not raise_error
+		module Descendant
+			include Tester
+		end
+		lambda{Descendant.pref1}.should raise_error(NoMethodError)
+		module Offspring
+			extend Tester
+		end
+		lambda{Offspring.pref1}.should raise_error(NoMethodError)
+		class Child
+			include Tester
+			extend Tester
+		end
+		lambda{Child.pref1}.should raise_error(NoMethodError)
+		lambda{Child.new.pref1}.should raise_error(NoMethodError)
+	end
+	
+	it 'should allow all of the following' do
+	 lambda{
+		module Master
+			extend Prefs
+			
+			pref :tester => 10
+		end
+
+		Master.pref :boo => 45
+		Master.boo = [23,45,32,56]
+		Master.tester = 30
+		Master.reset :tester
+		Master.pref :second => 'second'
+		Master.second = 'first'
+
+		module Extras  
+			extend Prefs
+
+			pref :a => 10
+			pref :reminders_on => true
+			pref :interval => 60
+			pref :log_file => "/d/workspace"
+			pref :tester => :mary
+
+			self.a = :b
+			#TODO: problem: local variables override prefs
+			a = 'c'
+			self.reminders_on = false
+			self.interval=45
+		end
+		}.should_not raise_error
+
+		lambda {
+		module Tester
+			extend Prefs
+
+			pref :foo => true
+			pref :faa => :is_not_error
+		end}.should_not raise_error
+		Tester.foo.should == true
+		Tester.faa.should == :is_not_error
+
+	end
+
+	it 'should also allow classes to be used' do
+		class C
+			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)
+	end
+
+	it 'should be possible to reset the prefs to their defaults' do
+		lambda{Tester.reset}.should_not raise_error
+	end
+	
+	it 'should allow definition of prefs store location' do
+		class One
+			extend Prefs
+			prefs_path 'spec/some_path'			
+			
+			pref :gaga => 3456
+		end
+		One.gaga.should == 3456
+		
+		File.should exist('spec/some_path/prefs')
+	end
+	
+	the 'Prefs module also works with Injectors' do
+		
+		injector :prefs_tester do
+			extend Prefs
+			pref :some_pref => 'value'
+		end
+		
+		prefs_tester.some_pref.should == 'value'
+	end
+
+end
+

data/spec/lib/jackbox/reclassing_spec.rb

@@ -0,0 +1,394 @@
+require "spec_helper"
+=begin rdoc
+	This file represents a new approach to refining a class using Jackbox modular closures.
+	
+	lha
+=end
+
+# Jackbox Reclassings
+############################################
+
+# RubyProf.start
+
+injector :StringExtensions do  										# define injector
+  def to_s
+		super + '++++'
+	end
+end
+
+# debugger
+lets String do 																		# apply to class
+	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 Reclassing
+
+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
+
+
+
+
+# Further Introspection
+##################################################
+# debugger
+assert( A6.new.foo_bar.injectors.by_name == [:NameSpacedArrayExtensions] )
+
+describe "introspection" do
+	
+	# introspecting on capabilities
+
+	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
+		Array(1).injectors.by_name == [:ArrayExtensions]
+		
+	end
+	
+	it 'works on namespaced reclassings' do
+		module M7
+			# debugger
+			Array() do
+				injectors.by_name.should == [:NameSpacedArrayExtensions]
+			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
+		
+		module M8 
+			reclass? Array
+		end.should == false
+		
+		module M9
+			reclass? String
+		end.should == false
+		
+	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
+
+
+
+
+
+# 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+'))
+
+