vcs 0.1 → 0.2.148

data/ruby_ex/orderedhash.rb

@@ -0,0 +1,252 @@
+# AUTHOR
+#    jan molic /mig/at/1984/dot/cz/
+#    updated by: Nicolas Pouillard  <ertai@lrde.epita.fr>
+#
+# DESCRIPTION
+#    Override hash to make it creation order preserved.
+#    This will be obsolete - it is better to use special OrderedHash class
+#    than overriding.
+#    Public domain.
+#
+# THANKS
+#    Andrew Johnson for his suggestions and fixes of Hash[],
+#    merge, to_a, inspect and shift
+#
+# USAGE
+#    just require this file, examples are at the end
+#    you can try to run this file (ruby orderedhash.rb)
+#
+
+# $LastChangedBy: ertai $
+# $Id: orderedhash.rb 152 2005-02-13 09:31:49Z ertai $
+
+module OrderedHash_ext
+
+  def store ( a, b )
+    @order.push a unless has_key? a
+    super a,b
+  end
+
+  def []= ( a, b )
+    @order.push a unless has_key? a
+    super a,b
+  end
+
+  def == ( hsh2 )
+    return false if !hsh2.respond_to? :order or @order != hsh2.order
+    super hsh2
+  end
+
+  def clear
+    @order = []
+    super
+  end
+
+  def delete ( key )
+    @order.delete key
+    super
+  end
+
+  def each_key
+    @order.each { |k| yield k }
+    self
+  end
+
+  def each_value
+    @order.each { |k| yield self[k] }
+    self
+  end
+
+  def each
+    @order.each { |k| yield(k, self[k]) }
+    self
+  end
+
+  alias :each_pair :each
+
+  def delete_if
+    @order.clone.each do |k|
+      delete k if yield(k, self[k])
+    end
+    self
+  end
+
+  def values
+    ary = []
+    @order.each { |k| ary << self[k] }
+    ary
+  end
+
+  def keys
+    @order
+  end
+
+  def invert
+    hsh2 = self.class.new
+    @order.each { |k| hsh2[self[k]] = k }
+    hsh2
+  end
+
+  def reject ( &block )
+    self.dup.delete_if(&block)
+  end
+
+  def reject! ( &block )
+    hsh2 = reject(&block)
+    self == hsh2 ? nil : hsh2
+  end
+
+  def replace ( hsh2 )
+    @order = hsh2.keys 
+    super hsh2
+  end
+
+  def shift
+    key = @order.first
+    key ? [key,delete(key)] : super
+  end
+
+  def to_a
+    ary = []
+    each { |k,v| ary << [k,v] }
+    ary
+  end
+
+  def to_s
+    to_a.to_s
+  end
+
+  def update ( hsh2 )
+    hsh2.each { |k,v| self[k] = v }
+    self
+  end
+
+  def merge! ( hsh2 )
+    hsh2.each { |k,v| self[k] = v }
+    self
+  end
+
+  def merge ( hsh2 )
+    self.dup.update(hsh2)
+  end
+
+  def select
+    ary = []
+    each { |k,v| ary << [k,v] if yield k,v }
+    ary
+  end
+
+  def ordered?
+    !@order.nil?
+  end
+
+end # module OrderedHash_ext
+
+
+class OHash < Hash
+
+  attr_accessor :order
+
+  alias :unordered_keys :keys
+
+  include OrderedHash_ext
+
+  def initialize ( *a )
+    @order = unordered_keys
+    super
+  end
+
+  def self.[] ( *args )
+    hsh = OHash.new
+    if Hash === args[0]
+      hsh.replace args[0]
+    elsif (args.size % 2) != 0
+      raise ArgumentError, "odd number of elements for Hash"
+    else
+      hsh[args.shift] = args.shift while args.size > 0
+    end
+    hsh
+  end
+  
+end # class OHash
+
+
+class Hash
+
+  def ordered?
+    false
+  end
+
+end # class Hash
+
+
+if defined? TEST_MODE or __FILE__ == $0
+
+  require 'test/unit'
+  class OrderedHashTest < Test::Unit::TestCase
+
+    def check_ordered ( h, ref )
+      h.store(4,3)
+      h.store(2,3) 
+      assert_equal(h.to_a, ref)
+    end
+
+    def test_ordered
+      check_ordered(OHash.new, [[4, 3], [2, 3]])
+    end
+
+    def test_unorderd
+      check_ordered(Hash.new, [[2, 3], [4, 3]])
+    end
+    
+    def test_simply
+      # You can do simply
+      hsh = OHash.new
+      hsh['z'] = 1
+      hsh['a'] = 2
+      hsh['c'] = 3
+      assert_equal(hsh.keys, ['z','a','c'])
+    end
+
+    def test_preserve
+      # or using OrderedHash[] method
+      hsh = OHash['z', 1, 'a', 2, 'c', 3] 
+      hsh2 = OHash['a', 2, 'z', 1, 'c', 3] 
+      assert_equal(hsh.keys, ['z','a','c'])
+      assert_not_equal(hsh, hsh2)
+    end
+
+    def test_dont_preserve
+      # but this don't preserve order
+      hsh = OHash['z'=>1, 'a'=>2, 'c'=>3]
+      hsh2 = OHash['a'=>2, 'z'=>1, 'c'=>3]
+      assert_equal(hsh, hsh2)
+    end
+
+    def test_unorderd_empty
+      check_ordered({}, [[2, 3], [4, 3]])
+    end
+
+    def test_little_ordered
+      a = (0..11).to_a
+      h = OHash[*a]
+      assert_equal(h.to_s, a.to_s)
+    end
+    
+    def test_big_ordered
+      a = (0..501).to_a
+      h = OHash[*a]
+      assert_equal(h.to_s, a.to_s)
+    end
+
+    def test_eql
+      assert_nothing_raised { OHash.new == {} }
+      assert_not_equal OHash.new, {}
+      assert_equal OHash.new, OHash.new
+      assert_equal OHash[1,2,3,4], OHash[1,2,3,4]
+      assert_not_equal OHash[1,2,3,4], OHash[3,4,1,2]
+    end
+    
+  end # OrderedHashTest
+
+end

