RubyExt 0.1.0 → 0.1.1

data/lib/RubyExt/Cache.rb

@@ -0,0 +1,101 @@
+module Cache		
+	DISABLED = false
+	
+	warn "CASHE DISABLED" if DISABLED 
+	
+	# It's not a good idea to mix Business Logic and Performance optimization, 
+	# so i think these methods should be never used.
+	#	def cached *methods
+	#		Cache.cached self, *methods
+	#	end	
+	#	
+	#	def cached_with_params *methods
+	#		Cache.cached_with_params self, *methods
+	#	end
+	
+	@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 cached *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 : RubyExt::Cache.alias_counter.to_sym 
+				
+				klass.class_eval{alias_method :"cached_#{als}", :"#{m}"}
+				unless vnames.is_a? Array
+					script = Cache["single_version_without_args.txt"].substitute binding					
+					@versions[vnames] = 0 unless @versions.include? vnames
+				else
+					vnames_str = vnames.collect{|vname| "'#{vname}' => nil"}.join(', ')
+					script = Cache["multiple_version_without_args.txt"].substitute binding
+					vnames.each{|vname| @versions[vname] = 0 unless @versions.include? vname}
+				end
+				klass.class_eval script, __FILE__, __LINE__								
+			end			
+		end
+		
+		def cached_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 : RubyExt::Cache.alias_counter
+				
+				klass.class_eval{alias_method :"cached_#{als}", :"#{m}"}
+				unless vnames.is_a? Array
+					script = Cache["single_version_with_args.txt"].substitute binding					
+					@versions[vnames] = 0 unless @versions.include? vnames
+				else
+					vnames_str = vnames.collect{|vname| "'#{vname}' => nil"}.join(', ')
+					script = Cache["multiple_version_with_args.txt"].substitute 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! :>=, 3
+			
+			version_names = arg[0]
+			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[1]
+			klass.class.should! :be, [Class, Module]
+			
+			methods = arg[2..arg.size]			
+			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		
+	end
+end

data/lib/RubyExt/Cache.res/multiple_version_with_args.txt

@@ -0,0 +1,12 @@
+def #{m} *params
+	Cache.monitor.synchronize do
+		@cache_versions_#{als} ||= {#{vnames_str}}
+		@cache_value_#{als} ||= {}
+		if @cache_versions_#{als}.all?{|vname, v| v == RubyExt::Cache.version(vname)} and @cache_value_#{als}.include?(params) 
+			return @cache_value_#{als}[params]
+		else
+			@cache_versions_#{als}.keys.each{|vname| @cache_versions_#{als}[vname] = RubyExt::Cache.version(vname)}
+			return @cache_value_#{als}[params] = cached_#{als}(*params)
+		end		
+	end
+end

data/lib/RubyExt/Cache.res/multiple_version_without_args.txt

@@ -0,0 +1,11 @@
+def #{m}
+	Cache.monitor.synchronize do
+		@cache_versions_#{als} ||= {#{vnames_str}}
+		if @cache_versions_#{als}.all?{|vname, v| v == RubyExt::Cache.version(vname)}
+			return @cache_value_#{als}
+		else
+			@cache_versions_#{als}.keys.each{|vname| @cache_versions_#{als}[vname] = RubyExt::Cache.version(vname)}
+			return @cache_value_#{als} = cached_#{als}
+		end		
+	end
+end

data/lib/RubyExt/Cache.res/single_version_with_args.txt

@@ -0,0 +1,11 @@
+def #{m} *params
+	Cache.monitor.synchronize do
+		@cache_value_#{als} ||= {}
+		if @cache_version_#{als} == RubyExt::Cache.version("#{vnames}") and @cache_value_#{als}.include?(params) 
+			return @cache_value_#{als}[params]
+		else
+			@cache_version_#{als} = RubyExt::Cache.version("#{vnames}")
+			return @cache_value_#{als}[params] = cached_#{als}(*params)
+		end		
+	end
+end

data/lib/RubyExt/Cache.res/single_version_without_args.txt

