runtex 0.2.1

data/lib/runtex_latex.rb

@@ -0,0 +1,373 @@
+#
+# This file is part of the runtex-bundle
+#
+module RunTeX
+
+# This class provides (pdf|Xe|Lua)LaTeX.
+class LaTeX < Tool
+  #Create a LaTeX-instance.
+  #
+  #The format is part of the options.
+  def initialize(job, options = {})
+    super(job, options, { :format => :pdflualatex,
+                                  :overfull => 100,
+                                  :underfull => 10000
+                                })
+    @options.keys.each{|key|
+      case key
+        when :format
+          if ! Job_chain::Configuration["#{@options[key]}"]
+            @job.log.error( "#{@step} #{self.class}: Unknown format #{@options[key]}" ) if @job.log.error?
+            @options[key] = :pdflualatex
+          end
+        when :overfull, :underfull
+          @job.log.error( "#{@step} #{self.class}: option #{key} no integer" ) if @job.log.error? and ! @options[key].is_a?(Fixnum)
+        else
+          @job.log.error( "#{@step} #{self.class}: Unknown option #{key}" ) if @job.log.error?
+      end
+    }
+  end
+  #
+  #Call LaTeX and analyse the aux+logfile for additional tools.
+  def execute( step )
+    super(step)
+    
+    auxfilename = "#{@job.basename}.aux"
+    logfilename = "#{@job.basename}.log"
+    
+    #Read AUX-File if available    
+    if File.exist?(auxfilename)
+      @job.add2zip( auxfilename )
+      auxfile_old = File.readlines(auxfilename)
+    end
+
+    #Build command line to call LaTeX
+    cmd = build_cmd(@options[:format], :filename => @job.filename)
+    
+    @job.log.debug( "#{@step} Start LaTeX #{cmd}") if @job.log.debug?
+    STDOUT.flush
+    stdout, stderr = catch_screen_output{ `#{cmd}` }
+    @job.log.debug( "#{@step} LaTeX finished") if @job.log.debug?
+    STDOUT.flush
+
+    #Read AUX-File if available    
+    if File.exist?(auxfilename)
+      @job.add2zip( auxfilename )
+      auxfile_new = File.readlines(auxfilename)
+      analyse_auxfile(auxfile_new)
+      @job.helpfiles << auxfilename
+    end
+
+    #Fill more helpfiles...
+    %w{out toc lof lot lox nav}.each{|ext|
+      @job.helpfiles << "#{@job.basename}.#{ext}"
+    }
+
+    #Read log-File if available
+    if File.exist?(logfilename)
+      @job.add2zip( logfilename )
+      @job.logfiles << logfilename
+      result = analyse_logfile(File.readlines(logfilename))
+    else
+      @job.log.error( "#{@step} Log-file #{logfilename} not found") if @job.log.error?
+    end
+    
+    
+    if auxfile_new != auxfile_old
+      @job.log.debug( "#{@step} Aux.file changed -> New TeX run") if @job.log.debug?
+      @job.please_rerun('Aux-File changed')
+    end
+    
+    return result
+  end #LaTeX#execute
+
+  MAKEINDEX_PARAMETERS = Struct.new('Makeindex', :name, :log, :out, :in)
+  #
+  #Easy check: If the data changed (aux-File) a rerun is necesary.
+  #
+  #Analyse the AUX-File to detect:
+  #- glossaries  from glossaries.sty (-> makeindex)
+  def analyse_auxfile(auxfile)
+    
+    @job.log.debug( "#{@step} Analyse aux-file") if @job.log.debug?
+    makeindex = []
+    glossaries_format = nil
+    auxfile.each{|auxline|
+      case auxline
+        when /bibdata/  #Check for Standard bibliography
+          @job << BibTeX.new( @job, :source => "#{@job.basename}.aux", :target => "#{@job.basename}.bbl" )
+        #Example: \@newglossary{main}{glg}{gls}{glo}
+        when /\\@newglossary\{(.+)\}\{(.+)\}\{(.+)\}\{(.+)\}/
+          @job.log.debug( "#{@step} Find glossary #{$1}") if @job.log.debug?          
+          makeindex << MAKEINDEX_PARAMETERS.new( $1, $2, $3, $4)
+        when /\\@istfilename\{(.+)\}/
+          glossaries_format = $1
+      end
+    }
+
+    makeindex.each{|idx|
+      if File.exist?("#{@job.basename}.#{idx.in}")
+        @job << Makeindex.new(
+          @job,
+          :name => ( idx.name == 'main' ? 'main glossary' : idx.name),
+          :file_in => "#{@job.basename}.#{idx.in}",
+          :file_out => "#{@job.basename}.#{idx.out}",
+          :file_log => "#{@job.basename}.#{idx.log}",
+          :format => glossaries_format
+          )
+      else
+        #Can happen, if defined, but no entries for the group are used.
+        @job.log.debug( "#{@step} glossaries.sty-entry #{idx.name} without entries") if @job.log.debug?        
+      end
+    }
+  end #analyse_auxfile
+
+  #Analyse logfile
+  #1. Check the log-File if an additional run is necessary.
+  #	- references
+  #	- longtable.sty: balancing not finished
+  #2. Check different Tools if they must be active and if they force an additional run
+  #	- BibTeX (bibliography)
+  #	- makeindex (including multiind, glossaries)
+  #	- rail-Diagramms
+  def analyse_logfile(logfile)
+    @job.log.debug( "#{@step} Analyse log-file") if @job.log.debug?
+    result = {	
+            :error		=> [],
+            :warning	=> [],
+            :warning_hyper	=> [],
+            :label	=> [],
+            :citation	=> [],
+            :overfull	=> [],
+            :underfull	=> [],
+        }
+    
+    #
+    #Help to test: Detect empty insertions
+    #
+    #~ class << result[:error]
+      #~ alias :oldpush :push
+      #~ def push (x)
+        #~ raise "Add nil-element (#{$logline.strip})" unless x
+        #~ oldpush(x)
+      #~ end
+      #~ alias :oldgg <<
+      #~ def << (x)
+        #~ raise "Add nil-element(#{$logline.strip})" unless x
+        #~ oldgg(x)
+      #~ end
+    #~ end
+
+    
+    #Flag for continued messages
+    last_message = nil
+    get_next_lines = 0  #Number of lines, which should be added to last_message
+    jump_to_numberline = false
+    
+    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 \$ 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 \$)/,
+                    #~ /(! 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 /Overfull \\hbox \((.*) too wide\) in paragraph at lines (.*)/ 
+          next if $1.to_i() < @options[:overfull]
+          result[:overfull] << last_message = "#{$1} at lines #{$2}"
+          get_next_lines = 1  #?test
+        when /Underfull (.*box) \(badness (.*)\) detected at line (.*)/
+          next if $1.to_i() < @options[:underfull]
+          result[:underfull] << last_message = "badness #{$2} at lines #{$3}"
+          get_next_lines = 1  #?test
+        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
+        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
+  #Used in logger
+  def inspect()
+    "(La)TeX<#{@options[:format]}>"
+  end
+
+end #LaTeX
+end #module RunTeX

