test 0.2.0

data/VERSION

@@ -0,0 +1 @@
+0.2.0

data/bin/ruby-test

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'test/cli'
+Test::Runner.cli(*ARGV)
+

data/lib/test.rb

@@ -0,0 +1,3 @@
+# TODO: Should we have test.rb file?
+
+require 'test/autorun'

data/lib/test/autorun.rb

@@ -0,0 +1,18 @@
+$TEST_SUITE = [] unless defined?($TEST_SUITE)
+
+at_exit {
+  if RUBY_VERSION < '1.9'
+    require 'test/runner'
+  else
+    require_relative 'runner'
+  end
+
+  suite   = $TEST_SUITE
+  options = {
+    :format => ENV['ruby-test-format']  # TODO: better name?
+  }
+
+  runner  = Test::Runner.new(suite, options)
+  success = runner.run
+  exit -1 unless success
+}

data/lib/test/cli.rb

@@ -0,0 +1,110 @@
+module Test
+
+  require 'test/config'
+  require 'test/runner'
+
+  # Command line interface.
+  class Runner
+
+    # Test runner command line interface.
+    #
+    def self.cli(*argv)
+      runner = new
+
+      Test::Config.load
+
+      cli_options(runner, argv)
+
+      begin
+        # Add standard location if it exists.
+        $LOAD_PATH.unshift(File.expand_path('lib')) if File.directory?('lib')
+
+        success = runner.run
+        exit -1 unless success
+      rescue => error
+        raise error if $DEBUG
+        $stderr.puts('ERROR: ' + error.to_s)
+      end
+    end
+
+    #
+    def self.cli_options(runner, argv)
+      require 'optparse'
+
+      config = Test.config.dup
+      config_loaded = false
+
+      common  = config.delete('common')
+      default = config.delete('default')
+
+      common.call(runner) if common
+
+      OptionParser.new do |opt|
+        opt.banner = "Usage: #{$0} [options] [files ...]"
+
+        unless config.empty?
+          opt.separator "PRESET OPTIONS:"
+          config.each do |name, block|
+            opt.on("--#{name}") do
+              block.call(runner)
+            end
+          end
+        end
+
+        opt.separator "CONFIG OPTIONS:"
+
+        opt.on '-f', '--format NAME', 'report format' do |name|
+          runner.format = name
+        end
+        opt.on '-y', '--tapy', 'shortcut for -f tapy' do
+          runner.format = 'tapy'
+        end
+        opt.on '-j', '--tapj', 'shortcut for -f tapj' do
+          runner.format = 'tapj'
+        end
+
+        opt.on '-t', '--tag TAG', 'select tests by tag' do |tag|
+          runner.tags << tag
+        end
+        opt.on '-u', '--unit TAG', 'select tests by software unit' do |unit|
+          runner.units << unit
+        end
+        opt.on '-m', '--match TEXT', 'select tests by description' do |text|
+          runner.match << text 
+        end
+
+        opt.on '-I', '--loadpath PATH',  'add to $LOAD_PATH' do |paths|
+          paths.split(/[:;]/).reverse_each do |path|
+            $LOAD_PATH.unshift path
+          end
+        end
+        opt.on '-r', '--require FILE', 'require file' do |file|
+          require file
+        end
+        opt.on '-v' , '--verbose', 'provide extra detailed report' do
+          runner.verbose = true
+        end
+        #opt.on('--log DIRECTORY', 'log directory'){ |dir|
+        #  options[:log] = dir
+        #}
+        opt.on_tail("--[no-]ansi" , 'turn on/off ANSI colors'){ |v| $ansi = v }
+        opt.on_tail("--debug" , 'turn on debugging mode'){ $DEBUG = true }
+        #opt.on_tail("--about" , 'display information about lemon'){
+        #  puts "Ruby Test v#{VERSION}"
+        #  puts "#{COPYRIGHT}"
+        #  exit
+        #}
+        opt.on_tail('-h', '--help', 'display this help message'){
+          puts opt
+          exit
+        }
+      end.parse!(argv)
+
+      default.call(runner) if default && !config_loaded
+
+      runner.files.replace(argv) unless argv.empty?
+    end
+
+  end
+
+end

data/lib/test/code_snippet.rb

