rake4latex 0.0.1

data/lib/rake4latex/splitindex.rb

@@ -0,0 +1,88 @@
+#
+#Checks for a given idx-file if splitindx is used.
+#
+class Splitindex
+  def initialize( idx_basename, logger )
+    @basename = idx_basename
+    @logger = logger
+    
+    
+    if ! File.exist?( @basename )
+      @logger.error("Error: No idx-file for splitindex (#{@basename})")
+      @indices = ['idx']
+      return 
+    end
+    
+    @targets =  {}
+    #Example:
+    #~ \indexentry[Fields]{MANDT!MARA|hyperpage}{4}
+    #~ \indexentry[DataElement]{MANDT!MARA-MANDT|hyperpage}{4}    
+    File.readlines(@basename).each{|idx_line|
+      case idx_line
+        when /\indexentry\[(.+?)\]\{(.+?)\}\{(.+?)\}/
+          @targets[$1]  ||= [] << "\\indexentry{#{$2}}{#{$3}}"
+        when /\indexentry\{(.+?)\}\{(.+?)\}/
+          @targets['idx']  ||= [] << "\\indexentry{#{$1}}{#{$2}}"
+      end
+    } #File.readlines(@basename)
+
+    @indices = ( @targets.keys << 'idx' ).uniq!
+  end
+  #
+  #Flag if it is no splitindex, but a  "normal" index for makeindex.
+  def makeindex?() 
+    @indices.size == 1  #idx always added
+  end
+  #Actions:
+  #* Build the splitted idx-files
+  #* add the help files to CLEAN
+  #* call makeindex for each file
+  def execute()
+    @logger.error("Splitindex#execute for normal index") if makeindex? and @logger.info?
+    @logger.info("Build splitindex-files for #{@targets.keys.inspect}") if @logger.info?
+    @targets.each{|target, content|
+      idxname = @basename.sub(/\.idx$/, "-#{target}.idx")
+      @logger.debug("Build Split-index #{target} (#{idxname})")
+      File.open(idxname, 'w'){| idx |
+        idx << content.join("\n")
+      }
+      CLEAN << idxname
+      CLEAN << idxname.ext('ind')
+      CLEAN << idxname.ext('ilg')
+      call_makeindex( idxname )
+    }
+  end
+  #
+  #Call makeindex for the given idx-file
+  def call_makeindex( idxname )
+      stdout, stderr = catch_screen_output{ 
+        puts `makeindex #{idxname}`
+      }
+      if $? != 0
+        @logger.fatal("There where Makeindex errors. for #{idxname}\n#{stderr}")
+      end
+  end #call_makeindex()
+  #~ #Loop on index names.
+  #~ def each_idxname()
+    #~ idxnames = []
+    #~ @indices.each{|index|  #\jobname-index.idx
+      #~ idxnames << @basename.sub(/\.idx$/, "-#{index}.idx")
+      #~ yield index if block_given?
+    #~ }
+    #~ idxnames
+  #~ end
+end #Splitindex
+
+__END__
+    #Get existing index-data first
+   
+
+      #Call makeindex for each element
+      #~ @job << Makeindex.new( @job,
+                      #~ :name => "Sub-Index #{target}",
+                      #~ :file_in => "#{@job.basename}-#{target}.idx",
+                      #~ :file_out => "#{@job.basename}-#{target}.ind",
+                      #~ :file_log => "#{@job.basename}-#{target}.ilg"
+                      #~ :format => glossaries_format
+                      #~ )
+    #~ }

data/lib/rake4latex/tex_statistic.rb

