rods 0.7.0 → 0.8.0

data/Manifest

@@ -1,5 +1,4 @@
 Manifest
 README
 Rakefile
-lib/example.rb
 lib/rods.rb

data/README

@@ -1,11 +1,13 @@
  = RODS - Ruby Open Document Spreadsheet
  This class provides a convenient interface for reading and writing 
- spreadsheets conforming to Open Document Format v1.1. with Ruby 1.9.1 and 1.8.7..
+ spreadsheets conforming to Open Document Format v1.1.
  Installiation of an office-application (LibreOffice, OpenOffice.org) is not required as the code directly 
- manipulates the XML-files in the zipped *.ods-container.
+ manipulates the XML-files in the zipped *.ods-container. The mere prerequisites are 
+   gem install zip
+   gem install rods
 
  On my website http://ruby.homelinux.com/ruby/rods/ you can see the output of the script below.
- You can contact me at rodsdotrubyatonlinedotde (and drop me a line, if you like it ;-).
+ You can contact me at rods.ruby@online.de (and tell me about experiences, problems you encountered or drop me a line, if you like it ;-).
 
  link:images/Rods.jpg
  
@@ -14,6 +16,14 @@
  Licensed under the same terms as Ruby. No warranty is provided.
 
  = Changelog
+ * 0.8.0
+   * new function
+     * insertColumn
+   cf. Example 0.8.0 below
+ * 0.7.5
+   * new functions
+     * insertRowAbove, insertRowBelow, insertCellBefore, insertCellAfter
+   cf. Example 0.7.5 below
  * 0.7.0 
    * added new function
      * getCellsAndIndicesFor(expression)
@@ -284,51 +294,54 @@
        puts("not so much: #{text} bucks") # -> "not so much: -7.78 bucks"
      end
    end
- 
- = Example for additions in 0.6.1
 
-   #!/usr/bin/ruby
-   # coding: UTF-8
-   #
-   # Author: Dr. Heinz Breinlinger
-   #
-   require 'rubygems'
-   require 'rods'
+ = Example 0.8.0
 
-   mySheet=Rods.new("Template.ods")
-   mySheet.insertTableAfter("Tabelle1","Neue Tabelle")
-   mySheet.insertTableAfter("Neue Tabelle","Neue Tabelle2")
-   mySheet.insertTableAfter("Neue Tabelle2","Neue Tabelle3")
-   mySheet.insertTableAfter("Tabelle3","Neue Tabelle4")
-   mySheet.insertTableBefore("Tabelle1","Vor1")
-   mySheet.insertTableBefore("Neue Tabelle4","Vor4")
-   mySheet.saveAs("Test2.ods")
-   puts("done")
+   #  #!/usr/bin/ruby
+   #  # coding: UTF-8
+   #  #
+   #  # Author: Dr. Heinz Breinlinger
+   #  #
+   #  require 'rubygems'
+   #  require 'rods'
+   #
+   #  mySheet=Rods.new("Template.ods")
+   #  1.upto(3){ |row|
+   #    1.upto(4){ |col|
+   #      mySheet.writeCell(row,col,"time","13:47")
+   #    }
+   #  }
+   #  #-----------------------------------------------------
+   #  # inserting new column -> shifting existing columns
+   #  #-----------------------------------------------------
+   #  mySheet.insertColumn(3) 
+   #  1.upto(3){ |row|
+   #    mySheet.writeCell(row,3,"string","o' clock")
+   #  }
+   #  mySheet.saveAs("Test7.ods")
 
- = Example for additions in 0.6.2
+ = Example 0.7.5
 
-   #!/usr/bin/ruby
-   # coding: UTF-8
+   #  #!/usr/bin/ruby
+   #  # coding: UTF-8
+   #  #
+   #  # Author: Dr. Heinz Breinlinger
+   #  #
+   #  require 'rubygems'
+   #  require 'rods'
    #
-   # Author: Dr. Heinz Breinlinger
-   #
-   require 'rubygems'
-   require 'rods'
-
-   mySheet=Rods.new("Template.ods")
-   cell=mySheet.writeGetCell(3,3,"string","Underline")
-   mySheet.setAttributes(cell,{ "style:text-underline-color" => "blue",
-                                "style:text-underline-style" => "solid",
-                                "style:text-underline-width" => "auto"})
-   cell=mySheet.writeGetCell(4,4,"string","Underline_Default_with_Black")
-   #----------------------------------------------------------------------
-   # if not specified otherwise, width and color are set to default
-   # - black
-   # - solid
-   #----------------------------------------------------------------------
-   mySheet.setAttributes(cell,{ "style:text-underline-style" => "solid" })
-   mySheet.saveAs("Test3.ods")
-   puts("done")
+   #  mySheet=Rods.new("Template.ods")
+   #  mySheet.writeCell(1,1,"string","oneOne")
+   #  mySheet.writeCell(1,2,"string","oneTwo")
+   #  mySheet.writeCell(2,1,"string","twoOne") # finally becomes cell 3,1
+   #  mySheet.writeCell(2,2,"string","twoTwo") # finally becomes cell 3,2
+   #  row=mySheet.getRow(1)
+   #  newRow=mySheet.insertRowBelow(row)
+   #  mySheet.writeCell(2,1,"string","twoNewOne")
+   #  cell=mySheet.writeGetCell(2,2,"string","moved") # finally becomes cell "2,3"
+   #  mySheet.insertCellBefore(cell)
+   #  mySheet.writeCell(2,2,"string","twoNewTwoNew")  # new cell "2,2"
+   #  mySheet.saveAs("Test6.ods")
 
  = Example 0.7.0
 
