ruby_ex 0.1.1

data/src/cache.rb

@@ -0,0 +1,350 @@
+# 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 273 2005-06-03 00:00:26Z ertai $
+
+
+require 'ruby_ex'
+require 'md5sum'
+
+
+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)
+    TempPath.new('cache_file') do |tmp|
+      md5 = Digest::MD5.new
+      new_size = 0
+      tmp.open('w') do |out|
+        while (str = block[])
+          out.write(str)
+          md5 << str
+          new_size += str.size
+        end
+      end
+      p = @repository + md5.to_s
+      if p.exist?
+        @atime.delete(p)
+      else
+        @size += new_size
+      end
+      FileUtils.move(tmp.to_s, p.to_s)
+      p.chmod(perm)
+      @atime << p
+      adjust_size
+      return p
+    end
+  end
+
+  def import(filename)
+    p = nil
+    pathname = filename.to_path
+    pathname.open do |f|
+      p = write(pathname.stat.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
+#
+test_section __FILE__ do
+
+
+class CacheTest < Test::Unit::TestCase
+
+  #
+  # Tests
+  #
+  def test_simple
+    # FIXME factor me using #setup, #teardown, and @cache instead of cache.
+    TempPath.new('cache') do |repo|
+      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(p1)
+      assert_equal(p1.md5sum.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'))
+
+      # FIXME man printf + Tempfile + File::md5sum
+      #       resources/foo.txt + TempPath + Path#md5sum
+      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)
+    end
+  end
+
+  def test_write_twice_the_same
+    TempPath.new('cache') do |repo|
+      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_kind_of(Pathname, p1)
+      assert_equal(p1.md5sum.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))
+    end
+  end
+
+  def test_nested_write
+    TempPath.new('cache') do |repo|
+      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(p1)
+      assert_equal(p1.md5sum.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))
+    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
+

data/src/checkout.rb

@@ -0,0 +1,12 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: polrop $
+# $Id: checkout.rb 159 2005-02-18 12:07:23Z polrop $
+
+require 'uri_ex' 
+require 'uri/http_ex'
+require 'uri/ftp_ex'
+require 'uri/file'
+require 'uri/svn'

data/src/choose.rb