@@ -0,0 +1,10 @@
+def #{m}
+	Cache.monitor.synchronize do
+		if @cache_version_#{als} == RubyExt::Cache.version("#{vnames}")
+			return @cache_value_#{als}
+		else
+			@cache_version_#{als} = RubyExt::Cache.version("#{vnames}")
+			return @cache_value_#{als} = cached_#{als}
+		end		
+	end
+end

data/lib/RubyExt/ClassLoader.rb

@@ -0,0 +1,142 @@
+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/lib/RubyExt/Debug.rb

@@ -0,0 +1,24 @@
+class Debug
+	class << self
+		
+		def trace_methods klass
+			klass.instance_methods(false).each do |m|
+				klass.class_eval do		
+					alias_method :"old_#{m}", m		
+					define_method m.to_sym do |*args|
+						begin
+							time = Time.now
+							p [m.to_sym, :start]
+							result = send :"old_#{m}", *args							
+						ensure
+							p [m.to_sym, :end, time - Time.now]
+						end
+						return result
+					end
+				end
+			end
+		end
+		
+		
+	end
+end

data/lib/RubyExt/ExtraBlankSlate.rb

@@ -0,0 +1,14 @@
+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/lib/RubyExt/ImportAll.rb

@@ -0,0 +1,9 @@
+module ImportAll
+	def import_all *params
+		params.each do |m|
+			m.constants.each do |name|
+				const_set name, m.const_get(name)
+			end
+		end
+	end
+end

data/lib/RubyExt/Localization/Module.rb

@@ -0,0 +1,12 @@
+class Module	
+  def localization lang
+    list, resource = [], "#{lang}.#{RubyExt::Localization::RESOURCE_EXTENSION}"
+    self_ancestors_and_namespaces do |klass|
+    	if RubyExt::Resource.resource_exist? klass, resource
+				list << RubyExt::Resource.resource_get(klass, resource)
+			end
+    end
+    return list.reverse.inject(:merge)
+  end
+end
+Cache.cached_with_params :class, Module, :localization

data/lib/RubyExt/Localization/Object.rb

@@ -0,0 +1,19 @@
+class Object
+	def to_l string, binding = nil
+		lang = RubyExt::Localization.language
+		unless lang == RubyExt::Localization::DEFAULT_LANGUAGE
+			aself = self.respond_to(:localization_self) || self
+			aclass = (aself.class == Class or aself.class == Module) ? aself : aself.class						
+			
+			localization = aclass.localization lang
+			if localization and localization.include? string
+				string = localization[string]
+			else				
+				RubyExt::Localization.log.warn("Not localized: '#{aclass.name}' '#{string}'!")
+			end		
+		end
+		
+		string = string.substitute binding if binding
+		return string
+	end
+end

data/lib/RubyExt/Localization/require.rb

@@ -0,0 +1,3 @@
+require 'RubyExt/require'
+require 'RubyExt/Localization/Module'
+require 'RubyExt/Localization/Object'

data/lib/RubyExt/Localization.rb

@@ -0,0 +1,28 @@
+module Localization
+  extend Log
+	DEFAULT_LANGUAGE = :en
+  RESOURCE_EXTENSION = "localization.yaml"
+
+  class << self
+    def default_language= lang
+      @default_language = lang
+    end
+
+    def default_language
+      @default_language ||= DEFAULT_LANGUAGE
+    end
+
+    def language= block
+      @language = block
+    end
+
+    def language
+      if @language
+				lang = @language.call
+				return lang || default_language
+			else
+				return default_language
+			end
+    end
+  end
+end

data/lib/RubyExt/Log.config.sample

