erbtex 0.4.3 → 0.5.0

data/bin/erbtex

@@ -1,8 +1,29 @@
 #! /usr/bin/env ruby
+#
+# frozen_string_literal: true
 
 require 'erbtex'
 
+# Name space module for erbtex's ruby pre-processing of TeX and LaTeX files by
+# ruby.
 module ErbTeX
-  cl = CommandLine.new(ARGV)
-  exit ErbTeX.run(cl).exitstatus
+  if ARGV.empty?
+    warn 'usage: erbtex [LaTex_filename]'
+    exit(1)
+  end
+
+  begin
+    cl = CommandLine.new(ARGV)
+    status = ErbTeX.run(cl)
+  rescue OutputExists => e
+    warn "Warning: #{e}"
+    status = 1
+  rescue SystemCallError, ArgumentError, NoInputFile => e
+    warn "Error: #{e}"
+    status = 1
+  rescue ScriptError => e
+    warn "Erubis pre-processing failed: #{e}"
+    status = 1
+  end
+  exit status
 end

data/erbtex.gemspec

@@ -1,33 +1,32 @@
-# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
 
-require "./lib/erbtex/version.rb"
+require './lib/erbtex/version'
 
 Gem::Specification.new do |gem|
-  gem.name = %q{erbtex}
+  gem.name = 'erbtex'
+  gem.license = 'MIT'
   gem.version = ErbTeX::VERSION
   gem.platform = Gem::Platform::RUBY
-  gem.date = %q{2012-05-13}
   gem.homepage = 'https://github.com/ddoherty03/erbtex'
   gem.authors = ['Daniel E. Doherty']
-  gem.email = %q{ded@ddoherty.net}
-  gem.summary = %q{Preprocesses TeX and LaTeX files with erubis for ruby.}
-  gem.description = %q{erbtex will act just like pdflatex except that it will
+  gem.email = 'ded@ddoherty.net'
+  gem.summary = 'Preprocesses TeX and LaTeX files with erubis for ruby.'
+  gem.description = 'erbtex will act just like pdflatex except that it will
                      process ruby fragments between {: and :} markers,
                      greatly expanding the ability to generate
-                     automated TeX and LaTeX documents.}
-  gem.files         = `git ls-files`.split("\n")
+                     automated TeX and LaTeX documents.'
+  gem.files = %x(git ls-files).split("\n")
   gem.files.delete_if { |f| f =~ /\.(log|etc|aux|etx|pdf|gem|tmp)$/ }
