RubyExt 0.1.0 → 0.1.1

data/spec/RubyExt/ForLocalization/NS/B.rb

@@ -0,0 +1,22 @@
+class B < A
+  def message
+    to_l("English")
+  end
+
+  def class_hierarchy_message
+    to_l("Class Hierarchy English")
+  end
+
+  def namespace_hierarchy_message
+    to_l("Namespace Hierarchy English")
+  end
+
+  def substitution
+    value = 10
+    to_l("English \#{value}", binding)
+  end
+
+  def not_localized
+    to_l("English Not Localized")
+  end
+end

data/spec/RubyExt/ForLocalization/NS/B.ru.localization.yaml

@@ -0,0 +1,3 @@
+--- 
+"English": "Russian"
+"English #{value}": "Russian #{value}"

data/spec/RubyExt/ForLocalization/NS.ru.localization.yaml

@@ -0,0 +1,2 @@
+---
+"Namespace Hierarchy English": "Namespace Hierarchy Russian"

data/spec/RubyExt/ForModule/NS1/A.data

@@ -0,0 +1 @@
+A.data

data/spec/RubyExt/ForModule/NS1/A.rb

@@ -0,0 +1 @@
+class A; end

data/spec/RubyExt/ForModule/NS1/A2.rb

@@ -0,0 +1 @@
+class A2; end

data/spec/RubyExt/ForModule/NS1/B.rb

@@ -0,0 +1,2 @@
+class B < ForModule::NS1::A
+end

data/spec/RubyExt/ForModule/NS1/B2.rb

@@ -0,0 +1 @@
+class B2 < ForModule::NS1::A2; end

data/spec/RubyExt/ForModule/NS1.data

@@ -0,0 +1 @@
+NS1.data

data/spec/RubyExt/ForModule/NS2/A.data

@@ -0,0 +1 @@
+A.data

data/spec/RubyExt/ForModule/NS2/A.rb

@@ -0,0 +1,3 @@
+class A
+	
+end

data/spec/RubyExt/ForModule/NS2/B.rb

@@ -0,0 +1,3 @@
+class B < ForModule::NS2::A
+	include ForModule::NS2::M
+end

data/spec/RubyExt/ForModule/NS2/M.data

@@ -0,0 +1 @@
+M.data

data/spec/RubyExt/ForModule/NS2/M.rb

@@ -0,0 +1,3 @@
+module M
+	
+end

data/spec/RubyExt/ForResource/ChangedClass.rb

@@ -0,0 +1 @@
+class ChangedClass; end

data/spec/RubyExt/ForResource/ProviderChaining/ProviderABaseDir/ChainTest.rb

@@ -0,0 +1,3 @@
+class ChainTest; 	
+# "ProviderA"
+end

data/spec/RubyExt/ForResource/ProviderChaining/ProviderABaseDir/ChainTest.resource

@@ -0,0 +1 @@
+ProviderA

data/spec/RubyExt/ForResource/ProviderChaining/ProviderABaseDir/ClassExistOnlyInProviderA.rb

@@ -0,0 +1,3 @@
+class ClassExistOnlyInProviderA
+#	ClassExistOnlyInProviderA
+end

data/spec/RubyExt/ForResource/ProviderChaining/ProviderBBaseDir/ChainTest.rb

@@ -0,0 +1,3 @@
+class ChainTest; 	
+# "ProviderB"
+end

data/spec/RubyExt/ForResource/ProviderChaining/ProviderBBaseDir/ChainTest.resource

@@ -0,0 +1 @@
+ProviderB

data/spec/RubyExt/ForResource/ResourceExtension.rb

@@ -0,0 +1 @@
+class ResourceExtension; end

data/spec/RubyExt/ForResource/ResourceExtension.res/Data.yaml

@@ -0,0 +1,2 @@
+--- 
+:value: true

data/spec/RubyExt/ForResource/ResourceTest/Test.rb

@@ -0,0 +1 @@
+class Test; end

