ttk 0.1.576

data/TODO

@@ -0,0 +1,23 @@
+
+
+= Introduction
+
+TTK's ToDo list is based on the TTK's tracker available on www.feydakins.org.
+This tracker is used for both features request and bugs report. This document
+describe how to post a good feature request and/or a good bug report.
+
+
+= TTK's tracker
+
+http://www.feydakins.org/projects/ttk/tracker/base_view
+
+This is the main view of TTK's tracker. It allow you to browse, to sort and
+to search for issues. The _Add issue_ link in the issue action frame on the
+left give you access to the post application form.
+
+When submitting a bug or a feature you have to choose the section of TTK, it
+best fit with. If you don't know, choose the section with the bigger scope.
+
+
+--
+TTK's maintainers

data/TODO.old

@@ -0,0 +1,115 @@
+* Documentation
+* On a un gros probl�me avec les fichiers ouverts sur NetBSD.
+* TestTCmd                           doit                           ajouter
+  {ref,cur,status,diff}_{exit,signal,output,error,timeout} dans le log
+* Le  filtre Weight  ne semble  pas  fonctionner, pourtant,  nous en  avons
+  absolument besoin (et il faut qu'il travaille en stream).
+* Je n'ai  pas r�ussis � faire  des filtres en stream.  C'est possible? (Il
+  faudrait, sinon, les filtres n'ont plus d'interets)
+* Il faudrait que TraceSplit fasse le boulot de copy_trace.sh
+* L'execution d'une commande est bizzare  a il y un thread (TestTBase) puis
+  un  fork  dans  le  thread  (TestTCmdBase).  Il  faudrait  simplifier  le
+  processus
+* TestCmdBase  fait  des  choses   pas  tr�s  catolique  pour  executer  la
+  commande... M�me si ca peut �tre utile dans certains cas, ca n'est pas le
+  comportement attendu. Il faudrait mettre tout ca au propre
+* Faut revoir TestCmdBase. En particuli�re,  l'appel d'un shell ne me plait
+   pas. (Ne serait-ce  que pour le quotting qui se fait  une fois dans Yaml
+   et une fois dans le shell)
+* Xml.rb pourrait  passer dans le  trunk, il faudrait juste  l'ameliorer un
+   peu
+_ configure et make n'affichent pas les sorties
+_ L'extraction de  tarball  est buggu�,  il  manque l'option  "f  -" �  la
+  commande tar
+_ TracesXml ne  g�n�re les traces qu'a la fin  du processus. C'est emb�tant
+  quand on se fait d�loggu� ou que la moulinette plante
+_ Xml.rb ne met pas la bonne ent�te pour les traces.
+_ Xml.rb met  des caract�res  non  imprimable dans  les xml,  il faut  les
+  remplacer par \x??
+_ Le  TestTCmd qui doit  faire le ./configure  est buggu�, je pense  que ca
+  vient de la remarque pr�c�dente
+_ Xml.rb a  un bug avec  la duplication des  attributs. Ca ressemble  a une
+   sombre histoire de noeuds copi�s par r�f�rence...
+_ Xml.rb  devrait nommer  son  premier  noaud "test"  en  "trace" pour  que
+   l'intra l'affiche plus joliment
+* Faire un  Html.rb qui  ne ferais que  applisuer une  xslt. Vu qu'on  a la
+   Xlst,  ca  devrait  pas  �tre  dur. Je  cherche  une  librairie  capable
+   d'appliquer une Xslt  en Ruby... Pa contre, ca a  tendance a changer les
+   l'optique des flux de log dans la moulinette. Il y aurait des flux Yaml,
+   des flux Xml,  etc... Maintenant, que j'y pense,  ca n'est peut-�tre pas
+   une mauvaise id�e... Il suffit de  typer un peu plus fortement la sortie
+   de nos filtres  (Je prefere parler de filtre au  sens g�n�ral plutot que
+   de Dumper) et c'est bon.
+_ La compilation, ca  n'est pas encore ca. La  compilation sur Makefile, ca
+   n'est pas bon.
+* On a et ca etre de pire  en pire des probl�mes avec les repertoires. On a
+   le  repertoire  ou  on copie  la  tarball,  le  repertoire ou  elle  est
+   d�compr�ss�e, le  repertoire ou  se trouves des  fichiers suppl�mentaire
+   pour  les tests,  etc....  Faut  qu'on trouve  une  solution... Dans  la
+   Moulmouth,  je me  mettais dans  le  repertoire de  decompression de  la
+   tarball et  je ne bougeais plus.  J'acc�dais au reste  avec des variable
+   d'environnement. On  peut faire le  m�me principe: Un certain  nombre de
+   variables globale � une TestTSuit qui definissent les repertoires.
+* C'est difficile  de faire  des tests avec  des fichiers  exterieur (genre
+   ajouter notre  main.c au rendu de  l'�tudiant). Le probl�me  vient de la
+   gestion des repertoire pourrie.
+* Les TestTCmd devient trop compliqu�. Au d�pard, j'�tais d'avis de fournir
+   un ensemble de TestTCmd d'exemple  et de laisser le programmeur faire le
+   reste.   Je reviens  un peut  en arri�re.   Il faudrait  un  ensemble de
+   classe TestTCmd repr�sentant les  cas simple (genre input/output) et une
+   classe assez "complexe"  capable de faire des trucs  compliqu� sans trop
+   se prendre la t�te.Il faut absoluement avoir des classe simples pour que
+   l'utilisateur pouisse facilement les d�river  si il veut faire une petit
+   modification.
+
+   Bref, avant, je voulais plutot:
+
+                             TestTCmdBase
+                           /    /    \    \
+                         /     /      \     \
+                       /      /        \      \
+               TestTCmd1 TestTCmd2 TestTCmd3 TestTCmd4
+
+   Maintenant, je serais plutot:
+                             TestTCmdBase
+                           /    /    \    \
+                         /     /      \     \
+                       /      /        \      \
+               TestTCmd1 TestTCmd2 TestTCmd3 TestTCmd4
+                        \     \       /     /
+                         \     \     /     /
+                          \     \   /     /
+               TestCmdAll (one classe to bring them all)
+
+   TestCmdAll  pourrait  par  exemple  faire  de  l'introspection  sur  les
+   TestTCmd* et permettre de choisir quelles m�thodes de quelles classes on
+   va utiliser. Genre:
+        - inputfunc: TestTCmd1::input
+          outputfunc: TestTCmd2::output
+          coef2: 2
+          coef1: 5
+          resultfunc: { (@outresult * @coef2 ) + (@errresult * @coef1) }
+
+
+_ Il y a des bug entre DFSplit et Xml. Je ne sais pas encore d'ou ca vient
+_ La classe TestTCmd  fait des diff sur stdout ou stderr  (et le test fail)
+   m�me si on  ne precise pas de output/error. C'est  mal faut qu'on change
+   ca.
+* TestTCmd ne permet pas de tester  la sortie avec un truc exterieur (genre
+   v�rifier si un certain fichier existe pour valider le test)
+* On devrait  peut-etre faire un  TestTCmd g�rant les attribut  "before" et
+   "after". Tous  les deux �tant des  blocs de Ruby que  l'on execute juste
+   avant et  juste apres le test. Ca  revient sur l'id�e du  Loader Ruby de
+   Marco
+* Il  faut qu'on  puise passer  des  parametre au  Loader par  la ligne  de
+   commande.  Je  pense  en   particulier  �  l'upload  qui  voudra  mettre
+   l'emplecement de la tarball sur la ligne de commande.
+* TestTCmd ne permet pas de v�rifier le signal emit par la commande
+* Il nous  faudrait une classe  TTAutoTest permettant de definir  des tests
+   avant que la moulinette ne se lance. Par exemple: "il faut la tarball de
+   ref passe tous les tests" ou bien "il faut que /bin/false ne passe aucun
+   test".
+* Il  nous faudrait  des warpper  pour different  trucs. c'ets  a  dire des
+   raccourcis  vers  certains  sc�narios  tres  utilis�  (tarball  piscine,
+   examsm, proj, etc...)
+* FIX bug in the test suite !!!

data/VERSION

@@ -0,0 +1,5 @@
+TTK version 0.1.<%= rev %> {<%= date %>} [BABY]
+
+Copyright (c) 2004-2005 Nicolas Despr�s, Nicolas Pouillard
+This is free software; see the source for copying conditions. There is NO
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

data/bin/getopts/ttk.rb

@@ -0,0 +1,394 @@
+# Author::    The TTK Team.
+# Copyright:: Copyright (c) 2004 TTK team. All rights reserved.
+# License::   LGPL
+# $Id: ttk.rb 575 2005-04-14 10:22:30Z polrop $
+
+require 'optparse'
+require 'module/hierarchy'
+require 'pp_hierarchy'
+
+module TTK
+
+  module Getopts
+
+    class TTK
+
+      DEFAULT_OPTIONS = {
+        :current_input => nil,
+        :current_output => STDOUT,
+        :current_loader => Loaders::Yaml,
+        :current_dumper => Dumpers::Yaml,
+        :no_default_observer => false,
+        :observers => [],
+        :wclass => Weights::Default,
+        :attributes => {},
+        :symbols => {},
+        :log_severity => Logger::Severity::INFO,
+        :log_verbosity => 0,
+        :log_section => [],
+        :tester_uris => [],
+        :profile_on => false,
+        :force_fetch => false,
+        :dump_status => false,
+        :cache_proc => DumpableProc.new('|test, status|
+                         status.pass? or status.is_a? TTK::SkipStatus'
+                       )
+      }
+
+      def self.parse(argv)
+        opts = DEFAULT_OPTIONS.dup
+        optparser = OptionParser.new do |optparser|
+
+          optparser.banner = "Usage: #{ME} [options] [files...]"
+          optparser.summary_indent = '  '
+          optparser.summary_width = 25
+
+          ### IO options
+
+          optparser.separator ''
+          optparser.separator 'IO options:'
+
+          optparser.on('-i',
+                       '--input FILE',
+                       'Set input file (only a Result)') do |aFile|
+            if aFile == '-'
+              opts[:current_input] = STDIN
+            else
+              opts[:current_input] = File.new(aFile, 'r')
+            end
+          end
+
+          optparser.on('-o', '--output FILE', 'Set output file') do |aFile|
+            if aFile == '-'
+              opts[:current_output] = STDOUT
+            else
+              opts[:current_output] = File.new(aFile, 'w')
+            end
+          end
+
+          ### Strategy options
+
+          optparser.separator ''
+          optparser.separator 'Strategy options:'
+
+          optparser.on('-I',
+                       '--include PATH',
+                       'Set PATH for test strategy classes') do |aPath|
+            Strategies.module_eval do
+              aPath.split(':').each do |aPath|
+                autoload_tree(aPath, false) do |p|
+                  ::TTK.pathname_to_class(p)
+                end
+              end
+            end
+          end
+
+          optparser.on('--strategy-list', 'List all test strategy classes') do
+            pp_class_hierarchy('Strategies::Strategy')
+            exit
+          end
+
+          ### Loader options
+
+          optparser.separator ''
+          optparser.separator 'Loader options:'
+
+          all_loaders = sub_modules(Loaders)
+
+          optparser.on('-L',
+                       '--loader [TYPE]',
+                       all_loaders,
+                       'Select a loader (no argument for the list)') do |aLoader|
+            if aLoader.nil?
+              pp_class_hierarchy('Loaders::Loader')
+              exit
+            else
+              opts[:current_loader] = Loaders.const_get(aLoader)
+            end
+          end
+
+          ### Dumper options
+
+          optparser.separator ''
+          optparser.separator 'Dumper options:'
+
+          all_dumpers = sub_modules(Dumpers)
+
+          optparser.on('-P',
+                       '--dumper [TYPE]',
+                       all_dumpers,
+                       'Select a dumper (no argument for the list)') do |aDumper|
+            if aDumper.nil?
+              pp_class_hierarchy('Dumpers::Dumper')
+              exit
+            else
+              opts[:current_dumper] = Dumpers.const_get(aDumper)
+            end
+          end
+
+          ### Filter options
+
+          optparser.separator ''
+          optparser.separator 'Filter options:'
+
+          all_filters = sub_modules(Filters)
+
+          #FIXME: the result here is overwritten in ttk driver
+
+          optparser.on('-F',
+                       '--filter [TYPE]',
+                       all_filters,
+                       'Select a filter ' +
+                       '(no argument for the list)') do |aFilter|
+            if aFilter.nil?
+              pp_class_hierarchy('Filters::Filter')
+              exit
+            else
+              dumper = opts[:current_dumper].new(opts[:current_output])
+              result = Logger.new(dumper)
+              opts[:observers] << Filters.const_get(aFilter).new(result)
+            end
+          end
+
+          optparser.on('--filter-seq x,y,z',
+                       Array,
+                       'Select a filter sequence') do |anArray|
+            dumper = opts[:current_dumper].new(opts[:current_output])
+            result = Logger.new(dumper)
+            opts[:observers] << anArray.reverse_fold(result) do |aFilter,acc|
+              Filters.const_get(aFilter).new(acc)
+            end
+          end
+
+          ### Weight options
+
+          optparser.separator ''
+          optparser.separator 'Weight options:'
+
+          optparser.on('-W',
+                       '--wclass [TYPE]',
+                       'Select the weight class ' +
+                       '(no argument for the list)') do |aString|
+            if aString.nil?
+              pp_class_hierarchy('Weights::Weight')
+              exit
+            else
+              opts[:wclass] = Weights.const_get(aString)
+            end
+          end
+
+          ### Tester options
+
+          optparser.separator ''
+          optparser.separator 'Server options:'
+
+          optparser.on('-t', '--tester URI', 'Remote tester uri') do |uri|
+            opts[:tester_uris] << URI.parse(uri)
+          end
+
+          ### Logger options
+
+          optparser.separator ''
+          optparser.separator 'Logger options:'
+
+          optparser.on('-l', '--log FILE', 'Set the log file') do |aFile|
+            io = (aFile == '-') ? STDERR : File.open(aFile, 'w')
+            opts[:observers] << opts[:current_dumper].new(io)
+          end
+
+          optparser.on('-d',
+                       '--severity [NAME]',
+                       'Log severity level ' +
+                       '(no argument for the list)') do |level|
+            if level.nil?
+              puts 'Log severity level list:'
+              Logger::Severity.labels.each { |l| puts " - #{l}" }
+              exit
+            else
+              begin
+                raise NameError if level.nil?
+                opts[:log_severity] = Logger::Severity.const_get(level.to_s.upcase)
+              rescue NameError
+                raise(OptionParser::InvalidArgument, level)
+              end
+            end
+          end
+
+          higher_level = Logger::Verbosity.higher_level
+          optparser.on('-v',
+                       '--verbosity NUM',
+                       "Log verbosity level [0-#{higher_level}]") do |level|
+            ilevel = level.to_i
+            if ilevel.to_s != level
+              raise(OptionParser::InvalidArgument, level)
+            end
+            if 0 <= ilevel and ilevel <= higher_level
+              opts[:log_verbosity] = ilevel
+            else
+              raise(OptionParser::InvalidArgument, level)
+            end
+          end
+
+          optparser.on('-s',
+                       '--log-section [NAME]',
+                       'Active a log section ' +
+                       '(no argument for the list)') do |name|
+            if name.nil?
+              #FIXME: print the section tree
+              exit
+            else
+              #FIXME: check the validity of the section
+              opts[:log_section] << name.to_s
+            end
+          end
+
+          ### Miscellaneous options
+
+          optparser.separator ''
+          optparser.separator 'Miscellaneous options:'
+
+          optparser.on('-S',
+                       '--symbols symbols',
+                       'Add a hash of symbols to the root test suite') do |str|
+            opts[:symbols] = opts[:current_loader].new.load_doc(str)
+          end
+
+          optparser.on('-A',
+                       '--attributes attributes',
+                       'Add a hash of attributes to ' +
+                       'the root test suite') do |aString|
+            opts[:attributes] = opts[:current_loader].new.load_doc(aString)
+          end
+
+          optparser.on('-D',
+                       '--define VAR=VALUE',
+                       'Set a global variable') do |aString|
+            if aString =~ /(\w+)=(.*)$/
+              eval "$#$1 = $2"
+            else
+              STDERR.puts optparser
+              exit
+            end
+          end
+
+          optparser.on('-C', '--[no-]cache', 'Keep the test in cache') do |c|
+            opts[:cache] = c
+          end
+
+          optparser.on('--cache-dir DIR', 'Use the cache in DIR') do |dir|
+            dir = Pathname.new(dir)
+            help unless dir.directory?
+            opts[:cache_dir] = dir
+          end
+
+          optparser.on('-r', '--cache-proc RUBY_CODE',
+                       'Use this block to skip tests in cache mode ' +
+                       '(ex: "|test, status| status.pass?")') do |code|
+
+            help unless code =~ /^\s*|[^,]+,[^,]+|\s*\S+/
+            opts[:cache_proc] = DumpableProc.new(code)
+          end
+
+          optparser.on('--profile', 'Switch on profile informations') do
+            opts[:profile_on] = true
+          end
+
+          optparser.on('--force-fetch',
+                       'Force to fetch file even on the same host') do
+            opts[:force_fetch] = true
+          end
+
+          optparser.on('--dump-status',
+                       'Dump the global status at the end (STDOUT)') do
+            opts[:dump_status] = true
+          end
+
+          optparser.on('--gen-strategies-hierarchy',
+                       'Generate the strategies hierarchy description') do
+            hsh = Strategies.sub_classes_tree(Strategies::Strategy, true, true)
+            puts "# TTK's strategies hierarchy generated on #{Time.now}"
+            YAML.dump(hierarchy_to_s(hsh), STDOUT)
+            exit
+          end
+
+          optparser.on('--no-default-observer',
+                       'Do not add a default observer') do
+            opts[:no_default_observer] = true
+          end
+
+          optparser.on_tail('-h',
+                            '--help [strategy]',
+                            'Show this message') do |aStrategy|
+            if aStrategy.nil?
+              STDERR.puts optparser
+              puts <<-eof
+
+For bug reporting instructions, please see:
+http://www.feydakins.org/projects/ttk/tracker/base_view
+eof
+            else
+              Strategies.const_get(aStrategy).help
+            end
+            exit
+          end
+
+          optparser.on_tail('--version', 'Show version') do
+            rev = 0
+            begin
+              File.open('REVISION') { |io| rev = io.gets.gsub!(/\D/, '').to_i }
+            rescue Errno::ENOENT
+            end
+            date = ''
+            begin
+              File.open('DATE') do |io|
+                date = io.gets.sub!(/^.*?\((.*?)\).*?$/) { $1 }
+              end
+            rescue Errno::ENOENT
+            end
+            date.chomp!
+            require 'erb'
+            res = ERB.new(File.read('VERSION'), nil, '<%>').result(binding)
+            puts res
+            exit
+          end
+
+        end
+
+        optparser.parse!(argv)
+        argv << '-' if argv.empty?
+        argv.map! { |x| x == '-' ? STDIN : Pathname.new(x) }
+        opts
+      end
+
+      protected
+      def self.sub_modules(mod)
+        mod.constants.sort!.map! { |c| c.to_sym }
+      end
+
+      protected
+      def self.pp_class_hierarchy(name)
+        if name =~ /^(\w+)::(\w+)$/
+          mod = ::TTK.const_get($1)
+          klass = mod.const_get($2)
+          puts "#{mod} classes hierarchy:"
+          hsh = mod.sub_classes_tree(klass, true, true)
+          hsh.pp_hierarchy(Regexp.new("^#{mod}::"), true)
+        end
+      end
+
+      protected
+      def self.hierarchy_to_s(hsh)
+        r = {}
+        hsh.each { |k, v| r[k.to_s] = hierarchy_to_s(v) }
+        r
+      end
+
+    end # class TTK
+
+  end # module Getopts
+
+end # module TTK
+
+
+
+