vcs 0.2.148 → 0.3.0

data/ruby_ex/module/hierarchy.rb

@@ -1,335 +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 194 2005-04-11 10:03:22Z polrop $
-
-
-# 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
-
-
-if (not defined? HIERARCHY_TESTED) and (defined? TEST_MODE or __FILE__ == $0)
-HIERARCHY_TESTED = true
-
-require 'test/unit/ui/console/testrunner'
-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
-
-

data/ruby_ex/module/instance_method_visibility.rb

@@ -1,73 +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: instance_method_visibility.rb 143 2005-01-30 14:06:43Z polrop $
-
-
-class Module
-
-  def instance_method_visibility(name)
-    if private_method_defined?(name)
-      :private
-    elsif protected_method_defined?(name)
-      :protected
-    elsif public_method_defined?(name)
-      :public
-    else
-      raise(NoMethodError,
-            "`#{name}' - not an instance method of `#{self.name}'")
-    end
-  end
-
-end # class Module
-
-
-if (not defined? INSTANCE_METHOD_VISIBILITY_TESTED) and
-    (defined? TEST_MODE or __FILE__ == $0)
-INSTANCE_METHOD_VISIBILITY_TESTED = true
-
-require 'test/unit/ui/console/testrunner'
-
-
-class InstanceMethodVisibilityTest < Test::Unit::TestCase
-
-  class A
-
-    def pub; end
-    def pri; end
-    def pro; end
-
-    public :pub
-    private :pri
-    protected :pro
-
-  end # class A
-
-  def test_simple
-    assert_equal(:public, A.instance_method_visibility('pub'))
-    assert_equal(:private, A.instance_method_visibility('pri'))
-    assert_equal(:protected, A.instance_method_visibility('pro'))
-    assert_raises(NoMethodError) { A.instance_method_visibility('new') }
-  end
-
-  class AA
-    def f; end
-  end
-  class BB < AA
-    private :f
-  end
-
-  def test_inheritance
-    assert_equal(:public, AA.instance_method_visibility('f'))
-    assert(! BB.public_method_defined?('f'))
-    assert_equal(:private, BB.instance_method_visibility('f'))
-  end
-
-end # class InstanceMethodVisibilityTest
-
-
-end
-
-

data/ruby_ex/module_ex.rb

@@ -1,11 +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: module_ex.rb 107 2005-01-17 03:31:39Z polrop $
-
-
-Dir["#{File.dirname(__FILE__)}/module/**/*.rb"].each do |filename|
-  require filename
-end

data/ruby_ex/node.rb

@@ -1,80 +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: node.rb 171 2005-03-29 09:12:47Z polrop $
-
-
-class Node
-
-  def initialize(data=nil, *sub_nodes)
-    @data = data
-    sub_nodes.each { |sub_node| check_sub_node_type(sub_node) }
-    @sub_nodes = sub_nodes
-  end
-
-  attr_reader :data, :sub_nodes
-
-  def [](sub_node_index)
-    @sub_nodes[sub_node_index]
-  end
-
-  def []=(sub_node_index, sub_node)
-    check_sub_node_type(sub_node)
-    @sub_nodes[sub_node_index] = sub_node
-  end
-
-  def <<(sub_node)
-    check_sub_node_type(sub_node)
-    @sub_nodes << sub_node
-  end
-
-  def each_pair(&block)
-    @sub_nodes.each_with_index { |sub_node, i| block[i, sub_node] }
-  end
-
-  def each_node(&block)
-    @sub_nodes.each_with_index { |sub_node, index| block[sub_node] }
-  end
-
-  alias :each :each_node
-
-  def each_index(&block)
-    @sub_nodes.each_with_index { |sub_node, index| block[index] }
-  end
-
-  def delete(sub_node)
-    @sub_nodes.delete(sub_node)
-  end
-
-  def nb_sub_nodes
-    @sub_nodes.size
-  end
-
-  alias size nb_sub_nodes
-  alias length nb_sub_nodes
-
-  def leaf?
-    @sub_nodes.empty?
-  end
-
-  def pre_depth_first(&block)
-    block[self]
-    @sub_nodes.each { |sub_node| sub_node.pre_depth_first(&block) }
-    nil
-  end
-
-#   FIXME: implement me
-#   def breadth_first(&block)
-#   end
-
-  protected
-  def check_sub_node_type(sub_node)
-    unless sub_node.is_a?(self.class)
-      raise(TypeError, "`#{sub_node}' - must be a #{self.class}")
-    end
-  end
-
-end # class Node
-