@@ -350,7 +363,7 @@
    #    :row  => rowIndex,
    #    :col  => colIndex}]
    #  
-   # Regular expressions for 'content' are alllowd but must be enclosed in 
+   # Regular expressions for 'content' are allowed but must be enclosed in 
    # single (not double) quotes !
    #
    # In case of no matches at all, an empty array is returned.
@@ -368,7 +381,7 @@
    # The following finds all occurences of a comma- or dot-separated number,
    # consisting of 1 digit before and 2 digits behind the decimal-separator.
    #-------------------------------------------------------------------------
-   result=mySheet.getCellsAndIndicesFor('\d{1}[.,]\\d{2}')
+   result=mySheet.getCellsAndIndicesFor('\d{1}[.,]\d{2}')
    result.each{ |cellHash|
      puts("----------------------------------------------")
      puts("Node: #{cellHash[:cell]}") # Be aware: Prints out whole node ! ;-)
@@ -376,6 +389,51 @@
      puts("Column: #{cellHash[:col]}")
    }
    puts("done")
+
+ = Example for additions in 0.6.2
+
+   #!/usr/bin/ruby
+   # coding: UTF-8
+   #
+   # Author: Dr. Heinz Breinlinger
+   #
+   require 'rubygems'
+   require 'rods'
+
+   mySheet=Rods.new("Template.ods")
+   cell=mySheet.writeGetCell(3,3,"string","Underline")
+   mySheet.setAttributes(cell,{ "style:text-underline-color" => "blue",
+                                "style:text-underline-style" => "solid",
+                                "style:text-underline-width" => "auto"})
+   cell=mySheet.writeGetCell(4,4,"string","Underline_Default_with_Black")
+   #----------------------------------------------------------------------
+   # if not specified otherwise, width and color are set to default
+   # - black
+   # - solid
+   #----------------------------------------------------------------------
+   mySheet.setAttributes(cell,{ "style:text-underline-style" => "solid" })
+   mySheet.saveAs("Test3.ods")
+   puts("done")
+ 
+ = Example for additions in 0.6.1
+
+   #!/usr/bin/ruby
+   # coding: UTF-8
+   #
+   # Author: Dr. Heinz Breinlinger
+   #
+   require 'rubygems'
+   require 'rods'
+
+   mySheet=Rods.new("Template.ods")
+   mySheet.insertTableAfter("Tabelle1","Neue Tabelle")
+   mySheet.insertTableAfter("Neue Tabelle","Neue Tabelle2")
+   mySheet.insertTableAfter("Neue Tabelle2","Neue Tabelle3")
+   mySheet.insertTableAfter("Tabelle3","Neue Tabelle4")
+   mySheet.insertTableBefore("Tabelle1","Vor1")
+   mySheet.insertTableBefore("Neue Tabelle4","Vor4")
+   mySheet.saveAs("Test2.ods")
+   puts("done")
  
  = Caveat
 

data/Rakefile

@@ -2,8 +2,8 @@ require 'rubygems'
 require 'rake'
 require 'echoe'
 
-Echoe.new('rods', '0.7.0') do |p|
-  p.description    = "OpenOffice.org oocalc: Fast automated batch-processing of spreadsheets (*.ods) conforming to Open Document Format v1.1. used by e.g. OpenOffice.org and LibreOffice. Please see screenshot and Rdoc-Documentation at http://ruby.homelinux.com/ruby/rods/. You can contact me at rodsdotrubyatonlinedotde (and drop me a line, if you like it ;-)"
+Echoe.new('rods', '0.8.0') do |p|
+  p.description    = "OpenOffice.org oocalc: Fast automated batch-processing of spreadsheets (*.ods) conforming to Open Document Format v1.1. used by e.g. OpenOffice.org and LibreOffice. Please see screenshot and Rdoc-Documentation at http://ruby.homelinux.com/ruby/rods/. You can contact me at rods.ruby@online.de (and tell me about your experiences or drop me a line, if you like it ;-)"
   p.summary        = "Automation of OpenOffice/LibreOffice by batch-processing of spreadsheets conforming to Open Document v1.1"
   p.url            = "http://ruby.homelinux.com/ruby/rods/"
   p.author         = "Dr. Heinz Breinlinger"

data/lib/rods.rb

@@ -2,7 +2,7 @@
 #
 # = RODS - Ruby Open Document Spreadsheet
 # This class provides a convenient interface for fast reading and writing 
-# spreadsheets conforming to Open Document Format v1.1. with Ruby 1.9.1 and 1.8.7..
+# spreadsheets conforming to Open Document Format v1.1..
 # Installiation of an office-application (LibreOffice, OpenOffice.org) is not required as the code directly 
 # manipulates the XML-files in the zipped *.ods-container. 
 #
