uttk 0.3.1.2

data/bin/uttk

@@ -0,0 +1,188 @@
+#!/usr/bin/env ruby
+# Author::    The Uttk Team.
+# Copyright:: Copyright (c) 2004, 2005 Uttk team. All rights reserved.
+# License::   LGPL
+# $Id: /w/fey/uttk/trunk/bin/uttk 22095 2006-02-21T17:17:56.386215Z pouillar  $
+
+begin
+  require 'pathname'
+
+  ME = Pathname.new($0).basename unless defined? ME
+  ME_DIR = Pathname.new(__FILE__).dirname unless defined? ME_DIR
+
+  $PROGRAME_NAME = ME
+  $PROGRAME_NAME.freeze
+  $VERBOSE = true           # you can use 'export RUBYOPT="-w"' too
+
+  Uttk_BIN = true
+
+  require Pathname.new(__FILE__).dirname.parent + 'lib/uttk' unless defined? Uttk
+
+  module Uttk
+    SPEC_YML = ME_DIR.parent + 'SPEC.yml'
+    SPEC = YAML::load(SPEC_YML.read)
+    VERSION = SPEC['version']
+    VERSION_PATH = ME_DIR.parent + 'VERSION'
+    AUTHORS_PATH = ME_DIR.parent + 'AUTHORS'
+    require 'erb'
+    VERSION_TEXT = ERB.new(VERSION_PATH.read, nil, '<%>').result(binding)
+  end
+
+  require "#{ME_DIR}/getopts/uttk"
+
+  argv = ARGV.dup
+  opts = Uttk::Getopts::Uttk.parse(argv)
+
+  require 'profile' if opts[:profile]
+
+  if opts[:cache_dir] and opts[:cache_dir] != TempPath.tmpdir
+    TempPath.tmpdir.rmdir
+    opts[:cache_dir].mv(TempPath.tmpdir)
+    opts[:cache_dir] = TempPath.tmpdir
+    opts[:cache_mode] ||= true
+  end
+
+  symtbl = Uttk.default_symtbl(opts).new_child
+  log = symtbl[:log]
+  at_exit { log.close }
+
+  t = argv.uttk_testify(symtbl)
+
+  # Load the cache file if cache_dir is set.
+  if cache_dir = opts[:cache_dir]
+    cache = cache_dir + 'cache.yml'
+    t.symtbl[:use_cache] = YAML.parse(cache.read).symbol_safe_transform
+  end
+
+  # Disable the automatic cleaning of TempPath for the cache mode.
+  if opts[:cache_mode]
+    TempPath.auto_clean = false
+  end
+
+  # Run the root test.
+  status = t.run
+
+
+  # Generate the cache file.
+  if opts[:cache_mode]
+    cache_file = TempPath.tmpdir + 'cache.yml'
+    cache = t.symtbl[:cache]
+    t.symtbl.local.delete :cache
+    cache.each do |name, test|
+      todel = [:use_cache]
+      test[:symtbl].each do |k, v|
+        if [SynFlow, SynFlowFactory].any? { |klass| v.is_a? klass }
+          todel << k
+        end
+      end
+      todel.each { |k| test[:symtbl].delete(k) }
+    end
+    cache_file.open('w') { |f| f.puts cache.to_yaml }
+  end
+
+  relaunch = TempPath.tmpdir + 'relaunch'
+
+  if opts[:cache_mode]
+
+    # Update the argument for the cache mode
+    ARGV.delete '-C'
+    if ARGV.include? '--cache-dir'
+      ind = ARGV.index('--cache-dir') + 1
+      ARGV[ind] = TempPath.tmpdir.to_s
+    else
+      ARGV << '--cache-dir' << TempPath.tmpdir.to_s
+    end
+
+  end
+
+  if (opts[:cache_mode] or opts[:cache_dir]) and not status.pass?
+    raise 'HighLine is unavailable' unless defined? HighLine
+    h = HighLine.new
+    # Ask the user what to do.
+    if h.agree 'Would you relaunch the test suite now (use the cache) (y/n)', true
+      pid = Kernel.fork do
+        Kernel.exec Config::CONFIG['RUBY_INSTALL_PATH'], $0, *ARGV
+      end
+      Process.waitpid pid
+      exit
+    else
+      if h.agree 'Would you remove the temporary dir (y/n)', true
+        TempPath.auto_clean = true
+      else
+        TempPath.auto_clean = false
+        # Generate a little helper script to use the cache mode.
+        unless relaunch.exist?
+          relaunch.open('w') do |f|
+            f.puts '#!/usr/bin/env ruby'
+            f.puts "
+              |Kernel.exec #{Config::CONFIG['RUBY_INSTALL_PATH'].inspect},
+              |            #{$0.inspect}, *#{ARGV.inspect}
+              |".head_cut!
+          end
+          relaunch.chmod(0500)
+        end
+
+        STDERR.puts "
+          |
+          |--- |
+          |
+          | /------------------------------------------------------------------.
+          | | Uttk was running in cache mode to re-run the same one just type: |
+          | |   #{relaunch.to_s.ljust(63)}|
+          | `------------------------------------------------------------------/
+          |".head_cut!
+      end
+    end
+  else
+    TempPath.auto_clean = true
+  end
+
+  # Handle the --dump-status option.
+  STDOUT.puts status.to_yaml if opts[:dump_status]
+
+  unless status.pass?
+
+    if not opts[:dump_status] # FIXME and filter contains Default
+      STDERR.puts "
+        |
+        |--- |
+        | /-----------------------------------------------------------------------------.
+        | |                         *** Some tests failed ***                           |
+        | | The last status was not PASS but something like FAIL(42%) (just FAIL stands |
+        | | for FAIL(0%)). This means that 42% of tests *pass* but 100% was expected.   |
+        | | To investigate results these different outputs are available:               |
+        | |   - the standard output is the shortest one (like a progression bar).       |
+        | |   - log.html contains an HTML/JavaScript page nice to display big outputs.  |
+        | |   - log.yml contains more information in the very readable YAML format.     |
+        | |   - log.xml contains the output as an XML document.                         |
+        | `-----------------------------------------------------------------------------/
+        |".head_cut!
+    end
+    exit(2)
+  end
+
+rescue SystemExit
+  raise
+rescue Exception => ex
+
+  TempPath.auto_clean = true if defined? TempPath
+  Thread.critical = true if defined? Thread
+  raise ex if ex.is_a? SystemExit
+  if defined? OptionParser and ex.is_a? OptionParser::ParseError
+    Uttk::Getopts::Uttk.usage
+    puts
+    if log.nil?
+      STDERR.puts "ERROR:\n  #{ex.to_s} (OptionParser)"
+    else
+      log.error { ex }
+    end
+  elsif log.nil?
+    raise ex
+  else
+    log.error { ex }
+  end
+  exit(1)
+
+end
+
+exit(0)

