ruby-ext 0.2.16 → 0.4.0

data/old/lib/RubyExt/resource.rb

@@ -1,172 +0,0 @@
-module RubyExt
-	module Resource		
-		@monitor = Monitor.new		
-		@providers = []		
-		@resource_extensions = {}
-		
-		class NotExist < RuntimeError
-			
-		end
-		
-		class << self
-			include Observable
-			
-			def add_resource_provider provider
-				@providers.unshift provider
-			end
-			
-			def providers
-				raise "There's no any Resource Provider!" if @providers.empty?
-				@providers
-			end
-			
-			def register_resource_extension extension, load, save
-				@monitor.synchronize do
-					@resource_extensions[extension] = load, save
-				end
-			end
-			
-			def unregister_resource_extension extension
-				@monitor.synchronize do
-					@resource_extensions.delete extension
-				end
-			end												
-			
-			# Returns from first Provider that contains this Class.
-			def class_get class_name
-				@monitor.synchronize do
-					providers.each do |p|
-						begin
-							return p.class_get(class_name) 
-						rescue NotExist;
-						end
-					end
-					raise "Class '#{class_name}' doesn't exist!"
-				end
-			end
-			
-			# Search for first Provider that contains Class Namespace and creates Class in it, then exits.
-			def class_set class_name, data, *args
-				@monitor.synchronize do					
-					namespace = Module.namespace_for class_name
-					namespace = namespace ? namespace.to_s : nil
-					found = true
-					providers.each do |p|
-						next unless !namespace or p.class_exist?(namespace)
-						p.class_set class_name, data, *args
-						break
-					end
-					raise "Namespace '#{namespace}' doesn't exist!" unless found
-				end
-			end
-			
-			def class_exist? class_name
-				@monitor.synchronize do
-					providers.any?{|p| p.class_exist? class_name}
-				end
-			end
-			
-			# Deletes in each Providers.
-			def class_delete class_name
-				@monitor.synchronize do
-					providers.each{|p| p.class_delete class_name}
-				end
-			end
-			
-#			def class_namespace_exist? namespace_name
-#				@monitor.synchronize do
-#					providers.any?{|p| p.class_namespace_exist? namespace_name}
-#				end
-#			end
-			
-			# Search each Provider that contains this Class and returns first found Resource.
-			def resource_get klass, resource_name				
-				@monitor.synchronize do					
-					providers.each do |p|
-						next unless p.class_exist?(klass.name)
-						begin
-							data = p.resource_get(klass.name, resource_name)
-							
-							if data
-								extension = File.extname(resource_name)
-								if @resource_extensions.include? extension
-									load, save = @resource_extensions[extension]
-									data = load.call data, klass, resource_name
-								end
-							end
-							
-							return data
-						rescue NotExist;
-						end
-					end
-					raise "Resource '#{resource_name}' for Class '#{klass.name}' doesn't exist!"
-				end
-			end
-			
-			# Deletes Resource in all Providers.
-			def resource_delete klass, resource_name
-				@monitor.synchronize do
-					providers.each do |p|
-						next unless p.class_exist?(klass.name)
-						p.resource_delete klass.name, resource_name		
-					end
-				end
-			end
-			
-			# Set Resource in fist Provider that contains this Class.
-			def resource_set klass, resource_name, data
-				@monitor.synchronize do
-					extension = File.extname(resource_name)
-					if @resource_extensions.include? extension
-						load, save = @resource_extensions[extension]
-						data = save.call data, klass, resource_name
-					end
-					
-					found = false
-					providers.each do |p|
-						next unless p.class_exist?(klass.name)
-						p.resource_set klass.name, resource_name, data
-						found = true
-						break
-					end
-					
-					raise "Class '#{klass.name}' doesn't exist!" unless found
-				end
-			end
-			
-			# Check also for Class existence.
-			def resource_exist? klass, resource_name
-				@monitor.synchronize do
-					providers.any? do |p|
-						next unless p.class_exist?(klass.name)
-						p.resource_exist? klass.name, resource_name
-					end
-				end
-			end												
-			
-			def class_to_virtual_file class_name
-				@monitor.synchronize do				
-					providers.each do |p|
-						begin
-							return p.class_to_virtual_file class_name 
-						rescue NotExist;
-						end
-					end
-					raise "Class '#{class_name}' doesn't exist!"					
-				end
-			end
-			
-#			def class_to_virtual_path class_name
-#				@monitor.synchronize do
-#					providers.each do |p|
-#						begin
-#							return p.class_to_virtual_path class_name 
-#						rescue NotExist;
-#						end
-#					end
-#					raise "Class '#{class_name}' doesn't exist!"
-#				end
-#			end
-		end 
-	end
-end

data/old/rakefile