data/spec/RubyExt/ForResource/ResourceTest/Test.res/Data.txt

@@ -0,0 +1 @@
+Data.txt

data/spec/RubyExt/ForResource/ResourceTest/Test.res/txt

@@ -0,0 +1 @@
+Test.txt

data/spec/array_spec.rb

@@ -0,0 +1,27 @@
+require 'RubyExt/require'
+require 'spec'
+
+module RubyExt
+	describe 'Array' do
+		class Respond
+			def test; 2 end
+		end
+
+		it "sort_by_weight" do
+			a = [:a, :b, :c]
+			w = [3, 2, 1]
+			a.sort_by_weight(w).should == [:c, :b, :a]
+			a.should == [:a, :b, :c]
+			a.sort_by_weight! w
+			a.should == [:c, :b, :a]
+		end		
+		
+		it "sort_by_weight (from error)" do
+			a = ["Attributes", "Micelaneous", "Containers", "Tools"]
+			w = [0, 0, -1, -2]
+			a.sort_by_weight! w
+			a.should == ["Tools", "Containers", "Attributes", "Micelaneous"]
+			w.should == [-2, -1, 0, 0]
+		end
+	end
+end

data/spec/assert_spec.rb

@@ -0,0 +1,18 @@
+require 'RubyExt/require'
+require 'spec'
+
+module RubyExt
+	describe 'Assert' do
+		it do
+			lambda{should! :be_never_called}.should raise_error(/ever/)
+			lambda{nil.should_not! :be_nil}.should raise_error(/nil/)
+			1.should_not! :be_nil
+			1.should! :==, 1
+			lambda{1.should! :==, 2}.should raise_error(/==/)
+			1.should! :be_in, [1, 2]
+			"".should! :be_a, String
+			String.should! :be, String			
+			1.should! :<, 2
+		end		
+	end
+end

data/spec/cache_spec.rb

@@ -0,0 +1,95 @@
+require 'RubyExt/require'
+require 'spec'
+
+module RubyExt
+	describe 'Cache' do
+		class CachedClass
+			attr_accessor :value
+			def value_get; @value end
+			
+			attr_accessor :value2
+			def value2_get; @value2 end
+			
+			attr_accessor :params
+			def params_get param; @params[param] end 				
+		end						
+		
+		Cache.cached CachedClass, CachedClass, :value_get
+		Cache.cached :cache_version_name, CachedClass, :value2_get
+		Cache.cached_with_params CachedClass, CachedClass, :params_get
+		
+		it "Simple Cache" do
+			o = CachedClass.new
+			o.value = 0
+			o.value2 = 0
+			o.value_get.should == 0
+			o.value2_get.should == 0
+			o.value = 1
+			o.value2 = 1
+			o.value_get.should == 0
+			o.value2_get.should == 0
+			Cache.update CachedClass
+			o.value_get.should == 1
+			o.value2_get.should == 0
+			Cache.update :cache_version_name
+			o.value2_get.should == 1
+			Cache.update CachedClass, :cache_version_name
+		end
+		
+		it "Cache With Params" do
+			o = CachedClass.new
+			o.params = {:a => :b}
+			o.params_get(:a).should == :b
+			o.params = {:a => :c}
+			o.params_get(:a).should == :b
+			Cache.update CachedClass
+			o.params_get(:a).should == :c
+		end
+		
+		class CachedClass2
+			class << self
+				attr_accessor :value
+				def value_get; @value end 								
+			end
+		end				
+		
+		Cache.cached CachedClass2, CachedClass2.singleton_class, :value_get				
+		
+		it "Simple Cache" do
+			CachedClass2.value = 0
+			CachedClass2.value_get.should == 0
+			CachedClass2.value = 1
+			CachedClass2.value_get.should == 0
+			Cache.update CachedClass2
+			CachedClass2.value_get.should == 1
+		end
+		
+		class MultipleCacheVersions
+			attr_accessor :value
+			def value_get; @value end 								
+				
+			attr_accessor :value2
+			def value2_get params; @value2 end
+		end
+		
+		Cache.cached [:class, :resource_update, :security_update], MultipleCacheVersions, :value_get				
+		Cache.cached_with_params [:class, :resource_update, :security_update], MultipleCacheVersions, :value2_get				
+		
+		it "Multiple cache versions" do
+			o = MultipleCacheVersions.new
+			o.value, o.value2 = 0, 0
+			
+			o.value_get.should == 0
+			o.value = 1
+			o.value_get.should == 0			
+			Cache.update :class
+			o.value_get.should == 1
+			o.value = 2
+			o.value_get.should == 1
+			Cache.update :resource_update, :security_update
+			o.value_get.should == 2
+			
+			o.value2_get("params").should == 0
+		end
+	end
+end

