reap 6.0.2 → 9.2.0

data/lib/reap/manager/stats.rb

@@ -0,0 +1,145 @@
+module Reap
+
+  class Manager
+
+#    DEFAULT['stats'] = {
+#      'exclude' => ['ext']
+#    }
+
+    # Simple code count analysis.
+    #
+    # Scan source code counting files, lines of code and
+    # comments and presents a report of it's findings.
+    #
+    #   loadpath   Path to include in analysis. The default
+    #              is the project's loadpath.
+    #
+    #   exclude    File globs to exclude from analysis. Default
+    #              is 'ext' b/c this does not yet support C analysis.
+    #
+    # TODO: Add C support for ext/.
+
+    def stats(options=nil)
+      options = configure_options(options, 'stats')
+
+      loadpath = options['loadpath'] || metadata.loadpath
+      exclude  = options['exclude']  || ['ext']
+
+      loadpath = list_option(loadpath)
+      exclude  = list_option(exclude)
+
+      files = multiglob_r(*loadpath) - multiglob_r(*exclude)
+
+      #() #.inject([]){ |memo, find| memo.concat(glob(find)); memo }
+      #Dir.multiglob_with_default(DEFAULT_STATS_FILES)
+
+      fc, l, c, r, t, s = *line_count(*files)
+
+      fct, lt, ct, rt, tt, st = *([0]*6)
+      if File.directory?('test')
+        fct, lt, ct, rt, tt, st = *line_count('test/**/*')
+        t = lt if lt > 0
+      end
+
+      rat = lambda do |d,n|
+        if d > n and n != 0
+          "%.1f" % [ d.to_f / n ]
+        elsif n > d and d != 0
+          "-" #"%.1f:1" % [ n.to_f / d ]
+        elsif d == 0 or n == 0
+          "-"
+        else
+          "1.0"
+        end
+      end
+
+      per = lambda do |n,d|
+        if d != 0
+          (((n.to_f / d)*100).to_i).to_s + "%"
+        else
+          "-"
+        end
+      end
+
+      max = l.to_s.size + 4
+
+      puts
+      #puts "FILES:"
+      #puts "  source: #{fc}"
+      #puts "  test  : #{fct}"
+      #puts "  total : #{fc+fct}"
+      #puts
+      #puts "LINES:"
+      #puts "  code  : %#{max}s   %4s" % [ c.to_s, per[c,l] ]
+      #puts "  docs  : %#{max}s   %4s" % [ r.to_s, per[r,l] ]
+      #puts "  space : %#{max}s   %4s" % [ s.to_s, per[s,l] ]
+      #puts "  test  : %#{max}s   %4s" % [ t.to_s, per[t,l] ]
+      #puts "  total : %#{max}s   %4s" % [ l.to_s, per[l,l] ]
+      #puts
+      #puts "Ratio to 1 :"
+      #puts "  code to test : #{rat[c,t]} #{per[c,t]}"
+
+      head = ["Total", "Code", "-%-", "Docs", "-%-", "Blank", "-%-", "Files"]
+      prod = [l.to_s, c.to_s, per[c,l], r.to_s, per[r,l], s.to_s, per[s,l], fc]
+      test = [lt.to_s, ct.to_s, per[ct,l], rt.to_s, per[rt,l], st.to_s, per[st,l], fct]
+      totl = [(l+lt), (c+ct), per[c+ct,l+lt], (r+rt), per[r+rt,l+lt], (s+st), per[s+st,l+lt], (fc+fct)]
+
+      puts "TYPE    %#{max}s %#{max}s %4s %#{max}s %4s %#{max}s %4s %#{max}s" % head
+      puts "Source  %#{max}s %#{max}s %4s %#{max}s %4s %#{max}s %4s %#{max}s" % prod
+      puts "Test    %#{max}s %#{max}s %4s %#{max}s %4s %#{max}s %4s %#{max}s" % test
+      puts "Total   %#{max}s %#{max}s %4s %#{max}s %4s %#{max}s %4s %#{max}s" % totl
+      puts
+      puts "RATIO     Code    Docs    Blank   Test   Total"
+      puts "Code   %7s %7s %7s %7s %7s" % [ rat[c,c], rat[c,r], rat[c,s], rat[c,t], rat[c,l] ]
+      puts "Docs   %7s %7s %7s %7s %7s" % [ rat[r,c], rat[r,r], rat[r,s], rat[r,t], rat[r,l] ]
+      puts "Blank  %7s %7s %7s %7s %7s" % [ rat[s,c], rat[s,r], rat[s,s], rat[s,t], rat[s,l] ]
+      puts "Test   %7s %7s %7s %7s %7s" % [ rat[t,c], rat[t,r], rat[t,s], rat[t,t], rat[t,l] ]
+      puts "Total  %7s %7s %7s %7s %7s" % [ rat[l,c], rat[l,r], rat[l,s], rat[l,t], rat[l,l] ]
+      puts
+    end
+
+    private
+
+    # Return line counts for files.
+
+    def line_count(*files)
+      files = files.inject([]) do |memo, find|
+        memo.concat(Dir.glob(find)); memo
+      end
+
+      fc, l, c, t, r = 0, 0, 0, 0, 0
+      bt, rb = false, false
+
+      files.each do |fname|
+        next unless fname =~ /.*rb/      # TODO should this be done?
+        fc += 1
+        File.open( fname ) do |f|
+          while line = f.gets
+            l += 1
+            next if line =~ /^\s*$/
+            case line
+            when /^=begin\s+test/
+              tb = true; t+=1
+            when /^=begin/
+              rb = true; r+=1
+            when /^=end/
+              t+=1 if tb
+              r+=1 if rb
+              rb, tb = false, false
+            when /^\s*#/
+              r += 1
+            else
+              c+=1 if !(rb or tb)
+              r+=1 if rb
+              t+=1 if tb
+            end
+          end
+        end
+      end
+      s = l - c - r - t
+      return fc, l, c, r, t, s
+    end
+
+  end
+
+end