@@ -0,0 +1,57 @@
+<log4r_config>
+  <pre_config>
+    <global level="DEBUG"/>
+    
+    <parameter name="serverlog" value="./logs/server.log"/>
+  </pre_config>
+
+  
+  <outputter type="FileOutputter" name="server">
+    <filename>#{serverlog}</filename>
+    <trunc>false</trunc>
+  </outputter>
+  <outputter type="FileOutputter" name="client" 
+             filename="./../logs/client.log"/>
+  <outputter type="FileOutputter" name="gui" 
+             filename="./../logs/guidebug.log"/>
+  <outputter type="StderrOutputter" name="console" level="ERROR"/>
+
+  <logger name="server" level="ERROR" outputters="server, console"/>
+  <logger name="client" level="INFO"  outputters="client, console"/>
+  <logger name="client::gui" trace="true">
+    <level>DEBUG</level>
+    <outputter>gui</outputter>
+  </logger>
+
+</log4r_config> 
+
+
+
+
+<log4r_config>
+	<pre_config>
+		<global level="ALL"/>
+	</pre_config>
+	
+	<outputter type="StderrOutputter" name="default" level="ALL"/>
+	<logger name="Default" level="ALL" outputters="default"/>
+	
+	<outputter type="StderrOutputter" name="console" level="WARN"/>
+	<outputter type="StderrOutputter" name="console_all" level="ALL"/>
+	<outputter type="FileOutputter" name="microcontainer" filename="./../logs/microcontainer.log"/>
+	<outputter type="FileOutputter" name="rubyext" filename="./../logs/rubyext.log"/>
+	<outputter type="FileOutputter" name="wgui" filename="./../logs/wgui.log"/>
+	<outputter type="FileOutputter" name="howt" filename="./../logs/howt.log"/>
+	<outputter type="FileOutputter" name="log" filename="./../logs/log.log"/>
+	<outputter type="FileOutputter" name="localization" filename="./../logs/localization.log"/>
+	<outputter type="FileOutputter" name="object_model" filename="./../logs/object_model.log" level="ALL"/>
+	
+	<logger name="MicroContainer" level="ALL" outputters="console, microcontainer"/>
+	<logger name="HOWT" level="ALL" outputters="console, howt"/>
+	<logger name="WGUI" level="ALL" outputters="console, wgui"/>
+	<logger name="RubyExt" level="ALL" outputters="console, rubyext"/>
+	<logger name="Localization" level="ALL" outputters="localization"/>
+	<logger name="Log" level="ALL" outputters="console, log"/>
+	<logger name="ClassLoader" level="ALL" outputters="console_all"/>
+	<logger name="ObjectModel" level="ALL" outputters="object_model, console_all"/>
+</log4r_config> 

data/lib/RubyExt/Log.rb

@@ -0,0 +1,59 @@
+require 'log4r'
+require 'log4r/configurator'
+
+module Log
+	@loggers = Hash.new do |hash, klass|
+		# Such complex initialization because I don't know how it exactly work.
+		# For example: Log.new for WGUI::SomeClass will works, but Log.new for WGUI will not.
+		logger = begin
+			Log4r::Logger.get(klass.name) 				
+		rescue 
+			Log4r::Logger.new(klass.name) rescue Log4r::Logger.get("Default")
+		end
+		hash[klass] = logger
+	end
+	
+	module ClassMethods
+		def log		
+			Log.loggers[(self.class == Class or self.class == Module) ? self : self.class]
+		end						
+	end
+	
+	def log
+		Log.loggers[(self.class == Class or self.class == Module) ? self : self.class]
+	end				
+	
+	class << self
+		attr_reader :loggers
+		
+		def info *s
+			log.info *s
+		end
+		
+		def error *s
+			log.error *s
+		end
+		
+		def warn *s
+			log.warn *s
+		end
+		
+		def log
+			Log.loggers[Log]
+		end				
+	end
+	#	configure %{\
+	#<log4r_config>
+	#	<pre_config>
+	#		<global level="ALL"/>
+	#	</pre_config>
+	#
+	#	<outputter type="StderrOutputter" name="default" level="ALL"/>
+	#	<logger name="Default" level="ALL" outputters="default"/>
+	#</log4r_config>}
+end
+
+module Log
+	config = Dir.getwd + "config/log.xml" 
+	Log4r::Configurator.load_xml_string(File.read(config)) if File.exist? config
+end

data/lib/RubyExt/OpenConstructor.rb

