rods 0.8.1 → 0.9.0

data/Manifest

@@ -2,3 +2,4 @@ Manifest
 README
 Rakefile
 lib/rods.rb
+rods.gemspec

data/README

@@ -16,6 +16,11 @@
  Licensed under the same terms as Ruby. No warranty is provided.
 
  = Changelog
+ * 0.9.0 
+   * added new methods 
+     * insertRow, insertCell, insertCellFromRow, deleteCellBefore, deleteCellAfter, deleteCell, deleteCellFromRow,
+       deleteRowAbove, deleteRowBelow, deleteRow, deleteColumn, deleteRow2, deleteCell2
+   cf. Examples 0.9.0 a-e and read chapter "Caveat" below for performance-considerations !
  * 0.8.1
    * Bug-Fix: methods insertRowBelow and insertCellAfter did not consider repetitions of previous element
  * 0.8.0
@@ -304,6 +309,134 @@
      end
    end
 
+ = Example 0.9.0 a
+
+   #!/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")
+     }
+   }
+   mySheet.insertColumn(3)
+   1.upto(3){ |row|
+     mySheet.writeCell(row,3,"string","o' clock")
+   }
+   mySheet.insertRow(2)
+   cell=mySheet.insertCell(3,3)
+   mySheet.writeText(cell,"string","insertCell")
+   row=mySheet.getRow(4)
+   row=mySheet.insertRowAbove(row)
+   mySheet.writeCell(4,1,"string","Willi")
+   cell=mySheet.insertCellFromRow(row,1)
+   mySheet.writeText(cell,"string","Supi")
+   mySheet.saveAs("Test8.ods")
+
+ = Example 0.9.0 b
+
+   #!/usr/bin/ruby
+   # coding: UTF-8
+   #
+   # Author: Dr. Heinz Breinlinger
+   #
+   require 'rubygems'
+   require 'rods'
+
+   mySheet=Rods.new("Template.ods")
+   mySheet.writeCell(1,1,"string","oneone")
+   cell=mySheet.writeGetCell(1,2,"string","onetwo")
+   mySheet.deleteCellBefore(cell)
+   cell=mySheet.writeGetCell(1,5,"string","onefive")
+   mySheet.deleteCellBefore(cell)
+
+   cellOne=mySheet.writeGetCell(5,1,"string","fiveone")
+   cellFive=mySheet.writeGetCell(5,5,"string","fivefive")
+   cellSix=mySheet.writeGetCell(5,6,"string","fivesix")
+   cellNine=mySheet.writeGetCell(5,9,"string","fivenine")
+   mySheet.deleteCellAfter(cellOne)
+   mySheet.deleteCellAfter(cellFive)
+   cell=mySheet.getCell(5,4)
+   mySheet.deleteCellBefore(cell)
+   cell=mySheet.getCell(5,4)
+   mySheet.deleteCellAfter(cell)
+   mySheet.deleteCell(5,2)
+   mySheet.deleteCell(5,3)
+   row=mySheet.getRow(5)
+   mySheet.deleteRowAbove(row)
+   mySheet.insertRow(2)
+   mySheet.insertRow(2)
+   row=mySheet.getRow(2)
+   mySheet.deleteRowBelow(row)
+   row=mySheet.getRow(1)
+   mySheet.deleteRowBelow(row)
+   row=mySheet.getRow(2)
+   mySheet.deleteRowBelow(row)
+   mySheet.deleteRow(2)
+   mySheet.deleteRow(1)
+   mySheet.deleteRow(1)
+   mySheet.saveAs("Test9.ods")
+
+ = Example 0.9.0 c
+
+   #!/usr/bin/ruby
+   # coding: UTF-8
+   #
+   # Author: Dr. Heinz Breinlinger
+   #
+   require 'rubygems'
+   require 'rods'
+
+   mySheet=Rods.new("Konten.ods")
+   startRow=mySheet.getRow(11)
+   i=0
+   while(row=mySheet.getNextExistentRow(startRow))
+     i+=1
+     puts("#{i}")
+     mySheet.deleteRow2(row)
+   end
+   mySheet.saveAs("Test10.ods")
+
+ = Example 0.9.0 d
+
+   #!/usr/bin/ruby
+   # coding: UTF-8
+   #
+   # Author: Dr. Heinz Breinlinger
+   #
+   require 'rubygems'
+   require 'rods'
+
+   mySheet=Rods.new("Konten.ods")
+   mySheet.deleteColumn(8)
+   mySheet.saveAs("Test11.ods")
+
+ = Example 0.9.0 e
+
+   #!/usr/bin/ruby
+   # coding: UTF-8
+   #
+   # Author: Dr. Heinz Breinlinger
+   #
+   require 'rubygems'
+   require 'rods'
+
+   mySheet=Rods.new("Konten.ods")
+   startCell=mySheet.getCell(12,1)
+   i=0
+   while(cell=mySheet.getNextExistentCell(startCell))
+     i+=1
+     puts("#{i}")
+     mySheet.deleteCell2(cell)
+   end
+   mySheet.saveAs("Test12.ods")
+
  = Example 0.8.0
 
    #!/usr/bin/ruby
