reap 5.0.0 → 5.10.10

data/lib/reap/task/test.rb

@@ -1,4 +1,3 @@
-#!/usr/bin/env ruby
 
 require 'reap/task'
 
@@ -6,114 +5,65 @@ require 'reap/task'
 require 'test/unit/ui/testrunnermediator'
 require 'facet/string/tabto'
 
-require 'facet/progressbar'
-
 Test::Unit.run = true  # don't run auto tests
 
-#  _____       _     _____        _
-# |_   _|__ __| |_  |_   _|_ _ __| |__
-#   | |/ -_|_-<  _|   | |/ _` (_-< / /
-#   |_|\___/__/\__|   |_|\__,_/__/_\_\
 #
-
-# = Test Task
+# Test Task
 #
-# The Reap test task runs each test in it's own
-# proccess, making for purer test facility.
+# The Reap test task runs each test in
+# it's own process, making for purer
+# test facility.
+#
+# NOTE: This works well enough but it is a bit of
+# hack. It actually marshals test results across
+# a stdout->stdin shell pipe. One consequence of
+# this is that you can't send debug info to stdout
+# (including #p and #puts). This, hopefully can be
+# remedied in the future.
 #
-# NOTE This works well enough but it is a tad delicate.
-# It actually marshals test results across stdout->stdin
-# shell pipe. One consequence of this is that you can't
-# send debug info to stdout (including #p and #puts).
-# This, hopefully can be remedied in the future.
-
 class Reap::Test < Reap::Task
 
