erbtex 0.3.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: ba2d024e5db40939058098d4ee6cc9c3efa58c19
-  data.tar.gz: da8fc247a17a3e51ae2e8fa75a2f75eded1ace51
+SHA256:
+  metadata.gz: 73e049b2407795a0ba4acd0b5e0bb7f962c072695ba245f6a42d12b96bdfea41
+  data.tar.gz: e15af14509ec54c2fbc4fc4bfadb75d5ff04a0a74b5fb4e1b581cd4d1abae978
 SHA512:
-  metadata.gz: 2bd38f093f3703bf0c1c55b3a649044d776aa68b7ef6243ebcea344e4eaa4cdab0b2b872ac62bf94f910028c92019ede620467084d54c43fedfe43d824c45c7f
-  data.tar.gz: e44d3414536cb37057be45e48d28f7c7a599f8732ed8a5ee1db803e5e7e35ae08805b1b6f73e675c650edc5d2c962b485826e163111aed8d774dc695f27da4c7
+  metadata.gz: bc69c3a51c63e9514e3fba20a05df2a567328235440e07d49ac612d08c902ac994a1a9687f4916d07b59a51c77c2d98073f2839ad0473ff9594ec62a7fa7e67d
+  data.tar.gz: 60e4929df42ca88888703ccb57d2a424ed5120d9ed1c25bd4f0feece9ee16878eb1fdd6118ffd0ddc2a9aee49c8133bf1a311ba5934b4c03139e7c610f6f6fc4

data/Gemfile.lock

@@ -1,48 +1,58 @@
 PATH
   remote: .
   specs:
-    erbtex (0.3.0)
+    erbtex (0.4.1)
       erubis
+      fat_core
 
 GEM
   remote: https://rubygems.org/
   specs:
-    byebug (3.5.1)
-      columnize (~> 0.8)
-      debugger-linecache (~> 1.2)
-      slop (~> 3.6)
+    activesupport (5.2.3)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    byebug (11.0.1)
     coderay (1.1.2)
-    columnize (0.9.0)
-    debugger-linecache (1.2.0)
-    diff-lcs (1.2.5)
+    concurrent-ruby (1.1.5)
+    damerau-levenshtein (1.3.1)
+    diff-lcs (1.3)
     erubis (2.7.0)
-    method_source (0.9.0)
-    minitest (5.5.0)
-    pry (0.11.3)
+    fat_core (4.5.0)
+      activesupport
+      damerau-levenshtein
+    i18n (1.6.0)
+      concurrent-ruby (~> 1.0)
+    method_source (0.9.2)
+    minitest (5.11.3)
+    pry (0.12.2)
       coderay (~> 1.1.0)
       method_source (~> 0.9.0)
-    pry-byebug (3.0.1)
-      byebug (~> 3.4)
+    pry-byebug (3.7.0)
+      byebug (~> 11.0)
       pry (~> 0.10)
-    pry-doc (0.11.1)
-      pry (~> 0.9)
-      yard (~> 0.9)
-    rake (10.3.2)
-    rspec (3.3.0)
-      rspec-core (~> 3.3.0)
-      rspec-expectations (~> 3.3.0)
-      rspec-mocks (~> 3.3.0)
-    rspec-core (3.3.1)
-      rspec-support (~> 3.3.0)
-    rspec-expectations (3.3.0)
+    pry-doc (1.0.0)
+      pry (~> 0.11)
+      yard (~> 0.9.11)
+    rake (12.3.2)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.3)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.3.0)
-    rspec-mocks (3.3.1)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.3.0)
-    rspec-support (3.3.0)
-    slop (3.6.0)
-    yard (0.9.12)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+    thread_safe (0.3.6)
+    tzinfo (1.2.5)
+      thread_safe (~> 0.1)
+    yard (0.9.19)
 
 PLATFORMS
   ruby
@@ -58,4 +68,4 @@ DEPENDENCIES
   rspec
 
 BUNDLED WITH
-   1.16.0
+   1.17.3

data/README.org

@@ -2,9 +2,9 @@
 
 ** Description
 
