# The LaTeX class.
# Note that methods with a ! in them work like the * versions of the LaTeX
# functions, and methods with a ? in them do not print a newline.
# Alternatively, you can use _star and _suppress, if you prefer a more
# English-like syntax.
class LaTeX
  def initialize()
    @nesting = 0
    @indent = "  "
  end

  # Allows the user to change the default indenting (default is two spaces
  # per nesting)
  attr_accessor :indent

  # Return the string for a newline
  def newline()
    return "\\\n"
  end

  # Return the string for a newline that won't break a page
  def newline!()
    return "\\*\n"
  end

  # Return a string for the LaTeX symbol
  def latex()
    return "\\LaTeX"
  end

  # Return a string for a comment, ended with a carriage-return
  def comment(comment)
    return "% #{comment}\n"
  end

  # Let % be an alternative way to specify a comment
  alias_method :%, :comment #,

  # Return an indented string, terminated by a newline if it isn't a comment
  # that is already newline-terminated
  def indent(str)
    s = indent?(str)
    if not s =~ /^\s*%.*\n/ then
      s << "\n"
    end
    return s
  end

  # Return an indented string that is never newline-terminated
  def indent?(str)
    s = ""
    @nesting.times do
      s << @indent
    end
    s << str
    return s
  end

  # Create a new LaTeX command
  def newcommand(cmd, func)
    method_missing("newcommand", "\\#{cmd}", func)
  end

  # Print a LaTeX command using the rules specified above
  def method_missing(symbol, *args)
    symbol = symbol.to_s.gsub('!', '*')
    symbol = symbol.to_s.gsub('_star', '*')
    nl = !(symbol =~ /(\?|_suppress)\*$/)
    symbol = symbol.gsub('\?', '')
    symbol = symbol.gsub('_suppress', '')
    s = ""
    if block_given? then
      s << __begin__(symbol, *args) << __gen_newline__(nl)
      nesting_tmp = @nesting
      @nesting = @nesting.succ
      s << proc.call()
      @nesting = nesting_tmp
      s << __end__(symbol) << __gen_newline__(nl)
    else
      s << indent?("\\#{symbol}#{__arg_list__(args)}#{__gen_newline__(nl)}")
    end
    return s
  end

  alias_method :__cmd__, :method_missing
  alias_method :__env__, :method_missing

  # Return the arguments of a LaTeX function; Use an array to specify
  # optional arguments
  def __arg_list__(args)
    s = ""
    args.each do |arg|
      case arg
      when Array
        s << "["
        arg.each do |a|
          s << "#{a},"
        end
        s.chop!
        s << "]"
      else
        s << "{#{arg}}"
      end
    end
    return s
  end

  # Return a newline if nl is true, otherwise return an empty string
  def __gen_newline__(nl)
    return nl ? "\n" : ""
  end

  def __begin__(symbol, *args)
    return indent?("\\begin{#{symbol}}#{__arg_list__(args)}")
  end

  def __end__(symbol)
    return indent?("\\end{#{symbol}}")
  end
end

if __FILE__ == $0 then
  l = LaTeX.new
  s =
  l.documentclass("article") +
  l.newcommand("foo", l.latex) +
  l.newenvironment("myitemize", l.__begin__("itemize"), l.__end__("itemize")) +
  l.document {
    l.title("#{l.LARGE?} This is a test") +
    l.author("Me") +
    l.date() +
    l.maketitle() +

    l.section("Writing #{l.foo_suppress} documents in Ruby") {
      l.indent(l % "This is a comment.") +
      l.indent("I can put text here.")
    } +

    l.section("More about #{l.foo_suppress} and Ruby") {
      l.myitemize {
        l.item?(["a)"]) + "This is item a.\n" +
        l.item?(["b)"]) + "This is item b.\n"
      }
    }
  }
  puts s
end