rake4latex 0.0.1

data/lib/rake4latex/latexdependencies.rb

@@ -0,0 +1,103 @@
+#
+#Class to determine dependecies of a LaTeX project.
+#
+#* \input/\include: searched recursive
+#
+#Not done (yet):
+#* check kpsewhich if files are not found
+#* scan for \bibliography{testdocument} and search via kpsewhich
+#       rule '.bbl' => 'xxx.bib' 
+#
+class LaTeXDependencies 
+  def self.get_dependecies(filename, *arguments)
+    new(filename).get_dependecies(*arguments)
+  end
+  #
+  #Define the main file for the dependecy-analyse.
+  def initialize( filename )
+    @filename = filename
+    raise ArgumentError, "File #{@filename} not found" unless File.exist?(@filename)
+    @basedir = File.dirname(filename)
+    @basename = File.basename(filename)
+  end
+=begin rdoc
+Get all dependecies.
+
+Which dependecies you get is defined by the arguments:
+* :inputs: All sub files, loaded with \input and \include
+There are also predefined actions:
+* :flat: flat the nested dependecies and delete double entries.
+Missing dependecies:
+*index (ind)
+*bibliography (bbl? + bib)
+*splitindex
+=end
+  def get_dependecies(*arguments)
+    deps = [ @filename ]
+    arguments.each{|arg|
+      case arg
+        when :inputs; deps << find_included_files
+        when :flat  #Action done at end
+        else
+          raise ArgumentError, "Unknown option #{arg}"
+      end
+    }
+
+    if arguments.include?(:flat)
+      return deps.flatten.uniq
+    else
+      return deps
+    end
+  end
+
+=begin rdoc
+Finds the files given as arguments to the <tt>\includeonly</tt>, <tt>\include</tt>
+and <tt>\input</tt> latex command in file _file_ and returns a nested  array of their 
+names (relative to the directory of file). 
+=end
+  def find_included_files()
+    deps = []
+    #Change to the basedir of the main_file and start from there the recursive analyse.
+    Dir.chdir(@basedir){
+      begin
+        deps = find_included_files_rec( @basename )
+      rescue Errno::EMFILE => err
+        raise "Recursive include structure in #{@filename}"
+      end
+    }
+    deps
+  end #self.find_included_files
+  #
+=begin rdoc
+There is a bit trouble with the basedir of TeX-files,
+All includes must be located relative to the main_file.
+
+There is no check on the file found by kpsewhich ##fixme##
+=end
+  def find_included_files_rec( file )
+    
+    raise ArgumentError, "File #{file} not found" unless File.exist?(file)
+    deps = []
+
+    File.foreach(file){ |line|
+      #Skip comments, then look for input macros
+      #Remarks:
+      #* A \% is not detected.
+      #* \endinput is not detected
+      line.sub(/%.*/, '').scan(/\\(?:include|input|includeonly)\{([^}]+)\}/){|m|
+        m.each{|ifile|
+          ifile = ifile.ext('tex')  #add the extension tex if not already done.
+          deps << ifile
+
+          if File.exist?(ifile)
+            subdeps = find_included_files_rec(ifile)  #Get includes in include file
+            deps << subdeps unless subdeps.empty?  #add sub-includes if available
+          else
+            puts "Include-File #{ifile} not found" #fixme puts/log...
+          end
+        }#hit
+      }#line.scan
+    }#File.foreach
+    deps
+  end #self.find_included_files
+end #LaTeXDependencies

data/lib/rake4latex/latexrunner.rb

