vcs 0.1 → 0.2.148

data/ruby_ex/labeled_node.rb

@@ -0,0 +1,63 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: polrop $
+# $Id: node.rb 171 2005-03-29 09:12:47Z polrop $
+
+
+require 'abstract_node'
+
+
+class LabeledNode < AbstractNode
+  include Concrete
+
+  def initialize(data=nil, *sub_nodes)
+    if sub_nodes.empty?
+      @sub_nodes = {}
+    else
+      @sub_nodes = sub_nodes.first
+    end
+    super
+  end
+
+  def merge!(sub_nodes)
+    sub_nodes.each { |index, sub_node| check_sub_node_type(sub_node) }
+    @sub_nodes.merge(sub_nodes)
+  end
+
+end # class LabeledNode
+
+
+if defined? TEST_MODE or __FILE__ == $0
+
+require 'test/unit'
+
+class LabeledNodeTest < Test::Unit::TestCase
+
+  def test_simple
+    s11 = LabeledNode.new(11)
+    s12 = LabeledNode.new(12)
+    s = LabeledNode.new(1, 0 => s11, 1 => s12)
+    assert_equal(1, s.data)
+    assert_equal(s11, s.sub_nodes[0])
+    assert_equal(s12, s.sub_nodes[1])
+  end
+
+  def test_crochet_equal
+    s = LabeledNode.new(1)
+    assert_nothing_raised { s[0] = LabeledNode.new(10) }
+    assert_raises(TypeError) { s[1] = nil }
+  end
+
+  def test_merge
+    s = LabeledNode.new(1)
+    s11 = LabeledNode.new(11)
+    s12 = LabeledNode.new(12)
+    s.merge!({ 0 => s11, 1 => s12 })
+  end
+
+end # class LabeledNodeTest
+
+end
+

data/ruby_ex/logger_observer.rb

@@ -0,0 +1,23 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: polrop $
+# $Id: logger_observer.rb 120 2005-01-22 19:43:06Z polrop $
+
+
+require 'logger'
+
+
+class Logger
+
+  def update(*args, &block)
+    severity = UNKNOWN
+    if args.size > 0
+      (severity = Severity.cons_get(args[0].to_s.upcase)) rescue NameError
+    end
+    add(severity, "#{args.inspect} #{block.inspect if block}", $PROGRAME_NAME)
+  end
+
+end # class Logger
+

data/ruby_ex/md5sum.rb

