reap 5.10.10 → 6.0.0

data/lib/reap/class/publish.rb

@@ -0,0 +1,152 @@
+#--
+#  ___      _    _ _    _
+# | _ \_  _| |__| (_)__| |_
+# |  _/ || | '_ \ | (_-< ' \
+# |_|  \_,_|_.__/_|_/__/_||_|
+#
+#++
+
+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

@@ -0,0 +1,131 @@
+#--
+#  ___    _
+# | _ \__| |___  __
+# |   / _` / _ \/ _|
+# |_|_\__,_\___/\__|
+#
+#++
+
+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/**/*' ]
+
+    # Note that ++dir++ is not offset by trunk.
+
+    attr_accessor :dir,
+                  :main,
+                  :title,
+                  :template,
+                  :trunk,
+                  :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)
+
+      if @trunk
+        Dir.chdir( @trunk ) { generate_rdocs }
+      else
+        generate_rdocs
+      end
+    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

@@ -0,0 +1,269 @@
+#--
+#  _____       _
+# |_   _|__ __| |_
+#   | |/ -_|_-<  _|
+#   |_|\___/__/\__|
+#
+#++
+
+#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 :trunk, :files, :requires, :live, :libs
+
+    def initialize( tst )
+      #@trunk    = 'trunk' if File.directory?('trunk')
+      @files    = [ 'test/*/**/*.rb', 'test/**/tc*.rb', 'test/**/test*.rb', 'test/**/*test.rb' ]
+      @requires = []
+      @live     = false
+      @libs     = [] #['./lib']
+
+      super
+    end
+
+    # Start testing.
+
+    def test
+      if @trunk
+        Dir.chdir( @trunk ) { run_tests }
+      else
+        run_tests
+      end
+    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