ruby_ex 0.4.6.1 → 0.4.6.2

data/NEWS

@@ -1,3 +1,7 @@
+= New in 0.4_p2, 2006-03-11:
+
+    Fix a bug in the pathname substitution inside symbol tables.
+
 = New in 0.4_p1, 2006-03-10:
 
     Fix a bug in sendmail.rb with recents ruby versions.

data/SPEC.yml

@@ -1,9 +1,9 @@
 ---
 Author: The Uttk Team.
 License: Ruby License
-Revision: '$Id: /w/fey/ruby_ex/trunk/SPEC.yml 22255 2006-02-26T14:19:43.502502Z pouillar  $'
+Revision: '$Id: /w/fey/ruby_ex/trunk/SPEC.yml 22445 2006-03-11T15:56:04.480135Z pouillar  $'
 
-version: !feydakins.org,2006/version dev-ruby/ruby_ex-0.4_p1
+version: !feydakins.org,2006/version dev-ruby/ruby_ex-0.4_p2
 
 title: RubyEx -- General purpose Ruby extensions.
 summary: RubyEx contains general purpose Ruby extensions.
@@ -17,7 +17,7 @@ root_test_suite: test/check-pkg-ruby_ex.yml
 rdoc_dir: doc/html
 tags_url: svn://svn.feydakins.org/ruby_ex/tags
 trunk_url: svn://svn.feydakins.org/ruby_ex/trunk
-version_path: !path lib/ruby_ex.rb
+version_id.rb: !path lib/ruby_ex.rb
 
 rdoc_files: !filelist
   - README

data/lib/module/hierarchy.rb

@@ -1,339 +1,336 @@
-# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
-# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
-# License: Gnu General Public License.
-
-# $LastChangedBy: polrop $
-# $Id: /w/fey/ruby_ex/trunk/lib/module/hierarchy.rb 7944 2005-09-06T23:27:27.929371Z ertai  $
-
-
-# Extend the Module class with method to manipulate inheritance relation
-# between constants of a 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.
-  # 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)
+# Copyright:: Copyright (c) 2004, 2006  Nicolas Despres. All rights reserved.
+# Author::    Nicolas Despres  <polrop@lrde.epita.fr>.
+# License::   Gnu General Public License.
+# Revision::  $Id: /w/fey/ruby_ex/trunk/lib/module/hierarchy.rb 22446 2006-03-11T18:07:59.270837Z pouillar  $
+
+class Module
+
+  # Extend the Module class with method to manipulate inheritance relation
+  # between constants of a 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.
+    # 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
-    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 = /^#{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)
+
+    # 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 = /^#{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 << sub_name
+      result
     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 = Set.new
-    base_classes.each do |b|
-      next_base_classes = Set.new
-      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)
+
+    # 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
-    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)
+    private
+    def sub_classes_tree_rec(base_classes, csts)
+      result = {}
+      next_csts = Set.new
+      base_classes.each do |b|
+        next_base_classes = Set.new
+        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
-  end
 
-end # module Hierarchy
+    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
 
-class Module
+  end # module Hierarchy
 
   include Hierarchy
 
-end # class Module
-
-module Hierarchy
-
-  test_section __FILE__ do
+  module Hierarchy
 
-    require 'diff'
+    test_section __FILE__ do
 
+      require 'diff'
 
-    class HierarchyTest < Test::Unit::TestCase
 
-      module M
+      class HierarchyTest < Test::Unit::TestCase
 
-        class A; end
-        class B < A; end
-        class C; end
-        FOO = 42
+        module M
 
-      end
+          class A; end
+          class B < A; end
+          class C; end
+          FOO = 42
 
-      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
+        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
 
-        class A; end
-        class B < A; end
-        autoload(:C, '/foo')
-        FOO = 42
+        module Mautoload
 
-      end
+          class A; end
+          class B < A; end
+          autoload(:C, '/foo')
+          FOO = 42
 
-      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
+        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
-        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))
+        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
-        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))
+
+        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
-        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
+        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
+          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
+          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 => {}
+        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_raise(TypeError) do
-          Error.sub_classes_tree(HierarchyTest::Error::M)
+          d = r.diff(ref)
+          assert_equal({}, d[:different])
+          assert_equal({}, d[:additional])
+          assert_equal({}, d[:missing])
         end