-~erbtex~ is a ruby gem that provides a command line program that pre-processes
-TeX and LaTeX source files with ruby's erubis and then passes the resulting file
-along to a real TeX program.
+~erbtex~ is a ruby gem that provides the ~erbtex~ command line program that
+pre-processes TeX and LaTeX source files with ruby's [[http://www.kuwata-lab.com/erubis][erubis]] and then passes
+the resulting file along to a real TeX program.
 
 ** Installation
 
@@ -16,35 +16,40 @@ Install ~erbtex~ with:
 
 ** Usage
 
-After the gem is installed, ~erbtex~ is placed in your PATH. ~erbtex~ recognizes
-only one command-line option, --invoke=<tex_program>, which specifies what TeX
-variant will process the TeX file after erubis has pre-proceesed the input file.
-By default, ~erubis~ uses ~pdflatex~ if no --invoke option is given.
+After the gem is installed, ~erbtex~ is placed in your PATH. ~erbtex~
+recognizes only one command-line option, ~--invoke=<tex_program>~, which
+specifies what TeX variant will process the TeX file after erubis has
+pre-proceesed the input file.  By default, ~erbtex~ uses ~pdflatex~ if no
+--invoke option is given.
 
-~Erbtex~ will then read the input file and execute any ruby code between the
-special delimiters `{:` and `:}` instead of the erubis default of `<% %>`. The
-brace-colon form of delimiters is less disruptive of syntax highlighting than
-the default delimiters, which get confused with TeX and LaTeX comments. Any text
-not between the delimiters is passed through untouched to the TeX program.
+~Erbtex~ reads the input file and executes any ruby code between the special
+delimiters ~{:~ and ~:}~.  This brace-colon form of delimiters is less
+disruptive of syntax highlighting than ~erubis~'s default delimiters ~<%~ and
+~%>~ delimiters, which often get confused by syntax-enabled editors with TeX
+and LaTeX comments.
 
