ruby-ext 0.2.16 → 0.4.0

data/lib/vresource/file_system_reloader.rb

@@ -0,0 +1,106 @@
+module VResource
+  class FileSystemReloader
+    attr_accessor :directories, :interval
+    
+    def initialize directories = Dir.glob("**/lib"), interval = 2
+      @files = {}
+      self.directories, self.interval = directories, interval      
+    end
+    
+    def start
+      self.thread = Thread.new do        
+        while true
+          sleep interval
+          check
+        end
+      end
+    end
+
+    def stop
+      if thread
+        thread.kill
+        self.thread = nil
+      end
+    end
+
+    def remember_file path
+      @files[path] = File.mtime(path)
+    end
+    
+    def check
+      reset if @files.empty?
+      
+      begin
+        check_for_changed_files.each do |type, klass, res|                        
+          VResource.notify_observers :update_resource, type, klass, res
+        end              
+      rescue Exception => e
+        warn e
+      end
+    end
+    
+    def reset
+      @files = {}
+      all_files.each do |path|
+        remember_file path
+      end
+    end
+    
+    protected
+      def all_files
+        directories.inject([]){|list, dir| list + Dir.glob("#{dir}/**/**")}.select{|f| !File.directory?(f)}
+      end
+    
+      def check_for_changed_files        
+        changed = []
+        all_files.each do |path|
+          if file_changed? path
+            remember_file path
+            changed << file_changed(path)              
+          end
+        end
+        return changed
+      end
+    
+      def file_changed? path        
+        old_time = @files[path]
+        
+        # p [old_time, File.mtime(path), path] if old_time != File.mtime(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.select{|f| path.include? f}.max{|a, b| a.size <=> b.size}
+        path.gsub(/^#{base_dir}\//, "").gsub("/", "::")
+      end
+  end
+end

data/lib/vresource/module.rb

@@ -0,0 +1,24 @@
+class Module
+  # TODO2 Cache it and next one
+  def resource_exist? resource_name    
+    self_ancestors_and_namespaces do |klass|
+      return true if VResource.resource_exist? klass, resource_name          
+    end
+    return false
+  end  
+  cache_method_with_params :resource_exist?
+  
+  def [] resource_name
+    self_ancestors_and_namespaces do |klass|
+      if VResource.resource_exist? klass, resource_name
+        return VResource.resource_get(klass, resource_name)
+      end  
+    end
+    raise VResource::NotExist, "Resource '#{resource_name}' for Class '#{self.name}' doesn't exist!", caller
+  end
+  cache_method_with_params :[]
+  
+  def []= resource_name, value
+    VResource.resource_set self.name, resource_name, value
+  end    
+end

data/lib/vresource/resource_extensions.rb

@@ -0,0 +1,14 @@
+VResource.register_resource_extension(
+  ".yaml",
+  lambda{|data, klass, name| YAML.load(data)}, 
+  lambda{|data, klass, name| YAML.dump(data)}
+)
+
+VResource.register_resource_extension(
+  ".rb",
+  lambda{|data, klass, name|
+    script = ClassLoader.wrap_inside_namespace(klass, data)
+    eval script, TOPLEVEL_BINDING, "#{klass.name}/#{name}"
+  }, 
+  lambda{|data, klass, name| raise "Writing '.rb' Resource isn't supported!"}
+)

data/lib/vresource/vresource.rb

@@ -0,0 +1,153 @@
+module VResource      
+  
+  class NotExist < RuntimeError    
+  end
+
+  @providers = []
+  class << self
+    include Observable2
+    
+    def resource_extensions; @resource_extensions ||= {} end
+    
+    def add_resource_provider provider
+      @providers.unshift provider
+    end
+    
+    def providers
+      raise "There's no any Resource Provider!" if @providers.empty?
+      @providers
+    end
+    
+    def register_resource_extension extension, load, save
+      resource_extensions[extension] = load, save
+    end
+    
+    def unregister_resource_extension extension
+      resource_extensions.delete extension
+    end                        
+    
+    # Returns from first Provider that contains this Class.
+    def class_get class_name
+      providers.each do |p|
+        begin
+          return p.class_get(class_name) 
+        rescue NotExist;
+        end
+      end
+      raise "Class '#{class_name}' doesn't exist!"
+    end
+    
+    # Search for first Provider that contains Class Namespace and creates Class in it, then exits.
+    def class_set class_name, data, *args      
+      namespace = Module.namespace_for class_name
+      namespace = namespace ? namespace.to_s : nil
+      found = false
+      providers.each do |p|
+        next unless !namespace or p.class_exist?(namespace)
+        p.class_set class_name, data, *args
+        found = true
+        break
+      end
+      raise "Namespace '#{namespace}' doesn't exist!" unless found
+    end
+    
+    def class_exist? class_name
+      providers.any?{|p| p.class_exist? class_name}
+    end
+    
+    # Deletes in each Providers.
+    def class_delete class_name
+      providers.each{|p| p.class_delete class_name}
+    end
+    
+#      def class_namespace_exist? namespace_name
+#        @monitor.synchronize do
+#          providers.any?{|p| p.class_namespace_exist? namespace_name}
+#        end
+#      end
+    
+    # Search each Provider that contains this Class and returns first found Resource.
+    def resource_get klass, resource_name        
+      providers.each do |p|
+        next unless p.class_exist?(klass.name)
+        begin
+          data = p.resource_get(klass.name, resource_name)
+          
+          if data
+            extension = File.extname(resource_name)
+            if resource_extensions.include? extension
+              load, save = resource_extensions[extension]
+              data = load.call data, klass, resource_name
+            end
+          end
+          
+          return data
+        rescue NotExist;
+        end
+      end
+      raise "Resource '#{resource_name}' for Class '#{klass.name}' doesn't exist!"
+    end
+    
+    # Deletes Resource in all Providers.
+    def resource_delete klass, resource_name
+      providers.each do |p|
+        next unless p.class_exist?(klass.name)
+        p.resource_delete klass.name, resource_name    
+      end
+    end
+    
+    # Set Resource in fist Provider that contains this Class.
+    def resource_set klass, resource_name, data
+      extension = File.extname(resource_name)
+      if resource_extensions.include? extension
+        load, save = resource_extensions[extension]
+        data = save.call data, klass, resource_name
+      end
+      
+      found = false
+      providers.each do |p|
+        next unless p.class_exist?(klass.name)
+        p.resource_set klass.name, resource_name, data
+        found = true
+        break
+      end
+      
+      raise "Class '#{klass.name}' doesn't exist!" unless found
+    end
+    
+    # Check also for Class existence.
+    def resource_exist? klass, resource_name
+      providers.any? do |p|
+        next unless p.class_exist?(klass.name)
+        p.resource_exist? klass.name, resource_name
+      end
+    end                        
+    
+    def class_to_virtual_file class_name
+      providers.each do |p|
+        begin
+          return p.class_to_virtual_file class_name 
+        rescue NotExist;
+        end
+      end
+      raise "Class '#{class_name}' doesn't exist!"          
+    end
+    
+    def hook!; ClassLoader.hook! end
+    def unhook!; ClassLoader.unhook! end
+    
+    synchronize_all_methods
+    
+#      def class_to_virtual_path class_name
+#        @monitor.synchronize do
+#          providers.each do |p|
+#            begin
+#              return p.class_to_virtual_path class_name 
+#            rescue NotExist;
+#            end
+#          end
+#          raise "Class '#{class_name}' doesn't exist!"
+#        end
+#      end
+  end 
+end

data/lib/vresource.rb

@@ -0,0 +1,12 @@
+require 'ruby_ext'
+
+%w{
+  file_system_provider
+  file_system_reloader
+
+  vresource
+  resource_extensions
+  class_loader
+
+  module
+}.each{|f| require "vresource/#{f}"}

data/old/README

@@ -18,7 +18,7 @@ All rights reserved.
 
 === License (LGPL) ===
 
-		   GNU LESSER GENERAL PUBLIC LICENSE
+       GNU LESSER GENERAL PUBLIC LICENSE
                        Version 3, 29 June 2007
 
  Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>

data/old/declarative_cache_rem.rb

@@ -0,0 +1,172 @@
+require 'monitor'
+
+class Class
+  def cache_method *methods
+    DeclarativeCache.cache_method self, *methods
+  end 
+  
+  def cache_method_with_params *methods
+    DeclarativeCache.cache_method_with_params self, *methods
+  end
+end
+
+module DeclarativeCache    
+  DISABLED = false
+
+  warn "CASHE DISABLED" if DISABLED 
+
+  @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 cache_method *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 : DeclarativeCache.alias_counter.to_sym 
+      
+        klass.class_eval{alias_method :"cached_#{als}", :"#{m}"}
+        unless vnames.is_a? Array
+          script = single_version_without_args.interpolate binding          
+          @versions[vnames] = 0 unless @versions.include? vnames
+        else
+          vnames_str = vnames.collect{|vname| "'#{vname}' => nil"}.join(', ')
+          script = multiple_version_without_args.interpolate binding
+          vnames.each{|vname| @versions[vname] = 0 unless @versions.include? vname}
+        end
+        klass.class_eval script, __FILE__, __LINE__                
+      end      
+    end
+  
+    def cache_method_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 : DeclarativeCache.alias_counter
+      
+        klass.class_eval{alias_method :"cached_#{als}", :"#{m}"}
+        unless vnames.is_a? Array
+          script = single_version_with_args.interpolate binding          
+          @versions[vnames] = 0 unless @versions.include? vnames
+        else
+          vnames_str = vnames.collect{|vname| "'#{vname}' => nil"}.join(', ')
+          script = multiple_version_with_args.interpolate 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! :>=, 2
+      
+      if arg.size == 3    
+        version_names = arg.shift
+        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.shift
+      else
+        version_names = klass = arg.shift        
+      end
+          
+      klass.class.should! :be, [Class, Module]
+    
+      methods = Array(arg.first)
+      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    
+  
+    def multiple_version_with_args
+      <<-RUBY
+        def \#{m} *params
+          DeclarativeCache.monitor.synchronize do
+            @cache_versions_\#{als} ||= {\#{vnames_str}}
+            @cache_value_\#{als} ||= {}
+            if @cache_versions_\#{als}.all?{|vname, v| v == DeclarativeCache.version(vname)} and @cache_value_\#{als}.include?(params) 
+              return @cache_value_\#{als}[params]
+            else
+              @cache_versions_\#{als}.keys.each{|vname| @cache_versions_\#{als}[vname] = DeclarativeCache.version(vname)}
+              return @cache_value_\#{als}[params] = cached_\#{als}(*params)
+            end    
+          end
+        end
+      RUBY
+    end
+  
+    def multiple_version_without_args
+      <<-RUBY
+        def \#{m}
+          DeclarativeCache.monitor.synchronize do
+            @cache_versions_\#{als} ||= {\#{vnames_str}}
+            if @cache_versions_\#{als}.all?{|vname, v| v == DeclarativeCache.version(vname)}
+              return @cache_value_\#{als}
+            else
+              @cache_versions_\#{als}.keys.each{|vname| @cache_versions_\#{als}[vname] = DeclarativeCache.version(vname)}
+              return @cache_value_\#{als} = cached_\#{als}
+            end    
+          end
+        end
+      RUBY
+    end
+    
+    def single_version_with_args
+      <<-RUBY
+        def \#{m} *params
+          DeclarativeCache.monitor.synchronize do
+            @cache_value_\#{als} ||= {}
+            if @cache_version_\#{als} == DeclarativeCache.version("\#{vnames}") and @cache_value_\#{als}.include?(params) 
+              return @cache_value_\#{als}[params]
+            else
+              @cache_version_\#{als} = DeclarativeCache.version("\#{vnames}")
+              return @cache_value_\#{als}[params] = cached_\#{als}(*params)
+            end    
+          end
+        end
+      RUBY
+    end
+    
+    def single_version_without_args
+      <<-RUBY
+        def \#{m}
+          DeclarativeCache.monitor.synchronize do
+            if @cache_version_\#{als} == DeclarativeCache.version("\#{vnames}")
+              return @cache_value_\#{als}
+            else
+              @cache_version_\#{als} = DeclarativeCache.version("\#{vnames}")
+              return @cache_value_\#{als} = cached_\#{als}
+            end    
+          end
+        end
+      RUBY
+    end
+  end
+end

data/old/declarative_cache_spec_rem.rb

@@ -0,0 +1,98 @@
+require 'spec'
+
+dir = File.dirname __FILE__
+require "#{dir}/../spec_require"
+require "#{dir}/../../lib/ruby_ext/should"
+require "#{dir}/../../lib/ruby_ext/declarative_cache"
+
+describe 'DeclarativeCache' do
+  class CachedClass
+    attr_accessor :value
+    def value_get; @value end
+    cache_method :value_get
+    
+    attr_accessor :value2
+    def value2_get; @value2 end
+    
+    attr_accessor :params
+    def params_get param; @params[param] end         
+  end            
+  
+  # DeclarativeCache.cache_method CachedClass, :value_get
+  DeclarativeCache.cache_method :cache_version_name, CachedClass, :value2_get
+  DeclarativeCache.cache_method_with_params CachedClass, CachedClass, :params_get  
+  
+  it "Simple Cache" do
+    o = CachedClass.new
+    o.value = 0
+    o.value2 = 0
+    o.value_get.should == 0
+    o.value2_get.should == 0
+    o.value = 1
+    o.value2 = 1
+    o.value_get.should == 0
+    o.value2_get.should == 0
+    DeclarativeCache.update CachedClass
+    o.value_get.should == 1
+    o.value2_get.should == 0
+    DeclarativeCache.update :cache_version_name
+    o.value2_get.should == 1
+    DeclarativeCache.update CachedClass, :cache_version_name
+  end
+  
+  it "Cache With Params" do
+    o = CachedClass.new
+    o.params = {:a => :b}
+    o.params_get(:a).should == :b
+    o.params = {:a => :c}
+    o.params_get(:a).should == :b
+    DeclarativeCache.update CachedClass
+    o.params_get(:a).should == :c
+  end
+  
+  class CachedClass2
+    class << self
+      attr_accessor :value
+      def value_get; @value end                 
+    end
+  end        
+  
+  DeclarativeCache.cache_method CachedClass2, CachedClass2.singleton_class, :value_get        
+  
+  it "Simple Cache" do
+    CachedClass2.value = 0
+    CachedClass2.value_get.should == 0
+    CachedClass2.value = 1
+    CachedClass2.value_get.should == 0
+    DeclarativeCache.update CachedClass2
+    CachedClass2.value_get.should == 1
+  end
+  
+  class MultipleCacheVersions
+    attr_accessor :value
+    def value_get; @value end                 
+      
+    attr_accessor :value2
+    def value2_get params; @value2 end
+  end
+  
+  DeclarativeCache.cache_method [:class, :resource_update, :security_update], MultipleCacheVersions, :value_get        
+  DeclarativeCache.cache_method_with_params [:class, :resource_update, :security_update], MultipleCacheVersions, :value2_get        
+  
+  it "Multiple cache versions" do
+    o = MultipleCacheVersions.new
+    o.value, o.value2 = 0, 0
+    
+    o.value_get.should == 0
+    o.value = 1
+    o.value_get.should == 0      
+    DeclarativeCache.update :class
+    o.value_get.should == 1
+    o.value = 2
+    o.value_get.should == 1
+    DeclarativeCache.update :resource_update, :security_update
+    o.value_get.should == 2
+    
+    o.value2_get("params").should == 0
+  end
+end

data/old/lib/RubyExt/ImportAll.rb

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

@@ -1,12 +1,12 @@
-class Module	
+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
+      if RubyExt::Resource.resource_exist? klass, resource
+        list << RubyExt::Resource.resource_get(klass, resource)
+      end
     end
     return list.reverse.inject(:merge)
   end
 end
-DeclarativeCache.cache_with_params! :class, Module, :localization
+DeclarativeCache.cache_method_with_params :class, Module, :localization

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

@@ -1,19 +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
+  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.rb

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