reap 5.10.10 → 6.0.0

data/lib/reap/task/publish.rb

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

data/lib/reap/task/rdoc.rb

@@ -1,82 +0,0 @@
-
-require 'reap/task'
-
-#
-# RDoc Task
-#
-class Reap::RDoc < Reap::Task
-
-  def task_desc
-     "Generate RDocs (in #{dir})."
-  end
-
-  attr_accessor :dir, :main, :title, :template,
-                :include, :exclude, :options
-
-  def init
-    @dir      ||= 'doc'
-    @main     ||= 'README'
-    @title    ||= master["title"]
-    @template ||= 'html' # 'jamis'
-    @include  ||= [ 'A-Z*', 'lib/**/*', 'ext/**/*' ]
-    @exclude  ||= [ 'demo/**/*', 'example/**/*', 'sample/**/*' ]
-    @options  ||= ['--merge', '--all']
-  end
-
-  def run
-    must_exclude = [ 'InstalledFiles', 'CVS/**/*' ]
-
-    if !File.exists?(@main) or File.directory?(@main)
-      warn "Specified RDoc Main file #{@main} not found. Ignored."
-      @main = nil
-    end
-
-    rdoc_dir = File.expand_path(@dir)
-
-    if FileTest.directory?(@dir)
-      print "Directory '#{@dir}' already exists. Clobber? [y/N] "
-      until inp = $stdin.gets[0,1] ; sleep 1 ; end ; puts
-      if (inp || 'y').downcase == 'y'
-        puts "Removing old directory '#{rdoc_dir}'..."
-        #FileUtils.mkdir_p(".trash") unless FileTest.directory?(".trash")
-        #trashdir = ".trash/#{File.basename(@dir)}"
-        #FileUtils.rm_r(trashdir) if FileTest.exists?(trashdir)
-        #FileUtils.mv(@dir, trashdir)
-        FileUtils.rm_r(@dir) unless $PRETEND
-      else
-        puts "Reap rdoc task canceled."
-        return nil
-      end
-    end
-
-    rdoc_target = "#{rdoc_dir}/index.html"
-
-    exc = []
-    (@exclude + must_exclude).each{ |e|
-      exc << e
-      exc |= Dir.glob(e+'/**/*')
-    }
-
-    inc = Dir.glob('[A-Z]*')
-    @include.each{ |i| inc |= Dir.glob(i) }
-    inc -= exc
-
-    inc = inc.select{ |f| File.file?(f) }
-
-    rdoc_files = inc
-    rdoc_files = '"' << rdoc_files.join('" "') << '"'
-
-    # build options string
-    build = []
-    build += @options
-    build << "--main '#{@main}'" if @main
-    build << "--title '#{@title}'" if @title
-    build << "-T '#{@template}'" if @template
-    rdoc_opts = build.join(' ')
-
-    # do it!
-    puts "Reap is shelling work out to RDoc..."
-    sh %{rdoc -o #{rdoc_dir} #{rdoc_opts} #{rdoc_files}}
-  end
-
-end

data/lib/reap/task/scaffold.rb

@@ -1,114 +0,0 @@
-
-#require 'rbconfig'
-#require 'reap/projectinfo'
-
-module Scaffold
-  extend self
-
-  SCMPaths => %w{
-    trunk
-    branch
-    tag
-    scrap
-    package
-  }
-
-  TrunkPaths = %w{
-    bin
-    lib
-    ext
-    dev
-    data
-    test
-    demo
-  }
-
-  TrunkFiles = %w{
-    README
-    INSTALL
-    COPYING
-    ProjectInfo
-    ChangeLog
-    Todo
-    RakeFile
-    setup.rb
-  }
-
-  def go(name) ; scaffold(name) ; end
-
-  # Main method.
-  def scaffold(name=nil)
-    name ||= 'yourlib.projectdomain.org'
-    t = Time.now.strftime("%Y-%m-%d")
-    libdir = File.join( 'lib', "#{@name},#{t}" )
-
-    if @scm
-      SCMPaths.each { |d| makedir( d ) }
-      Dir.chdir 'trunk'
-    end
-    TrunkPaths.each { |d| makedir( d ) }
-    makedir_with_check( libdir )
-    TrunkFiles.each { |f| temlpate( f ) }
-  end
-
-  private
-
-  # Copy a file from lib/data to the current dir.
-  def template( filename )
-    dir = File.join(File.dirname(__FILE__), 'data' )
-    #dir = File.join( ::Config::CONFIG['datadir'], DATA_DIR )
-    f = File.join( dir, filename )
-    unless File.file?( f )
-      puts f
-      raise "Tempfile is missing."
-    end
-
-    if File.exists?(filename)
-      puts "#{filename} already exists."
-      return
-    end
-    # copy tmpf to Reapfile
-    FileUtils.cp( f, filename )
-    #puts "#{filename} created. You'll need to fill it out."
-  end
-
-  # Make a directory as long as it doesn't already exist.
-  def makedir( dir )
-    FileUtils.makedir_p( dir ) unless File.directory?( dir )
-  end
-
-end
-
-
-
-=begin
-  def scaffold
-    require 'reap/scaffold'
-    name =
-    domain =
-    Scaffold.go( name, domain )
-  end
-
-  def template( file_name = ProjectInfo )
-    #dir = File.dirname(File.dirname(__FILE__))
-    dir = File.join( ::Config::CONFIG['datadir'], DATA_DIR )
-
-    tmpf = File.join( dir, 'template.yaml' )
-    unless File.file?( tmpf )
-      puts tmpf
-      raise "Tempfile is missing."
-    end
-
-    if File.directory?(filename)
-      puts "#{filename} a directory. Cannot comply."
-      return
-    elsif File.file?(filename)
-      puts "#{filename} already exists."
-      return
-    end
-    # copy tmpf to Reapfile
-    FileUtils.cp( tmpf, filename )
-    puts "#{filename} created. You'll need to fill it out."
-  end
-=end
-

data/lib/reap/task/test.rb

@@ -1,186 +0,0 @@
-
-require 'reap/task'
-
-#require 'test/unit'
-require 'test/unit/ui/testrunnermediator'
-require 'facet/string/tabto'
-
-Test::Unit.run = true  # don't run auto tests
-
-#
-# Test Task
-#
-# 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.
-#
-class Reap::Test < Reap::Task
-
-  def task_desc
-    "Run unit-tests (each in a separate process)."
-  end
-
-  attr_accessor :libs, :files, :fixture, :against_installed
-
-  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
-
-  def run
-    # get test files
-    test_libs = @libs.join(':')
-    test_files = FileList.new
-    test_files.include(*@files)
-    if test_files.empty?
-      puts "No test files found."
-      return
-    end
-    print "Reap is shelling out work to Ruby's Test Suite..."
-
-    test_files.each { |f|
-      $stdout << '.'; $stdout.flush
-      dotest( f )
-      #ruby %{-r"test/unit" "#{f}"}
-    }
-    puts "done."
-
-    # Don't know why empty arrays get in them yet, but...
-    @failures.reject! { |e| e == [] }
-    @errors.reject! { |e| e == [] }
-
-    # Display Failures
-    puts
-    puts %{FAILURES:#{@failures.empty? ? ' []' : ''}}
-    @failures.reverse.each { |fails|
-      fails.reverse.each { |failure|
-        puts
-        puts %{  - test      : #{failure.test_name}}
-        puts %{    location  : #{failure.location}}
-        if failure.message.index("\n")
-          puts %{    message   : >}
-          puts failure.message.tabto(6)
-        else
-          puts %{    message   : #{failure.message}}
-        end
-      }
-    }
-
-    # Display Errors
-    puts
-    puts %{ERRORS:#{@errors.empty? ? ' []' : ''}}
-    @errors.reverse.each { |errs|
-      errs.reverse.each { |err|
-        puts
-        puts %{  - test      : #{err.test_name}}
-        puts %{    message   : #{err.exception.message}}
-        puts %{    backtrace :}
-        err.exception.backtrace[0...-1].each { |bt| puts %Q{      - #{bt}} }
-      }
-    }
-
-    # Display Final Results
-    puts
-    puts @results
-    puts
-
-    # old way (don't work right)
-    #puts %Q{ ruby %{-I#{test_libs} -e0 -r"test/unit" \\\n#{test_reqs}#{test_opts}} } if $DEBUG
-    #ruby %{-I#{test_libs} -e0 -r"test/unit" \\\n#{test_reqs}#{test_opts}}
-    #ruby %{-e0 -r"test/unit" \\\n#{test_reqs}#{test_opts}}
-  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
-
-  # Currently send program output to null device.
-  # Could send to a logger in future version.
-  def fork_test( testfile )
-    src = ''
-    src << %{$:.unshift('lib')} unless against_installed
-    src << %{
-      #require 'test/unit'
-      require 'test/unit/collector'
-      require 'test/unit/collector/objectspace'
-      require 'test/unit/ui/testrunnermediator'
-    }
-    fixture.each do |fix|
-      src << %Q{
-        require '#{fix}'
-      }
-    end
-    src << %{
-      output = STDOUT.dup
-      STDOUT.reopen( PLATFORM =~ /mswin/ ? "NUL" : "/dev/null" )
-
-      load('#{testfile}')
-      tests = Test::Unit::Collector::ObjectSpace.new.collect
-      runner = Test::Unit::UI::TestRunnerMediator.new( tests )
-      result = runner.run_suite
-      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
-    return Marshal.load(result)
-  end
-
-  #
-  # 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}
-      s << %{  assertions : #{@assertion_count}\n}
-      s << %{  failures   : #{@failure_count}\n}
-      s << %{  errors     : #{@error_count}\n}
-      s
-    end
-  end
-
-end
-

data/lib/reap/task/testext.rb

@@ -1,110 +0,0 @@
-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
-