ratch 0.2.2 → 0.2.3

data/lib/ratch/facets/multiglob.rb

@@ -0,0 +1,160 @@
+# TITLE:
+#
+#   Multiglob
+#
+# SUMMARY:
+#
+#    Dir extensions for globbing multiple locations at once.
+#
+# COPYING:
+#
+#   Copyright (c) 2007 Psi T Corp.
+#
+#   This file is part of the ProUtils' Ratch program.
+#
+#   Ratch is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   Ratch is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with Ratch.  If not, see <http://www.gnu.org/licenses/>.
+
+#
+class Dir
+
+  # Like +glob+ but can take multiple patterns.
+  #
+  #   Dir.multiglob( '*.rb', '*.py' )
+  #
+  # Rather then constants for options multiglob accepts a trailing options
+  # hash of symbol keys.
+  #
+  #   :noescape    File::FNM_NOESCAPE
+  #   :casefold    File::FNM_CASEFOLD
+  #   :pathname    File::FNM_PATHNAME
+  #   :dotmatch    File::FNM_DOTMATCH
+  #   :strict      File::FNM_PATHNAME && File::FNM_DOTMATCH
+  #
+  # It also has an option for recurse.
+  #
+  #   :recurse     Recurively include contents of directories.
+  #
+  # For example
+  #
+  #   Dir.multiglob( '*', :recurse => true )
+  #
+  # would have the same result as
+  #
+  #   Dir.multiglob('**/*')
+  #
+  # Multiglob also accepts '+' and '-' prefixes. Any entry that begins with a '-'
+  # is treated as an exclusion glob and will be removed from the final result.
+  # For example, to collect all files in the current directory, less ruby scripts:
+  #
+  #   Dir.multiglob( '*', '-*.rb' )
+  #
+  # This is very useful in collecting files as specificed by a configuration
+  # parameter.
+
+  def self.multiglob( *patterns )
+    options  = (Hash === patterns.last ? patterns.pop : {})
+
+    bitflags = 0
+    bitflags |= File::FNM_NOESCAPE if options[:noescape]
+    bitflags |= File::FNM_CASEFOLD if options[:casefold]
+    bitflags |= File::FNM_PATHNAME if options[:pathname] or options[:strict]
+    bitflags |= File::FNM_DOTMATCH if options[:dotmatch] or options[:strict]
+
+    patterns = [patterns].flatten.compact
+
+    patterns_include = patterns.select{ |f| f !~ /^[-]/ }
+    patterns_exclude = patterns.select{ |f| f =~ /^[-]/ }
+
+    patterns_include.collect!{ |f| f =~ /^[+]/ ? f[1..-1] : f }
+    patterns_exclude.collect!{ |f| f =~ /^[-]/ ? f[1..-1] : f }
+
+    if options[:recurse]
+      patterns_include += patterns_include.collect{ |f| File.join(f, '**', '*') }
+      patterns_exclude += patterns_exclude.collect{ |f| File.join(f, '**', '*') }
+    end
+
+    files = []
+    files += patterns_include.collect{ |pattern| Dir.glob(pattern, bitflags) }.flatten.uniq
+    files -= patterns_exclude.collect{ |pattern| Dir.glob(pattern, bitflags) }.flatten.uniq
+
+    return files
+  end
+
+  # The same as +multiglob+, but recusively includes directories.
+  #
+  #   Dir.multiglob_r( 'folder' )
+  #
+  # is equivalent to
+  #
+  #   Dir.multiglob( 'folder', :recurse=>true )
+  #
+  # The effect of which is
+  #
+  #   Dir.multiglob( 'folder', 'folder/**/*' )
+
+  def self.multiglob_r( *patterns )
+    options = (Hash === patterns.last ? patterns.pop : {})
+    options[:recurse] = true
+    patterns << options
+    multiglob(*patterns)
+  end
+
+  # This is just like multiglob but handles a base pattern such that
+  # if the +patterns+ list starts with a '+' or '-' entry, then the base
+  # will be included in the result, otherwise it will be omitted.
+  #
+  #   Dir.multiglob_with_default('*.yaml', '-*.rb')  #=> [ 'foo.yaml' ]
+  #   Dir.multiglob_with_default('*.yaml', '+*.rb')  #=> [ 'foo.yaml', 'foo.rb' ]
+  #   Dir.multiglob_with_default('*.yaml', '*.rb')   #=> [ 'foo.rb' ]
+  #
+  # This is useful when a configuration option needs to supply a file list
+  # that may include files, exclude files or append files to a default list.
+  #
+  # TODO Deprecate this and replace with :default option on regular multiglob.
+
+  def self.multiglob_with_default(default, *patterns)
+    default = [default].flatten.compact
+    patterns = patterns.flatten.compact
+
+    if patterns.empty?
+      patterns = default
+    elsif patterns.first =~ /^[+-]/
+      patterns = default + patterns
+    end
+
+    multiglob(*patterns)
+  end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+# TODO Need to mock file system.
+
+=begin #no test yet
+
+  require 'test/unit'
+
+  class TestDir < Test::Unit::TestCase
+
+  end
+
+=end

