ruby-ext 0.2.16 → 0.4.0

data/README.rdoc

@@ -1,3 +0,0 @@
-Set of common Ruby language extensions.
-
-For docs go to spec.

data/lib/ruby_ext/declarative_cache_rem.rb

@@ -1,172 +0,0 @@
-require 'monitor'
-
-class Class
-  def cache! *methods
-    DeclarativeCache.cache! self, *methods
-  end 
-  
-  def cache_with_params! *methods
-    DeclarativeCache.cache_with_params! self, *methods
-  end
-end
-
-module DeclarativeCache		
-	DISABLED = false
-
-	warn "CASHE DISABLED" if DISABLED 
-
-	@versions, @alias_counter, @monitor = Hash.new{should! :be_never_called}, 0, Monitor.new
-	class << self
-	
-		def alias_counter
-			@alias_counter += 1
-			return :"m#{@alias_counter}"
-		end		
-	
-		def cache! *arg
-			vnames, klass, methods = parse_and_check_arguments *arg
-		
-			return if DISABLED						
-			methods.each do |m|				
-				als = (m.to_s =~ /^[_a-zA-Z0-9]+$/) ? m : DeclarativeCache.alias_counter.to_sym 
-			
-				klass.class_eval{alias_method :"cached_#{als}", :"#{m}"}
-				unless vnames.is_a? Array
-					script = single_version_without_args.interpolate binding					
-					@versions[vnames] = 0 unless @versions.include? vnames
-				else
-					vnames_str = vnames.collect{|vname| "'#{vname}' => nil"}.join(', ')
-					script = multiple_version_without_args.interpolate binding
-					vnames.each{|vname| @versions[vname] = 0 unless @versions.include? vname}
-				end
-				klass.class_eval script, __FILE__, __LINE__								
-			end			
-		end
-	
-		def cache_with_params! *arg
-			vnames, klass, methods = parse_and_check_arguments *arg
-		
-			return if DISABLED			
-			methods.each do |m|
-				als = (m.to_s =~ /^[_a-zA-Z0-9]+$/) ? m : DeclarativeCache.alias_counter
-			
-				klass.class_eval{alias_method :"cached_#{als}", :"#{m}"}
-				unless vnames.is_a? Array
-					script = single_version_with_args.interpolate binding					
-					@versions[vnames] = 0 unless @versions.include? vnames
-				else
-					vnames_str = vnames.collect{|vname| "'#{vname}' => nil"}.join(', ')
-					script = multiple_version_with_args.interpolate binding
-					vnames.each{|vname| @versions[vname] = 0 unless @versions.include? vname}
-				end
-				klass.class_eval script, __FILE__, __LINE__
-			end	
-		end
-	
-		def version name
-			@versions[name]
-		end
-	
-		def update *names
-			names.each do |n| 
-				n = n.to_s
-				@versions[n] = 0 unless @versions.include? n 
-				@versions[n] += 1
-			end
-		end
-	
-		attr_reader :monitor
-	
-		protected
-		def parse_and_check_arguments *arg
-			arg.size.should! :>=, 2
-			
-			if arg.size == 3	  
-  			version_names = arg.shift
-  			if version_names.is_a? Array
-  				version_names.size.should! :>, 0
-  				version_names = version_names.collect{|n| n.to_s}
-  			else
-  				version_names = version_names.to_s
-  			end
-  			
-  			klass = arg.shift
-  		else
-  		  version_names = klass = arg.shift  		  
-  		end
-					
-			klass.class.should! :be, [Class, Module]
-		
-			methods = Array(arg.first)
-			defined = klass.instance_methods
-			methods.each do |m|
-				raise "Invalid method_name '#{m}'!" unless defined.include? m.to_s
-			end
-			return version_names, klass, methods
-		end		
-	
-		def multiple_version_with_args
-		  <<-RUBY
-		    def \#{m} *params
-        	DeclarativeCache.monitor.synchronize do
-        		@cache_versions_\#{als} ||= {\#{vnames_str}}
-        		@cache_value_\#{als} ||= {}
-        		if @cache_versions_\#{als}.all?{|vname, v| v == DeclarativeCache.version(vname)} and @cache_value_\#{als}.include?(params) 
-        			return @cache_value_\#{als}[params]
-        		else
-        			@cache_versions_\#{als}.keys.each{|vname| @cache_versions_\#{als}[vname] = DeclarativeCache.version(vname)}
-        			return @cache_value_\#{als}[params] = cached_\#{als}(*params)
-        		end		
-        	end
-        end
-		  RUBY
-		end
-	
-	  def multiple_version_without_args
-	    <<-RUBY
-	      def \#{m}
-        	DeclarativeCache.monitor.synchronize do
-        		@cache_versions_\#{als} ||= {\#{vnames_str}}
-        		if @cache_versions_\#{als}.all?{|vname, v| v == DeclarativeCache.version(vname)}
-        			return @cache_value_\#{als}
-        		else
-        			@cache_versions_\#{als}.keys.each{|vname| @cache_versions_\#{als}[vname] = DeclarativeCache.version(vname)}
-        			return @cache_value_\#{als} = cached_\#{als}
-        		end		
-        	end
-        end
-	    RUBY
-	  end
-	  
-	  def single_version_with_args
-	    <<-RUBY
-	      def \#{m} *params
-        	DeclarativeCache.monitor.synchronize do
-        		@cache_value_\#{als} ||= {}
-        		if @cache_version_\#{als} == DeclarativeCache.version("\#{vnames}") and @cache_value_\#{als}.include?(params) 
-        			return @cache_value_\#{als}[params]
-        		else
-        			@cache_version_\#{als} = DeclarativeCache.version("\#{vnames}")
-        			return @cache_value_\#{als}[params] = cached_\#{als}(*params)
-        		end		
-        	end
-        end
-	    RUBY
-	  end
-	  
-	  def single_version_without_args
-	    <<-RUBY
-	      def \#{m}
-        	DeclarativeCache.monitor.synchronize do
-        		if @cache_version_\#{als} == DeclarativeCache.version("\#{vnames}")
-        			return @cache_value_\#{als}
-        		else
-        			@cache_version_\#{als} = DeclarativeCache.version("\#{vnames}")
-        			return @cache_value_\#{als} = cached_\#{als}
-        		end		
-        	end
-        end
-	    RUBY
-	  end
-	end
-end