@@ -0,0 +1,93 @@
+module Test
+
+  # Thanks goes to Suraj N. Kurapati for the origins of this code.
+  #
+  class CodeSnippet
+
+    def self.cache(file)
+      @cache ||= {}
+      @cache[file] ||=  File.readlines(file)
+    end
+
+    #
+    def self.from_backtrace(backtrace)
+      backtrace.first =~ /(.+?):(\d+(?=:|\z))/ or return ""
+      file, line = $1, $2.to_i
+      new(file, line)
+    end
+
+    #
+    def self.from_error(exception)
+      backtrace = exception.backtrace
+      from_backtrace(backtrace)
+    end
+
+    #
+    def initialize(file, line)
+      @file = file
+      @line = line || 1
+      @code = CodeSnippet.cache(file)
+    end
+
+    #
+    attr :file
+
+    #
+    attr :line
+
+    #
+    attr :code
+
+    #
+    alias :source :code
+
+    #
+    def to_str
+      code[line-1].strip
+    end
+
+    #
+    #--
+    # TODO: ensure proper alignment by zero-padding line numbers
+    #++
+    def to_s(radius=2)
+      r = range(radius)
+      f = " %2s %0#{r.last.to_s.length}d %s"
+      r.map do |n|
+        f % [('=>' if n == line), n, code[n-1].chomp]
+      end.join("\n")
+    end
+
+    #
+    def to_a(radius=2)
+      r = range(radius)
+      r.map do |n|
+        code[n-1].chomp
+      end
+    end
+
+    #
+    def to_omap(radius=2)
+      a = []
+      r = range(radius)
+      r.each do |n|
+        a << {n => code[n-1].chomp}
+      end
+      a
+    end
+
+    #
+    def succ
+      line += 1
+    end
+
+  private
+
+    #
+    def range(radius)
+      [line - radius, 1].max..[line + radius, source.length].min
+    end
+
+  end
+
+end

data/lib/test/config.rb

@@ -0,0 +1,72 @@
+module Test
+
+  #
+  def self.run(name=:default, &block)
+    @config ||= {}
+    @config[name.to_s] = block
+  end
+
+  def self.config
+    @config ||= {}
+  end
+
+  #
+  class Config
+
+    # Test configuration file.
+    #
+    # The name of the file is an ode to the original Ruby cli test tool.
+    #
+    # @example
+    #   .test
+    #   .testrb
+    #   .test.rb
+    #   .config/test.rb
+    #
+    GLOB_RC = '{.testrb,.test.rb,.test,.config/test.rb,config/test.rb}'
+
+    #
+    GLOB_ROOT = '{.ruby,.git,.hg}'
+
+    #
+    def self.load
+      super(rc_file) if rc_file
+    end
+
+    # Find rc file.
+    def self.rc_file
+      @rc_file ||= (
+        glob    = GLOB_RC
+        stop    = root
+        default = nil
+        dir     = Dir.pwd
+        file    = nil
+        loop do
+          file = Dir[File.join(dir, glob)].first
+          break file if file
+          break if dir == stop
+          dir = File.dirname(dir)
+          break if dir == '/'
+        end
+        file ? file : default
+      )
+    end
+
+    # Find project root.
+    def self.root
+      @root ||= (
+        glob    = GLOB_ROOT
+        stop    = '/'
+        default = Dir.pwd
+        dir     = Dir.pwd
+        until dir == stop
+          break dir if Dir[File.join(dir, glob)].first
+          dir = File.dirname(dir)
+        end
+        dir == stop ? default : dir
+      )
+    end
+
+  end
+
+end

data/lib/test/core_ext.rb

@@ -0,0 +1,9 @@
+if RUBY_VERSION < '1.9'
+  require 'test/core_ext/assertion'
+  require 'test/core_ext/exception'
+  require 'test/core_ext/string'
+else
+  require_relative 'core_ext/assertion'
+  require_relative 'core_ext/exception'
+  require_relative 'core_ext/string'
+end

data/lib/test/core_ext/assertion.rb

@@ -0,0 +1,30 @@
+class Assertion < Exception
+
+  # New assertion (failure).
+  #
+  # @param message [String] the failure message
+  # @param options [Hash] options such as :backtrace
+  #
+  def initialize(message=nil, options={})
+    super(message)
+    backtrace = options[:backtrace]
+    set_backtrace(backtrace) if backtrace
+    @assertion = true
+  end
+
+  # Technically any object that affirmatively responds to #assertion?
+  # can be taken to be an Assertion. This makes it easier for various 
+  # libraries to work together without having to depend upon a common
+  # Assertion base class.
+  def assertion?
+    true # @assertion
+  end
+
+  # Parents error message prefixed with "(assertion)".
+  #
+  # @return [String] error message
+  def to_s
+    '(assertion) ' + super
+  end
+
+end