-If the opening delimiter has an ~=~ appended to it, the delimited ruby
-expression is converted into a string (with ruby's ~.to_s~ method) and inserted
-in-place into the TeX manuscript at that point. For example, the text ~{:=
-"Hello, world".reverse :}~ places the string ~'dlrow ,olleH'~ at that point in
-the TeX file.
+If the opening delimiter is instead ~{:=~, the delimited ruby expression is
+converted into a string (with ruby's ~.to_s~ method) and inserted in-place
+into the TeX manuscript at that point. For example, the text ~{:= "Hello,
+world".reverse :}~ places the string ~dlrow ,olleH~ at that point in the TeX
+file.
 
-Without the `=` the ruby code is simply executed. You can use these, for
-example, to ~require~ ruby libraries or to embed loops into the file.
+Any text /not/ enclosed in these delimiters is passed through untouched to the
+TeX program.
 
-Loops started in one ruby fragment can be continued or terminated in a later
-fragment, and variables defined in one fragment in one fragment are visible in
-later fragments according to Ruby's usual scoping rules. The result is that you
-can use the ruby programming language to greatly increase the computational
+Without the `=` the ruby code is simply executed. You can use these, for
+example, to ~require~ ruby libraries or to embed loops into the file.  Loops
+started in one delimited ruby fragment can be continued or terminated in a
+later fragment, and variables defined in one fragment are accessible in later
+fragments according to Ruby's usual scoping rules. The result is that you can
+use the ruby programming language to greatly increase the computational
 capabilities of a normal TeX or LaTeX.
 
-The resulting output is then processed as a normal TeX file.
+You can get the version with the --version flag and help with --help.
 
-** Example
+** Examples
+
+*** Square Roots
 
 For example, the following LaTeX file will produce a table of square
 roots when run through erbtex.  It uses a ruby iterator to supply the
@@ -68,6 +73,7 @@ LaTeX.
   % The following line starts a ruby enumerator loop but does not
   % produce any output, since the delimiters are {: :}.
   {: 0.upto(100).each do |x| :}
+
   % But the following two lines produce output since the opening delimiter is
   % '{:='. Both call the sprintf method in ruby via the percent operator, and the
   % second line calls ruby's Math module to compute the square root. Notice that
@@ -76,19 +82,20 @@ LaTeX.
 
     {:= "\\mathversion{bold}$%0.4f$" % x :}&
     {:= "$%0.8f$" % Math.sqrt(x) :}\\
+
+  % End of the loop started above.
   {: end :}
-  \end{longtable}
+    \end{longtable}
   \end{document}
 #+END_SRC
 
-With the above in file `roots.tex`, running `$ erbtex roots.tex` at the command
-line will generate a `PDF` file with a nicely typeset table of square roots.
-
-As a by-product, the pre-processed file ~roots.etx~ is left in the same
-directory, so you can see what the effect of the erbtex fragments were. This is
-often very handy when you are trying to debug the document; otherwise, feel free
-to delete it. Here, for example is a portion of the `roots.etx` file generated
-by the foregoing:
+With the above in file ~roots.tex~, running ~$ erbtex roots.tex~ at the
+command line will generate a `PDF` file with a nicely typeset table of square
+roots.  The generated pdf file can be seen [[file:examples/roots.pdf][here]].  As a by-product, the
+pre-processed file ~roots.etx~ is left in the same directory, so you can see
+what the effect of the erbtex fragments were. This is often very handy when
+you are trying to debug the document; otherwise, feel free to delete it. Here,
+for example is a portion of the `roots.etx` file generated by the foregoing:
 
 #+BEGIN_SRC latex
     \begin{document}
@@ -133,5 +140,8 @@ by the foregoing:
 
 And many more lines like it.
 
+*** Trigonometry Table
+
 The examples directory installed with the erbtex gem has a few more
-examples.
+examples, including a [[file:examples/TrigTable2.pdf][large trigonometry table]] generated from a relatively
+small [[file:examples/TrigTable2.tex][input file]].

data/erbtex.gemspec

@@ -23,6 +23,7 @@ Gem::Specification.new do |gem|
   gem.require_paths = ['lib']
 
   gem.add_dependency 'erubis'
+  gem.add_dependency 'fat_core'
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'bundler'
   gem.add_development_dependency 'rspec'

data/examples/TrigTable.tex

@@ -56,10 +56,10 @@
 ## increments of step
 
    require 'bigdecimal'
-   step = BigDecimal.new("0.001")
+   step = BigDecimal("0.001")
    one = BigDecimal("1.0")
    z0 = BigDecimal("0.0")
-   p2 = BigDecimal.new((Math::PI / 2.0).to_s)
+   p2 = BigDecimal((Math::PI / 2.0).to_s)
 -:}
 
 %% Treat the first line of the table, for an x value of 0 specially
@@ -76,10 +76,10 @@
 %% x one step beyond 0 and pre-computes some of the functions
 {:   x = z0 + step
      while (x < p2) do
-      tanx = BigDecimal.new(Math.tan(x).to_s)
-      cotx = one / BigDecimal.new(Math.tan(x).to_s)
-      secx = one / BigDecimal.new(Math.cos(x).to_s)
-      cscx = one / BigDecimal.new(Math.sin(x).to_s)
+      tanx = BigDecimal(Math.tan(x).to_s)
+      cotx = one / BigDecimal(Math.tan(x).to_s)
+      secx = one / BigDecimal(Math.cos(x).to_s)
+      cscx = one / BigDecimal(Math.sin(x).to_s)
 :}
 
 {:
@@ -122,4 +122,4 @@
 
 %% End the table and document---this version comes to 315 pages!
 \end{longtable}
-\end{document}
+\end{document}

data/lib/erbtex/command_line.rb

@@ -1,26 +1,28 @@
-# -*- coding: utf-8 -*-
+# coding: utf-8
 
+# Name space for erbtex command.
 module ErbTeX
   class NoInputFile < StandardError; end
 
+  # Class to record and manipulate the command line typed by the user.
   class CommandLine
-    attr_reader :erbtex_name, :tex_program, :tex_options
-    attr_reader :tex_commands, :input_file
+    attr_reader :erbtex_name, :tex_program, :tex_args, :tex_commands
+    attr_reader :input_file, :print_version, :print_help
 
     def initialize(argv)
       # Note: argv will be the command line arguments after processing by the
-      # shell, so if we see things such as '&', '~', '\' in the args, these were
-      # quoted by the user on the command-line and need no special treatment
-      # here. For example, '~/junk' on the commandline will show up here as
-      # '/home/ded/junk'. If we see '~/junk', that means the user has quoted the
-      # ~ on the command line with something like '\~junk', so we should assume
-      # that the user wants to keep it that way. Likewise, an arg with spaces in
-      # it will have been quoted by the user to be seen as a single argument.
-      # When we output these for use by the shell in the system command, we
-      # should apply shellquote to everything so that the receiving shell sees
-      # the args in the same way.
-
-      @erbtex_name = File.basename($0)
+      # shell, so if we see things such as '&', '~', '\' in the args, these
+      # were quoted by the user on the command-line and need no special
+      # treatment here. For example, '~/junk' on the commandline will show up
+      # here as '/home/ded/junk'. If we see '~/junk', that means the user has
+      # quoted the ~ on the command line with something like '\~junk', so we
+      # should assume that the user wants to keep it that way. Likewise, an
+      # arg with spaces in it will have been quoted by the user to be seen as
+      # a single argument.  When we output these for use by the shell in the
+      # system command, we should apply shellquote to everything so that the
+      # receiving shell sees the args in the same way.
+
+      @erbtex_name = File.basename($PROGRAM_NAME)
 
       # Find the tex_commands
       @tex_commands = []
@@ -39,8 +41,23 @@ module ErbTeX
         argv.reject! { |a| a =~ /\A--invoke=(\w+)/ }
       end
 
+      # Look for our --version
+      @print_version = false
+      if argv.any? { |a| a =~ /\A--version/ }
+        @print_version = true
+        argv.reject! { |a| a =~ /\A--version/ }
+      end
+
+      # Look for our --help
+      @print_help = false
+      if argv.any? { |a| a =~ /\A--help/ }
+        @print_help = true
+        argv.reject! { |a| a =~ /\A--help/ }
+      end
+
       # The last argument, assuming it does not start with a '-' or '&', is
       # assumed to be the name of the input_file.
+      @input_file = nil
       if !argv.empty? && argv[-1] !~ /\A[-&]/
         @input_file = CommandLine.expand_input_file(argv.pop)
       end
@@ -48,12 +65,12 @@ module ErbTeX
       # What remains in argv should be the tex program's '-options', which
       # should be passed through untouched. So, can form the full command line
       # for tex_processing
-      @tex_options = argv.dup
+      @tex_args = argv.dup
     end
 
     def tex_command(tex_file = input_file)
       "#{tex_program} " \
-      "#{tex_options.shelljoin} " \
+      "#{tex_args.shelljoin} " \
       "#{tex_commands.shelljoin} " \
       "#{tex_file}"
         .strip.squeeze(' ')
@@ -62,19 +79,25 @@ module ErbTeX
     # Return the name of the input file based on the name given in the command
     # line. Try to find the right extension for the input file if none is given.
     def self.expand_input_file(input_file)
-      full_ext = input_file[/\A(.*)(\.[\w.]+)\z/, 2]
-      if full_ext.nil? || full_ext.empty?
-        if File.exist?("#{input_file}.tex.erb")
-          "#{input_file}.tex.erb"
-        elsif File.exist?("#{input_file}.tex")
-          "#{input_file}.tex"
-        elsif File.exist?("#{input_file}.erb")
-          "#{input_file}.erb"
+      return '' if input_file.blank?
+
+      md = %r{\A(.*)(\.[\w.]+)?\z}.match(input_file)
+      if md
+        input_base = md[1]
+        input_ext = md[2]
+      end
+      if input_ext.nil?
+        if File.exist?("#{input_base}.tex.erb")
+          "#{input_base}.tex.erb"
+        elsif File.exist?("#{input_base}.tex")
+          "#{input_base}.tex"
+        elsif File.exist?("#{input_base}.erb")
+          "#{input_base}.erb"
         else
-          input_file
+          input_base
         end
       else
-        input_file
+        input_base
       end
     end
   end
@@ -111,14 +134,14 @@ end
 # 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
+# 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
+# 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
+# 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
@@ -126,5 +149,5 @@ end
 
 # 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
+# as '.tex') are added by default and no exhaustive path searching is
 # done, the input name is simply checked as given.

data/lib/erbtex/runner.rb

@@ -1,44 +1,52 @@
 require 'tempfile'
 require 'pathname'
+require 'English'
 
+# Name space module for erbtex program.
 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 other than the erbtex
-  # default '{: :}'.  Erubis normally by uses '<%= %>' by default.  Erubis -p
-  # commandline -p '\.{ }\.'
-
-  # 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 self.run(cl)
-    tex_dir = input_dir(cl.input_file)
-    tex_file = erb_to_tex(cl.input_file, tex_dir) if cl.input_file
-    run_tex(cl.tex_command(tex_file), tex_dir)
+  def self.run(cmd_line)
+    report_version && exit(0) if cmd_line.print_version
+    report_help && exit(0) if cmd_line.print_help
+
+    tex_dir = input_dir(cmd_line.input_file)
+    tex_file = erb_to_tex(cmd_line.input_file, tex_dir) if cmd_line.input_file
+    run_tex(cmd_line.tex_command(tex_file), tex_dir)
+  end
+
+  def self.report_version
+    puts "erbtex version: #{ErbTeX::VERSION}"
+    puts "Ruby version: #{RUBY_VERSION}"
+    begin
+      erubis_version = `erubis -v`
+    rescue Errno::ENOENT
+      warn 'Warning: erubis does not appear to be installed!'
+      exit(1)
+    end
+    puts "erubis version: #{erubis_version}"
+    true
+  end
+
+  def self.report_help
+    puts <<~HELP
+      Usage: erbtex [erbtex_options] [tex_prog_args] [file]
+
+      erbtex_options are:
+        --version           - print the version of the erbtex gem, ruby and erubis
+        --help              - print this help message
+        --invoke=<tex_prog> - after pre-processing, invoke <tex_prog> on the
+                              resulting file, tex_prog is pdflatex by default
+
+      All other arguments, except possibly the last, are passed unaltered to
+      the tex_prog for interpretation.  If any of these arguments starts with a
+      '\\' or '&', then all remaining arguments are passed to tex-prog for
+      interpretation, even the final argument.
+
+      The last argument is taken as the input file name unless it  or any earlier
+      argument starts with a '\\' or '&', in which case it is also passed along
+      as an argument to the tex-prog.
+
+    HELP
+    true
   end
 
   # Run the TeX program, adding add_dir to the front of TEXINPUTS, unless it is
@@ -54,26 +62,29 @@ module ErbTeX
       end
     end
     unless system(cmd)
-      $stderr.puts "Call to '#{cmd}' failed."
-      exit $?.exitstatus
+      warn "Call to '#{cmd}' failed."
+      exit $CHILD_STATUS
     end
-    $?
+    $CHILD_STATUS
   end
 
   def self.input_dir(in_file)
     return nil unless in_file
+
     in_file_absolute = File.absolute_path(File.expand_path(in_file))
-    in_file_absolute[/\A(.*\/)([^\/.]+)(\.[\w.]+)\z/, 1]
+    in_file_absolute[%r{\A(.*/)([^/.]+)(\.[\w.]+)\z}, 1]
   end
 
   # Pre-process the input file with erubis, adding the add_dir to the front of
   # the ruby load path if its not already in the load path.  Return the name of
   # the processed file.
   def self.erb_to_tex(in_file, add_dir = nil)
-    add_dir = File.absolute_path(File.expand_path(add_dir))
-    unless $LOAD_PATH
-             .any? { |p| add_dir == File.absolute_path(File.expand_path(p)) }
-      $LOAD_PATH.unshift(add_dir)
+    if File.exist?(add_dir)
+      add_dir = File.absolute_path(File.expand_path(add_dir))
+      unless $LOAD_PATH
+               .any? { |p| add_dir == File.absolute_path(File.expand_path(p)) }
+        $LOAD_PATH.unshift(add_dir)
+      end
     end
 
     in_contents = nil
@@ -82,134 +93,59 @@ module ErbTeX
     end
     # TODO: recurse through any \input or \include commands
 
-    pat =
-      if ENV['ERBTEX_PATTERN']
-        ENV['ERBTEX_PATTERN']
-      else
-        '{: :}'
-      end
+    pat = ENV['ERBTEX_PATTERN'] || '{: :}'
 
-    out_file = set_out_file(in_file)
+    out_file = out_file_name(in_file)
     File.open(out_file, 'w') do |f|
       er = ::Erubis::Eruby.new(in_contents, pattern: pat)
       f.write(er.result)
     end
     out_file
-  rescue SystemCallError => ex
-    $stderr.puts "Error: #{ex}"
+  rescue SystemCallError => e
+    warn "Error: #{e}"
     exit 1
-  rescue ScriptError => ex
-    $stderr.puts "Erubis pre-processing failed: #{ex}"
+  rescue ScriptError => e
+    warn "Erubis pre-processing failed: #{e}"
     exit 1
   end
 
-  def self.set_out_file(in_file)
+  def self.out_file_name(in_file)
     in_file_absolute = File.absolute_path(File.expand_path(in_file))
-    in_dir = in_file_absolute[/\A(.*\/)([^\/.]+)(\.[\w.]+)\z/, 1]
-    in_base = in_file_absolute[/\A(.*\/)([^\/.]+)(\.[\w.]+)\z/, 2]
-    in_ext = in_file_absolute[/\A(.*\/)([^\/.]+)(\.[\w.]+)\z/, 3]
-
-    if in_ext.empty?
-      if File.exists?("#{in_file}.tex.erb")
-        out_ext = '.tex'
-      elsif File.exists?("#{in_file}.tex")
-        out_ext = '.etx'
-      elsif File.exists?("#{in_file}.erb")
-        out_ext = '.tex'
-      else
-        out_ext = '.tex'
-      end
-    else
-      case in_ext
-      when '.tex.erb'
-        out_ext = '.tex'
-      when '.tex'
-        out_ext = '.etx'
-      when '.erb'
-        out_ext = '.tex'
-      else
-        out_ext = '.tex'
-      end
-    end
+    in_dir = File.dirname(in_file_absolute)
+    in_base = File.basename(in_file_absolute)
+    in_ext = File.extname(in_file_absolute)
+
+    out_ext = if in_ext.empty?
+                if File.exist?("#{in_file}.tex.erb")
+                  '.tex'
+                elsif File.exist?("#{in_file}.tex")
+                  '.etx'
+                elsif File.exist?("#{in_file}.erb")
+                  '.tex'
+                else
+                  '.tex'
+                end
+              else
+                case in_ext
+                when '.tex.erb'
+                  '.tex'
+                when '.tex'
+                  '.etx'
+                when '.erb'
+                  '.tex'
+                else
+                  '.tex'
+                end
+              end
 
     # Find a writable directory, prefering the one the input file came
     # from, or the current directory, and a temp file as a last resort.
     if File.writable?(in_dir)
-      out_file = File.join(in_dir, "#{in_base}#{out_ext}")
+      File.join(in_dir, "#{in_base}#{out_ext}")
     elsif File.writable?('.')
-      out_file = File.join('.', "#{in_base}#{out_ext}")
+      File.join('.', "#{in_base}#{out_ext}")
     else
-      out_file = Tempfile.new([in_base, out_ext]).path
+      Tempfile.new([in_base, out_ext]).path
     end
-    out_file
   end
 end
-  # 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))
-  #     end
-  #     new_progname = ErbTeX.find_executable(command.lstrip.split(' ')[0])
-  #     cmd = cl.new_command_line(new_progname, new_infile)
-  #     cmd.sub!('\\', '\\\\\\')
-  #     cmd.sub!('&', '\\\\&')
-  #     puts "Executing: #{cmd}"
-  #     system(cmd)
-  #   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

data/lib/erbtex/version.rb

@@ -1,3 +1,3 @@
 module ErbTeX
-  VERSION = "0.3.0"
+  VERSION = "0.4.1"
 end

data/lib/erbtex.rb

@@ -8,8 +8,8 @@ require 'bundler/setup' if $LOAD_PATH.none? { |p| p =~ /erbtex/ }
 
 require 'shellwords'
 require 'erubis'
+require 'fat_core'
 
 require 'erbtex/version'
 require 'erbtex/command_line'
-require 'erbtex/find_binary'
 require 'erbtex/runner'

data/spec/lib/command_line_spec.rb

@@ -18,6 +18,17 @@ module ErbTeX
             -recorder -shell-escape -src-specials cr,display,hbox,math,par
             -translate-file willy -version &myformat file_name.tex.erb
           )
+        @argv_with_invoke_and_file =
+          %w(
+            --invoke=lualatex
+            -draftmode -enc -etex -file-line-error -fmt junk
+            -halt-on-error -ini -interaction batchmode -ipc -ipc-start
+            -jobname junk -kpathsea-debug 8 -mktex tex --invoke=pdflatex
+            -mltex -nomktex tfm -ouptput-comment This\ is\ a\ long\ comment
+            -output-directory ~/texmf/tex -parse-first-line -progname pdflatex
+            -recorder -shell-escape -src-specials cr,display,hbox,math,par
+            -translate-file willy -version &myformat file_name.tex.erb
+          )
         @argv_with_cmds =
           %w(
             -draftmode -enc -etex -file-line-error -fmt junk
@@ -58,6 +69,22 @@ module ErbTeX
         EOS
       end
 
+      it 'parse command line with invoke and file name' do
+        cl = CommandLine.new(@argv_with_invoke_and_file)
+        expect(cl.erbtex_name).to eq('erbtex')
+        expect(cl.tex_program).to eq('lualatex')
+        expect(cl.input_file).to eq('file_name.tex.erb')
+        expect(cl.tex_command).to eq(<<~'EOS'.tr("\n", ' ').strip)
+          lualatex -draftmode -enc -etex -file-line-error -fmt junk -halt-on-error
+          -ini -interaction batchmode -ipc -ipc-start -jobname junk -kpathsea-debug 8
+          -mktex tex -mltex -nomktex tfm
+          -ouptput-comment This\ is\ a\ long\ comment
+          -output-directory \~/texmf/tex -parse-first-line -progname pdflatex
+          -recorder -shell-escape -src-specials cr,display,hbox,math,par
+          -translate-file willy -version \&myformat file_name.tex.erb
+        EOS
+      end
+
       it 'parse command line with TeX commands' do
         cl = CommandLine.new(@argv_with_cmds)
         expect(cl.erbtex_name).to eq('erbtex')

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: erbtex
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Daniel E. Doherty
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: fat_core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -146,16 +160,14 @@ files:
 - examples/TrigTable.tex
 - examples/TrigTable2.tex
 - examples/dms.rb
-- examples/roots.tex.erb
+- examples/roots.tex
 - examples/testbind.rb
-- examples/testbind.tex.erb
+- examples/testbind.tex
 - lib/erbtex.rb
 - lib/erbtex/command_line.rb
-- lib/erbtex/find_binary.rb
 - lib/erbtex/runner.rb
 - lib/erbtex/version.rb
 - spec/lib/command_line_spec.rb
-- spec/lib/find_executable_spec.rb
 - spec/spec_helper.rb
 homepage: ''
 licenses: []
@@ -175,8 +187,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Preprocesses TeX and LaTeX files with erubis for ruby.

data/lib/erbtex/find_binary.rb

@@ -1,41 +0,0 @@
-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/spec/lib/find_executable_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-
-module ErbTeX
-  describe 'FindExecutable' do
-    # 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.
-    before :all do
-      # 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.exist?(@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
-
-    after :all do
-      FileUtils.rm_rf(@fake_dir)
-    end
-
-    it 'should find the real executable from fake' do
-      expect(ErbTeX.find_executable(@fake_binary)).to eq @real_binary
-    end
-
-    it 'should find the real executable from erbtex' do
-      expect(ErbTeX.find_executable(@erbtex)).to eq @real_binary
-    end
-
-  end
-end