data/bin/uttk-unit

@@ -0,0 +1,125 @@
+#!/usr/bin/env ruby
+# Copyright:: Copyright (c) 2005  Uttk Team. All rights reserved.
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# License::   Gnu General Public License.
+# Revision::  $Id$
+
+
+# FIXME add a configuration file
+# conf:
+# load_path: ../lib # relative to the place of the configuration file
+# requires:
+class UttkUnit
+
+  def initialize ( argv )
+    @argv = argv
+  end
+
+
+  def parse_options
+    @options = OpenStruct.new(:load_path => [],
+                              :actions   => [],
+                              :uttk      => nil,
+                              :verbose   => true,
+                              :mode      => :require)
+
+    OptionParser.new do |o|
+      o.on('-I', '--include DIR', 'Add this directory to $LOAD_PATH') do |dir|
+        @options.load_path << dir
+        @options.actions << proc { dir.to_path.load_path! if defined? CoreEx }
+      end
+      o.on('-r', '--require FEATURE', 'Require this file') do |file|
+        @options.actions << proc { require file }
+      end
+      o.on('--import NAME', 'Import this constant') do |const|
+        @options.actions << proc { const.constantize.import! }
+      end
+      o.on('--mode import|require|nothing', [:import, :require, :nothing],
+           'Set the loading mode for unit tests [default: require]') do |mode|
+        @options.mode = mode
+      end
+      o.on('-w', '--[no-]verbose', 'Turn on/off the verbose mode [default: on]') do |b|
+        @options.verbose = b
+      end
+      o.on('--uttk FILE', 'Require this Uttk (`no\' to disable)') do |file|
+        @options.uttk = file
+      end
+    end.parse!(@argv)
+  end
+
+
+  def requires
+    require 'pathname'
+    require 'ostruct'
+    require 'optparse'
+  end
+
+
+  def run
+    raise 'Do not load CoreEx before uttk-unit' if defined? CoreEx
+
+    requires
+
+    parse_options
+
+    files = []
+    options = false
+    argv = ARGV.dup
+    ARGV.replace([])
+    argv.each do |arg|
+      if options
+        ARGV << arg
+        next
+      end
+      if arg == '--'
+        options = true
+      else
+        files << Pathname.new(arg).cleanpath
+      end
+    end
+
+    quoted_paths = files.map { |s| Regexp.quote(s) }
+    re_paths = Regexp.new("(#{quoted_paths.join '|'})")
+
+    Kernel.const_set(:EMBEDDED_TEST_MODE, re_paths)
+
+    @options.load_path.each { |dir| $LOAD_PATH << dir }
+
+    root = Pathname.new(__FILE__).dirname.parent
+
+    if @options.uttk.nil?
+      require((root + 'lib' + 'uttk').to_s)
+    elsif @options.uttk != 'no'
+      require @options.uttk
+    end
+
+    @options.actions.each { |block| block[] }
+
+    raise 'CoreEx not loaded' unless defined? CoreEx
+
+    Test::Unit::UI::Yaml::TestRunner.import!
+
+    $VERBOSE = @options.verbose
+
+    files.each do |arg|
+      path = Pathname.new(arg).ext.to_s
+
+      case @options.mode
+        when :import
+          path = path.camelize if path !~ /[A-Z]/ or path =~ /[.\/]/
+          path.constantize.import!
+        when :require
+          require path
+        when :nothing
+        else raise "Bad loading mode: #{@options.mode}"
+      end
+    end
+
+    run_embedded_test_sections
+  end
+
+
+end # class UttkUnit
+
+
+UttkUnit.new(ARGV).run