data/spec/class_loader_spec.rb

@@ -0,0 +1,94 @@
+require 'RubyExt/require_base'
+require 'spec'
+
+module RubyExt
+	describe "PackageManager" do
+		it "Should load classes only one time" do
+			class CustomObserver
+				attr_reader :list
+				def initialize
+					@list = []
+				end
+				
+				def update_class klass
+					@list << klass
+				end
+			end
+			obs = CustomObserver.new
+			RubyExt::ClassLoader.add_observer obs
+			ForClassLoader::LoadCount
+			ForClassLoader::LoadCount
+			RubyExt::ClassLoader.delete_observers
+			obs.list.inject(0){|count, klass| klass == ForClassLoader::LoadCount ? count + 1 : count}.
+				should == 1
+		end
+		
+		it "Should load classes From Multiple directories" do
+			
+		end
+
+		it "Class has the same name as package" do
+			ForClassLoader::ModuleA::SameName
+			RubyExt::ForClassLoader::ModuleA::SameName::SomeClass
+		end
+
+		it "Infinity Loop" do
+			lambda{ForClassLoader::ModuleA::InfinityLoop}.
+				should raise_error(/Class Name .+ doesn't correspond to File Name/)
+		end
+
+		it "Core" do
+			ForClassLoader::ModuleA::ModuleB::ClassC.new
+		end
+
+
+		module ForClassLoader::ModuleA
+			class << self
+        def anonymous
+					ClassInsideAnonymousClass
+        end
+			end
+		end
+
+		it "Should works inside Anonymous Class" do
+			ForClassLoader::ModuleA.anonymous
+		end
+
+		it "Should raise exception if class isn't defined in scope" do
+			ForClassLoader::Scope::ScopeA1
+			RubyExt::ClassLoader.error_on_defined_constant = true
+			lambda{ForClassLoader::Scope::ScopeB1}.
+				should raise_error(/Class '.+' is not defined in the '.+' Namespace!/)
+		end
+
+		it "Class Reloading" do
+			fname = File.join(File.dirname(__FILE__), 'RubyExt/ForClassLoader/ModuleA/ClassReloading.rb')
+			File.delete fname if File.exist? fname
+			File.open(fname, 'w') do |f|
+				f.write %{\
+class ClassReloading
+	def test
+		1
+	end
+end}
+			end
+
+			test = ForClassLoader::ModuleA::ClassReloading.new
+			test.test.should == 1
+
+			File.open(fname, 'w') do |f|
+				f.write %{\
+class ClassReloading
+	def test
+		2
+	end
+end}
+			end
+
+			RubyExt::ClassLoader.reload_class(ForClassLoader::ModuleA::ClassReloading.name)
+			test.test.should == 2
+
+			File.delete fname if File.exist? fname
+		end
+	end
+end

data/spec/import_all_spec.rb

@@ -0,0 +1,21 @@
+require 'RubyExt/require_base'
+require 'spec'
+
+module RubyExt
+	describe "ImportAll" do
+		class A
+			class B; end
+			class C; end
+			class D; end
+		end
+
+		class E
+			extend RubyExt::ImportAll
+			import_all A
+		end
+
+		it do
+			E::B
+		end
+	end
+end

data/spec/kernel_spec.rb

@@ -0,0 +1,38 @@
+require 'RubyExt/require'
+require 'spec'
+
+module RubyExt
+	describe 'Kernel' do
+		class Respond
+			def test; 2 end
+		end
+
+		it "respond_to" do
+			r = Respond.new
+			r.respond_to(:not_exist).should be_nil
+			r.respond_to(:test).should == 2
+		end		
+
+		it "raise_without_self" do
+			begin
+				ForKernel::RaiseWithoutSelf.new.test
+			rescue RuntimeError => e
+				stack = e.backtrace
+				stack.any?{|line| line =~ /RaiseWithoutSelf/}.should be_false
+				stack.any?{|line| line =~ /kernel_spec/}.should be_true
+			end
+		end
+		
+		it "raise_without_self" do
+			begin
+				t1 = ForKernel::RaiseWithoutSelf.new
+				ForKernel::Raise2.new.test t1
+			rescue RuntimeError => e
+				stack = e.backtrace
+				stack.any?{|line| line =~ /RaiseWithoutSelf/}.should be_false
+				stack.any?{|line| line =~ /Raise2/}.should be_false
+				stack.any?{|line| line =~ /kernel_spec/}.should be_true
+			end
+		end
+	end
+end

data/spec/localization_spec.rb

@@ -0,0 +1,49 @@
+require 'spec'
+require 'RubyExt/Localization/require'
+
+module RubyExt
+	describe "RubyExt::Localization" do
+		before :each do
+			RubyExt::Localization.default_language = :en
+			RubyExt::Localization.language = nil
+		end
+		
+		it "Default Language" do
+			ForLocalization::NS::B.new.message.should == "English"
+			RubyExt::Localization.default_language = :ru
+			ForLocalization::NS::B.new.message.should == "Russian"
+		end
+		
+		it "Not Localized" do
+			RubyExt::Localization.default_language = :ru
+			ForLocalization::NS::B.new.not_localized.should == "English Not Localized"
+		end
+		
+		it "Language set" do
+			ForLocalization::NS::B.new.message.should == "English"
+			RubyExt::Localization.language = lambda{:ru}
+			ForLocalization::NS::B.new.message.should == "Russian"
+		end
+		
+		it "Language not set" do
+			RubyExt::Localization.language = lambda{nil}
+			ForLocalization::NS::B.new.message.should == "English"
+		end
+		
+		it "Class Hierarchy" do
+			RubyExt::Localization.language = lambda{:ru}
+			ForLocalization::NS::B.new.class_hierarchy_message.should == "Class Hierarchy Russian"
+		end
+		
+		it "Namespace Hierarchy" do
+			RubyExt::Localization.language = lambda{:ru}
+			ForLocalization::NS::B.new.namespace_hierarchy_message.should ==
+          "Namespace Hierarchy Russian"
+		end
+		
+		it "Substitution" do
+			RubyExt::Localization.language = lambda{:ru}
+			ForLocalization::NS::B.new.substitution.should == "Russian 10"
+		end
+	end
+end

data/spec/module_spec.rb

@@ -0,0 +1,135 @@
+require 'RubyExt/require_base'
+require 'spec'
+
+module RubyExt
+	describe "Module" do
+		class A
+			class B
+				class C
+					
+				end
+			end
+		end
+		
+		it "Namespace" do
+			File.namespace.should == nil
+			A::B::C.namespace.should == RubyExt::A::B
+		end
+		
+		class AnonymousClass
+			class << self
+				def anonymous_name
+					self.name
+				end
+			end
+		end
+		
+		
+		it "name" do
+			A::B::C.name.should == "RubyExt::A::B::C"
+		end
+		
+		class X; end
+		class Y < X; end
+		class Z < Y; end
+		
+		
+		it "each_ancestor" do
+			list = []
+			Z.each_ancestor{|a| list << a}
+			list.should include Y
+			list.should include X
+			list.should_not include Z
+			list.should_not include Object
+			list.should_not include Kernel
+			
+			list = []
+			Z.each_ancestor(true){|a| list << a}
+			list.should include Y
+			list.should include X
+			list.should_not include Z
+			list.should include Object
+			list.should include Kernel
+		end
+		
+		it "each_namespace" do
+			list = []
+			A::B::C.each_namespace{|n| list << n}
+			list.should == [RubyExt::A::B, RubyExt::A, RubyExt]
+		end
+		
+		it "is?" do
+			File.is?(IO).should be_true
+		end
+		
+		class WrapMethod
+			def method_name value
+				10*value
+			end
+		end
+		
+		it "wrap_method" do
+			WrapMethod.wrap_method :method_name do |old, value|
+				send(old, value)*value
+			end
+			WrapMethod.new.method_name(10).should == 1000
+		end
+		
+		it "resources" do
+			ForModule::NS1::B["data"].should == "A.data"
+			ForModule::NS1::B2["data"].should == "NS1.data"
+		end
+		
+		it "resources, should aslo inherit resources from included modules" do
+			ForModule::NS2::B["data"].should == "M.data"
+		end
+		
+		module M
+			def m_m; end				
+			module ClassMethods
+				def cm_m; end
+			end
+		end						
+		
+		class C
+			inherit M
+		end
+		
+		it "inherit" do
+			C.respond_to?(:cm_m).should be_true
+			C.new.respond_to?(:m_m).should be_true				
+		end
+		
+		module M2
+			include M
+			
+			module ClassMethods
+				def cm2_m; end
+			end
+		end
+		
+		class D
+			inherit M2
+		end
+		
+		it "should inherit all ancestors class methods" do
+			D.respond_to?(:cm_m).should be_true
+			D.respond_to?(:cm2_m).should be_true
+			D.new.respond_to?(:m_m).should be_true
+		end
+		
+		class C2
+			inherit M
+		end
+		
+		it "Shouldn't redefine ancestors class methods" do
+			C2.respond_to?(:cm2_m).should be_false
+		end
+		
+		it "inherited_instance_methods" do
+			im = Set.instance_methods - Set.inherited_instance_methods
+			im.should include("union")
+			im.should_not include("object_id")
+		end
+	end
+end

data/spec/object_spec.rb

@@ -0,0 +1,8 @@
+require 'RubyExt/require_base'
+require 'spec'
+
+module RubyExt
+	describe "Object" do
+		
+	end
+end

data/spec/observable_spec.rb

@@ -0,0 +1,44 @@
+require 'RubyExt/require_base'
+require 'spec'
+
+module RubyExt
+		describe "Observable" do
+			class AnObservable
+				include Observable
+			end
+			
+			it "Method without Parameters" do
+				mock = mock("Observer")
+				obs = AnObservable.new
+				obs.add_observer mock
+				mock.should_receive(:update).with(2)
+				obs.notify_observers :update, 2			
+			end
+			
+#			it "Method without Parameters" do
+#				mock = mock("Observer")
+#				obs = AnObservable.new
+#				obs.add_observer(mock, :method => :custom_update, :filter => lambda{|o| o == 2})
+#				mock.should_receive(:custom_update).with(2)
+#				obs.notify_observers 2
+#				obs.notify_observers 4
+#			end
+#			
+#			it "With Block" do
+#				mock = mock("Observer")
+#				mock.should_receive(:got)
+#				obs = AnObservable.new
+#				obs.add_observer{mock.got}
+#				obs.notify_observers
+#			end
+#			
+#			it "With Block and Filter" do
+#				mock = mock("Observer")
+#				obs = AnObservable.new
+#				obs.add_observer(:filter => lambda{|o| o == 2}){|o| mock.got o}
+#				mock.should_receive(:got).with(2)
+#				obs.notify_observers 2
+#				obs.notify_observers 4									
+#			end
+		end
+end