* lib/test/unit.rb: removed installation instructions.

* lib/test/unit/ui/testrunnermediator.rb: moved the run flag to a more
	  central location.

	* lib/test/unit.rb: ditto.

	* lib/test/unit.rb: extracted the running code in to AutoRunner.

	* lib/test/unit/autorunner.rb: added.

	* lib/test/unit/collector/objectspace.rb: extracted common test
	  collection functionality in to a module.

	* lib/test/unit/collector.rb: ditto; added.

	* test/testunit/collector/test_objectspace.rb: ditto.

	* lib/test/unit/collector/dir.rb: added. Supports collecting tests out
	  of a directory structure.

	* test/testunit/collector/test_dir.rb: added.

	* test/runner.rb: simplified to use the new capabilities.


git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@4720 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

lib/test/unit/collector/dir.rb

@@ -0,0 +1,80 @@
+require 'test/unit/testsuite'
+require 'test/unit/collector'
+
+module Test
+  module Unit
+    module Collector
+      class Dir
+        include Collector
+
+        attr_writer :pattern
+
+        def initialize(dir=::Dir, file=::File, object_space=::ObjectSpace, req=nil)
+          super()
+          @dir = dir
+          @file = file
+          @object_space = object_space
+          @req = req
+          @pattern = /\Atest_.*\.rb\Z/m
+        end
+
+        def collect(*from)
+          if(from.empty?)
+            recursive_collect('.', find_test_cases)
+          elsif(from.size == 1)
+            recursive_collect(from.first, find_test_cases)
+          else
+            suites = []
+            from.each do |f|
+              suite = recursive_collect(f, find_test_cases)
+              suites << suite unless(suite.tests.empty?)
+            end
+            suite = TestSuite.new("[#{from.join(', ')}]")
+            sort(suites).each{|s| suite << s}
+            suite
+          end
+        end
+
+        def find_test_cases(ignore=[])
+          cases = []
+          @object_space.each_object(Class) do |c|
+            cases << c if(c < TestCase && !ignore.include?(c))
+          end
+          ignore.concat(cases)
+          cases
+        end
+
+        def recursive_collect(name, already_gathered)
+          sub_suites = []
+          if(@file.directory?(name))
+            @dir.entries(name).each do |e|
+              next if(e == '.' || e == '..')
+              e_name = @file.join(name, e)
+              if(@file.directory?(e_name))
+                sub_suite = recursive_collect(e_name, already_gathered)
+                sub_suites << sub_suite unless(sub_suite.empty?)
+              else
+                (next unless(@pattern =~ e)) if(@pattern)
+                collect_file(e_name, sub_suites, already_gathered)
+              end
+            end
+          else
+            collect_file(name, sub_suites, already_gathered)
+          end
+          suite = TestSuite.new(@file.basename(name))
+          sort(sub_suites).each{|s| suite << s}
+          suite
+        end
+
+        def collect_file(name, suites, already_gathered)
+          if(@req)
+            @req.require(name)
+          else
+            require(name)
+          end
+          find_test_cases(already_gathered).each{|t| add_suite(suites, t.suite)}
+        end
+      end
+    end
+  end
+end

lib/test/unit/collector/objectspace.rb

@@ -2,15 +2,19 @@
 # Copyright:: Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
 # License:: Ruby license.
 
+require 'test/unit/collector'
+
 module Test
   module Unit
     module Collector
       class ObjectSpace
+        include Collector
+        
         NAME = 'collected from the ObjectSpace'
         
         def initialize(source=::ObjectSpace)
+          super()
           @source = source
-          @filters = []
         end
         
         def collect(name=NAME)
@@ -18,32 +22,12 @@ module Test
           sub_suites = []
           @source.each_object(Class) do |klass|
             if(Test::Unit::TestCase > klass)
-              sub_suite = klass.suite
-              to_delete = sub_suite.tests.find_all{|t| !include(t)}
-              to_delete.each{|t| sub_suite.delete(t)}
-              sub_suites << sub_suite unless(sub_suite.size == 0)
+              add_suite(sub_suites, klass.suite)
             end
           end
-          sub_suites.sort_by{|s| s.name}.each{|s| suite << s}
+          sort(sub_suites).each{|s| suite << s}
           suite
         end
-        
-        def include(test)
-          return true if(@filters.empty?)
-          @filters.each do |filter|
-            return true if(filter.call(test))
-          end
-          false
-        end
-        
-        def filter=(filters)
-          @filters = case(filters)
-            when Proc
-              [filters]
-            when Array
-              filters
-          end
-        end
       end
     end
   end