vcs 0.2.148 → 0.3.0

data/ruby_ex/array_each_pair.rb

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

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

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

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