ruby-ext 0.2.2 → 0.2.3

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

@@ -0,0 +1,273 @@
+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/StateMashine.rb

@@ -0,0 +1,176 @@
+class StateMashine
+  attr_accessor :object
+  
+  def initialize object = nil;
+    @object = object
+    @on_entry, @on_exit, @on_event = {}, {}, {}
+    
+    @custom_states = {}
+    if self.class.custom_state_get
+      self.class.custom_state_get.each do |state, klass|
+        @custom_states[state] = klass.new
+      end    
+    end
+    
+    is = self.class.initial_state_get
+    raise_without_self "Initial State not defined!" unless is    
+    fire_action @on_entry[is]            
+    @state = is
+  end
+  
+  def on_entry state, method = nil, &b
+    if method or b
+      @on_entry[state] = method || b
+    else
+      @on_entry.delete state
+    end
+  end
+  
+  def on_event from, event, method = nil, &b
+    if method or b
+      @on_event[from + event] = method || b
+    else      
+      @on_event.delete from + event
+    end
+  end  
+  
+  def on_exit state, method = nil, &b
+    if method or b
+      @on_exit[state] = method || b
+    else
+      @on_exit.delete state
+    end
+  end
+  
+  def event event        
+    custom_state = @custom_states[state]
+    
+    to = if custom_state
+      begin
+        custom_state.send event
+      rescue NoMethodError
+        raise_without_self "There is no :#{event} Event in :#{state} State!"
+      end
+    else
+      actions = self.class.from_actions[state]
+      raise_without_self "There is no :#{event} Event in :#{state} State!" unless actions
+      actions[event]      
+    end
+    raise_without_self "There is no :#{event} Event in :#{state} State!" unless to
+    
+    #    p [state, event, to]
+    
+    old_state = state
+    
+    @state = to
+    
+    begin
+      fire_action @on_exit[old_state]
+      fire_action @on_event[old_state + event] 
+      fire_action @on_entry[to]                      
+    rescue Exception => e
+      @state = old_state
+      raise e
+    end
+  end    
+  
+  def state; @state end
+  
+  def state= new_state
+    custom_state = @custom_states[state]
+    
+    event = if custom_state
+      begin
+        custom_state.state new_state
+      rescue Exception => e
+        raise e
+      end
+    else
+      states = self.class.from_states[state]
+      raise_without_self "There is no way from :#{state} State into :#{new_state} State!" unless states
+      states[new_state]      
+    end
+    raise_without_self "There is no way from :#{state} State into :#{new_state} State!" unless event
+    
+    old_state = state
+    
+    @state = new_state
+    
+    begin
+      fire_action @on_exit[old_state]
+      fire_action @on_event[old_state + event] 
+      fire_action @on_entry[new_state]        
+    rescue Exception => e
+      @state = old_state
+      raise e
+    end
+  end
+  
+  def == other
+    return true if equal? other
+    return state == other if other.is_a? Symbol
+    return state == other.state if other.is_a? StateMashine
+    return false
+  end
+  
+  def hash
+    state.hash
+  end
+  
+  def eql? other
+    return true if equal? other
+    return state == other.state if other.is_a? StateMashine
+    return false
+  end
+  
+  class << self
+    def from_actions; @from_actions end
+    def from_states; @from_states end      
+    def initial_state_get; @initial_state end    
+    def custom_state_get; @custom_state end
+    
+    def transitions *args
+      @from_actions, @from_states = {}, {}
+      args.each do |from, action, to|        
+        actions = @from_actions[from]
+        unless actions
+          actions = {}
+          @from_actions[from] = actions
+        end        
+        actions[action] = to
+        
+        states = @from_states[from]
+        unless states
+          states = {}
+          @from_states[from] = states
+        end        
+        states[to] = action
+      end
+    end
+    
+    def custom_state state, klass; 
+      @custom_state ||= {}
+      @custom_state[state] = klass
+    end
+    
+    def initial_state state; @initial_state = state end
+  end
+  
+  def to_s
+    "#<#{self.class.name} state = :#{state}"
+  end
+  
+  def inspect
+    to_s
+  end
+  
+  protected
+  def fire_action a
+    return unless a
+    if a.is_a? Symbol
+      @object.send a if @object
+    else
+      a.call
+    end
+  end
+end

data/old/lib/RubyExt/array.rb

@@ -0,0 +1,24 @@
+class Array
+	def sort_by_weight weight
+		clone.sort_by_weight! weight.clone		
+	end
+	
+	def sort_by_weight! weight
+		size.times do |i|
+			iteration = size - i - 1
+			break if iteration < 0
+			iteration.times do |j|
+				if weight[j] > weight[j+1]
+					buf = self[j]
+					self[j] = self[j+1]
+					self[j+1] = buf
+					
+					buf = weight[j]
+					weight[j] = weight[j+1]
+					weight[j+1] = buf
+				end
+			end
+		end
+		return self
+	end
+end

data/old/lib/RubyExt/debug.rb

@@ -0,0 +1,71 @@
+$debug = true
+if $debug
+	warn 'DEBUG MODE'
+	
+	#require 'ruby-debug'
+	
+	Thread.abort_on_exception = true
+	
+	RubyExt::ClassLoader.error_on_defined_constant = true
+	
+	module Kernel
+		STACK_TRACE_EXCLUDE = [
+		/\/rspec/, 
+		/\/ruby-debug/, 
+		/\/monitor.rb/, 
+		/\/timeout.rb/,
+#				/gems/, 
+		#		/WGUI/,
+		/\/MicroContainer/,
+		/\/RubyExt/,
+		/\/kernel.rb/,
+		/\/mongrel/,
+		/\/rack/,
+		/\/sync/,
+		/\/require/,
+		/\/site_ruby/,
+		/OpenConstructor/,
+		]
+		
+		alias_method :old_caller, :caller
+		def caller int = 0
+			stack = old_caller  
+			stack = stack[(int+1)..stack.size].delete_if do |line|
+				STACK_TRACE_EXCLUDE.any?{|re| line =~ re}
+			end
+			return stack
+		end
+		
+		def where?
+			puts "\nwhere:"
+			puts caller
+		end
+		
+#		alias_method :old_raise, :raise
+#		def raise *p
+#			case p.size
+#				when 3
+#				e, m, c = p
+#				when 2
+#				e, m = p
+#				c = caller
+#				when 1					
+#				if p[0].is_a? Exception
+#					e = p[0].class
+#					m = p[0].message					
+#				else
+#					e = RuntimeError
+#					m = p[0]				
+#				end
+#				c = caller
+#				when 0
+#				e, m, c = RuntimeError, "", caller
+#			else 
+#				old_raise "Invalid Usage!"
+#			end
+#			old_raise e, m, c
+#		end
+	end				
+end
+#def p; end
+#def puts; end

data/old/lib/RubyExt/false_class.rb

@@ -0,0 +1,5 @@
+class FalseClass
+	def copy
+		false
+	end
+end

data/old/lib/RubyExt/kernel.rb

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

data/old/lib/RubyExt/module.rb

@@ -0,0 +1,26 @@
+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/nil_class.rb

@@ -0,0 +1,5 @@
+class NilClass
+#	def copy
+#		nil
+#	end
+end

data/old/lib/RubyExt/observable.rb

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

data/old/lib/RubyExt/require.rb

@@ -0,0 +1 @@
+require 'RubyExt/_require'

data/old/lib/RubyExt/require_base.rb

@@ -0,0 +1 @@
+require 'RubyExt/_require_base'