reap 6.0.2 → 9.2.0

data/lib/reap/class/publish.rb

@@ -1,152 +0,0 @@
-#--
-#  ___      _    _ _    _
-# | _ \_  _| |__| (_)__| |_
-# |  _/ || | '_ \ | (_-< ' \
-# |_|  \_,_|_.__/_|_/__/_||_|
-#
-#++
-
-require 'shellwords'
-
-module Reap
-
-  # = Publish
-  #
-  # Publish documents to hosting service. Three means of
-  # publishing are current supported, ftp uploading, scp,
-  # and web convenience option that recognizes particular
-  # hosts (only RubyForge is currently supported).
-  #
-  #   type           Type of publishing, 'web', 'scp' or 'ftp'.
-  #   host           Host server, default is 'rubyforge.org'
-  #   username       Username for host.
-  #   dir            Directory of files to publish. Or,
-  #   copy           Files to publish using from and to.
-  #   project        Project name (used for Rubyforge)
-  #
-  # If the type is 'scp' or 'ftp' you will also need to provide
-  # the root directory parameter.
-  #
-  #   root           Document root directory at host.
-  #
-  # The dir parameter allows you to simply specify a local
-  # directory, the contents of which will be published to
-  # host's document root location (directory tree intact).
-  #
-  # If you need more control over which files to publish
-  # where, you can use the copy parameter instead. Provide
-  # an array of pattern strings in the form of "{from} {to}".
-  # If the desitination is the host's document root you do
-  # not need to specify the {to} part. For example:
-  #
-  #   copy: [ 'web/*', 'doc/api/* doc/api' ]
-  #
-  # The first copies the files under your project's web directory
-  # to the host's document root. The second copies your projects
-  # doc/api files to the doc/api location on the host.
-  #
-  # When using the 'scp' type the internal template used for
-  # the outbound destination is 'username@host:root/'.
-
-  class Publish
-
-    include TaskUtils
-
-    attr_accessor :dir, :type, :host, :root, :project, :username, :copy
-
-    def initialize( pub )
-      @type     = 'web'
-      @host     = 'rubyforge.org'
-      @root     = 'var/www/gforge-projects/'
-
-      super
-
-      @copy     ||= [ "#{@dir}/*" ]
-    end
-
-    # Upload files to host.
-
-    def publish( target=nil, copy_from=nil, copy_to=nil )
-
-      return nil if target and target != @target
-
-      # setup
-      if copy_from
-        @copy = [ "#{copy_from} #{copy_to}".strip ]
-      end
-
-      # validate
-      unless @project
-        puts "Project not specified." ; return nil
-      end
-      unless @username
-        puts "Username not specified." ; return nil
-      end
-
-      # publish
-      puts "Reap is passing off publishing work..."
-
-      case @type
-      when 'web', 'www'
-        case @host
-        when 'rubyforge', 'rubyforge.org'
-          @host = "rubyforge.org"
-          @root = "/var/www/gforge-projects/#{@project}"
-          run_scp
-        else
-          puts %{Unrecognized publishing host '#{@host}'. Skipped.}
-          return nil
-        end
-      when 'scp'
-        run_scp
-      when 'ftp'
-        run_ftp
-      else
-        puts %{Unrecognized publishing type '#{@type}'. Skipped.}
-        return nil
-      end
-
-    end
-
-  private
-
-    # Use scp to upload files.
-    #--
-    # SHELL OUT! Need a net/ssh library to fix.
-    #++
-
-    def run_scp
-      @copy.each { |c|
-        from, to = *Shellwords.shellwords(c)
-        to = '' if to.nil?
-        to = to[1..-1] if to[0,1] == '/'
-        cmd = "scp -r #{from} #{@username}@#{@host}:#{@root}/#{to}"
-        sh( cmd )
-      }
-    end
-
-    # Use ftp to upload files.
-
-    def run_ftp
-      require 'net/ftp'
-      return if $PRETEND
-      Net::FTP.open( @host ) { |ftp|
-        ftp.login( @username )
-        ftp.chdir( @root )
-        @copy.each { |c|
-          from, to = *Shellwords.shellwords(c)
-          to = '' if to.nil?
-          to = to[1..-1] if to[0,1] == '/'
-          from.sub('*', '**/*') unless from =~ /\*\*/
-          files = FileList.new( from )
-          files.each { |f|
-            t = File.join( to, f.basename )
-            ftp.putbinaryfile( f, t, 1024 )
-          }
-        }
-      }
-    end
-
-  end
-
-end #module Reap

data/lib/reap/class/rdoc.rb

