vcs 0.1 → 0.2.148

data/ruby_ex/array_each_pair.rb

@@ -0,0 +1,18 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: polrop $
+# $Id: cache.rb 173 2005-03-29 09:41:46Z polrop $
+
+
+class Array
+
+  # Basically, do the same as each_with_index but yield the arguments in
+  # reverse order. Thus an array can be assume in certain cases to a hash.
+  def each_pair(&block)
+    each_with_index { |x, i| block[i, x] }
+  end
+
+end # class Array
+

data/ruby_ex/ask.rb

@@ -0,0 +1,101 @@
+# Author: Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright: Copyright (c) 2004, 2005 Nicolas Pouillard. All rights reserved.
+# License: GNU General Public License (GPL).
+
+# $LastChangedBy: ertai $
+# $Id: ask.rb 187 2005-04-03 00:11:56Z ertai $
+
+ANSWERS = [ :y, :n ]
+ANSWER_NOT_VALID = 'Not a valid answer, please answer correctly'
+
+# `ask', ask the user to answer, to your question.
+#
+# Example:
+#   ask('Commiting, are you sure', :n)
+#
+#   produce => Commiting, are you sure (y/N): 
+#   and wait your answer.
+def ask ( aQuestion, theDefaultAnswer=:y, cin=STDIN, cout=STDOUT, cerr=STDERR )
+  
+  yn = case theDefaultAnswer
+       when :y then ' [Y/n]: '
+       when :n then ' [y/N]: '
+       else raise ArgumentError, "not valid default answer #{theDefaultAnswer}"
+       end
+
+  loop do
+    cout.print aQuestion, yn
+    cout.flush
+
+    answer = cin.readline.chomp.downcase
+    
+    return theDefaultAnswer if answer.empty?
+
+    answer = answer.to_sym
+
+    return answer if ANSWERS.include? answer
+
+    cerr.puts ANSWER_NOT_VALID
+    cout.puts
+  end
+
+end
+
+if defined? TEST_MODE or $0 == __FILE__
+
+require 'test/unit'
+class AskTest < Test::Unit::TestCase
+
+  def ask_checker ( question, default, answer, ref, out, err )
+    require 'stringio'
+    cin, cout, cerr = StringIO.new, StringIO.new, StringIO.new
+    cin.puts answer
+    cin.rewind
+    res = ask(question, default, cin, cout, cerr)
+    cout.rewind
+    cerr.rewind
+    assert_equal(res, ref, 'bad return value')
+    assert_equal(cout.readlines.join, out, 'bad standard output')
+    assert_equal(cerr.readlines.join, err, 'bad error output')
+  end
+
+  def test_bad_default
+    assert_raise(ArgumentError) { ask_checker('Q', :foo, '', :y, [], []) }
+    assert_nothing_raised do
+      ask_checker('Q', :y, 'y', :y, 'Q [Y/n]: ', '')
+    end
+    assert_nothing_raised do
+      ask_checker('Q', :n, 'y', :y, 'Q [y/N]: ', '')
+    end
+  end
+
+  def test_valid_default_yes
+    ask_checker('Q', :y, 'y', :y, 'Q [Y/n]: ', '')
+    ask_checker('Q', :y, 'Y', :y, 'Q [Y/n]: ', '')
+    ask_checker('Q', :y, 'n', :n, 'Q [Y/n]: ', '')
+    ask_checker('Q', :y, 'N', :n, 'Q [Y/n]: ', '')
+    ask_checker('Q', :y, '',  :y, 'Q [Y/n]: ', '')
+  end
+
+  def test_valid_default_no
+    ask_checker('Q', :n, 'y', :y, 'Q [y/N]: ', '')
+    ask_checker('Q', :n, 'Y', :y, 'Q [y/N]: ', '')
+    ask_checker('Q', :n, 'n', :n, 'Q [y/N]: ', '')
+    ask_checker('Q', :n, 'N', :n, 'Q [y/N]: ', '')
+    ask_checker('Q', :n, '',  :n, 'Q [y/N]: ', '')
+  end
+
+  def test_invalid_answer
+    ask_checker('Q', :n, "bad\ny", :y,
+                "Q [y/N]: \nQ [y/N]: ", ANSWER_NOT_VALID + "\n")
+    ask_checker('Q', :y, "ad\n\n", :y,
+                "Q [Y/n]: \nQ [Y/n]: ", ANSWER_NOT_VALID + "\n")
+  end
+
+  def test_ask1
+    ask_checker('Q', :y, 'y', :y, 'Q [Y/n]: ', '')
+  end
+
+end # class AskTest
+
+end