@@ -14,57 +14,17 @@
 # As *.ods-files are zipped archives you need to
 #   $ sudo gem install zip
 # 
-# = What ist does 
-# * open and save a spreadsheet
-#   * save the spreadsheet under a different location/name
-# * add, delete and rename tables
-#   * tables are always inserted at the end of the spreadsheet
-# * read cells with content of type
-#   * string
-#   * formula
-#   * percent
-#   * time
-#   * date
-#   * currency
-# * write cells with content of type
-#   * string
-#   * formula
-#     * formula:float
-#     * formula:date
-#     * formula:time
-#     * formula:currency
-#   * percent
-#   * time
-#   * date
-#     * 2 different date formats (German so far)
-#   * currency
-#     * German
-#     * English
-# * insert annotations
-# * create styles and apply styles as well as features to cells
-#   * style-name
-#   * font-color
-#   * background-color
-#   * border
-#     * all four sides or
-#     * top,bottom,left,right
-#   * indentation
-#   * alignment
-#   * font-weight ('bold')
-#   * font-style ('italic')
-#   * data-style-name (most important for language specific formattings)
-#
 # = Tutorial
-# Please refer to README for how to use the interface. 
+# Please refer to README for how to use the interface with many annotated examples.
 # 
 require 'rubygems'
 require 'zip/zipfilesystem'
 require 'rexml/document'
 
-
 class Rods
   ROW="row"
   CELL="cell"
+  COLUMN="column"
   TAG="tag"
   TEXT="text"
   CHILD="child"
@@ -75,6 +35,8 @@ class Rods
   NODE="node"
   BEFORE="before"
   AFTER="after"
+  INDEX="index"
+  NUMBER="number"
   WIDTHEXCEEDED="exceeded"
   ##########################################################################
   # Convenience-function to switch the default-style for the display of
@@ -122,24 +84,48 @@ class Rods
     return createElement(ROW,repetition)
   end
   ##########################################################################
-  # internal: Returns a new REXML::Element of type 'row' or 'cell' with repetition-attribute set to 'n'
+  # internal: Returns a new REXML::Element of type 'column' with repetition-attribute set to 'n'
+  #-------------------------------------------------------------------------
+  def createColumn(repetition)
+    return createElement(COLUMN,repetition)
+  end
+  ##########################################################################
+  # internal: Returns a new REXML::Element of type 'row', 'cell' or 'column'
+  # with repetition-attribute set to 'n'
   #-------------------------------------------------------------------------
   def createElement(type,repetition)
     if(repetition < 1)
       die("createElement: invalid value for repetition #{repetition}")
     end
+    #----------------------------------------------
+    # Zeile
+    #----------------------------------------------
     if(type == ROW)
       row=REXML::Element.new("table:table-row")
       if(repetition > 1)
         row.attributes["table:number-rows-repeated"]=repetition.to_s
       end
       return row
+    #----------------------------------------------
+    # Zelle
+    #----------------------------------------------
     elsif(type == CELL)
       cell=REXML::Element.new("table:table-cell")
       if(repetition > 1)
         cell.attributes["table:number-columns-repeated"]=repetition.to_s
       end
       return cell
+    #----------------------------------------------
+    # Spalte (als Tabellen-Header)
+    #----------------------------------------------
+      elsif(type == COLUMN)
+      column=REXML::Element.new("table:table-column")
+      if(repetition > 1)
+        column.attributes["table:number-columns-repeated"]=repetition.to_s
+      end
+      column.attributes["table:default-cell-style-name"]="Default"
+      return column
+    #----------------------------------------------
     else
       die("createElement: Invalid Type: #{type}")
     end
@@ -268,8 +254,8 @@ class Rods
     return getChildByIndex(currentTable,ROW,rowInd)
   end
   ##########################################################################
-  # internal: returns the child REXML::Element of the given parent, type 
-  # ('row' or 'cell') and index within the parent-element.
+  # internal: returns the child REXML::Element of the given type 
+  # ('row', 'cell' or 'column') and index within the parent-element.
   # The child is created if it does not exist.
   #------------------------------------------------------------------------
   def getChildByIndex(parent,type,index)
@@ -278,14 +264,14 @@ class Rods
     #----------------------------------------------------------------------
     # Validierung
     #----------------------------------------------------------------------
-    if((type != ROW) && (type != CELL))
+    if((type != ROW) && (type != CELL) && (type != COLUMN))
       die("getChildByIndex: wrong type #{type}")
     end
     if(index < 1)
       die("getChildByIndex: invalid index #{index}")
     end
     if(! parent)
-      die("getChildByIndex: parent-element is nil")
+      die("getChildByIndex: parent-element does not exist")
     end
     #----------------------------------------------------------------------
     # Typabhaengige Vorbelegungen
@@ -293,13 +279,21 @@ class Rods
     if(type == ROW)
       kindOfElement="table:table-row"
       kindOfRepetition="table:number-rows-repeated"