-  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.executables   = %x(git ls-files -- bin/*).split("\n").map { |f| File.basename(f) }
   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'
   gem.add_development_dependency 'minitest'
   gem.add_development_dependency 'pry'
-  gem.add_development_dependency 'pry-doc'
   gem.add_development_dependency 'pry-byebug'
+  gem.add_development_dependency 'pry-doc'
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rspec'
 end

data/examples/TrigTable2.tex

@@ -55,7 +55,7 @@
 ## increments of step.
 
    require 'bigdecimal'
-   require 'dms'
+   require_relative 'dms'
    DMS.precision = 0
    step = DMS.new(0, 0, 30)
    one = BigDecimal("1.0")
@@ -130,4 +130,4 @@
 \end{longtable}
 \end{document}
 
-% Take /that/ Charles Babbage!
+% Take /that/ Charles Babbage!

data/examples/dms.rb

@@ -1,27 +1,30 @@
-#! /usr/bin/ruby
+#! /usr/bin/env ruby
+#
+# frozen_string_literal: true
+
+require_relative "int_ext"
 
 # A class for maipulating angles expressed as degreed, minutes,
 # and seconds.
 class DMS
   include Comparable
 
-  attr_reader :degrees, :minutes, :seconds
-
-  @@precision = 4
+  attr_accessor :degrees, :minutes, :seconds, :precision
 
-  def initialize(deg, min = 0, sec = 0.0)
+  def initialize(deg, min = 0, sec = 0.0, precision: 4)
     @degrees = deg.to_i
     @minutes = min.to_i
     @seconds = sec.to_f
+    @precision = precision
     normalize
   end
 
   def self.from_radians(rad)
-    if rad < 0
+    if rad.negative?
       rad = -rad
-      sign = -1
+      -1
     else
-      sign = 1
+      1
     end
     deg = rad * (360.0 / (2.0 * Math::PI))
     degrees = deg.floor
@@ -31,16 +34,12 @@ class DMS
     DMS.new(degrees, minutes, seconds)
   end
 
-  def self.precision=(p)
-    @@precision = p
-  end
-
   def to_s
-    "#{@degrees}* #{@minutes}' %0.*f''" % [@@precision, @seconds]
+    format("#{degrees}* #{minutes}' %0.*f''", precision, seconds)
   end
 
   def to_f
-    @degrees.to_f + (@minutes / 60.0) + (@seconds / 3600.0)
+    degrees.to_f + (minutes / 60.0) + (seconds / 3600.0)
   end
 
   def to_radians
@@ -50,13 +49,11 @@ class DMS
   # If degrees are at well-known values, eppress as radians
   # symbolically, using TeX notation
   def to_radians_tex
-    unless @seconds == 0.0 and @minutes == 0
-      return '$%0.*f$' % [@@precision, to_radians]
-    end
+    return format('$%0.*f$', precision, to_radians) unless (@seconds == 0.0) && @minutes.zero?
 
     # This gets deg to 0 <= x <= 360, even for negative
     # values of @degrees
-    deg = @degrees.divmod(360)[1]
+    deg = degrees.divmod(360)[1]
     case deg
     when 0
       '$0$'
@@ -85,20 +82,20 @@ class DMS
     when 360
       '$2\\pi$'
     else
-      '$%0.*f$' % [@@precision, to_radians]
+      format('$%0.*f$', precision, to_radians)
     end
   end
 
   def to_tex
-    "$%02d^\\circ~%02d'~%02.*f''$" % [@degrees, @minutes, @@precision, @seconds] #"
+    format("$%02d^\\circ~%02d'~%02.*f''$", degrees, minutes, precision, seconds) # "
   end
 
   def -@
-    DMS.new(-@degrees, @minutes, @seconds)
+    DMS.new(-degrees, minutes, seconds)
   end
 
   def +@
-    DMS.new(@degrees, @minutes, @seconds)
+    DMS.new(degrees, minutes, seconds)
   end
 
   def <=>(other)
@@ -106,23 +103,23 @@ class DMS
   end
 
   def +(other)
-    seconds = @seconds + other.seconds
-    minutes = @minutes + other.minutes
-    degrees = @degrees + other.degrees
+    seconds += other.seconds
+    minutes += other.minutes
+    degrees += other.degrees
     DMS.new(degrees, minutes, seconds)
   end
 
   def -(other)
-    r = (self + (-other))
-    DMS.new(r.degrees, r.minutes, r.seconds)
+    diff = (self + -other)
+    DMS.new(diff.degrees, diff.minutes, diff.seconds)
   end
 
-  def *(scalar)
-    DMS.new(scalar*@degrees, scalar*@minutes, scalar*@seconds)
+  def *(other)
+    DMS.new(other * degrees, other * minutes, other * seconds)
   end
 
-  def /(scalar)
-    DMS.new(@degrees / scalar, @minutes / scalar, @seconds / scalar)
+  def /(other)
+    DMS.new(@degrees / other, @minutes / other, @seconds / other)
   end
 
   def sin
@@ -153,28 +150,16 @@ class DMS
   # After normalization, only degrees can be negative,
   # which will represent a negative quantity
   def normalize
-    q, r = @seconds.divmod(60.0)
-    @seconds = r
-    @minutes += q
-    q, r = @minutes.divmod(60)
-    @minutes = r
-    @degrees += q
-  end
-end
-
-class Integer
-  alias times *
-  def *(other)
-    case other
-    when DMS
-      other * self
-    else
-      times(other)
-    end
+    q, r = seconds.divmod(60.0)
+    self.seconds = r
+    self.minutes += q
+    q, r = minutes.divmod(60)
+    self.minutes = r
+    self.degrees += q
   end
 end
 
-if __FILE__ == $0
+if __FILE__ == $PROGRAM_NAME
   print "Fifty seconds in radians: #{DMS.new(0, 0, 50).to_radians}\n"
   print "One minute in radians: #{DMS.new(0, 1, 0).to_radians}\n"
   print "Fifty seconds in degrees: #{DMS.new(0, 0, 50).to_f}\n"

data/examples/int_ext.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class Integer
+  alias_method :times, :*
+  def *(other)
+    case other
+    when DMS
+      other * self
+    else
+      times(other)
+    end
+  end
+end

data/examples/testbind.rb

@@ -1,3 +1,4 @@
-x = 1957
+# frozen_string_literal: true
 
+# rubocop:disable-next Style/GlobalVars
 $x = 1957

data/lib/erbtex/command_line.rb

@@ -1,4 +1,4 @@
-# coding: utf-8
+# frozen_string_literal: true
 
 # Name space for erbtex command.
 module ErbTeX
@@ -6,61 +6,46 @@ module ErbTeX
 
   # Class to record and manipulate the command line typed by the user.
   class CommandLine
-    attr_reader :erbtex_name, :tex_program, :tex_args, :tex_commands
-    attr_reader :input_file, :print_version, :print_help
+    attr_reader :erbtex_name, :tex_program, :tex_args, :tex_commands, :input_file, :print_version, :print_help
+    attr_reader :preprocess_only, :no_clobber
 
     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.
+      # Arguments have already been split by the shell. Preserve each string
+      # unchanged and pass it directly to the TeX process.
 
       @erbtex_name = File.basename($PROGRAM_NAME)
 
       # Find the tex_commands
       @tex_commands = []
-      if argv.any? { |a| a =~ /\A\\/ }
+      if argv.any? { |a| a.start_with?('\\') }
         # All args after first starting with '\' should be interpreted as TeX
         # commands, even if they don't start with '\'
         @tex_commands = argv.drop_while { |a| a !~ /\A\\/ }
         first_tex_command_k = argv.size - @tex_commands.size
-        argv = argv[0..first_tex_command_k - 1]
+        argv = argv.take(first_tex_command_k)
       end
 
-      # Look for our --invoke=tex_command option
-      @tex_program = 'pdflatex'
-      if argv.any? { |a| a =~ /\A--invoke=(\w+)/ }
-        @tex_program = $1
-        argv.reject! { |a| a =~ /\A--invoke=(\w+)/ }
+      # Keep the complete executable name, including paths and punctuation.
+      invoke_options = argv.select { |argument| argument.start_with?('--invoke=') }
+      if invoke_options.include?('--invoke=')
+        raise ArgumentError, '--invoke requires a nonempty executable name'
       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
+      @tex_program = invoke_options.first&.delete_prefix('--invoke=') || 'pdflatex'
+      argv = argv.reject { |argument| argument.start_with?('--invoke=') }
 
-      # Look for our --help
-      @print_help = false
-      if argv.any? { |a| a =~ /\A--help/ }
-        @print_help = true
-        argv.reject! { |a| a =~ /\A--help/ }
-      end
+      @print_version = argv.include?('--version')
+      @print_help = argv.include?('--help')
+      @preprocess_only = argv.include?('--preprocess-only')
+      @no_clobber = argv.include?('--no-clobber')
+      argv = argv.reject { |argument| argument == '--version' || argument == '--help' }
+      argv = argv.reject { |argument| argument == '--preprocess-only' }
+      argv = argv.reject { |argument| argument == '--no-clobber' }
 
       # 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 = ErbTeX.expand_input_file(argv.pop)
-      end
+      @input_file = ErbTeX.expand_input_file(argv.pop) if !argv.empty? && argv[-1] !~ /\A[-&]/
 
       # What remains in argv should be the tex program's '-options', which
       # should be passed through untouched. So, can form the full command line
@@ -69,11 +54,7 @@ module ErbTeX
     end
 
     def tex_command(tex_file = input_file)
-      "#{tex_program} " \
-      "#{tex_args.shelljoin} " \
-      "#{tex_commands.shelljoin} " \
-      "#{tex_file}"
-        .strip.squeeze(' ')
+      [tex_program, *tex_args, tex_file, *tex_commands].compact
     end
   end
 end

data/lib/erbtex/file_names.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+# Name space module for ErbTeX.
 module ErbTeX
   # Given an arbitrary file name, parse it into its components in one go.  It
   # separates three parts of a filename: (1) the directory, if any, (2) the
@@ -5,7 +8,7 @@ module ErbTeX
   # name rather than an extension, and (3) any extension, including a compound
   # extension such as .tex.erb
   def self.parse_file_name(path)
-    fn_re = %r{\A(?<dir>([^\/]*\/)*)  (?<base>.?[^\/.]*)  (?<ext>\.[\w.]+)?}x
+    fn_re = %r{\A(?<dir>([^/]*/)*)  (?<base>.?[^/.]*)  (?<ext>\.[\w.]+)?}x
     md = fn_re.match(path)
     { dir: md[:dir], base: md[:base], ext: md[:ext] }
   end

