ruby_on_ruby 0.0.1

data/vendor/javascripts/emscripted-ruby/lib/test/unit/autorunner.rb

@@ -0,0 +1,220 @@
+require 'test/unit'
+require 'test/unit/ui/testrunnerutilities'
+require 'optparse'
+
+module Test
+  module Unit
+    class AutoRunner
+      def self.run(force_standalone=false, default_dir=nil, argv=ARGV, &block)
+        r = new(force_standalone || standalone?, &block)
+        r.base = default_dir
+        r.process_args(argv)
+        r.run
+      end
+      
+      def self.standalone?
+        return false unless("-e" == $0)
+        ObjectSpace.each_object(Class) do |klass|
+          return false if(klass < TestCase)
+        end
+        true
+      end
+
+      RUNNERS = {
+        :console => proc do |r|
+          require 'test/unit/ui/console/testrunner'
+          Test::Unit::UI::Console::TestRunner
+        end,
+        :gtk => proc do |r|
+          require 'test/unit/ui/gtk/testrunner'
+          Test::Unit::UI::GTK::TestRunner
+        end,
+        :gtk2 => proc do |r|
+          require 'test/unit/ui/gtk2/testrunner'
+          Test::Unit::UI::GTK2::TestRunner
+        end,
+        :fox => proc do |r|
+          require 'test/unit/ui/fox/testrunner'
+          Test::Unit::UI::Fox::TestRunner
+        end,
+        :tk => proc do |r|
+          require 'test/unit/ui/tk/testrunner'
+          Test::Unit::UI::Tk::TestRunner
+        end,
+      }
+
+      OUTPUT_LEVELS = [
+        [:silent, UI::SILENT],
+        [:progress, UI::PROGRESS_ONLY],
+        [:normal, UI::NORMAL],
+        [:verbose, UI::VERBOSE],
+      ]
+
+      COLLECTORS = {
+        :objectspace => proc do |r|
+          require 'test/unit/collector/objectspace'
+          c = Collector::ObjectSpace.new
+          c.filter = r.filters
+          c.collect($0.sub(/\.rb\Z/, ''))
+        end,
+        :dir => proc do |r|
+          require 'test/unit/collector/dir'
+          c = Collector::Dir.new
+          c.filter = r.filters
+          c.pattern.concat(r.pattern) if(r.pattern)
+          c.exclude.concat(r.exclude) if(r.exclude)
+          c.base = r.base
+          $:.push(r.base) if r.base
+          c.collect(*(r.to_run.empty? ? ['.'] : r.to_run))
+        end,
+      }
+
+      attr_reader :suite
+      attr_accessor :output_level, :filters, :to_run, :pattern, :exclude, :base, :workdir
+      attr_writer :runner, :collector
+
+      def initialize(standalone)
+        Unit.run = true
+        @standalone = standalone
+        @runner = RUNNERS[:console]
+        @collector = COLLECTORS[(standalone ? :dir : :objectspace)]
+        @filters = []
+        @to_run = []
+        @output_level = UI::NORMAL
+        @workdir = nil
+        yield(self) if(block_given?)
+      end
+
+      def process_args(args = ARGV)
+        begin
+          options.order!(args) {|arg| @to_run << arg}
+        rescue OptionParser::ParseError => e
+          puts e
+          puts options
+          $! = nil
+          abort
+        else
+          @filters << proc{false} unless(@filters.empty?)
+        end
+        not @to_run.empty?
+      end
+
+      def options
+        @options ||= OptionParser.new do |o|
+          o.banner = "Test::Unit automatic runner."
+          o.banner << "\nUsage: #{$0} [options] [-- untouched arguments]"
+
+          o.on
+          o.on('-r', '--runner=RUNNER', RUNNERS,
+               "Use the given RUNNER.",
+               "(" + keyword_display(RUNNERS) + ")") do |r|
+            @runner = r
+          end
+
+          if(@standalone)
+            o.on('-b', '--basedir=DIR', "Base directory of test suites.") do |b|
+              @base = b
+            end
+
+            o.on('-w', '--workdir=DIR', "Working directory to run tests.") do |w|
+              @workdir = w
+            end
+
+            o.on('-a', '--add=TORUN', Array,
+                 "Add TORUN to the list of things to run;",
+                 "can be a file or a directory.") do |a|
+              @to_run.concat(a)
+            end
+
+            @pattern = []
+            o.on('-p', '--pattern=PATTERN', Regexp,
+                 "Match files to collect against PATTERN.") do |e|
+              @pattern << e
+            end
+
+            @exclude = []
+            o.on('-x', '--exclude=PATTERN', Regexp,
+                 "Ignore files to collect against PATTERN.") do |e|
+              @exclude << e
+            end
+          end
+
+          o.on('-n', '--name=NAME', String,
+               "Runs tests matching NAME.",
+               "(patterns may be used).") do |n|
+            n = (%r{\A/(.*)/\Z} =~ n ? Regexp.new($1) : n)
+            case n
+            when Regexp
+              @filters << proc{|t| n =~ t.method_name ? true : nil}
+            else
+              @filters << proc{|t| n == t.method_name ? true : nil}
+            end
+          end
+
+          o.on('-t', '--testcase=TESTCASE', String,
+               "Runs tests in TestCases matching TESTCASE.",
+               "(patterns may be used).") do |n|
+            n = (%r{\A/(.*)/\Z} =~ n ? Regexp.new($1) : n)
+            case n
+            when Regexp
+              @filters << proc{|t| n =~ t.class.name ? true : nil}
+            else
+              @filters << proc{|t| n == t.class.name ? true : nil}
+            end
+          end
+
+          o.on('-I', "--load-path=DIR[#{File::PATH_SEPARATOR}DIR...]",
+               "Appends directory list to $LOAD_PATH.") do |dirs|
+            $LOAD_PATH.concat(dirs.split(File::PATH_SEPARATOR))
+          end
+
+          o.on('-v', '--verbose=[LEVEL]', OUTPUT_LEVELS,
+               "Set the output level (default is verbose).",
+               "(" + keyword_display(OUTPUT_LEVELS) + ")") do |l|
+            @output_level = l || UI::VERBOSE
+          end
+
+          o.on('--',
+               "Stop processing options so that the",
+               "remaining options will be passed to the",
+               "test."){o.terminate}
+
+          o.on('-h', '--help', 'Display this help.'){puts o; exit}
+
+          o.on_tail
+          o.on_tail('Deprecated options:')
+
+          o.on_tail('--console', 'Console runner (use --runner).') do
+            warn("Deprecated option (--console).")
+            @runner = RUNNERS[:console]
+          end
+
+          o.on_tail('--gtk', 'GTK runner (use --runner).') do
+            warn("Deprecated option (--gtk).")
+            @runner = RUNNERS[:gtk]
+          end
+
+          o.on_tail('--fox', 'Fox runner (use --runner).') do
+            warn("Deprecated option (--fox).")
+            @runner = RUNNERS[:fox]
+          end
+
+          o.on_tail
+        end
+      end
+
+      def keyword_display(array)
+        list = array.collect {|e, *| e.to_s}
+        Array === array or list.sort!
+        list.collect {|e| e.sub(/^(.)([A-Za-z]+)(?=\w*$)/, '\\1[\\2]')}.join(", ")
+      end
+
+      def run
+        @suite = @collector[self]
+        result = @runner[self] or return false
+        Dir.chdir(@workdir) if @workdir
+        result.run(@suite, @output_level).passed?
+      end
+    end
+  end
+end