@@ -0,0 +1,66 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: polrop $
+# $Id: md5sum.rb 88 2005-01-09 21:11:26Z polrop $
+
+
+require 'md5'
+
+
+class File
+
+  def self.md5sum(filename)
+    md5 = Digest::MD5.new
+    IO.foreach(filename) { |l| md5 << l }
+    md5
+  end
+
+end # module File
+
+
+class Pathname
+
+  def md5sum
+    md5 = Digest::MD5.new
+    each_line { |l| md5 << l }
+    md5
+  end
+
+end # class Pathname
+
+
+#
+# Unit test suite
+#
+if defined? TEST_MODE or __FILE__ == $0
+
+
+require 'test/unit/ui/yaml/testrunner'
+require 'mktemp'
+
+
+class MD5SumTest < Test::Unit::TestCase
+
+  #
+  # Tests
+  #
+  def test_simple
+    TempPath.new('src_md5sum') do |tmp_filename|
+      assert(system("man printf > #{tmp_filename} 2> /dev/null"),
+             'can\'t generate a tmp file from man printf')
+      ref_md5sum = ''
+      IO.popen("md5sum #{tmp_filename}") do |io|
+        ref_md5sum = io.gets.chomp.sub(/\s+#{tmp_filename}$/, '')
+      end
+      assert_equal(ref_md5sum, File.md5sum(tmp_filename).to_s)
+      assert_equal(ref_md5sum, tmp_filename.md5sum.to_s)
+    end
+  end
+
+end # class MD5SumTest
+
+
+end
+

data/ruby_ex/mktemp.rb

@@ -0,0 +1,208 @@
+# Copyright: Copyright (c) 2004  Nicolas Pouillard. All rights reserved.
+# Author: Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: ertai $
+# $Id: mktemp.rb 186 2005-04-03 00:07:45Z ertai $
+
+require 'pathname'
+require 'tempfile'
+require 'tmpdir'
+require 'set'
+require 'thread'
+
+class TempPath < Pathname
+
+  @@tmps = Set.new
+  @@mutex = Mutex.new
+  @@progname = Pathname.new($0).basename
+  @@tmpdir = Pathname.new(Dir.tmpdir) + "#{@@progname}.#{$$}"
+  @@tmpdir.freeze
+  @@initialized = false
+  @@clean_planned = false
+  @@auto_clean = true
+
+  # You can use a temporary pathname like that:
+  #
+  #  - # No argument are mandatory.
+  #    tmp = TempPath.new
+  #    tmp.open('w') { |f| f << 'foo' }
+  #    tmp.clean
+  #
+  #  - # You can choose the basename and an extension.
+  #    TmpPath.new('the_base_file_name', 'rb')
+  #
+  #  - # You can supply a block (recomended).
+  #    TmpPath.new('foo') do |tmp|
+  #      tmp.open('w') { |f| << 'foo' }
+  #      tmp.exist? == true
+  #      $tmp = tmp
+  #    end
+  #    $tmp.exist? == false
+  #
+  #  - # You can make a temporary directory.
+  #    TmpPath.new('adirectory') do |tmpdir|
+  #      tmpdir.mkpath
+  #      $file = tmpdir + 'foo'
+  #      $file.open('w') { |f| f << 'foo' }
+  #    end
+  #    $file.exist? == false
+  #
+  def initialize ( base=@@progname, ext='', &block )
+    if base.to_s =~ /\//
+      raise ArgumentError, "bad basename, you give me a pathname #{base}"
+    end
+    self.class.init
+    ext = ".#{ext}" unless ext.empty? or ext[0] == ?.
+    res = nil
+    @@mutex.synchronize do
+      id_tmp = object_id
+      while (res = @@tmpdir + "#{base}.#{id_tmp}#{ext}").exist? \
+        and not @@tmps.include? res
+        id_tmp += 1
+      end
+      super(res)
+      @@tmps << self
+    end
+    if block_given?
+      begin
+        block[self.dup]
+      ensure
+        clean
+      end
+    end
+  end
+
+  # This method remove your temporary pathname.
+  # You do not need to call this method if you provide
+  # a block when you create a tempfile.
+  def clean
+    if exist?
+      if directory?
+        rmtree
+      else
+        unlink
+      end
+    end
+  end
+
+  def temp?
+    true
+  end
+
+  def self.init #:nodoc:
+    return if @@initialized
+    @@mutex.synchronize do
+      return if @@initialized
+      @@tmpdir.mkpath
+      @@initialized = true
+      at_exit { clean if @@auto_clean }
+    end
+  end
+
+  # By default the autoclean is on.
+  # But in some case (if you use your temppaths in at_exit)
+  # You must disable the autoclean.
+  # And manually call TempPath.clean at the very of the program.
+  def self.clean ( &block )
+    @@mutex.synchronize do
+      return if @@clean_planned
+      @@clean_planned = true
+    end
+    begin
+      block[] if block_given?
+    ensure
+      if @@tmpdir.exist?
+        @@tmpdir.rmtree 
+        @@initialized = false
+      end
+    end
+  end
+
+  def self.auto_clean= ( aBool )
+    @@auto_clean = aBool
+  end
+
+  def self.tmpdir
+    init
+    @@tmpdir
+  end
+
+end # class TempPath
+
+
+# This tempfile extension, provide the mktemp function.
+#
+# Example:
+#
+# Tempfile.mktemp('foo', 'rb')
+#   => 'foo.111811.432.rb'
+# which follow this format:
+#   => 'base.pid.uniq.ext
+#
+# Tempfile.mktemp('bar')
+#   => 'foo.111811.134'
+# 
+class Tempfile
+
+  # Almost deprecated use TempPath.
+  def self.mktemp ( base=$0, ext='', &block )
+    TempPath.new(base, ext, &block)
+  end
+
+end # class Tempfile
+
+
+class Pathname
+
+  def temp?
+    false
+  end
+
+end # class Pathname
+
+
+
+if defined? TEST_MODE or $0 == __FILE__
+
+  require 'test/unit'
+  class MkTempTest < Test::Unit::TestCase
+
+    def setup
+      @list = []
+    end
+
+    def teardown
+      @list.each { |l| l.clean }
+    end
+
+    def test_interface
+      assert_nothing_raised { @foo = Tempfile.mktemp('foo') }
+      assert_nothing_raised { @foobar = Tempfile.mktemp('foo', 'bar') }
+      assert_match(/\.#{$$}\/foo\.\d+$/, @foo.to_s)
+      assert_match(/\.#{$$}\/foo\.\d+\.bar$/, @foobar.to_s)
+      assert_nothing_raised { @foo.open('w') { |f| f.puts 'FooFoo'  }  }
+      @list << @foo
+      @list << @foobar
+    end
+
+    def test_many
+      (0 .. 100).each do |i|
+        tmp = Tempfile.mktemp('many')
+        tmp.open('w') { |f| f.puts "i: #{i}" }
+        assert(tmp.exist?)
+        assert_equal("i: #{i}\n", tmp.readlines.join)
+        @list << tmp
+      end
+    end
+
+    def test_temp?
+      tmp = Tempfile.mktemp('is_temp')
+      assert(tmp.temp?, 'not tmp.temp?')
+      assert_nothing_raised { Pathname.new(tmp.to_s).temp? }
+      assert(!Pathname.new(tmp.to_s).temp?)
+    end
+
+  end # class MkTempTest
+
+end

data/ruby_ex/module/attr_once.rb

@@ -0,0 +1,36 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: polrop $
+# $Id: attr_once.rb 135 2005-01-28 12:43:31Z polrop $
+
+
+class Module
+
+  # You can use this method as you use attr_reader. Must be used only with
+  # immutable object.
+  #
+  # This method is imported from the Date implementation. It provides a way
+  # to compute only once the value of getter. Basically, the first time, the
+  # getter is used, its result is computed and stored in an attribute with the
+  # same name. The second times only the attribute is returned.
+  def attr_once(*ids)
+    for id in ids
+      module_eval <<-"end;", __FILE__, __LINE__
+        alias_method :__#{id.to_i}__, :#{id.to_s}
+        private :__#{id.to_i}__
+        def #{id.to_s}(*args, &block)
+        if defined? @__#{id.to_i}__
+            @__#{id.to_i}__
+          elsif ! self.frozen?
+            @__#{id.to_i}__ ||= __#{id.to_i}__(*args, &block)
+          else
+            __#{id.to_i}__(*args, &block)
+          end
+        end
+      end;
+    end
+  end
+
+end # class Module

data/ruby_ex/module/autoload_tree.rb

@@ -0,0 +1,75 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: ertai $
+# $Id: autoload_tree.rb 217 2005-05-09 12:01:07Z ertai $
+
+
+require 'pathname_ex'
+
+
+class Module
+
+  def autoload_tree(dir, recursive=true, &block)
+    pdir = Pathname.new(dir)
+    pdir.each_entry do |p|
+      next if p.to_s =~ /^\./
+      pfull = pdir + p
+      if pfull.directory? and recursive
+        name = p.to_s.capitalize!
+        const_set(name, Module.new) unless const_defined?(name)
+        const_get(name).autoload_tree(pfull, recursive, &block)
+      elsif pfull.file? and p.to_s =~ /\.rb$/
+        autoload(name.to_s, pfull.to_s) if name = block[p]
+      end
+    end
+  end
+
+  def autoloaded_module ( file )
+    dir = file.sub(/\.rb$/, '').to_path
+    autoload_tree(dir) do |path|
+      path.basename.to_s.sub(/\.rb$/, '').gsub(/(?:^|_)([a-z])/) { $1.upcase }
+    end
+  end
+
+end # class Module
+
+
+if (not defined? AUTOLOAD_TREE_TESTED) and
+    (defined? TEST_MODE or __FILE__ == $0)
+AUTOLOAD_TREE_TESTED = true
+
+require 'test/unit/ui/console/testrunner'
+
+
+class AutoloadTreeTest < Test::Unit::TestCase
+
+  if defined? SRC_DIR
+    REPO_DIR = SRC_DIR + Pathname.new('../test/resources/autoload_tree')
+  else
+    REPO_DIR = Pathname.new(__FILE__).dirname +
+               Pathname.new('../../test/resources/autoload_tree')
+  end
+
+  module AutoloadTree; end
+
+  #
+  # Test
+  #
+  def test_autoload_tree
+    $: << REPO_DIR
+    AutoloadTree.autoload_tree(REPO_DIR) { |p| p.to_s.sub!(/\.rb$/, '') }
+    ["Foo", "B", "A"].each do |x|
+      assert(AutoloadTree.constants.include?(x), "#{x} is missing")
+    end
+    assert_equal(["C"], AutoloadTree::Foo.constants)
+    $:.delete(REPO_DIR)
+  end
+
+end # class AutoloadTreeTest
+
+
+end
+
+