data/lib/uttk.rb

@@ -0,0 +1,288 @@
+# Author::    The Uttk team
+# Copyright:: Copyright (c) 2004, 2005 Uttk team. All rights reserved.
+# License::   LGPL
+# $Id: /w/fey/uttk/trunk/lib/uttk.rb 22081 2006-02-21T15:10:48.580983Z pouillar  $
+
+#
+# = Description
+#
+# Interface module of the Uttk library. This file must be included by every
+# Uttk's users.
+#
+
+#
+# = Introduction
+#
+# This is the Uttk namespace. All Uttk is included into this namespace. This
+# module provides some function to set up and run a Uttk pipeline.
+#
+# = How to use Uttk as a library
+#
+# FIXME: document me
+module Uttk
+
+  require 'pathname'
+
+  lib = Pathname.new(__FILE__).dirname
+  vendor = lib.parent + 'vendor'
+  unless defined? RubyEx
+    $CORE_EX_VENDORS ||= []
+    $CORE_EX_VENDORS << vendor
+    file = vendor + 'ruby_ex' + 'lib' + 'ruby_ex.rb'
+    if file.exist?
+      require file.to_s
+    else
+      require 'rubygems'
+      require_gem 'ruby_ex'
+      require 'ruby_ex'
+    end
+  end
+  $LOADED_FEATURES << 'uttk.rb'
+  lib.load_path!
+  RubyEx.import!
+  mattr_accessor :dir, :load_path
+  self.dir = lib + 'uttk'
+  self.load_path = [dir]
+  silence_warnings { core_ex_require 'action_view', 'actionpack' }
+
+
+  # Standard library requirements
+  require 'stringio'
+  require 'ostruct'
+  require 'tmpdir'
+  require 'thread'
+  require 'mutex_m'
+  require 'benchmark'
+  require 'rbconfig'
+  conf = Config::CONFIG
+  conf['RUBY_INSTALL_PATH'] = "#{conf['bindir']}/#{conf['RUBY_INSTALL_NAME']}"
+
+  # RubyEx requirements
+  SymTblGsub.import!
+  SynFlow.import!
+  Module::InstanceMethodVisibility.import!
+  AutoloadTree.import!
+  OrderedHash.import!
+  Abstract.import!
+  ConstRegexp.import!
+  HashEval.import!
+  RPath.import!
+  Commands.import!
+  Version.import!
+  URI::GenericEx.import!
+
+  # Mother exception of every exception thrown by Uttk.
+  class UttkException < Exception
+  end
+
+  # Uttk library requirements
+  require 'uttk/logger'
+  require 'uttk/logger_factory'
+  require 'uttk/streams'
+
+  # Autoload modules
+  def pathname_to_class(p)
+    const = p.basename.to_s.sub(/\.rb$/, '')
+    if const =~ ConstRegexp::RB_CONST
+      const
+    else
+      raise(ArgumentError,
+          "`#{p.to_s}' - your file doesn't follow our convention, " +
+          "the filename must be equal to the class name you declared into.")
+      nil
+    end
+  end
+  module_function :pathname_to_class
+
+  UTTK_MODULES = []
+
+  class ::Module
+    def uttk_module
+      module_eval do
+        UTTK_MODULES << self
+
+        def self.module_dirs
+          mod = name.demodulize.underscore
+          Uttk.load_path.map { |path| path/mod }
+        end
+
+        def self.setup_autoload
+          module_dirs.each do |module_dir|
+            if module_dir.directory? and module_dir.readable? and module_dir.executable?
+              autoload_tree(module_dir, false) do |p|
+                Uttk.pathname_to_class(p)
+              end
+            end
+          end
+        end
+        setup_autoload
+
+        def self.define_module
+          module_dirs.each do |module_dir|
+            def_file = Pathname.new("#{module_dir}.rb")
+            if def_file.readable?
+              require def_file.to_s
+            end
+          end
+        end
+        define_module
+
+        def self.each_module_name ( &block )
+          Pathname.glob('{' + module_dirs.join(',') + '}/**/*.rb') do |path|
+            block[path.basename.ext.to_s.to_sym]
+          end
+        end
+
+      end
+    end
+  end
+
+  def self.setup_autoload_all
+    UTTK_MODULES.each do |uttk_module|
+      uttk_module.setup_autoload
+    end
+  end
+
+  class ObserverError < ArgumentError
+    def initialize ( anObject )
+      @obs = anObject
+    end
+    def to_s
+      "observer needs to respond to `update' (#{@obs.inspect})"
+    end
+  end
+
+  module Weights
+    uttk_module
+  end
+
+  require 'uttk/status'
+
+  module Dumpers
+    uttk_module
+  end
+
+  module Loaders
+    uttk_module
+  end
+
+  module PathFilters
+    uttk_module
+  end
+
+  module Filters
+    uttk_module
+  end
+
+  module Strategies
+    uttk_module
+  end
+
+  # Modules shortcuts
+  S = Strategies
+  L = Loaders
+  D = Dumpers
+  F = Filters
+  W = Weights
+
+  # Set default options
+  DEFAULT_OPTIONS = {
+    :observers => [],
+    :backend => STDOUT.tty? ? 'DefaultColor' : 'Default',
+    :loader => Loaders::Yaml,
+    :wclass => Weights::Default,
+    :attributes => {}, #FIXME: freeze
+    :symbols => {}, #FIXME: freeze
+    :log_severity => Logger::Severity::INFO,
+    :log_verbosity => 0,
+    :log_section => [], #FIXME: freeze
+    :benchmark => false,
+    :profile => false,
+    :dump_status => false,
+    :cache_mode => false,
+    :cache_proc => DumpableProc.new('|test, status|
+       status.pass? or (status.is_a? Uttk::SkipStatus and status.weight.pass?)'
+    ).freeze,
+  }.freeze
+
+  def self.default_options
+    DEFAULT_OPTIONS
+  end
+
+  # Return the default symbol table
+  def self.default_symtbl ( options=default_options,
+                            log_factory=default_log_factory(options),
+                            log=default_log(options, log_factory))
+    symtbl = SymTbl.new(options)
+    symtbl[:uttk] = Pathname.new($0).expand_path
+    symtbl[:ruby] = Config::CONFIG['RUBY_INSTALL_PATH']
+    symtbl[:'uttk-unit'] = symtbl[:uttk_unit] =
+      (Uttk.dir.parent.parent/'bin'/'uttk-unit').expand_path.cleanpath
+    symtbl[:core_ex] = CoreEx.dir
+    symtbl[:symtbl_class] = symtbl.class
+    symtbl[:pwd] = Pathname.pwd.expand_path
+    symtbl[:loader] = options[:loader].new
+    symtbl[:log_factory] = log_factory
+    symtbl[:log] = log
+    symtbl[:cache] = {}
+    symtbl[:cache_proc] = options[:cache_proc]
+    symtbl[:suite_name] = 'root'
+    symtbl
+  end
+
+  # Return the default logger factory
+  def self.default_log_factory ( options=default_options )
+    log_factory = LoggerFactory.new
+    if ENV.has_key?('UTTK_SEVERITY')
+      log_factory.severity_level = ENV['UTTK_SEVERITY']
+    else
+      log_factory.severity_level = options[:log_severity]
+    end
+    log_factory.verbosity_level = options[:log_verbosity]
+    log_factory.section_tree << Logger::SectionNode.new('basicObserver')
+    log_factory.active_section = options[:log_section]
+    log_factory
+  end
+
+  # Return the default logger factory
+  def self.default_log ( options=default_options,
+                         log_factory=default_log_factory(options) )
+    log = log_factory.create
+    options[:observers] << options[:backend] if options[:observers].empty?
+    options[:observers].each do |backend|
+      Filters[backend].each do |obsv|
+        raise ObserverError, obsv unless obsv.respond_to? :update
+        log.add_observer(obsv)
+      end
+    end
+    log.info_basicObserver do
+      log.add_observer(Uttk::Dumpers::Basic.new(STDERR))
+      nil
+    end
+    log
+  end
+
+  # Evaluate code in the context of the Uttk module
+  def self.uttk_eval(string, symtbl, filename=__FILE__, lineno=1)
+    eval(string, binding, filename, lineno)
+  end
+
+  def self.bin
+    Config::CONFIG["RUBY_INSTALL_NAME"].to_cmd[dir.parent.parent + 'bin/uttk']
+  end
+
+end # module Uttk
+
+class Class
+  alias_method :old_to_yaml, :to_yaml
+  def to_yaml ( opts={} )
+    to_s.to_yaml(opts)
+  end
+  def is_complex_yaml?
+    false
+  end
+end
+
+if $0.to_path.basename.to_s == 'uttk' and not defined? Uttk_BIN
+  load Uttk::LIB_DIR.parent + 'bin/uttk'
+end