ruby-ext 0.2.16 → 0.4.0

data/lib/ruby_ext/observable2.rb

@@ -0,0 +1,23 @@
+module Observable2
+  def add_observer observer
+    @observable_observers ||= []
+    @observable_observers << observer unless @observable_observers.include? observer      
+  end
+  
+  def notify_observers method, *args
+    raise "Invalid usage, method must be Symbol or String!" unless method.is_a?(Symbol) or method.is_a?(String)
+    @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

data/lib/ruby_ext/open_constructor.rb

@@ -1,51 +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
+  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/ruby_ext/prepare_arguments.rb

@@ -3,7 +3,7 @@ class ArgumentsParser
     def register method, arguments
       # check and prepare metadata
       arguments.collect!{|meta| meta.is_a?(Hash) ? meta : {:type => meta}}
-      arguments.each{|meta| meta.should! :include, :type}
+      arguments.each{|meta| meta.must.include :type}
       
       # register
       @registry ||= {}
@@ -16,7 +16,7 @@ class ArgumentsParser
       parsed_args = metadata.collect do |options| 
         send options[:type], args, block, options, index, (index == metadata.size - 1)
       end
-      args.should_be! :empty
+      args.must_be.empty
       return parsed_args
     end
     
@@ -34,7 +34,7 @@ class ArgumentsParser
             args.shift
           end
         else
-          should! :be_never_called
+          must_be.never_called
         end
       else
         args.shift
@@ -59,7 +59,7 @@ class ArgumentsParser
             tmp
           end
         else
-          should! :be_never_called
+          must_be.never_called
         end
       else
         args.shift
@@ -73,12 +73,12 @@ class ArgumentsParser
 
     def hash args, block, options, index, last
       a = object(args, block, options, index, last) || {}
-      a.should! :be_a, Hash
+      a.must_be.a Hash
       a
     end
     
     def _common_options a, options
-      a.should_not! :be_nil if options[:require]
+      a.must_not_be.nil if options[:require]
       if (default = options[:default]) and a.eql?(nil)
         a = default
       end

data/lib/ruby_ext/string.rb

@@ -1,18 +1,18 @@
 String.class_eval do
-	def to_reader
-		self.to_sym
-	end
-	
-	def to_writer
-		"#{self}=".to_sym
-	end
-	
-	def to_iv
-		"@#{self}"
-	end
-	
+  def to_reader
+    self.to_sym
+  end
+  
+  def to_writer
+    "#{self}=".to_sym
+  end
+  
+  def to_iv
+    "@#{self}"
+  end
+  
   def interpolate binding