-        assert_raise(TypeError) do
-          Error.sub_classes(HierarchyTest::Error::M)
+
+        module Error
+          module M; end
         end
-        assert_raise(TypeError) do
-          Error.remove_class(HierarchyTest::Error::M)
+
+        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
-      end
 
-      module RemoveClass
+        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
+          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
+        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))
+        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 # class HierarchyTest
+
+    end
 
-  end
+  end # module Hierarchy
 
-end # module Hierarchy
+end # class Module

data/lib/ruby_ex.rb

@@ -1,7 +1,7 @@
 # Copyright:: Copyright (c) 2005  Nicolas Pouillard. All rights reserved.
 # Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
 # License::   Gnu General Public License.
-# Revision::  $Id: /w/fey/ruby_ex/trunk/lib/ruby_ex.rb 22255 2006-02-26T14:19:43.502502Z pouillar  $
+# Revision::  $Id: /w/fey/ruby_ex/trunk/lib/ruby_ex.rb 22445 2006-03-11T15:56:04.480135Z pouillar  $
 
 require 'pathname'
 
@@ -57,7 +57,7 @@ module RubyEx
     i.fixed_cases 'URI', 'DRuby', 'MySQL', 'PgSQL', 'FTP', 'HTTP', 'DRb'
   end
 
-  Version = ::Version.parse("dev-ruby/ruby_ex-0.4_p1")
+  VersionId = ::Version.parse("dev-ruby/ruby_ex-0.4_p2")
 
   dir.load_path!
   (dir + 'module').load_path!

data/lib/sym_tbl_gsub.rb

@@ -1,7 +1,7 @@
 # Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
 # Copyright:: Copyright (c) 2005 Nicolas Pouillard. All rights reserved.
 # License::   Ruby License
-# Revision::  $Id: /w/fey/ruby_ex/trunk/lib/sym_tbl_gsub.rb 21868 2006-02-18T18:09:17.837831Z pouillar  $
+# Revision::  $Id: /w/fey/ruby_ex/trunk/lib/sym_tbl_gsub.rb 22444 2006-03-11T15:54:37.116683Z pouillar  $
 
 module SymTblGsub
 
@@ -10,13 +10,24 @@ module SymTblGsub
     attr_accessor :symtbl
 
     def assert_symtbl ( my, ref )
+      my_copy = Marshal.load(Marshal.dump(my))
       assert_equal ref, my.do_symtbl_gsub(symtbl)
+      assert_equal my, my_copy,
+                   'substitution not inplace has changed the object'
     end
 
     def assert_symtbl_nil ( my )
       assert_nil my.symtbl_gsub(symtbl)
     end
 
+    def assert_symtbl! ( my, ref )
+      assert_equal ref, my.do_symtbl_gsub!(symtbl)
+    end
+
+    def assert_symtbl_nil! ( my )
+      assert_nil my.symtbl_gsub!(symtbl)
+    end
+
   end # module Assertions
 
 end # module SymTblGsub
@@ -123,7 +134,8 @@ class Pathname
   end
 
   def symtbl_gsub ( symtbl )
-    dup.symtbl_gsub!(symtbl)
+    x = Pathname.new(@path.dup)
+    x.symtbl_gsub!(symtbl)
   end
 
 end # class Pathname
@@ -266,6 +278,14 @@ module SymTblGsub
         assert_symtbl '<<dne>> <<foo>>', '<<dne>> bar'
       end
       class Foo
+        include Comparable
+        attr_reader :y
+        def initialize
+          @y = rand
+        end
+        def <=> ( x )
+          @y <=> x.y
+        end
       end
       def test_object
         f = Foo.new

data/lib/uri/generic_ex.rb

@@ -1,7 +1,7 @@
 # Copyright:: Copyright (c) 2005  Nicolas Pouillard. All rights reserved.
 # Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
 # License::   Gnu General Public License.
-# Revision::  $Id: /w/fey/ruby_ex/trunk/lib/uri/generic_ex.rb 22242 2006-02-24T17:19:34.959052Z pouillar  $
+# Revision::  $Id: /w/fey/ruby_ex/trunk/lib/uri/generic_ex.rb 22448 2006-03-11T18:09:23.325348Z pouillar  $
 
 module URI
 
