RubyExt 0.1.0 → 0.1.1

data/lib/RubyExt/Resource/file_system_provider.rb

@@ -0,0 +1,244 @@
+module RubyExt
+	class FileSystemProvider
+		attr_accessor :directories
+		
+		def initialize directories = lambda{[File.expand_path('.')]}
+			@directories, @files, @cache = 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)
+			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
+			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 check_for_changed_files
+			changed = []
+			v = @directories.call
+			@directories.call.inject([]){|list, dir| list + Dir.glob("#{dir}/**/**")}.each do |path|
+				if file_changed? path
+					remember_file path
+					changed << file_changed(path)							
+				end
+			end
+			return changed
+		end
+		
+		def reset_changed_files
+			@files = {}
+			@directories.call.inject([]){|list, dir| list + Dir.glob("#{dir}/**/**")}.each do |path|
+				remember_file path
+			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 @cache.include? class_name
+				path = @cache[class_name]
+			else
+				path = real_class_path class_name								
+				raise Resource::NotExist, "Class '#{class_name}' doesn't Exist!" unless path
+				
+				@cache[class_name] = path
+			end						
+			
+			File.expand_path path
+		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
+		
+		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
+		
+		def remember_file path
+			@files[path] = File.mtime(path)
+		end
+		
+		def file_changed? path
+			old_time = @files[path]
+			old_time == nil or old_time != File.mtime(path)
+		end
+		
+		def file_changed path
+			begin
+				if path =~ /\.rb$/
+					path = path.sub(/\.rb$/, "")
+					class_name = path_to_class(path)
+					
+					# 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_name = path.sub("#{class_path}.res/", "")
+						class_name = path_to_class class_path
+					else
+						resource_name = path.sub(/.+\./, "")
+						class_name = path_to_class path.sub(/\.#{resource_name}$/, "")
+					end			
+					klass = eval class_name, TOPLEVEL_BINDING, __FILE__, __LINE__
+					return :resource, klass, resource_name			
+				end
+			rescue Exception => e
+				warn "Can't reload file '#{path}' #{e.message}!"																				
+			end
+		end
+		
+		def path_to_class path
+			base_dir = @directories.call.select{|f| path.include? f}.max{|a, b| a.size <=> b.size}
+			path.gsub(/^#{base_dir}\//, "").gsub("/", "::")
+		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/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/lib/RubyExt/Synchronizer.rb

@@ -0,0 +1,29 @@
+module Synchronizer
+	include MonitorMixin
+	
+	module ClassMethods								
+		def synchronize *methods
+			methods.each do |name|							
+				als = (name.to_s =~ /^[_a-zA-Z0-9]+$/) ? name : RubyExt::Cache.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/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/lib/RubyExt/assert.rb

@@ -0,0 +1,111 @@
+class Object
+	def should! cmd, arg = NotDefined
+		result = case cmd								
+			when :be_never_called then false
+			
+			when :be_nil then self.equal? nil		
+			
+			when :be_a
+			if arg.class == Array
+				arg.any?{|klass| self.is_a? klass}
+			else
+				self.is_a? arg
+			end
+			
+			when :be			
+			if arg.class == Array
+				arg.any?{|klass| self.respond_to :is?, klass}
+			else
+				self.respond_to :is?, arg
+			end
+			
+			when :include then self.include? arg
+			
+			when :be_in then arg.include? self
+			
+			when :be_true then self
+			
+		when :be_false then !self
+			
+			when :be_empty then self.empty?
+			
+		else
+			if arg.equal? NotDefined
+				self.send cmd
+			else
+				self.send cmd, arg
+			end						
+		end
+		
+		unless result
+			unless arg.equal? NotDefined
+				raise RuntimeError,  "				
+ASSERTION FAILED:
+#{self.inspect} should #{cmd} #{arg.inspect}
+", caller
+			else
+				raise RuntimeError,  "				
+ASSERTION FAILED:
+#{self.inspect} should #{cmd}
+", caller
+			end
+		end		
+		
+		return self
+	end
+	
+	def should_not! cmd, arg = NotDefined
+		result = case cmd								
+			when :be_never_called then false
+			
+			when :be_nil then self.equal? nil
+			
+			when :be_a
+			if arg.class == Array
+				arg.any?{|klass| self.is_a? klass}
+			else
+				self.is_a? arg
+			end
+			
+			when :be			
+			if arg.class == Array
+				arg.any?{|klass| self.respond_to :is?, klass}
+			else
+				self.respond_to :is?, arg
+			end
+			
+			when :include then self.include? arg
+			
+			when :be_in then arg.include? self
+			
+			when :be_true then self
+			
+		when :be_false then !self
+			
+			when :be_empty then self.empty?
+			
+		else
+			if arg.equal? NotDefined
+				self.send cmd
+			else
+				self.send cmd, arg
+			end						
+		end
+		
+		if result
+			unless arg.equal? NotDefined
+				raise RuntimeError,  "				
+ASSERTION FAILED:
+#{self.inspect} should not #{cmd} #{arg.inspect}
+", caller
+			else
+				raise RuntimeError,  "				
+ASSERTION FAILED:
+#{self.inspect} should not #{cmd}
+", caller
+			end
+		end
+		
+		return self
+	end
+end

data/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/lib/RubyExt/false_class.rb

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

data/lib/RubyExt/file.rb

@@ -0,0 +1,23 @@
+class File
+	class << self
+		def write(path, data)
+			File.open(path, "wb") do |file|
+				return file.write(data)
+			end
+		end
+		
+		def read(path)
+			File.open(path, "rb") do |file|
+				return file.read
+			end
+		end
+		
+		def create_directory dir
+			Dir.mkdir dir unless File.exist? dir
+		end
+		
+		def delete_directory dir
+			FileUtils.rm_r dir, :force => true if File.exist? dir
+		end
+	end
+end

data/lib/RubyExt/ideas.txt

@@ -0,0 +1,17 @@
+CRITICAL
+- Reloading resourses in ClassXXX.res folder doesn't works.
+- Change 'raise_without_self' to caller.delete(SomePackage)
+
+MEDIUM
+	 
+LOW
+- Add macros functionality to Ruby. (for example replace all '!=' with 'not_equal')
+- Create project 'Flawless Ruby' (macros != to not_equal, and so on)
+- Automatically evaluate extension for resources, use Class["res"] instead of Class["res.yaml"]
+
+DONE
+- Add resource providers chaining.
+- Resource providers should be abstract (also for ObjectModel storage).
+- Cashe implementation    
+- Resource reloading doesn't works (fix and add spec).
+- Add raise_withoud_self 'bla-bla', [excludeAclass, excludeBclass]