latex 0.1.1

data/LICENSE.txt

@@ -0,0 +1,58 @@
+Ruby is copyrighted free software by Yukihiro Matsumoto <matz@netlab.co.jp>.
+You can redistribute it and/or modify it under either the terms of the GPL
+(see COPYING.txt file), or the conditions below:
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise
+          make them Freely Available, such as by posting said
+	  modifications to Usenet or an equivalent medium, or by allowing
+	  the author to include your modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) rename any non-standard executables so the names do not conflict
+	  with standard executables, which must also be provided.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may distribute the software in object code or executable
+     form, provided that you do at least ONE of the following:
+
+       a) distribute the executables and library files of the software,
+	  together with instructions (in the manual page or equivalent)
+	  on where to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of
+	  the software.
+
+       c) give non-standard executables non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+     software (possibly commercial).  But some files in the distribution
+     are not written by the author, so that they are not under this terms.
+
+     They are gc.c(partly), utils.c(partly), regex.[ch], st.[ch] and some
+     files under the ./missing directory.  See each file for the copying
+     condition.
+
+  5. The scripts and library files supplied as input to or produced as 
+     output from the software do not automatically fall under the
+     copyright of the software, but belong to whomever generated them, 
+     and may be sold commercially, and may be aggregated with this
+     software.
+
+  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+     PURPOSE.
+

data/README