data/lib/ruby_ext/synchronizer.rb

@@ -1,31 +0,0 @@
-require 'monitor'
-
-module Synchronizer
-	include MonitorMixin
-	
-	module ClassMethods								
-		def synchronize *methods
-			methods.each do |name|							
-				als = (name.to_s =~ /^[_a-zA-Z0-9]+$/) ? name : DeclarativeCache.alias_counter.to_sym
-				
-				alias_method :"sync_#{als}", name
-				script = "\
-def #{name} *p, &b
-	synchronize{sync_#{als} *p, &b}
-end"
-				class_eval script, __FILE__, __LINE__
-			end
-		end
-		
-		def synchronize_all
-			methods = self.instance_methods(false).collect{|m| m.to_sym}
-			synchronize *methods
-		end
-		
-		protected
-		def alias_counter
-			@alias_counter += 1
-			return :"m#{@alias_counter}"
-		end
-	end
-end

data/old/lib/RubyExt/ClassLoader.rb

@@ -1,142 +0,0 @@
-module RubyExt
-	module ClassLoader
-		@monitor = Monitor.new
-		@loaded_classes = {}
-		
-		class << self
-			include Observable
-			
-			attr_accessor :error_on_defined_constant
-			
-			def reload_class class_name
-				@monitor.synchronize do
-					class_name = class_name.sub(/^::/, "")
-					namespace = Module.namespace_for(class_name);
-					name = class_name.sub(/^#{namespace}::/, "")
-					return load_class namespace, name, true
-				end
-			end
-			
-			def load_class namespace, const, reload = false						
-				@monitor.synchronize do
-					namespace = nil if namespace == Object or namespace == Module
-					target_namespace = namespace
-					
-					# Name hack (for anonymous classes)
-					namespace = eval "#{name_hack(namespace)}" if namespace
-					
-					class_name = namespace ? "#{namespace.name}::#{const}" : const
-					simple_also_tried = false
-					begin
-						simple_also_tried = (namespace == nil)
-						
-						if try_load class_name, const
-							defined_in_home_scope = namespace ? namespace.const_defined?(const) : \
-							Object.const_defined?(const)
-							
-							raise_without_self NameError, "Class Name '#{class_name}' doesn't\
- correspond to File Name '#{Resource.class_to_virtual_file(class_name)}'!", ClassLoader \
-							unless defined_in_home_scope
-								
-								unless reload
-									if @loaded_classes.include? class_name
-										if error_on_defined_constant	
-											raise_without_self NameError,
-										"Class '#{class_name}' is not defined in the '#{target_namespace}' Namespace!",
-											ClassLoader
-										else
-											warn "Warn: Class '#{class_name}' is not defined in the '#{target_namespace}' Namespace!"
-											puts caller
-										end
-									end
-								end
-								
-								result = namespace ? namespace.const_get(const) : Object.const_get(const)
-								
-								@loaded_classes[class_name] = target_namespace
-								notify_observers :update_class, result
-								return result
-							elsif namespace
-								namespace = Module.namespace_for(namespace.name)
-								class_name = namespace ? "#{namespace.name}::#{const}" : const
-							end
-						end until simple_also_tried
-						
-						raise_without_self NameError, "uninitialized constant '#{class_name}'!",
-						ClassLoader
-					end
-				end
-				
-				def wrap_inside_namespace namespace, script
-					nesting = []
-					if namespace
-						current_scope = ""
-						namespace.name.split("::").each do |level|
-							current_scope += "::#{level}"
-							type = eval current_scope, TOPLEVEL_BINDING, __FILE__, __LINE__
-							nesting << [level, (type.class == Module ? "module" : "class")]
-						end
-					end
-					begining = nesting.collect{|l, t| "#{t} #{l};"}.join(' ')
-					ending = nesting.collect{"end"}.join('; ')
-					return "#{begining}#{script} \n#{ending}"
-				end
-				
-				protected
-				
-				def try_load class_name, const										
-					if Resource.class_exist? class_name
-						script = Resource.class_get class_name
-						script = wrap_inside_namespace Module.namespace_for(class_name), script
-						eval script, TOPLEVEL_BINDING, Resource.class_to_virtual_file(class_name)
-						#					elsif Resource.class_namespace_exist? class_name
-						#						script = "#{begining} module #{const}; end; #{ending}"
-						#						eval script, TOPLEVEL_BINDING, __FILE__, __LINE__
-					else
-						return false
-					end
-					return true
-				end
-				
-				def name_hack namespace
-					if namespace
-						namespace.to_s.gsub("#<Class:", "").gsub(">", "")
-					else
-          ""
-					end
-					# Namespace Hack description
-					# Module.name doesn't works correctly for Anonymous classes.
-					# try to execute this code:
-					#
-					#class Module
-					#	def const_missing const
-					#		p self.to_s
-					#	end
-					#end
-					#
-					#class A
-					#    class << self
-					#        def a
-					#            p self
-					#            MissingConst
-					#        end
-					#    end
-					#end
-					#
-					#A.a
-					#
-					# the output will be:
-					# A
-					# "#<Class:A>"
-					#
-				end
-			end
-		end
-	end
-	
-	class Module
-		#	alias_method :old_const_missing, :const_missing
-		def const_missing const
-			return RubyExt::ClassLoader.load_class self, const.to_s
-		end
-	end

data/old/lib/RubyExt/ExtraBlankSlate.rb

@@ -1,14 +0,0 @@
-class ExtraBlankSlate < BlankSlate
-	CUSTOM_UNDEFINE = [:p, :select, :puts]
-		
-	undefine = Kernel.instance_methods + Object.instance_methods + CUSTOM_UNDEFINE
-	BlankSlate.instance_methods.each{|m| undefine.delete m}
-	
-	undefine.each do |m|
-		script = %{\
-def #{m} *p, &b
-	method_missing :#{m}, *p, &b
-end}
-		class_eval script, __FILE__, __LINE__
-	end		
-end

data/old/lib/RubyExt/Resource/file_system_provider.rb

@@ -1,273 +0,0 @@
-module RubyExt
-	class FileSystemProvider
-		attr_accessor :directories
-		
-		def initialize directories = lambda{[File.expand_path('.')]}
-			@directories = directories
-		end
-		
-		def class_get class_name
-			path = real_class_path class_name
-			raise Resource::NotExist unless path
-			
-			if File.directory? path
-				"module #{File.basename(path)}; end;"
-			else
-				File.read path
-			end			
-		end
-		
-		# It updates existing class, if class doesn't exist it creates one in directory provided by filter
-		def class_set class_name, data, directory_for_class_file = nil
-			directory_for_class_file ||= Dir.getwd
-			directory_for_class_file = File.expand_path directory_for_class_file
-			unless @directories.call.include? directory_for_class_file
-				raise "Dirctories should include '#{directory_for_class_file}'!"
-			end
-			
-			path = real_class_path class_name			
-			unless path
-				path = class_to_files(class_name).select{|f| f.include?(directory_for_class_file)}.first
-				dir = path.sub(/\w+\.rb/, "")
-				FileUtils.mkdir dir unless dir.empty? or File.exist? dir			
-			end
-			
-			length = File.write(path, data)
-			FileSystemProvider.remember_file path
-			return length
-		end
-		
-		def class_exist? class_name
-			real_class_path(class_name) != nil
-		end
-		
-		def class_delete class_name
-			path = real_class_path class_name
-			File.delete path if path
-		end
-		
-		#		def class_namespace_exist? namespace_name
-		#			File.exist? class_to_basefile(namespace_name)
-		#		end
-		
-		# First search for "./class_name.resource_name" files
-		# And then search for "./class_name.res/resource_name" files
-		def resource_get class_name, resource_name
-			path = real_resource_path class_name, resource_name
-			raise Resource::NotExist unless path
-			
-			File.read path
-		end
-		
-		def resource_delete class_name, resource_name
-			path = real_resource_path class_name, resource_name
-			File.delete path if path			
-		end
-		
-		# It can only update existing resource, it can't create a new one
-		# First search for the same resource and owerwrites it
-		# If such resource doesn't exists writes to
-		# "./class_name.res/resource_name" file.
-		def resource_set class_name, resource_name, data
-			class_path = real_class_path class_name
-			raise Resource::NotExist unless class_path
-			
-			path = real_resource_path class_name, resource_name
-			unless path
-				class_path = class_path.sub(/\.rb$/, "")
-				dir = "#{class_path}.res"				
-				FileUtils.mkdir dir unless File.exist? dir
-				path = "#{dir}/#{resource_name}"
-			end
-			
-			length =  File.write path, data
-			FileSystemProvider.remember_file path
-			return length
-		end
-		
-		def resource_exist? class_name, resource_name
-			class_path = real_class_path class_name
-			raise Resource::NotExist unless class_path
-			
-			real_resource_path(class_name, resource_name) != nil
-		end						
-		
-		#		def class_to_virtual_path class_name
-		#			result = nil
-		#			if @cache.include? class_name
-		#				result = @cache[class_name]
-		#			else
-		#				result = nil
-		#				path = "#{base_dir}/#{class_name.gsub("::", "/")}"
-		#				if File.exist? path
-		#					result = path
-		#				else
-		#					path2 = "#{path}.rb"
-		#					if File.exist? path2
-		#						result = path
-		#					else
-		#						path3 = "#{path}.res"
-		#						if File.exist? path3
-		#							result = path			
-		#						end
-		#					end				
-		#				end
-		#				@cache[class_name] = result
-		#			end						
-		#			
-		#			if result
-		#				return result
-		#			else
-		#				raise Resource::NotExist, "Class '#{class_name}' doesn't Exist!"
-		#			end
-		#		end
-		
-		# Different Providers can use different class path interpretation.
-		# So we return virtual path only if this path really exist.
-		def class_to_virtual_file class_name
-			path = nil
-			if FileSystemProvider.cache.include? class_name
-				path = FileSystemProvider.cache[class_name]
-			else
-				path = real_class_path class_name								
-				raise Resource::NotExist, "Class '#{class_name}' doesn't Exist!" unless path
-				
-				FileSystemProvider.cache[class_name] = path
-			end						
-			
-			File.expand_path path
-		end
-		
-		# Reloading
-		@files, @cache = {}, {}
-		class << self
-			attr_reader :cache
-			
-			def start_watching interval = 2, directories = Dir.glob("**/lib")
-				stop_watching
-				@watch_thread = Thread.new do					
-					reset_changed_files directories
-					while true
-						sleep interval
-						begin
-							check_for_changed_files(directories).each do |type, klass, res|												
-								Resource.notify_observers :update_resource, type, klass, res
-							end							
-						rescue Exception => e
-							warn e
-						end
-					end
-				end
-			end
-			
-			def stop_watching
-				if @watch_thread
-					@watch_thread.kill
-					@watch_thread = nil
-				end
-			end
-			
-			def remember_file path			
-				@files[path] = File.mtime(path)
-			end
-			
-			protected
-			def check_for_changed_files directories
-				changed = []
-				directories.inject([]){|list, dir| list + Dir.glob("#{dir}/**/**")}.each do |path|
-					if file_changed? path, directories
-						remember_file path
-						changed << file_changed(path, directories)							
-					end
-				end
-				return changed
-			end
-			
-			def reset_changed_files directories
-				@files = {}
-				directories.inject([]){|list, dir| list + Dir.glob("#{dir}/**/**")}.each do |path|
-					remember_file path
-				end
-			end						
-			
-			def file_changed? path, directories
-				old_time = @files[path]
-				old_time == nil or old_time != File.mtime(path)
-			end
-			
-			def file_changed path, directories
-				begin
-					if path =~ /\.rb$/
-						path = path.sub(/\.rb$/, "")
-						class_name = path_to_class(path, directories)
-						
-						# ClassLoader.reload_class()
-						klass = eval class_name, TOPLEVEL_BINDING, __FILE__, __LINE__
-						cache.delete class_name
-						return :class, klass, nil
-					else		
-						if path =~ /\.res/
-							class_path = path.sub(/\.res.+/, "")
-							resource_name3 = path.sub("#{class_path}.res/", "")
-							class_name = path_to_class class_path, directories
-						else
-							resource_name3 = path.sub(/.+\./, "")
-							class_name = path_to_class path.sub(/\.#{resource_name3}$/, ""), directories
-						end			
-						klass = eval class_name, TOPLEVEL_BINDING, __FILE__, __LINE__
-						return :resource, klass, resource_name3
-					end
-				rescue Exception => e
-					warn "Can't reload file '#{path}' #{e.message}!"																				
-				end
-			end
-			
-			def path_to_class path, directories
-				base_dir = directories.select{|f| path.include? f}.max{|a, b| a.size <=> b.size}
-				path.gsub(/^#{base_dir}\//, "").gsub("/", "::")
-			end
-		end
-		
-		protected	
-		def real_class_path class_name
-			path = class_to_files(class_name).find{|f| File.exist? f}
-			path = class_to_basefiles(class_name).find{|f| File.exist? f} unless path			
-			return path
-		end
-		
-		def real_resource_path class_name, resource_name
-			file = class_to_basefiles(class_name).collect{|f| "#{f}.#{resource_name}"}.find{|f| File.exist? f}			
-			file = class_to_basefiles(class_name).collect{|f| "#{f}.res/#{resource_name}"}.find{|f| File.exist? f} unless file
-			return file
-		end
-		
-		def class_to_files class_name						
-			class_to_basefiles(class_name).collect{|name| "#{name}.rb"}
-		end
-		
-		# Different Providers can use different class path interpretation.
-		# So we return virtual path only if this path really exist.
-		def class_to_basefiles class_name
-			relative = class_name.gsub("::", "/")
-			return @directories.call.collect{|dir| "#{dir}/#{relative}"}
-		end		
-		
-		#			Doesn't make Sense for Virtual Resource System
-		#			def resource_path class_name, resource_name
-		#				@monitor.synchronize do
-		#					path = "#{class_to_path(class_name)}.#{resource_name}"
-		#					if File.exist? path
-		#						return path
-		#					else
-		#						path = "#{class_to_path(class_name)}.res/#{resource_name}"
-		#						if File.exist? path
-		#							return path
-		#						else
-		#							nil
-		#						end
-		#					end
-		#				end
-		#			end
-		
-	end
-end

data/old/lib/RubyExt/kernel.rb

@@ -1,3 +0,0 @@
-module Kernel
-	def raise_without_self *args
-end

data/old/lib/RubyExt/module.rb

@@ -1,26 +0,0 @@
-class Module
-  
-  
-  
-  
-  
-  def resource_exist? resource_name		
-    self_ancestors_and_namespaces do |klass|
-      return true if RubyExt::Resource.resource_exist? klass, resource_name					
-    end
-    return false		
-  end
-  
-  def [] resource_name
-    self_ancestors_and_namespaces do |klass|
-      if RubyExt::Resource.resource_exist? klass, resource_name
-        return RubyExt::Resource.resource_get(klass, resource_name)
-      end	
-    end
-    raise RubyExt::Resource::NotExist, "Resource '#{resource_name}' for Class '#{self.name}' doesn't exist!", caller
-  end
-  
-  def []= resource_name, value
-    RubyExt::Resource.resource_set self.name, resource_name, value
-  end    
-end

data/old/lib/RubyExt/observable.rb

@@ -1,25 +0,0 @@
-module RubyExt
-	module Observable								
-		def add_observer observer
-			@observable_observers ||= []
-			@observable_observers << observer unless @observable_observers.include? observer			
-		end
-		
-		def notify_observers method, *args
-			method.should! :be_a, Symbol
-			@observable_observers.each{|observer| observer.respond_to method, *args} if @observable_observers			
-		end
-		
-		def delete_observer observer
-			@observable_observers.delete observer if @observable_observers
-		end
-		
-		def delete_observers			
-			@observable_observers.clear if @observable_observers
-		end
-		
-		def observers_count
-			@observable_observers ? @observable_observers.size : 0
-		end
-	end
-end