turn 0.7.0 → 0.8.0

data/lib/turn/command.rb

@@ -1,165 +1,210 @@
-# Turn - Pretty Unit Test Runner for Ruby
-#
-# SYNOPSIS
-#   turn [OPTIONS] [RUN MODE] [OUTPUT MODE] [test globs...]
-#
-# OPTIONS
-#   -h --help             display this help information
-#      --live             don't use loadpath
-#      --log              log results to a file
-#   -n --name=PATTERN     only run tests that match regexp PATTERN
-#   -I --loadpath=PATHS   add given paths to the $LOAD_PATH
-#   -r --requires=PATHS   require given paths before running tests
-#
-# RUN MODES
-#      --normal      run all tests in a single process [default]
-#      --solo        run each test in a separate process
-#      --cross       run each pair of test files in a separate process
-#
-# OUTPUT MODES
-#   -O --outline     turn's original case/test outline mode [default]
-#   -P --progress    indicates progress with progress bar
-#   -D --dotted      test/unit's traditonal dot-progress mode
-#   -M --marshal     dump output as YAML (normal run mode only)
-
-require 'getoptlong'
+require 'optparse'
 require 'turn/controller'
 
-#RUBY = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
+module Turn
 
-original_argv = ARGV.dup
+  # Turn - Pretty Unit Test Runner for Ruby
+  #
+  # SYNOPSIS
+  #   turn [OPTIONS] [RUN MODE] [OUTPUT MODE] [test globs...]
+  #
+  # OPTIONS
+  #   -h --help             display this help information
+  #      --live             don't use loadpath
+  #      --log              log results to a file
+  #   -n --name=PATTERN     only run tests that match regexp PATTERN
+  #   -I --loadpath=PATHS   add given PATHS to the $LOAD_PATH
+  #   -r --requires=LIBS    require given LIBS before running tests
+  #   -m --minitest         Force use of MiniTest framework.
+  #
+  # RUN MODES
+  #      --normal      run all tests in a single process [default]
+  #      --solo        run each test in a separate process
+  #      --cross       run each pair of test files in a separate process
+  #
+  # OUTPUT MODES
+  #   -O --outline     turn's original case/test outline mode [default]
+  #   -P --progress    indicates progress with progress bar
+  #   -D --dotted      test/unit's traditonal dot-progress mode
+  #      --pretty      new pretty reporter
+  #   -M --marshal     dump output as YAML (normal run mode only)
+  #   -Q --queued      interactive testing
+  #
+  class Command
 
