runtex 0.2.1

data/lib/runtex_bibtex.rb

@@ -0,0 +1,111 @@
+#
+# This file is part of the runtex-bundle
+#
+
+module RunTeX
+#Actions to handle bibliographies with bibTeX.
+#
+#Also supported:
+#Glossaries with gloss.sty. 
+#Instead gloss.sty I recommend glossaries.sty (uses makeindex/xindy).
+#
+class BibTeX < Tool
+  def initialize(job, options = {})
+    super(job, options, 
+          :source => "#{job.basename}.aux",
+          :target => "#{job.basename}.bbl",
+          :log => "#{job.basename}.blg"
+        )
+    @options.keys.each{|key|
+      case key
+        when :source
+          if @options[:source] !~ /\.aux/
+            @job.log.error( "#{@step} #{self.class}: Source is no aux-file (#{@options[:source]})" ) if @job.log.error?
+          end
+        when :target
+          if @options[:target] !~ /\.bbl/
+            @job.log.error( "#{@step} #{self.class}: Target is no bbl-file (#{@options[:target]})" ) if @job.log.error?
+          end
+        when :log
+          if @options[:log] !~ /\.blg/
+            @job.log.error( "#{@step} #{self.class}: Log is no blg-file (#{@options[:log]})" ) if @job.log.error?
+          end
+        else
+          @job.log.error( "#{@step} #{self.class}: Unknown option #{key}" ) if @job.log.error?
+      end
+    }
+  end #initialize
+  #Take the aux-file (source) and create the bbl-file.
+  def execute( step )
+    super(step)
+    @result = {	
+            :error		=> [],
+            :warning	=> [],
+            :info	=> [],
+        }
+    #~ Logger.add( 5, self.class, "Execute #{Configuration.bibtex}for \"#{@filename}\"" )
+    if File.exist?( @options[:source])
+      @job.add2zip( @options[:source] )
+    end
+    if File.exist?( @options[:target])
+      @job.add2zip( @options[:target] )
+      bblold = File.readlines(@options[:target])
+    end
+    
+    subrc = nil
+    cmd = build_cmd('bibtex', @options)
+    @job.log.debug( "#{@step} Call #{cmd}") if @job.log.debug?
+    stdout, stderr = catch_screen_output{    subrc = system( cmd ) }
+    #~ Logger.add_file( @filename + '.blg' ) if @logInclude
+    if ! subrc
+      @job.log.error( "#{@step} Error executing #{cmd}")
+    end
+    if File.exist?( @options[:target])
+      @job.add2zip( @options[:target] )
+      bblnew = File.readlines(@options[:target])
+    else
+      @job.log.error( "#{@step} No result after executing #{cmd}")
+    end
+    if bblold != bblnew
+      @job.please_rerun('Bibliography changed')
+    end
+ 
+    @job.helpfiles << @options[:source]
+    @job.helpfiles << @options[:target]
+    @job.helpfiles << "#{@job.basename}-blx.bib"  #This is an auxiliary file used by the 'biblatex' package.
+    @job.logfiles << @options[:log]
+    
+    
+    if File.exist?( @options[:log])
+      @job.add2zip( @options[:log] )
+      File.readlines(@options[:log]).each{ |logline|
+        case logline
+          when /Database file #(.*): (.*)/
+            @result[:info] << "Database file #{$2} used"
+          when  /Warning--I didn't find a database entry for "(.*)"/
+            @result[:warning] << "Databaseentry #{$1} missing"
+          #~ when  /Warning--Empty definition in (.*)/
+            #~ result[:warning] << "Empty definition #{$1}"
+          when  /Warning--(.*)/
+            @result[:warning] << "#{$1}"
+          when  /I couldn't open (.*) file (.*)/
+            @result[:error] << "#{$1} #{$2} not found"
+          when  /I found no (.*) commands---while reading file(.*)/
+            @result[:warning] << "found no #{$1} in #{$2}"			
+          when  /(.*)---line (.*) of file(.*)/
+            #line-number ist unsinnig
+            @result[:error] << "#{$1} in #{$3}"
+        end
+      }
+    else
+      @job.log.error( "#{@step} No BibTeX-Log found #{@options[:log]}")
+    end
+    return @result
+  end #execute
+  #Used in logger
+  def inspect()
+    "BibTeX<#{@options[:target]}>"
+  end
+end #BibTeX 
+
+end #module RunTeX