@@ -0,0 +1,51 @@
+module OpenConstructor
+	def set values, list = nil
+		unless list
+			if values.is_a? Hash
+				values.each do |k, v|					
+					self.respond_to k.to_writer, v
+				end
+			else
+				values.instance_variables.each do |name|
+					accessor = name[1..name.size].to_writer
+					if self.respond_to? accessor
+						self.send accessor, values.instance_variable_get(name)
+					end
+				end
+			end
+		else
+			if values.is_a? Hash
+				values.each do |k, v|					
+					self.respond_to k.to_writer, v if list.include? k
+				end
+			else
+				values.instance_variables.each do |name|
+					accessor = name[1..name.size]
+					if list.include?(accessor.to_sym) 
+						accessor = accessor.to_writer
+						if self.respond_to?(accessor)
+							self.send accessor, values.instance_variable_get(name)
+						end
+					end
+				end
+			end						
+		end
+		return self		
+	end 
+	
+	def set_with_check values
+		values.each do |k, v|
+			self.send k.to_writer, v			
+		end
+		return self
+	end
+	alias_method :set!, :set_with_check
+	
+	def to_hash
+		hash = {}
+		instance_variables.each do |name|
+			hash[name[1..name.size].to_sym] = instance_variable_get name
+		end
+		return hash
+	end
+end

data/lib/RubyExt/Path.rb

@@ -0,0 +1,91 @@
+class Path < String
+	def initialize path = ''
+		super path.chomp
+		raise "Invalid Path '#{path}' (ends with the '/' sign)" if (self =~ /\/$/ ) && !empty?
+		raise "Tnvalid Path '#{path}' (the '/' sign encounters multiple times in a row)" if self =~ /\/{2,}/
+	end
+
+	def absolute?;
+		(self =~ /^\//) ? true : false
+	end
+	
+	def relative?;
+		!absolute?
+	end
+
+	def empty?; self == '' || self == '/' end
+
+	def simple?;
+		self =~ /^\/?[^\/]*$/ ? true : false
+	end
+
+	def after part
+		raise "There is no Part '#{part}' in the Path '#{self}'" unless include? part
+		Path.new((absolute? ? '/' : '') + sub(/.*#{part}\/*/, ""))
+	end
+
+	def before part
+		raise "There is no Part '#{part}' in the Path '#{self}'" unless include? part
+		Path.new((absolute? ? '/' : '') + to_relative.sub(/\/*#{part}.*/, ""))
+	end
+
+	def previous;
+		return nil if empty?
+		p = sub(/[^\/]+?$/, "" )
+		p = p[0..p.string_size-2] if p.string_size > 1
+		return p
+	end
+
+	def next;
+		p = sub(/[^\/]+\/?/, "")
+		return p.empty? ? nil : p
+	end
+
+	def first;
+		Path.new(scan(/^\/?[^\/]*/)[0])
+	end
+
+	def last;
+		Path.new(sub(/[^\/].+\//, ""))
+	end
+
+	def last_name
+		list = scan(/[^\/]+$/)
+		return list.size > 0 ? list[0] : nil
+	end
+
+	def first_name
+		list = scan(/[^\/]+/)
+		return list.size > 0 ? list[0] : nil
+	end
+
+	def add path
+		path = Path.new(path) unless path.is_a? Path
+		return Path.new((absolute? ? "/" : "") + path.to_relative) if empty?
+		return Path.new(self) if path.empty?
+		return Path.new(self.string_plus((path.absolute? ? '' : '/')) + path)
+	end
+
+	alias_method :string_plus, :+
+		def + o
+		add(o)
+	end
+
+	def to_absolute; Path.new(absolute? ? self : "/#{self}") end
+
+	def to_relative; Path.new sub(/^\//, "") end
+
+	alias_method :string_each, :each
+	def each &block
+		to_a.each(&block)
+	end
+
+	alias_method :string_size, :size
+	def size() to_a.size end
+
+	def to_a; @elements ||= to_relative.split('/') end
+
+	def to_s
+		return String.new(self)
+	end
+end