-opts = GetoptLong.new(
-  [ '--help', '-h',     GetoptLong::NO_ARGUMENT ],
-  [ '--live',           GetoptLong::NO_ARGUMENT ],
-  [ '--log',            GetoptLong::OPTIONAL_ARGUMENT ],
-  [ '--name',     '-n', GetoptLong::REQUIRED_ARGUMENT ],
-  [ '--loadpath', '-I', GetoptLong::REQUIRED_ARGUMENT ],
-  [ '--requires', '-r', GetoptLong::REQUIRED_ARGUMENT ],
+    # Shortcut for new.main(*argv)
+    def self.main(*argv)
+      new.main(*argv)
+    end
 
-  # RUN MODES
-  [ '--normal',         GetoptLong::NO_ARGUMENT ],
-  [ '--solo',           GetoptLong::NO_ARGUMENT ],
-  [ '--cross',          GetoptLong::NO_ARGUMENT ],
-  #[ '--load',           GetoptLong::NO_ARGUMENT ],
+    # Log output.
+    attr :log
 
-  # OUTPUT MODES
-  [ '--outline',  '-O', GetoptLong::NO_ARGUMENT ],
-  [ '--progress', '-P', GetoptLong::NO_ARGUMENT ],
-  [ '--dotted',   '-D', GetoptLong::NO_ARGUMENT ],
-  [ '--marshal',  '-M', GetoptLong::NO_ARGUMENT ]
-)
-
-live     = nil
-log      = nil
-pattern  = nil
-loadpath = []
-requires = []
-
-runmode = nil
-outmode = nil
-
-opts.each do |opt, arg|
-  case opt
-  when '--help'
-    help, rest = File.read(__FILE__).split(/^\s*$/)
-    puts help.gsub(/^\#[ ]{0,1}/,'')
-    exit
-
-  when '--live'
-    live = true
-  when '--log'
-    log = true
-  when '--name'
-    pattern = Regexp.new(arg, Regexp::IGNORECASE)
-  when '--loadpath'
-    loadpath << arg
-  when '--requires'
-    requires << arg
-
-  when '--solo'
-    runmode = :solo
-  when '--cross'
-    runmode = :cross
-  when '--marshal'
-    runmode = :marshal
-    outmode = :marshal
-  when '--progress'
-    outmode = :progress
-  when '--outline'
-    outmode = :outline
-  when '--dotted'
-    outmode = :dotted
-  end
-end
+    # Do not use local loadpath.
+    attr :live
 
-loadpath = ['lib'] if loadpath.empty?
+    # Only run tests matching this pattern.
+    attr :pattern
 
-tests = ARGV.empty? ? nil : ARGV.dup
+    # List of paths to add to $LOAD_PATH
+    attr :loadpath
 
-case outmode
-when :marshal
-  reporter = Turn::MarshalReporter.new($stdout)
-when :progress
-  reporter = Turn::ProgressReporter.new($stdout)
-when :dotted
-  reporter = Turn::DotReporter.new($stdout)
-else
-  reporter = Turn::OutlineReporter.new($stdout)
-end
+    # Libraries to require before running tests.
+    attr :requires
 
-case runmode
-when :marshal
-  require 'turn/runners/testrunner'
-  runner   = Turn::TestRunner
-when :solo
-  require 'turn/runners/solorunner'
-  runner = Turn::SoloRunner
-when :cross
-  require 'turn/runners/crossrunner'
-  runner = Turn::CrossRunner
-else
-  require 'turn/runners/testrunner'
-  runner = Turn::TestRunner
-end
+    # Framework to use, :minitest or :testunit.
+    attr :framework
 
-controller = Turn::Controller.new do |c|
-  c.live     = live
-  c.log      = log
-  c.loadpath = loadpath
-  c.requires = requires
-  c.tests    = tests
-  c.runner   = runner
-  c.reporter = reporter
-  c.pattern  = pattern
-end
+    # Run mode.
+    attr :runmode
 
-controller.start
+    # Output mode.
+    attr :outmode
 
-=begin
-else
+    #
+    def initialize
+      @live      = nil
+      @log       = nil
+      @pattern   = nil
+      @loadpath  = []
+      @requires  = []
+      @runmode   = nil
+      @outmode   = nil
+      @framework = RUBY_VERSION >= "1.9" ? :minitest : :testunit
+    end
 
-  begin
-    require 'turn/adapters/testunit' # 'turn'
-  rescue LoadError
-    require 'rubygems'
-    require 'turn/adapters/testunit' # 'turn'
-  end
+    #
+    def option_parser
+      OptionParser.new do |opts|
 
-  ARGV.each{ |a| Dir[a].each{ |f| require f }}
-  Turn::TestRunner.run(TS_MyTests)
+        opts.banner = "Turn - Pretty Unit Test Runner for Ruby"
 
-  #RUBY = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
-  #
-  #begin
-  #  require 'turn'
-  #  Kernel.exec(RUBY, '-r', 'turn', *ARGV)
-  #rescue LoadError
-  #  require 'rubygems'
-  #  require 'turn'
-  #  Kernel.exec(RUBY, '-rubygems', '-r', 'turn', *ARGV)
-  #end
+        opts.separator " "
+        opts.separator "SYNOPSIS"
+        opts.separator "  turn [OPTIONS] [RUN MODE] [OUTPUT MODE] [TEST GLOBS ...]"
 
-end
-=end
+        opts.separator " "
+        opts.separator "GENERAL OPTIONS"
 
+        opts.on('-I', '--loadpath=PATHS', "add paths to $LOAD_PATH") do |path|
+          @loadpath.concat(path.split(':'))
+        end
+
+        opts.on('-r', '--require=LIBS', "require libraries") do |lib|
+          @requires.concat(lib.split(':'))
+        end
+
+        opts.on('-n', '--name=PATTERN', "only run tests that match PATTERN") do |pattern|
+          @pattern = Regexp.new(pattern, Regexp::IGNORECASE)
+        end
+
+        opts.on('-m', '--minitest', "Force use of MiniTest framework") do
+          @framework = :minitest
+        end
+
+        # Turn does not support Test::Unit 2.0+
+        #opts.on('-u', '--testunit', "Force use of TestUnit framework") do
+        #  @framework = :testunit
+        #end
+
+        opts.on('--log', "log results to a file") do #|path|
+          @log = true # TODO: support path/file
+        end
+
+        opts.on('--live', "do not use local load path") do
+          @live = true
+        end
+
+        opts.separator " "
+        opts.separator "RUN MODES"
+
+        opts.on('--normal', "run all tests in a single process [default]") do
+          @runmode = nil
+        end
+
+        opts.on('--solo', "run each test in a separate process") do
+          @runmode = :solo
+        end
+
+        opts.on('--cross', "run each pair of test files in a separate process") do
+          @runmode = :cross
+        end
+
+        #opts.on('--load', "") do
+        #end
+
+        opts.separator " "
+        opts.separator "OUTPUT MODES"
+
+        opts.on('--outline', '-O', "turn's original case/test outline mode [default]") do
+          @outmode = :outline
+        end
+
+        opts.on('--progress', '-P', "indicates progress with progress bar") do
+          @outmode = :progress
+        end
+
+        opts.on('--dotted', '-D', "test-unit's traditonal dot-progress mode") do
+          @outmode = :dotted
+        end
+
+        opts.on('--pretty', '-T', "new pretty output mode") do
+          @outmode = :pretty
+        end
+
+        opts.on('--cue', '-C', "cue for action on each failure/error") do
+          @outmode = :cue
+        end
+
+        opts.on('--marshal', '-M', "dump output as YAML (normal run mode only)") do
+          @runmode = :marshal
+          @outmode = :marshal
+        end
+
+        opts.separator " "
+        opts.separator "COMMAND OPTIONS"
+
+        opts.on('--debug', "turn debug mode on") do
+          $VERBOSE = true
+          $DEBUG   = true
+        end
+
+        opts.on_tail('--help', '-h', "display this help information") do
+          puts opts
+          exit
+        end
+      end
+    end
+
+    # Run command.
+    def main(*argv)
+      option_parser.parse!(argv)
+
+      @loadpath = ['lib'] if loadpath.empty?
+
+      tests = ARGV.empty? ? nil : ARGV.dup
+
+      controller = Turn::Controller.new do |c|
+        c.live      = live
+        c.log       = log
+        c.loadpath  = loadpath
+        c.requires  = requires
+        c.tests     = tests
+        c.runmode   = runmode
+        c.format    = outmode
+        c.pattern   = pattern
+        c.framework = framework
+      end
+
+      result = controller.start
+
+      if result
+        exit result.passed?
+      else # no tests
+        exit
+      end
+    end
+
+  end
+
+end

data/lib/turn/components/case.rb

@@ -2,6 +2,7 @@ module Turn
 
   #
   class TestCase
+    include Enumerable
 
     # Name of test case.
     attr_accessor :name
@@ -17,7 +18,7 @@ module Turn
     #attr_accessor :count_errors
     #attr_accessor :count_tests
 
-    # This can;t be calculated, so it must be
+    # This can't be calculated, so it must be
     # assigned by the runner.
     attr_accessor :count_assertions
 
@@ -71,6 +72,8 @@ module Turn
       tests.size
     end
 
+    alias_method :size, :count_tests
+
     def count_failures
       sum = 0; tests.each{ |t| sum += 1 if t.fail? }; sum
     end
@@ -92,6 +95,9 @@ module Turn
       tests.collect{ |t| t.message }.join("\n")
     end
 
+    def each(&block)
+      tests.each(&block)
+    end
   end
 
 end

data/lib/turn/components/method.rb

@@ -4,28 +4,38 @@ module Turn
   class TestMethod
     attr_accessor :name
     attr_accessor :file
+    attr_accessor :raised
     attr_accessor :message
+    attr_accessor :backtrace
 
     def initialize(name)
-      @name    = name
-      @fail    = false
-      @error   = false
-      @message = nil
+      @name      = name
+      @fail      = false
+      @error     = false
+      @raised    = nil
+      @message   = nil
+      @backtrace = []
     end
 
-    def fail!(message=nil)
+    def fail!(assertion)
       @fail, @error = true, false
-      @message = message if message
+      @rasied    = assertion
+      @message   = assertion.message
+      @backtrace = assertion.backtrace
     end
 
-    def error!(message=nil)
+    def error!(exception)
       @fail, @error = false, true
-      @message = message if message
+      @rasied    = exception
+      @message   = exception.message
+      @backtrace = exception.backtrace
     end
 
     def fail?  ; @fail  ; end
     def error? ; @error ; end
     def pass?  ; !(@fail or @error) ; end
+
+    def to_s ; name ; end
   end
 
 end

data/lib/turn/components/suite.rb

@@ -33,6 +33,18 @@ module Turn
       c
     end
 
+    def count_tests
+      #@count_tests ||= (
+        sum = 0; each{ |c| sum += c.count_tests }; sum
+      #)
+    end
+
+    def count_assertions
+      #@count_assertions ||= (
+        sum = 0; each{ |c| sum += c.count_assertions }; sum
+      #)
+    end
+
     def count_failures
       #@count_failures ||= (
         sum = 0; each{ |c| sum += c.count_failures }; sum
@@ -51,21 +63,9 @@ module Turn
       #)
     end
 
-    def count_tests
-      #@count_tests ||= (
-        sum = 0; each{ |c| sum += c.count_tests }; sum
-      #)
-    end
-
-    def count_assertions
-      #@count_assertions ||= (
-        sum = 0; each{ |c| sum += c.count_assertions }; sum
-      #)
-    end
-
     # Convenience methods --this is what is typcially wanted.
     def counts
-      return count_tests, count_assertions, count_failures, count_errors
+      return count_tests, count_assertions, count_failures, count_errors #,count_skips
     end
 
     def each(&block)
@@ -76,6 +76,9 @@ module Turn
       @size ||= @cases.size
     end
 
+    def passed?
+      (count_failures == 0 && count_errors == 0)
+    end
   end
 
 end

data/lib/turn/controller.rb

@@ -5,15 +5,6 @@ module Turn
   require 'turn/components/case.rb'
   require 'turn/components/method.rb'
 
-  require 'turn/reporters/outline_reporter'
-  require 'turn/reporters/marshal_reporter'
-  require 'turn/reporters/progress_reporter'
-  require 'turn/reporters/dot_reporter'
-
-  require 'turn/runners/testrunner'
-  require 'turn/runners/solorunner'
-  require 'turn/runners/crossrunner'
-
   # = Controller
   #
   #--
@@ -38,11 +29,11 @@ module Turn
     # Libs to require when running tests.
     attr_accessor :requires
 
-    # Instance of Reporter.
-    attr_accessor :reporter
+    # Reporter type.
+    attr_accessor :format
 
-    # Insatance of Runner.
-    attr_accessor :runner
+    # Run mode.
+    attr_accessor :runmode
 
     # Test against live install (i.e. Don't use loadpath option)
     attr_accessor :live
@@ -53,6 +44,9 @@ module Turn
     # Verbose output?
     attr_accessor :verbose
 
+    # Test framework, either :minitest or :testunit
+    attr_accessor :framework
+
     def verbose? ; @verbose ; end
     def live?    ; @live    ; end
 
@@ -71,8 +65,8 @@ module Turn
       @requires ||= []
       @live     ||= false
       @log      ||= true
-      @reporter ||= OutlineReporter.new($stdout)
-      @runner   ||= TestRunner.new
+      #@reporter ||= OutlineReporter.new($stdout)
+      #@runner   ||= RUBY_VERSION >= "1.9" ? MiniRunner : TestRunner
       @pattern  ||= /.*/
     end
 
@@ -128,7 +122,7 @@ module Turn
           File.directory?(x) ? Dir[File.join(x, '**', '*')] : Dir[x]
         end
         ex = ex.flatten.reject{ |f| File.directory?(f) }
-        (fs - ex).uniq
+        (fs - ex).uniq.map{ |f| File.expand_path(f) }
       )
     end
 
