turn 0.8.3 → 0.9.0

data/.gitignore

@@ -0,0 +1,4 @@
+coverage
+doc
+pkg
+tmp

data/Gemfile

@@ -1,9 +1,2 @@
 source :rubygems
-
-gem "ansi", ">= 1.2.2"
-
-group :development do
-  gem "bones"',     ">= 3.6.5"
-  gem "bones-get"', ">= 1.2.4"
-end
-
+gemspec

data/History.txt

@@ -1,3 +1,19 @@
+== 0.9.0 / 2012-01-30
+  * Fix bundle exec issue, which means...
+  * Developer's must require `turn/autorun` instead fo just `turn`.
+  * Improve detection of TestUnit 1.x vs. MiniTest
+  * Show randomization seed number in output.
+  * Pretty format option is now `-R` instead of `-T`.
+  * Rename case match shortcut to `-c` instead of `-t`.
+  * Add support for skipped tests.
+  * Support max backtrace limit via `-b` option.
+  * Use $RUBY_IGNORE_CALLERS to ignore lines of backtrace.
+  * Better color support on Windows (install ANSICON)
+  * MiniTest is a dependency (even if you are using it for TestUnit 1.x).
+
+== 0.8.4 / 2011-11-11
+  * Now must use MiniTest 2.0+.
+
 == 0.8.3 / 2011-10-10
   * Merge pull request #56 from codeinvain/master
   * Merge pull request #52 from markburns/patch-2

data/{NOTICE.txt → LICENSE.txt}

@@ -25,7 +25,7 @@ interface with MiniTest effectively.
 Copyright:: (c) Nathaniel Talbott
 License:: The Ruby License
 
-This software is distributed under the same terms as ruby.
+This software is distributed under the same terms as Ruby.
 
 See license/RUBY-LICENSE.txt for detiails.
 

data/README.md

@@ -85,6 +85,32 @@ the end user to install the TURN package.
 For a Rails application, put the require line into the 'test/test_helper.rb'
 script. Now your Rails tests will use TURN formatting.
 
+
+## RAILS/BUNDLER USERS
+
+Bundler automatically requires everything listed in your Gemfile, e.g.
+when using `bundle exec`. This means `turn` will get automatically
+required too, which in turn means the Turn's test autorunner is doing
+to kick in. Obviously we don't want that to happen unless we are actually
+running tests.
+
+Turn was created well before Bundler existed, and the use of `require 'turn'`
+as the autorunner was the obvious convenience. Unfortunately Bundler's choice
+to force require all requirements by defualt can have unexpected consequences,
+as is the case here.
+
+Thankfully there is a work around. In your Gemfile add:
+
+    gem 'turn', :require => false
+
+The `:require` option will prevent Turn from trying to autorun tests.
+
+In the future we will change turn to use `reuqire 'turn/autorun'` instead,
+but that will require a lot of people to update a lot of tests, so it's not
+something to do lightly. Full change over will wait until the 1.0 release.
+In the mean time Turn will just put out a warning.
+
+
 ## REQUIREMENTS:
 
 * ansi 1.1+ (for colorized output and progress bar output mode)

data/Rakefile

@@ -21,6 +21,7 @@ Bones {
   use_gmail
 
   depend_on 'ansi'
+  depend_on 'minitest'
   depend_on 'bones-git', :development => true
 }
 

data/Version.txt

@@ -1 +1 @@
-0.8.3
+0.9.0

data/bin/turn

@@ -1,4 +1,10 @@
 #!/usr/bin/env ruby
 require 'turn/command'
-Turn::Command.main(*ARGV)
+begin
+  Turn::Command.main(*ARGV)
+rescue StandardError => e
+  raise if $DEBUG
+  puts e
+  exit -1
+end
 

data/lib/turn.rb

@@ -1,19 +1,28 @@
+#
 module Turn
-  # Returns +true+ if the ruby version supports minitest.
-  # Otherwise, +false+ is returned.
-  def self.minitest?
-    RUBY_VERSION >= '1.9'
+  # Are we using Test::Unit (1.x)?
+  def self.testunit?
+    defined?(Test::Unit) && !defined?(MiniTest)
   end
 end
 
+require 'fileutils'
+
+require 'turn/version'
 require 'turn/autoload'
+require 'turn/configuration'
+require 'turn/colorize'
+require 'turn/components'
+require 'turn/controller'
 
-unless defined?(Turn::Command)
-  if Turn.minitest?
-    require 'turn/autorun/minitest'
-    MiniTest::Unit.autorun
-  else
-    require 'turn/autorun/testunit'
-  end
+if Turn.testunit?
+  require 'turn/testunit'
+else
+  require 'turn/minitest'
 end
 