@@ -142,10 +142,12 @@ module URI
         def test_lazy_loading_full
           PathList[__FILE__.to_path.dirname.parent + '(uri/**/*).rb'].each do |full, path|
             assert_nothing_raised do
-              class_name = path.to_s.camelize.gsub(/Ex$/, '')
+              next if path.to_s == 'uri/generic_ex'
+              class_name = path.to_s.gsub(/_ex$/, '').camelize
               class_object = class_name.constantize
               assert_equal class_name, class_object.name
-              assert_match(/URI::Generic(Ex)?/, class_object.superclass.name)
+              assert_match(/URI::Generic(Ex)?/, class_object.superclass.name,
+                            "Superclass of #{class_object}")
             end
           end
         end

data/test/algorithms/simulated_annealing_test.rb

@@ -7,95 +7,91 @@ require 'yaml'
 require 'stringio'
 require 'test/unit'
 
-module Algorithms
+class SimulatedAnnealingTest < Test::Unit::TestCase
 
-  class SimulatedAnnealingTest < Test::Unit::TestCase
+  class BasicFunction
+    include Algorithms::SimulatedAnnealing::Support
 
-    class BasicFunction
-      include SimulatedAnnealing::Support
-
-      def initialize ( &fun )
-        @max = 100000
-        @min = -@max
-        @step_width = 500
-        @f = fun
-        @cur_pos = (@min..@max).choose
-      end
-
-      def choose_transition ( generator=nil )
-        @cur_pos + @step_width.choose(generator) - (@step_width / 2)
-      end
-
-      def apply_transition ( transition )
-        @cur_pos = transition
-      end
-
-      def transition_cost ( current_cost, transition )
-        @f[transition] - current_cost
-      end
-
-      def cost
-        @f[@cur_pos]
-      end
+    def initialize ( &fun )
+      @max = 100000
+      @min = -@max
+      @step_width = 500
+      @f = fun
+      @cur_pos = (@min..@max).choose
+    end
 
-      def copy_of_the_current_solution
-        @cur_pos
-      end
+    def choose_transition ( generator=nil )
+      @cur_pos + @step_width.choose(generator) - (@step_width / 2)
+    end
 
-    end # class BasicFunction
+    def apply_transition ( transition )
+      @cur_pos = transition
+    end
 
-    def factory ( out, &fun )
-      obj = BasicFunction.new(&fun)
-      SimulatedAnnealing.new(
-        :support             => obj,
-        :output              => out,
-        :global_threshold    => 20,
-        :step_multiplicator  => 0.63,
-        :initial_temperature => 10,
-        :initial_cost        => obj.cost,
-        :iteration_modulus   => 10,
-        :step_modulus        => 5000
-      )
+    def transition_cost ( current_cost, transition )
+      @f[transition] - current_cost
     end
 
-    def basic_checker ( &fun )
-      out = StringIO.new
-      strm, sa = nil, nil
-      assert_nothing_raised do
-        sa = factory(out, &fun)
-      end
-      assert_nothing_raised do
-        sa.run
-      end
-      assert_nothing_raised do
-        sa.summary
-      end
-      out.flush
-      out.rewind
-      assert_nothing_raised do
-        strm = YAML::load_stream(out.read)
-      end
-      assert_kind_of(YAML::Stream, strm)
-      docs = strm.documents
-      assert_equal(2, docs.size)
-      docs[0] = [] if docs[0].nil?
-      assert_kind_of(Array, docs[0])
-      assert(docs[0].all? { |x| x.is_a?(Hash) })
-      docs[0].all? do |x|
-        ks = x.keys.delete_if { |y| y.is_a? Integer or y =~ /\|/ }
-        assert_equal(%w[cost prob temp thres], ks.sort)
-      end
-      assert_kind_of(Hash, docs[1])
+    def cost
+      @f[@cur_pos]
     end
 
-    def test_square
-      basic_checker { |x| x ** 2 }
+    def copy_of_the_current_solution
+      @cur_pos
     end
 