data/lib/erbtex/runner.rb

@@ -1,17 +1,33 @@
+# frozen_string_literal: true
+
 require 'tempfile'
 require 'pathname'
 require 'English'
 
 # Name space module for erbtex program.
 module ErbTeX
+  GENERATED_MARKER = '% Generated by erbtex. Changes may be overwritten.'
+
+  class OutputExists < StandardError; end
+
   # Perform the erubis pre-processing and the TeX processing on the input
-  # file.
+  # file. Return an exit status; preprocessing errors propagate to the caller.
   def self.run(cmd_line)
-    report_version && exit(0) if cmd_line.print_version
-    report_help && exit(0) if cmd_line.print_help
+    return report_version if cmd_line.print_version
+
+    if cmd_line.print_help
+      report_help
+      return 0
+    end
+
+    if cmd_line.preprocess_only && !cmd_line.input_file
+      raise NoInputFile, '--preprocess-only requires an input file'
+    end
+
+    in_dir = parse_file_name(cmd_line.input_file)[:dir] if cmd_line.input_file
+    tex_file = erb_to_tex(cmd_line.input_file, in_dir, no_clobber: cmd_line.no_clobber) if cmd_line.input_file
+    return 0 if cmd_line.preprocess_only
 
-    in_dir = parse_file_name(cmd_line.input_file)[:dir]
-    tex_file = erb_to_tex(cmd_line.input_file, in_dir) if cmd_line.input_file
     run_tex(cmd_line.tex_command(tex_file), in_dir)
   end
 