data/ruby_ex/attributed_class.rb

@@ -0,0 +1,302 @@
+# Copyright:: Copyright (c) 2004, 2005  Nicolas Pouillard. All rights reserved.
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# License::   Gnu General Public License.
+# Revision::  $Id: attributed_class.rb 212 2005-05-05 20:07:23Z ertai $
+
+
+# Extension to have inherited, class attributes,
+# Where each class have his own attributes set.
+module AttributedClass
+
+  class Attribute
+
+    attr_reader :name, :descr, :klass, :default_proc
+    attr_accessor :default
+
+    @@default_proc = nil
+
+    def initialize ( name, descr, *args, &block )
+      raise ArgumentError, 'need a symbol' unless name.is_a? Symbol
+      @name, @descr = name, descr
+      @default, @klass = nil, nil
+      @mandatory = false
+      @visible = true
+      if block_given?
+        @default_proc = block
+      else
+        @default_proc = @@default_proc
+      end
+      other = []
+
+      args.each do |arg|
+        case arg
+        when :mandatory then @mandatory = true
+        when :invisible then @visible = false
+        else other << arg
+        end
+      end
+
+      case other.size
+      when 1
+        if other[0].is_a? Class
+          @klass = [other[0]]
+        elsif other[0].is_a? Array and other[0].all? { |k| k.is_a? Class }
+          @klass = other[0]
+        else
+          @default = other[0]
+        end
+      when 2
+        a, b = other
+        if a.is_a? Class and b.is_a? a
+          @klass, @default = [a], b
+        elsif a.is_a? Array and
+              a.all? { |k| k.is_a? Class } and
+              a.any? { |k| b.is_a? k }
+          @klass, @default = a, b
+        elsif b.is_a? Class and a.is_a? b
+          @klass, @default = [b], a
+        elsif b.is_a? Array and
+              b.all? { |k| k.is_a? Class } and
+              b.any? { |k| a.is_a? k }
+          @klass, @default = b, a
+        else
+          raise ArgumentError, 'need a Class and a default value'
+        end
+      when 0
+      else raise ArgumentError, 'too many values'
+      end
+
+      # removed because it causes some probleme when distributed such a class
+      #[@name, @descr, @default].each { |x| x.freeze }
+    end
+
+    def visible?
+      @visible
+    end
+
+    def invisible?
+      !@visible
+    end
+
+    def mandatory?
+      @mandatory
+    end
+
+    def valid? ( anObject )
+      return false if mandatory? and anObject.nil?
+      @klass.nil? or @klass.empty? or @klass.any? { |k| anObject.is_a? k }
+    end
+
+
+    def self.set_default_proc ( &block )
+      @@default_proc = block
+    end
+      
+    
+    def help ( output=STDERR )
+      output << "#@name: #@descr"
+      output << " [#@klass]" unless @klass.nil?
+      other = []
+      other << 'mandatory' if mandatory?
+      other << 'invisible' if invisible?
+      output << " (#{other.join(', ')})" unless other.empty?
+      output
+    end
+
+    def inspect
+      help('#<') + '>'
+    end
+
+  end # class Attribute
+
+
+  class MethodAttribute < Attribute
+    VISIBILITIES = [ :private, :protected, :public, :unknown ]
+    attr_reader :visibility
+    def private?
+      @visibility == :private
+    end
+    def protected?
+      @visibility == :protected
+    end
+    def public?
+      @visibility == :public
+    end
+    def initialize ( name, descr, *args )
+      vis = args.find { |arg| VISIBILITIES.include? arg }
+      args.delete(vis) unless vis.nil?
+      @visibility = vis || :unknown
+      super(name, descr, *args)
+    end
+  end # class MethodAttribute
+
+
+  class AttributeError < Exception
+
+    def initialize ( anObject, anAttr, val=nil )
+      if val.nil?
+        super "Missing the #{anAttr.name} attribute for `#{anObject}'"
+      else
+        super "Attribute #{anAttr.name} wait for a `#{anAttr.klass}' not " +
+              "`#{val}' in #{anObject}"
+      end
+    end
+
+  end # class AttributeError
+
+
+  def self.included ( aClass )
+
+    aClass.module_eval do
+
+      def initialize_attributes ( *default_proc_args )
+        self.class.attributes.each do |attr|
+          next if attr.is_a? MethodAttribute
+          if attr.default_proc.nil? and attr.default.nil?
+            instance_variable_set("@#{attr.name}", nil)
+          else
+            unless attr.default_proc.nil?
+              pr = attr.default_proc
+              if pr.arity == default_proc_args.size
+                default = pr[*default_proc_args]
+              else
+                default = pr[attr, *default_proc_args]
+              end
+              attr.default = default
+            end
+            send "#{attr.name}=", attr.default
+          end
+        end
+      end
+
+      def self.set_default_proc ( &block )
+        Attribute.set_default_proc(&block)
+      end
+
+      def each_attribute ( &block )
+        self.class.attributes.each do |attr|
+          block[attr, send(attr.name)]
+        end
+      end
+
+      def each_variable_attribute ( &block )
+        self.class.attributes.each do |attr|
+          next if attr.is_a? MethodAttribute
+          block[attr, send(attr.name)]
+        end
+      end
+
+      def each_method_attribute ( &block )
+        self.class.attributes.each do |attr|
+          next unless attr.is_a? MethodAttribute
+          block[attr, send(attr.name)]
+        end
+      end
+
+      def check_attribute ( attr, anObject )
+        unless attr.valid? anObject
+          raise AttributeError.new(self, attr, anObject)
+        end
+      end
+
+      def check_attributes
+        each_variable_attribute(&method(:check_attribute))
+      end
+
+      def self.help ( output=STDERR )
+        output.puts "#{self.to_s}:"
+        attributes.each do |attr|
+          output << '  '
+          attr.help(output)
+          output.puts '.'
+        end
+      end
+
+      def self.attributes
+        unless defined? @attributes
+          if superclass and superclass.respond_to? :attributes
+            @attributes = superclass.attributes.dup
+          else
+            @attributes = []
+          end
+        end
+        @attributes
+      end
+
+      def self.attribute ( name, descr, *args, &block )
+        attr = Attribute.new(name, descr, *args, &block)
+        unless method_defined? name
+          if att = get_attribute(name, MethodAttribute)
+            attributes.delete(att)
+          end
+          attr_reader name
+        end
+        meth = "#{name}="
+        unless method_defined? meth
+          if att = get_attribute(meth, MethodAttribute)
+            attributes.delete(att)
+          end
+          attr_writer name
+        end
+        attributes << attr
+      end
+
+      def self.method_attribute ( name, descr, *args, &block )
+        # unless method_defined? name
+          # raise ArgumentError, "Undefined method #{name}"
+        # end
+        attr = MethodAttribute.new(name, descr, *args, &block)
+        attributes << attr
+      end
+
+      def self.get_attribute ( name, type=nil )
+        if type.nil?
+          attributes.find { |attr| attr.name == name }
+        else
+          attributes.find { |attr| attr.name == name && attr.is_a?(type) }
+        end
+      end
+
+    end
+
+  end
+
+end # module AttributedClass
+
+
+
+if defined? TEST_MODE or $0 == __FILE__
+
+  require 'test/unit'
+  class AttributedClassTest < Test::Unit::TestCase
+
+    def test_simple
+      c = Class.new
+      assert_nothing_raised do
+        c.module_eval { include AttributedClass }
+      end
+      assert_equal([], c.attributes)
+      assert_nothing_raised do
+        c.module_eval { attribute :foo, 'foofoo', 42 }
+      end
+      cc, d, dd = nil, nil, nil
+      assert_nothing_raised { cc = c.new }
+      assert_equal(nil, cc.foo)
+      assert_nothing_raised { cc.initialize_attributes }
+      assert_equal(42, cc.foo)
+      assert_nothing_raised { cc.foo = 32 }
+      assert_equal(32, cc.foo)
+      assert_nothing_raised { d = Class.new(c) }
+      assert_nothing_raised do
+        d.module_eval { attribute :bar, 'foofoo', :mandatory }
+      end
+      assert_nothing_raised { dd = d.new }
+      assert_nothing_raised { dd.initialize_attributes }
+      assert_raise(AttributedClass::AttributeMissingError) do
+        dd.check_attributes
+      end
+    end
+
+  end # class AttributedClassTest
+
+end

