ruby_ex 0.1.2 → 0.2.0

data/lib/mocks/observer.rb

@@ -0,0 +1,38 @@
+# Copyright:: Copyright (c) 2005  Nicolas Pouillard. All rights reserved.
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# License::   Gnu General Public License.
+# Revision::  $Id: observer.rb 339 2005-09-06 23:27:27Z ertai $
+
+require 'mocks'
+
+module Mocks
+
+  class Observer < Mock
+    concrete
+
+    def update ( *args, &block )
+      mock_add MethodCall.new(:update, *args, &block)
+    end
+
+  end # class Observer
+
+  test_section __FILE__ do
+
+    class TestObserver < ::Test::Unit::TestCase
+
+      def setup
+        @proc = proc { 43 }
+        @obj = Mocks::Observer.new
+      end
+
+      def test_simple
+        @obj.update(:foo, :bar, 42, &@proc)
+        @obj.update(:bar)
+        assert_equal([[:foo, :bar, 42], [:bar]], @obj.mock_args)
+      end
+
+    end # class TestObserver
+
+  end
+
+end # module Mocks

data/lib/module/autoload_tree.rb

@@ -1,15 +1,10 @@
-# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
-# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
-# License: Gnu General Public License.
+# Copyright:: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author::    Nicolas Despres  <polrop@lrde.epita.fr>.
+# License::   Gnu General Public License.
+# Revision::  $Id: autoload_tree.rb 339 2005-09-06 23:27:27Z ertai $
 
-# $LastChangedBy: ertai $
-# $Id: autoload_tree.rb 279 2005-06-05 17:46:53Z ertai $
 
-
-require 'ruby_ex'
-
-
-class Module
+module AutoloadTree
 
   def autoload_tree(dir, recursive=true, &block)
     pdir = Pathname.new(dir)
@@ -33,33 +28,39 @@ class Module
     end
   end
 
-end # class Module
+end # module AutoloadTree
+
+class Module
 
+  include AutoloadTree
 
-test_section __FILE__ do
+end # class Module
 
-class AutoloadTreeTest < Test::Unit::TestCase
+module AutoloadTree
 
-  REPO_DIR = __FILE__.to_path.dirname.parent.parent + 'test/resources/autoload_tree'
+  test_section __FILE__ do
 
-  module AutoloadTree; end
+    class AutoloadTreeTest < Test::Unit::TestCase
 
-  #
-  # 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
+      REPO_DIR = __FILE__.to_path.dirname.parent.parent + 'test/resources/autoload_tree'
 
-end # class AutoloadTreeTest
+      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
+    end # class AutoloadTreeTest
 
+  end
 
+end # module AutoloadTree

data/lib/module/hierarchy.rb

@@ -3,13 +3,12 @@
 # License: Gnu General Public License.
 
 # $LastChangedBy: polrop $
-# $Id: hierarchy.rb 279 2005-06-05 17:46:53Z ertai $
+# $Id: hierarchy.rb 339 2005-09-06 23:27:27Z ertai $
 
-require 'ruby_ex'
 
 # Extend the Module class with method to manipulate inheritance relation
 # between constants of a module.
-class Module
+module Hierarchy
 
   # Return the list of all sub classes of base_class (including itself).
   # If force_autoload is false, not yet loaded constants will be ignored.
@@ -37,7 +36,7 @@ class Module
   # 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}::")
+    re = /^#{name}::/
     result = []
     subs.each do |sub|
       sub_name = sub.to_s.sub!(re, '')
@@ -118,9 +117,9 @@ class Module
   private
   def sub_classes_tree_rec(base_classes, csts)
     result = {}
-    next_csts = []
+    next_csts = Set.new
     base_classes.each do |b|
-      next_base_classes = []
+      next_base_classes = Set.new
       csts.each do |c|
         c.superclass == b ? next_base_classes << c : next_csts << c;
       end
@@ -136,199 +135,205 @@ class Module
     end
   end
 
+end # module Hierarchy
+
+class Module
+
+  include Hierarchy
+
 end # class Module
 
+module Hierarchy
 
-test_section __FILE__ do
+  test_section __FILE__ do
 
-require 'diff'
+    require 'diff'
 
 
-class HierarchyTest < Test::Unit::TestCase
+    class HierarchyTest < Test::Unit::TestCase
 
-  module M
+      module M
 
-    class A; end
-    class B < A; end
-    class C; end
-    FOO = 42
+        class A; end
+        class B < A; end
+        class C; end
+        FOO = 42
 
-  end
+      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
+      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
+      module Mautoload
 
-    class A; end
-    class B < A; end
-    autoload(:C, '/foo')
-    FOO = 42
+        class A; end
+        class B < A; end
+        autoload(:C, '/foo')
+        FOO = 42
 
-  end
+      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
+      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_raise(MissingSourceFile, 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
+      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
+      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
+      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
+      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=>{}
+      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=>{}
             }
           }
-        },
-        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
+        d = r.diff(ref)
+        assert_equal({}, d[:different])
+        assert_equal({}, d[:additional])
+        assert_equal({}, d[:missing])
+      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
+      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 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
+      module Error
+        module M; end
+      end
 
-  end
+      def test_sub_classes_error
+        assert_raise(TypeError) do
+          Error.sub_classes_tree(HierarchyTest::Error::M)
+        end
+        assert_raise(TypeError) do
+          Error.sub_classes(HierarchyTest::Error::M)
+        end
+        assert_raise(TypeError) do
+          Error.remove_class(HierarchyTest::Error::M)
+        end
+      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
+      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 # class HierarchyTest
+      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
+    end # class HierarchyTest
 
+  end
 
+end # module Hierarchy