ruby_ex 0.1.1

data/src/ioo.rb

@@ -0,0 +1,193 @@
+# Copyright: Copyright (c) 2004  Nicolas Pouillard. All rights reserved.
+# Author: Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: ertai $
+# $Id: ioo.rb 266 2005-06-01 14:27:18Z ertai $
+
+require 'delegate'
+require 'ruby_ex'
+
+# With this class you can easily overwrite only write or read methods
+# to change the whole IO.
+#
+# This is very usefull to produce a crypted IO for example.
+module ImplIOO
+
+  def << ( obj )
+    write obj
+    self
+  end
+
+  def each ( sep_string=$/, &block )
+    begin
+      loop { block[readline(sep_string)] }
+    rescue EOFError
+      return self
+    end
+  end
+  alias :each_line :each
+
+  def each_byte ( &block )
+    begin
+      loop { block[readchar] }
+    rescue EOFError
+      return nil
+    end
+  end
+
+  def getc
+    begin
+      readchar
+    rescue EOFError
+      nil
+    end
+  end
+
+  def gets ( sep_string=$/ )
+    begin
+      readline(sep_string)
+    rescue EOFError
+      nil
+    end
+  end
+
+  def print ( *args )
+    if args.empty?
+      write $_
+    else
+      args.each { |x| write x }
+    end
+    nil
+  end
+
+  def printf ( fmt, *args )
+    write Kernel.sprintf(fmt, *args)
+    nil
+  end
+
+  def putc ( c )
+    case c
+    when Numeric then write c.chr
+    when String
+      if c.size == 1
+        write c
+      else
+        c = c[0].chr
+        write c
+      end
+    else
+      c = c.to_s[0].chr
+      write c
+    end
+    c
+  end
+
+  def puts ( *args )
+    if args.size == 0
+      write "\n"
+    else
+      args.each do |x|
+        x = x.to_s
+        write x
+        write "\n" unless x[-1] == ?\n
+      end
+    end
+    nil
+  end
+
+  def readchar
+    raise EOFError if eof?
+    read(1)[0]
+  end
+
+  def readline ( sep_string=$/ )
+    raise EOFError if eof?
+    buf = ''
+    begin
+      while (char = readchar) != ?\n
+        buf += char.chr
+      end
+      return buf + char.chr
+    rescue EOFError
+      return buf
+    end
+  end
+
+  def readlines ( sep_string=$/ )
+    res = []
+    each_line(sep_string) { |line| res << line }
+    res
+  end
+
+end # module ImplIOO
+
+class IOO < DelegateClass(IO)
+  include ImplIOO
+end # class IOO
+
+require 'socket'
+class TCPSocket
+  alias :real_send :send
+  alias :real_recv :recv
+end
+
+class IOOTCPSocket < DelegateClass(TCPSocket)
+  include ImplIOO
+
+  def recv ( integer, flags=nil )
+    read(integer)
+  end
+
+  def read ( integer=nil, buffer='' )
+    raise ArgumentError unless buffer.is_a? String
+    raise NotImplementedError if integer.nil?
+    raise ArgumentError unless integer.is_a? Numeric
+    buffer += real_recv(integer, 0)
+    return buffer
+  end
+
+  def send ( obj, flags=nil )
+    write(obj)
+  end
+
+  def write ( obj )
+    real_send(obj.to_s, 0)
+    nil
+  end
+
+end # class IOOTCPSocket
+
+
+test_section __FILE__ do
+
+  class TestIOO < Test::Unit::TestCase
+
+    def setup
+      @tmp = TempPath.new('ioo')
+      @tmp.open('w') do |tmp|
+        tmp.puts 'foo'
+        tmp.puts
+        tmp.puts 'bar'
+      end
+      @readlines = @tmp.readlines
+    end
+
+    def teardown
+      @tmp.clean
+      @tmp = nil
+    end
+      
+    def test_readlines
+      @tmp.open do |tmp|
+        assert_not_nil(tmp)
+        f = nil
+        assert_nothing_raised { f = IOO.new(tmp) }
+        assert_not_nil(f)
+        assert_equal(@readlines, f.readlines)
+      end
+    end
+
+  end # class TestIOO
+
+end

