erbtex 0.2.0

data/examples/testbind.tex

@@ -0,0 +1,31 @@
+\documentclass{article}
+
+\begin{document}
+
+% This demonstrates that a local variable defined in one chunk of Ruby code
+% can be picked up and used in a later chunk.
+
+{: x = 99999 :}
+
+\section{Some Pointed Questions}
+
+{: 25.times do :}
+  \noindent Did you know that
+  {: new_x = Math.sqrt(x) :}
+  $\sqrt{{:= "%0.10f" % x :}} \approx {:= "%0.10f" % new_x :}$?\par
+  {: x = new_x :}
+{: end :}
+
+Maybe if you're Rain Man.
+
+% The following shows that local variables don't persist across a 'require'
+% statement.  Local variables defined in required file disappear on return.
+% Use a global variable $var to communicate between files.
+
+{: require './testbind' :}
+
+The `required' file set x to 1957, but it still reads {:= x :} in the \LaTeX\
+doc.  However, the global variable \$x set to 1957 in the required file is {:=
+  $x :} %$
+in the \LaTeX\ file.
+\end{document}

data/lib/erbtex/command_line.rb

@@ -0,0 +1,160 @@
+# -*- coding: utf-8 -*-
+
+module ErbTeX
+  class NoInputFile < StandardError; end
+
+  class CommandLine
+    attr_reader :command_line, :marked_command_line, :input_file
+    attr_reader :progname, :input_path, :output_dir, :run_dir
+
+    def initialize(command_line)
+      @command_line = command_line
+      @input_file = @marked_command_line = nil
+      @run_dir = Dir.pwd
+      find_output_dir
+      find_progname
+      find_input_file
+      find_input_path
+      mark_command_line
+    end
+
+    def find_progname
+      @progname = @command_line.split(' ')[0]
+    end
+
+    def find_output_dir
+      args = @command_line.split(' ')
+      # There is an -output-comment option, so -output-d is the shortest
+      # unambiguous way to write the -output-directory option.  It can use
+      # one or two dashes at the beginning, and the argument can be
+      # seaparated from it with an '=' or white space.
+      have_out_dir = false
+      out_dir = nil
+      args.each do |a|
+        if have_out_dir
+          # Found -output-directory on last pass without an equals sign
+          out_dir = a
+        end
+        if a =~ /^--?output-d(irectory)?=(\S+)/
+          out_dir = $2
+        elsif a =~ /^--?output-d(irectory)?$/
+          # Next arg is the out_dir
+          have_out_dir = true
+        end
+      end
+      if out_dir.nil?
+        if File.writable?(Dir.pwd)
+          @output_dir = Dir.pwd
+        else
+          @output_dir = File.expand_path(ENV['TEXMFOUTPUT'])
+        end
+      else
+        @output_dir = File.expand_path(out_dir)
+      end
+    end
+
+    def find_input_file
+      # Remove the initial command from the command line
+      cmd = @command_line.split(/\s+/)[1..-1].join(' ')
+      cmd = cmd.gsub(/\s+--?[-a-zA-Z]+(=\S+)?/, ' ')
+      infile_re = %r{(\\input\s+)?(([-.~_/A-Za-z0-9]+)(\.[a-z]+)?)\s*$}
+      if cmd =~ infile_re
+        @input_file = "#{$2}"
+        if @input_file =~ /\.tex(\.erb)?$/
+          @input_file = @input_file
+        else
+          @input_file += ".tex"
+        end
+      elsif cmd =~ %r{(\\input\s+)?(["'])((?:\\?.)*?)\2} #"
+        # The re above captures single- or double-quoted strings with
+        # the insides in $3
+        @input_file = "#{$3}"
+        if @input_file !~ /\.tex$/
+          @input_file += ".tex#{$1}"
+        end
+      else
+        @input_file = nil
+      end
+    end
+
+    def find_input_path
+      # If input_file is absolute, don't look further
+      if @input_file =~ /^\//
+        @input_path = @input_file
+      elsif @input_file.nil?
+        @input_path = nil
+      else
+        # The following cribbed from kpathsea.rb
+        @progname.untaint
+        @input_file.untaint
+        kpsewhich = "kpsewhich -progname=\"#{@progname}\" -format=\"tex\" \"#{@input_file}\""
+        lines = ""
+        IO.popen(kpsewhich) do |io|
+          lines = io.readlines
+        end
+        if $? == 0
+          @input_path = lines[0].chomp.untaint
+        else
+          raise NoInputFile, "Can't find #{@input_file} in TeX search path; try kpsewhich -format=tex #{@input_file}."
+        end
+      end
+    end
+
+    def new_command_line(new_progname, new_infile)
+      ncl = @marked_command_line.sub('^p^', new_progname)
+      # Quote the new_infile in case it has spaces
+      if new_infile
+        ncl = ncl.sub('^f^', "'#{new_infile}'")
+      end
+      ncl
+    end
+
+    def mark_command_line
+      # Replace input file with '^f^'
+      infile_re = %r{(\\input\s+)?(([-.~_/A-Za-z0-9]+)(\.[a-z]+)?)\s*$}
+      quoted_infile_re = %r{(\\input\s+)?(["'])((?:\\?.)*?)\2} #"
+      if @input_file.nil?
+        @marked_command_line = @command_line
+      elsif @command_line =~ infile_re
+        @marked_command_line = @command_line.sub(infile_re, "#{$1}^f^")
+      elsif @command_line =~ quoted_infile_re
+        @marked_command_line = @command_line.sub(quoted_infile_re, "#{$1}^f^")
+      else
+        @marked_command_line = @command_line
+      end
+      # Replace progname with '^p^'
+      @marked_command_line = @marked_command_line.lstrip
+      @marked_command_line = @marked_command_line.sub(/\S+/, '^p^')
+    end
+  end
+end
+
+# NOTES:
+
+# The following text is from the Web2C documentation at
+# http://tug.org/texinfohtml/web2c.html#Output-file-location
+#
+# 3.4 Output file location
+#
+# All the programs generally follow the usual convention for output
+# files. Namely, they are placed in the directory current when the
+# program is run, regardless of any input file location; or, in a few
+# cases, output is to standard output.
+
+# For example, if you run ‘tex /tmp/foo’, for example, the output will
+# be in ./foo.dvi and ./foo.log, not /tmp/foo.dvi and /tmp/foo.log.
+
+# You can use the ‘-output-directory’ option to cause all output files
+# that would normally be written in the current directory to be written
+# in the specified directory instead. See Common options.
+
+# If the current directory is not writable, and ‘-output-directory’ is
+# not specified, the main programs (TeX, Metafont, MetaPost, and BibTeX)
+# make an exception: if the config file or environment variable value
+# TEXMFOUTPUT is set (it is not by default), output files are written to
+# the directory specified.
+
+# TEXMFOUTPUT is also checked for input files, as TeX often generates
+# files that need to be subsequently read; for input, no suffixes (such
+# as ‘.tex’) are added by default and no exhaustive path searching is
+# done, the input name is simply checked as given.

data/lib/erbtex/find_binary.rb

@@ -0,0 +1,41 @@
+module ErbTeX
+  # Find the first executable file in the PATH that is the same
+  # basename, but not the same absolute name as calling_prog.  If this
+  # program has been linked to the name pdflatex, for example, and is
+  # located in ~/bin/pdflatex, this function will take '~/bin/pdflatex'
+  # as it parameter, expand it to /home/ded/pdflatex, then walk through
+  # the PATH looking for an executable with the same basename, pdflatex,
+  # but not the same absolute name /home/ded/bin/pdflatex.
+  #
+  # This allows us to make several symlinks to our erbtex program with
+  # the name of the actual program we want to invoke.  So our link
+  # version of pdflatex will know to invoke the *real* pdflatex in
+  # /usr/bin/pdflatex after we've done the pre-processing.  Also, other
+  # programs that want to invoke pdflatex will still work, except that
+  # we'll sneak in and do ruby pre-processing before invoking the real
+  # program.
+
+  # If the calling program is 'erbtex', treat it as 'pdflatex' just as
+  # if it were a pdflatex link to erbtex
+
+  def ErbTeX.find_executable(calling_prog)
+    calling_prog = File.absolute_path(calling_prog)
+    call_path = File.dirname(calling_prog)
+    call_base = File.basename(calling_prog).sub(/^erbtex$/, 'pdflatex')
+    executable = nil
+    ENV['PATH'].split(':').each do |p|
+      next unless File.directory?(p)
+      next if File.absolute_path(p) == call_path
+      Dir.chdir(p) do
+        Dir.glob(call_base).each do |f|
+          if system("file -L #{f} | grep -q ELF")
+            executable = File.join(p, f)
+            break
+          end
+        end
+      end
+      break if executable
+    end
+    executable
+  end
+end

data/lib/erbtex/runner.rb

@@ -0,0 +1,108 @@
+require 'tempfile'
+require 'pathname'
+
+module ErbTeX
+  # When we are handed a command line, it will be one that was
+  # originally intended for the real tex processor, e.g., pdflatex.
+  #
+  # We want to find the intended input file and the intended output
+  # directory using the ErbTeX::CommandLine object.
+  #
+  # We want to process the intended input file with Erubis and save the
+  # output in a temporary file with an .etx extension.
+  #
+  # Write the .etx file to the current directory unless it is not
+  # writable, in which case write it to /tmp.
+  #
+  # Perhaps change the Erubis pattern to something like .{ }. so that
+  # AucTeX does not get confused with the comment character used in
+  # Erubis by default (<%= %>).  Erubis -p commandline would use the
+  # switch -p '\.{ }\.' But adapt if old pattern style is found in the
+  # input.
+  #
+  # If there are no Erubis patterns in the file, skip the Erubis phase
+  # and just pass the original command on to the system.
+  #
+  # But wait.  What if there are \include{file} or \input file
+  # statements in the input and those have Erubis patterns in them?  We
+  #  have to invoke erbtex recursively on those, replacing the
+  # orginal with a processed temporary and patching up the
+  # \include{tmp-file}, and so on.
+  #
+  # If there is an error in the Erubis phase, we want the error message
+  # to make it clear what happened and exit without invoking the tex
+  # processor.
+  #
+  # We want to find the real tex processor with find_executable and run it
+  # on our processed .etx file and otherwise leave the commandline
+  # intact.
+  #
+  def ErbTeX.run(command)
+    cl = CommandLine.new(command)
+    Dir.chdir(cl.run_dir) do
+      if cl.input_file
+        new_infile = process(cl.input_file, cl.input_path)
+      else
+        new_infile = nil
+      end
+      if new_infile
+        new_infile = Pathname.new(new_infile).
+          relative_path_from(Pathname.new(cl.run_dir))
+        new_progname = ErbTeX.find_executable(command.lstrip.split(' ')[0])
+        cmd = cl.new_command_line(new_progname, new_infile)
+        cmd.sub!('\\', '\\\\\\')
+        puts "Executing: #{cmd}"
+        system(cmd)
+      end
+    end
+  end
+
+  # Run erbtex on the content of file_name, a String, and return the
+  # name of the file where the processed content can be found.  This
+  # could be the orignal file name if no processing was needed, or a
+  # temporary file if the erubis pattern is found anywhere in the file.
+  def ErbTeX.process(file_name, dir)
+    puts "Input path: #{dir}"
+    contents = nil
+    File.open(file_name) do |f|
+      contents = f.read
+    end
+    # TODO: recurse through any \input or \include commands
+
+    # Add current directory to LOAD_PATH
+    $: << '.' unless $:.include?('.')
+
+    if ENV['ERBTEX_PATTERN']
+      pat = ENV['ERBTEX_PATTERN']
+    else
+      pat = '{: :}'
+    end
+
+    # Otherwise process the contents
+    # Find a writable directory, prefering the one the input file came
+    # from, or the current directory, and a temp file as a last resort.
+    file_absolute = File.absolute_path(File.expand_path(file_name))
+    file_dir = File.dirname(file_absolute)
+    if file_absolute =~ /\.tex\.erb$/
+      file_base = File.basename(file_absolute, '.tex.erb')
+    else
+      file_base = File.basename(file_absolute, '.tex')
+    end
+    of = nil
+    if File.writable?(file_dir)
+      out_file = file_dir + '/' + file_base + '.etx'
+    elsif File.writable?('.')
+      out_file = './' + file_base + '.etx'
+    else
+      of = Tempfile.new([File.basename(file_name), '.etx'])
+      out_file = of.path
+    end
+    unless of
+      of = File.open(out_file, 'w+')
+    end
+    er = Erubis::Eruby.new(contents, :pattern => pat)
+    of.write(er.result)
+    of.close
+    out_file
+  end
+end

data/lib/erbtex/version.rb

@@ -0,0 +1,3 @@
+module ErbTeX
+  VERSION = "0.2.0"
+end

data/lib/erbtex.rb

@@ -0,0 +1,10 @@
+#! /usr/bin/env ruby
+
+require 'erubis'
+
+require 'erbtex/version'
+require 'erbtex/command_line'
+require 'erbtex/find_binary'
+require 'erbtex/runner'
+
+require 'byebug'

data/test/test_command_line.rb

@@ -0,0 +1,181 @@
+require 'test_helper'
+
+class CommandLineTest < Test::Unit::TestCase
+  include ErbTeX
+
+  def setup
+    @test_dir = File.dirname(File.absolute_path(__FILE__))
+    @junk_tex = @test_dir + '/junk.tex'
+    FileUtils.touch(@junk_tex)
+
+    @tex_dir = @test_dir + '/tex_dir'
+    FileUtils.mkdir(@tex_dir) unless File.exists?(@tex_dir)
+    @junk2_tex = @tex_dir + '/junk2.tex'
+    FileUtils.touch(@junk2_tex)
+
+    @tex_dir_nw = @test_dir + '/tex_dir_nw'
+    FileUtils.mkdir(@tex_dir_nw) unless File.exists?(@tex_dir_nw)
+    @junk3_tex = @tex_dir_nw + '/junk3.tex'
+    FileUtils.touch(@junk3_tex)
+    FileUtils.chmod(0500, @tex_dir_nw)
+
+    @junk4_tex = File.expand_path('~/junk.tex')
+    FileUtils.touch(@junk4_tex)
+  end
+
+  def teardown
+    FileUtils.rm(@junk_tex)
+    FileUtils.rm(@junk4_tex)
+    FileUtils.rm_rf(@tex_dir)
+    FileUtils.chmod(0700, @tex_dir_nw)
+    FileUtils.rm_rf(@tex_dir_nw)
+  end
+
+  def test_find_ordinary_input_file
+    cl = 'pdflatex -ini --halt-on-error junk'
+    assert_equal("junk.tex",
+           CommandLine.new(cl).input_file)
+  end
+
+  def test_find_input_file_relative
+    cl = 'pdflatex -ini --halt-on-error ./junk.tex'
+    assert_equal("./junk.tex",
+           CommandLine.new(cl).input_file)
+  end
+
+  def test_find_input_file_relative_no_ext
+    cl = 'pdflatex -ini --halt-on-error ./junk'
+    assert_equal("./junk.tex",
+           CommandLine.new(cl).input_file)
+  end
+
+  def test_find_ordinary_input_file_with_ext
+    cl = 'pdflatex -ini --halt-on-error junk.tex'
+    assert_equal("junk.tex",
+           CommandLine.new(cl).input_file)
+  end
+
+  def test_find_ordinary_input_file_with_spaces
+    fn = 'A junk.tex'
+    FileUtils.touch(fn)
+    cl = "pdflatex -ini --halt-on-error \'#{fn}\'"
+    assert_equal("A junk.tex",
+           CommandLine.new(cl).input_file)
+    FileUtils.rm(fn)
+  end
+
+  def test_no_input_file
+    assert_raise ErbTeX::NoInputFile do
+      cl = 'pdflatex -ini'
+      CommandLine.new(cl)
+    end
+  end
+
+  def test_no_input_file_with_eq
+    assert_raise ErbTeX::NoInputFile do
+      cl = 'pdflatex -ini -output-directory=/tmp'
+      CommandLine.new(cl).input_file
+    end
+  end
+
+  def test_find_progname
+    cl = 'pdflatex -ini --halt-on-error junk.tex'
+    assert_equal("pdflatex",
+           CommandLine.new(cl).progname)
+  end
+
+  def test_mark_command_line
+    cl = 'pdflatex -ini --halt-on-error junk'
+    clm = '^p^ -ini --halt-on-error ^f^'
+    assert_equal(clm,
+           CommandLine.new(cl).marked_command_line)
+  end
+
+  def test_mark_command_line_with_ext
+    cl = 'pdflatex -ini --halt-on-error junk.tex'
+    clm = '^p^ -ini --halt-on-error ^f^'
+    assert_equal(clm,
+           CommandLine.new(cl).marked_command_line)
+  end
+
+  def test_mark_command_line_with_dir
+    cl = 'pdflatex -ini --halt-on-error ~/junk.tex'
+    clm = '^p^ -ini --halt-on-error ^f^'
+    assert_equal(clm,
+           CommandLine.new(cl).marked_command_line)
+  end
+
+  def test_mark_command_line_with_spaces
+    cl = 'pdflatex -ini --halt-on-error \'/home/ded/A junk.tex\''
+    clm = '^p^ -ini --halt-on-error ^f^'
+    assert_equal(clm,
+           CommandLine.new(cl).marked_command_line)
+  end
+
+  def test_find_embedded_input_file
+    cl = 'pdflatex -ini --halt-on-error \input junk'
+    assert_equal("junk.tex",
+           CommandLine.new(cl).input_file)
+  end
+
+  def test_find_embedded_input_file_with_ext
+    cl = 'pdflatex -ini --halt-on-error \input junk.tex'
+    assert_equal("junk.tex",
+           CommandLine.new(cl).input_file)
+  end
+
+  def test_find_input_file_with_relative
+    cl = 'pdflatex -ini --halt-on-error \input tex_dir/junk2.tex'
+    assert_equal("tex_dir/junk2.tex",
+           CommandLine.new(cl).input_file)
+  end
+
+  def test_find_input_file_with_spaces
+    fn = "my junk2.tex"
+    FileUtils.touch(fn)
+    cl = "pdflatex -ini --halt-on-error \input \"#{fn}\""
+    assert_equal(fn,
+                 CommandLine.new(cl).input_file)
+    FileUtils.rm(fn)
+  end
+
+  def test_find_input_path_existing
+    cl = 'pdflatex -ini --halt-on-error \input junk.tex'
+    assert_equal("./junk.tex",
+           CommandLine.new(cl).input_path)
+  end
+
+  def test_dont_find_input_path_non_existing
+    cl = 'pdflatex -ini --halt-on-error \input junk3.tex'
+    assert_raise NoInputFile do
+      CommandLine.new(cl).input_path
+    end
+  end
+
+  def test_find_full_path_with_env
+    save_env = ENV['TEXINPUTS']
+    ENV['TEXINPUTS'] = File.dirname(__FILE__) + '/tex_dir'
+    cl = 'pdflatex -ini --halt-on-error \input junk2.tex'
+    assert_equal("./tex_dir/junk2.tex",
+           CommandLine.new(cl).input_path)
+    ENV['TEXINPUTS'] = save_env
+  end
+
+  def test_find_output_dir
+    cl = 'pdflatex -ini --halt-on-error \input junk.tex'
+    assert_equal(File.expand_path('./'), CommandLine.new(cl).output_dir)
+  end
+
+  def test_find_output_dir_with_options
+    cl = 'pdflatex -ini -output-d=~/tmp \input junk.tex'
+    assert_equal(File.expand_path('~/tmp'), CommandLine.new(cl).output_dir)
+  end
+
+  def test_find_output_dir_with_non_writable_pwd
+    cl = 'pdflatex -ini \input junk3.tex'
+    ENV['TEXMFOUTPUT'] = File.expand_path(File.dirname(__FILE__) + '/tex_dir')
+    Dir.chdir('tex_dir_nw') do
+      assert_equal(File.expand_path('../tex_dir'), CommandLine.new(cl).output_dir)
+    end
+  end
+end

data/test/test_find_executable.rb

@@ -0,0 +1,44 @@
+require 'test_helper'
+
+class FindBinaryTest < Test::Unit::TestCase
+  include ErbTeX
+
+  # Here we set up the situation as we expect it to be after
+  # installation.  There is a "real" pdflatex executable binary and
+  # there is one that is just a link to our script, the "fake" binary.
+  # The fake binary is earlier in PATH than the real binary, and we want
+  # this function, when fed the name of the fake binary to deduce the
+  # name of the real binary.
+  def setup
+    # Create a "fake" ruby script named pdflatex
+    @fake_dir = File.dirname(File.absolute_path(__FILE__)) + '/fake_bin'
+    FileUtils.mkdir(@fake_dir) unless File.exist?(@fake_dir)
+    @fake_binary = @fake_dir + '/pdflatex'
+    @erbtex = @fake_dir + '/erbtex'
+    FileUtils.touch(@erbtex)
+    FileUtils.chmod(0700, @erbtex)
+    FileUtils.rm_rf(@fake_binary) if File.exists?(@fake_binary)
+    FileUtils.ln_s(@erbtex, @fake_binary)
+
+    # Point to "real" pdflatex to find
+    @real_binary = '/usr/bin/pdflatex'
+    @real_dir = '/usr/bin'
+
+    # Put the fake dir on the PATH before the real dir
+    ENV['PATH'] = @fake_dir + ':' + @real_dir + ':' + ENV['PATH']
+  end
+
+  def teardown
+    FileUtils.rm_rf(@fake_dir)
+  end
+
+  def test_find_pdflatex
+    assert_equal(@real_binary,
+                 ErbTeX.find_executable(@fake_binary))
+  end
+
+  def test_find_pdflatex_with_erbtex
+    assert_equal(@real_binary,
+                 ErbTeX.find_executable(@erbtex))
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+
+# Set up load path for tests.
+
+lib_dir = File.dirname(__FILE__) + '/../lib'
+$:.unshift lib_dir unless $:.include?(lib_dir)
+
+require 'test/unit'
+require 'erbtex'
+require 'fileutils'
+