data/lib/runtex_job_chain.rb

@@ -0,0 +1,371 @@
+#
+# This file is part of the runtex-bundle
+#
+
+module RunTeX
+
+# This class defines a process chain to translate a tex-File.
+#
+# The process chain starts with a TeX-tool (LaTeX, TeX, PDFLaTeX...).
+#
+# Postprocessors (dvi2ps, ps2pdf...) can be integrated here
+class Job_chain
+
+  #
+  MAX_TEX_RUN = 5 #Stop for infinite TeX-runs
+  #The configuration defines:
+  #- the programm to call
+  #- post processes
+  File.open(RunTeX::CONFIGURATION){|f|
+    Configuration = YAML.load(f)
+  }
+  #Default options for TeX-Jobs.
+  #Used by Job_chain#new and Job_chain#help.
+  DEFAULT_OPTIONS = {
+      :format             => :pdflatex,
+      :delete_logfiles   => true,
+      :delete_helpfiles => true,
+      :zip_helpfiles      => true,
+      :keep_summary   => true,
+      :overfull => 100, #report overfull boxes > this value
+      :underfull => 9000, #report underfull boxes > this badness
+    }
+    
+  def self.help()
+    return <<help
+Help for RunTeX::Jobchain
+Codeexample>>>>>Start>>>>>>>
+require 'runtex'
+#~ puts RunTeX::Job_chain.help()
+tex = RunTeX::Job_chain.new('filename', {
+#{DEFAULT_OPTIONS.map{|key, value| "    #{key.inspect} => #{value.inspect}" }.join(",\n")}}
+  })
+tex.start  
+require 'runtex'
+#~ tex.start( 'pdflatex' )
+Codeexample<<<<<<End<<<<<<<
+help
+#~ Available formats and programms:
+#~ #{Configuration.keys.map{|k| k =~ /tex/ ? k : nil }.compact.to_yaml}
+  end
+  
+
+  #
+  #Create a job and define the parameters.
+  #To execute it, use Job_chain#start()
+  def initialize( filename, options = {} )
+    @options = DEFAULT_OPTIONS.merge(options)
+       
+    @logfiles   = []
+    @helpfiles  = []
+    
+    @log = Log4r::Logger.new( File.basename(filename) )
+    @log.level = Log4r::DEBUG
+    @log.outputters = Log4r::StdoutOutputter.new('log_stdout', :level => Log4r::INFO )
+    @logfiles << "#{filename}.runtex.log"
+    @log.add(Log4r::FileOutputter.new('log_file', :filename => "#{@logfiles.last}", :level => Log4r::DEBUG ) )
+
+    self.file= filename
+    
+    (options.keys - DEFAULT_OPTIONS.keys).each{|key|
+      @log.warn( "#{self.inspect}: Unknown option-key #{key}" ) if @log.warn?
+    }
+
+  end
+  #Main document. This document is to be converted.
+  attr_reader :filename
+  #Main document without extension.
+  attr_reader :basename
+  #List with log-files. Used for Job_chain#delete_helpfiles
+  attr_reader :logfiles
+  #List with help-files. Used for Job_chain#delete_helpfiles
+  attr_reader :helpfiles
+  
+  #Define the TeX-file 
+  def file=( filename )
+    @dirname = File.dirname( filename)
+    @filename = File.basename( filename ) 
+    #~ @basename = File.basename( filename, ".tex" ) 
+    @basename = @filename.sub(/\.(tex|dtx)$/, '') 
+    Dir.chdir(@dirname){
+      if ! File.exist?( @filename )
+        @log.fatal("File #{@filename } not found (looking in #{Dir.pwd()})") if @log.fatal?
+      end
+    }
+  end
+
+  #Start the job chain.
+  def start( format = @options[:format] )
+    puts "Start job chain for #{@filename }"
+    @log.info( "Start job chain for #{@dirname}/#{@filename }") if @log.info?
+    
+    @texrun = 0
+    @rerun = [ nil ]   #Flag, if an additional texrun is necessary (nil, so compact can delete it again)
+    @stop_rerun = {}  #Set a Rerun-Stop in case of serious problems.
+    zipfilename = "#{@basename}.log.zip"
+    summary = nil
+    #Don't use "#{filename}.runtex.log", Thats already the log.
+    jobreport = "#{filename}.runtex_summary.txt"
+    
+    Dir.chdir(@dirname){
+      if ! File.exist?( @filename )
+        @log.error( "File #{@filename} missing (dir #{@dirname})" ) if @log.error?
+        return false
+      end
+      
+      if File.exist?( zipfilename )
+        #Extract previous help files
+        Zip::ZipFile.open( zipfilename, Zip::ZipFile::CREATE ){|zip|
+          zip.each{|f| f.extract if File.dirname("#{f}") == '.' and ! File.exist?("#{f}")}
+        }
+        File.delete( zipfilename)#Delete zip file. Easier then rebuild the zip.
+        @log.debug( "Re-Create log/help-zip #{zipfilename}") if @log.debug?
+      else
+        @log.debug( "Create log/help-zip #{zipfilename}") if @log.debug?
+      end
+      @zip = Zip::ZipFile.new( zipfilename, Zip::ZipFile::CREATE )
+
+      configuration = Configuration["#{format}"]
+      @log.fatal("No configuration for #{format}") if ! configuration and @log.fatal
+      
+      while ! @rerun.empty? and @texrun < MAX_TEX_RUN
+        #Write the message only, if it is the 2nd run (-> test with compact).
+        @log.info( "%02i--- Rerun necessary (#{@rerun.join(', ')})" % @texrun ) if @log.info? and ! @rerun.compact.empty?
+        @rerun = []
+        texresult = run( LaTeX.new( self, { 
+                                                      :format => configuration['call'],
+                                                      :overfull => @options[:overfull],
+                                                      :underfull => @options[:underfull],
+                                                      }
+                            ) )
+        texresult = {} unless texresult
+        #jobreport/summary for each step
+        summary = build_summary( texresult, jobreport, format )
+        @zip.add("%02i/#{jobreport}" % @texrun, jobreport )
+        #The deletion is done with the end-summary
+
+      end
+      if @texrun >= MAX_TEX_RUN
+        @log.warn( "Stop after #{MAX_TEX_RUN} tex runs") if @log.warn?
+      end
+      
+      ##################
+      #fixme - postprocesses
+      ##################
+      configuration['post'].each{|post|
+        @log.error( "Post-process #{post} undefined") if @log.error?
+      } if configuration['post']
+
+      @helpfiles.uniq!
+      #Save all helpfiles to the zip file.
+      #In a later run, this helpfiles are extracted again.
+      if @options[:zip_helpfiles]
+        @log.debug( "Zip help files for later use (#{@helpfiles.join(', ')})") if @log.debug?
+        @helpfiles.each{|filename|
+          #~ @log.debug( "Zip #{filename} for later use") if @log.debug?
+          @zip.add( filename, filename ) if File.exist?(filename)
+        }
+      end
+      
+      #fixme - I would like to add the log - does not work
+      #~ filename = @log.outputters[1].filename
+      #~ @log.outputters[1].close
+      #~ @log.remove[1]
+      #~ @zip.add( filename, filename )
+
+      #build the summary and save it
+      summary = build_summary( texresult, jobreport, format )      
+      @zip.add(jobreport, jobreport)
+      @logfiles << jobreport unless @options[:keep_summary]
+      
+      #Close must be done before the files are deleted.
+      @zip.close
+
+      #Delete logfiles if requested
+      if @options[:delete_logfiles]
+        @logfiles.delete_if{|filename| ! File.exist?(filename) }  #delete for log
+        @log.debug( "Delete log files #{@logfiles.join(', ')}") if @log.debug?
+        @logfiles.each{|filename|
+          #~ @log.debug( "Delete #{filename}") if @log.debug?
+          begin; File.delete(filename) if File.exist?(filename)
+          rescue Errno::EACCES => err
+            @log.error( "Delete #{filename}: #{err}") if @log.error?
+          end
+        }
+      end
+      #Delete helpfiles if requested
+      if @options[:delete_helpfiles]
+        @helpfiles.delete_if{|filename| ! File.exist?(filename) }  #delete for log
+        @log.debug( "Delete helpfiles #{@helpfiles.join(', ')}") if @log.debug?
+        @helpfiles.each{|filename|
+          #~ @log.debug( "Delete #{filename}") if @log.debug?
+          begin; File.delete(filename) if File.exist?(filename)
+          rescue Errno::EACCES => err
+            #Happens with rail.exe at xxx.rai-file
+            @log.error( "Delete #{filename}: #{err}") if @log.error?
+          end
+        }
+      end
+
+    } #Dir.chdir(@dirname)
+    puts summary
+    puts "More Details see #{jobreport} or #{zipfilename}"
+    return summary  #for other usages (e.g.runtex_gui.rb..)
+  end #start
+  #
+  #Build the summary and store it in file jobreport
+  #
+  def  build_summary( texresult, jobreport, format )
+    #Get main data (filename, number of pages, size...)
+    summary = texresult[:fileinfo].to_yaml
+    #Get more data
+    [ [:error, 'Errors'], 
+      [:warning,'Warnings'],
+      [:overfull, "Overfull boxes > #{@options[:overfull]}"],
+      [:underfull, "Underfull boxes with badness > #{@options[:underfull]}"],
+      ].each{|key, text|
+      next unless texresult[key]
+      next if texresult[key].empty?
+      summary << "#{text}:\n"
+      summary << texresult[key].to_yaml.sub(/--- \n/, '')
+    }
+    
+    #Save the summary to a file
+    File.open(jobreport, 'w'){| file |
+    
+      file << <<header
+==================================================
+|  Report for TeX-Job #{filename}"
+|   #{Time.now.strftime('%Y-%m-%d %H:%M')}, TeX-run #{@texrun}
+==================================================
+
+header
+      file << "#{'='*50}\n"
+      file << "LaTeX (#{format})\n"
+      file << "#{'='*50}\n"
+      file << summary
+      @nextsteps.each{|step|
+        file << "\n#{'='*50}\n"
+        file << "#{step.inspect}\n"
+        file << "#{'='*50}\n"
+        file  << step.summary
+        summary  << "#{step.inspect}: #{step.summary(:count)}\n"
+      }#@nextsteps
+      @stop_rerun.each{|tool, reasons|
+        summary << "!! Rerun-Stopp for #{tool}!"
+        file << "\n#{'='*50}\n"
+        file << "!! Rerun-Stopp for #{tool}"
+        file << "\n#{'='*50}\n"
+        reasons.each{|reason|
+          file << "- #{reason}\n"
+        }
+      }#@stop_rerun
+    } #open file
+    return summary
+  end  #build_summary( summary, jobreport )
+  
+  #Counter for the texrun.
+  attr_reader :texrun 
+  
+  #Access to the logger
+  attr_reader :log
+  
+  
+  #Start a run with LaTeX. Required additional tools  are added with << during the TeX-run.
+  def run( latex )
+    
+    if ! latex.is_a?(LaTeX)
+      @log.fatal( "Run with a non-LaTeX-tool") if @log.fatal?
+    end
+    
+    @texrun += 1
+    @nextsteps  = []
+    
+    #Run LaTeX
+    @latex = latex  #store it for log in << 
+    @log.info( "%02i    Start TeX-run #{@texrun}" % @texrun ) if @log.info?
+    texresult = latex.execute(1)
+    @log.debug( "#{latex.step} -> #{prepare_result(texresult)}") if @log.debug?
+    
+    #Run the necessary tools
+    @nextsteps.each_with_index{|step, index|
+      result = step.execute( index + 2 ) #TeX is step 1
+      @log.debug( "#{step.step} -> #{prepare_result(result)}") if @log.debug? and !result.empty?
+    }
+    #Print the end statistic
+    return texresult
+    
+  end
+  #Delete result hash form empty arrays and zero-counters, build an ordered string.
+  #Sort messages by importance
+  def prepare_result( result )
+    result.delete_if{|key,val| ( val.is_a?(Array) and val.empty? ) or val == 0  }
+    string = []
+    string << "File: #{result[:fileinfo].join(', ')}" if result[:fileinfo]    #List with filename, size , number of errors...
+    string << "Errors: #{result[:error].join(', ')}" if result[:error]
+    string << "Warnings: #{result[:warning].join(', ')}" if result[:warning]
+    string << "Info: #{result[:info].join(', ')}" if result[:info]
+    (result.keys - [:fileinfo, :file, :size, :pages, :error, :warnings, :info ]).each{|key|
+      if result[key].respond_to?(:join)
+        string << "#{result[key]}: #{result[key].join(', ')}"
+      else
+        string << "#{result[key]}: #{result[key]}"
+      end
+    }
+    string.join('; ')
+  end
+  #Add a reason, why an additional TeX-run is necessary.
+  def please_rerun( reason )
+    @log.debug( "%02i    Rerun necessary (#{reason})" % @texrun) if @log.debug?
+    @rerun << reason    
+  end #please_rerun
+  #Set a Rerun-Stop in case of serious problems.
+  #Contains Symbols with name of the tool which should be blocked.
+  def stop_rerun( tool, reason )
+    @stop_rerun[tool] = [] unless @stop_rerun[tool]
+    @stop_rerun[tool] << reason
+  end
+  #Is there a rerun-stop for a special tool?
+  def stop_rerun?( tool )
+    return @stop_rerun.keys.include?(tool)
+  end
+  #Add a new step for the next step.
+  def << (step)
+    @log.debug( "#{@latex.step} Add new step #{step.inspect}" % @texrun ) if @log.debug?
+    
+    case step
+      when Splitindex
+        @log.debug( "#{@latex.step} Replace Makeindex by Splitindex" ) if @log.debug?
+        @nextsteps.pop if @nextsteps.last.is_a?(Makeindex)
+      when Makeindex
+        if step.options[:name] =~ /Index2/ and
+            @nextsteps.last.is_a?(Makeindex) and
+            @nextsteps.last.options[:name] == 'Index'
+          @log.debug( "#{@latex.step} Replace Makeindex by #{step.options[:name]}" ) if @log.debug?
+          @nextsteps.pop if @nextsteps.last.is_a?(Makeindex)
+        end
+      when Rail
+        #Execute Rail only once
+        @nextsteps.each{|lstep| return false if lstep.is_a?(Rail) }
+    end
+    @nextsteps << step
+  end #Job_chain#<<
+  
+  #Add the given file to the log-zip
+  def add2zip(filename)
+    zipname = "%02i/%s" % [@texrun, filename]
+    
+    count = 1
+    while @zip.find_entry(zipname)
+      count += 1
+      zipname = "%02i/%s.%i" % [@texrun, filename, count]
+    end
+    @zip.add( zipname, filename )
+    
+  end #add2zip
+  
+  def inspect()
+    return "<RunTeX::Job_chain #{@filename}>"
+  end
+end #Job_chain
+end #module RunTeX