@@ -0,0 +1,509 @@
+=begin rdoc
+Build a quick overview on the logs for TeX-runs
+=end
+
+
+require 'knut_yaml' #fixme
+
+class TeX_Statistic
+  #Define the main file for the log-analyse.
+  def initialize( filename )
+    @stat = {}
+
+    @texfile = filename.ext('tex')
+    if ! File.exist?(@texfile)
+      @stat['_'] ||= {}
+      @stat['_'][:tex]  = "No TeX File #{@texfile} found"
+    end
+
+    #Analyse TeX-log  
+    if File.exist?(@texfile.ext('log'))
+      @stat[@texfile.ext('log')] = log_analyse( File.read(@texfile.ext('log')))
+    else
+      @stat['_'] ||= {}
+      @stat['_'][:log]  = "No log-file #{File.read(@texfile.ext('log'))} found"
+    end #File.exist?(@texfile.ext('log'))
+    
+    #Analyse BibTeX-log
+    if File.exist?(@texfile.ext('blg'))
+      @stat[@texfile.ext('blg')] = blg_analyse(@texfile.ext('blg'))
+    end #File.exist?(@texfile.ext('log'))
+    
+    #Analyse index-logs (multiple possible with splitindex)
+    #Example for dirpattern: testdokument{-*,}.ilg
+    Dir["#{@texfile.ext}{-*,}".ext('ilg')].each{|ilg_filename|
+      @stat[ilg_filename] = ilg_analyse(ilg_filename)
+    }
+    
+  end
+  #
+  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)
+    log = File.read(logfilename)
+    stat = {}
+
+    #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.
+    
+    #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]/
+    
+    #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|
+      case x #x[0]
+        when file_pattern
+          if x[-1,1] == ')'
+            #~ puts "open and close #{file} on page #{page} #{filestack.inspect}" if file =~ /^\./
+          else
+            file = x.strip.sub(/\(/,'')
+            filestack << file
+            filecount[file] += 1
+            filecontent[file] = ''
+            #~ puts "open #{file} on page #{page} #{filestack.inspect}" if file =~ /^\./
+          end
+        when page_pattern
+          page = $1
+        when '('
+          filecount[file] += 1
+          filecontent[file] << x
+        when ')'        
+          filecount[file] = filecount[file] - 1
+          if filecount[file] == 0
+            filestack.pop
+            #~ puts "close #{file} on page #{page} #{filestack.inspect}" if file =~ /^\./
+            stat = log_analyse_content(filecontent[file], file, page)
+            if ! stat.empty?
+              #hier stats sammeln (je vor/hinter input gab es meldungen)
+              puts '============'
+              puts file
+              puts stat.to_yaml
+            end
+            #~ filecontent.delete(file)
+            filecontent[file] = ''
+            file = filestack.last
+          else
+            filecontent[file] << x
+          end
+        else
+          filecontent[file] << x
+        end
+      #~ puts "%6s : %s" % [page, file ]
+    }
+    puts filestack.inspect
+  end
+
+  #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|
+      logline.strip!
+      case logline
+        when /Package (.*) Error: (.*)/
+          stat[:package_error] ||= {}
+          stat[:package_error][$1] ||= [] << $2
+        when /LaTeX Error:\s*(.*)/
+          ( stat[:latex_error] ||= [] ) << $1
+        when /Error:/
+          (stat[:error] ||= [] ) << logline
+          #~ puts "!#{logline}"
+        when /Package (.*) Warning: (.*)/
+          stat[:package_warning] ||= {}
+          stat[:package_warning][$1] ||= [] << $2
+        when /LaTeX Warning:\s*(.*)/
+          (stat[:latex_warning] ||= [] ) << $1
+        when /Warning/
+          #~ puts "!#{logline}"
+          (stat[:warnings] ||= [] ) << logline
+        #~ 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}"
+          #~ 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}"
+          #~ get_next_lines = 1  #?test
+        else
+          #~ puts " #{logline}"
+        end
+    }
+    stat
+  end #log_analyse
+  #Analyse the BibTeX-Logfile
+  def blg_analyse(logfilename)
+      stat = {}
+      File.readlines(logfilename).each{ |logline|
+        case logline
+          when /Database file #(.*): (.*)/
+            stat[:info] ||= [] << "Database file #{$2} used"
+          when  /Warning--I didn't find a database entry for "(.*)"/
+            stat[:warn] ||= [] << "Databaseentry #{$1} missing"
+          when  /Warning--Empty definition in (.*)/
+            stat[:warn] ||= [] << "Empty definition #{$1}"
+          when  /Warning--(.*)/
+            stat[:warn] ||= [] << "#{$1}"
+          when  /I couldn't open (.*) file (.*)/
+            stat[:error] ||= [] << "#{$1} #{$2} not found"
+          when  /I found no (.*) commands---while reading file(.*)/
+            stat[:warn] ||= [] << "found no #{$1} in #{$2}"			
+          when  /(.*)---line (.*) of file(.*)/
+            #line-number ist unsinnig
+            stat[:error] ||= [] << "#{$1} in #{$3}"
+        end
+      }
+      stat
+  end #log_analyse
+  #Analyse the makeindex-log
+  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}"
+          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}"
+          #~ when /done \((.*) entries accepted, (.*) rejected\)./
+            #~ result[:rejected] += $2.to_i() if $2.to_i() > 0
+          when /!! Input index error \(file = (.*), line = (.*)\):/
+            #Error-message on next line
+            error = "(file #{$1} line #{$2}: #{logline})"
+          end
+        end #if error
+      }
+      stat
+  end #log_analyse
+  
+  def to_s()
+    <<stat
+#{@texfile}:
+#{@stat.to_yaml}
+stat
+  end
+end #TeX_Statistic
+
+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
+
+__END__
+
+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
+
+      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
+        #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"
+          
+          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
+      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}"
+      end
+    }
+