data/lib/reap/manager/svn.rb

@@ -0,0 +1,76 @@
+require 'reap/systems/subversion'
+
+module Reap
+
+  class Manager
+
+    # Branch current version.
+    #
+    #   message       Optional commit message. This is intended for commandline
+    #                 usage. (Use -m for shorthand).
+    #
+    # TODO: How should metadata.repository come into play here?
+
+    def svn_branch(options=nil)
+      options = configure_options(options, 'scm-branch', 'scm')
+      svn_system.branch(options)
+    end
+
+    # Tag current version.
+    #
+    #   message       Optional commit message. This is intended for commandline
+    #                 usage. (Use -m for shorthand).
+    #
+    # TODO: How should metadata.repository come into play here?
+
+    def svn_tag(options=nil)
+      options = configure_options(options, 'scm-tag', 'scm')
+      svn_system.tag(options)
+    end
+
+    # Create changelog.
+    #
+    #   change     File path to store rdoc formated changelog. Default is 'log/changelog.txt'.
+    #   xmlchange  File path to store XML formated changelog. Default is 'doc/log/changelog.xml'.
+    #
+    # Set either to false to supress creation.
+
+    def svn_log(options=nil)
+      txtlog = options['txtlog']
+      xmllog = options['xmllog']
+
+      svn_system.log(txtlog)
+      svn_system.log_xml(xmllog) if xmllog
+    end
+
+    private
+
+    # Branch current version.
+    #
+    #   repository    Developers URL to repository. Defaults to Rubyforge address.
+    #   username      Username. Defaults to ENV['RUBYFORGE_USERNAME'].
+    #   protocol      The URL protocol to use. Defaults to "svn+ssh".
+    #   prefix        Prefix to use on tag folder. Default is no prefix.
+    #   tagpath       Directory to store tags. Defaults to tags/.
+    #   branchpath    Directory to store branches. Defaults to branches/.
+    #
+    def svn_system
+      @svn_system ||= (
+        options = configuration['svn'] || {}
+
+        rubyforge = configuration['rubyforge'] || {}
+
+        options['repository'] ||= metadata.repository
+        options['dryrun']     ||= dryrun?
+        options['project']    ||= rubyforge['project'] || metadata.project
+
+        options['version'] = metadata.version
+
+        Subversion.new(options)
+      )
+    end
+
+  end
+
+end
+

data/lib/reap/manager/test.rb