data/lib/test/core_ext/exception.rb

@@ -0,0 +1,8 @@
+class Exception
+  def set_assertion(boolean)
+    @assertion = boolean
+  end
+  def assertion?
+    @assertion
+  end
+end

data/lib/test/core_ext/string.rb

@@ -0,0 +1,30 @@
+class String
+
+  # Preserves relative tabbing.
+  # The first non-empty line ends up with n spaces before nonspace.
+  #
+  # This is a Ruby Facet (http://rubyworks.github.com/facets).
+
+  def tabto(n)
+    if self =~ /^( *)\S/
+      indent(n - $1.length)
+    else
+      self
+    end
+  end unless method_defined?(:tabto)
+
+  # Indent left or right by n spaces.
+  # (This used to be called #tab and aliased as #indent.)
+  #
+  # This is a Ruby Facet (http://rubyworks.github.com/facets).
+
+  def indent(n, c=' ')
+    if n >= 0
+      gsub(/^/, c * n)
+    else
+      gsub(/^#{Regexp.escape(c)}{0,#{-n}}/, "")
+    end
+  end unless method_defined?(:indent)
+
+end
+

data/lib/test/rake.rb

@@ -0,0 +1,120 @@
+require 'rake/tasklib'
+
+module Test
+
+  module Rake
+
+    # Define a test rake task.
+    #
+    # The `TEST` environment variable can be used to select tests
+    # when using the task.
+    #
+    #--
+    #   TODO: The test task uses #fork. Maybe it should shell out instead?
+    #         Or provide the option for either?
+    #++
+    class TestTask < ::Rake::TaskLib
+
+      # Glob patterns are used by default to select test scripts.
+      DEFAULT_TESTS = [
+        'test/**/case_*.rb',
+        'test/**/*_case.rb',
+        'test/**/test_*.rb',
+        'test/**/*_test.rb'
+      ]
+
+      # Test scripts to load. Can be a file glob.
+      attr_accessor :tests
+
+      # Paths to add to $LOAD_PATH.
+      attr_accessor :loadpath
+
+      # Scripts to load prior to loading tests.
+      attr_accessor :requires
+
+      # Report format to use.
+      attr_accessor :format
+
+      # Filter tests based by tags.
+      attr_accessor :tags
+
+      # Filter tests by matching description.
+      attr_accessor :match
+
+      #
+      def initialize(name='test', desc="run tests", &block)
+        @name       = name
+        @desc       = desc
+
+        @loadpath   = ['lib']
+        @requires   = []
+        @tests      = [ENV['TEST'] || DEFAULT_TESTS].flatten
+        @format     = nil
+        @match      = nil
+        @tags       = []
+
+        block.call(self)
+
+        define_task
+      end
+
+      #
+      def define_task
+        desc @desc
+        task @name do
+          @tests ||= default_tests
+          run
+        end
+      end
+
+      #
+      def run
+        fork {
+          #require 'test'
+          require 'test/runner'
+
+          loadpath.each   { |d| $LOAD_PATH.unshift(d) }
+          requires.each   { |f| require f }
+          test_files.each { |f| require f }
+
+          suite   = $TEST_SUITE || []
+          runner  = new(suite, :format=>format, :tags=>tags, :match=>match)
+          success = runner.run
+
+          exit -1 unless success
+        }
+        Process.wait
+      end
+
+      # Resolve test globs.
+      #--
+      # TODO: simplify?
+      #++
+      def test_files
+        files = tests
+        files = files.map{ |f| Dir[f] }.flatten
+        files = files.map{ |f| File.directory?(f) ? Dir[File.join(f, '**/*.rb')] : f }
+        files = files.flatten.uniq
+        files = files.map{ |f| File.expand_path(f) }
+        files
+      end
+
+      #
+      def default_tests
+        if ENV['tests']
+          ENV['tests'].split(/[:;]/)
+        else
+          DEFAULT_TESTS
+        end
+      end
+
+      #
+      #def ruby_command
+      #  File.join(RbConfig::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
+      #end
+
+    end
+
+  end
+
+end