+#if ENV['autorun']
+#  warn "Use `require 'turn/autorun'` instead of `require 'turn'` for future versions."
+#  MiniTest::Unit.autorun
+#end
+

data/lib/turn/autoload.rb

@@ -1,6 +1,6 @@
 # This is a "dirty trick" to load `test/unit` or `minitest/unit` if sought.
 # Eventually a way to handle this more robustly (without autoreload) 
-# should be worked out.
+# should be worked out. But how?
 autoload "Test",     'test/unit'
 autoload "MiniTest", 'minitest/unit'
 

data/lib/turn/autorun.rb

@@ -0,0 +1,8 @@
+require 'turn'
+
+if Turn.testunit?
+  Test::Unit.run = true
+else
+  MiniTest::Unit.autorun
+end
+

data/lib/turn/bin.rb

@@ -1,4 +1,10 @@
 $LOAD_PATH.unshift(File.dirname(File.dirname(__FILE__)))
 require 'turn/command'
-Turn::Command.main(*ARGV)
+#begin
+  Turn::Command.main(*ARGV)
+#rescue StandardError => e
+#  raise if $DEBUG
+#  puts e
+#  exit -1
+#end
 

data/lib/turn/colorize.rb

@@ -1,3 +1,5 @@
+require 'turn/configuration'  # why is this needed here?
+
 begin
   require 'ansi/code'
 rescue LoadError
@@ -10,17 +12,30 @@ end
 
 module Turn
 
+  # Provides a uniform interface for colorizing Turn output.
+  #
   module Colorize
 
     COLORLESS_TERMINALS = ['dumb']
 
-    def colorize?
-      defined?(::ANSI::Code) &&
-        ENV.has_key?('TERM') &&
-        !COLORLESS_TERMINALS.include?(ENV['TERM']) &&
-        $stdout.tty?
+    def self.colorize?
+      @colorize ||= (
+        ansi = Turn.config.ansi?
+        if ansi.nil?
+          color_supported?
+        else
+          Turn.config.ansi?
+        end
+      )
+    end
+
+    def self.color_supported?
+      return false unless defined?(::ANSI::Code)
+      return false unless $stdout.tty?
+      return true if ENV.has_key?('TERM') && !COLORLESS_TERMINALS.include?(ENV['TERM'])
+      return true if ::RbConfig::CONFIG['host_os'] =~ /mswin|mingw/ && ENV.has_key?('ANSICON')
+      return false
     end
-    module_function :colorize?
 
     def self.red(string)
       colorize? ? ::ANSI::Code.red{ string } : string
@@ -50,11 +65,8 @@ module Turn
       colorize? ? ::ANSI::Code.red{ string } : string
     end
 
-    #def self.error(string)
-    #  colorize? ? ::ANSI::Code.white{ ::ANSI::Code.on_red{ string } } : string
-    #end
-
     def self.error(string)
+      #colorize? ? ::ANSI::Code.white_on_red{ string } : string
       colorize? ? ::ANSI::Code.yellow{ string } : string
     end
 
@@ -67,6 +79,10 @@ module Turn
     ERROR = error('ERROR')
     SKIP  = skip('SKIP')
 
+    def colorize?
+      Colorize.colorize?
+    end
+
   end
 
 end

data/lib/turn/command.rb

@@ -1,7 +1,7 @@
 require 'optparse'
+require 'turn'
 
 module Turn
-  require 'turn/controller'
 
   # Turn - Pretty Unit Test Runner for Ruby
   #
@@ -13,10 +13,11 @@ module Turn
   #      --live             don't use loadpath
   #      --log              log results to a file
   #   -n --name=PATTERN     only run tests that match regexp PATTERN
+  #   -c --case=PATTERN     only run testcases 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.
-  #   -t --trace            Turn on invoke/execute tracing, enable full backtrace.
+  #   -b --backtrace=INT    Set the number of lines to show in backtrace.
   #
   # RUN MODES
   #      --normal      run all tests in a single process [default]
@@ -27,9 +28,9 @@ module Turn
   #   -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
+  #   -R --pretty      new pretty reporter
   #   -M --marshal     dump output as YAML (normal run mode only)
-  #   -Q --queued      interactive testing
+  #   -C --cue         interactive testing
   #
   class Command
 
@@ -57,7 +58,7 @@ module Turn
     attr :requires
 
     # Framework to use, :minitest or :testunit.
-    attr :framework
+    #attr :framework
 
     # Run mode.
     attr :runmode
@@ -68,6 +69,12 @@ module Turn
     # Enable full backtrace
     attr :trace
 