-    elsif(type == CELL)
-      kindOfElement="table:table-cell"
-      kindOfRepetition="table:number-columns-repeated"
+    #---------------------------------------------------------------------
+    # in der "Horizontalen" (Zelle oder Spalte) ggf. Breitenwerte anpassen
+    # und typabhaengig vorbelegen
+    #---------------------------------------------------------------------
+    elsif((type == CELL) || (type == COLUMN))
       if(index > @tables[@currentTableName][WIDTH])
         @tables[@currentTableName][WIDTH]=index
         @tables[@currentTableName][WIDTHEXCEEDED]=true
       end
+      kindOfRepetition="table:number-columns-repeated"
+      case type
+        when CELL then kindOfElement="table:table-cell"
+        when COLUMN then kindOfElement="table:table-column"
+        else die("getChildByIndex: internal error: when-clause-failure for type #{type}")
+      end
     else
       die("getChildByIndex: wrong type #{type}")
     end
@@ -486,11 +480,11 @@ class Rods
     insertTableBeforeAfter(relativeTableName,tableName,AFTER)
   end
   ##########################################################################
-  # Internal: Inserts a table of the given name before or after the given spreadsheet and updates
-  # the internal table-administration.
+  # internal: Inserts a table of the given name before or after the given spreadsheet and updates
+  # the internal table-administration. The default position is 'after'.
   #   mySheet.insertTableBeforeAfter("table1","table2",BEFORE) 
   #-------------------------------------------------------------------------
-  def insertTableBeforeAfter(relativeTableName,tableName,position="after")
+  def insertTableBeforeAfter(relativeTableName,tableName,position=AFTER)
     die("insertTableAfter: table '#{relativeTableName}' does not exist") unless (@tables.has_key?(relativeTableName))
     die("insertTableAfter: table '#{tableName}' already exists") if (@tables.has_key?(tableName))
     #-----------------------------------------
@@ -603,7 +597,7 @@ class Rods
       numColumnsOfTable+=1
       numRepetitions=tableColumn.attributes["table:number-columns-repeated"]
       if(numRepetitions)
-        numColumnsOfTable+=numRepetitions.to_i
+        numColumnsOfTable+=numRepetitions.to_i-1
       end
     }
     tell("getTableWidth: width of '#{tableName}': #{numColumnsOfTable}")
@@ -614,7 +608,7 @@ class Rods
   # according to the right-most valid column. This routine is called when
   # the spreadsheet is saved.
   #------------------------------------------------------------------------
-  def padTable
+  def padTables
     #---------------------------------------------------------------
     # Ggf. geaenderte Tabellenbreite setzen und
     # alle Zeilen auf neue Tabellenbreite auffuellen
@@ -624,7 +618,7 @@ class Rods
       width=tableHash[WIDTH]
       numColumnsOfTable=getTableWidth(table)
       if(tableHash[WIDTHEXCEEDED])
-        die("padTable: current table does not contain table:table-column") unless(table.elements["table:table-column"])
+        die("padTables: current table does not contain table:table-column") unless(table.elements["table:table-column"])
         #--------------------------------------------------------------
         # Differenz zu Sollbreite ermitteln und Wiederholungszahl des
         # letzten Spalteneintrages aktualisieren/setzen
@@ -633,19 +627,19 @@ class Rods
         if(lastTableColumn.attributes["table:number-columns-repeated"])
           numRepetitions=(lastTableColumn.attributes["table:number-columns-repeated"]).to_i+width-numColumnsOfTable
         else
-          numRepetitions=width-numColumnsOfTable
+          numRepetitions=width-numColumnsOfTable+1 # '+1' da Spalte selbst als Wiederholung zaehlt !
         end
         lastTableColumn.attributes["table:number-columns-repeated"]=numRepetitions.to_s
         tableHash[WIDTHEXCEEDED]=false
-        tell("padTable: adjusted columns: #{numColumnsOfTable} -> #{width}")
+        tell("padTables: adjusted columns: #{numColumnsOfTable} -> #{width}")
       else
-        tell("padTable: equal: #{numColumnsOfTable} <-> #{width}")
+        tell("padTables: equal: #{numColumnsOfTable} <-> #{width}")
       end
     }
   end
   ##########################################################################
   # internal: This routine pads the given row with newly created cells and/or
-  # adapts their repetition-attributes. It was formerly called by 'padTable' and is obsolete.
+  # adapts their repetition-attributes. It was formerly called by 'padTables' and is obsolete.
   #----------------------------------------------------------------------
   def padRow(row,width)
     j=0
@@ -951,7 +945,7 @@ class Rods
     #------------------------
     # content.xml
     #------------------------
