ratch 0.4.1 → 1.0.0

data/lib/ratch/toolset/ruby/test/extest

@@ -1,129 +0,0 @@
-#!/usr/bin/env ratch
-
-# Extract embedded tests.
-
-# Extract unit tests. This task scans every package script
-# looking for sections of the form:
-#
-#     =begin test
-#       ...
-#     =end
-#
-# With appropriate headers, it copies these sections to files
-# in your project's test/ dir, which then can be run using the
-# Ratchet test task. The exact directory layout of the files to
-# be tested is reflected in the test directory. You can then
-# use project.rb's test task to run the tests.
-#
-#     files      Files to extract ['lib/**/*.rb']
-#     output     Test directory   ['test/']
-
-main :extest do
-  extract_tests # Deal with arg once rathc has better support fot it.
-end
-
-# Extract tests for scripts.
-
-def extract_tests(files=nil)
-  output = 'test/embedded'     # Don't think output should be setable.
-
-  files  = files || 'lib/**/*.rb'
-  files = 'lib/**/*.rb' if TrueClass == files
-  files = [files].flatten.compact
-
-  filelist = files.collect{ |f| Dir.glob(f) }
-  filelist.flatten!
-  if filelist.empty?
-    puts "No scripts found from which to extract tests."
-    return
-  end
-
-  mkdir_p(output) unless directory?(output)
-
-  #vrunner = VerbosityRunner.new("Extracting", verbosity?)
-  #vrunner.setup(filelist.size)
-
-  filelist.each do |file|
-    #vrunner.prepare(file)
-
-    testing = extract_test_from_file( file )
-    if testing.strip.empty?
-      status = "[NONE]"
-    else
-      complete_test = create_test(testing, file)
-      libpath = File.dirname(file)
-      testfile = "test_" + File.basename(file)
-      fp = File.join(output, libpath, testfile)
-      unless directory?( File.dirname(fp))
-        mkdir_p(File.dirname(fp))
-      end
-      if dryrun?
-        puts "write #{fp}"
-      else
-        File.open(fp, "w"){ |fw| fw << complete_test }
-      end
-      status = "[TEST]"
-    end
-
-    #vrunner.complete(file, status)
-  end
-
-  #vrunner.finish(
-  #  :normal => "#{filelist.size} files had tests extracted.",
-  #  :check => false
-  #)
-end
-
-private
-
-# Extract test from a file's testing comments.
-
-def extract_test_from_file( file )
-  return nil if ! File.file?( file )
-  tests = ""; inside = false
-  fstr = File.read( file )
-  fstr.split(/\n/).each do |l|
-    if l =~ /^=begin[ ]*test/i
-      tests << "\n"
-      inside = true
-      next
-    elsif inside and l =~ /^=[ ]*end/
-      inside = false
-      next
-    end
-    if inside
-      tests << l << "\n"
-    end
-  end
-  tests
-end
-
-# Generate the test.
-
-def create_test( testing, file )
-  fp = file.split(/[\/]/)
-  if fp[0] == 'lib'
-    reqf = "require '#{fp[1..-1].join('/')}'"
-  else
-    reqf = ''
-  end
-  str = []
-  str << "  #  _____         _"
-  str << "  # |_   _|__  ___| |_"
-  str << "  #   | |/ _ \\/ __| __|"
-  str << "  #   | |  __/\\__ \\ |"
-  str << "  #   |_|\\___||___/\\__|"
-  str << "  #"
-  str << "  # for #{file}"
-  str << "  #"
-  str << "  # Extracted #{Time.now}"
-  str << "  # w/ Test Extraction Ratchet"
-  str << "  #"
-  str << ""
-  str << " #{reqf}"
-  str << ""
-  str << testing
-  str << "\n"
-  str = str.join("\n")
-  str
-end

data/lib/ratch/toolset/ruby/test/isotest