-    binding.should! :be_a, Binding
+    binding.must_be.a Binding
     return gsub(/\#\{.+?\}/) do |term|
       identifier = term.slice(2 .. term.size-2)
       binding.eval identifier
@@ -23,4 +23,14 @@ String.class_eval do
     original = [Time.now, (1..10).map{ rand.to_s }]
     Digest::SHA1.hexdigest(original.flatten.join('--'))
   end
+  
+  def underscore
+    word = self.dup
+    word.gsub!(/::/, '/')
+    word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+    word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+    word.tr!("-", "_")
+    word.downcase!
+    word
+  end
 end

data/lib/ruby_ext/symbol.rb

@@ -8,12 +8,12 @@ Symbol.class_eval do
   end
   
   def to_writer
-		"#{self}=".to_sym
-	end
+    "#{self}=".to_sym
+  end
  
- 	def to_iv
-		"@#{self}"
-	end
+   def to_iv
+    "@#{self}"
+  end
 
   def + other
     (self.to_s + other.to_s).to_sym

data/lib/ruby_ext/synchronize.rb

@@ -0,0 +1,24 @@
+require 'monitor'
+
+class Module
+  def synchronize_method *methods
+    methods.each do |method|              
+      als = "sync_#{escape_method(method)}"
+      
+      raise "Can't synchronize the '#{method}' twice!" if instance_methods.include?(als)
+      
+      alias_method als, method
+      script = "\
+def #{method} *p, &b
+  @monitor ||= Monitor.new
+  @monitor.synchronize{#{als} *p, &b}
+end"
+      class_eval script, __FILE__, __LINE__
+    end
+  end
+  
+  def synchronize_all_methods include_super = false
+    methods = self.instance_methods(include_super).collect{|m| m.to_sym}
+    synchronize_method *methods
+  end
+end

data/lib/ruby_ext.rb

@@ -1,15 +1,15 @@
 core = [
-	'facets/array/indexable', # Array first!, last!
-	'facets/enumerable/every',
-	'facets/enumerable/group_by',
-	'facets/exception/detail', # pretty print
-	'facets/duplicable', # false.dup(), false.clone() and so on.
-	'facets/blank',
-	'facets/numeric/round.rb', # round_at, round_to
-	'facets/hash',
-	'facets/string/interpolate',
-	'facets/ostruct',
-	'facets/openobject'
+  'facets/array/indexable', # Array first!, last!
+  'facets/enumerable/every',
+  'facets/enumerable/group_by',
+  'facets/exception/detail', # pretty print
+  'facets/duplicable', # false.dup(), false.clone() and so on.
+  'facets/blank',
+  'facets/numeric/round.rb', # round_at, round_to
+  'facets/hash',
+  'facets/string/interpolate',
+  'facets/ostruct',
+  'facets/openobject'
 ]
 
 more = [
@@ -29,11 +29,11 @@ more = [
   string
   symbol
   
-  should
+  extra_blank_slate
   declarative_cache
+  must
+  observable2
   open_constructor
-  prepare_arguments
-  synchronizer
-}.each do |f|
-  require "#{File.dirname __FILE__}/ruby_ext/#{f}"
-end
+  prepare_arguments  
+  synchronize
+}.each{|f| require "ruby_ext/#{f}"}

data/lib/vresource/class_loader.rb

@@ -0,0 +1,150 @@
+module VResource
+  module ClassLoader
+    class << self
+      include Observable2
+      
+      attr_accessor :error_on_defined_constant
+      def loaded_classes; @loaded_classes ||= {} end
+      
+      def reload_class class_name
+        class_name = class_name.sub(/^::/, "")
+        namespace = Module.namespace_for(class_name);
+        name = class_name.sub(/^#{namespace}::/, "")
+        return load_class namespace, name, true
+      end
+      synchronize_method :reload_class
+      
+      
+      def load_class namespace, const, reload = false            
+        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)            
+            
+            unless defined_in_home_scope
+              msg = "Class Name '#{class_name}' doesn't correspond to File Name '#{VResource.class_to_virtual_file(class_name)}'!"
+              raise_without_self NameError, msg, ClassLoader
+            end
+                          
+            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
+      synchronize_method :load_class
+        
+      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
+      
+      def hook!
+        unless @hooked          
+          ::Module.class_eval do
+            alias_method :cl_const_missing, :const_missing
+            def const_missing const
+              return VResource::ClassLoader.load_class self, const.to_s
+            end
+          end
+          @hooked = true
+        end
+      end
+      
+      def unhook!
+        if @hooked
+          ::Module.class_eval do
+            alias_method :const_missing, :cl_const_missing
+          end
+          @hooked = false
+        end
+      end
+      
+      protected
+      
+        def try_load class_name, const                    
+          if VResource.class_exist? class_name
+            script = VResource.class_get class_name
+            script = wrap_inside_namespace Module.namespace_for(class_name), script
+            eval script, TOPLEVEL_BINDING, VResource.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

data/lib/vresource/file_system_provider.rb

@@ -0,0 +1,181 @@
+module VResource
+  class FileSystemProvider
+    attr_accessor :directories
+    
+    def initialize directories = File.expand_path('.')
+      @directories = Array(directories).collect{|path| File.expand_path path}
+    end
+    
+    def class_get class_name
+      path = ensure_exist!(real_class_path(class_name))
+      
+      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.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
+      
+      reloader.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 = ensure_exist!(real_resource_path(class_name, resource_name))
+      
+      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 = ensure_exist!(real_class_path(class_name))
+      
+      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
+      reloader.remember_file path
+      return length
+    end
+    
+    def resource_exist? class_name, resource_name
+      class_path = ensure_exist!(real_class_path(class_name))
+      
+      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 = ensure_exist!(real_class_path(class_name), "Class '#{class_name}' doesn't Exist!")      
+      File.expand_path path
+    end
+    cache_method_with_params :class_to_virtual_file
+    
+    def reloader
+      @reloader ||= FileSystemReloader.new directories
+    end
+    
+    protected  
+      def ensure_exist! path, msg = ""
+        raise VResource::NotExist, msg unless path
+        path
+      end
+    
+      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}
+        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}
+        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.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