RubyExt 0.1.0 → 0.1.1

data/spec/open_constructor_spec.rb

@@ -0,0 +1,38 @@
+require 'RubyExt/require_base'
+require 'spec'
+
+module RubyExt
+	describe 'OpenConstructor' do
+		class Test
+			include OpenConstructor
+			attr_accessor :name, :value
+    end
+
+		it 'should initialize atributes from Hash' do
+			t = Test.new.set(:name => 'name', :value => 'value')
+			[t.name, t.value].should == ['name', 'value']
+		end
+		
+		it 'should initialize atributes from any Object' do
+			t = Test.new.set(:name => 'name', :value => 'value')
+			t2 = Test.new.set t
+			[t2.name, t2.value].should == ['name', 'value']
+		end
+		
+		it 'restrict copied values' do
+			t = Test.new.set(:name => 'name', :value => 'value')
+			t2 = Test.new.set t, [:name]
+			[t2.name, t2.value].should == ['name', nil]
+			
+			t = {:name => 'name', :value => 'value'}
+			t2 = Test.new.set t, [:name]
+			[t2.name, t2.value].should == ['name', nil]
+		end
+		
+		it 'to_hash' do
+			h = {:name => 'name', :value => 'value'}
+			t = Test.new.set h
+			t.to_hash.should == h
+		end
+	end
+end

data/spec/path_spec.rb

@@ -0,0 +1,169 @@
+require 'RubyExt/require_base'
+require 'spec'
+
+module RubyExt
+	describe "Path" do
+		it '+' do
+		(Path.new('/aa')+'bb').should == Path.new('/aa/bb')
+		(Path.new('aa')+'bb').should == Path.new('aa/bb')
+		(Path.new('/aa')+Path.new('bb')).should == Path.new('/aa/bb')
+		end
+		
+		it "Invaalid path" do
+			lambda{Path.new '//aa'}.should raise_error
+			lambda{Path.new '//'}.should raise_error
+			lambda{Path.new '/aa//bb'}.should raise_error
+			lambda{Path.new 'aa//bb'}.should raise_error
+		end
+		
+		it "simple?" do
+			Path.new('aa').should be_simple
+			Path.new('/aa').should be_simple
+			Path.new('').should be_simple
+			Path.new('/').should be_simple
+			
+			Path.new('aa/bb').should_not be_simple
+			Path.new('/aa/bb').should_not be_simple
+		end
+		
+		it "should bbe cconvertaabble to String" do
+			Path.new('aa').to_s.class.should == String
+		end
+		
+		it 'bbaase operaations' do
+			Path.new('/').empty?.should be_true
+			Path.new('aa').absolute?.should be_false
+			Path.new('/aa').absolute?.should be_true
+		end
+		
+		it 'first && last' do
+			path = Path.new("/aa/bb/cc")
+			path.first.should == Path.new('/aa')
+			path.last.should == Path.new('/cc')
+			
+			path = Path.new("/")
+			path.should == path.first
+			path.should == path.last
+			
+			path = Path.new("aa/bb/cc")
+			Path.new('aa').should == path.first
+			Path.new('cc').should == path.last
+			
+			path = Path.new("")
+			path.should == path.first
+			path.should == path.last
+		end
+		
+		it 'first_name & last_name' do
+			path = Path.new("/aa/bb/cc")
+			path.last_name.should == 'cc'
+			path.first_name.should == 'aa'
+			
+			path = Path.new("/")
+			path.last_name.should == nil
+			path.first_name.should == nil
+			
+			path = Path.new("aa/bb/cc")
+			path.last_name.should == 'cc'
+			path.first_name.should == 'aa'
+			
+			path = Path.new("")
+			path.last_name.should == nil
+			path.first_name.should == nil
+		end
+		
+		it "next & previous" do
+			path = Path.new("/aa/bb/cc")
+			
+			path.previous.should == Path.new('/aa/bb')
+			path.previous.previous.previous.should == Path.new("/")
+			path.previous.previous.previous.previous.should == nil
+			
+			path.next.should == Path.new('/bb/cc')
+			path.next.next.next.should == nil
+			
+			path = Path.new("aa/bb/cc")
+			
+			path.previous.should == Path.new('aa/bb')
+			path.previous.previous.previous.should == Path.new
+			path.previous.previous.previous.previous.should == nil
+			
+			path.next.should == Path.new('bb/cc')
+			path.next.next.next.should == nil
+		end
+		
+		it 'aabbsolute path' do
+			path = Path.new("/aa/bb/cc")
+			
+			str = ''
+			path.each do |p|
+				str << p.to_s
+			end
+			str.should == 'aabbcc'
+			
+			path.size.should == 3
+			
+			Path.new("/bb/cc").should == "/bb/cc"
+			
+			path.after('aa').should == '/bb/cc'
+			path.after('bb').should == '/cc'
+			path.after('cc').should == '/'
+			path.before('aa').should == '/'
+			path.before('bb').should == '/aa'
+			path.before('cc').should == '/aa/bb'
+		end
+		
+		it 'should cconvert to relative' do
+			Path.new("aa").should == Path.new("/aa").to_relative
+		end
+		
+		it 'should cconvert to String' do
+			Path.new("/").to_s.should == "/"
+			Path.new("").to_s.should == ""
+		end
+		
+		it 'should define ==' do
+			Path.new("aa/bb").should_not == Path.new("aa")
+		end
+		
+		it "cconstrucctors should works" do
+			Path.new("")
+			Path.new("/")
+		end
+		
+		it "should aappend to end aand staart" do
+			path = Path.new("")
+			path = path.add(Path.new("aa"))
+			path.should == Path.new("aa")
+			
+			path = Path.new("bb")
+			path = path.add(Path.new("aa"))
+			path.should == Path.new("bb/aa")
+			
+			path = Path.new("/")
+			path = path.add(Path.new("aa"))
+			path.should == Path.new("/aa")
+		end
+		
+		it "relative path" do
+			path = Path.new("aa/bb/cc")
+			
+			path.size.should == 3
+			
+			str = ''
+			path.each do |p|
+				str << p.to_s
+			end
+			str.should == 'aabbcc'
+			
+			Path.new("bb/cc").should == "bb/cc"
+			
+			path.after('aa').should == 'bb/cc'
+			path.after('bb').should == 'cc'
+			path.after('cc').should == ''
+			path.before('aa').should == ''
+			path.before('bb').should == 'aa'
+			path.before('cc').should == 'aa/bb'
+		end
+	end
+end