@@ -1,293 +0,0 @@
-#!/usr/bin/env ratch
-
-#
-require 'facets/hash/rekey'
-require 'facets/string/tabs'
-require 'facets/progressbar'
-
-require 'test/unit/ui/testrunnermediator' #require 'test/unit'
-::Test::Unit.run = true # Don't autorun tests!
-
-main :isotestsolid do
-  run_isotests
-end
-
-# Run unit-tests. Each test is run in a separate interpretor
-# to prevent script clash. This makes for a more robust test
-# facility and prevents potential conflicts between test scripts.
-#
-#   tests     Test files (eg. test/tc_**/*.rb) [test/**/*]
-#   libs      Directories to include in load path.
-#             ('./lib' is always included)
-#   live      Deactive use of local libs and test against install.
-#   reqs      List of files to require prior to running tests.
-#   extract   Extract embedded tests first? [false]
-#
-# To isolate tests this tool marshals test results across a
-# stdout->stdin shell pipe. This prevents interfence of one
-# script's tests on another. But consequently it is not always
-# possible to send debug info to stdout in the tests themselves
-# (eg. #p and #puts).
-
-def run_isotests
-  info = configuration['test']
-
-  tests   = info['files'] || 'test/unit/**/test_*.rb'
-  libs    = info['libpath']
-  reqs    = info['require']
-  live    = info['live']
-  #extract = info['extract']
-
-  tests = [ tests ].flatten
-  libs  = [ libs ].flatten
-
-  #files = [ @files ].flatten
-  #extract_tests if extract
-
-  results  = TestResults.new #(style)
-
-  # get test files
-  test_libs  = libs.join(':')
-  test_files = Dir.multiglob( *tests )
-  if test_files.empty?
-    puts "Tests        [NONE]"
-    return
-  end
-
-  # run tests
-
-  if trace?
-    pbar = nil
-    size = test_files.collect{|f| f.size}.max + 5
-    dots = '.' * size
-  else
-    pbar = Console::ProgressBar.new( 'Testing', test_files.size )
-    pbar.inc
-  end
-
-  test_files.each do |test_file|
-    pbar.inc if pbar
-    if ! File.file?(test_file)
-      next #r = nil
-    else
-      unless pbar
-        print test_file + dots[test_file.size..-1]
-        $stdout.flush
-      end
-      r = fork_test( test_file, :libs=>libs, :reqs=>reqs, :live=>live )
-      unless pbar
-        puts r.passed? ? "[PASS]" : "[FAIL]"
-      end
-    end
-    results << r
-  end
-
-  pbar.finish if pbar
-
-  # display results
-  puts results
-
-  fails, errrs = results.failure_count, results.error_count
-  #CHECKLIST << :test if fails > 0
-  #CHECKLIST << :test if errrs > 0
-  return (fails + errrs > 0)
-end
-
-# Run a test in a separate process.
-#
-# Currently send program output to null device.
-# Could send to a logger in future version.
-#
-# Key parameters are libs, reqs, live.
-
-def fork_test( file, keys )
-  keys = keys.rekey(:to_s)
-
-  libs = keys['lib'] || []
-  reqs = keys['req'] || []
-  live = keys['live']
-
-  src = ''
-
-  unless live
-    l = File.join( Dir.pwd, 'lib' )
-    if File.directory?( l )
-      src << %{$:.unshift('#{l}')\n}
-    end
-    libs.each { |r| src << %{$:.unshift('#{r}')\n} }
-  end
-
-  src << %{
-    #require 'test/unit'
-    require 'test/unit/collector'
-    require 'test/unit/collector/objectspace'
-    require 'test/unit/ui/testrunnermediator'
-  }
-
-  reqs.each do |fix|
-    src << %Q{
-      require '#{fix}'
-    }
-  end
-
-  src << %{
-    def warn(*null); end  # silence warnings
-
-    output = STDOUT.dup
-    STDOUT.reopen( PLATFORM =~ /mswin/ ? "NUL" : "/dev/null" )
-
-    load('#{file}')
-    tests = Test::Unit::Collector::ObjectSpace.new.collect
-    runner = Test::Unit::UI::TestRunnerMediator.new( tests )
-    result = runner.run_suite
-
-    begin
-      marshalled = Marshal.dump(result)
-    rescue TypeError => e
-      $stderr << "MARSHAL ERROR\n"
-      $stderr << "TEST: #{file}\n"
-      $stderr << "DATA:" << result.inspect
-      exit -1
-    end
-    output << marshalled
-
-    STDOUT.reopen(output)
-    output.close
-  }
-
-  result = IO.popen("ruby","w+") do |ruby|
-    ruby.puts src
-    ruby.close_write
-    ruby.read
-  end
-
-  begin
-    marsh = Marshal.load(result)
-  rescue ArgumentError
-    $stderr << "\nCannot load marshalled test data.\n"
-    $stderr << result << "\n"
-    exit -1
-  end
-
-  return marsh
-end
-
-#
-# Support class for collecting test results.
-#
-
-class TestResults
-  attr_reader :assertion_count,
-              :run_count,
-              :failure_count,
-              :error_count
-
-  attr_accessor :style
-
-  def initialize( style=nil )
-    @style = style
-
-    @results = []
-
-    @assertion_count = 0
-    @run_count = 0
-    @failure_count = 0
-    @error_count = 0
-  end
-
-  # Add a result to the results collection.
-
-  def <<( result )
-    @results << result
-
-    @assertion_count += result.assertion_count
-    @run_count += result.run_count
-    @failure_count += result.failure_count
-    @error_count += result.error_count
-  end
-
-  #
-
-  def errors
-    errors = []
-    @results.each do |r|
-      unless r.passed?
-        errors << r.instance_variable_get('@errors')
-      end
-    end
-    errors.reject! { |e| e == [] }
-    errors
-  end
-
-  #
-
-  def failures
-    failures = []
-    @results.each do |r|
-      unless r.passed?
-        failures << r.instance_variable_get('@failures')
-      end
-    end
-    failures.reject! { |e| e == [] }
-    failures
-  end
-
-  # Output format for test results.
-
-  def to_s
-    return @results.to_s if style == 'pease'
-
-    s = []
-    # Display failures
-    unless failures.empty?
-      s << ''
-      s << "FAILURES:"
-      failures.reverse.each do |fails|
-        fails.reverse.each do |failure|
-          #puts
-          s << %{  - test      : #{failure.test_name}}
-          s << %{    location  : #{failure.location}}
-          if failure.message.index("\n")
-            s << %{    message   : >}
-            s << failure.message.tabto(6)
-          else
-            s << %{    message   : #{failure.message}}
-          end
-        end
-      end
-    end
-
-    # Display errors
-    unless errors.empty?
-      s << ''
-      s << "ERRORS:"
-      errors.reverse.each do |errs|
-        errs.reverse.each do |err|
-          s << ''
-          s << %{  - test      : #{err.test_name}}
-          s << %{    message   : #{err.exception.message}}
-          s << %{    backtrace :}
-          err.exception.backtrace[0...-1].each { |bt| s << %Q{      - #{bt}} }
-        end
-      end
-    end
-
-    # Display final results
-    s << ''
-    s << "Summary:"
-    s << "  Tests      : #{@run_count}"
-    s << "  Assertions : #{@assertion_count}"
-    s << "  Failures   : #{@failure_count}"
-    s << "  Errors     : #{@error_count}"
-    s << ''
-    s << ''
-
-    return s.join("\n")
-  end
-
-  # Delegate missing call to the results array.
-
-  def method_missing(*a,&b)
-    @results.send(*a,&b)
-  end
-end

data/lib/ratch/toolset/ruby/test/load

@@ -1,39 +0,0 @@
-#!/usr/bin/env ratch
-
-# Load check all libs.
-
-#
-
-require 'benchmark'
-
-$:.unshift('lib')
-
-scripts_core, scripts_more = [], []
-Dir.chdir('lib') do
-  scripts_more = glob('facets/*.rb')
-  scripts_more.collect!{ |s| File.expand_path(s) }
-  scripts_more.uniq!
-
-  scripts_core = glob('facets/*/*.rb')
-  scripts_core.collect!{ |s| File.expand_path(s) }
-  scripts_core.uniq!
-end
-
-$VERBOSE = nil
-
-def require_scripts(scripts)
-  scripts.each do |file|
-    begin
-      require file
-    rescue Exception => e
-      puts file
-      puts e.message
-    end
-  end
-end
-
-Benchmark.bm do |x|
-  x.report("core"){ require_scripts(scripts_core) }
-  x.report("more"){ require_scripts(scripts_more) }
-end
-