data/vendor/javascripts/emscripted-ruby/lib/test/unit/collector.rb

@@ -0,0 +1,43 @@
+module Test
+  module Unit
+    module Collector
+      def initialize
+        @filters = []
+      end
+
+      def filter=(filters)
+        @filters = case(filters)
+          when Proc
+            [filters]
+          when Array
+            filters
+        end
+      end
+
+      def add_suite(destination, suite)
+        to_delete = suite.tests.find_all{|t| !include?(t)}
+        to_delete.each{|t| suite.delete(t)}
+        destination << suite unless(suite.size == 0)
+      end
+
+      def include?(test)
+        return true if(@filters.empty?)
+        @filters.each do |filter|
+          result = filter[test]
+          if(result.nil?)
+            next
+          elsif(!result)
+            return false
+          else
+            return true
+          end
+        end
+        true
+      end
+
+      def sort(suites)
+        suites.sort_by{|s| s.name}
+      end
+    end
+  end
+end

data/vendor/javascripts/emscripted-ruby/lib/test/unit/collector/dir.rb

@@ -0,0 +1,107 @@
+require 'test/unit/testsuite'
+require 'test/unit/collector'
+
+module Test
+  module Unit
+    module Collector
+      class Dir
+        include Collector
+
+        attr_reader :pattern, :exclude
+        attr_accessor :base
+
+        def initialize(dir=::Dir, file=::File, object_space=::ObjectSpace, req=nil)
+          super()
+          @dir = dir
+          @file = file
+          @object_space = object_space
+          @req = req
+          @pattern = [/\btest_.*\.rb\Z/m]
+          @exclude = []
+        end
+
+        def collect(*from)
+          basedir = @base
+          $:.push(basedir) if basedir
+          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
+        ensure
+          $:.delete_at($:.rindex(basedir)) if basedir
+        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 = []
+          path = realdir(name)
+          if @file.directory?(path)
+	    dir_name = name unless name == '.'
+            @dir.entries(path).each do |e|
+              next if(e == '.' || e == '..')
+              e_name = dir_name ? @file.join(dir_name, e) : e
+              if @file.directory?(realdir(e_name))
+                next if /\ACVS\z/ =~ e
+                sub_suite = recursive_collect(e_name, already_gathered)
+                sub_suites << sub_suite unless(sub_suite.empty?)
+              else
+                next if /~\z/ =~ e_name or /\A\.\#/ =~ e
+                if @pattern and !@pattern.empty?
+                  next unless @pattern.any? {|pat| pat =~ e_name}
+                end
+                if @exclude and !@exclude.empty?
+                  next if @exclude.any? {|pat| pat =~ e_name}
+                end
+                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)
+          dir = @file.dirname(@file.expand_path(name, @base))
+          $:.unshift(dir)
+          if(@req)
+            @req.require(name)
+          else
+            require(name)
+          end
+          find_test_cases(already_gathered).each{|t| add_suite(suites, t.suite)}
+        ensure
+          $:.delete_at($:.rindex(dir)) if(dir)
+        end
+
+	def realdir(path)
+	  if @base
+	    @file.join(@base, path)
+	  else
+	    path
+	  end
+	end
+      end
+    end
+  end
+end