@@ -0,0 +1,271 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2005 Nicolas Pouillard. All rights reserved.
+# License::   GNU General Public License (GPL).
+# Revision::  $Id: choose.rb 258 2005-06-01 00:22:51Z ertai $
+
+
+require 'random_generators'
+
+
+class Integer
+
+  def self.choose ( limit=nil, generator=nil )
+    limit.to_i.choose(generator)
+  end
+
+  def choose ( generator=nil )
+    (generator || RandomGenerators.default).choose_integer(self)
+  end
+
+end # class Integer
+
+
+
+class Float
+
+  def self.choose ( limit=nil, generator=nil )
+    (limit || 1.0).to_f.choose(generator)
+  end
+
+  def choose ( generator=nil )
+    (generator || RandomGenerators.default).choose_float(self)
+  end
+
+end # class Float
+
+
+
+class Hash
+
+  def choose ( limit=nil, generator=nil )
+    self[keys.choose(limit, generator)]
+  end
+
+end # class Hash
+
+
+
+class Array
+
+  def choose ( limit=nil, generator=nil )
+    n = size
+
+    # Out of limits: limit > size (FIXME warn)
+    limit = n if limit.nil? or limit > n
+
+    self[limit.choose(generator)]
+  end
+
+end # class Array
+
+
+
+module Enumerable
+
+  def choose ( limit=nil, generator=nil )
+    to_a.choose(limit, generator)
+  end
+
+end # module Enumerable
+
+
+
+class Range
+
+  def choose ( generator=nil )
+    case first
+    when Integer
+      first + (last + 1 - first).choose(generator)
+    else
+      super(nil, generator)
+    end
+  end
+
+end # class Array
+
+
+
+test_section __FILE__ do
+
+  class MockRandomGenerator < RandomGenerators::RandomGenerator
+    concrete
+    attr_reader :ref
+    def initialize ( tab_i, tab_f )
+      raise unless tab_i.is_a? Array
+      raise unless tab_f.is_a? Array
+      @ref, @ref_f, @pos = tab_i, tab_f, -1
+    end
+    def get ( tab )
+      tab[@pos = (@pos + 1) % tab.size]
+    end
+    def choose_integer ( n )
+      check_choose_integer(n)
+      get(@ref) % n
+    end
+    def choose_float ( f=1.0 )
+      check_choose_float(f)
+      get(@ref_f) * f
+    end
+  end # class MockRandomGenerator
+
+  class RandomMockRandomGenerator < MockRandomGenerator
+    def initialize ( n )
+      tab_i = (0 .. n - 1).to_a.shuffle
+      tab_f = []
+      n.times { tab_f << Float.choose() }
+      super(tab_i, tab_f)
+    end
+  end # class RandomMockRandomGenerator
+
+
+  require 'test/unit'
+  require 'set'
+
+  class ChooseTest < Test::Unit::TestCase
+
+    REF_5 = [1, 2, 4, 0, 3]
+    REF_F_5 = [0.187528345035389, 0.368857819121331, 0.06954449811019,
+                0.188887464581057, 0.213757352204993]
+    REF_50 = [
+      28,  12,  17,  10, 1, 37, 46, 25, 47, 2, 45, 36, 20, 5, 30, 14, 18, 39,
+      8,  15,  16, 43, 27, 33, 22, 7, 32, 3, 35, 9, 19, 13, 21, 6, 23, 26, 4,
+      40, 44, 11, 49, 29, 42, 24, 31, 48, 34, 0, 38, 41
+    ]
+    REF_F_50 = [
+      0.643785412423313, 0.765736325876787, 0.604515956481919,
+      0.133839202811942, 0.350400971015915, 0.966710213804618,
+      0.904755113180727, 0.88459848286584, 0.163951952941716,
+      0.808023529592901, 0.387806572020054, 0.659689131658524,
+      0.289974238490686, 0.813535830006003, 0.565311754588038,
+      0.889200099511072, 0.0668127918615937, 0.992091996129602,
+      0.604403987759724, 0.89254002738744, 0.601499371463433,
+      0.754795648856089, 0.751190354581922, 0.434389552799985,
+      0.761369747575372, 0.174903159961104, 0.940325234550983,
+      0.536097376374528, 0.957906004507095, 0.693120914744213,
+      0.23448576242663, 0.638284107437357, 0.423910334473476,
+      0.251349127152935, 0.457931924844161, 0.20579389645718,
+      0.256057573715225, 0.584466924890876, 0.609375598141924,
+      0.0856487881392241, 0.437958877766505, 0.432312048738822,
+      0.81560374982655, 0.142059376928955, 0.118824432371184,
+      0.958816710859537, 0.69899930502288, 0.118259542621672,
+      0.52218786906451, 0.339233995880932
+    ]
+
+    def checker_n ( n, ref_i, ref_f, inp, ref, lim=nil )
+      mrg = MockRandomGenerator.new(ref_i, ref_f)
+      my = []
+      if lim == :no
+        n.times { my << inp.choose(mrg) }
+      else
+        n.times { my << inp.choose(lim, mrg) }
+      end
+      assert_equal(ref, my)
+    end
+
+    def checker_5 ( inp, ref, lim=nil )
+      checker_n(5, REF_5, REF_F_5, inp, ref, lim)
+    end
+
+    def checker_50 ( inp, ref, lim=nil )
+      checker_n(50, REF_50, REF_F_50, inp, ref, lim)
+    end
+
+
+
+
+    def test_integer
+      checker_5 Integer, REF_5, 5
+      checker_50 Integer, REF_50, 50
+      assert(Integer.choose(1000) < 1000)
+    end
+
+    def test_float
+      checker_5 Float, REF_F_5, 1.0
+      checker_50 Float, REF_F_50, 1.0
+      assert(Float.choose(2.0) < 2)
+      assert(Float.choose < 1)
+    end
+
+    def test_array_5
+      checker_5 [4], [4] * 5, 5
+      checker_5 [4, 5], [5, 4, 4, 4, 5], 5
+      checker_5 [4, 5, 6], [5, 6, 5, 4, 4], 5
+      checker_5 [2, 1, 0, 5, 4, 3], [1, 0, 4, 2, 5], 5
+      10.times { assert(REF_50.include?(REF_50.choose)) }
+    end
+
+    def test_set_5
+      checker_5 Set[4], [4] * 5, 5
+      checker_5 Set[4, 5], [4, 5, 5, 5, 4], 5
+      checker_5 Set[4, 5, 6], [6, 4, 6, 5, 5], 5
+      checker_5 Set[2, 1, 0, 5, 4, 3], [0, 1, 3, 5, 2], 5
+      set = REF_50.to_set
+      10.times { assert(set.include?(set.choose)) }
+    end
+
+    def test_hash
+      checker_5({ 1 => 2 }, [2] * 5, 5)
+      checker_5({ 1 => 2, 3 => 4 }, [4, 2, 2, 2, 4], 5)
+    end
+
+    def test_array_50
+      checker_50 [4], [4] * 50, 50
+      checker_50 [
+        36,  16,  15, 6, 27, 33, 17, 10, 18, 39, 8, 43, 19, 23, 49, 40, 46, 37,
+        9,  41, 35, 0, 38, 26, 22, 4, 7, 25, 21, 12, 42, 45, 28, 5, 31, 24, 34,
+        48, 32, 30, 13, 29, 11, 2, 1, 20, 3, 44, 47, 14
+      ], [
+        21,  19,  37,  8,  16, 48, 3, 4, 44, 15, 20, 34, 35, 33, 42, 49, 9, 30,
+        18,  40, 46, 2, 25, 5, 38, 10, 28, 6, 24, 39, 41, 23, 0, 17, 26, 7, 27,
+        13, 1, 43, 14, 12, 11, 22, 45, 47, 31, 36, 32, 29
+      ], 50
+    end
+
+    def test_integer_instances
+      assert_raise(ArgumentError) { checker_5 0, [], :no }
+      checker_5 1, [0] * 5, :no
+      checker_5 4, [1, 2, 0, 0, 3], :no
+      checker_5 10, REF_5, :no
+      assert(1000.choose < 1000)
+    end
+
+    def test_float_instances
+      assert_raise(ArgumentError) { checker_5 0.0, [], :no }
+      checker_5  1.0, [ 0.187528345035389, 0.368857819121331, 0.06954449811019,
+                        0.188887464581057, 0.213757352204993 ], :no
+      assert(2.0.choose < 2)
+    end
+
+    def test_integer_range_instances
+      checker_5 1..1, [1] * 5, :no
+      checker_5 1..2, [2, 1, 1, 1, 2], :no
+      checker_5 0..1, [1, 0, 0, 0, 1], :no
+      checker_5 0..4, [1, 2, 4, 0, 3], :no
+    end
+
+    class Xs
+      include Comparable
+      attr_reader :length
+      def initialize ( n )
+        @length = n
+      end
+      def succ
+        Xs.new(@length.succ)
+      end
+      def <=> ( rhs )
+        @length <=> rhs.length
+      end
+      def inspect
+        'x' * @length
+      end
+    end
+
+    def test_range_instances
+      checker_5 'a'..'a', ['a'] * 5, :no
+      checker_5 'a'..'b', ['b', 'a', 'a', 'a', 'b'], :no
+      checker_5 Xs.new(1)..Xs.new(4), [2, 3, 1, 1, 4].map { |x| Xs.new(x) }, :no
+    end
+
+  end # class ChooseTest
+
+end