data/lib/ratch/fileutils.rb

@@ -1,4 +1,28 @@
+# TITLE:
+#
+#   FileUtils
+#
+# COPYING:
+#
+#   Copyright (c) 2007 Psi T Corp.
+#
+#   This file is part of the ProUtils' Ratch program.
+#
+#   Ratch is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   Ratch is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with Ratch.  If not, see <http://www.gnu.org/licenses/>.
+
 require 'fileutils'
+require 'ratch/facets/multiglob'
 
 
 module Ratch
@@ -11,6 +35,14 @@ module Ratch
       Dir.glob(*args, &blk)
     end
 
+    def multiglob(*args, &blk)
+      Dir.multiglob(*args, &blk)
+    end
+
+    def multiglob_r(*args, &blk)
+      Dir.multiglob_r(*args, &blk)
+    end
+
     # Read file.
 
     def file_read(path)
@@ -130,13 +162,13 @@ module Ratch
     alias_method :exist!, :exists! ; module_function :exist!
     alias_method :path!,  :exists! ; module_function :path!
 
-    # Is a file a task?
-
-    def task?(path)
-      task = File.dirname($0) + "/#{path}"
-      task.chomp!('!')
-      task if FileTest.file?(task) && FileTest.executable?(task)
-    end
+#     # Is a file a task?
+#
+#     def task?(path)
+#       task = File.dirname($0) + "/#{path}"
+#       task.chomp!('!')
+#       task if FileTest.file?(task) && FileTest.executable?(task)
+#     end
 
     # Is a file a command executable?
     #
@@ -152,7 +184,7 @@ module Ratch
     # This is a support method of #bin?
 
     def command_paths
-      @command_paths ||= ENV['PATH'].split(':')
+      @command_paths ||= ENV['PATH'].split(/[:;]/)
     end
 
     # TODO Make more robust.

data/lib/ratch/options.rb

@@ -1,3 +1,25 @@
+# TITLE:
+#
+#   GeneralOptions
+#
+# COPYING:
+#
+#   Copyright (c) 2007 Psi T Corp.
+#
+#   This file is part of the ProUtils' Ratch program.
+#
+#   Ratch is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   Ratch is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with Ratch.  If not, see <http://www.gnu.org/licenses/>.
 
 module Ratch
 
@@ -22,7 +44,19 @@ module Ratch
     # Debug mode.
 
     def debug?
-      @debug
+      @debug ||= %w{--debug}.any?{|a| argv.delete(a)}
+    end
+
+    #
+
+    def verbose?
+      @verbose ||= %w{--verbose}.any?{|a| argv.delete(a)}
+    end
+
+    #
+
+    def verbose!
+      @verbose = true
     end
 
     #
@@ -42,16 +76,21 @@ module Ratch
     def noharm?
       @noharm ||= %w{--dryrun --dry-run --noharm}.any?{|a| argv.delete(a)}
     end
-
     alias_method :dryrun?, :noharm? ; module_function :dryrun?
 
-    #
-
     def noharm!
       @noharm = true
     end
     alias_method :dryrun!, :noharm! ; module_function :dryrun!
 
+    # Force mode.
+
+    def force?
+      @force ||= %w{--force}.any?{|a| argv.delete(a)}
+    end
+
+    def force! ; @force = true ; end
+
   end
 
 end

data/lib/ratch/taskable.rb

