rake4latex 0.1.0 → 0.1.1

data/lib/rake4latex/base.rb

@@ -9,8 +9,20 @@ require 'rake'
 require 'md5'
 require 'log4r' #1.0.5
 
+module Rake
+  class Task
+=begin rdoc
+Define and get the related TeXRunner.
+The value is set by Rake4LaTeX::LaTeXRunner#run_latex_once
+and can be used by the tex_postrule.
+=end
+    attr_accessor :texrunner
+  end
+end
+
+
 module Rake4LaTeX
-  VERSION = '0.1.0'
+  VERSION = '0.1.1'
   
   #With this creation we define the constants Log4r::DEBUG...
   Logger = Log4r::Logger.new("LaTeXRunner")
@@ -47,7 +59,11 @@ But with this method you get also a check if the option exists.
   end
   
 =begin rdoc
-Load the Programs with parameters for Rake4LaTeX.build_cmd.
+Definition of the programms and there call parameters.
+
+There is a basic definition, you may redefine the values with your 
+local definitions.
+You can define your local definition in a file 'rake4latex.yaml'.
 
 Each program is a Hash:
   program:
@@ -59,18 +75,22 @@ Each program is a Hash:
       optional: flag, if the parameter is optional.
       space_separated: between name and value is a space.
 =end
+Programms = {}
 
-#fixme: incremental reading: global + local overwrites
+=begin rdoc
+Load the Programs with parameters for Rake4LaTeX.build_cmd.
+=end
   [
     "#{File.dirname(__FILE__)}/rake4latex.yaml",
     #ocra-settings:
     #a src\lib\rake4latex\rake4latex.yaml    
     #a lib\ruby\gems\1.8\gems\rake4latex-0.1.0\lib\rake4latex\base.rb    
     "#{File.dirname(__FILE__)}/../../../../../../../../src/lib/rake4latex/rake4latex.yaml",  #for ocra-version (exe)
+    "./rake4latex.yaml", #local re-definition
   ].each{| setting_file |
     if File.exist?(setting_file)
-      Programms = YAML.load(File.read(setting_file))
-      break
+      #Take the "more local" definition.
+      Programms.replace(YAML.load(File.read(setting_file)).merge(Programms))
     end
   }
   if ! defined? Programms
@@ -86,9 +106,13 @@ Bases is the configuration in Programms.
 'parameters' contains the parameters for the call.
 The keys must fit to the settings in Rake4LaTeX::Programms .
 =end
-  def self.build_cmd( programm, parameters = {} )
+  def self.build_cmd( programm, parameters = {}, task = nil )
     
-    configuration = Programms[programm]
+    if task #take the LaTeXRunner specific settings
+      configuration = task.texrunner.programms[programm] 
+    else  #take the global settings
+      configuration = Programms[programm] 
+    end
     if ! configuration
       Rake4LaTeX::Logger.fatal( "No configuration for #{programm.inspect}") if Rake4LaTeX::Logger.fatal?
       return false
@@ -122,7 +146,7 @@ only the help file for the selected basename is taken.
 Helpfiles for splitindex are not added. You can do it manual:
   CLEAN.add("testdocument-*") #splitidx-helpfiles
 
-This method is called by task 'basename'
+This method is called by task 'basename'.
 =end
   def self.set4clean( basename )
     #fixme splitindex-dateien
@@ -136,12 +160,16 @@ This method is called by task 'basename'
           CLEAN.include(file)
         when /\.(ilg|idx|ind)\Z/  #Index-Files
           CLEAN.include(file)
+        when /\.(glo|gls)\Z/  #Glossary-Files
+          CLEAN.include(file)
         when /\.(blg|bbl)\Z/  #BibTeX-Files
           CLEAN.include(file)
         when /\.(rai|rao|RAO)\Z/  #Rail-Files
           CLEAN.include(file)
         when /\.(dvi|pdf|ps)\Z/
           CLOBBER.include(file)              
+        when /\.overview.txt\Z/ #rake4latex, task :log_overview
+          CLOBBER.include(file)              
         else
           #~ @logger.warn("Unknown help file #{file}")
       end
@@ -158,6 +186,8 @@ Define a task to be executed after each TeX run.
 
 The task name is added to LaTeXRunner::Post_Prerequisites.
 LaTeXRunner#run_latex_once will loop on all tasks in LaTeXRunner::Post_Prerequisites.
+
+In the task definition you have access to the TeXRunner via Rake::Task#texrunner .
 =end
 def tex_postrule(*args, &block)
   #~ rules = rule(*args, &block)
@@ -181,6 +211,7 @@ The block will be called with a hash, the block must accept this one parameter.
 Inside the block you have access to:
 * :task: The task for which you test.
 * :checksums: the checksums of the files before the TeX-run.
+* :texrunner: The actual TeXRunner, calling the pre-check.
 * :logger: the logger of the related task
 
 The block must return false or the reason for a call (e.g. "testdocument.aux changed")
@@ -198,8 +229,7 @@ end
 #
 require 'rake4latex/clean'  #modified rake/clean
 require 'rake4latex/latexrunner'
-require 'rake4latex/latexdependencies'
+require 'rake4latex/analyse_texfile'
 require 'rake4latex/splitindex'
 require 'rake4latex/rules'
 require 'rake4latex/tex_statistic'
-require 'rake4latex/template'

data/lib/rake4latex/latexrunner.rb

@@ -1,5 +1,3 @@
-
-
 module Rake4LaTeX
 =begin rdoc
 Class which encapsulates all the information needed to call latex 
@@ -70,12 +68,17 @@ The settings contain the following values:
     #~ @logger = Log4r::Logger.new("LaTeXRunner #{settings[:main_file]}")
     #~ @logger.outputters = Log4r::StdoutOutputter.new('log_stdout')
     