-    padTable() 
+    padTables() 
     tell("finalize: writing content.xml ...")
     zipfile.file.open("content.xml","w") { |outfile|
       outfile.puts @contentText.to_s
@@ -2513,7 +2507,7 @@ class Rods
               "palegreen" => "#ccffff",
               "darkpurple" => "#660066",
               "salmon" => "#ff8080"
-    }
+  }
     @fixedStyles=["myTable", "myRow", "myColumn", "myFloatFormat", "myFloat", "myTimeFormat", 
                   "myTime", "myPercentFormat", "myPercent", "myString", "myDateFormat", 
                   "myDate", "myDateFormatDay", "myDateDay", "myCurrencyFormatPositive", 
@@ -2555,7 +2549,7 @@ class Rods
   ##########################################################################
   # Fast Routine to get the next cell, because XML-Parser does not have
   # to start from top-node of row to find cell ! 
-  # Returns next cell as a REXML::Element or nil if no element exists
+  # Returns next cell as a REXML::Element or nil if no element exists.
   # Cf. explanation in README !
   #------------------------------------------------------------------------
   def getNextExistentCell(cell)
@@ -2564,7 +2558,7 @@ class Rods
   ##########################################################################
   # Fast Routine to get the previous cell, because XML-Parser does not have
   # to start from top-node of row to find cell ! 
-  # Returns previous cell as a REXML::Element or nil if no element exists
+  # Returns previous cell as a REXML::Element or nil if no element exists.
   # Cf. explanation in README !
   #------------------------------------------------------------------------
   def getPreviousExistentCell(cell)
@@ -2573,7 +2567,7 @@ class Rods
   ##########################################################################
   # Fast Routine to get the next row, because XML-Parser does not have
   # to start from top-node of document to find row ! 
-  # Returns next row as a REXML::Element or nil if no element exists
+  # Returns next row as a REXML::Element or nil if no element exists.
   # Cf. explanation in README !
   #------------------------------------------------------------------------
   def getNextExistentRow(row)
@@ -2589,7 +2583,7 @@ class Rods
   #    :row  => rowIndex,
   #    :col  => colIndex}]
   #  
-  # Regular expressions for 'content' are alllowd but must be enclosed in 
+  # Regular expressions for 'content' are allowed but must be enclosed in 
   # single (not double) quotes !
   #
   # In case of no matches at all, an empty array is returned.
@@ -2657,15 +2651,33 @@ class Rods
     return result
   end
   ##########################################################################
+  # internal: Wrapper for 
+  # getIndexOrNumberOfSiblings(node,NUMBER)
+  #-------------------------------------------------------------------------
+  def getNumberOfSiblings(node)
+    return getIndexOrNumberOfSiblings(node,NUMBER)
+  end
+  ##########################################################################
+  # internal: Wrapper for 
+  # getIndexOrNumberOfSiblings(node,INDEX)
+  #-------------------------------------------------------------------------
+  def getIndexOfElement(node)
+    return getIndexOrNumberOfSiblings(node,INDEX)
+  end
+  ##########################################################################
   # internal: Calculates index (in the sense of spreadsheet, NOT XML) of
-  # given element (row or cell as REXML::Element) within the corresponding parent-element
-  # (table or row)
+  # given element (row, cell or column as REXML::Element) within the 
+  # corresponding parent-element (table or row) or the number of siblings
+  # of the same kind - depending on given flag
   #
-  # index=mySheet.getIndexOfElement(row) # -> Line-number within table
+  # index=mySheet.getIndexOrNumberOfElements(row,INDEX) # -> Line-number within table
+  # numColumns=mySheet.getIndexOrNumberOfElements(column,NUMBER) # number of columns
   #-------------------------------------------------------------------------
-  def getIndexOfElement(node)
-    die("getIndexOfElements: passed node '#{node}' is not a REXML::Element") unless (node.class.to_s == "REXML::Element")
-    index=0
+  def getIndexOrNumberOfSiblings(node,flag)
+    die("getIndexOrNumberOfSiblings: passed node '#{node}' is not a REXML::Element") \
+      unless (node.class.to_s == "REXML::Element")
+    die("getIndexOrNumberOfSiblings: internal error: invalid flag '#{flag}'") \
+      unless (flag == NUMBER || flag == INDEX)
     #--------------------------------------------------------------
     # Typabhaengige Vorbelegungen
     #--------------------------------------------------------------
@@ -2673,29 +2685,37 @@ class Rods
       kindOfSelf="table:table-cell"
       kindOfParent="table:table-row"
       kindOfRepetition="table:number-columns-repeated"
+    elsif(node.elements["self::table:table-column"])
+      kindOfSelf="table:table-column"
+      kindOfParent="table:table"
+      kindOfRepetition="table:number-columns-repeated"
     elsif(node.elements["self::table:table-row"])
       kindOfSelf="table:table-row"
       kindOfParent="table:table"
       kindOfRepetition="table:number-rows-repeated"
     else
-      die("getIndexOfElement: internal error: passed element '#{node}' is neither cell nor row")
+      die("getIndexOrNumberOfSiblings: internal error: passed element '#{node}' is neither cell, nor row or column")
     end
     #--------------------------------------------------------------
     # Zugehoeriges Vater-Element ermitteln 
     #--------------------------------------------------------------
     parent=node.elements["ancestor::"+kindOfParent]
     unless (parent)
-      die("getIndexOfElement: internal error: Could not extract parent of #{node}") 
+      die("getIndexOrNumberOfSiblings: internal error: Could not extract parent of #{node}") 
     end
     #--------------------------------------------------------------
-    # Index des Kind-Elements innerhalb Vater-Element ermitteln
+    # Index des Kind-Elements innerhalb Vater-Element oder
+    # Gesamtzahl der Siblings ermitteln
     #--------------------------------------------------------------
+    index=0
     parent.elements.each(kindOfSelf){ |child|
       index+=1
       #-----------------------------------------------
       # Bei Treffer -> Ruecksprung mit aktuellem Index
+      # sofern Indizierungsflag gesetzt, sonst
+      # verwerfen und weiterzaehlen
       #-----------------------------------------------
-      if(child == node)
+      if(flag == INDEX && child == node)
         return index
       #-----------------------------------------------
       # Wiederholungen zaehlen
@@ -2706,7 +2726,116 @@ class Rods
         index+=repetition.to_i-1
       end
     }
-    die("getIndexOfElement: internal error: Could not calculate index of element #{node}")
+    if(flag == INDEX)
+      die("getIndexOrNumberOfSiblings: internal error: Could not calculate index of element #{node}")
+    else
+      return index # <- hier: Letzter Index == Gesamtzahl der Siblings
+    end
+  end
+  ##########################################################################
+  # internal: Inserts a new header-column before the given column thereby 
+  # shifting existing column-header-entries
+  #-------------------------------------------------------------------------
+  def insertColumnBefore(column)
+    newColumn=createColumn(1)
+    column.previous_sibling=newColumn
+    #-----------------------------------------
+    # bisherige Tabellenbreite überschritten ?
+    #-----------------------------------------
+    lengthOfHeader=getNumberOfSiblings(column)
+    if(lengthOfHeader > @tables[@currentTableName][WIDTH])
+      @tables[@currentTableName][WIDTH]=lengthOfHeader
+      @tables[@currentTableName][WIDTHEXCEEDED]=true
+    end
+    return newColumn
+  end
+  ##########################################################################
+  # Inserts a new cell before the given cell thereby shifting existing cells
+  #   cell=mySheet.getCell(5,1)
+  #   mySheet.insertCellBefore(cell) # adds cell at beginning of row 5
+  #-------------------------------------------------------------------------
+  def insertCellBefore(cell)
+    newCell=createCell(1)
+    cell.previous_sibling=newCell
+    #-----------------------------------------
+    # bisherige Tabellenbreite überschritten ?
+    #-----------------------------------------
+    lengthOfRow=getNumberOfSiblings(cell)
+    if(lengthOfRow > @tables[@currentTableName][WIDTH])
+      @tables[@currentTableName][WIDTH]=lengthOfRow
+      @tables[@currentTableName][WIDTHEXCEEDED]=true
+      tell("insertCellBefore: new table width: #{lengthOfRow}")
+    end
+    return newCell
+  end
+  ##########################################################################
+  # Inserts a new cell after the given cell thereby shifting existing cells
+  #   cell=mySheet.getCell(4,7)
+  #   mySheet.insertCellAfter(cell)
+  #-------------------------------------------------------------------------
+  def insertCellAfter(cell)
+    newCell=createCell(1)
+    cell.next_sibling=newCell
+    #-----------------------------------------
+    # bisherige Tabellenbreite überschritten ?
+    #-----------------------------------------
+    lengthOfRow=getNumberOfSiblings(cell)
+    if(lengthOfRow > @tables[@currentTableName][WIDTH])
+      @tables[@currentTableName][WIDTH]=lengthOfRow
+      @tables[@currentTableName][WIDTHEXCEEDED]=true
+      tell("insertCellAfter: new table width: #{lengthOfRow}")
+    end
+    return newCell
+  end
+  ##########################################################################
+  # Inserts a new row above the given row thereby shifting existing rows
+  #   row=mySheet.getRow(1)
+  #   mySheet.insertRowAbove(row)
+  #-------------------------------------------------------------------------
+  def insertRowAbove(row)
+    newRow=createRow(1)
+    row.previous_sibling=newRow
+    return newRow
+  end
+  ##########################################################################
+  # Inserts a new row below the given row thereby shifting existing rows
+  #   row=mySheet.getRow(8)
+  #   mySheet.insertRowBelow(row)
+  #-------------------------------------------------------------------------
+  def insertRowBelow(row)
+    newRow=createRow(1)
+    row.next_sibling=newRow
+    return newRow
+  end
+  ##########################################################################
+  # Inserts a column at the given index, thereby shifting existing columns
+  #   mySheet.insertColumn(1) # inserts column before former column 1
+  #-------------------------------------------------------------------------
+  def insertColumn(index)
+    die("insertColumn: invalid index #{index}") unless (index > 0)
+    die("insertColumn: index #{index} is not a Fixnum/Integer") unless (index.class.to_s == "Fixnum")
+    tell("insertColumn: inserting new column")
+    currentTable=@tables[@currentTableName][NODE]
+    #-----------------------------------------------
+    # Neuer Spalteneintrag im Header mit impliziter
+    # Aktualisierung der Tabellenbreite
+    #-----------------------------------------------
+    column=getChildByIndex(currentTable,COLUMN,index)
+    insertColumnBefore(column)
+    #-----------------------------------------------
+    # Fuer alle existierenden Zeilen neue Zelle an
+    # Spaltenposition einfuegen und dabei implizit
+    # Tabellenbreite aktualisieren
+    #-----------------------------------------------
+    row=getRow(1)
+    cell=getChildByIndex(row,CELL,index)
+    insertCellBefore(cell)
+    i=1
+    while(row=getNextExistentRow(row)) # fuer alle Zeilen ab der zweiten
+      cell=getChildByIndex(row,CELL,index)
+      insertCellBefore(cell)
+      i+=1
+    end 
   end
   ##########################################################################
   # internal: Opens zip-file
@@ -2729,12 +2858,15 @@ class Rods
          :insertTable, :deleteTable, :readCellFromRow, :readCell, :setAttributes, :writeStyleAbbr, 
          :setStyle, :printOfficeStyles, :printAutoStyles, :getNextExistentRow, :getPreviousExistentRow, 
 	 :getNextExistentCell, :getPreviousExistentCell, :insertTableAfter, :insertTableBefore,
-         :writeComment, :save, :saveAs, :initialize, :writeText, :getCellsAndIndicesFor
+         :writeComment, :save, :saveAs, :initialize, :writeText, :getCellsAndIndicesFor,
+         :insertRowBelow, :insertRowAbove, :insertCellBefore, :insertCellAfter, :insertColumn
 
   private :tell, :die, :createCell, :createRow, :getChildByIndex, :createElement, :setRepetition, :initHousekeeping, 
-          :getTableWidth, :padTable, :padRow, :time2TimeVal, :percent2PercentVal, :date2DateVal, 
+          :getTableWidth, :padTables, :padRow, :time2TimeVal, :percent2PercentVal, :date2DateVal, 
           :finalize, :init, :normalizeText, :getColor, :normStyleHash, :getStyle, :getIndexOfElement,
+          :getNumberOfSiblings, :getIndexOrNumberOfSiblings, :createColumn,
           :getAppropriateStyle, :checkStyleAttributes, :insertStyleAttributes, :cloneNode, 
           :writeStyle, :writeStyleXml, :style2Hash, :writeDefaultStyles, :writeXml, 
-          :internalizeFormula, :getColorPalette, :open, :printStyles, :insertTableBeforeAfter
+          :internalizeFormula, :getColorPalette, :open, :printStyles, :insertTableBeforeAfter, 
+          :insertColumnBefore
 end # Klassenende

data/rods.gemspec

@@ -2,15 +2,15 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rods}
-  s.version = "0.7.0"
+  s.version = "0.8.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
   s.authors = ["Dr. Heinz Breinlinger"]