data/spec/resource_spec.rb

@@ -0,0 +1,135 @@
+require 'RubyExt/require_base'
+require 'spec'
+Thread.abort_on_exception=true
+
+module RubyExt
+	describe "Resource" do
+		
+		before :all do
+			dir = "#{File.dirname(__FILE__)}/RubyExt/ForResource/ProviderChaining"
+			Resource.add_resource_provider RubyExt::FileSystemProvider.new(lambda{["#{dir}/ProviderABaseDir"]})
+			Resource.add_resource_provider RubyExt::FileSystemProvider.new(lambda{["#{dir}/ProviderBBaseDir"]})
+		end
+		
+		it "class get, set, exist, delete" do
+			Resource.class_set("RubyExt::ForResource::ClassTest",
+				"class ClassTest; end", File.dirname(__FILE__))
+			
+			Resource.class_exist?("RubyExt::ForResource::ClassTest").
+			should be_true
+			
+			Resource.class_get("RubyExt::ForResource::ClassTest").
+			should == "class ClassTest; end"
+			
+			Resource.class_delete("RubyExt::ForResource::ClassTest")
+			Resource.class_exist?("RubyExt::ForResource::ClassTest").
+			should be_false
+			
+		end
+		
+		it "namespace" do
+			Resource.class_exist?("RubyExt::ForResource").should be_true
+		end
+		
+		it "resource get, set, delete, exist" do
+			dir = "#{File.dirname(__FILE__)}/RubyExt/ForResource/ResourceTest"
+			FileUtils.remove_dir(dir) if File.exist? dir
+			
+			FileUtils.mkdir dir
+			File.write("#{dir}/Test.rb", "class Test; end")
+			File.write("#{dir}/Test.txt", "Test.txt")
+			FileUtils.mkdir "#{dir}/Test.res"
+			File.write("#{dir}/Test.res/Data.txt", "Data.txt")
+			
+			Resource.resource_get(RubyExt::ForResource::ResourceTest::Test, "txt").
+			should == "Test.txt"
+			Resource.resource_get(RubyExt::ForResource::ResourceTest::Test, "Data.txt").
+			should == "Data.txt"
+			
+			Resource.resource_exist?(RubyExt::ForResource::ResourceTest::Test, "txt").
+			should be_true
+			Resource.resource_exist?(RubyExt::ForResource::ResourceTest::Test, "Data.txt").
+			should be_true
+			
+			Resource.resource_delete(RubyExt::ForResource::ResourceTest::Test, "txt")
+			Resource.resource_delete(RubyExt::ForResource::ResourceTest::Test, "Data.txt")
+			Resource.resource_exist?(RubyExt::ForResource::ResourceTest::Test, "txt").
+			should be_false
+			Resource.resource_exist?(RubyExt::ForResource::ResourceTest::Test, "Data.txt").
+			should be_false
+			
+			
+			Resource.resource_set(RubyExt::ForResource::ResourceTest::Test, "txt",
+				"Test.txt")
+			Resource.resource_set(RubyExt::ForResource::ResourceTest::Test, "Data.txt",
+				"Data.txt")
+			Resource.resource_get(RubyExt::ForResource::ResourceTest::Test, "txt").
+			should == "Test.txt"
+			Resource.resource_get(RubyExt::ForResource::ResourceTest::Test, "Data.txt").
+			should == "Data.txt"
+		end
+		
+		it "Class to Path" do
+			lambda{Resource.class_to_virtual_file("A::B::C").should =~ /A\/B\/C/}.should raise_error(/doesn't exist!/)
+			Resource.class_to_virtual_file("RubyExt::ForResource::ResourceTest::Test").should =~
+			/RubyExt\/ForResource\/ResourceTest\/Test/
+		end
+		
+		it "change listeners" do						
+			class CustomObserver 
+				attr_reader :classes, :resources
+				
+				def initialize
+					@classes, @resources = [], []
+				end
+				
+				def update_resource type, klass, resource
+					if type == :class
+						@classes << klass
+					else
+						@classes << klass
+						@resources << resource
+					end	
+				end
+			end
+			
+			obs = CustomObserver.new
+			Resource.add_observer obs
+			
+			begin
+				Resource.start_watching(1)
+				
+				sleep 0.1
+				base = "#{File.dirname(__FILE__)}/RubyExt/ForResource"
+				File.write("#{base}/ChangedClass.rb", "class ChangedClass; end")
+				File.write("#{base}/ChangedClass.txt", "")
+				File.write("#{base}/ChangedClass.res/Text.txt", "")
+				sleep 1.5
+			ensure
+				Resource.stop_watching
+			end
+			
+			obs.classes.size.should == 3
+			obs.classes.all?{|k| k == ForResource::ChangedClass}.should be_true
+			
+			obs.resources.size.should == 2
+			obs.resources.should include("txt")
+			obs.resources.should include("Text.txt")
+		end
+		
+		it "ResourceProvider Chaining" do			    	        	
+			Resource.class_get("ChainTest").should == %{\
+class ChainTest; 	
+# "ProviderB"
+end}
+			Resource.resource_get(ChainTest, "resource").should == "ProviderB"		
+		end
+		
+		it "ResourceExtension" do
+			require "#{File.expand_path(File.dirname(__FILE__))}/../lib/RubyExt/require"
+			Resource.resource_set RubyExt::ForResource::ResourceExtension, "Data.yaml", {:value => true}
+			res = Resource.resource_get RubyExt::ForResource::ResourceExtension, "Data.yaml"
+			res.should == {:value => true}
+		end        
+	end
+end

data/spec/state_machine_spec.rb

@@ -0,0 +1,201 @@
+require 'RubyExt/require'
+require 'spec'
+
+module RubyExt
+	describe "State Mashine" do
+		class Meta < StateMashine
+			initial_state :Creation
+			transitions [:Creation, :create, :View],
+			[:View, :edit, :Edit],
+			[:Edit, :save, :View],
+			[:Edit, :cancel, :View],
+			[:View, :delete, :Deleted]
+		end
+		
+		class BareMeta < StateMashine
+			initial_state :Created
+			transitions [:Created, :delete, :Deleted]
+		end
+		
+		class MetadataTest < StateMashine
+			transitions [:s1, :fun, :s2], [:s3, :fun, :s4]
+		end
+		
+		before :each do
+			@state = Meta.new
+		end
+		
+		it "Initial State" do
+			@state.should == :Creation
+		end
+		
+		it "Exceptions in event processing should cause rollback in state change" do
+			@state.on_event :Creation, :create do
+				raise
+			end
+			lambda{@state.event :create}.should raise_error
+			@state.state.should == :Creation
+		end
+		
+		it "Should properly process events inside another event (from error)" do
+			@state.on_event :Creation, :create do
+				@state.event :edit
+			end
+			@state.event :create
+			@state.state.should == :Edit
+		end
+		
+		it "Transfer function" do
+			@state.event :create
+			@state.should == :View
+		end
+		
+		it "==" do
+			state2 = Meta.new
+			@state.should == state2
+			@state.should == :Creation
+		end
+		
+		it "before & after" do
+			@state.on_entry :View, :entry
+			@state.on_exit :View, :_exit
+			
+			mock = mock("Events")
+			@state.object = mock
+			
+			mock.should_receive(:entry).twice
+			@state.event :create
+			mock.should_receive(:_exit)
+			@state.event :edit
+			
+			@state.event :cancel
+			@state.on_entry :View, nil
+			@state.on_exit :View, nil
+			
+			@state.event :edit
+		end
+		
+		it "on_event" do
+			mock = mock("Events")
+			mock.should_receive :create
+			@state.on_event :Creation, :create do
+				mock.create
+			end
+			@state.event :create
+		end
+		
+		it "should also use block as action" do
+			mock = mock("Events")
+			@state.on_entry :View do
+				mock.entry
+			end                
+			
+			mock.should_receive(:entry)
+			@state.event :create
+		end
+		
+		it "Invalid method" do
+			lambda{@state.event :invalid}.should raise_error(/There is no :invalid Event in :Creation State/)
+		end
+		
+		it "Invalid state" do
+			lambda{@state.event :delete}.should raise_error(/There is no :delete Event in :Creation State!/)
+		end
+		
+		it "Bare State" do
+			s = BareMeta.new        
+			s.state = :Deleted
+		end
+		
+		# (Waiting) - begin -> (Action) - begin -> (NestedAction) - begin n-times -> (NestedAction)
+		#           <- end   -          <- end   -                < end n-times    -
+		#           <- cancel                    - 
+		it "Custom Recursive State" do
+			class NestedAction          
+				def initialize
+					@nesting_level = 0
+				end
+				
+				def begin
+						@nesting_level += 1
+						:NestedAction
+					end
+					
+					def end
+					if @nesting_level == 0
+						return :Action
+					else
+						@nesting_level -= 1  
+						return :NestedAction
+					end
+				end
+				
+				def cancel
+					@nesting_level = 0
+					return :Waiting
+				end
+				
+				# Not required, can be omited
+				def state state
+					case state
+						when :Action
+						@nesting_level = 0
+						return :Action
+					else nil
+					end
+				end
+			end
+			
+			class CustomState < StateMashine
+				initial_state :Waiting
+				transitions [:Waiting, :begin, :Action],
+				[:Action, :end, :Waiting],
+				[:Action, :begin, :NestedAction]
+				custom_state :NestedAction, NestedAction
+			end
+			
+			sm = CustomState.new
+			sm.event :begin
+			sm.state.should == :Action
+			sm.event :begin
+			sm.state.should == :NestedAction
+			
+			# Nested :begin/:end
+			sm.event :begin
+			sm.state.should == :NestedAction
+			sm.event :begin
+			sm.state.should == :NestedAction
+			
+			sm.event :end
+			sm.state.should == :NestedAction
+			sm.event :end
+			sm.state.should == :NestedAction
+			lambda{sm.event :invalid}.should raise_error(/There is no :invalid Event in :NestedAction State/)
+			
+			sm.event :end
+			sm.state.should == :Action
+			
+			# Nested :cancel
+			sm.event :begin
+			sm.state.should == :NestedAction
+			sm.event :begin
+			sm.state.should == :NestedAction
+			sm.event :cancel
+			sm.state.should == :Waiting
+			
+			# Correct working after :cancel
+			sm.event :begin
+			sm.state.should == :Action
+			sm.event :begin
+			sm.state.should == :NestedAction
+			sm.event :end
+			sm.state.should == :Action
+			
+			# Should also works with "state= ..."
+			sm.event :begin
+			sm.state.should == :NestedAction
+			sm.state = :Action
+			sm.state.should == :Action
+		end
+	end
+end

data/spec/synchronizer_spec.rb

@@ -0,0 +1,66 @@
+require 'RubyExt/require'
+require 'spec'
+
+module RubyExt
+	describe "Synchronize" do
+		it "synchronize" do
+			class Account
+				inherit RubyExt::Synchronizer
+				attr_reader :from, :to
+				
+				def initialize
+					super
+					@from, @to = 0, 0
+				end
+				
+				def transfer
+					@from -= 1
+					@to += 1
+				end
+				synchronize :transfer
+			end
+			
+			a, threads = Account.new, []
+			100.times do 
+				t = Thread.new do
+					100.times{a.transfer}
+				end
+				threads << t
+			end				
+			threads.each{|t| t.join}
+			
+			a.from.should == -10_000
+			a.to.should == 10_000
+		end
+		
+		it "synchronize_all" do
+			class Account
+				inherit RubyExt::Synchronizer
+				attr_reader :from, :to
+				
+				def initialize
+					super
+					@from, @to = 0, 0
+				end
+				
+				def transfer
+					@from -= 1
+					@to += 1
+				end
+				synchronize_all
+			end
+			
+			a, threads = Account.new, []
+			100.times do 
+				t = Thread.new do
+					100.times{a.transfer}
+				end
+				threads << t
+			end				
+			threads.each{|t| t.join}
+			
+			a.from.should == -10_000
+			a.to.should == 10_000
+		end
+	end
+end