data/ruby_ex/pathname_ex.rb

@@ -0,0 +1,152 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: ertai $
+# $Id: pathname_ex.rb 215 2005-05-08 10:58:49Z ertai $
+
+
+require 'pathname'
+require 'fileutils_ex'
+
+
+class Pathname
+
+  def ensure_mkdir
+    (mkdir) rescue Errno::EEXIST
+  end
+
+  def ensure_mkpath
+    (mkpath) rescue Errno::EEXIST
+  end
+
+  def extsplit ( aChar='.' )
+    raise ArgumentError, "#{aChar} is not just a char" if aChar.size != 1
+    aChar = Regexp.escape(aChar)
+    to_s =~ /^(.*?)(#{aChar}[^#{aChar}]*)?$/
+    [Pathname.new($1), $2 || '']
+  end
+
+  def cp ( aPath )
+    FileUtils.cp self.to_s, aPath.to_s
+  end
+
+  def cp_r ( aPath )
+    FileUtils.cp_r self.to_s, aPath.to_s
+  end
+
+  def cp_rf ( aPath )
+    FileUtils.cp_rf self.to_s, aPath.to_s
+  end
+
+  def rm
+    FileUtils.rm self.to_s
+  end
+
+  def rm_r
+    FileUtils.rm_r self.to_s
+  end
+
+  def rm_rf
+    FileUtils.rm_rf self.to_s
+  end
+
+  def rm_f
+    FileUtils.rm_f self.to_s
+  end
+
+  # Allow this kind of things:
+  #
+  #  root = Pathname.new('/tmp/test')
+  #  foo, bar = 'foo', 'bar'
+  #
+  #  ...
+  #
+  #  (root/foo/bar).each_line do |line|
+  #    ...
+  #  end
+  alias :/ :+
+
+  def to_io
+    @open_mode ||= 'r'
+    open(@open_mode)
+  end
+
+  attr_accessor :open_mode
+
+  module ShortCut
+
+    # Allow to use this sort of constructions:
+    #
+    #  `/path/to/a/file`.open do |f|
+    #    ...
+    #  end
+    def ` ( path )
+      Pathname.new(path)
+    end
+  end
+
+end # class Pathname
+
+
+
+class String
+
+  def to_path
+    Pathname.new(self)
+  end
+
+end # class String
+
+
+
+#
+# Unit test suite
+#
+if defined? TEST_MODE or $0 == __FILE__
+
+
+require 'test/unit'
+require 'tempfile'
+
+
+class PathnameExTest < Test::Unit::TestCase
+
+  #
+  # Tests
+  #
+  def test_ensure_dir
+    p = nil
+    begin
+      name = Tempfile.new('pathname')
+      p = Pathname.new(name.path)
+      name.delete
+      assert(! p.directory?, 'no directory')
+      assert_nothing_raised { p.ensure_mkdir }
+      assert(p.directory?, 'directory')
+      assert_nothing_raised { p.ensure_mkdir }
+      assert(p.directory?, 'still directory')
+    ensure
+      p.rmdir unless p.nil?
+    end
+  end
+
+  include Pathname::ShortCut
+
+  def test_simple
+    assert_equal([`path.ext1`, '.ext2'], `path.ext1.ext2`.extsplit)
+    assert_equal([`path`, ''], `path`.extsplit)
+    assert_equal([`path`, '.'], `path.`.extsplit)
+    assert_equal([`path`, '-ext'], `path-ext`.extsplit('-'))
+    assert_equal([`path-ext1`, '-ext2'], `path-ext1-ext2`.extsplit('-'))
+  end
+
+  def test_slash
+    assert_equal(`path/to/a/file`, `path`/'to'/'a'/'file')
+    path, to, a, file = `/path`, 'to', 'a', 'file'
+    assert_equal(`/path/to/a/file`, path/to/a/file)
+  end
+
+end # class PathnameExTest
+
+end

data/ruby_ex/pp_hierarchy.rb

@@ -0,0 +1,29 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: polrop $
+# $Id: hierarchy.rb 145 2005-01-30 14:16:14Z polrop $
+
+
+class Hash
+
+  # Pretty print a hash symbolizing a class hierarchy.
+  def pp_hierarchy(prefix=//, abstract=false)
+    pp_hierarchy_rec('', prefix, abstract)
+  end
+
+  protected
+  def pp_hierarchy_rec(indent, prefix, abstract)
+    self.each do |k, v|
+      k_str = k.to_s.sub(prefix, '')
+      if abstract and k.abstract?
+        puts "#{indent}/#{k_str}/"
+      else
+        puts "#{indent}#{k_str}"
+      end
+      v.pp_hierarchy_rec(indent + '  ', prefix, abstract)
+    end
+  end
+
+end # class Hash

data/ruby_ex/pseudo_cache.rb

@@ -0,0 +1,190 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: ertai $
+# $Id: pseudo_cache.rb 186 2005-04-03 00:07:45Z ertai $
+
+
+require 'pathname'
+require 'md5'
+
+require 'md5sum'
+
+
+class PseudoCache
+
+  #
+  # Constants
+  #
+  DEFAULT_CACHE_REPOSITORY = '/var/cache/ruby_ex_cache'
+
+  #
+  # Constructor
+  #
+  def initialize(repository=DEFAULT_CACHE_REPOSITORY)
+    @repository = check_repository(repository)
+  end
+
+  #
+  # Methods
+  #
+  def get_key(name)
+    Pathname.new(Digest::MD5.new(name).to_s)
+  end
+
+  def get_full_key(name)
+    @repository + Digest::MD5.new(name).to_s
+  end
+
+  alias [] get_full_key
+
+  def get_name(name)
+    name = get_full_key(name) + 'name'
+    name.open('r') { |f| return f.gets.chomp }
+  end
+
+  def get_md5sum(name)
+    md5 = get_full_key(name) + 'md5sum'
+    md5.open('r') { |f| return f.gets.chomp }
+  end
+
+  def present?(name)
+    get_full_key(name).directory?
+  end
+
+  def up_to_date?(name, md5sum)
+    (get_md5sum(name) == md5sum.to_s)
+  end
+
+  def add(name, &block)
+    key = get_full_key(name)
+    unless key.exist?
+      key.mkdir
+      (key + 'name').open('w') { |f| f.puts(name) }
+      data = key + 'data'
+      data.open('w', &block)
+      (key + 'md5sum').open('w') { |f| f.puts(File.md5sum(data).to_s) }
+    end
+    key
+  end
+
+  def read(name, &block)
+    key = get_full_key(name)
+    (key + 'data').open(&block)
+    key
+  end
+
+  def del(name)
+    key = get_full_key(name)
+    key.rmtree if key.exist?
+    key
+  end
+
+  def replace(name, new_name, &block)
+    add(new_name, &block)
+    del(name)
+  end
+
+  def each(&block)
+    @repository.each_entry do |p|
+      next if p.to_s =~ /^\./
+      (@repository + p + 'name').open('r') { |f| block[f.gets.chomp] }
+    end
+  end
+
+  def clear
+    @repository.rmtree
+  end
+
+  def create
+    @repository.mkdir
+  end
+
+  def recreate
+    clear
+    create
+  end
+
+  protected
+  def check_repository(repository)
+    repo = Pathname.new(repository)
+    unless (repo.directory? and
+            repo.writable? and
+            repo.readable? and
+            repo.executable?)
+      raise(ArgumentError, "`#{repository}' - bad repository")
+    end
+    repo
+  end
+
+end # class PseudoCache
+
+
+#
+# Unit test suite
+#
+if defined? TEST_MODE or __FILE__ == $0
+
+require 'test/unit/ui/yaml/testrunner'
+require 'mktemp'
+
+
+class PseudoCacheTest < Test::Unit::TestCase
+
+  #
+  # Tests
+  #
+  def test_simple
+    Tempfile.mktemp('cache') do |repo|
+      assert_raises(ArgumentError) { PseudoCache.new(repo) }
+      repo.mkdir
+      cache = nil
+      assert_nothing_raised { cache = PseudoCache.new(repo) }
+      assert_not_nil(cache)
+      assert(! cache.present?('toto'))
+      assert_raises(Errno::ENOENT) { cache.get_name('toto') }
+      assert_raises(Errno::ENOENT) { cache.get_md5sum('toto') }
+      assert_equal(cache['toto'],
+                   cache.add('toto') { |f| f.puts('toto'); f.puts('tata') })
+      assert(cache.present?('toto'))
+      assert_equal('toto', cache.get_name('toto'))
+      cache.read('toto') do |f|
+        assert_equal("toto\n", f.gets)
+        assert_equal("tata\n", f.gets)
+        assert(f.eof?)
+      end
+      assert(! cache.present?('tata'))
+      assert(cache.present?('toto'))
+      cache.replace('toto', 'tata') { |f| f.puts('foo'); f.puts('bar') }
+      assert(! cache.present?('toto'))
+      assert(cache.present?('tata'))
+      cache.read('tata') do |f|
+        assert_equal("foo\n", f.gets)
+        assert_equal("bar\n", f.gets)
+        assert(f.eof?)
+      end
+      assert_equal(cache.get_full_key('toto'),
+                   cache.add('toto') { |f| f.puts('toto'); f.puts('tata') })
+      assert(cache.up_to_date?('toto', cache.get_md5sum('toto')))
+      names = []
+      cache.each { |p| names << p }
+      assert_equal(2, names.size)
+      names.sort!
+      assert_equal('tata', names[0].to_s)
+      assert_equal('toto', names[1].to_s)
+      cache.del('toto')
+      assert(! cache.present?('toto'))
+      assert(cache.present?('tata'))
+      cache.clear
+      assert(! cache.present?('tata'))
+      cache.create
+      assert(! cache.present?('tata'))
+    end
+  end
+
+end # class PseudoCacheTest
+
+
+end
+