+    # Use natural test case names.
+    attr :natural
+
+    # Force ANSI use on or off.
+    attr :ansi
+
     #
     def initialize
       @live      = nil
@@ -78,8 +85,10 @@ module Turn
       @requires  = []
       @runmode   = nil
       @outmode   = nil
-      @framework = RUBY_VERSION >= "1.9" ? :minitest : :testunit
+      #@framework = RUBY_VERSION >= "1.9" ? :minitest : :testunit
       @trace     = nil
+      @natural   = false
+      @ansi      = nil
     end
 
     #
@@ -111,7 +120,7 @@ module Turn
           end
         end
 
-        opts.on('-t', '--testcase=PATTERN', "only run testcases that match PATTERN") do |pattern|
+        opts.on('-c', '--case=PATTERN', "only run test cases that match PATTERN") do |pattern|
           if pattern =~ /\/(.*)\//
             @matchcase = Regexp.new($1)
           else
@@ -119,12 +128,20 @@ module Turn
           end
         end
 
-        opts.on('-m', '--minitest', "Force use of MiniTest framework") do
-          @framework = :minitest
+        #opts.on('-m', '--minitest', "Force use of MiniTest framework") do
+        #  @framework = :minitest
+        #end
+
+        opts.on('-b', '--backtrace', '--trace INT', "Limit the number of lines of backtrace.") do |int|
+          @trace = int
+        end
+
+        opts.on('--natural', "Show natualized test names.") do |bool|
+          @natural = bool
         end
 
-        opts.on("-T", '--trace', "Turn on invoke/execute tracing, enable full backtrace") do
-          @trace = true
+        opts.on('--[no-]ansi', "Force use of ANSI codes on or off.") do |bool|
+          @ansi = bool
         end
 
         # Turn does not support Test::Unit 2.0+
@@ -173,7 +190,7 @@ module Turn
           @outmode = :dotted
         end
 
-        opts.on('--pretty', '-T', "new pretty output mode") do
+        opts.on('--pretty', '-R', '-T', "new pretty output mode") do
           @outmode = :pretty
         end
 
@@ -225,8 +242,10 @@ module Turn
         c.format    = outmode
         c.pattern   = pattern
         c.matchcase = matchcase
-        c.framework = framework
+        #c.framework = framework
         c.trace     = trace
+        c.natural   = natural
+        c.ansi      = ansi unless ansi.nil?
       end
 
       controller = Turn::Controller.new(config)

data/lib/turn/components.rb

@@ -0,0 +1,4 @@
+require 'turn/components/suite'
+require 'turn/components/case'
+require 'turn/components/method'
+

data/lib/turn/components/case.rb

@@ -23,7 +23,7 @@ module Turn
     attr_accessor :count_assertions
 
     # Holds dump of test output (optional depending on runner).
-    attr_accessor :message
+    attr_writer :message
 
     # Command used to run test (optional depending on runner).
     #attr_accessor :command

data/lib/turn/components/suite.rb

@@ -6,18 +6,19 @@ module Turn
     include Enumerable
 
     attr_accessor :name
-    attr_accessor :size
     attr_accessor :cases
+    attr_accessor :seed
 
     # This one can be set manually since it
     # is not calculatable (beyond the case level).
-    attr_accessor :count_assertions
+    attr_writer :count_assertions
 
     #
     def initialize(name=nil)
       @name  = name
-      @size  = nil
       @cases = []
+      @size  = nil
+      @seed  = nil
 
       #@count_tests      = nil
       #@count_assertions = nil
@@ -76,6 +77,11 @@ module Turn
       @size ||= @cases.size
     end
 
+    # Why the size would ever have to overridden... well who can say.
+    def size=(number)
+      @size = number.to_i
+    end
+
     def passed?
       (count_failures == 0 && count_errors == 0)
     end

data/lib/turn/configuration.rb