@@ -1,123 +0,0 @@
-#--
-#  ___    _
-# | _ \__| |___  __
-# |   / _` / _ \/ _|
-# |_|_\__,_\___/\__|
-#
-#++
-
-module Reap
-
-  # = RDoc
-  #
-  # This class generates RDoc API documentation from source
-  # comments.
-  #
-  #     title      Project title to use in RDocs.
-  #     dir        Directory to store documentation [doc].
-  #     main       File to use as main page of RDocs.
-  #     template   Which RDoc template to use.
-  #     include    Files to include in RDocs.
-  #     exclude    Files to exclude from those.
-  #     options    Pass-thru extra options to RDoc command.
-  #
-
-  class RDoc # < Task
-
-    include TaskUtils
-
-    MUST_EXCLUDE = [ 'InstalledFiles', 'CVS/**/*', '_darcs/**/*' ]
-
-    attr_accessor :dir,
-                  :main,
-                  :title,
-                  :template,
-                  :include,
-                  :exclude,
-                  :options
-
-    def initialize( doc )
-      # set default values
-      @dir      = 'doc'
-      @main     = 'README'
-      #@title    ||= master.title
-      @template = 'html' # 'jamis'
-      @include  = [ 'A-Z*', 'lib/**/*', 'ext/**/*' ] #, @main ]
-      @exclude  = [ 'demo/**/*', 'example/**/*', 'sample/**/*' ]
-      @options  = ['--merge', '--all']
-
-      super
-
-      @include = [ @include, @main ].flatten
-      @exclude = [ @exclude ].flatten
-      @options = [ @options ].flatten
-    end
-
-    # Generate RDocs.
-
-    def generate
-      @rdoc_dir = File.expand_path(@dir)
-      generate_rdocs
-    end
-
-    alias_method :call, :generate
-
-  private
-
-    def generate_rdocs
-      # warn if main file doesn't exist
-      if !File.exists?(@main) or File.directory?(@main)
-        warn "WARNING! Specified RDoc Main file #{@main} not found."
-        @main = nil
-      end
-
-      if FileTest.directory?(@rdoc_dir)
-        q = "Directory '#{@dir}' already exists. Clobber?"
-        #until inp = $stdin.gets[0,1] ; sleep 1 ; end ; puts
-        inp = ask( q, 'yN' )
-        case inp.downcase
-        when 'y', 'yes', 'okay'
-          tell "Removing old directory '#{@rdoc_dir}'..."
-          FileUtils.rm_r(@rdoc_dir) unless $PRETEND
-        else
-          tell "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(' ')
-
-      #--
-      # SHELL OUT! Can RDoc be called from code?
-      #++
-
-      tell "Reap is shelling work out to RDoc..."
-      sh %{rdoc -o #{@rdoc_dir} #{rdoc_opts} #{rdoc_files}}
-    end
-
-  end
-
-end #module Reap

data/lib/reap/class/test.rb

@@ -1,264 +0,0 @@
-#--
-#  _____       _
-# |_   _|__ __| |_
-#   | |/ -_|_-<  _|
-#   |_|\___/__/\__|
-#
-#++
-
-#require 'test/unit'
-require 'test/unit/ui/testrunnermediator'
-require 'facet/string/tabto'
-require 'facet/progressbar'
-
-::Test::Unit.run = true  # don't run auto tests
-
-module Reap
-
-  # == Test
-  #
-  # The Reap test class runs each test in it's own
-  # proccess, making for a more pure test facility.
-  # 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.
-  #
-  # 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 in your tests (including #p and #puts).
-
-  class Test
-
-    include TaskUtils
-
-    attr_accessor :files, :requires, :live, :libs
-
-    def initialize( tst )
-      @files    = [ 'test/*/**/*.rb', 'test/**/tc*.rb', 'test/**/test*.rb', 'test/**/*test.rb' ]
-      @requires = []
-      @live     = false
-      @libs     = [] #['./lib']
-
-      super
-    end
-
-    # Start testing.
-
-    def test
-      run_tests
-    end
-
-    alias_method :call, :test
-
-  private
-
-    # Run each test.
-
-    def run_tests
-      # interal use
-      @results = TestResults.new
-      @errors = []
-      @failures = []
-
-      # Get test files
-      test_libs = @libs.join(':')
-      test_files = FileList.new
-      test_files.include(*@files)
-      test_files.uniq!
-
-      if test_files.empty?
-        tell "No test files found."
-        return
-      end
-
-      #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
-
-        #ruby %{-r"test/unit" "#{f}"}
-      end
-
-      pbar.finish
-
-      # 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
-
-  private
-
-    # Runs a test.
-    #
-    # Currently send program output to null device.
-    # Could send to a logger in future version.
-
-    def fork_test( testfile )
-      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'
-      }
-  
-      @requires.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
-  
-        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
-  
-        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
-    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
-
-end #module Reap