@@ -19,13 +35,13 @@ module ErbTeX
     puts "erbtex version: #{ErbTeX::VERSION}"
     puts "Ruby version: #{RUBY_VERSION}"
     begin
-      erubis_version = `erubis -v`
+      erubis_version = %x(erubis -v)
     rescue Errno::ENOENT
       warn 'Warning: erubis does not appear to be installed!'
-      exit(1)
+      return 1
     end
     puts "erubis version: #{erubis_version}"
-    true
+    0
   end
 
   # Display the help for erbtex.
@@ -36,6 +52,9 @@ module ErbTeX
       erbtex_options are:
         --version           - print the version of the erbtex gem, ruby and erubis
         --help              - print this help message
+        --no-clobber        - refuse to overwrite any existing preprocessed file
+        --preprocess-only   - generate the preprocessed file without invoking TeX
+                              (requires an input file)
         --invoke=<tex_prog> - after pre-processing, invoke <tex_prog> on the
                               resulting file, tex_prog is pdflatex by default
 
@@ -49,7 +68,6 @@ module ErbTeX
       as an argument to the tex-prog.
 
     HELP
-    true
   end
 
   # Run the TeX program on the erubis-processed output file, which is the
@@ -57,7 +75,9 @@ module ErbTeX
   def self.run_tex(cmd, in_dir = nil)
     # If the input file is located in another directory (in_dir), add that
     # directory to TEXINPUTS if its not already there so that the input file
-    # can \include or \input files using relative file names.
+    # can \include or \input files using relative file names.  Place it after
+    # the current directory '.' so that an plain file name is still
+    # interpreted relative to the current working directory.
     new_env = {}
     if in_dir
       in_dir = File.absolute_path(File.expand_path(in_dir))
@@ -65,32 +85,39 @@ module ErbTeX
       unless ENV['TEXINPUTS'].split(File::PATH_SEPARATOR)
                .reject { |p| p.strip.empty? }
                .any? { |p| in_dir == File.absolute_path(File.expand_path(p)) }
-        new_env['TEXINPUTS'] = "#{in_dir}:#{ENV['TEXINPUTS']}"
+        new_env['TEXINPUTS'] = ".:#{in_dir}:#{ENV['TEXINPUTS']}"
       end
     end
     # Call cmd with the environment augmented by possibly expanded TEXINPUTS
     # environment variable.
-    unless system(new_env, cmd)
-      warn "Call to '#{cmd}' failed."
-      exit $CHILD_STATUS
+    warn "TEXINPUTS set to: #{new_env['TEXINPUTS']}"
+    unless system(new_env, [cmd.first, cmd.first], *cmd.drop(1))
+      warn "Call to '#{cmd.shelljoin}' failed."
+      return $CHILD_STATUS.exitstatus || 128 + $CHILD_STATUS.termsig
     end
     # Run a second time unless its latexmk