@@ -0,0 +1,197 @@
+module Turn
+
+  # Configure Turn
+  def self.config(&block)
+    @config ||= Configuration.new
+    block.call(@config) if block
+    @config
+  end
+
+  # TODO: Support for test run loggging ?
+
+  # Central interface for Turn configuration.
+  #
+  class Configuration
+
+    # List of if file names or glob pattern of tests to run.
+    attr_reader :tests
+
+    # List of file names or globs to exclude from +tests+ list.
+    attr_reader :exclude
+
+    # Regexp pattern that all test name's must
+    # match to be eligible to run.
+    attr_accessor :pattern
+
+    # Regexp pattern that all test cases must
+    # match to be eligible to run.
+    attr_accessor :matchcase
+
+    # Add these folders to the $LOAD_PATH.
+    attr_reader :loadpath
+
+    # Libs to require when running tests.
+    attr_reader :requires
+
+    # Reporter type.
+    attr_accessor :format
+
+    # Run mode.
+    attr_accessor :runmode
+
+    # Test against live install (i.e. Don't use loadpath option)
+    attr_accessor :live
+
+    # Log results? May be true/false or log file name. (TODO)
+    attr_accessor :log
+
+    # Verbose output?
+    attr_accessor :verbose
+
+    # Test framework, either :minitest or :testunit
+    attr_accessor :framework
+
+    # Enable full backtrace
+    attr_accessor :trace
+
+    # Use natural language case names.
+    attr_accessor :natural
+
+    def verbose? ; @verbose ; end
+    def live?    ; @live    ; end
+    def natural? ; @natural ; end
+    def ansi?    ; @ansi    ; end
+
+  private
+
+    def initialize
+      yield(self) if block_given?
+      initialize_defaults
+    end
+
+    #
+    def initialize_defaults
+      @loadpath  ||= ['lib']
+      @tests     ||= ["test/**/{test,}*{,test}.rb"]
+      @exclude   ||= []
+      @requires  ||= []
+      @live      ||= false
+      @log       ||= true
+      #@format   ||= nil
+      #@runner   ||= RUBY_VERSION >= "1.9" ? MiniRunner : TestRunner
+      @matchcase ||= nil
+      @pattern   ||= /.*/
+      @natural   ||= false
+      @trace     ||= environment_trace
+      @ansi      ||= nil
+
+      @files = nil  # reset files just in case
+    end
+
+    # Collect test configuation.
+    #def test_configuration(options={})
+    #  #options = configure_options(options, 'test')
+    #  #options['loadpath'] ||= metadata.loadpath
+    #  options['tests']    ||= self.tests
+    #  options['loadpath'] ||= self.loadpath
+    #  options['requires'] ||= self.requires
+    #  options['live']     ||= self.live
+    #  options['exclude']  ||= self.exclude
+    #  #options['tests']    = list_option(options['tests'])
+    #  options['loadpath'] = list_option(options['loadpath'])
+    #  options['exclude']  = list_option(options['exclude'])
+    #  options['require']  = list_option(options['require'])
+    #  return options
+    #end
+
+    #
+    def list_option(list)
+      case list
+      when nil
+        []
+      when Array
+        list
+      else
+        list.split(/[:;]/)
+      end
+    end
+
+  public
+
+    def ansi=(boolean)
+      @ansi = boolean ? true : false
+    end
+
+    def tests=(paths)
+      @tests = list_option(paths)
+    end
+
+    def loadpath=(paths)
+      @loadpath = list_option(paths)
+    end
+
+    def exclude=(paths)
+      @exclude = list_option(paths)
+    end
+
+    def requires=(paths)
+      @requires = list_option(paths)
+    end
+
+    # Test files.
+    def files
+      @files ||= (
+        fs = tests.map do |t|
+          File.directory?(t) ? Dir[File.join(t, '**', '*')] : Dir[t]
+        end
+        fs = fs.flatten.reject{ |f| File.directory?(f) }
+
+        ex = exclude.map do |x|
+          File.directory?(x) ? Dir[File.join(x, '**', '*')] : Dir[x]
+        end
+        ex = ex.flatten.reject{ |f| File.directory?(f) }
+
+        (fs - ex).uniq.map{ |f| File.expand_path(f) }
+      ).flatten
+    end
+
+    # TODO: Better name ?
+    def suite_name
+      files.map{ |path| File.dirname(path).sub(Dir.pwd+'/','') }.uniq.join(',')
+    end
+
+    # Select reporter based on output mode.
+    def reporter
+      @reporter ||= (
+        opts = { :trace=>trace, :natural=>natural? }
+        case format
+        when :marshal
+          require 'turn/reporters/marshal_reporter'
+          Turn::MarshalReporter.new($stdout, opts)
+        when :progress
+          require 'turn/reporters/progress_reporter'
+          Turn::ProgressReporter.new($stdout, opts)
+        when :dotted, :dot
+          require 'turn/reporters/dot_reporter'
+          Turn::DotReporter.new($stdout, opts)
+        when :pretty
+          require 'turn/reporters/pretty_reporter'
+          Turn::PrettyReporter.new($stdout, opts)
+        when :cue
+          require 'turn/reporters/cue_reporter'
+          Turn::CueReporter.new($stdout, opts)
+        else
+          require 'turn/reporters/outline_reporter'
+          Turn::OutlineReporter.new($stdout, opts)
+        end
+      )
+    end
+
+    #
+    def environment_trace
+      (ENV['backtrace'] ? ENV['backtrace'].to_i : nil)
+    end
+
+  end
+
+end