data/lib/runtex_makeindex.rb

@@ -0,0 +1,114 @@
+#
+# This file is part of the runtex-bundle
+#
+
+module RunTeX
+#
+# Makeindex is used by the standard LaTeX and by 
+#- index.sty (part of camel)
+#- glossaries.sty
+#
+class Makeindex< Tool
+  def initialize(job, options = {})
+    super(job, options,
+        :file_in => "#{job.basename}.idx",
+        :file_out => "#{job.basename}.ind",
+        :file_log => "#{job.basename}.ilg"
+      )
+    @options.keys.each{|key|
+      case key
+        when :file_in   # normally idx
+        when :file_out # normally ind
+        when :file_log # normally ilg
+        when :format
+        when :name
+        else
+          @job.log.error( "#{self.class}: Unknown option #{key}" ) if @job.log.error?
+      end
+    }
+  end
+  #Start makeindex 
+  def execute( step )
+    super(step)
+    @result = {	
+            :error		=> [],
+            :info	=> [],
+        }
+    
+    #Get existing index-data first
+    if File.exist?( @options[:file_out] )
+      @job.add2zip( @options[:file_out] )
+      ind_old = File.readlines( @options[:file_out] )
+    end
+    
+    #Build the call for makeindex
+    cmd = build_cmd('makeindex')
+    #~ cmd = build_cmd('makeindex', @options) )
+    @job.log.debug( "#{@step} Start Makeindex: #{cmd}") if @job.log.debug?
+    STDOUT.flush
+    
+    #Execute makeindex
+    subrc = nil
+    stdout, stderr = catch_screen_output{ subrc = system(cmd) }
+    @job.log.error( "#{@step} Error Makeindex: #{cmd}") if !subrc and @job.log.error?
+
+    if File.exist?( @options[:file_out] )
+      @job.add2zip( @options[:file_out] )
+      ind_new = File.readlines( @options[:file_out] )
+    end
+
+    @job.logfiles   << @options[:file_log]
+    @job.helpfiles  << @options[:file_in]
+    @job.helpfiles  << @options[:file_out]
+
+
+    if ind_old != ind_new
+      @job.please_rerun("Index #{@options[:file_out]} changed")
+    end
+
+    if File.exist?( @options[:file_log] )
+      @job.add2zip( @options[:file_log] )
+      @result = analyse_log( File.readlines( @options[:file_log] ) )
+    else
+      @job.log.error( "#{@step} Error Makeindex: No log #{@options[:file_log]}") if @job.log.error?
+      @result[:error] << "Error Makeindex: No log #{@options[:file_log]}"
+    end
+
+    return @result
+  end #Makeindex#execute()
+
+  #Analyse the makeindex-log
+  def analyse_log( logdata )
+    @job.log.debug( "#{@step} Analyse log-file") if @job.log.debug?
+    result = {	
+            :error		=> [],
+            #~ :warning	=> [],
+            :info	=> [],
+            :rejected => 0,
+        }
+    error = nil
+    logdata.each{ |logline|
+      if error  #Index error
+        result[:error] << "#{logline.chomp.sub(/.*--/, "")} #{error}"
+        error = nil
+      else
+        case logline
+        when /Scanning input file (.*)\...done \((.*) entries accepted, (.*) rejected\)./
+          result[:info] << "input file #{$1} (#{$2} entries accepted, #{$3} rejected)"
+        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 #case logline
+      end #if error
+    }
+    result[:error] << "#{logline.chomp.sub(/.*--/, "")} #{error}" if error
+    return result
+  end #analyse_log( logdata )
+  #Used in logger
+  def inspect()
+    "Makeindex<#{@options[:name]}>"
+  end
+end #Makeindex
+end #module RunTeX