@@ -1,52 +0,0 @@
-require 'rake'
-require 'spec/rake/spectask'
-
-Dir.chdir File.dirname(__FILE__)	
-
-# Specs
-task :default => :spec
-
-Spec::Rake::SpecTask.new('spec') do |t|
-	t.spec_files = FileList["spec/**/*_spec.rb"]
-	t.libs = ["lib", "spec"]
-end
-
-# Gem
-require 'rake/clean'
-require 'rake/gempackagetask'
-require 'fileutils'
-
-spec = Gem::Specification.new do |s|
-	s.name = "RubyExt"
-	s.version = "0.1.1"
-	s.summary = "A set of Ruby language extensions, mainly for ActivePoint Project"
-	s.description = "A set of Ruby language extensions, mainly for ActivePoint Project"
-	s.author = "Alexey Petrushin"
-	#	s.email = ""
-	s.homepage = "http://www.bos-tec.com"
-	s.rubyforge_project = "RubyExt"
-	
-	s.platform = Gem::Platform::RUBY
-	s.has_rdoc = true
-	s.extra_rdoc_files = ["README"]
-	
-	s.files = (%w{rakefile README} + Dir.glob("{lib,spec}/**/*"))\
-	.select{|f| f !~ /^\./}
-	#	s.executables = ['restclient']
-	#	s.add_dependency("BlueCloth", ">= 0.0.4")
-	s.add_dependency "facets"
-	
-	s.require_path = "lib"
-end
-
-Rake::GemPackageTask.new(spec) do |p|
-	package_dir = "#{File.expand_path File.dirname(__FILE__)}/../build"
-#	FileUtils.mkdir package_dir unless File.exist? package_dir	
-	p.need_tar = true if RUBY_PLATFORM !~ /mswin/
-	p.need_zip = true
-	p.package_dir = package_dir
-end
-
-CLEAN.include [ 'pkg', '*.gem']
-
-task :release => [:gem, :clean]

data/old/spec/RubyExt/ForClassLoader/ClassA.rb

@@ -1,4 +0,0 @@
-class ClassA
-	
-end
-# Do not delete this comment on last line! It's the Test!

data/old/spec/RubyExt/ForClassLoader/ModuleA/ModuleB/ClassC.rb

@@ -1,3 +0,0 @@
-class ClassC
-	ClassB
-end

data/old/spec/RubyExt/ForClassLoader/Scope/ScopeB1.rb

@@ -1,5 +0,0 @@
-class ScopeB1
-	class InnerClass; end
-
-	InnerClass::ScopeA1
-end

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

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

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

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

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

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

data/old/spec/class_loader_spec.rb

@@ -1,94 +0,0 @@
-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/old/spec/kernel_spec.rb

@@ -1,29 +0,0 @@
-require 'RubyExt/require'
-require 'spec'
-
-module RubyExt
-	describe 'Kernel' do
-
-		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/old/spec/module_spec.rb

@@ -1,14 +0,0 @@
-require 'RubyExt/require_base'
-require 'spec'
-
-module RubyExt
-		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
-	end
-end

data/old/spec/observable_spec.rb

@@ -1,44 +0,0 @@
-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

data/old/spec/resource_spec.rb

@@ -1,136 +0,0 @@
-require 'RubyExt/require_base'
-require 'fileutils'
-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
-				FileSystemProvider.start_watching(1, [File.dirname __FILE__])
-				
-				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
-				FileSystemProvider.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 "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/declarative_cache_rem.rb

@@ -1,98 +0,0 @@
-require 'spec'
-
-dir = File.dirname __FILE__
-require "#{dir}/spec_require"
-require "#{dir}/../lib/ruby_ext/should"
-require "#{dir}/../lib/ruby_ext/declarative_cache"
-
-describe 'DeclarativeCache' do
-	class CachedClass
-		attr_accessor :value
-		def value_get; @value end
-		cache! :value_get
-		
-		attr_accessor :value2
-		def value2_get; @value2 end
-		
-		attr_accessor :params
-		def params_get param; @params[param] end 				
-	end						
-	
-  # DeclarativeCache.cache! CachedClass, :value_get
-	DeclarativeCache.cache! :cache_version_name, CachedClass, :value2_get
-	DeclarativeCache.cache_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
-		DeclarativeCache.update CachedClass
-		o.value_get.should == 1
-		o.value2_get.should == 0
-		DeclarativeCache.update :cache_version_name
-		o.value2_get.should == 1
-		DeclarativeCache.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
-		DeclarativeCache.update CachedClass
-		o.params_get(:a).should == :c
-	end
-	
-	class CachedClass2
-		class << self
-			attr_accessor :value
-			def value_get; @value end 								
-		end
-	end				
-	
-	DeclarativeCache.cache! 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
-		DeclarativeCache.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
-	
-	DeclarativeCache.cache! [:class, :resource_update, :security_update], MultipleCacheVersions, :value_get				
-	DeclarativeCache.cache_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			
-		DeclarativeCache.update :class
-		o.value_get.should == 1
-		o.value = 2
-		o.value_get.should == 1
-		DeclarativeCache.update :resource_update, :security_update
-		o.value_get.should == 2
-		
-		o.value2_get("params").should == 0
-	end
-end