@@ -1,3 +1,26 @@
+# TITLE:
+#
+#   Taskable
+#
+# COPYING:
+#
+#   Copyright (c) 2007 Psi T Corp.
+#
+#   This file is part of the ProUtils' Ratch program.
+#
+#   Ratch is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   Ratch is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with Ratch.  If not, see <http://www.gnu.org/licenses/>.
+
 module Ratch
 
   # = Taskable Mixin
@@ -6,7 +29,7 @@ module Ratch
 
     # Reference task manager.
     def task_manager
-      @task_manager ||= TaskManager.new
+      @task_manager ||= TaskManager.new(self)
     end
 
     # Define a main task.
@@ -46,8 +69,10 @@ module Ratch
   class TaskManager
     attr :main
     attr :tasks
+    attr :runspace
 
-    def initialize
+    def initialize(runspace)
+      @runspace = runspace
       @main = nil
       @tasks = {}
     end
@@ -78,14 +103,25 @@ module Ratch
       if list.include?(name)
         raise "Circular dependency #{name}."
       end
-      task = @tasks[name]
-      task.preqs.each do |need|
-        need = need.to_s
-        next if list.include?(need)
-        #@tasks[need].plan(need, list)
-        plan(need, list)
+      if task = @tasks[name]
+        task.needs.each do |need|
+          need = need.to_s
+          next if list.include?(need)
+          #@tasks[need].plan(need, list)
+          plan(need, list)
+        end
+        list << task.name
+      else
+        if fname = runspace.batch?(name)  # TODO THIS TIES TASKS INTO BATCH, BETTER WAY?
+          task = Task.new(name) do
+            runspace.batch(fname)
+          end
+          @tasks[name] = task
+          list << task.name
+        else
+          abort "no task -- #{name}"
+        end
       end
-      list << task.name
       return list
     end
 
@@ -96,13 +132,13 @@ module Ratch
   class Task
 
     attr :name
-    attr :preqs
+    attr :needs
     attr :action
 
     #
-    def initialize(name, *preqs, &action)
+    def initialize(name, *needs, &action)
       @name          = name.to_s
-      @preqs         = preqs
+      @needs         = needs
       @action        = action
     end
 

data/lib/ratch/toolset/ruby/crosstest