-    def test_poly4
-      basic_checker { |x| (x - 1) * (x - 300) * (x - 10000) * (x + 300)  }
+  end # class BasicFunction
+
+  def factory ( out, &fun )
+    obj = BasicFunction.new(&fun)
+    Algorithms::SimulatedAnnealing.new(
+      :support             => obj,
+      :output              => out,
+      :global_threshold    => 20,
+      :step_multiplicator  => 0.63,
+      :initial_temperature => 10,
+      :initial_cost        => obj.cost,
+      :iteration_modulus   => 10,
+      :step_modulus        => 5000
+    )
+  end
+
+  def basic_checker ( &fun )
+    out = StringIO.new
+    strm, sa = nil, nil
+    assert_nothing_raised do
+      sa = factory(out, &fun)
+    end
+    assert_nothing_raised do
+      sa.run
+    end
+    assert_nothing_raised do
+      sa.summary
     end
+    out.flush
+    out.rewind
+    assert_nothing_raised do
+      strm = YAML::load_stream(out.read)
+    end
+    assert_kind_of(YAML::Stream, strm)
+    docs = strm.documents
+    assert_equal(2, docs.size)
+    docs[0] = [] if docs[0].nil?
+    assert_kind_of(Array, docs[0])
+    assert(docs[0].all? { |x| x.is_a?(Hash) })
+    docs[0].all? do |x|
+      ks = x.keys.delete_if { |y| y.is_a? Integer or y =~ /\|/ }
+      assert_equal(%w[cost prob temp thres], ks.sort)
+    end
+    assert_kind_of(Hash, docs[1])
+  end
+
+  def test_square
+    basic_checker { |x| x ** 2 }
+  end
 
-  end # class SimulatedAnnealingTest
+  def test_poly4
+    basic_checker { |x| (x - 1) * (x - 300) * (x - 10000) * (x + 300)  }
+  end
 
-end # module Algorithms
+end # class SimulatedAnnealingTest

data/test/unit-suite.yml

@@ -10,6 +10,6 @@ RubyEx Unit Test Suite: !S::Iterate
       load_path: [<<pwd>>/../lib, <<pwd>>/algorithms]
       requires: <<pwd>>/../lib/ruby_ex # The full path is here to ensure we
                                        # load the good one.
-      input: !path <<it_name>>
-      uttk_unit_options: --uttk no
+      input: !path <<it_name>>.rb
+      uttk_unit_options: --uttk no --mode import
       verbose: true

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: ruby_ex
 version: !ruby/object:Gem::Version 
-  version: 0.4.6.1
-date: 2006-03-10 00:00:00 +01:00
+  version: 0.4.6.2
+date: 2006-03-11 00:00:00 +01:00
 summary: RubyEx contains general purpose Ruby extensions.
 require_paths: 
 - lib
@@ -167,7 +167,6 @@ files:
 - test/sanity/single-requires.yml
 - test/sanity/multiple-requires.yml
 - NEWS
-- SPEC.gemspec
 - Rakefile
 - README
 - AUTHORS

data/SPEC.gemspec