@@ -145,6 +139,65 @@ module Turn
       testrun.start
     end
 
+    # Select reporter based on output mode.
+    def reporter
+      @reporter ||= (
+        case format
+        when :marshal
+          require 'turn/reporters/marshal_reporter'
+          Turn::MarshalReporter.new($stdout)
+        when :progress
+          require 'turn/reporters/progress_reporter'
+          Turn::ProgressReporter.new($stdout)
+        when :dotted
+          require 'turn/reporters/dot_reporter'
+          Turn::DotReporter.new($stdout)
+        when :pretty
+          require 'turn/reporters/pretty_reporter'
+          Turn::PrettyReporter.new($stdout)
+        when :cue
+          require 'turn/reporters/cue_reporter'
+          Turn::CueReporter.new($stdout)
+        else
+          require 'turn/reporters/outline_reporter'
+          Turn::OutlineReporter.new($stdout)
+        end
+      )
+    end
+
+    # # Insatance of Runner, selected based on format and runmode.
+    def runner
+      @runner ||= (
+        case framework
+        when :minitest
+          require 'turn/runners/minirunner'
+        else
+          require 'turn/runners/testrunner'
+        end
+
+        case runmode
+        when :marshal
+          if framework == :minitest
+            Turn::MiniRunner
+          else
+            Turn::TestRunner
+          end
+        when :solo
+          require 'turn/runners/solorunner'
+          Turn::SoloRunner
+        when :cross
+          require 'turn/runners/crossrunner'
+          Turn::CrossRunner
+        else
+          if framework == :minitest
+            Turn::MiniRunner
+          else
+            Turn::TestRunner
+          end
+        end
+      )
+    end
+
   end
 
 end