-  s.date = %q{2011-01-11}
-  s.description = %q{OpenOffice.org oocalc: Fast automated batch-processing of spreadsheets (*.ods) conforming to Open Document Format v1.1. used by e.g. OpenOffice.org and LibreOffice. Please see screenshot and Rdoc-Documentation at http://ruby.homelinux.com/ruby/rods/. You can contact me at rodsdotrubyatonlinedotde (and drop me a line, if you like it ;-)}
+  s.date = %q{2011-01-13}
+  s.description = %q{OpenOffice.org oocalc: Fast automated batch-processing of spreadsheets (*.ods) conforming to Open Document Format v1.1. used by e.g. OpenOffice.org and LibreOffice. Please see screenshot and Rdoc-Documentation at http://ruby.homelinux.com/ruby/rods/. You can contact me at rods.ruby@online.de (and tell me about your experiences or drop me a line, if you like it ;-)}
   s.email = %q{rods.ruby@online.de}
-  s.extra_rdoc_files = ["README", "lib/example.rb", "lib/rods.rb"]
-  s.files = ["Manifest", "README", "Rakefile", "lib/example.rb", "lib/rods.rb", "rods.gemspec"]
+  s.extra_rdoc_files = ["README", "lib/rods.rb"]
+  s.files = ["Manifest", "README", "Rakefile", "lib/rods.rb", "rods.gemspec"]
   s.homepage = %q{http://ruby.homelinux.com/ruby/rods/}
   s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Rods", "--main", "README"]
   s.require_paths = ["lib"]

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rods
 version: !ruby/object:Gem::Version 
-  hash: 3
+  hash: 63
   prerelease: false
   segments: 
   - 0
-  - 7
+  - 8
   - 0
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors: 
 - Dr. Heinz Breinlinger
@@ -15,11 +15,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-11 00:00:00 +01:00
+date: 2011-01-13 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
-description: "OpenOffice.org oocalc: Fast automated batch-processing of spreadsheets (*.ods) conforming to Open Document Format v1.1. used by e.g. OpenOffice.org and LibreOffice. Please see screenshot and Rdoc-Documentation at http://ruby.homelinux.com/ruby/rods/. You can contact me at rodsdotrubyatonlinedotde (and drop me a line, if you like it ;-)"
+description: "OpenOffice.org oocalc: Fast automated batch-processing of spreadsheets (*.ods) conforming to Open Document Format v1.1. used by e.g. OpenOffice.org and LibreOffice. Please see screenshot and Rdoc-Documentation at http://ruby.homelinux.com/ruby/rods/. You can contact me at rods.ruby@online.de (and tell me about your experiences or drop me a line, if you like it ;-)"
 email: rods.ruby@online.de
 executables: []
 
@@ -27,13 +27,11 @@ extensions: []
 
 extra_rdoc_files: 
 - README
-- lib/example.rb
 - lib/rods.rb
 files: 
 - Manifest
 - README
 - Rakefile
-- lib/example.rb
 - lib/rods.rb
 - rods.gemspec
 has_rdoc: true

data/lib/example.rb

@@ -1,88 +0,0 @@
-# coding: UTF-8
-require 'rubygems'
-require 'rods'
-mySheet=Rods.new("/home/heinz/Work/Template.ods",["de","DE","€","EUR"]) 
-# aternative values for United States would be
-# mySheet=Rods.new("/home/heinz/Work/Template.ods",["us","US","$","DOLLAR"]) 
-mySheet.renameTable("Tabelle1","not needed") 
-mySheet.insertTable("example")  
-mySheet.setCurrentTable("example")
-mySheet.deleteTable("Tabelle2")
-mySheet.deleteTable("Tabelle3")
-mySheet.writeCell(1,1,"date","31.12.2010") 
-mySheet.writeCell(2,1,"formula:date","=A1+1") 
-mySheet.setDateFormat("myDateDay") 
-mySheet.writeCell(1,2,"formula:date","=A1")
-mySheet.writeCell(2,2,"formula:date","=A2")
-mySheet.setDateFormat("myDate")  
-mySheet.writeCell(1,3,"time","13:37") 
-mySheet.writeCell(2,3,"time","20:15")
-mySheet.writeCell(1,4,"currency","19,99") 
-mySheet.writeCell(2,4,"currency","-7,78")
-cell=mySheet.writeGetCell(3,3,"formula:time","=C2-C1")
-mySheet.setAttributes(cell,{ "border" => "0.01cm solid turquoise",
-                             "text-align" => "center",           
-                             "background-color" => "yellow2",   
-                             "color" => "blue"})               
-cell=mySheet.writeGetCell(3,4,"formula:currency","=D2+D1")
-mySheet.setAttributes(cell,{ "border-right" => "0.05cm solid magenta4",
-                             "border-bottom" => "0.03cm solid lightgreen",
-                             "border-top" => "0.08cm solid salmon",
-                             "font-style" => "italic",
-                             "font-weight" => "bold"})
-mySheet.writeStyleAbbr({"name" => "myNewPercentStyle",        
-                        "margin-left" => "0.3cm",
-                        "text-align" => "start",
-                        "color" => "blue",
-                        "border" => "0.01cm solid black",
-                        "font-style" => "italic",
-                        "data-style-name" => "myPercentFormat",
-                        "font-weight" => "bold"})
-cell=mySheet.writeGetCell(4,2,"percent","4,71")
-mySheet.setStyle(cell,"myNewPercentStyle")
-mySheet.writeComment(cell,"by Dr. Heinz Breinlinger")
-cell=mySheet.writeGetCell(4,3,"formula:time","=B4*C3")
-mySheet.setAttributes(cell,{ "color" => "lightmagenta",
-                             "font-style" => "italic"})
-cell=mySheet.writeGetCell(4,4,"formula:currency","=B4*D3")
-mySheet.setAttributes(cell,{ "color" => "turquoise7",
-                             "text-align" => "center",
-                             "font-style" => "bold"})
-mySheet.writeStyleAbbr({"name" => "myBold",
-                       "text-align" => "end",
-                       "font-weight" => "bold",
-                       "background-color" => "purple"})
-cell=mySheet.writeGetCell(3,1,"string","Diff/Sum")
-mySheet.setStyle(cell,"myBold")
-cell=mySheet.writeGetCell(4,1,"string","Percent")
-mySheet.setStyle(cell,"myBold")
-cell=mySheet.writeGetCell(6,1,"string","annotation")
-mySheet.writeComment(cell,"C3,C4,D3,D4 are formulas")
-1.upto(7){ |row|
-  cell=mySheet.getCell(row,5)
-  mySheet.setAttributes(cell,{ "border-right" => "0.07cm solid green6" }) 
-}
-1.upto(5){ |col|
-  cell=mySheet.getCell(7,col)
-  mySheet.setAttributes(cell,{ "border-bottom" => "0.085cm solid red5" }) # 
-}
-amount=0.0
-1.upto(2){ |i|
-  row=mySheet.getRow(i)
-  text,type=mySheet.readCellFromRow(row,4)
-  if(type == "currency")
-    amount+=text.to_f
-  end
-}
-mySheet.deleteTable("not needed")
-mySheet.saveAs("/home/heinz/Work/Example.ods")
-puts("Sums up to: #{amount}")  # -> "Sums up to: 12.21"
-#----------Open Example.ods again---------------------------
-mySheet=Rods.new("/home/heinz/Work/Example.ods") 
-mySheet.setCurrentTable("example") # not essential, as 'example' is the 1st and only table
-text,type=mySheet.readCell(2,4)
-if(text && type)
-  if(type == "currency")
-  puts("not so much: #{text} bucks") # -> "not so much: -7.78 bucks"
-  end
-end