@@ -1,14 +0,0 @@
-Gem::Specification.new do |s|
-  s.name = %q{ruby_ex}
-  s.version = "0.4.6.1"
-  s.date = %q{2006-03-10}
-  s.summary = %q{RubyEx contains general purpose Ruby extensions.}
-  s.email = ["nicolas.despres@gmail.com", "ertai@feydakins.org"]
-  s.homepage = %q{http://api.feydakins.org/ruby_ex}
-  s.rubyforge_project = %q{ruby_ex}
-  s.description = %q{}
-  s.authors = ["Nicolas Despr\350s", "Nicolas Pouillard"]
-  s.files = ["lib/file_type.rb", "lib/config_file.rb", "lib/labeled_node.rb", "lib/diff.rb", "lib/spring_set.rb", "lib/genpasswd.rb", "lib/sendmail.rb", "lib/auto_object.rb", "lib/concrete.rb", "lib/commands.rb", "lib/generate_id.rb", "lib/ruby_ex.rb", "lib/verbose_object.rb", "lib/md5sum.rb", "lib/daemon.rb", "lib/syn_flow.rb", "lib/html_encode.rb", "lib/hooker.rb", "lib/d_logger.rb", "lib/cache.rb", "lib/diff_tools.rb", "lib/mocks.rb", "lib/choose.rb", "lib/safe_eval.rb", "lib/histogram.rb", "lib/regex_path.rb", "lib/timeout_ex.rb", "lib/text.rb", "lib/observable.rb", "lib/r_path.rb", "lib/indexed_node.rb", "lib/io_marshal.rb", "lib/ioo.rb", "lib/logger_observer.rb", "lib/abstract.rb", "lib/service_manager.rb", "lib/node.rb", "lib/meta_factory.rb", "lib/hash_eval.rb", "lib/object_monitor.rb", "lib/hookable.rb", "lib/pp_hierarchy.rb", "lib/ordered_hash.rb", "lib/spring.rb", "lib/shuffle.rb", "lib/observable_pool.rb", "lib/object_monitor_activity.rb", "lib/sym_tbl.rb", "lib/blank_slate.rb", "lib/sym_tbl_gsub.rb", "lib/attributed_class.rb", "lib/drb_ex.rb", "lib/random_generators.rb", "lib/method_call.rb", "lib/const_regexp.rb", "lib/regex_list.rb", "lib/abstract_node.rb", "lib/kill_all.rb", "lib/trace.rb", "lib/drb/undumped_attributes.rb", "lib/drb/insecure_protected_methods.rb", "lib/drb/observable.rb", "lib/drb/service.rb", "lib/drb/observable_pool.rb", "lib/drb/undumped_indexed_object.rb", "lib/uri/ftp_ex.rb", "lib/uri/pgsql.rb", "lib/uri/rsync.rb", "lib/uri/file.rb", "lib/uri/druby.rb", "lib/uri/generic_ex.rb", "lib/uri/http_ex.rb", "lib/uri/ssh.rb", "lib/uri/svn.rb", "lib/uri/mysql.rb", "lib/yaml/yregexpath.rb", "lib/yaml/chop_header.rb", "lib/yaml/transform.rb", "lib/mocks/observer.rb", "lib/mocks/assertions.rb", "lib/mocks/mock.rb", "lib/mocks/method_logger.rb", "lib/mocks/object.rb", "lib/commands/datas.rb", "lib/commands/helpers.rb", "lib/commands/seq.rb", "lib/commands/command.rb", "lib/commands/factory.rb", "lib/commands/pipe.rb", "lib/commands/runners.rb", "lib/commands/datas/data.rb", "lib/commands/datas/composite.rb", "lib/commands/datas/temp.rb", "lib/commands/datas/factory.rb", "lib/commands/datas/pipe.rb", "lib/commands/runners/popen.rb", "lib/commands/runners/system.rb", "lib/commands/runners/exec.rb", "lib/commands/runners/no_run.rb", "lib/commands/runners/fork.rb", "lib/commands/runners/mockable.rb", "lib/commands/runners/runner.rb", "lib/algorithms/simulated_annealing.rb", "lib/module/instance_method_visibility.rb", "lib/module/hierarchy.rb", "lib/module/autoload_tree.rb", "lib/random_generators/random_generator.rb", "lib/random_generators/ruby.rb", "test/unit-suite.yml", "test/check-ruby_ex.yml", "test/functional", "test/algorithms", "test/stress-tests", "test/fixtures", "test/sanity", "test/sanity-suite.yml", "test/check-pkg-ruby_ex.yml", "test/algorithms/simulated_annealing_test.rb", "test/stress-tests/threads_and_exceptions.yml", "test/fixtures/tar.gz.log", "test/fixtures/foo.tar.bz2", "test/fixtures/foo.rb.gz", "test/fixtures/my_diff.patch", "test/fixtures/foo.bz2", "test/fixtures/foo.tar", "test/fixtures/foo.txt", "test/fixtures/foo.gz.zip", "test/fixtures/foo.tar.gz", "test/fixtures/autoload_tree", "test/fixtures/autoload_tree/foo", "test/fixtures/autoload_tree/A.rb", "test/fixtures/autoload_tree/B.rb", "test/fixtures/autoload_tree/foo/C.rb", "test/sanity/single-requires.yml", "test/sanity/multiple-requires.yml", "NEWS", "SPEC.gemspec", "Rakefile", "README", "AUTHORS", "SPEC.yml", "ChangeLog"]
-  s.add_dependency(%q<highline>, ["~> 1.0.1"])
-  s.add_dependency(%q<core_ex>, ["~> 0.5.5"])
-end