@@ -0,0 +1,389 @@
+# TITLE:
+#
+#   Test
+#
+# TODO:
+#   - Needs to be made DRY.
+#   - Perhaps simplifiy this, making it more like the load test.
+#     And simply collect that parse the output of each test.
+
+require 'facets/hash/rekey'
+require 'facets/string/tabs'
+require 'facets/progressbar'
+
+module Reap
+
+  class Manager
+
+#    DEFAULT['test'] = {
+#      'tests'    => 'test/**/{test,tc}_*.rb',
+#      'loadpath' => ['lib'],
+#      'require'  => [],
+#      'exclude'  => ['ext'],
+#      'live'     => false
+#    }
+
+    private
+
+    # Collect test configuation.
+
+    def test_configuration(options=nil)
+      options = configure_options(options, 'test')
+
+      options['loadpath'] ||= metadata.loadpath
+
+      #options['tests']    ||= DEFAULT['test']['tests']
+      #options['loadpath'] ||= DEFAULT['test']['loadpath']
+      #options['exclude']  ||= DEFAULT['test']['exclude']
+      #options['require']  ||= DEFAULT['test']['require']
+      #options['live']     ||= DEFAULT['test']['live']
+
+      options['tests']    = list_option(options['tests'])
+      options['loadpath'] = list_option(options['loadpath'])
+      options['exclude']  = list_option(options['exclude'])
+      options['require']  = list_option(options['require'])
+
+      return options
+    end
+
+    public
+
+    # Run unit tests. Unlike test-solo and test-cross this loads
+    # all tests and runs them together in a single process.
+    #
+    # Note that this shells out to the testrb program.
+    #
+    # TODO: Generate a test log entry?
+
+    def test_unit(options={})
+      options = test_configuration(options)
+
+      tests    = options['tests']
+      loadpath = options['loadpath']
+      requires = options['requires']
+      live     = options['live']
+      exclude  = options['exclude']
+      #log      = options['log'] != false
+      #logfile  = File.join('log', apply_naming_policy('test', 'log'))
+
+      # what about arguments for selecting specific tests?
+      tests = options['arguments'] if options['arguments']
+
+      unless live
+        loadpath.each do |lp|
+          $LOAD_PATH.unshift(File.expand_path(lp))
+        end
+      end
+
+      files = multiglob_r(*tests)
+
+      if files.empty?
+        puts "No tests."
+        return
+      end
+
+      filelist = files.select{|file| !File.directory?(file) }.join(' ')
+      command  = %[testrb -I#{loadpath} #{filelist} 2>&1]
+      system command
+
+      #if log && !dryrun?
+      #  command = %[testrb -I#{loadpath} #{filelist} > #{logfile} 2>&1]  # /dev/null 2>&1
+      #  system command
+      #  puts "Updated #{logfile}"
+      #end
+    end
+
+    # Load each test independently to ensure there are no
+    # require dependency issues. This is actually a bit redundant
+    # as test-solo will also cover these results. So we may deprecate
+    # this in the future. This does not generate a test log entry.
+
+    def test_load(options=nil)
+      options = test_configuration(options)
+
+      tests    = options['tests']
+      loadpath = options['loadpath']
+      requires = options['requires']
+      live     = options['live']
+      exclude  = options['exclude']
+
+      files = multiglob_r(*tests) - multiglob_r(*exclude)
+
+      return puts("No tests.") if files.empty?
+
+      max   = files.collect{ |f| f.size }.max
+      list  = []
+
+      files.each do |f|
+        next unless File.file?(f)
+        if r = system("ruby -I#{loadpath.join(':')} #{f} > /dev/null 2>&1")
+          puts "%-#{max}s  [PASS]" % [f]  #if verbose?
+        else
+          puts "%-#{max}s  [FAIL]" % [f]  #if verbose?
+          list << f
+        end
+      end
+
+      puts "  #{list.size} Load Failures"
+
+      if verbose?
+        unless list.empty?
+          puts "\n-- Load Failures --\n"
+          list.each do |f|
+            print "* "
+            system "ruby -I#{loadpath} #{f} 2>&1"
+            #puts
+          end
+          puts
+        end
+      end
+    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/**/*]
+    #   loadpath  Directories to include in load path [lib].
+    #   require   List of files to require prior to running tests.
+    #   live      Deactive use of local libs and test against install.
+
+    def test_solo(options=nil)
+      options = test_configuration(options)
+
+      tests    = options['tests']
+      loadpath = options['loadpath']
+      requires = options['requires']
+      live     = options['live']
+      exclude  = options['exclude']
+      log      = options['log'] != false
+
+      files = multiglob_r(*tests) - multiglob_r(*exclude)
+
+      return puts("No tests.") if files.empty?
+
+      files = files.select{ |f| File.extname(f) == '.rb' and File.file?(f) }
+      width = files.collect{ |f| f.size }.max
+
+      make if compiles?
+
+      cmd   = %[ruby -I#{loadpath.join(':')} %s]
+      dis   = "%-#{width}s"
+
+      testruns = files.collect do |file|
+        { 'files'   => file,
+          'command' => cmd % file,
+          'display' => dis % file
+        }
+      end
+
+      report = test_loop_runner(testruns)
+
+      puts report
+
+      if log && !dryrun?
+        logfile = File.join('log', apply_naming_policy('testlog', 'txt'))
+        File.open(logfile, 'a') do |f|
+          f << "= Solo Test @ #{Time.now}\n"
+          f << report
+          f << "\n"
+        end
+      end
+    end
+
+    # Run cross comparison testing.
+    #
+    # This tool runs unit tests in pairs to make sure there is cross
+    # library compatibility. Each pari 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/**/*]
+    #   loadpath  Directories to include in load path.
+    #   require   List of files to require prior to running tests.
+    #   live      Deactive use of local libs and test against install.
+
+    def test_cross(options=nil)
+      options = test_configuration(options)
+
+      tests    = options['tests']
+      loadpath = options['loadpath']
+      requires = options['requires']
+      live     = options['live']
+      exclude  = options['exclude']
+      log      = options['log'] != false
+
+      files = multiglob_r(*tests) - multiglob_r(exclude)
+
+      return puts("No tests.") if files.empty?
+
+      files = files.select{ |f| File.extname(f) == '.rb' and File.file?(f) }
+      width = files.collect{ |f| f.size }.max
+      pairs = files.inject([]){ |m, f| files.collect{ |g| m << [f,g] }; m }
+
+      make if compiles?
+
+      cmd   = %[ruby -I#{loadpath.join(':')} -e"load('./%s'); load('%s')"]
+      dis   = "%-#{width}s %-#{width}s"
+
+      testruns = pairs.collect do |pair|
+        { 'file'    => pair,
+          'command' => cmd % pair,
+          'display' => dis % pair
+        }
+      end
+
+      report = test_loop_runner(testruns)
+
+      puts report
+
+      if log && !dryrun?
+        logfile = File.join('log', apply_naming_policy('testlog', 'txt'))
+        File.open(logfile, 'a') do |f| 
+          f << "= Cross Test @ #{Time.now}\n"
+          f << report
+          f << "\n"
+        end
+      end
+    end
+
+    private
+
+    # Runs the list of test calls passed to it.
+    # This is used by #test_solo and #test_cross.
+
+    def test_loop_runner(testruns)
+      width = testruns.collect{ |tr| tr['display'].size }.max
+
+      testruns = if trace?
+        test_loop_runner_trace(testruns)
+      elsif verbose?
+        test_loop_runner_verbose(testruns)
+      else
+        test_loop_runner_progress(testruns)
+      end
+
+      tally = test_tally(testruns)
+
+      report = ""
+      report << "\n%-#{width}s       %10s %10s %10s %10s" % [ 'TEST FILE', '  TESTS   ', 'ASSERTIONS', ' FAILURES ', '  ERRORS   ' ]
+      report << "\n"
+
+      testruns.each do |testrun|
+        count = testrun['count']
+        pass = (count[2] == 0 and count[3] == 0)
+
+        report << "%-#{width}s  " % [testrun['display']]
+        report << "%10s %10s %10s %10s" % count
+        report << " " * 8
+        report << (pass ? "[PASS]" : "[FAIL]")
+        report << "\n"
+      end
+
+      report << "%-#{width}s  " % "TOTAL"
+      report << "%10s %10s %10s %10s" % tally
+
+      #puts("\n%i tests, %i assertions, %i failures, %i errors\n\n" % tally)
+
+      report << "\n\n"
+
+      fails = []
+      
+      fails = testruns.select do |testrun|
+        count = testrun['count']
+        count[2] != 0 or count[3] != 0
+      end
+
+      if tally[2] != 0 or tally[3] != 0
+        unless fails.empty? # or verbose?
+          report << "-- Failures and Errors --\n\n"
+          fails.uniq.each do |testrun|
+            report << testrun['result']
+          end
+          report << "\n"
+        end
+      end
+
+      return report
+    end
+
+    #
+
+    def test_loop_runner_verbose(testruns)
+      testruns.each do |testrun|
+        result = `#{testrun['command']}`
+        count  = test_parse_result(result)
+        testrun['count']  = count
+        testrun['result'] = result
+
+        puts "\n" * 3; puts result
+      end
+      puts "\n" * 3
+
+      return testruns
+    end
+
+    #
+
+    def test_loop_runner_progress(testruns)
+      pbar = Console::ProgressBar.new( 'Testing', testruns.size )
+      pbar.inc
+      testruns.each do |testrun|
+        pbar.inc
+
+        result = `#{testrun['command']}`
+        count  = test_parse_result(result)
+        testrun['count']  = count
+        testrun['result'] = result
+      end
+      pbar.finish
+
+      return testruns
+    end
+
+    #
+
+    def test_loop_runner_trace(testruns)
+      width = testruns.collect{ |tr| tr['display'].size }.max
+
+      testruns.each do |testrun|
+        print "%-#{width}s  " % [testrun['display']]
+
+        result = `#{testrun['command']}`
+        count = test_parse_result(result)
+        testrun['count']  = count
+        testrun['result'] = result
+
+        pass = (count[2] == 0 and count[3] == 0)
+        puts(pass ? "[PASS]" : "[FAIL]")
+      end
+
+      return testruns
+    end
+
+    #
+
+    def test_tally(testruns)
+      counts = testruns.collect{ |tr| tr['count'] }
+      tally  = [0,0,0,0]
+      counts.each do |count|
+        4.times{ |i| tally[i] += count[i] }
+      end
+      return tally
+    end
+
+    #
+
+    def test_parse_result(result)
+      if md = /(\d+) tests, (\d+) assertions, (\d+) failures, (\d+) errors/.match(result)
+        count = md[1..4].collect{|q| q.to_i}
+      else       
+        count = [1, 0, 0, 1]  # SHOULD NEVER HAPPEN
+      end
+      return count
+    end
+
+  end
+
+end
+

data/lib/reap/manager.rb

@@ -0,0 +1,74 @@
+require 'yaml'
+require 'rbconfig'  # replace with facets/system?
+
+require 'reap/extensions'
+require 'reap/utilities/fileutils'
+require 'reap/utilities/shellutils'
+require 'reap/utilities/netutils'
+
+module Reap
+
+  class Manager
+    # Default constant is used my various tools
+    # to soter the defualts for options. By using this
+    # it easy to dump a complete list of built-in
+    # defaults. Defaults should be patterned after the
+    # configuration file agsint which they will be used.
+
+    DEFAULT = {}
+
+    include Utilities::ShellUtils
+    include Utilities::FileUtils
+    include Utilities::NetUtils
+  end
+
+  #class Project < Manager; end
+
+end
+
+# Load up all the tools
+require "reap/manager/announce.rb"
+require "reap/manager/check.rb"
+require "reap/manager/clean.rb"
+require "reap/manager/gem.rb"
+require "reap/manager/html.rb"
+require "reap/manager/log.rb"
+require "reap/manager/make.rb"
+require "reap/manager/pack.rb"
+require "reap/manager/publish.rb"
+require "reap/manager/rdoc.rb"
+require "reap/manager/release.rb"
+require "reap/manager/scaffold.rb"
+require "reap/manager/site.rb"
+require "reap/manager/spec.rb"
+require "reap/manager/stats.rb"
+require "reap/manager/scm.rb"
+require "reap/manager/svn.rb"
+require "reap/manager/test.rb"
+
+
+    #def html
+    #  config = configuration['rd2html']
+    #  webmaker = RD2Html.new(config)
+    #  webmaker.rd2html
+    #end
+
+    # Update release "stamp" (.roll) file.
+
+    #def stamp
+    #  # You can change these via the command line.
+    #  version = commandline['version'] || release.version
+    #  status  = commandline['status']  || release.status
+    #
+    #  if version != release.version or status != release.status
+    #    Stamp.new(
+    #      :version => version,
+    #      :status  => status,
+    #      :file    => release.file,
+    #      :name    => release.name,
+    #      :default => release.default,
+    #      :libpath => release.libpath
+    #    ).stamp
+    #  end
+    #end
+