@@ -0,0 +1,268 @@
+=begin rdoc
+Class which encapsulates all the information needed to call latex 
+as often as needed. 
+It calls (pdf|xe|lua)LaTeX and checks if additional tools are needed.
+=end
+class LaTeXRunner
+  #Define Infinity (needed for option maxruns.
+  Infinity = 1.0/0
+  #
+  #Define the main settings for the runner.
+  #
+  #This values can be overwritten with
+  #   Rake.application.set_latexrunner_default(:loglevel, Log4r::DEBUG)
+  #
+  DEFAULT_SETTINGS = {
+    :main_file => nil,  #only needed for key-check. Must be defined later.
+    :maxruns => 5,
+    :program => :pdflatex,  #Valid entries see PROGRAMS
+    :loglevel => Log4r::INFO,
+    :options => ['-interaction=batchmode'],
+    :texerrors_allowed => false,
+  }
+=begin rdoc
+All tasks, which should be executed after a TeX-call.
+
+The constant is filled via LaTeXRunner#tex_postrule,
+LaTeXRunner#run_latex_once will loop on all this tasks
+and execute them if necessary.
+=end
+  Post_Prerequisites = []
+=begin rdoc
+Defines an optional check routine to check if a Post_Prerequisites
+is necessary. 
+Should return true or false.
+=end
+  Post_Prerequisites_check = {}
+  
+=begin rdoc
+  The default programs to use to process latex files, depending on the extension
+  of the file to generate. To add a default program for another extension, simply
+  add the corresponding entry here. To change the default program for a given 
+  extension for all the latex tasks, change it here. To change the program used
+  in a specific task, change it in the corresponding runner
+=end
+  PROGRAMS = {
+    :latex    => 'latex',
+    :pdflatex => 'pdflatex',
+    :lualatex => 'lualatex',
+    :xelatex => 'xelatex',
+  }
+
+
+  #Error class
+  class MainfileError < ArgumentError; end
+
+=begin rdoc
+Define a new runner.
+
+The settings contain the following values:
+* main_file, see LaTeXRunner#main_file
+* maxruns, see LaTeXRunner#maxruns
+=end
+  def initialize( settings )
+    
+    #~ raise ArgumentError, "Task is no RakeTask but #{t.class}" unless task.is_a?(Rake::Task)
+    
+    @logger = Log4r::Logger.new("LaTeXRunner #{settings[:main_file]}")
+    @logger.outputters = Log4r::StdoutOutputter.new('log_stdout')
+    
+    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 :options;  @options = value
+      when :loglevel;  @logger.level = value
+      when :texerrors_allowed;  @texerrors_allowed = value
+      when :dummy #dummy
+      else
+        raise ArgumentError, "Undefined key #{key} for LaTeXRunner"
+      end
+    }
+
+    raise MainfileError, "main_file missing" unless @main_file
+    raise MainfileError, "main_file #{@main_file} not found" unless File.exist?(@main_file)
+    raise ArgumentError, "Maxrun is no number" unless @maxruns.is_a?( Fixnum ) or @maxruns == Infinity
+
+    Rake.application.latexrunner = self
+    @basename = File.basename(@main_file)
+    @input_dir = File.dirname(@main_file)
+    @full_input_dir = File.expand_path(@input_dir)
+
+    @logger.name.replace("LaTeXRunner #{@basename}")
+    @logger.info( "StartLaTeXRunner for #{@main_file}")
+
+    @rerun_necessary = true #initialize
+  end #initialize
+
+  def inspect()
+    return  "#<LaTeXRunner: #{@main_file}>"
+  end
+=begin rdoc
+  The name of the file on which latex should be invoked. The input directory is
+  determined from this.
+=end
+  attr_accessor :main_file
+
+=begin rdoc
+  The maximum number of times latex can be run. 
+  If you want to remove the limit, you can set it to infinity
+  (LaTeXRunner::Infinity)
+=end rdoc
+  attr_accessor :maxruns
+
+# The directory where the input file is located. It is determined automatically during initialization
+  attr_reader :input_dir
+
+# The full path of the input directory. It is determined automatically during initialization
+  attr_reader :full_input_dir
+  
+# The looger for the LaTeX-Run.
+  attr_reader :logger
+
+# Flag if TeX should be started again.
+  def rerun_necessary?()
+    @rerun_necessary and ( maxruns > @texruns )
+  end
+
+=begin rdoc
+  The program to use to process the .tex files for this runner. 
+  Default is :pdflatex, but can be redefined by the task definition.
+=end
+  def program=(key)
+    raise ArgumentError, "Programm key #{key.inspect} unknown" unless PROGRAMS[key]
+    @program = PROGRAMS[key]
+  end
+
+# An array of the options to pass to latex. Defaults to <tt>['-interaction=batchmode']</tt>
+  attr_reader :options
+
+
+=begin rdoc
+  Starts the build process for the output file.
+  
+  It determines the latex command line and calls <tt>run_latex_as_needed</tt>.
+=end
+  def execute()
+    
+    cmd = "#{@program} #{@options.join ' '} " + 
+        #~ "-output-directory=#@full_output_dir 
+        " #{@basename}"
+    Dir.chdir(@input_dir) do
+      @texruns = 0
+      while rerun_necessary?
+        @texruns += 1
+        @rerun_necessary = false
+        run_latex_once(cmd)
+      end
+    end
+    #Guarentee that help files are deleted fin clean.
+    set4clean( @basename )
+    
+    plural_s = "#{@texruns} run#{@texruns>1 ? 's': ''}"
+    if @rerun_necessary
+      @logger.warn("TeX-run stopped after #{plural_s}, but more runs are necessary" )
+    else
+      @logger.info("TeX-run stopped after #{plural_s}" )
+    end
+  end
+
+=begin rdoc
+  Manages a single invocation of latex. This means:
+  * Get the MD5 digest of help-files.
+  * executes latex
+  * Invokes the following tasks like Index...
+  This method is expected to be started in @input_dir
+=end
+  def run_latex_once(cmd)
+
+    checksums = {}
+    FileList["#{@basename.ext('*')}"].each do |file|
+        # Computes a MD5 digest for the given file, reading the file.
+        File.open(file){|f| checksums[file] = MD5.new(f.read).hexdigest }
+    end
+
+    @logger.info("Excute #{cmd}")
+    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
+    end
+        
+    #Build the checksums.
+    FileList["#{@basename.ext('*')}"].each do |file|
+      # Compare old and new MD5 digest for the given file.
+      File.open(file){|f| 
+          case checksums[file]
+          when nil
+            @logger.debug("new file #{file}")
+            checksums[file] = :changed
+          when File.open(file){|f| MD5.new(f.read).hexdigest}
+            @logger.debug("Unchanged file #{file}")
+          else
+            @logger.debug("  Changed file #{file}" )
+            checksums[file] = :changed
+          end
+        }
+    end
+ 
+    #check changes in some files.
+    %w{aux toc lof lot}.each{|ext|
+      next unless checksums[@basename.ext(ext)] == :changed
+      @rerun_necessary = true
+      @logger.info("Rerun necessary (#{ext}-file changed)" ) if @rerun_necessary
+      break #stop after the first reason for an additional run.
+    }
+
+    #Loop on all Post_Prerequisites (e.g. makeindex, BibTeX...)
+    Post_Prerequisites.each{|pre|
+      @logger.debug("Check Post-prerequisite #{pre}" )
+      #Get the Post-prerequisites.
+      #Stops if it does not exist.
+      begin
+        if ! post_prereq = Rake.application[@basename.ext(pre)]
+          @logger.fatal("No rule for Post-prerequisites #{pre}" )
+          next
+        end
+      rescue RuntimeError => err
+        @logger.debug("No Post-prerequisite #{pre}" )
+        next
+      end
+      
+      #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|
+        reason4call = false
+        #Check special rules (e.g. for BibTeX)
+        if Post_Prerequisites_check[pre]
+          @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)
+            break if reason4call  #we need only one reason to start the task.
+          }
+        else  #make the standard check (
+          reason4call = "#{post_prereq_pre} changed" if ( checksums[post_prereq_pre] == :changed )
+        end
+        if reason4call  #We have to run the task for the post_prereq
+          #One of the sources of post_prereq changes
+          @logger.info("Call target #{post_prereq.name} (#{reason4call})" )
+          post_prereq.invoke() 
+          File.open(post_prereq.name){|f|
+              @rerun_necessary = (MD5.new(f.read).hexdigest != checksums[f.path])
+              @logger.info("Rerun necessary (#{f.path} changed)" ) if @rerun_necessary
+          } unless @rerun_necessary #check not necessary, if we already need an additional run
+          break #Only one call necessary
+        end #source changed
+      } ##prerequisites of  post_prereq
+    } #Post_Prerequisites
+
+    #fixme: get info for next run (global?, adabp invoke?
+    #set again task??
+    #call rake again? creaite new app?
+  end
+
+end #LaTeXRunner