data/vendor/javascripts/emscripted-ruby/lib/test/unit/collector/objectspace.rb

@@ -0,0 +1,34 @@
+# Author:: Nathaniel Talbott.
+# 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
+        end
+        
+        def collect(name=NAME)
+          suite = TestSuite.new(name)
+          sub_suites = []
+          @source.each_object(Class) do |klass|
+            if(Test::Unit::TestCase > klass)
+              add_suite(sub_suites, klass.suite)
+            end
+          end
+          sort(sub_suites).each{|s| suite << s}
+          suite
+        end
+      end
+    end
+  end
+end

data/vendor/javascripts/emscripted-ruby/lib/test/unit/error.rb

@@ -0,0 +1,56 @@
+#--
+#
+# Author:: Nathaniel Talbott.
+# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
+# License:: Ruby license.
+
+require 'test/unit/util/backtracefilter'
+
+module Test
+  module Unit
+
+    # Encapsulates an error in a test. Created by
+    # Test::Unit::TestCase when it rescues an exception thrown
+    # during the processing of a test.
+    class Error
+      include Util::BacktraceFilter
+
+      attr_reader(:test_name, :exception)
+
+      SINGLE_CHARACTER = 'E'
+
+      # Creates a new Error with the given test_name and
+      # exception.
+      def initialize(test_name, exception)
+        @test_name = test_name
+        @exception = exception
+      end
+
+      # Returns a single character representation of an error.
+      def single_character_display
+        SINGLE_CHARACTER
+      end
+
+      # Returns the message associated with the error.
+      def message
+        "#{@exception.class.name}: #{@exception.message}"
+      end
+
+      # Returns a brief version of the error description.
+      def short_display
+        "#@test_name: #{message.split("\n")[0]}"
+      end
+
+      # Returns a verbose version of the error description.
+      def long_display
+        backtrace = filter_backtrace(@exception.backtrace).join("\n    ")
+        "Error:\n#@test_name:\n#{message}\n    #{backtrace}"
+      end
+
+      # Overridden to return long_display.
+      def to_s
+        long_display
+      end
+    end
+  end
+end