-  task_desc "Run unit-tests (each in a separate process)."
-
-  task_help %{
-
-    reap test
-
-    Run unit tests. Reap runs each test in a separate
-    proccess to aviod potential conflicts between scripts.
-
-      files       Test files (eg. test/tc_**/*.rb)
-                  Defaults to typcial selection.
-
-      libs        List of lookup directories to include in
-                  load path. './lib' is always included.
-
-      live        Flag to quickly deactive use of local libs.
-                  Test against installed files instead.
-
-      requires    List of any files to pre-require.
-
-  }
-
-  task_attr :tst
-
-  # Run testing task.
-
-  def run
-
-    # setup
+  def task_desc
+    "Run unit-tests (each in a separate process)."
+  end
 
-    tst.files    ||= [ 'test/*/**/*.rb', 'test/**/tc*.rb', 'test/**/test*.rb', 'test/**/*test.rb' ]
-    tst.requires ||= []
+  attr_accessor :libs, :files, :fixture, :against_installed
 
-    tst.live ||= false
-    tst.libs ||= [] #['./lib']
+  def init
+    @libs    ||= ['lib']
+    @files   ||= [ 'test/*/**/*.rb', 'test/**/tc*.rb', 'test/**/test*.rb', 'test/**/*test.rb' ]
+    @fixture ||= []
+    @against_installed ||= false
 
     # interal use
-
     @results = TestResults.new
     @errors = []
     @failures = []
+  end
 
-    # Get test files
-
-    test_libs = tst.libs.join(':')
+  def run
+    # get test files
+    test_libs = @libs.join(':')
     test_files = FileList.new
-    test_files.include(*tst.files)
-    test_files.uniq!
-
+    test_files.include(*@files)
     if test_files.empty?
-      tell "No test files found."
+      puts "No test files found."
       return
     end
+    print "Reap is shelling out work to Ruby's Test Suite..."
 
-    #tell "Reap is passing off work to Ruby's Test Suite..."
-
-    pbar = Console::ProgressBar.new( 'Testing', test_files.size )
-
-    # Run tests
-    # (why arn't these unique to begin with?)
-    test_files.each do |test_file|
-      pbar.inc
-      #$stdout << '.'; $stdout.flush
-
-      if ! File.file?( test_file )
-        r = nil
-      else
-        r = fork_test( test_file )
-      end
-      unless r.passed?
-        @errors << r.instance_variable_get('@errors')
-        @failures << r.instance_variable_get('@failures')
-      end
-      @results << r
-
+    test_files.each { |f|
+      $stdout << '.'; $stdout.flush
+      dotest( f )
       #ruby %{-r"test/unit" "#{f}"}
-    end
-
-    pbar.finish
+    }
+    puts "done."
 
     # Don't know why empty arrays get in them yet, but...
     @failures.reject! { |e| e == [] }
     @errors.reject! { |e| e == [] }
 
-    # Display failures
+    # Display Failures
     puts
     puts %{FAILURES:#{@failures.empty? ? ' []' : ''}}
     @failures.reverse.each { |fails|
@@ -130,7 +80,7 @@ class Reap::Test < Reap::Task
       }
     }
 
-    # Display errors
+    # Display Errors
     puts
     puts %{ERRORS:#{@errors.empty? ? ' []' : ''}}
     @errors.reverse.each { |errs|
@@ -143,7 +93,7 @@ class Reap::Test < Reap::Task
       }
     }
 
-    # Display final results
+    # Display Final Results
     puts
     puts @results
     puts
@@ -154,41 +104,35 @@ class Reap::Test < Reap::Task
     #ruby %{-e0 -r"test/unit" \\\n#{test_reqs}#{test_opts}}
   end
 
-private
-
-
-  #def dotest( tst, test_file )
-  #end
+  def dotest( test_file )
+    if ! File.file?( test_file )
+      r = nil
+    else
+      r = fork_test( test_file )
+    end
+    unless r.passed?
+      @errors << r.instance_variable_get('@errors')
+      @failures << r.instance_variable_get('@failures')
+    end
+    @results << r
+  end
 
-  # Runs a test.
-  #
   # Currently send program output to null device.
   # Could send to a logger in future version.
-
   def fork_test( testfile )
     src = ''
-
-    unless tst.live
-      l = File.join( Dir.pwd, 'lib' )
-      if File.directory?( l )
-        src << %{$:.unshift('#{l}')\n}
-      end
-      tst.libs.each { |r| src << %{$:.unshift('#{r}')\n} }
-    end
-
+    src << %{$:.unshift('lib')} unless against_installed
     src << %{
       #require 'test/unit'
       require 'test/unit/collector'
       require 'test/unit/collector/objectspace'
       require 'test/unit/ui/testrunnermediator'
     }
-
-    tst.requires.each do |fix|
+    fixture.each do |fix|
       src << %Q{
         require '#{fix}'
       }
     end
-
     src << %{
       output = STDOUT.dup
       STDOUT.reopen( PLATFORM =~ /mswin/ ? "NUL" : "/dev/null" )
@@ -197,62 +141,37 @@ private
       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: #{testfile}\n"
-        $stderr << "DATA:" << result.inspect
-        exit -1
-      end
-      output << marshalled
+      output << Marshal.dump(result)
 
       STDOUT.reopen(output)
       output.close
     }
-
     result = IO.popen("ruby","w+") do |ruby|
       ruby.puts src
       ruby.close_write
       ruby.read
     end
-
     p testfile if $VERBOSE
-
-    begin
-      marsh = Marshal.load(result)
-    rescue ArgumentError
-      $stderr << "\nCannot load marshalled test data.\n"
-      $stderr << result << "\n"
-      exit -1
-    end
-
-    return marsh
+    return Marshal.load(result)
   end
 
   #
-  # Support class for collecting test results.
+  # Support class for collecting test results
   #
-
   class TestResults
-
     attr_reader :assertion_count, :run_count, :failure_count, :error_count
-
     def initialize
       @assertion_count = 0
       @run_count = 0
       @failure_count = 0
       @error_count = 0
     end
-
     def <<( result )
       @assertion_count += result.assertion_count
       @run_count += result.run_count
       @failure_count += result.failure_count
       @error_count += result.error_count
     end
-
     def to_s
       s  = %{SUMMARY:\n\n}
       s << %{  tests      : #{@run_count}\n}
@@ -261,20 +180,6 @@ private
       s << %{  errors     : #{@error_count}\n}
       s
     end
-
-  end
-
-end
-
-
-# Rake interface.
-
-if defined?(Rake)
-
-  #require 'reap/rake/adapter'
-
-  module Rake
-    ReapTest = ::Reap::RakeAdapter( ::Reap::Test )
   end
 
 end

data/lib/reap/task/testext.rb

@@ -0,0 +1,110 @@
+require 'reap/task'
+require 'facet/string/margin'
+
+# Extract Test Task
+#
+# The Reap extract test task scans every package script
+# looking for =begin testing ... =end sections.
+# With appropriat headers, it copies these sections
+# to files in the test dir, which then can be run
+# using the Reap test taks.
+#
+class Reap::TestExt < Reap::Task
+
+  def task_desc
+    "Extract unit-tests from lib scripts."
+  end
+
+  attr_accessor :dir, :files, :options
+
+  def init
+    @dir    ||= 'test'
+    @files  ||= [ 'lib/**/*.rb' ]
+    #@options
+  end
+
+  def run
+    #test_libs = @libs.join(':')
+    files = FileList.new
+    files.include(*@files)
+    if files.empty?
+      puts "No script files found."
+      return
+    end
+    print "Reap is scanning and copying embedded tests..."
+
+    if @dir.strip.empty?
+      puts "Test directory must be specified."
+      return
+    end
+
+    unless File.directory?(@dir)
+      puts "Test directory doesn't exist: #{File.expand_path( @dir )}"
+      return
+    end
+
+    files.each { |file|
+      $stdout << '.'; $stdout.flush
+      testing = extract( file )
+      unless testing.strip.empty?
+        complete_test = create( testing, file )
+        fp = File.join(@dir,file)
+        unless File.directory?( File.dirname( fp ) )
+          FileUtils.mkdir_p( File.dirname(fp) )
+        end
+        File.open( fp, "w" ) { |fw| fw << complete_test }
+      end
+    }
+    puts "done."
+  end
+
+  def extract( file )
+    return nil if ! File.file?( file )
+    tests = ""; inside = false
+    fstr = File.read( file )
+    fstr.split(/\n/).each do |l|
+      if l =~ /^=[ ]*begin[ ]*testing/
+        tests << "\n"
+        inside = true
+        next
+      elsif inside and l =~ /^=[ ]*end/
+        inside = false
+        next
+      end
+      if inside
+        tests << l << "\n"
+      end
+    end
+    tests
+  end
+
+  def create( testing, file )
+    fp = file.split(/[\/]/)
+    if fp[0] == 'lib'
+      reqf = "require '#{fp[1..-1].join('/')}'"
+    else
+      reqf = ''
+    end
+
+    teststr = <<-HERE.margin
+      `#  _____         _
+      `# |_   _|__  ___| |_
+      `#   | |/ _ \\/ __| __|
+      `#   | |  __/\\__ \\ |_
+      `#   |_|\\___||___/\\__|
+      `#
+      `# for #{file}
+      `#
+      `# Extracted #{Time.now}
+      `# Unit Tools Reap Test Extractor
+      `#
+      `
+      `#{reqf}
+      `
+    HERE
+    teststr << testing << "\n"
+    teststr
+  end
+
+end
+

data/lib/reap/task/webpublish.rb

@@ -0,0 +1,43 @@
+
+require 'reap/task'
+
+#
+# Web Publish Task
+#
+class Reap::WebPublish < Reap::Task
+
+  section_required true
+
+  def task_desc
+    "publish project website to your internet host *"
+  end
+
+  attr_accessor :host, :type, :dir, :project, :username
+  attr_accessor :exclude  # not using yet
+
+  def init
+    @host     ||= 'rubyforge.org'
+    @project  ||= master['rubyforge']['project'] || master['name']
+    @username ||= master['rubyforge']['username']
+    @exclude  ||= []
+  end
+
+  def run
+    cmd = ''; skip = false
+
+    case @host
+    when 'rubyforge'
+      cmd = %{scp -r #{@dir}/* #{@username}@rubyforge.org:/var/www/gforge-projects/#{@project}/}
+    else
+      puts %{Unrecognized publishing host '#{@host}'. Skipped.}
+      skip = true
+    end
+
+    unless skip
+      puts "Reap is shelling out publishing work..."
+      puts cmd
+      sh(cmd) unless $PRETEND
+    end
+  end
+
+end