data/ruby_ex/cache.rb

@@ -0,0 +1,373 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: ertai $
+# $Id: cache.rb 186 2005-04-03 00:07:45Z ertai $
+
+
+require 'pathname'
+require 'md5'
+require 'tempfile'
+require 'fileutils'
+
+
+class Cache
+
+  #
+  # Constants
+  #
+  REPOSITORY = '/var/cache/ruby_ex_cache'
+  MAX_SIZE = 50 * 1024 * 1024 # 50 MB
+  BLOCK_SIZE = 1024 # octets
+
+  #
+  # Attributs
+  #
+  attr_reader :repository, :max_size, :size
+
+  #
+  # Constructor
+  #
+  def initialize(repository=REPOSITORY, max_size=MAX_SIZE)
+    @repository = Pathname.new(repository)
+    @max_size = check_max_size(max_size)
+    create
+  end
+
+  #
+  # Methods
+  #
+  def create
+    @size = 0
+    @atime = []
+    if @repository.directory?
+      @repository.each_entry do |p|
+        next if p.to_s =~ /^\./
+        full_p = @repository + p
+        @atime << full_p
+        @size += full_p.size
+      end
+      @atime.sort! { |a, b| a.atime <=> b.atime }
+    else
+      @repository.mkdir
+    end
+  end
+
+  def clear
+    @repository.each_entry do |p|
+      (@repository + p).delete unless p.to_s =~ /^\./
+    end
+    @size = 0
+    @atime.clear
+  end
+
+  def recreate
+    clear
+    create
+  end
+
+  def open(md5sum=nil, mode='r', perm=0644, &block)
+    case mode
+    when 'r': read(md5sum, &block)
+    when 'w': write(perm, &block)
+    else
+      raise(ArgumentError, "`#{mode}' - bad mode")
+    end
+  end
+
+  def read(md5sum, &block)
+    p = @repository + md5sum.to_s
+    p.open('r', &block)
+    @atime.delete(p)
+    @atime << p
+    p
+  end
+
+  def write(perm=0644, &block)
+    tmp = nil
+    p = nil
+    begin
+      md5 = Digest::MD5.new
+      tmp = Tempfile.new('cache')
+      new_size = 0
+      while (str = block[])
+        tmp.write(str)
+        md5 << str
+        new_size += str.size
+      end
+      tmp.close
+      p = @repository + md5.to_s
+      if p.exist?
+        @atime.delete(p)
+      else
+        @size += new_size
+      end
+      FileUtils.move(tmp.path, p)
+      p.chmod(perm)
+    rescue
+      tmp.delete if tmp
+      raise
+    end
+    @atime << p
+    adjust_size
+    p
+  end
+
+  def import(filename)
+    p = nil
+    File.open(filename) do |f|
+      p = write(File.stat(filename).mode) { f.eof? ? nil : f.read(BLOCK_SIZE) }
+    end
+    p
+  end
+
+  def export(md5sum, dst_filename)
+    p = @repository + md5sum.to_s
+    FileUtils.copy_entry(p, dst_filename)
+    update_entry(p)
+    p
+  end
+
+  def present?(md5sum)
+    p = @repository + md5sum.to_s
+    p.exist? ? p : nil;
+  end
+
+  def each
+    @atime.each { |p| yield(p) }
+  end
+
+  def [](index)
+    @atime[index]
+  end
+
+  def max_size=(max_size)
+    @max_size = check_max_size(max_size)
+    adjust_size
+  end
+
+  def nb_files
+    @atime.size
+  end
+
+  protected
+  def adjust_size
+    while @size > @max_size
+      p = @atime.shift
+      @size -= p.size
+      p.delete
+    end
+    @size
+  end
+
+  protected
+  def check_max_size(max_size)
+    unless max_size > 0
+      raise(ArgumentError, "`#{max_size}' - bad cache maximum size")
+    end
+    max_size
+  end
+
+end # class Cache
+
+
+#
+# Unit test suite
+#
+if defined? TEST_MODE or __FILE__ == $0
+
+
+require 'test/unit/ui/yaml/testrunner'
+require 'md5sum'
+
+
+class CacheTest < Test::Unit::TestCase
+
+  #
+  # Tests
+  #
+  def test_simple
+    tmp_cache = nil
+    begin
+      tmp_cache = Tempfile.new('cache')
+      repo = Pathname.new(tmp_cache.path)
+      tmp_cache.delete
+      cache = nil
+      assert_nothing_raised { cache = Cache.new(repo) }
+      assert_equal(0, cache.nb_files, 'bad nb_files')
+      assert_nothing_raised { cache.create }
+      assert_equal(0, cache.nb_files, 'bad nb_files')
+      assert_nothing_raised { cache.clear }
+      assert_equal(0, cache.nb_files, 'bad nb_files')
+      assert_nothing_raised { cache.create }
+      assert_equal(0, cache.nb_files, 'bad nb_files')
+      assert_raises(Errno::ENOENT) { cache.open('toto', 'r') { |f| f.gets } }
+      assert_equal(0, cache.nb_files, 'bad nb_files')
+      assert_equal(0, cache.size)
+
+      data = [ "toto\n", "tata\n" ]
+      p1 = cache.open(nil, 'w') do
+        data.shift
+      end
+      assert_equal(File.md5sum(p1.to_s).to_s, p1.basename.to_s, 'bad md5 open')
+      assert_equal(1, cache.nb_files, 'bad nb_files')
+      assert_equal(p1, cache[0])
+      assert_equal(10, cache.size)
+      assert_equal(p1, cache.present?(p1.basename))
+      tmp_p = cache.read(p1) do |f|
+        assert_equal("toto\n", f.gets)
+        assert_equal("tata\n", f.gets)
+        assert(f.eof?)
+      end
+      assert_equal(tmp_p, p1)
+      check_atime(cache)
+      assert_equal(1, cache.nb_files, 'bad nb_files')
+      assert(cache.present?(p1))
+      assert_equal(p1, cache[0])
+      assert(! cache.present?('foo'))
+
+      tmp_file = Tempfile.new('cache')
+      system("man printf > #{tmp_file.path} 2> /dev/null")
+      md5 = File.md5sum(tmp_file.path)
+      p2 = cache.import(tmp_file.path)
+      assert_equal(md5.to_s, p2.basename.to_s, 'bad name after import')
+      assert(p2.exist?, 'file do not exist after import')
+      assert(FileUtils.cmp(tmp_file.path, p2.to_s), 'bad import')
+      assert_equal(md5.to_s, File.md5sum(p2.to_s).to_s, 'bad md5 import')
+      tmp_file.delete
+      assert_equal(2, cache.nb_files, 'bad nb_files')
+      assert_equal(p2, cache[1])
+      check_atime(cache)
+
+      data = [ "foo\n", "bar\n" ]
+      p3 = cache.open(nil, 'w') do
+        data.shift
+      end
+      assert_equal(File.md5sum(p3.to_s).to_s, p3.basename.to_s, 'bad md5 open')
+      assert_equal(3, cache.nb_files, 'bad nb_files')
+      assert_equal(p3, cache[2])
+      assert_equal(p3, cache.present?(p3.basename))
+
+      assert_equal(p1, cache[0], 'p1 first')
+      assert_equal(p2, cache[1], 'p2 second')
+      assert_equal(p3, cache[2], 'p3 third')
+      assert_equal(p1, cache.read(p1) { |f| f.gets })
+      assert_equal(p2, cache[0], 'p2 first')
+      assert_equal(p3, cache[1], 'p3 second')
+      assert_equal(p1, cache[2], 'p1 third')
+      check_atime(cache)
+      assert_equal(3, cache.nb_files, 'bad nb_files')
+
+
+      new_cache = nil
+      assert_nothing_raised { new_cache = Cache.new(repo) }
+      assert_equal(3, new_cache.nb_files, 'bad nb_files in new cache')
+      check_atime(new_cache)
+      assert_equal(cache.size, new_cache.size)
+
+      assert_equal(3, cache.nb_files, 'bad nb_files')
+      assert(cache.size > 1024)
+      cache.max_size = 1024
+      assert(cache.size < 1024)
+      assert_equal(p1.size + p3.size, cache.size)
+      assert_equal(2, cache.nb_files, 'bad nb_files')
+      assert_equal(p3, cache[0], 'p3 first')
+      assert_equal(p1, cache[1], 'p1 second')
+
+      cache.clear
+      assert_equal(0, cache.nb_files, 'bad nb_files')
+      assert_equal(0, cache.size)
+    ensure
+      repo.rmtree if repo
+    end
+  end
+
+  def test_write_twice_the_same
+    tmp_cache = nil
+    begin
+      tmp_cache = Tempfile.new('cache')
+      repo = Pathname.new(tmp_cache.path)
+      tmp_cache.delete
+      cache = nil
+      assert_nothing_raised { cache = Cache.new(repo) }
+      assert_equal(0, cache.nb_files, 'bad nb_files')
+      assert_equal(0, cache.size)
+
+      data = [ "toto\n", "tata\n" ]
+      d = data.dup
+      p1 = cache.open(nil, 'w') do
+        d.shift
+      end
+
+      assert_equal(File.md5sum(p1.to_s).to_s, p1.basename.to_s, 'bad md5 open')
+      assert_equal(1, cache.nb_files, 'bad nb_files')
+      assert_equal(p1, cache[0])
+      assert_equal(10, cache.size)
+      assert_equal(p1, cache.present?(p1.basename))
+
+      data = [ "toto\n", "tata\n" ]
+      d = data.dup
+      p2 = cache.open(nil, 'w') do
+        d.shift
+      end
+
+      assert_equal(File.md5sum(p1.to_s).to_s, p1.basename.to_s, 'bad md5 open')
+      assert_equal(1, cache.nb_files, 'bad nb_files')
+      assert_equal(p1, cache[0])
+      assert_equal(10, cache.size)
+      assert_equal(p1, cache.present?(p1.basename))
+    ensure
+      repo.rmtree if repo
+    end
+  end
+
+  def test_nested_write
+    tmp_cache = nil
+    begin
+      tmp_cache = Tempfile.new('cache')
+      repo = Pathname.new(tmp_cache.path)
+      tmp_cache.delete
+      cache = nil
+      assert_nothing_raised { cache = Cache.new(repo) }
+      assert_equal(0, cache.nb_files, 'bad nb_files')
+      assert_equal(0, cache.size)
+
+      data = [ "toto\n", "tata\n" ]
+      d1 = data.dup
+      p1 = cache.open(nil, 'w') do
+        d2 = data.dup
+        p2 = cache.open(nil, 'w') do
+          d2.shift
+        end
+        d1.shift
+      end
+
+      assert_equal(File.md5sum(p1.to_s).to_s, p1.basename.to_s, 'bad md5 open')
+      assert_equal(1, cache.nb_files, 'bad nb_files')
+      assert_equal(p1, cache[0])
+      assert_equal(10, cache.size)
+      assert_equal(p1, cache.present?(p1.basename))
+
+    ensure
+      repo.rmtree if repo
+    end
+  end
+
+  #
+  # Utilities
+  #
+  protected
+  def check_atime(cache)
+    j = 0
+    for i in 1...cache.nb_files do
+      assert(cache[j].atime <= cache[i].atime, "bad atime order for #{i}")
+      j = i
+    end
+  end
+
+end # class CacheTest
+
+
+end
+