@@ -0,0 +1,57 @@
+Latex README
+============
+
+  Latex is a ruby library and contains LaTeX text generation support for Ruby.
+  Its main class LatexFile contains:
+  - support for the subfigure environment => LatexFile.figures
+  - complex tables with nested headers and subheaders => LatexFile.table
+  - the method LatexFile.puts indents the given lines according to begin...end
+    blocks.
+
+  The directory examples/ contains a demonstration of the table generating
+  features.
+
+
+Requirements
+------------
+
+  * Ruby 1.8
+
+
+Install
+-------
+
+  De-compress archive and enter its top directory.
+  Then type:
+
+   ($ su)
+    # ruby setup.rb
+
+  This simple step installs this program under the default
+  location of Ruby libraries.  You can also install files into
+  your favorite directory by supplying setup.rb some options.
+  Try "ruby setup.rb --help".
+
+
+  Alternatively you can use the remote installer RubyGems
+  [http://rubygems.rubyforge.org/] for installation.  Having RubyGems installed
+  on your system, just type:
+  
+   ($ su)
+   # gem install latex --remote
+
+
+Usage
+-----
+
+  In order to get an overview of the features you can generate
+  the RDoc documentation and hava a look at the examples/ directory.
+
+
+License
+-------
+
+  Ruby License
+
+
+Christian Bang, cbang AT web.de

data/examples/test-latex.rb

@@ -0,0 +1,40 @@
+require 'latex'
+
+tex=LatexFile.new("latextest.tex")
+rows = {}
+rows["row1"] = {"col1" => "r1c1", "col2"=>"r1c2", "col3"=>["r1c3","3"]}
+rows["row2"] = {"col1" => "r2c1", "col2"=>"r2c2", "Col3"=>["r2c3","1.4","2"]}
+tex.table(rows,"common table")
+
+File.open("saved_table.dat","w") do |f|
+  Marshal::dump(rows, f)
+end
+
+rows = {}
+rows["A1"] = {'B'=> 
+              {'A'=> ['5',6],
+               'C'=> {'F'=>'1','G'=>'2'},
+               'D'=> {'H'=>'3','I'=>'4'}
+               },
+              'X'=>[1,3,55.55]}
+rows["A2"] = {'B'=> 
+              {'C'=> {'F'=>'11','G2'=>'22'},
+               'D'=> {'H'=>'33','I2'=>{'a'=>'44','b'=>'66'}},
+               'E'=> '55'},
+               'X'=>[2.3,5.111,1,4]}
+tex.table(rows,"hierarchical headers", "Rows")
+
+File.open("saved_table.dat","r") do |f|
+  old_rows = Marshal::load(f)
+  rows.merge!(old_rows)
+end
+tex.table(rows,"both tables",:rowTitle=>"Instance") do |x,y|
+  order = %w{X B C D E G F H col1 col2 col3 Col3}
+  if order.index(x) && order.index(y)
+    order.index(x) <=> order.index(y)
+  else
+    x <=> y
+  end
+end
+tex.close
+

data/lib/latex.rb

@@ -0,0 +1,516 @@
+# Copyright (c) 2004 Christian Bang <cbang AT web.de> and Frank Hutter
+#
+# Version 0.1.1
+#
+# All rights reserved. You can redistribute and/or modify it under the same terms as Ruby.
+#
+# This file provides a LatexFile class for Ruby.
+
+class String
+  #Escapes underscores. Use this if you have a string that contains
+  #such but you don't mean the latex semantic of underscore.
+  def escape_
+    gsub(/_/,"\\_")
+  end
+end
+
+#examples: Figure.new("9cm", "image.eps", "Test image")
+#          Figure.new("angle=-90,width=9.5cm", "rotatedimage.eps", "Rotated image", "link01")
+Figure = Struct.new(:format, :filename, :title, :label)
+
+class FormatError < StandardError 
+end
+
+# +LatexFile+ is a +File+ with special functions for easy generation of
+# LaTeX code.
+# Current mayor features are +table+ and +figures+ generation.
+#
+# You may want to quote underscores ('_') in some Latex code you create. For this use String.escape_ which
+# is available with this file.
+class LatexFile < File
+  Header = Struct.new(:name, :children)
+
+  # the default table font size, default is nil which means the Latex default. See #table for possible values
+  attr_accessor :defaultTableFontSize
+
+  @@defaultUsePackages = %w([latin1]{inputenc} [final]{graphics} [pdftex]{graphicx} [dvips]{color} 
+   {amsfonts} {subfigure}  {lscape} {hyperref})
+  @@default_extras = {:fontsize => "10pt" }
+  attr_reader :extras
+
+  # Open a new latex-file for writing.
+  # +extras+ is an optional hash that may contain the following flags
+  # <tt>:landscape</tt>:: turns all pages 90�
+  # <tt>:twocolumn</tt>:: the whole document has two columns
+  # <tt>extras[:fontsize]</tt>:: string containing the font size like "10pt"
+  # === Example:
+  #  f = LatexFile.new("test.tex", {:twocolumn => true, :fontsize => "11pt"})
+  def initialize(filename, extras = nil)
+    super(filename,"w") # open a file for write access
+    @extras = extras || Hash.new
+    #use defaults for unused entries:
+    @extras.each_key{|key| @extras[key] |= @@default_extras[key] }
+    @indent = 0 # indent lines in blocks
+
+    @usePackages = @extras[:usePackages] || @@defaultUsePackages
+
+    writeDocumentHeader
+    @lastWasPrint = false
+  end
+
+  def writeDocumentHeader
+    twocolumn = @extras[:twocolumn] ? ",twocolumn" : ""
+    landscape = @extras[:landscape] ? "\\special{landscape}" : ""
+    puts "\\documentclass[#{@extras[:fontsize]}#{twocolumn}]{article}"
+    @usePackages.each{|package| puts "\\usepackage#{package}"}
+    puts "\\addtolength{\\oddsidemargin}{-3.5cm}"
+    puts "\\addtolength{\\textwidth}{7cm}"
+    puts "\\addtolength{\\topmargin}{-3cm}"
+    puts "\\addtolength{\\textheight}{5cm}"
+    puts "\\newcommand{\\hide}[1]{}"
+    puts "#{landscape}"
+    puts "\\begin{document}"
+    puts "\\DeclareGraphicsExtensions{.jpg,.pdf,.mps,.png}"
+  end
+
+  #Write the latex-file footer and closes the file.
+  def close
+    puts "\\end{document}"
+    super
+  end
+
+  #Prints a string to the latex file and indents each line with respect to the
+  #current indentation level that depends on nested blocks.
+  def puts(string)
+    lines = string.split("\n")
+    for line in lines
+      @indent -= 2 if line[0,5]=='\\end{' && @indent >= 2
+      if @lastWasPrint
+        super(line)
+        @lastWasPrint = false
+      else
+        super(" " * @indent + line)
+      end
+      @indent += 2 if line[0,7]=='\\begin{'
+    end
+  end
+
+  #Insert spaces up to the current indentation level
+  def indent
+    print " "*@indent
+  end
+
+  #Other than puts, print does NOT indent the text. If you want to do so
+  #call +indent+ before.
+  def print(string)
+    @lastWasPrint = true
+    @indent -= 2 if string[/\\end/]
+    @indent += 2 if string[/\\begin/]
+    super(string)
+  end
+
+  # Easy creation of environments.
+  # +name+:: the name of the environment.
+  # +args+:: an optional list of arguments that will be added after the environment definition.
+  # === Example:
+  #  tex.env("table","[ht]") do
+  #    tex.puts "<table body>"
+  #  end
+  def env(name, *args)
+    puts "\\begin{#{name}}#{args}"
+    yield if block_given?
+    puts "\\end{#{name}}"
+  end
+
+  ########### Figure generation #################################################
+
+  #Inserts one (ore more) figure block(s) with given figures as subfigures.
+  #+figures+:: 
+  #  is an array consisting of +Figure+ instances.
+  #  <tt>Figure = Struct.new(:format, :filename, :title)</tt>
+  #  If +format+ begins with a number, it is assumed to be the width of the image.
+  #  But you can also set e.g. <tt>"height=10.5cm,angle=-90"</tt>.
+  #  For more info see the documentation to <tt>\includegraphics </tt> in the
+  #  +graphicx+ package of _LaTeX_.
+  #+caption+:: is placed on each figure block that is created.
+  #+newPageThreshold+:: 
+  #  is maximum the number of figures in a block.
+  #  If more figures are given then a new block is created with the same
+  #  caption.
+  #+placement+:: an optional placement for the figure blocks.
+  #+label+:: an optional label of the figures block ('fig:' is added)
+  #  You can also use label="\\hypertarget{...}" if you like.
+  #  Otherwise a \label{fig:...} is generated.
+  #=== Example:
+  # Experiment = Struct.new(:caption, :figures)
+  # thisExperiment = Experiment.new
+  # thisExperiment.caption = "Instance: #{instance}_1.dat".escape_
+  # thisExperiment.figures = [
+  #   Figure.new("6.5cm", epsDirectory, "#{instance}-a.eps"),
+  #   Figure.new("6.5cm", epsDirectory, "#{instance}-b.eps"),
+  #   Figure.new("14cm",  epsDirectory, "#{instance}-c.eps", "Title for image c)")
+  # ]
+  # tex.figures(thisExperiment.caption, thisExperiment.figures, 3)
+  def figures(caption, figures, newPageThreshold, placement = "htbp", label = nil)
+    lastimagepath = ""
+    figures.each_with_index do |figure,i|
+      figure.title = "[{#{figure.title}}]" unless figure.title == "" or figure.title == nil
+      if i % newPageThreshold == 0
+        puts "\\begin{figure}[#{placement}]"
+        puts "\\caption{#{caption}}"
+        if label
+          if label[0,1]=='\\' #you can use \hypertarget here
+            puts label
+          else
+            puts "\\label{fig:#{label}}" 
+          end
+        end
+        puts "\\centering"
+      end
+      imagepath = File.dirname(figure.filename)
+      puts "\\graphicspath{{#{imagepath}}}" if imagepath != "" and imagepath != "." and lastimagepath != imagepath 
+      lastimagepath = imagepath
+      figure.format = "width="+figure.format if figure.format =~ /^[0-9\.]/
+      if figure.label
+        if figure.label[0,1]=='\\'
+          puts figure.label
+        else
+          puts "\\label{#{figure.label}}" 
+        end
+      end
+      puts "\\subfigure#{figure.title}{\\includegraphics[#{figure.format}]{#{File.basename(figure.filename)}}}"
+      if i % newPageThreshold == newPageThreshold-1 or figure == figures[-1]
+        puts "\\end{figure}"
+        puts "\\clearpage"
+      end
+    end
+  end
+
+  ########### Table Generation functions #################################################
+
+  #This is a helper function for table generation.
+  #It computes the number of columns that are leaves of the tree with root +header_node+.
+  #You can also say, it computes the number of leaves of the given tree.
+  #+header+:: is of type +Header+: (name, children)
+  def getNumColsOfHeader(header)
+    header.children.inject(0) do |numChildren, child|
+      numChildren + ((child.class == Header) ? getNumColsOfHeader(child) : 1)
+    end
+  end
+  private :getNumColsOfHeader
+
+  #+hash+:: must contain hashes as values for all keys.
+  #These child hashes will be joined/merged to one big hash.
+  #The actual leafes will be ignored so that only the header remain.
+  def getHeaderMergedHash(list)
+    merged = {}
+    toMerge = Hash.new {|h,k| h[k] = [] }
+    nothingToMerge = true
+    for entry in list
+      if entry.class == Hash
+        entry.each_pair do |key,value|
+          toMerge[key] << value
+        end
+        nothingToMerge = false
+      end
+    end
+    #return list if nothingToMerge
+    return nil if nothingToMerge #return only header tree without any data
+    toMerge.each_pair do |key,value|
+      merged[key] = getHeaderMergedHash(value)
+    end
+    return merged
+  end
+  private :getHeaderMergedHash
+
+  @@default_sort = Proc.new { |x,y| x <=> y }
+
+  #Given a list of hashes, initially a hash-list of each row it
+  #returns a sorted tree representation - a headerList.
+  #+sort_block+:: a block that compares header names
+  def hash2HeaderList(hash, sort_block = @@default_sort)
+    headerList = []
+    entries = hash.to_a
+    entries.sort! {|x,y| sort_block.call(x[0],y[0])}
+    for key,value in entries
+      if value.class == Hash
+        subtree = hash2HeaderList(value, sort_block)
+        headerList << Header.new(key,subtree)
+      else
+        headerList << key
+      end
+    end
+    return headerList
+  end
+  private :hash2HeaderList
+
+  #Performes a breath first traversal of the given tree
+  #+headerList+:: a list of header nodes of class +Header+.
+  #Returns a list of headers (together with the number of columns they use) for each header line needed.
+  #example: <tt>[['B',['C',['F','G']], ['D',['H','I']],['E']]]</tt> =>
+  #<tt>[['B'], ['C','D','E'], ['F','G','H','I']]</tt> and with their column width information 
+  #if the (sub)header covers more than one column =>
+  #<tt>[[['B',5]], [['C',2],['D',2],'E'], ['F','G','H','I']]</tt>
+  #The length of the returned list is the number of rows needed for the headers.
+  def getHeaderLines(headerList) #:nodoc:
+    line = []
+    nextLevel = [] # collects the children nodes of all nodes processed (BFS)
+    hasChildrenInNextLevel = false
+    for header in headerList
+      if header.class != Header
+        line << header #leaf node will not be put in an array with column width info
+        nextLevel += ["~"] # insert this for lines below this
+      else
+        line << [header.name, getNumColsOfHeader(header)]
+        nextLevel += header.children
+        hasChildrenInNextLevel = true
+      end
+    end
+    return hasChildrenInNextLevel ? [line] + getHeaderLines(nextLevel) : [line]      
+  end
+  private :getHeaderLines
+
+  #Returns a list of paths to all leaf nodes of the given header-tree list. The Leaf nodes are the final
+  #columns. In order to compute the table value at (row,col) we want to access only the leaf cols and not
+  #the header columns. 
+  #Example: let <tt>[['B',['C',['F','G']], ['D',['H','I']],['E']]]</tt> be our
+  #header tree. The real columns are F,G,H,I,E. In order to access e.g. 'I' we need to know the path [B,D,I].
+  #<tt> => [["B", "C", "F"], ["B", "C", "G"], ["B", "D", "H"], ["B", "D", "I"], ["B", "E"]]</tt>
+  def getLeafColumns(headerList, path_prefix = nil) #:nodoc:
+    paths = []
+    path_prefix = path_prefix || []
+    for header in headerList
+      if header.class == Header
+        paths += getLeafColumns(header.children, path_prefix + [header.name])
+      else #header is not of class Header but a leaf header (string)
+        paths << path_prefix + [header]
+      end
+    end
+    return paths
+  end
+  private :getLeafColumns
+
+  #Pretty print output of table entries. If an entry is an array then
+  #+prettyPrintCell+ will be called for every table item. You can override this
+  #function if you like a special behaviour.
+  def prettyPrintCell(x)
+    if x.kind_of?(Integer)
+      x = "%d" % x
+    elsif x.kind_of?(Float)
+      x = "%.2f" % x
+    else
+      x = x.to_s
+    end
+    raise(FormatError, "Invalid format: #{x.inspect} contains % that is not sufficiently quoted for latex.", caller) if x =~ /[^\\]%|^%/
+    x.gsub(/1.#J|Infinity|1.#INF0/, "$\\infty$")
+  end
+
+
+  # Generates a table with the specified entries.
+  # +entries+:: 
+  #   the row-hash where the keys are the row names which are printed in the first column.
+  #   The <tt>entries[row]</tt> is a column-hash. Its keys are the column names.
+  #   A column-hash value can be either
+  #   - an object (with a <tt>to_s</tt> method) that are printed
+  #   - an array containing objects. In this case a new row is added for each array entry
+  #   - a hash in which case the keys of this hash are subheaders.
+  # +caption+:: the caption of the table.
+  # +args+:: 
+  #   is either a hash or further arguments
+  #   Case 1:: 
+  #     The hash is indexed by one of the argument symbols below, the values correspond to the
+  #     argument values you want to set to the corresponding argument.
+  #     Instead of symbols you can also use strings, e.g. <tt>:label</tt> or <tt>"label"<</tt>
+  #   Case 2::
+  #     args are some more arguments. Then they will be interpreted as the following arguments
+  #     in the same order. You need not use all of them.
+  #   <tt>:rowTitle</tt>:: the title of the first column that contains the row names.
+  #   <tt>:label</tt>:: the label of the table. The "tab:" prefix is added automatically .
+  #   <tt>:newTableThreshold</tt>::
+  #     maximum number of lines per table. If reached then a new table will be created.
+  #     Zero means no restriction. An empty row (entries[name] == nil) also toggles a new table.
+  #   <tt>:placement</tt>:: the LaTeX placement for the table. See the LaTeX documentation for details.
+  #   <tt>:empty</tt>:: a string that will be put in those fields that have no value.
+  #   <tt>:sort</tt>:: 
+  #     is used to sort the rows and columns. Default is alphabetical ordering.
+  #     See the example below to get an idea on how to implement customized ordering.
+  #   <tt>:landscape</tt>:: if true, it will turn the page by 90 degree.
+  #   <tt>:fontSize</tt>:: 
+  #     A latex fontsize modifier like tiny, scriptsize, footnotesize, small, 
+  #     normalsize (default), large, Large, LARGE, huge, Huge.
+  #   <tt>:header_hlines</tt>:: 
+  #     If +true+, then horizontal lines between headers of different depths are drawn.
+  #     Default is +false+ (no horizontal header lines).
+  #
+  # === Example:
+  #  require 'latex'
+  #  tex = LatexFile.new("table.tex")
+  #  rows["row1"] = {'Main Header'=> 
+  #                  {'A'=> '5',
+  #                   'B'=> {'D'=>'1','E'=>'2'},
+  #                   'C'=> {'F'=>'3','G'=>'4'}},
+  #                   'X'=> [1,3,55.55]}
+  #  tex.table(rows,"table with hierarchical headers",:rowTitle=>"Instance")
+  #  tableSort = Proc.new do |x,y|
+  #    order = %w{A X B C D E}
+  #    (order.index(x) && order.index(y)) ? order.index(x) <=> order.index(y) : x <=> y
+  #  end
+  #  tex.table(rows,"special ordering", :rowTitle=>"Instance", :sort => tableSort) 
+  def table(entries, caption, *args)
+    tableValidArgs = [:rowTitle, :label, :newTableThreshold, :placement, :empty, :sort, :landscape, :fontSize, :grouping, :header_hlines]
+#    raise(ArgumentError,"Too many arguments Latex.table", caller) unless args.length <= 1
+    hash = {}
+    args = if args[0].kind_of?(Hash)
+             args[0].each_pair{|key,value| hash[key.to_sym]= value}; hash # allow string keys also
+           else
+             args.each_with_index{|arg,i| hash[tableValidArgs[i].to_sym] = arg}; hash
+           end
+    args.each_key{|key| raise(ArgumentError,"Invalid argument: #{key} for Latex.table", caller) unless tableValidArgs.include?(key)}
+    @tableCaption     = caption
+    rowTitle          = args[:rowTitle] || ""
+    @tableLabel       = args[:label] || ""
+    newTableThreshold = args[:newTableThreshold] || (args[:landscape] ? 38 : 60)
+    placement         = args[:placement] || "htbp"
+    empty             = args[:empty] ||"-"
+    sort_block        = args[:sort] ||@@default_sort
+    grouping = args[:grouping] || [entries.keys]
+    @tableLandscape   = args[:landscape]
+    @tableFontSize    = args[:fontSize] || @defaultTableFontSize
+    @header_hlines    = args[:header_hlines]
+
+    #access an element in the table which is located in row _rowName_ and in a column
+    #that is defined by a _path_ through the headers that can be obtained with
+    #the function +getLeafColumns+.
+    def accessElement(entries, rowName, path) #:nodoc:
+      entry = entries[rowName]
+      for key in path
+        entry = entry[key]
+        return [] unless entry
+      end
+      return entry.is_a?(Array) ? entry : [entry]
+    end
+
+    def printTableHeader(placement, headerLines, leafColumns, rowTitle) #:nodoc:
+      puts "\\begin{landscape}" if @tableLandscape
+      puts "\n\\begin{table}[#{placement}]\n\\begin{center}"
+      puts "\\#{@tableFontSize}" if @tableFontSize
+      print " "*@indent + "\\begin{tabular}{|"
+      print "c|" * (leafColumns.length+1)
+      puts "}"
+      currentHeaderRowNumber = 0
+      puts "\\hline"
+      for headerLine in headerLines
+        print " "*@indent
+        if headerLine == headerLines[-1]
+          print "#{rowTitle} & " # row name title comes in the last header line
+        else
+          print "~ & "
+        end
+        currentColumn = 2
+        cline = ""
+        print headerLine.map {|headerName, columns|
+          raise(FormatError, "Invalid format: #{headerName.inspect} contains % that is not sufficiently quoted for latex.", caller) if headerName =~ /[^\\]%|^%/
+          if columns
+            cline += "\\cline{#{currentColumn}-#{(currentColumn+=columns)-1}}" if @header_hlines
+            "\\multicolumn{#{columns}}{c|}{#{headerName}}"
+          else
+            currentColumn += 1
+            if currentHeaderRowNumber == headerLines.length-1 || headerName == "~"
+              headerName
+            else
+              delta = "%.1f" % ((headerLines.length-currentHeaderRowNumber-1).to_f)
+              "\\raisebox{-#{delta}\\totalheight}[1ex][1ex]{#{headerName}}"
+            end
+          end
+        }.join(" & ")
+        puts "\\\\"+cline
+        currentHeaderRowNumber += 1
+      end
+      puts "\\hline\\hline"
+    end
+
+    def printTableFooter #:nodoc:
+      puts "\\end{tabular}"
+      puts "\\caption{#{@tableCaption}}\n\\label{tab:#@tableLabel}"
+      puts "\\end{center}\n\\end{table}\n"
+      puts "\\end{landscape}" if @tableLandscape
+    end
+
+    #====== Generate header
+    headerList = hash2HeaderList(getHeaderMergedHash(entries.values), sort_block)
+    headerLines = getHeaderLines(headerList)
+    leafColumns = getLeafColumns(headerList)
+    printTableHeader(placement, headerLines, leafColumns, rowTitle)
+
+    currentRow = 0
+    for row_names in grouping
+      #======= Compute table break for multiple groupings.
+      new_lines = 0
+      for row_name in row_names
+        max_lines_per_entry = 1
+        for col_header in leafColumns
+          max_lines_per_entry = [max_lines_per_entry, accessElement(entries,row_name,col_header).length].max
+        end
+        new_lines += max_lines_per_entry
+      end
+      
+      if (currentRow > 0 and currentRow + new_lines >= newTableThreshold)
+        currentRow = 0
+        printTableFooter # close last table
+        printTableHeader(placement, headerLines, leafColumns, rowTitle) # open new table    
+      else
+        unless currentRow == 0
+          puts "\\hline" unless row_names == []
+          currentRow += 0.5
+        end
+      end
+      
+      row_names.sort! &sort_block
+      #====== Generate entries.
+      for row_name in row_names
+        if (newTableThreshold > 0 and currentRow >= newTableThreshold)
+          currentRow = 0
+          printTableFooter # close last table
+          printTableHeader(placement, headerLines, leafColumns, rowTitle) # open new table    
+        end
+        max_lines_per_entry = 1
+        for col_header in leafColumns
+          max_lines_per_entry = [max_lines_per_entry, accessElement(entries,row_name,col_header).length].max
+        end
+	
+        for i in 0...max_lines_per_entry
+          #print row-name
+          print " "*@indent
+          output = (i==0 ? row_name.to_s.gsub(/_/,"\\_") : "~")
+          delta = "%.1f" % ((max_lines_per_entry-1).to_f)
+          output = "\\raisebox{-#{delta}\\totalheight}[1ex][1ex]{#{output}}" if max_lines_per_entry > 1
+          print output
+          
+          #print the other columns
+          for col_header in leafColumns
+            entry = accessElement(entries,row_name,col_header)
+            if entry[i]
+              output = prettyPrintCell(entry[i])
+              delta = "%.1f" % (max_lines_per_entry-entry.length).to_f
+            else
+              output = (i==0 ? empty : "~")
+              delta = max_lines_per_entry
+            end
+            #Center the entries vertically in the cell. Out-comment this if you don't like that.
+            if entry.length != max_lines_per_entry# && entry.length > 0
+              output = "\\raisebox{-#{delta}\\totalheight}[1ex][1ex]{#{output}}" unless output == "~"
+            end
+            print " & " + output
+          end
+          puts "\\\\"
+        end
+        puts "\\hline" 
+        currentRow += max_lines_per_entry
+      end
+    end
+    #====== Generate footer.
+    printTableFooter
+  end
+end
+
+

metadata

@@ -0,0 +1,39 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.1
+specification_version: 1
+name: latex
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+date: 2004-09-30
+summary: Latex is a LaTeX text generation library for Ruby.
+require_paths: 
+  - lib
+author: Christian Bang
+email: cbang AT web.de
+homepage: http://latex.rubyforge.org
+rubyforge_project: latex
+description: 
+autorequire: latex/latex
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+files: 
+  - lib/latex.rb
+  - README
+  - LICENSE.txt
+  - examples/test-latex.rb
+test_files: []
+rdoc_options: []
+extra_rdoc_files: []
+executables: []
+extensions: []
+requirements: []
+dependencies: []