data/lib/rake4latex/rules.rb

@@ -0,0 +1,134 @@
+#Some Tools have screen output.
+#runtex should run silent in background, so we have to redirect the output.
+require 'catch_output'
+include Catch_output
+
+
+desc "Show compiled source in Adobe Acrobat Reader."
+task :acroread do |t|
+  t.prerequisites.each{|pre|
+    #~ sh "acroread #{pre.ext('pdf')}"
+    #Problem: rake process waits until reader is closed
+    sh "call #{pre.ext('pdf')}"
+  }
+end
+
+desc "Set the basefile - needed for clean and statistic"
+task :basefile do |task|
+  task.prerequisites.each{|pre|
+    #~ puts "Set basefile #{pre.inspect}"
+    set4clean( pre )
+    file :statistic => pre
+  }
+  task.reenable() #If not the second call for clean will not work.
+end
+task :default => :basefile
+
+
+#
+#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|
+    FileUtils.touch(pre)
+  }
+end
+
+desc "Build a dvi-file with LaTeX"
+rule '.dvi' => '.tex' do |t|
+  runner =   LaTeXRunner.new( 
+    :main_file => t.source,
+    :program => :latex,
+    :dummy => nil
+    )
+  runner.execute  #Does all the work and calls the "post-prerequisites"
+end
+
+desc "Build a pdf-file with pdfLaTeX"
+rule '.pdf' => '.tex' do |t|
+  runner =   LaTeXRunner.new( 
+    :main_file => t.source,
+    :program => :pdflatex,
+    :dummy => nil
+    )
+  runner.execute  #Does all the work and calls the "post-prerequisites"
+end
+
+desc "Call Makeindex"
+tex_postrule '.ind' => '.idx' do |t, args |
+  #check for splitidx
+  splitidx = Splitindex.new(t.source, Rake.application.latexrunner.logger)
+  if splitidx.makeindex?   #standard index, no splitidx
+    #makeindex writes to stderr -> catch it
+    stdout, stderr = catch_screen_output{ 
+      sh "makeindex #{t.source}"
+    }
+  else  #splitidx used
+    #call splitindex
+    splitidx.execute()
+  end
+end
+
+desc "Call BibTeX"
+#Define the precheck
+tex_postrule_check '.bbl' do |args|
+  necessary = false
+  #Check for change in aux-file
+  #This must be done outside the prerequisites-loop.
+  #With definition
+  #       file 'testdocument.pdf' => 'testdocument.bib'
+  #the auxfile is missing in prerequisites and we loose the 3rd run.
+  auxfile = args[:task].name.ext('aux')
+  if File.exist?(auxfile)
+    #BibTeX should only start when BibTeX is really used.
+    if ( args[:checksums][auxfile] == :changed and File.read(auxfile) =~ /bibdata/ )
+      necessary = "#{auxfile} changed" 
+    end
+  end
+  #Check all prerequisites.
+  #This should be the aux-file and (optional) bib-files.
+  args[:task].prerequisites.each{|post_prereq_pre|  
+    args[:logger].debug("\tCheck dependency <#{post_prereq_pre}>")
+    case post_prereq_pre
+      when /\.aux\Z/  #Already done
+      when String #Name of the file (normally xxx.bib)
+        #compare timestamps of last modification
+        if File.exist?(post_prereq_pre) 
+          if args[:task].timestamp < File.mtime(post_prereq_pre)
+            args[:logger].debug("Bibbliography <#{post_prereq_pre}> changed")
+            necessary = "#{post_prereq_pre} changed"
+          end
+        else  #File not found
+          args[:logger].warn("Bibbliography: File <#{post_prereq_pre}> not found for pre-check")
+          necessary = "#{post_prereq_pre}"
+        end #File.exist?
+      else
+          args[:logger].warn("Bibbliography: Don't know how to pre-check <#{post_prereq_pre.inspect}>")
+          necessary = "#{post_prereq_pre}"
+      end #case post_prereq_pre
+      break if necessary
+  } unless necessary
+  necessary #return parameter
+end
+#Define the rule
+tex_postrule '.bbl' => '.aux' do |t|  
+  stdout, stderr = catch_screen_output{ 
+    puts `bibtex #{t.source}`
+  }
+  if $? != 0
+    Rake.application.latexrunner.logger.fatal("There where BibTeX errors. \n#{stdout}")
+  end
+end
+
+desc "Build a statistic for TeX project"
+
+task :statistic => :basefile do |t|
+  puts "Statistics:"
+  t.prerequisites.each{|pre|
+    next if pre == 'basefile' #exclude task :basefile
+    stat = TeX_Statistic.new(pre)
+    puts stat
+  }
+end
+