vcs 0.1 → 0.2.148

data/ruby_ex/module/hierarchy.rb

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

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

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

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