data/lib/turn/core_ext.rb

@@ -0,0 +1,31 @@
+# Borrowed methods from Ruby Facets.
+
+class String
+
+  # Aligns each line n spaces.
+  def tab(n)
+    gsub(/^ */, ' ' * n)
+  end
+
+  # Preserves relative tabbing.
+  # The first non-empty line ends up with n spaces before nonspace.
+  def tabto(n)
+    if self =~ /^( *)\S/
+      indent(n - $1.length)
+    else
+      self
+    end
+  end
+
+  # Indent left or right by n spaces.
+  # (This used to be called #tab and aliased as #indent.)
+  def indent(n, c=' ')
+    if n >= 0
+      gsub(/^/, c * n)
+    else
+      gsub(/^#{Regexp.escape(c)}{0,#{-n}}/, "")
+    end
+  end
+
+end
+

data/lib/turn/reporter.rb

@@ -1,5 +1,6 @@
 module Turn
   require 'turn/colorize'
+  require 'turn/core_ext'
 
   # = Reporter
   #
@@ -23,10 +24,10 @@ module Turn
 
     # These methods are called in the process of running the tests.
 
-    def start_suite(suite)
+    def start_suite(test_suite)
     end
 
-    def start_case(kase)
+    def start_case(test_case)
     end
 
     def start_test(test)
@@ -35,19 +36,31 @@ module Turn
     def pass(message=nil)
     end
 
-    def fail(message=nil)
+    def fail(assertion, message=nil)
     end
 
-    def error(message=nil)
+    def error(exception, message=nil)
     end
 
     def finish_test(test)
     end
 
-    def finish_case(kase)
+    def finish_case(test_case)
     end
 
-    def finish_suite(suite)
+    def finish_suite(test_suite)
+    end
+
+  private
+
+    # TODO: backtrace filter probably could use some refinement.
+    def filter_backtrace(bt)
+      return [] unless bt
+      bt.reject!{ |line| line.rindex('minitest') }
+      bt.reject!{ |line| line.rindex('test/unit') }
+      bt.reject!{ |line| line.rindex('lib/turn') }
+      bt.reject!{ |line| line.rindex('bin/turn') }
+      bt.map{ |line| line.sub(Dir.pwd+'/', '') }
     end
 
   end