-    unless cmd =~ /\A *latexmk/
-      unless system(new_env, cmd)
-        warn "Call to '#{cmd}' failed."
-        exit $CHILD_STATUS
+    unless File.basename(cmd.first) == 'latexmk'
+      warn "TEXINPUTS set to: #{new_env['TEXINPUTS']}"
+      unless system(new_env, [cmd.first, cmd.first], *cmd.drop(1))
+        warn "Call to '#{cmd.shelljoin}' failed."
+        return $CHILD_STATUS.exitstatus || 128 + $CHILD_STATUS.termsig
       end
     end
-    $CHILD_STATUS
+    $CHILD_STATUS.exitstatus
   end
 
   # Pre-process the input file with erubis, adding the in_dir to the front of
   # the ruby load path if its not already in the load path so that requires in
   # the input file can be found if they are in the in_dir.  Return the name of
   # the output file.
-  def self.erb_to_tex(in_file, in_dir = nil)
+  def self.erb_to_tex(in_file, in_dir = nil, no_clobber: false)
+    out_file = ErbTeX.out_file_name(in_file)
+    check_output_file(out_file, no_clobber: no_clobber)
+
+    warn '================================================================'
+    warn 'Erubis phase of processing ...'
     # Add input to ruby LOAD_PATH, $:,if its not already there.
-    if File.exist?(in_dir)
+    if in_dir && File.exist?(in_dir)
       in_dir = File.absolute_path(File.expand_path(in_dir))
       unless $LOAD_PATH
                .any? { |p| in_dir == File.absolute_path(File.expand_path(p)) }
@@ -99,6 +126,7 @@ module ErbTeX
     end
 
     # Read the input
+    warn "  Erubis reading from #{in_file}..."
     in_contents = nil
     File.open(in_file) do |f|
       in_contents = f.read
@@ -107,17 +135,31 @@ module ErbTeX
 
     pat = ENV['ERBTEX_PATTERN'] || '{: :}'
 
-    out_file = ErbTeX.out_file_name(in_file)
-    File.open(out_file, 'w') do |f|
-      er = ::Erubis::Eruby.new(in_contents, pattern: pat)
-      f.write(er.result)
+    rendered = ::Erubis::Eruby.new(in_contents, pattern: pat, filename: in_file).result
+    warn "  Erubis writing to #{out_file}..."
+    # Keep the temporary file beside its destination so rename is atomic.
+    Tempfile.create([".#{File.basename(out_file)}-", '.tmp'], File.dirname(out_file)) do |f|
+      f.puts(GENERATED_MARKER)
+      f.write(rendered)
+      f.close
+      check_output_file(out_file, no_clobber: no_clobber)
+      File.rename(f.path, out_file)
     end
+    warn 'done'
+    warn '================================================================'
     out_file
-  rescue SystemCallError => e
-    warn "Error: #{e}"
-    exit 1
-  rescue ScriptError => e
-    warn "Erubis pre-processing failed: #{e}"
-    exit 1
+  end
+
+  def self.check_output_file(out_file, no_clobber: false)
+    return unless File.exist?(out_file)
+
+    if no_clobber
+      raise OutputExists, "Refusing to overwrite #{out_file}: --no-clobber is set"
+    end
+
+    first_line = File.open(out_file, &:gets)
+    return if first_line&.chomp == GENERATED_MARKER
+
+    raise OutputExists, "Refusing to overwrite #{out_file}: missing erbtex generated-file marker"
   end
 end

data/lib/erbtex/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ErbTeX
-  VERSION = '0.4.3'
+  VERSION = '0.5.0'
 end

data/lib/erbtex.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 # Conditional added to prevent running bundler/setup twice when it already has
 # erbtex in the LOAD_PATH.  Failure to do this was causing bundler to setup for
 # the wrong Gemfile if it was run in the development directory of another gem,
 # for example, ydl.  This only happened on saturn for some reason that I don't
 # understand, but this kludge made it work.
 
-require 'bundler/setup' if $LOAD_PATH.none? { |p| p =~ /erbtex/ }
+require 'bundler/setup' if $LOAD_PATH.none? { |p| p.include?('erbtex') }
 
 require 'shellwords'
 require 'erubis'