data/src/labeled_node.rb

@@ -0,0 +1,62 @@
+# 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 'ruby_ex'
+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
+
+
+test_section __FILE__ do
+
+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/src/logger_observer.rb

@@ -0,0 +1,24 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: ertai $
+# $Id: logger_observer.rb 266 2005-06-01 14:27:18Z ertai $
+
+
+require 'ruby_ex'
+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/src/md5sum.rb

@@ -0,0 +1,70 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: ertai $
+# $Id: md5sum.rb 266 2005-06-01 14:27:18Z ertai $
+
+
+require 'ruby_ex'
+require 'md5'
+
+
+class File
+
+  def self.md5sum(filename)
+    md5 = Digest::MD5.new
+    IO.foreach(filename) { |l| md5 << l }
+    md5
+  end
+
+  def md5sum
+    md5 = Digest::MD5.new
+    each { |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
+#
+test_section __FILE__ do
+
+
+require 'ruby_ex'
+
+
+class MD5SumTest < Test::Unit::TestCase
+
+  def setup
+    @source = __FILE__.to_path.dirname.parent + 'test/resources/foo.txt'
+    @ref = '9508b4f53cff19cf42c5a0f0fc127602'
+  end
+
+  #
+  # Tests
+  #
+  def test_simple
+    assert_equal(@ref, @source.md5sum.to_s)
+    assert_equal(@ref, File.md5sum(@source).to_s)
+    assert_equal(@ref, @source.open { |f| f.md5sum.to_s })
+  end
+
+end # class MD5SumTest
+
+
+end
+

data/src/module/autoload_tree.rb

@@ -0,0 +1,65 @@
+# 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 266 2005-06-01 14:27:18Z ertai $
+
+
+require 'ruby_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_sym, pfull.to_s) if name = block[p]
+      end
+    end
+  end
+
+  def autoloaded_module ( file, recursive=true )
+    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
+
+
+test_section __FILE__ do
+
+class AutoloadTreeTest < Test::Unit::TestCase
+
+  REPO_DIR = __FILE__.to_path.dirname.parent.parent + 'test/resources/autoload_tree'
+
+  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
+
+

data/src/module/hierarchy.rb

@@ -0,0 +1,334 @@
+# 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 266 2005-06-01 14:27:18Z ertai $
+
+require 'ruby_ex'
+
+# Extend the Module class with method to manipulate inheritance relation
+# between constants of a module.
+class Module
+
+  # Return the list of all sub classes of base_class (including itself).
+  # If force_autoload is false, not yet loaded constants will be ignored.
+  # If recursive is true sub modules will also be traversed.
+  def sub_classes(base_class, force_autoload=false, recursive=false)
+    check_const_is_class?(base_class)
+    result = []
+    constants.each do |const_name|
+      if autoload?(const_name).nil? or force_autoload
+        const = const_get(const_name)
+        if const.is_a?(Module)
+          if const.is_a?(Class)
+            result << const if const.ancestors.include?(base_class)
+          elsif recursive
+            result += const.sub_classes(base_class, force_autoload, recursive)
+          end
+        end
+      end
+    end
+    result
+  end
+
+  # Remove a class from the hierarchy using remove_const. Sub classes of this
+  # class are also removed. It returns an array of the removed class name.
+  # See sub_classes for a description of the recursive argument.
+  def remove_class(base_class, recursive=false)
+    subs = sub_classes(base_class, true, recursive)
+    re = Regexp.new("^#{name}::")
+    result = []
+    subs.each do |sub|
+      sub_name = sub.to_s.sub!(re, '')
+      if sub_name =~ /^(.+)::(.+)$/
+        const_get($1).module_eval { remove_const($2.to_sym) }
+      else
+        remove_const(sub_name.to_sym)
+      end
+      result << sub_name
+    end
+    result
+  end
+
+  # Return the inheritance tree of the base_class.
+  # Example:
+  #
+  # module M
+  #   class A; end
+  #   class B < A; end
+  #   class C < B; end
+  #   class D < B; end
+  #   class E < A; end
+  #   module N
+  #     class F < A; end
+  #     class G < F; end
+  #     class H < D; end
+  #     class I < H; end
+  #     class J < E; end
+  #     class Y; end
+  #   end
+  #   class Z; end
+  #   FOO = 42
+  # end
+  #
+  # M.sub_classes_tree(M::A)
+  #
+  # produces:
+  #
+  # {
+  #   M::A => {
+  #     M::B => {
+  #       M::D => {},
+  #       M::C => {}
+  #     },
+  #     M::E => {}
+  #   }
+  # }
+  #
+  # and
+  #
+  # M.sub_classes_tree(M::A, false, true)
+  #
+  # produces:
+  #
+  # {
+  #   M::A => {
+  #     M::N::F => {
+  #       M::N::G => {}
+  #     },
+  #     M::B => {
+  #       M::C => {},
+  #       M::D => {
+  #         M::N::H => {
+  #           M::N::I => {}
+  #         }
+  #       }
+  #     },
+  #     M::E => {
+  #       M::N::J => {}
+  #     }
+  #   }
+  # }
+  def sub_classes_tree(base_class, force_autoload=false, recursive=false)
+    subs = sub_classes(base_class, force_autoload, recursive)
+    sub_classes_tree_rec([base_class], subs)
+  end
+
+  private
+  def sub_classes_tree_rec(base_classes, csts)
+    result = {}
+    next_csts = []
+    base_classes.each do |b|
+      next_base_classes = []
+      csts.each do |c|
+        c.superclass == b ? next_base_classes << c : next_csts << c;
+      end
+      result[b] = sub_classes_tree_rec(next_base_classes, next_csts)
+    end
+    result
+  end
+
+  private
+  def check_const_is_class?(*base_classes)
+    base_classes.each do |b|
+      raise(TypeError, "`#{b}' - not a class") unless b.is_a?(Class)
+    end
+  end
+
+end # class Module
+
+
+test_section __FILE__ do
+
+require 'diff'
+
+
+class HierarchyTest < Test::Unit::TestCase
+
+  module M
+
+    class A; end
+    class B < A; end
+    class C; end
+    FOO = 42
+
+  end
+
+  def test_sub_classes
+    sub_classes = M.sub_classes(HierarchyTest::M::A)
+    assert_equal(2, sub_classes.size)
+    [HierarchyTest::M::B, HierarchyTest::M::A].each do |x|
+      assert(sub_classes.include?(x))
+    end
+    assert_equal([HierarchyTest::M::C], M.sub_classes(M::C))
+  end
+
+  module Mautoload
+
+    class A; end
+    class B < A; end
+    autoload(:C, '/foo')
+    FOO = 42
+
+  end
+
+  def test_sub_classes_force_autoload
+    sub_classes = Mautoload.sub_classes(Mautoload::A)
+    assert_equal(2, sub_classes.size)
+    [Mautoload::B, Mautoload::A].each do |x|
+      assert(sub_classes.include?(x))
+    end
+    assert_equal(4, Mautoload.constants.size)
+    assert_not_nil(Mautoload.autoload?(:C))
+    assert_raises(LoadError) { Mautoload.sub_classes(Mautoload::A, true) }
+    assert_equal(3, Mautoload.constants.size)
+    assert_nil(Mautoload.autoload?(:C))
+  end
+
+  module Mrec
+    class A; end
+    class B < A; end
+    module M
+      class C < A; end
+      class D < B; end
+      class E < D; end
+      class Y; end
+    end
+    class Z; end
+    FOO = 42
+  end
+
+  def test_sub_classes_recursive
+    sub_classes = Mrec.sub_classes(Mrec::A)
+    assert_equal(2, sub_classes.size)
+    [Mrec::B, Mrec::A].each do |x|
+      assert(sub_classes.include?(x))
+    end
+    sub_classes = Mrec.sub_classes(Mrec::A, false, true)
+    assert_equal(5, sub_classes.size)
+    [Mrec::B, Mrec::A, Mrec::M::C, Mrec::M::D, Mrec::M::E].each do |x|
+      assert(sub_classes.include?(x))
+    end
+    r = Mrec.remove_class(Mrec::A, true)
+    assert_equal(5, r.size)
+    ['B', 'A', 'M::E', 'M::C', 'M::D'].each do |x|
+      assert(r.include?(x))
+    end
+    assert_equal(3, Mrec.constants.size)
+    ['FOO', 'M', 'Z'].each { |x| assert(Mrec.constants.include?(x)) }
+    assert_equal(1, Mrec::M.constants.size)
+    ['Y'].each { |x| assert(Mrec::M.constants.include?(x)) }
+  end
+
+  module Tree
+
+    class A; end
+    class B < A; end
+    class C < B; end
+    class D < B; end
+    class E < A; end
+    module M
+      class F < A; end
+      class G < F; end
+      class H < D; end
+      class I < H; end
+      class J < E; end
+      class Y; end
+    end
+    class Z; end
+    FOO = 42
+
+  end
+
+  def test_sub_classes_tree_rec
+    r = Tree.sub_classes_tree(HierarchyTest::Tree::A, false, true)
+    ref = {
+      HierarchyTest::Tree::A => {
+        HierarchyTest::Tree::M::F => {
+          HierarchyTest::Tree::M::G => {}
+        },
+        HierarchyTest::Tree::B => {
+          HierarchyTest::Tree::C => {},
+          HierarchyTest::Tree::D => {
+            HierarchyTest::Tree::M::H => {
+              HierarchyTest::Tree::M::I=>{}
+            }
+          }
+        },
+        HierarchyTest::Tree::E=> {
+          HierarchyTest::Tree::M::J=>{}
+        }
+      }
+    }
+    d = r.diff(ref)
+    assert_equal({}, d[:different])
+    assert_equal({}, d[:additional])
+    assert_equal({}, d[:missing])
+  end
+
+  def test_sub_classes_tree
+    r = Tree.sub_classes_tree(HierarchyTest::Tree::A)
+    ref = {
+      HierarchyTest::Tree::A => {
+        HierarchyTest::Tree::B => {
+          HierarchyTest::Tree::D => {},
+          HierarchyTest::Tree::C => {}
+        },
+        HierarchyTest::Tree::E => {}
+      }
+    }
+    d = r.diff(ref)
+    assert_equal({}, d[:different])
+    assert_equal({}, d[:additional])
+    assert_equal({}, d[:missing])
+  end
+
+  module Error
+    module M; end
+  end
+
+  def test_sub_classes_error
+    assert_raises(TypeError) do
+      Error.sub_classes_tree(HierarchyTest::Error::M)
+    end
+    assert_raises(TypeError) do
+      Error.sub_classes(HierarchyTest::Error::M)
+    end
+    assert_raises(TypeError) do
+      Error.remove_class(HierarchyTest::Error::M)
+    end
+  end
+
+  module RemoveClass
+
+    class A; end
+    class B < A; end
+    class C < B; end
+    class D < B; end
+    class E < D; end
+    class F < A; end
+    class Z; end
+    module M
+      class Y; end
+    end
+    BAR = 51
+
+  end
+
+  def test_remove_class
+    r = RemoveClass.remove_class(HierarchyTest::RemoveClass::B)
+    assert_equal(4, r.size)
+    ['B', 'D', 'E', 'C'].each { |x| assert(r.include?(x)) }
+    assert_equal(5, RemoveClass.constants.size)
+    ['A', 'F', 'Z', 'M', 'BAR'].each do |x|
+      assert(RemoveClass.constants.include?(x))
+    end
+  end
+
+end # class HierarchyTest
+
+
+end
+
+