@@ -516,6 +649,8 @@
  On the ATOM-Nettop I developed the gem, even the first script above took just 2-3 seconds and on my Core-i7-Notebook it was finished so quickly
  that I supposed it had halted on an immediate error, so: don't be concerned and just experiment :-).
  
+ The same considerations apply for the family of 'delete'-functions added in version 0.9.0 ! See the examples above.
+ 
  = Standards
  * Open Document Format for Office Applications (Open Document) v1.1 based on OpenOffice.org (OOo)
    * http://www.oasis-open.org/specs/#opendocumentv1.1

data/Rakefile

@@ -2,7 +2,7 @@ require 'rubygems'
 require 'rake'
 require 'echoe'
 
-Echoe.new('rods', '0.8.1') do |p|
+Echoe.new('rods', '0.9.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/"

data/lib/rods.rb

@@ -37,6 +37,7 @@ class Rods
   AFTER="after"
   INDEX="index"
   NUMBER="number"
+  BOTH="both"
   WIDTHEXCEEDED="exceeded"
   ##########################################################################
   # Convenience-function to switch the default-style for the display of
@@ -259,6 +260,8 @@ class Rods
   # The child is created if it does not exist.
   #------------------------------------------------------------------------
   def getChildByIndex(parent,type,index)
+    die("getChildByIndex: 'parent' #{parent} is not a node") unless (parent.class.to_s == "REXML::Element")
+    die("getChildByIndex: 'index' #{index} is not a Fixnum") unless (index.class.to_s == "Fixnum")
     i=0
     lastElement=nil
     #----------------------------------------------------------------------
@@ -2151,8 +2154,8 @@ class Rods
   ##########################################################################
   # internal: Helper-Tool: Prints out all styles of given node in an indented ASCII-notation
   #------------------------------------------------------------------------
-  def printStyles(start,indent)
-    start.elements.each("*"){ |element|
+  def printStyles(startNode,indent)
+    startNode.elements.each("*"){ |element|
       #------------------------------------------
       # Tag extrahieren (Standard-Tag-Zeichen nach '<')
       #------------------------------------------
@@ -2541,9 +2544,19 @@ class Rods
   # to start from top-node of document to find row ! 
   # Returns previous row as a REXML::Element or nil if no element exists.
   # Cf. explanation in README !
+  #
   #------------------------------------------------------------------------
   def getPreviousExistentRow(row)
-    return row.previous_sibling
+    #----------------------------------------------------------------------
+    # Cave: table:table-row und table:table-column sind Siblings !!!!
+    # Letztere duerfen jedoch NICHT zurueckgegeben werden
+    #----------------------------------------------------------------------
+    previousSibling=row.previous_sibling
+    if(previousSibling && previousSibling.elements["self::table:table-row"])
+      return previousSibling
+    else
+      return nil
+    end
   end
   ##########################################################################
   # Fast Routine to get the next cell, because XML-Parser does not have
@@ -2631,7 +2644,7 @@ class Rods
         unless (cell)
           die("getCellsAndIndicesFor: internal error: Could not extract parent-cell of textNode with #{content}") 
         end
-        colIndex=getIndexOfElement(cell)
+        colIndex=getIndex(cell)
         #-----------------------------------------------------
         # Zeile und Zeilenindex ermitteln
         #-----------------------------------------------------
@@ -2639,7 +2652,7 @@ class Rods
         unless (row)
           die("getCellsAndIndicesFor: internal error: Could not extract parent-row of textNode with #{content}") 
         end
-        rowIndex=getIndexOfElement(row)
+        rowIndex=getIndex(row)
         result[i][:cell]=cell
         result[i][:row]=rowIndex
         result[i][:col]=colIndex
@@ -2651,32 +2664,42 @@ class Rods
   end
   ##########################################################################
   # internal: Wrapper for 
-  # getIndexOrNumberOfSiblings(node,NUMBER)
+  # getIndexAndOrNumber(node,NUMBER)
   #-------------------------------------------------------------------------
   def getNumberOfSiblings(node)
-    return getIndexOrNumberOfSiblings(node,NUMBER)
+    return getIndexAndOrNumber(node,NUMBER)
   end
   ##########################################################################
   # internal: Wrapper for 
-  # getIndexOrNumberOfSiblings(node,INDEX)
+  # getIndexAndOrNumber(node,INDEX)
   #-------------------------------------------------------------------------
-  def getIndexOfElement(node)
-    return getIndexOrNumberOfSiblings(node,INDEX)
+  def getIndex(node)
+    return getIndexAndOrNumber(node,INDEX)
+  end
+  ##########################################################################
+  # internal: Wrapper for 
+  # getIndexAndOrNumber(node,BOTH)
+  #-------------------------------------------------------------------------
+  def getIndexAndNumber(node)
+    return getIndexAndOrNumber(node,BOTH)
   end
   ##########################################################################
   # internal: Calculates index (in the sense of spreadsheet, NOT XML) of
   # 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
+  # of the same kind or both - depending on the flag given.
+  #
+  # Cave: In case of flag 'BOTH' the method returns TWO values !
   #
-  # index=mySheet.getIndexOrNumberOfElements(row,INDEX) # -> Line-number within table
-  # numColumns=mySheet.getIndexOrNumberOfElements(column,NUMBER) # number of columns
+  # index=getIndexAndOrNumber(row,INDEX) # -> Line-number within table
+  # numColumns=getIndexAndOrNumber(column,NUMBER) # number of columns
+  # index,numColumns=getIndexAndOrNumber(row,BOTH) # Line-number and total number of lines
   #-------------------------------------------------------------------------
-  def getIndexOrNumberOfSiblings(node,flag)
-    die("getIndexOrNumberOfSiblings: passed node '#{node}' is not a REXML::Element") \
+  def getIndexAndOrNumber(node,flag)
+    die("getIndexAndOrNumber: 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)
+    die("getIndexAndOrNumber: internal error: invalid flag '#{flag}'") \
+      unless (flag == NUMBER || flag == INDEX || flag == BOTH)
     #--------------------------------------------------------------
     # Typabhaengige Vorbelegungen
     #--------------------------------------------------------------
@@ -2693,49 +2716,55 @@ class Rods
       kindOfParent="table:table"
       kindOfRepetition="table:number-rows-repeated"
     else
-      die("getIndexOrNumberOfSiblings: internal error: passed element '#{node}' is neither cell, nor row or column")
+      die("getIndexAndOrNumber: 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("getIndexOrNumberOfSiblings: internal error: Could not extract parent of #{node}") 
+      die("getIndexAndOrNumber: internal error: Could not extract parent of #{node}") 
     end
     #--------------------------------------------------------------
     # Index des Kind-Elements innerhalb Vater-Element oder
-    # Gesamtzahl der Siblings ermitteln
+    # Gesamtzahl der Items ermitteln
     #--------------------------------------------------------------
-    index=0
+    index=number=0
     parent.elements.each(kindOfSelf){ |child|
-      index+=1
+      number+=1
       #-----------------------------------------------
-      # Bei Treffer -> Ruecksprung mit aktuellem Index
-      # sofern Indizierungsflag gesetzt, sonst
-      # verwerfen und weiterzaehlen
+      # Kind-Element gefunden ? -> Index festhalten, 
+      # je nach Flag Ruecksprung oder weiterzaehlen
       #-----------------------------------------------
-      if(flag == INDEX && child == node)
-        return index
+      if(child == node)
+        if(flag == INDEX)
+          return number
+	elsif(flag == BOTH)
+	  index=number
+	end
       #-----------------------------------------------
       # Wiederholungen zaehlen
       # Cave: Aktuelles Element selbst zaehlt ebenfalls als Wiederholung
       # => um 1 dekrementieren
       #-----------------------------------------------
       elsif(repetition=child.attributes[kindOfRepetition])
-        index+=repetition.to_i-1
+        number+=repetition.to_i-1
       end
     }
     if(flag == INDEX)
-      die("getIndexOrNumberOfSiblings: internal error: Could not calculate index of element #{node}")
+      die("getIndexAndOrNumber: internal error: Could not calculate number of element #{node}")
+    elsif(flag == NUMBER)
+      return number 
     else
-      return index # <- hier: Letzter Index == Gesamtzahl der Siblings
+      return index,number
     end
   end
   ##########################################################################
-  # internal: Inserts a new header-column before the given column thereby 
-  # shifting existing column-header-entries
+  # internal: Inserts a new header-column before the given header-column thereby 
+  # shifting existing header-columns
   #-------------------------------------------------------------------------
-  def insertColumnBefore(column)
+  def insertColumnBeforeInHeader(column)
+    die("insertColumnBeforeInHeader: column #{column} is not a REXML::Element") unless (column.class.to_s == "REXML::Element")
     newColumn=createColumn(1)
     column.previous_sibling=newColumn
     #-----------------------------------------
@@ -2749,11 +2778,218 @@ class Rods
     return newColumn
   end
   ##########################################################################
+  # Delets the cell to the right of the given cell
+  #
+  #   cell=mySheet.writeGetCell(4,7,"date","16.01.2011")
+  #   mySheet.deleteCellAfter(cell)
+  #-------------------------------------------------------------------------
+  def deleteCellAfter(cell)
+    die("deleteCellAfter: cell #{cell} is not a REXML::Element") unless (cell.class.to_s == "REXML::Element")
+    #--------------------------------------------------------
+    # Entweder Wiederholungsattribut der aktuellen Zelle
+    # dekrementieren oder ggf. Wiederholungsattribut der
+    # Folgezelle dekrementieren oder selbige loeschen
+    #--------------------------------------------------------
+    repetitions=cell.attributes["table:number-columns-repeated"]
+    if(repetitions && repetitions.to_i > 1)
+      cell.attributes["table:number-columns-repeated"]=(repetitions.to_i-1).to_s
+    else
+      nextCell=cell.next_sibling
+      die("deleteCellAfter: cell is already last cell in row") unless (nextCell)
+      nextRepetitions=nextCell.attributes["table:number-columns-repeated"]
+      if(nextRepetitions && nextRepetitions.to_i > 1)
+        nextCell.attributes["table:number-columns-repeated"]=(nextRepetitions.to_i-1).to_s
+      else
+        row=cell.elements["ancestor::table:table-row"]
+        unless (row)
+          die("deleteCellAfter: internal error: Could not extract parent-row of cell #{cell}") 
+        end
+        row.elements.delete(nextCell)
+      end
+    end
+  end
+  ##########################################################################
+  # Delets the row below the given row
+  #
+  #   row=mySheet.getRow(11)
+  #   mySheet.deleteRowBelow(row)
+  #-------------------------------------------------------------------------
+  def deleteRowBelow(row)
+    die("deleteRowBelow: row #{row} is not a REXML::Element") unless (row.class.to_s == "REXML::Element")
+    #--------------------------------------------------------
+    # Entweder Wiederholungsattribut der aktuellen Zeile
+    # dekrementieren oder ggf. Wiederholungsattribut der
+    # Folgezeile dekrementieren oder selbige loeschen
+    #--------------------------------------------------------
+    repetitions=row.attributes["table:number-rows-repeated"]
+    if(repetitions && repetitions.to_i > 1)
+      row.attributes["table:number-rows-repeated"]=(repetitions.to_i-1).to_s
+    else
+      nextRow=row.next_sibling
+      die("deleteRowBelow: row #{row} is already last row in table") unless (nextRow)
+      nextRepetitions=nextRow.attributes["table:number-rows-repeated"]
+      if(nextRepetitions && nextRepetitions.to_i > 1)
+        nextRow.attributes["table:number-rows-repeated"]=(nextRepetitions.to_i-1).to_s
+      else
+        table=row.elements["ancestor::table:table"]
+        unless (table)
+          die("deleteRowBelow: internal error: Could not extract parent-table of row #{row}") 
+        end
+        table.elements.delete(nextRow)
+      end
+    end
+  end
+  ##########################################################################
+  # Delets the cell at the given index in the given row
+  #
+  #   row=mySheet.getRow(8)
+  #   mySheet.deleteCell(row,9)
+  #-------------------------------------------------------------------------
+  def deleteCellFromRow(row,colInd)
+    die("deleteCell: row #{row} is not a REXML::Element") unless (row.class.to_s == "REXML::Element")
+    die("deleteCell: index #{colInd} is not a Fixnum/Integer") unless (colInd.class.to_s == "Fixnum")
+    die("deleteCell: invalid index #{colInd}") unless (colInd > 0)
+    cell=getCellFromRow(row,colInd+1)
+    deleteCellBefore(cell)
+  end
+  ##########################################################################
+  # Delets the given cell.
+  #
+  # 'cell' is a REXML::Element as returned by getCell(cellInd).
+  #
+  # startCell=mySheet.getCell(34,1)
+  # while(cell=mySheet.getNextExistentCell(startCell))
+  #   mySheet.deleteCell2(cell)
+  # end
+  #-------------------------------------------------------------------------
+  def deleteCell2(cell)
+    die("deleteCell2: cell #{cell} is not a REXML::Element") unless (cell.class.to_s == "REXML::Element")
+    #-------------------------------------------------------------------
+    # Entweder Wiederholungszahl dekrementieren oder Zelle loeschen
+    #-------------------------------------------------------------------
+    repetitions=cell.attributes["table:number-columuns-repeated"]
+    if(repetitions && repetitions.to_i > 1)
+      cell.attributes["table:number-columns-repeated"]=(repetitions.to_i-1).to_s
+      tell("deleteCell2: decrementing empty cells")
+    else
+      row=cell.elements["ancestor::table:table-row"]
+      unless (row)
+        die("deleteCell2: internal error: Could not extract parent-row of cell #{cell}") 
+      end
+      row.elements.delete(cell)
+      tell("deleteCell2: deleting non-empty cell")
+    end
+  end
+  ##########################################################################
+  # Delets the given row.
+  #
+  # 'row' is a REXML::Element as returned by getRow(rowInd).
+  #
+  # startRow=mySheet.getRow(12)
+  # while(row=mySheet.getNextExistentRow(startRow))
+  #   mySheet.deleteRow2(row)
+  # end
+  #-------------------------------------------------------------------------
+  def deleteRow2(row)
+    die("deleteRow2: row #{row} is not a REXML::Element") unless (row.class.to_s == "REXML::Element")
+    #-------------------------------------------------------------------
+    # Entweder Wiederholungszahl dekrementieren oder Zeile loeschen
+    #-------------------------------------------------------------------
+    repetitions=row.attributes["table:number-rows-repeated"]
+    if(repetitions && repetitions.to_i > 1)
+      row.attributes["table:number-rows-repeated"]=(repetitions.to_i-1).to_s
+      tell("deleteRow2: decrementing empty rows")
+    else
+      table=row.elements["ancestor::table:table"]
+      unless (table)
+        die("deleteRow2: internal error: Could not extract parent-table of row #{row}") 
+      end
+      table.elements.delete(row)
+      tell("deleteRow2: deleting non-empty row")
+    end
+  end
+  ##########################################################################
+  # Delets the row at the given index
+  #
+  #   mySheet.deleteRow(7)
+  #-------------------------------------------------------------------------
+  def deleteRow(rowInd)
+    die("deleteRow: index #{rowInd} is not a Fixnum/Integer") unless (rowInd.class.to_s == "Fixnum")
+    die("deleteRow: invalid index #{rowInd}") unless (rowInd > 0)
+    row=getRow(rowInd+1)
+    deleteRowAbove(row)
+  end
+  ##########################################################################
+  # Delets the cell at the given indices
+  #
+  #   mySheet.deleteCell(7,9)
+  #-------------------------------------------------------------------------
+  def deleteCell(rowInd,colInd)
+    die("deleteCell: index #{rowInd} is not a Fixnum/Integer") unless (rowInd.class.to_s == "Fixnum")
+    die("deleteCell: invalid index #{rowInd}") unless (rowInd > 0)
+    die("deleteCell: index #{colInd} is not a Fixnum/Integer") unless (colInd.class.to_s == "Fixnum")
+    die("deleteCell: invalid index #{colInd}") unless (colInd > 0)
+    tell("deleteCell: deleting cell at #{rowInd}:#{colInd}")
+    row=getRow(rowInd)
+    deleteCellFromRow(row,colInd)
+  end
+  ##########################################################################
+  # Delets the row above the given row
+  #
+  #   row=mySheet.getRow(5)
+  #   mySheet.deleteRowAbove(row)
+  #-------------------------------------------------------------------------
+  def deleteRowAbove(row)
+    die("deleteRowAbove: row #{row} is not a REXML::Element") unless (row.class.to_s == "REXML::Element")
+    #--------------------------------------------------------
+    # Entweder Wiederholungsattribut der vorherigen Zeile
+    # dekrementieren oder selbige loeschen
+    #--------------------------------------------------------
+    previousRow=row.previous_sibling
+    die("deleteRowAbove: row is already first row in row") unless (previousRow)
+    previousRepetitions=previousRow.attributes["table:number-rows-repeated"]
+    if(previousRepetitions && previousRepetitions.to_i > 1)
+      previousRow.attributes["table:number-rows-repeated"]=(previousRepetitions.to_i-1).to_s
+    else
+      table=row.elements["ancestor::table:table"]
+      unless (table)
+        die("deleteRowAbove: internal error: Could not extract parent-table of row #{row}") 
+      end
+      table.elements.delete(previousRow)
+    end
+  end
+  ##########################################################################
+  # Delets the cell to the left of the given cell
+  #
+  #   cell=mySheet.writeGetCell(4,7,"formula:currency","=A1+B2")
+  #   mySheet.deleteCellBefore(cell)
+  #-------------------------------------------------------------------------
+  def deleteCellBefore(cell)
+    die("deleteCellBefore: cell #{cell} is not a REXML::Element") unless (cell.class.to_s == "REXML::Element")
+    #--------------------------------------------------------
+    # Entweder Wiederholungsattribut der vorherigen Zelle
+    # dekrementieren oder selbige loeschen
+    #--------------------------------------------------------
+    previousCell=cell.previous_sibling
+    die("deleteCellBefore: cell is already first cell in row") unless (previousCell)
+    previousRepetitions=previousCell.attributes["table:number-columns-repeated"]
+    if(previousRepetitions && previousRepetitions.to_i > 1)
+      previousCell.attributes["table:number-columns-repeated"]=(previousRepetitions.to_i-1).to_s
+    else
+      row=cell.elements["ancestor::table:table-row"]
+      unless (row)
+        die("deleteCellBefore: internal error: Could not extract parent-row of cell #{cell}") 
+      end
+      row.elements.delete(previousCell)
+    end
+  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)
+    die("insertCellBefore: cell #{cell} is not a REXML::Element") unless (cell.class.to_s == "REXML::Element")
     newCell=createCell(1)
     cell.previous_sibling=newCell
     #-----------------------------------------
@@ -2773,6 +3009,7 @@ class Rods
   #   mySheet.insertCellAfter(cell)
   #-------------------------------------------------------------------------
   def insertCellAfter(cell)
+    die("insertCellAfter: cell #{cell} is not a REXML::Element") unless (cell.class.to_s == "REXML::Element")
     newCell=createCell(1)
     cell.next_sibling=newCell
     #-----------------------------------------------------------------------
@@ -2795,6 +3032,46 @@ class Rods
     return newCell
   end
   ##########################################################################
+  # Inserts and returns a cell at the given index in the given row, 
+  # thereby shifting existing cells.
+  #
+  #   row=mySheet.getRow(5)
+  #   cell=mySheet.insertCellFromRow(row,17) 
+  #-------------------------------------------------------------------------
+  def insertCellFromRow(row,colInd)
+    die("insertCell: row #{row} is not a REXML::Element") unless (row.class.to_s == "REXML::Element")
+    die("insertCell: index #{colInd} is not a Fixnum/Integer") unless (colInd.class.to_s == "Fixnum")
+    die("insertCell: invalid index #{colInd}") unless (colInd > 0)
+    tell("insertCell: inserting new cell in column:#{colInd}")
+    cell=getCellFromRow(row,colInd)
+    return insertCellBefore(cell)
+  end
+  ##########################################################################
+  # Inserts and returns a cell at the given index, thereby shifting existing cells.
+  #
+  #   cell=mySheet.insertCell(4,17) 
+  #-------------------------------------------------------------------------
+  def insertCell(rowInd,colInd)
+    die("insertCell: index #{rowInd} is not a Fixnum/Integer") unless (rowInd.class.to_s == "Fixnum")
+    die("insertCell: invalid index #{rowInd}") unless (rowInd > 0)
+    die("insertCell: index #{colInd} is not a Fixnum/Integer") unless (colInd.class.to_s == "Fixnum")
+    die("insertCell: invalid index #{colInd}") unless (colInd > 0)
+    tell("insertCell: inserting new cell at #{rowInd}:#{colInd}")
+    cell=getCell(rowInd,colInd)
+    return insertCellBefore(cell)
+  end
+  ##########################################################################
+  # Inserts and returns a row at the given index, thereby shifting existing rows
+  #   row=mySheet.insertRow(1) # inserts row above former row 1
+  #-------------------------------------------------------------------------
+  def insertRow(rowInd)
+    die("insertRow: invalid rowInd #{rowInd}") unless (rowInd > 0)
+    die("insertRow: rowInd #{rowInd} is not a Fixnum/Integer") unless (rowInd.class.to_s == "Fixnum")
+    tell("insertRow: inserting new row")
+    row=getRow(rowInd)
+    return insertRowAbove(row)
+  end
+  ##########################################################################
   # Inserts a new row above the given row thereby shifting existing rows
   #   row=mySheet.getRow(1)
   #   mySheet.insertRowAbove(row)
@@ -2823,31 +3100,70 @@ class Rods
     return newRow
   end
   ##########################################################################
+  # Deletes the column at the given index
+  #
+  #   mySheet.deleteColumn(8)
+  #-------------------------------------------------------------------------
+  def deleteColumn(colInd)
+    die("deleteColumn: index #{colInd} is not a Fixnum/Integer") unless (colInd.class.to_s == "Fixnum")
+    die("deleteColumn: invalid index #{colInd}") unless (colInd > 0)
+    currentWidth=@tables[@currentTableName][WIDTH]
+    die("deleteColumn: column-index #{colInd} is outside valid range/current table width") if (colInd > currentWidth)
+    #-------------------------------------------------------------------
+    # Entweder Wiederholungsattribut der fraglichen Spalte dekrementieren
+    # oder selbige loeschen
+    #-------------------------------------------------------------------
+    currentTable=@tables[@currentTableName][NODE]
+    column=getChildByIndex(currentTable,COLUMN,colInd)
+    repetitions=column.attributes["table:number-columns-repeated"]
+    if(repetitions && repetitions.to_i > 1)
+      column.attributes["table:number-columns-repeated"]=(repetitions.to_i-1).to_s
+    else
+      table=column.elements["ancestor::table:table"]
+      unless (table)
+        die("deleteColumn: internal error: Could not extract parent-table of column #{column}") 
+      end
+      table.elements.delete(column)
+    end
+    #-----------------------------------------------
+    # Fuer alle existierenden Zeilen neue Zelle an
+    # Spaltenposition einfuegen und dabei implizit
+    # Tabellenbreite aktualisieren
+    #-----------------------------------------------
+    row=getRow(1)
+    deleteCellFromRow(row,colInd)
+    i=1
+    while(row=getNextExistentRow(row)) # fuer alle Zeilen ab der zweiten
+      deleteCellFromRow(row,colInd)
+      i+=1
+    end 
+  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")
+  def insertColumn(colInd)
+    die("insertColumn: index #{colInd} is not a Fixnum/Integer") unless (colInd.class.to_s == "Fixnum")
+    die("insertColumn: invalid index #{colInd}") unless (colInd > 0)
     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)
+    column=getChildByIndex(currentTable,COLUMN,colInd)
+    insertColumnBeforeInHeader(column)
     #-----------------------------------------------
     # Fuer alle existierenden Zeilen neue Zelle an
     # Spaltenposition einfuegen und dabei implizit
     # Tabellenbreite aktualisieren
     #-----------------------------------------------
     row=getRow(1)
-    cell=getChildByIndex(row,CELL,index)
+    cell=getChildByIndex(row,CELL,colInd)
     insertCellBefore(cell)
     i=1
     while(row=getNextExistentRow(row)) # fuer alle Zeilen ab der zweiten
-      cell=getChildByIndex(row,CELL,index)
+      cell=getChildByIndex(row,CELL,colInd)
       insertCellBefore(cell)
       i+=1
     end 
@@ -2856,12 +3172,12 @@ class Rods
   # internal: returns cell at index if existent, nil otherwise
   #   row=getRowIfExists(4)
   #   if(row)
-  #     cell=getCellIfExists(row,7)
+  #     cell=getCellFromRowIfExists(row,7)
   #     unless(cell) .....
   #   end
   #-------------------------------------------------------------------------
-  def getCellIfExists(row,index)
-    return getElementIfExists(row,CELL,index)
+  def getCellFromRowIfExists(row,colInd)
+    return getElementIfExists(row,CELL,colInd)
   end
   ##########################################################################
   # internal: returns row at index if existent, nil otherwise
@@ -2869,9 +3185,9 @@ class Rods
   #     ........
   #   end
   #-------------------------------------------------------------------------
-  def getRowIfExists(index)
+  def getRowIfExists(rowInd)
     currentTable=@tables[@currentTableName][NODE]
-    return getElementIfExists(currentTable,ROW,index)
+    return getElementIfExists(currentTable,ROW,rowInd)
   end
   ##########################################################################
   # internal: examines, whether element of given type (row, cell, column) and index
@@ -2949,14 +3265,17 @@ class Rods
          :setStyle, :printOfficeStyles, :printAutoStyles, :getNextExistentRow, :getPreviousExistentRow, 
          :getNextExistentCell, :getPreviousExistentCell, :insertTableAfter, :insertTableBefore,
          :writeComment, :save, :saveAs, :initialize, :writeText, :getCellsAndIndicesFor,
-         :insertRowBelow, :insertRowAbove, :insertCellBefore, :insertCellAfter, :insertColumn
+         :insertRowBelow, :insertRowAbove, :insertCellBefore, :insertCellAfter, :insertColumn,
+         :insertRow, :insertCell, :insertCellFromRow, :deleteCellBefore, :deleteCellAfter,
+         :deleteCell, :deleteCellFromRow, :deleteRowAbove, :deleteRowBelow, :deleteRow,
+         :deleteColumn, :deleteRow2, :deleteCell2
 
   private :tell, :die, :createCell, :createRow, :getChildByIndex, :createElement, :setRepetition, :initHousekeeping, 
           :getTableWidth, :padTables, :padRow, :time2TimeVal, :percent2PercentVal, :date2DateVal, 
-          :finalize, :init, :normalizeText, :getColor, :normStyleHash, :getStyle, :getIndexOfElement,
-          :getNumberOfSiblings, :getIndexOrNumberOfSiblings, :createColumn,
+          :finalize, :init, :normalizeText, :getColor, :normStyleHash, :getStyle, :getIndex,
+          :getNumberOfSiblings, :getIndexAndOrNumber, :createColumn,
           :getAppropriateStyle, :checkStyleAttributes, :insertStyleAttributes, :cloneNode, 
           :writeStyle, :writeStyleXml, :style2Hash, :writeDefaultStyles, :writeXml, 
           :internalizeFormula, :getColorPalette, :open, :printStyles, :insertTableBeforeAfter, 
-          :insertColumnBefore, :getElementIfExists, :getRowIfExists, :getCellIfExists
+          :insertColumnBeforeInHeader, :getElementIfExists, :getRowIfExists, :getCellFromRowIfExists
 end # Klassenende

data/rods.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rods}
-  s.version = "0.8.1"
+  s.version = "0.9.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-13}
+  s.date = %q{2011-01-17}
   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/rods.rb"]
@@ -15,10 +15,11 @@ Gem::Specification.new do |s|
   s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Rods", "--main", "README"]
   s.require_paths = ["lib"]
   s.rubyforge_project = %q{rods}
-  s.rubygems_version = %q{1.4.2}
+  s.rubygems_version = %q{1.3.7}
   s.summary = %q{Automation of OpenOffice/LibreOffice by batch-processing of spreadsheets conforming to Open Document v1.1}
 
   if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rods
 version: !ruby/object:Gem::Version 
-  hash: 61
-  prerelease: 
+  hash: 59
+  prerelease: false
   segments: 
   - 0
-  - 8
-  - 1
-  version: 0.8.1
+  - 9
+  - 0
+  version: 0.9.0
 platform: ruby
 authors: 
 - Dr. Heinz Breinlinger
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-13 00:00:00 +01:00
+date: 2011-01-17 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
@@ -70,7 +70,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: rods
-rubygems_version: 1.4.2
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Automation of OpenOffice/LibreOffice by batch-processing of spreadsheets conforming to Open Document v1.1