ruby-ext 0.2.2 → 0.2.3

data/old/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/old/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/old/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/old/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
+DeclarativeCache.cached_with_params :class, Module, :localization

data/old/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.interpolate binding if binding
+		return string
+	end
+end

data/old/lib/RubyExt/Localization/require.rb

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

data/old/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/old/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/old/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/old/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