+    #Copy the programms.
+    #This allows us to overwrite the program settings for a special LaTeXRunner.
+    @programms = Programms.dup
+    
     DEFAULT_SETTINGS.merge(settings).each{|key, value|
       #~ puts "#{key}: #{value}"
       case key
       when :main_file; @main_file = value
       when :maxruns; @maxruns = value
       when :program;  self.program = value
+      when :programms;  @programms.merge!(value)
       when :options;  @options = value
       when :loglevel;  @logger.level = value
       when :texerrors_allowed;  @texerrors_allowed = value
@@ -121,9 +124,12 @@ The settings contain the following values:
 # The full path of the input directory. It is determined automatically during initialization
   attr_reader :full_input_dir
   
-# The looger for the LaTeX-Run.
+# The logger for the LaTeX-Run.
   attr_reader :logger
 
+# Hash with Programm settings. by default Rake4LaTeX::Programms.
+  attr_reader :programms
+
 # Flag if TeX should be started again.
   def rerun_necessary?()
     @rerun_necessary and ( maxruns > @texruns )
@@ -158,7 +164,7 @@ The settings contain the following values:
         run_latex_once(cmd)
       end
     end
-    #Guarentee that help files are deleted fin clean.
+    #Guarentee that help files are deleted in clean.
     Rake4LaTeX.set4clean( @basename )
     
     plural_s = "#{@texruns} run#{@texruns>1 ? 's': ''}"
@@ -188,8 +194,10 @@ The settings contain the following values:
     latex_output = `#{cmd}`
     if $? != 0
       @logger.fatal("There where #@program errors. See #{@main_file.ext('.log')} for details")
-      raise RuntimeError, "There where #@program errors. "\
-          "See #{@main_file.ext('.log')} for details"  unless @texerrors_allowed
+      #~ @logger.fatal("Errors: #{TeX_Statistic.new(@main_file.ext('.log')).stat[@main_file.ext('.log')][:latex_errors].inspect}")
+      #~ raise RuntimeError, "There where #@program errors. "\
+          #~ "See #{@main_file.ext('.log')} for details"  unless @texerrors_allowed
+      exit unless @texerrors_allowed
     end
     
     helpfiles = %w{aux toc lof lot}
@@ -247,6 +255,8 @@ The settings contain the following values:
         next
       end
       
+      post_prereq.texrunner = self  #Set the connection to the TeXRunner
+      
       #Starts only, if prerequisites of post_prereq exist and was regenerated by TeX.
       #Here we make an additional check if we need the post_prereq.
       post_prereq.prerequisites.each{|post_prereq_pre|
@@ -256,7 +266,10 @@ The settings contain the following values:
           @logger.debug("Make precheck for #{pre}" )
           Post_Prerequisites_check[pre].each{|precheck|
             #Call the pre-check with the task...
-            reason4call = precheck.call(:task => post_prereq, :checksums => checksums, :logger => @logger)
+            reason4call = precheck.call(  :task => post_prereq, 
+                                                    :checksums => checksums, 
+                                                    :texrunner => self,
+                                                    :logger => @logger)
             break if reason4call  #we need only one reason to start the task.
           }
         else  #make the standard check (

data/lib/rake4latex/rake4latex.yaml

@@ -20,16 +20,20 @@ latex:
   - value_key: :filename
 makeindex: 
   cmd: makeindex
+  comment:     makeindex -s style.ist -t base.glg -o base.gls base.glo
   parameters: 
   - name: -s
     value_key: :format
     optional: true
+    space_separated: true
   - name: -o
     value_key: :file_out
     optional: true
+    space_separated: true
   - name: -t
     value_key: :file_log
     optional: true
+    space_separated: true
   - value_key: :file_in
 pdflatex: 
   cmd: pdflatex

data/lib/rake4latex/rules.rb

@@ -51,21 +51,51 @@ task :basefile do |task|
 end
 task :default => :basefile
 
+desc "Build a log-overview file"
+task :log_overview => :basefile do
+  Rake.application[:statistic].prerequisites.each{|pre|
+    next if pre == 'basefile' #exclude task :basefile
+    stat = Rake4LaTeX::TeX_Statistic.new(pre)
+    #Filename also used in set4clean
+    File.open("#{pre.ext()}.overview.txt", 'w'){|f| 
+      f << stat.overview()
+    }
+  }
+end
+
+desc "Archive all log-files to zip-file"
+task :log_archive => :basefile do
+  require 'zip/zipfilesystem'
+  Zip::ZipFile.open("rake4latex_log_archive.zip", Zip::ZipFile::CREATE ){|zip|
+    puts "Pack #{zip.name}"
+    #Store all Files to be deleted
+    CLEAN.each{|filename|
+      zip.file.open(File.basename(filename), 'w'){|f| f << File.open(filename,"rb") {|io| io.read} }
+    }
+    Rake.application[:statistic].prerequisites.each{|pre|
+      next if pre == 'basefile' #exclude task :basefile
+      stat = Rake4LaTeX::TeX_Statistic.new(pre)
+      zip.file.open("#{pre}.overview.txt", 'w'){|f| 
+        f << stat.overview()
+      }
+    }    
+  } #close zip-file
+end
 
 #
 #Reset the timestamp of a file (can be used to force the first compilation)
 #
 desc "Touch - reset timestamp"
-task :touch do |t|
-  t.prerequisites.each{|pre|
+task :touch do |task|
+  task.prerequisites.each{|pre|
     FileUtils.touch(pre)
   }
 end
 
 desc "Build a dvi-file with LaTeX"
-rule '.dvi' => '.tex' do |t|
+rule '.dvi' => '.tex' do |task|
   runner =   Rake4LaTeX::LaTeXRunner.new( 
-    :main_file => t.source,
+    :main_file => task.source,
     :program => :latex,
     :dummy => nil
     )
@@ -73,9 +103,9 @@ rule '.dvi' => '.tex' do |t|
 end
 
 desc "Build a ps-file from dvi"
-rule '.ps' => '.dvi' do |t|
-  Rake4LaTeX::Logger.info("Call dvips for <#{t.source}>")
-  cmd = Rake4LaTeX.build_cmd( 'dvips', :filename => t.source )
+rule '.ps' => '.dvi' do |task|
+  Rake4LaTeX::Logger.info("Call dvips for <#{task.source}>")
+  cmd = Rake4LaTeX.build_cmd( 'dvips', :filename => task.source )
   
   stdout, stderr = catch_screen_output{ 
     sh cmd
@@ -90,12 +120,13 @@ end
 
 
 desc "Call Makeindex"
-tex_postrule '.ind' => '.idx' do |t, args |
+tex_postrule '.ind' => '.idx' do |task|
   #check for splitidx
-  splitidx = Rake4LaTeX::Splitindex.new(t.source, Rake4LaTeX::Logger)
+  splitidx = Rake4LaTeX::Splitindex.new(task.source, Rake4LaTeX::Logger)
   if splitidx.makeindex?   #standard index, no splitidx
     #makeindex writes to stderr -> catch it
-    cmd = Rake4LaTeX.build_cmd( 'makeindex', :file_in => t.source )
+    cmd = Rake4LaTeX.build_cmd( 'makeindex', { :file_in => task.source }, task )
+    task.texrunner.logger.debug("\t#{cmd}")
     stdout, stderr = catch_screen_output{ 
       sh cmd
     }
@@ -150,57 +181,59 @@ tex_postrule_check '.bbl' do |args|
 end
 
 #Define the rule
-tex_postrule '.bbl' => '.aux' do |t|  
-  cmd = Rake4LaTeX.build_cmd( 'bibtex', :source => t.source )
+tex_postrule '.bbl' => '.aux' do |task|  
+  cmd = Rake4LaTeX.build_cmd( 'bibtex', {:source => task.source}, task )
+  task.texrunner.logger.debug("Call bibTeX: #{cmd}")
   stdout, stderr = catch_screen_output{ 
     puts `#{cmd}`
   }
   if $? != 0
-    Rake4LaTeX::Logger.fatal("There where BibTeX errors. \n#{stdout}")
+    task.texrunner.logger.fatal("There where BibTeX errors. \n#{stdout}")
   end
 end
 
 #Support for rail
 #http://www.ctan.org/tex-archive/support/rail/
 desc "Call Rail"
-tex_postrule '.rao' => '.rai' do |t|
+tex_postrule '.rao' => '.rai' do |task|
   #Rail works only with filenames with 8 characters.
   #So we use stdin.
-  cmd = Rake4LaTeX.build_cmd( 'rail', :railfile => t.source )
-  Rake4LaTeX::Logger.debug("Call rail: #{cmd}")
+  cmd = Rake4LaTeX.build_cmd( 'rail', :railfile => task.source )
+  task.texrunner.logger.debug("Call rail: #{cmd}")
   stdout, stderr = catch_screen_output{ 
     puts `#{cmd}`
   }
   error = false
   if $? != 0
-    Rake4LaTeX::Logger.fatal("There where Rail errors.")
+    task.texrunner.logger.fatal("There where Rail errors.")
     error = true
   end
   stderr.each{|errline|
-    Rake4LaTeX::Logger.error("Rail error: #{errline.strip}")
+    task.texrunner.logger.error("Rail error: #{errline.strip}")
     error = true
   }
   if error
-    Rake4LaTeX::Logger.warn("No rail diagramms generated")
+    task.texrunner.logger.warn("No rail diagramms generated")
   else
     #Now we have to save the result and delete some stuff.
     stdout.sub!(/^(This is Rail.*)/, '%\1') #%This is Rail, Version 1.1 #0
     stdout.sub!(/^(\(stdin.*)/, '%\1')  
     stdout.sub!(/^\)/, '%\1)')		#last line
-    File.open(t.source.ext('rao'), 'w'){|f| f << stdout }    
+    File.open(task.source.ext('rao'), 'w'){|f| f << stdout }    
   end
+  CLEAN.include(task.source)
+  CLEAN.include(task.name)
 end
 
 
-
-
 desc "Build a statistic for TeX project"
-task :statistic => :basefile do |t|
-  puts "Statistics:"
-  t.prerequisites.each{|pre|
+task :statistic => :basefile do |task|
+  task.prerequisites.each{|pre|
     next if pre == 'basefile' #exclude task :basefile
     stat = Rake4LaTeX::TeX_Statistic.new(pre)
-    puts stat
+    puts "Statistic for #{pre}:"
+    puts stat.stat_summary.map{|e| "  #{e}"}
+    #~ puts stat
   }
 end
 

data/lib/rake4latex/tex_statistic.rb

@@ -7,11 +7,92 @@ begin
 rescue LoadError 
   require 'yaml' 
 end
+
+=begin fixmes
+under/overfull:
+* Grouping 
+* Grenzwert
+
+Filesplit verbessern (testcase equal_log_analyse)
+=end
+
+
 module Rake4LaTeX
+=begin
+Informations about one TeX-Message
+=end
+class TeXMessage
+  #List of supported message types.
+  TYPES = [
+    :latex_errors,
+    :latex_warnings,
+    :package_errors,
+    :package_warnings,
+    :warnings,
+    :output, :source_information, #for statistic
+    :overfull_boxes, :underfull_boxes,
+  ]
+  @@seq = 0
+=begin rdoc
+Define a new TeX-Message.
+
+line: Source code line of the tex-file, where the message was created.
+No number, may be something line '621-625'.
+=end
+  def initialize(type, logline, message, details = {}, page = nil, source = nil, line = nil)
+    @type = type
+    #~ Rake4LaTeX::Logger.error("undefined TeX-message type #{@type.inspect}") if ! TYPES.include?(@type)
+    @message = message
+    @details = details
+    @page = page
+    @source = source
+    @line = line
+    @logline = logline
+    @nextlines = []
+  end
+  #Type of the message
+  #* Error
+  #* Warning
+  #* ...
+  attr_reader :type
+  #Message text of the message
+  attr_reader :message
+  #Hash with details for the message (special informations...)
+  attr_reader :details
+  #Next page in the generated document. 
+  #The previous page should be the location, where the effect of the error should be visible.
+  attr_reader :page
+  #TeX-Sourcefile. Place, where the error should be corrected.
+  attr_reader :source
+  #Line in the TeX-Sourcefile. Place, where the error should be corrected.
+  #No number, may be something line '621-625'.
+  attr_accessor :line
+  #Line in the log line
+  attr_reader :logline
+  #Sort by line of occurence in the log.
+  def <=> ( mess )
+    @logline <=> mess.logline
+  end
+  #collect additional lines for the message.
+  attr_reader :nextlines
+  #Add the following line(s) to the message
+  def << (logline)
+    @nextlines << logline
+  end
+end #TeXMessage
+
+=begin rdoc
+Get an overview on status of a generated TeX-Project.
+* Analoyse log for
+   *LaTeX
+   *BibTeX if used
+   *makeindex if used
+=end
 class TeX_Statistic
   #Define the main file for the log-analyse.
   def initialize( filename )
     @stat = {}
+    @texmessages = []
 
     @texfile = filename.ext('tex')
     if ! File.exist?(@texfile)
@@ -21,10 +102,10 @@ class TeX_Statistic
 
     #Analyse TeX-log  
     if File.exist?(@texfile.ext('log'))
-      @stat[@texfile.ext('log')] = log_analyse( File.read(@texfile.ext('log')))
+      @texmessages = log_analyse_content( File.read(@texfile.ext('log')),nil,nil)
+      @stat[@texfile.ext('log')] = texmessages2hash(:messages => @texmessages) #option , :page_info ??
     else
-      @stat['_'] ||= {}
-      @stat['_'][:log]  = "No log-file #{File.read(@texfile.ext('log'))} found"
+      @stat[@texfile.ext('log')] ||= [ "No log-file #{@texfile.ext('log')} found" ]
     end #File.exist?(@texfile.ext('log'))
     
     #Analyse BibTeX-log
@@ -39,225 +120,229 @@ class TeX_Statistic
     }
     
   end
-  #
+  #Hash with a status overview on the logs of the TeX-project.
   attr_reader :stat
-  #Analyse the TeX-log file.
-  #
-  #The log-text is splitted into files and pages and analysed separatly.
-  #
-  # ----TESTVERSION----
-  def log_analyse_by_file_page(logfilename)
+  #Array with TeXMessage-object. Contains messages of the TeX-log.
+  attr_reader :texmessages
+
+  #Regexp to detect new pages in result file.
+  #New pages looks like "[1.1\n" or [9.9]
+  PAGE_PATTERN = /^\[(\d+\.\d+)[\]\s]/
+  #Container for some data
+  #* count: numbers of open ( in file, needed to detect end of file
+  #* logcontent: Extract of the log-file, contains only the parts for the actual source file
+  #* logstart: Line in log-file
+  FILEDATA_STRUCT = Struct.new('FILEDATA', :name, :startpage, :logstart, :count, :logcontent )
+
+=begin rdoc  
+Analyse the TeX-log file.
+
+The log-text is splitted into files and pages and analysed separatly.
+
+----TESTVERSION----
+Errors:
+Somewhere is an offset 4 loglines
+=end
+  def log_analyse_by_file(logfilename)
     log = File.read(logfilename)
     stat = {}
+    texmessages = []
+    
 
     #Analyse log for page and source file
     page = nil  #store the actual page
     file   = nil  #store the actual file 
     filestack = []  #
-    filecount = Hash.new(0) #numbers of open ( in file, needed to detect end of file
-    filecontent = {nil => ''}#content of a file. The content of sub-includes are not part of this content.
+    filelist = { nil => FILEDATA_STRUCT.new(nil, 0, 0, 1, '' ) }
+    logline = 0
+    #~ filecount = Hash.new(0) #numbers of open ( in file, needed to detect end of file
+    #~ filestartpage = {}  #Page, where the source is started.
+    #~ filecontent = {nil => ''}#content of a file. The content of sub-includes are not part of this content.
     
-    #New pages looks like "[1.1\n" or [9.9]
-    page_pattern = /^\[(\d+\.\d+)[\]\s]/
     # inputs looks like "(./filename_en.toc \n" or "(./filename.lot)"
-    file_pattern = /\(((?:\.|c:)\/.*?)[\)\n]/
+    file_pattern = %r{\((?:\.|c:)\/.*?[\)\n]}
     
     #Splitt at the file- and page-patterns and at ( and )
     #If the ( ) are balanced, then we can detect a file end with )
     #
-    log.split(/(#{file_pattern}|\(|\)|#{page_pattern})/ ).each{|x|
+    log.split(/(#{file_pattern}|\(|\)|#{PAGE_PATTERN})/ ).each{|x|
+      logline += x.count("\n")
       case x #x[0]
         when file_pattern
           if x[-1,1] == ')'
             #~ puts "open and close #{file} on page #{page} #{filestack.inspect}" if file =~ /^\./
+            filelist[file].logcontent << x
           else
+            filelist[file].logcontent << x
             file = x.strip.sub(/\(/,'')
             filestack << file
-            filecount[file] += 1
-            filecontent[file] = ''
+            filelist[file] = FILEDATA_STRUCT.new(file, page, logline, 1, '' )
             #~ puts "open #{file} on page #{page} #{filestack.inspect}" if file =~ /^\./
           end
-        when page_pattern
+        when PAGE_PATTERN
           page = $1
+#~ if x =~ /76/
+#~ puts x.inspect
+#~ puts page.inspect
+#~ puts logline
+#~ puts file
+#~ end
+          filelist[file].logcontent << x
+          #Add page to all open log collection.
+          #Without this, we would ignore all pages between the insertion of an include.
+          filelist.each{| name, filedata | filedata.logcontent << "\n#{x} ##ADDED to log #{logline + 1}##\n" }
         when '('
-          filecount[file] += 1
-          filecontent[file] << x
-        when ')'        
-          filecount[file] = filecount[file] - 1
-          if filecount[file] == 0
+          filelist[file].count+= 1
+          filelist[file].logcontent << x
+        when ')'
+          filelist[file].count = filelist[file].count - 1
+          if filelist[file].count == 0
             filestack.pop
             #~ puts "close #{file} on page #{page} #{filestack.inspect}" if file =~ /^\./
-            stat = log_analyse_content(filecontent[file], file, page)
+            texmessages.concat(log_analyse_content(filelist[file].logcontent, filelist[file].name, filelist[file].startpage, filelist[file].logstart ))
             if ! stat.empty?
               #hier stats sammeln (je vor/hinter input gab es meldungen)
-              puts '============'
-              puts file
-              puts stat.to_yaml
+              #~ puts '============'
+              #~ puts file
+              #~ puts stat.to_yaml
             end
             #~ filecontent.delete(file)
-            filecontent[file] = ''
+            filelist[file].logcontent = ''
             file = filestack.last
           else
-            filecontent[file] << x
+            filelist[file].logcontent << x
           end
         else
-          filecontent[file] << x
+          filelist[file].logcontent << x
         end
       #~ puts "%6s : %s" % [page, file ]
     }
-    puts filestack.inspect
+    #Get unclear messages (top file?)
+    texmessages.concat(log_analyse_content(filelist[nil].logcontent, filelist[nil].name, filelist[nil].startpage, filelist[nil].logstart ))
+    #~ puts filestack.inspect
+    texmessages
   end
+=begin rdoc
+Analyse the content of an extract of the TeX-log file and
+collect the messages as TeXMessage-objects.
 
-  #Analyse the content of an extract of the TeX-log file.
-  #
-  def log_analyse_content(log, file, page)
-    stat = {}
-    filepage = [" (",
-      file ? "in #{file}" : '',
-      page ? " on page #{page}" : '',
-      ")"].join
-    
-    log.each{|logline|
-      logline.strip!
-      case logline
-        when /Package (.*) Error: (.*)/
-          stat[:package_error] ||= {}
-          stat[:package_error][$1] ||= [] << $2
-          stat[:package_error][$1].last << filepage
-        when /LaTeX Error:\s*(.*)/
-          ( stat[:latex_error] ||= [] ) << $1
-          stat[:latex_error].last << filepage
-        when /Error:/
-          (stat[:error] ||= [] ) << logline
-          stat[:error].last << filepage
-          #~ puts "!#{logline}"
-        when /Package (.*) Warning: (.*)/
-          stat[:package_warning] ||= {}
-          stat[:package_warning][$1] ||= [] << $2
-          stat[:package_warning][$1].last << filepage
-        when /LaTeX Warning:\s*(.*)/
-          (stat[:latex_warning] ||= [] ) << $1
-          stat[:latex_warning].last << filepage
-        when /Warning/
-          #~ puts "!#{logline}"
-          (stat[:warnings] ||= [] ) << logline
-          stat[:warnings].last << filepage
-        #~ when /Package (.*) Info: (.*)/ #A lot of messages
-          #~ stat[:package_info] ||= {}
-          #~ stat[:package_info][$1] ||= [] << $2
-        when /Output written on (.*) \((\d*) pages, (\d*) bytes\)/
-          raise "Double output in #{logfilename}" if stat[:output]
-          stat[:output] = {
-              :name => $1, :pages => $2, :bytes => $3,
-              :kbytes => ($3.to_i / 1024 )
-            }
-        when /Overfull \\hbox \((.*) too wide\) in paragraph at lines (.*)/ 
-          ( stat[:overfull] ||= [] ) << "#{$1} at lines #{$2}"
-          stat[:overfull].last << filepage
-          #~ next if $1.to_i() < @options[:overfull]
-          #~ stat[:overfull] ||= [] << last_message = "#{$1} at lines #{$2}"
-          #~ get_next_lines = 1  #?test
-        when /Underfull (.*box) \(badness (.*)\) (detected|in paragraph) at lines? (.*)/
-          #~ next if $1.to_i() < @options[:underfull]
-          ( stat[:underfull] ||= []  )<< last_message = "badness #{$2} at lines #{$4}"
-          stat[:underfull].last << filepage
-          #~ get_next_lines = 1  #?test
-        else
-          #~ puts " #{logline}"
-        end
-    }
-    stat
-  end #log_analyse
-
-
-  #Analyse the content of a TeX-log file.
-  #
-  def log_analyse(log)
-    stat = {}
-    
-    log.each{|logline|
+file, startpage and logstart are only needed for the splitted analyse to get the initial values.
+=end
+  def log_analyse_content(log, file, startpage, logstart = 0)
+    page = startpage 
+    messages =[]
+    linecorrection = logstart + 1
+    get_next_lines = nil
+    log.each_with_index{|logline, loc_lineno|
       logline.strip!
+      #Check if the message is continued on next line
+      case get_next_lines
+        when Numeric  #Counter to add the next x lines to the previous message
+          messages.last << logline
+          if get_next_lines ==1
+            get_next_lines = nil
+          else
+            get_next_lines = get_next_lines - 1
+          end
+          next
+        when Regexp
+          if logline =~ get_next_lines
+            messages.last << $~.post_match
+            messages.last.line = $1 if logline =~ /on input line (\d+)/
+            next
+          else
+            get_next_lines = nil
+          end
+      end
+      lineno = loc_lineno + linecorrection
       case logline
+        when PAGE_PATTERN
+          page = $1
+          if logline =~ /##ADDED to log (\d+)##/
+            linecorrection = $1.to_i - loc_lineno - 1 #resync the log line number
+          end
         when /Package (.*) Error: (.*)/
-          stat[:package_error] ||= {}
-          stat[:package_error][$1] ||= [] << $2
+          messages << TeXMessage.new(:package_errors, lineno, $2, {:package => $1 }, page, file)
         when /LaTeX Error:\s*(.*)/
-          ( stat[:latex_error] ||= [] ) << $1
+          messages << TeXMessage.new(:latex_errors, lineno, $1, {}, page, file)
         when /Error:/
-          (stat[:error] ||= [] ) << logline
-          #~ puts "!#{logline}"
+          messages << TeXMessage.new(:error, lineno, logline, {}, page, file)
         when /Package (.*) Warning: (.*)/
-          stat[:package_warning] ||= {}
-          stat[:package_warning][$1] ||= [] << $2
+          get_next_lines = /\(#{$1}\)\s*/
+          messages << TeXMessage.new(:package_warnings, lineno, $2, {:package => $1 }, page, file)
         when /LaTeX Warning:\s*(.*)/
-          (stat[:latex_warning] ||= [] ) << $1
+          messages << TeXMessage.new(:latex_warnings, lineno, $1, {}, page, file)
         when /Warning/
-          #~ puts "!#{logline}"
-          (stat[:warnings] ||= [] ) << logline
-        #~ when /Package (.*) Info: (.*)/ #A lot of messages
-          #~ stat[:package_info] ||= {}
-          #~ stat[:package_info][$1] ||= [] << $2
+          messages << TeXMessage.new(:warnings, lineno, logline, {}, page, file)
+        when /Package (.*) Info: (.*)/ #A lot of messages
+          messages << TeXMessage.new(:package_info, lineno, $2, {:package => $1 }, page, file)
         when /Output written on (.*) \((\d*) pages, (\d*) bytes\)/
           raise "Double output in #{logfilename}" if stat[:output]
-          stat[:output] = {
-              :name => $1, :pages => $2, :bytes => $3,
-              :kbytes => ($3.to_i / 1024 )
-            }
+          messages << TeXMessage.new(:output, lineno, logline, {
+                                    :name => $1, :pages => $2, :bytes => $3, :kbytes => ($3.to_i / 1024 )}, 
+                                    page, file)
         when /Overfull \\hbox \((.*) too wide\) in paragraph at lines (.*)/ 
-          ( stat[:overfull] ||= [] ) << "#{$1} at lines #{$2}"
-          #~ next if $1.to_i() < @options[:overfull]
-          #~ stat[:overfull] ||= [] << last_message = "#{$1} at lines #{$2}"
-          #~ get_next_lines = 1  #?test
+          #~ messages << TeXMessage.new(:overfull_boxes, lineno, "#{$1} at lines #{$2}", {:wide => $1.to_i }, page, file, $2)
+          messages << TeXMessage.new(:overfull_boxes, lineno, logline, {:wide => $1.to_i }, page, file, $2)
+          get_next_lines = 1
         when /Underfull (.*box) \(badness (.*)\) (detected|in paragraph) at lines? (.*)/
-          #~ next if $1.to_i() < @options[:underfull]
-          ( stat[:underfull] ||= []  )<< last_message = "badness #{$2} at lines #{$4}"
-          #~ get_next_lines = 1  #?test
+          #~ messages << TeXMessage.new(:underfull_boxes, lineno, "badness #{$2} at lines #{$4}", {:badness => $2.to_i }, page, file, $4)
+          messages << TeXMessage.new(:underfull_boxes, lineno, logline, {:badness => $2.to_i }, page, file, $4)
+          get_next_lines = 1  #oder bis / []/
+        #fixme...
+        when /^!\s*(.*)/ #Undefined control sequence.
+          messages << TeXMessage.new(:latex_errors, lineno, $1, {}, page, file)        
         else
           #~ puts " #{logline}"
         end
     }
-    stat
+    messages
   end #log_analyse
-  #Analyse the BibTeX-Logfile
+  
+=begin rdoc
+Analyse a bibTeX-log.
+=end
   def blg_analyse(logfilename)
       stat = {}
       File.readlines(logfilename).each{ |logline|
         case logline
           when /Database file #(.*): (.*)/
-            stat[:info] ||= [] << "Database file #{$2} used"
+            stat[:source_information] ||= [] << "Database file #{$2} used"
           when  /Warning--I didn't find a database entry for "(.*)"/
-            stat[:warn] ||= [] << "Databaseentry #{$1} missing"
+            ( stat[:warnings] ||= [] ) << "Databaseentry #{$1} missing"
           when  /Warning--Empty definition in (.*)/
-            stat[:warn] ||= [] << "Empty definition #{$1}"
+            ( stat[:warnings] ||= [] ) << "Empty definition #{$1}"
           when  /Warning--(.*)/
-            stat[:warn] ||= [] << "#{$1}"
+            ( stat[:warnings] ||= [] ) << "#{$1}"
           when  /I couldn't open (.*) file (.*)/
-            stat[:error] ||= [] << "#{$1} #{$2} not found"
+            ( stat[:errors] ||= [] ) << "#{$1} #{$2} not found"
           when  /I found no (.*) commands---while reading file(.*)/
-            stat[:warn] ||= [] << "found no #{$1} in #{$2}"			
+            ( stat[:warnings] ||= [] ) << "found no #{$1} in #{$2}"			
           when  /(.*)---line (.*) of file(.*)/
             #line-number ist unsinnig
-            stat[:error] ||= [] << "#{$1} in #{$3}"
+            ( stat[:errors] ||= [] ) << "#{$1} in #{$3}"
         end
       }
       stat
-  end #log_analyse
-  #Analyse the makeindex-log
+  end #blg_analyse
+=begin rdoc
+Analyse the makeindex-log.
+=end
   def ilg_analyse(logfilename)
       stat = {}
       error = nil
       File.readlines(logfilename).each{ |logline|
         if error  #Index error announced in previous line
-          stat[:error] ||= [] << "#{logline.chomp.sub(/.*--/, "")} #{error}"
+          ( stat[:errors] ||= [] ) << "#{logline.chomp.sub(/.*--/, "")} #{error}"
           error = nil
         else
           case logline
           when /Scanning input file (.*)\...done \((.*) entries accepted, (.*) rejected\)./
-            #~ stat[:info] ||= [] << "input file #{$1} (#{$2} entries accepted, #{$3} rejected)"
-            stat[:output] ||= []
-            stat[:output] << "Input file: #{$1}"
-            stat[:output] << "Entries accepted: #{$2}"
-            stat[:output] << "Entries rejected: #{$3}"
+            #~ stat[:source_information] ||= [] << "input file #{$1} (#{$2} entries accepted, #{$3} rejected)"
+            stat[:source_information] ||= []
+            stat[:source_information] << "Input file: #{$1}"
+            stat[:source_information] << "Entries accepted: #{$2}"
+            stat[:source_information] << "Entries rejected: #{$3}"
           #~ when /done \((.*) entries accepted, (.*) rejected\)./
             #~ result[:rejected] += $2.to_i() if $2.to_i() > 0
           when /!! Input index error \(file = (.*), line = (.*)\):/
@@ -267,248 +352,193 @@ class TeX_Statistic
         end #if error
       }
       stat
-  end #log_analyse
+  end #ilg_analyse
+
+=begin rdoc
+Define the defaults for TeX_Statistic#texmessages2hash
+=end
+  Defaults_texmessages2hash = {
+    :messages => :texmessages,  #replaced with @texmessages
+    :page_info => true,
+    :source_info  => false,
+    :loglineno_info => true,
+    :nextlines_info => false,
+  }
   
-  def to_s()
-    <<stat
-#{@texfile}:
-#{@stat.to_yaml}
-stat
-  end
-end #TeX_Statistic
-end #Rake4LaTeX
+=begin rdoc
+Take messages and convert them into a hash for quick analyses.
 
+Options is a hash with flags, which informations should be added.
+Defaults can be seen in Defaults_texmessages2hash.
+=end
+  def texmessages2hash( options )
+    options = Defaults_texmessages2hash.dup.merge(options)
+    options[:messages] = @texmessages if options[:messages] == :texmessages
 
-if $0 == __FILE__
-  require 'rake'
-  #~ puts TeX_Statistic.new('../testdocument.tex')
-  #~ puts TeX_Statistic.new('C:/usr/Festo/_Projects/PriceCatalog/PriceCatalogTool_en.pdf')
-  s = TeX_Statistic.new('logtest_pcat/PriceCatalogTool_en.pdf')
-  #~ puts s.stat['logtest_pcat/PriceCatalogTool_en.log'].to_yaml
-  
-  #Test
-  #~ s.log_analyse_file_page('logtest_pcat/PriceCatalogTool_en.log')
-  s.log_analyse_by_file_page('logtest_pcat/PriceCatalogTool_en.log')
-end
+    #Return-Hash.
+    #Collects the datas.
+    stat = {}
+    options[:messages].sort.each{|mess|
+      text = [ mess.message ]
+      if mess.source and options[:source_info]
+        text <<  " (#{mess.source}#{mess.line ? ":#{mess.line}" : '' })"
+      end
+      text <<  " [page#{mess.page}]" if mess.page and options[:page_info]
+      text <<  " [log##{mess.logline}]" if options[:loglineno_info]
+      text <<  " - #{mess.nextlines}" if options[:nextlines_info]
+      text = text.join()
+        
+      case mess.type
+        when :package_info
+        next
+      when :package_warnings, :package_errors
+        stat[mess.type] ||= {}
+        (stat[mess.type][mess.details[:package]] ||= [] ) << text
+      else
+      ( stat[mess.type] ||= [] ) << text
+      end
+    }
+    stat
+  end  #texmessages2hash
+=begin rdoc
+Build a very quick overview on actual status.
 
-__END__
+Each tool gets one line.
 
-TeX:
-    logfile.each{|logline|
-      #The previous message is continued, get the rest here
-      if get_next_lines > 0
-        get_next_lines -= 1
-        case	logline 
-          #Get the line number
-          when /l\.([0-9]*) (.*)/
-            last_message << " #{$2} (line #{$1})".strip
-            #fixme: get also next line (pdflualatex/invalid utf?)
-          else
-            last_message << " (#{logline.chomp()})"
-        end
-        last_message = nil
-        next  #continue with the next warning/error
-      end #last_message
-      
-      #In case of errors, get the line number where it happens
-      if jump_to_numberline 
-        case	logline 
-          #skip text
-          when /Type  H <return>  for immediate help./,
-                  /^[\.\s]*$/  #empty line
-          #Get the line number
-          when /l\.([0-9]*) (.*)/
-            last_message << " #{$2} (line #{$1})".strip
-            jump_to_numberline = false #numberline reached, continue with log-analyses
-            #fixme: collect text in between?
-          when /See the (.*) package documentation for explanation./
-            last_message << " (package #{$1})"
-          else
-            last_message << " #{logline.strip} ||"
-        end
-        next  #continue with the next warning/error
-      end #jump_to_numberline = true; last_message = result[:error].last
+Example:
+  - "Document: 14 errors, 15 warnings, 44 overfull boxes, 70 underfull boxes (testdocument.log)"
+  - "Bibliography: 1 error (testdocument.blg)"
+  - "Index: 21 entries (testdocument-changes.ilg)"
+  - "Index: 38 entries (testdocument-BMEcat.ilg)"
+  - "Index: 1 error (testdocument-idx.ilg)"
+  - "Index: 139 entries (testdocument-Fields.ilg)"
 
-      last_message = nil
-      $logline = logline  #Only for test surposes
-      case logline
-        when /^! (.*)/
-          case $1
-            #Error messages with line code
-            when /LaTeX Error:\s*(.*)/,
-                    /(Undefined control sequence.)/, 
-                    /(Missing [\$|\{|\}|\\cr] inserted.)/,
-                    /(Dimension too large.)/,
-                    /(Text line contains an invalid utf-8 sequence.)/, #pdflualatex
-                    /(Argument of .* has an extra \})./,
-                    /(Paragraph ended before .* was complete.)/,
-                    /(Misplaced .+)/, 
-                    /(Extra \}, or forgotten [\$|\\\\endgroup])/,
-                    /You can't use `\\\\end' in internal vertical mode/
-                    #~ /(! Emergency stop.)/,
-                    #~ /(! Huge page cannot be shipped out.)/
-                    :last_entry_to_avoid_comma_error
-              result[:error] << last_message = $1
-              jump_to_numberline = true; 
-            #LaTeX-Errors without line.
-            when /(Emergency stop|Huge page cannot be.*)/,
-                    /(File ended while scanning use of .*)/,
-                    /(==> Fatal error occurred, no output PDF file produced!)/
-              result[:error] << last_message = $1            
-            when /Package (.*) Error: (.*)/
-              result[:error] << last_message = "#{$1}.sty:\t#{$2}"
-              jump_to_numberline = true
-            when /Extra alignment tab has been changed to \\cr./
-              result[:error] << last_message = "tabular: wrong alignment"
-            when /pdfTeX warning .*?: (.*)/
-              result[:warning] << last_message = "pdftex: #{$1}"
-            else
-              result[:error] << last_message = "New error to runtex: #{logline.strip}"
-              #~ jump_to_numberline = true; last_message = result[:error].last = result[:error].last
-              @job.log.warn( "#{__FILE__} Uncatched error? <#{$1.inspect}>") if @job.log.warn?
-          end
-        when /(job aborted, no legal \\end found)/, 
-                /(==> Fatal error occurred, no output PDF file produced!)/
-          result[:error] << last_message = $1
-        when /Package gloss Info: Writing gloss file (.*).aux/  #Check for gloss.sty
-          @job << BibTeX.new( @job, :source => "#{$1}.aux", :target => "#{$1}.bbl", :log => "#{$1}.blg" )
-        when /Package hyperref Warning: old toc file detected, not used; run LaTeX again/
-          @job.please_rerun("(old toc)")
-        when /LaTeX Warning: Label(s) may have changed. Rerun to get cross-references right./
-          @job.please_rerun("Labels/Toc changed")
-        when /Package longtable Warning: Table widths have changed. Rerun LaTeX./
-          @job.please_rerun("Longtable requires additional calculation)")
-        when /LaTeX Warning: Label (.*)/
-          result[:label]<< last_message = $1
-        when	/LaTeX Warning: (Reference .*)/
-          result[:label]<< last_message = $1
-        when  /LaTeX Warning: Citation (.*)/
-          result[:citation]<< last_message = $1
-        when  /LaTeX Warning: (.*)/
-          result[:warning] << last_message = $1
-        when	/Package hyperref Warning: (.*)/
-          result[:warning_hyper]<< last_message = "#{$1}"
-        when /Package rail Warning: Railroad diagram \{(\d*)\} doesn't match on input line (\d*)./
-          @job.log.debug( "#{@step} Rerun necessary (Rail diagram #{$1} on line #{$2})") if @job.log.debug?
-          if @job.stop_rerun?(:rail)
-            @job.log.warn( "#{@step} Rail-Rerun blocked by previous error") if @job.log.warn?
-          else
-            @job.please_rerun( "Rail diagram #{$1} on line #{$2} changed")
-            @job << Rail.new( @job, :source => "#{@job.basename}.rai", :target => "#{@job.basename}.rao" )
-          end
-        when /Package rail Warning: Railroad diagram\(s\) may have changed./
-          @job.log.debug( "#{@step} Rerun necessary (Rail diagram changed)") if @job.log.debug?
-          if @job.stop_rerun?(:rail)
-            @job.log.warn( "#{@step} Rail-Rerun blocked by previous error") if @job.log.warn?
-          else          
-            @job.please_rerun( "Rail diagram changed")
-            @job << Rail.new( @job, :source => "#{@job.basename}.rai", :target => "#{@job.basename}.rao"  )
-          end
-        #~ when /Package: rail / #Package: rail 1998/05/19
-          #~ @job.log.debug( "#{@step} Package rail detected") if @job.log.debug?
-          #~ @job << Rail.new( @job ) ??          
-        when /Package (.*) Warning: (.*)/
-          result[:warning] << last_message = "#{$1}:\t#{$2}"
-        when /Using splitted index at (.*)/ ##Find Splittindex
-          @job.log.debug( "#{@step} Found splitindex for #{$1}") if @job.log.debug?
-          @job << Splitindex.new(@job, :source => $1 )
-        #This message is posted, if index2 is used.
-        #I hope the responsible person for index.sty will take my changes.
-        #If the name is very long, there is a break in the Filename.
-        when /Package index2 Info: (.*) (.*)/
-          @job.log.debug( "#{@step} Index #{$1} detected (->#{$2})") if @job.log.debug?
-          @job.log.warn( "#{@step} Warning: Name #{$2} perhaps cutted") if @job.log.warn? and $1.size != $2.size
-          @job << Makeindex.new( @job,
-                                :name => "Index2-#{$1}",
-                                :file_in => $1,  #"#{@job.basename}.idx",
-                                :file_out => $2, #"#{@job.basename}.ind",
-                                :file_log => "#{$1}.ilg"
-                                #~ :format => glossaries_format
-                                )
-        #If you use index.sty:
-        #Unfortenalty there are some missing information to complete the task.
-        #Please use index2.sty
-        when /Writing index file (\S*)/
-          @job.log.debug( "#{@step} Index #{$1} detected") if @job.log.debug?
-                    
-          if $1 == @job.basename + '.idx' #'normal' standard index
-            name = 'Index'
-            format = nil
-            if @job.filename =~ /\.dtx$/
-              name << '/dtx'
-              format = 'gind.ist' 
-            end
-            @job << Makeindex.new( @job,
-                                  :name => name,
-                                  :file_in => "#{@job.basename}.idx",
-                                  :file_out => "#{@job.basename}.ind",
-                                  :file_log => "#{@job.basename}.ilg",
-                                  :format => format
-                                  )
-          else
-            @job.log.warn( "#{@step} Warning: index.sty is not supported, please use index2 (#{$1})") if @job.log.warn?
-            @job.helpfiles << $1
-          end
-        #This message is created by 
-        #- glossaries (-> already catched by aux-analyses)
-        #- ltxdoc.cls (for dtx.files)
-        when /Writing glossary file (\S*)/
-          glossfile = $1
-          @job.log.debug( "#{@step} Glossary #{glossfile} detected") if @job.log.debug?
-          
-          if @job.filename =~ /\.dtx$/ and glossfile =~ /.glo$/  #ltxdoc.cls 
-              @job << Makeindex.new( @job,
-                                    :name => 'Glossary/dtx',
-                                    :file_in => glossfile,
-                                    :file_out => "#{@job.basename}.gls",
-                                    :file_log => "#{@job.basename}.glg",
-                                    :format => 'gglo.ist'
-                                    )
-          else
-            #Possible with usage of glossaries.sty -> catched by aux-analyses
-            @job.log.debug( "#{@step} Glossary in non-dtx found #{glossfile}") if @job.log.debug?
+=end
+  def stat_summary()
+    result = []
+    @stat.each{|key, values|
+      stat = {}
+      values.each{|logkey,logvalues|
+        stat[key] ||= []
+        case logkey
+          when :source_information, :output
+            logvalues.each{|mess|
+              case mess
+                when /Entries accepted: (\d*)/
+                  stat[:ok] = $1.to_i unless $1 == '0'
+                when /Entries rejected: (\d*)/
+                  stat[:reject] = $1.to_i unless $1 == '0'
+                when /Database file (.+) used/
+                  ( stat[:source] ||= [] ) << $1
+                when /Output written on .* \((\d*) pages, (\d*) bytes\)/
+                  stat[:pages] = $1.to_i
+                when /Input file:/
+                else
+                  #~ puts mess.inspect
+              end
+            }
+          when String
+            #~ stat[key] = logkey
+            puts logkey.inspect
+            raise "?Undefined String-Handling in stat_overview"
+          else  #count messages
+            stat[logkey] = logvalues.size
           end
-        #Add minitocs to helpfiles
-        when /\(minitoc\)\s*Writing (.*\.mtc\d*)/
-          @job.log.debug( "#{@step} Found minitoc-helpfile") if @job.log.debug?
-          @job.helpfiles << $1
-        when /Output written on (.*) \((.*) pages?, (.*) bytes\)/
-          result[:file]	= $1
-          result[:pages]	= $2.to_i
-          result[:size]	= "#{$3.to_i / 1024}KB"
+      } #values
+      
+      #Build summary line
+      summary = []
+      if stat[:pages]
+        summary << "#{stat[:pages]} page" 
+        summary.last << "s" if stat[:pages] > 1
+      end
+      if stat[:source]
+        summary << "Used #{stat[:source].join(', ')}" 
+      end
+      errors = (stat[:error] ? stat[:error] : 0 ) + 
+                  (stat[:latex_errors] ? stat[:latex_errors] : 0 ) + 
+                  (stat[:package_errors] ? stat[:package_errors] : 0 )
+      if errors > 0
+        summary << "#{errors} error" 
+        summary.last << 's' if errors > 1
+      end
+      case stat[:ok]
+        when 0, nil #no report
+        when 1; summary << "#{stat[:ok]} entry" 
+        else; summary << "#{stat[:ok]} entries" 
+      end
+      case stat[:reject]
+        when 0, nil
+        when 1; summary << "#{stat[:reject]} rejected entry" 
+        else; summary << "#{stat[:reject]} rejected entries"       
+      end
           
-          filedata = []
-          filedata << "#{result[:file]}"
-          filedata << "#{result[:pages]} Page#{'s' if result[:pages] > 1}" if result[:pages]
-          filedata << result[:size] if result[:size]
-          filedata << "#{result[:error].size} Error#{'s' if result[:error].size > 1}" unless result[:error].empty?
-          filedata << "#{result[:overfull].size} Overfull box#{'es' if result[:overfull].size > 1} (> #{@options[:overfull]})" unless result[:overfull].empty?
-          filedata << "#{result[:underfull].size} Underfull box#{'es' if result[:underfull].size > 1} (> #{@options[:underfull]})" unless result[:underfull].empty?
-          #~ result[:fileinfo] = "#{result[:file]} (#{filedata.join(', ')})" unless filedata.empty?
-          result[:fileinfo] = filedata
-          last_message = nil
-        end #case logline
-    } #each.loglines
-    return result
-  end #analyse_logfile
-
-
-Rail:
-    stderr.each{ |errline|
-      case errline
-        when /(.*), line (.*): (.*)/
-          #$1: Filename (e.g. 'stdin')
-          @result[:error] << "Line #{$2}: #{$3}"
-          @job.stop_rerun( :rail, "Rail: #{$3} on line #{$2}")   #block rerun for rail
+      warnings = (stat[:warnings] ? stat[:warnings] : 0 ) + 
+                      (stat[:latex_warnings] ? stat[:latex_warnings] : 0 ) + 
+                      (stat[:package_warnings] ? stat[:package_warnings] : 0 )
+      if warnings > 0
+        summary << "#{warnings} warning" 
+        summary.last << 's' if warnings > 1
       end
-    }
-    
-    stdout.each{ |stdout_line|
-      case stdout_line
-      when /This is Rail, Version (.*)\s/
-        @result[:info] << "Rail version #{$1} was called"
-      when /(Der Prozess kann nicht auf die Datei zugreifen, .*)/
-        @result[:error] << "#{$1}"
+      if stat[:overfull_boxes]
+        summary << "#{stat[:overfull_boxes]} overfull box"
+        summary.last << 'es' if stat[:overfull_boxes] > 1
       end
-    }
+      if stat[:underfull_boxes]
+        summary << "#{stat[:underfull_boxes]} underfull box" 
+        summary.last << 'es' if stat[:underfull_boxes] > 1
+      end
+      
+      #Put summary to result-array
+      #The result contains a sort-number, which is deleted in the end
+      case key
+        when /log\Z/; result << "%-13s: %s (%s)" % [ '1Document', summary.join(', '), key]
+        when /blg\Z/; result << "%-13s: %s (%s)" % [ '2Bibliography', summary.join(', '), key]
+        when /ilg\Z/; result <<  "%-13s: %s (%s)" % [ '3Index', summary.join(', '), key]
+        else
+          #fixme
+          puts "#{__FILE__}##{__LINE__}: Unknown #{key}"
+          result << "?? #{key}: #{summary.join(', ') }"
+      end      
+    } #@stat
+    #Retrun the result in the wanted order, but without the sort-number.
+    result.sort.map{|e| e[1..-1] }
+  end
+=begin rdoc
+Build a more complex overview.
+Contains:
+* Summary (method #stat_summary)
+* All errors and warnings from TeX and the tools.
+* A detailed analyses for the TeX-log (including some buge in the analyse).
+=end
+  def overview()
+    overview = []
+    overview << "Log-overview for #{@texfile}"
+    overview << stat_summary.map{|e| "  #{e}"} 
+    overview << stat.to_yaml
+    #And the TeX-errors in details (buggy)
+    overview << "========\n   Detailed analyse of #{@texfile.ext('log')}\n========"
+    overview << "###########\n##The following list may contain wrong line assignments\n###########"
+    overview << texmessages2hash({
+                  :messages => log_analyse_by_file(@texfile.ext('log')),
+                  :page_info => true,   #add page information
+                  :loglineno_info => true,
+                  :nextlines_info => true,
+                  :source_info => true, #add source code information, only in log_analyse_by_file_page
+                }).to_yaml
+    overview.join("\n")
+  end #overview()
+  
+=begin rdoc
+Return a quick overview. See stat_overview()
+=end
+  def to_s()
+    stat_overview()
+  end
+end #TeX_Statistic
+end #Rake4LaTeX
+
 
+#~ if $0 == __FILE__
+  #~ Dir.chdir('../../test/'){  require 'test_tex_statistic.rb' }
+#~ end