vcs 0.2.148 → 0.3.0

data/ruby_ex/orderedhash.rb

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

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

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

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