@@ -0,0 +1,305 @@
+#!/usr/bin/env ratch
+
+# run cross comparison tests
+#
+# This tool runs unit tests in pairs to make
+# sure there is cross library compatibility.
+
+require 'facets/hash/rekey'
+require 'facets/string/tabs'
+require 'facets/progressbar'
+
+require 'test/unit/ui/testrunnermediator' #require 'test/unit'
+::Test::Unit.run = true # Don't autorun tests!
+
+
+main :crosstest do
+  run_crosstests
+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/**/*]
+#   libs      Directories to include in load path.
+#             ('./lib' is always included)
+#   live      Deactive use of local libs and test against install.
+#   reqs      List of files to require prior to running tests.
+#   extract   Extract embedded tests first? [false]
+#
+# To isolate tests this tool marshals test results across a
+# stdout->stdin shell pipe. This prevents interfence of one
+# script's tests on another. But consequently it is not always
+# possible to send debug info to stdout in the tests themselves
+# (eg. #p and #puts).
+
+def run_crosstests
+  info = configuration['test']
+
+  tests   = info['files'] || 'test/unit/**/test_*.rb'
+  libs    = info['libpath']
+  reqs    = info['require']
+  live    = info['live']
+  #extract = info['extract']
+
+  tests = [ tests ].flatten
+  libs  = [ libs ].flatten
+
+  results  = TestResults.new #(style)
+
+  # get test files
+  test_libs  = libs.join(':')
+  test_files = Dir.multiglob( *tests )
+  if test_files.empty?
+    puts "Tests        [NONE]"
+    return
+  end
+
+  # run tests
+
+  if trace?
+    pbar = nil
+    size = test_files.collect{|f| f.size}.max * 2 + 5
+    dots = '.' * size
+  else
+    pbar = Console::ProgressBar.new('Testing', test_files.size ** 2)
+    pbar.inc
+  end
+
+  test_files.each do |test_file|
+    next unless File.file?(test_file)
+
+    test_files.each do |test_file_x|
+      next unless File.file?(test_file_x)
+      next if test_file == test_file_x
+
+      pbar.inc if pbar
+      unless pbar
+        out = test_file +' : ' + test_file_x
+        print out + dots[out.size..-1]
+        $stdout.flush
+      end
+
+      r = fork_test( test_file, test_file_x, :libs=>libs, :reqs=>reqs, :live=>live )
+
+      unless pbar
+        puts r.passed? ? "[PASS]" : "[FAIL]"
+      end
+
+      results << r
+    end
+  end
+
+  pbar.finish if pbar
+
+  # display results
+  puts results
+
+  fails, errrs = results.failure_count, results.error_count
+  #CHECKLIST << :test if fails > 0
+  #CHECKLIST << :test if errrs > 0
+  return (fails + errrs > 0)
+end
+
+# Run a test in a separate process.
+#
+# Currently send program output to null device.
+# Could send to a logger in future version.
+#
+# Key parameters are libs, reqs, live.
+
+def fork_test( file, xfile, keys )
+  keys = keys.rekey(:to_s)
+
+  libs = keys['lib'] || []
+  reqs = keys['req'] || []
+  live = keys['live']
+
+  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'
+  }
+
+  reqs.each do |fix|
+    src << %Q{
+      require '#{fix}'
+    }
+  end
+
+  src << %{
+    def warn(*null); end  # silence warnings
+
+    output = STDOUT.dup
+    STDOUT.reopen( PLATFORM =~ /mswin/ ? "NUL" : "/dev/null" )
+
+    load('#{file}')
+    load('#{xfile}')
+
+    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: #{file}\n"
+      $stderr << "XTEST: #{xfile}\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
+
+  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
+
+  attr_accessor :style
+
+  def initialize( style=nil )
+    @style = style
+
+    @results = []
+
+    @assertion_count = 0
+    @run_count = 0
+    @failure_count = 0
+    @error_count = 0
+  end
+
+  # Add a result to the results collection.
+
+  def <<( result )
+    @results << result
+
+    @assertion_count += result.assertion_count
+    @run_count += result.run_count
+    @failure_count += result.failure_count
+    @error_count += result.error_count
+  end
+
+  #
+
+  def errors
+    errors = []
+    @results.each do |r|
+      unless r.passed?
+        errors << r.instance_variable_get('@errors')
+      end
+    end
+    errors.reject! { |e| e == [] }
+    errors
+  end
+
+  #
+
+  def failures
+    failures = []
+    @results.each do |r|
+      unless r.passed?
+        failures << r.instance_variable_get('@failures')
+      end
+    end
+    failures.reject! { |e| e == [] }
+    failures
+  end
+
+  # Output format for test results.
+
+  def to_s
+    return @results.to_s if style == 'pease'
+
+    s = []
+    # Display failures
+    unless failures.empty?
+      s << ''
+      s << "FAILURES:"
+      failures.reverse.each do |fails|
+        fails.reverse.each do |failure|
+          #puts
+          s << %{  - test      : #{failure.test_name}}
+          s << %{    location  : #{failure.location}}
+          if failure.message.index("\n")
+            s << %{    message   : >}
+            s << failure.message.tabto(6)
+          else
+            s << %{    message   : #{failure.message}}
+          end
+        end
+      end
+    end
+
+    # Display errors
+    unless errors.empty?
+      s << ''
+      s << "ERRORS:"
+      errors.reverse.each do |errs|
+        errs.reverse.each do |err|
+          s << ''
+          s << %{  - test      : #{err.test_name}}
+          s << %{    message   : #{err.exception.message}}
+          s << %{    backtrace :}
+          err.exception.backtrace[0...-1].each { |bt| s << %Q{      - #{bt}} }
+        end
+      end
+    end
+
+    # Display final results
+    s << ''
+    s << "Summary:"
+    s << "  Tests      : #{@run_count}"
+    s << "  Assertions : #{@assertion_count}"
+    s << "  Failures   : #{@failure_count}"
+    s << "  Errors     : #{@error_count}"
+    s << ''
+    s << ''
+
+    return s.join("\n")
+  end
+
+  # Delegate missing call to the results array.
+
+  def method_missing(*a,&b)
+    @results.send(*a,&b)
+  end
+end