rods 0.8.0 → 0.8.1

data/README

@@ -16,6 +16,8 @@
  Licensed under the same terms as Ruby. No warranty is provided.
 
  = Changelog
+ * 0.8.1
+   * Bug-Fix: methods insertRowBelow and insertCellAfter did not consider repetitions of previous element
  * 0.8.0
    * new function
      * insertColumn
@@ -78,18 +80,25 @@
  = What you must know
  When you open a (new) spreadsheet in an application like OpenOffice.org, you'll see an infinity of empty cells and
  might be tempted to assume that all these cells actually "exist" in the underlying file format/XML-structure.
- This is not the case ! A "newly born" spreadsheet does not contain even a single cell ! They're created on demand along
- with all other cells of lesser x- or y-coordinate.
- That is: If you write a cell with coordinates (10,10) all cells from (1,1) to (10,10)
- spring into existence or vice versa: If the cell farthest down the sheet and farthest to the right
- having a visible value has coordinates (90,87), then all cells from row 1-90 and column 1-87 exist, 
- but no cell out of this virutal rectangle is "alive".
+ This is not the case ! A "newly born" spreadsheet does not contain even a single cell ! They're created on demand.
+ That is: If you write a cell with coordinates (10,10) into a new sheet only 2 rows and 2 cells are created
+ * an empty row with a repetition-attribute of 9 ( -> visible as row 1 to 9)
+ * a second row (visible on line 10)
+ * a single cell in the second row with a repetition-attribute of 9 ( -> visible as cells 1 to 9 in line 10)
+ * a single cell after the previous cell ( -> visible as cell 10 in line 10)
+ Things get complicated when you insert one or more rows, but we won't delve into implementation details here.
+ Suffice it to say, that
+ * if a single cell in a row has a visible value, the row as well as the cell 'exist' in the former sense, i.e. 
+   they're definitely found by the routines get(Next|Previous)Existent(Row|Cell).
+ * the opposite does not apply: If a cell or row is visibly empty it COULD exist (and therefore be detectetd by 
+   the former routines) or not. That is: When using the 'fast routines' you will from time to time stumble over
+   cells and rows not bearing any value, but nevertheless existing and are well advised to verify the return-values !
+ 
  This is very important for using the interface appropriately: All routines matching 'Existent' merely return "living"
- cells, while all other routines bearing a "get|Get" create a row or cell if necessary (and implicitly all other cells
- within the new boundaries).
+ cells, while all other routines bearing a "get|Get" create a row or cell if necessary.
  In other words: Use
  * getNextExistentRow, getPreviousExistentRow, getNextExistentCell, getPreviousExistentCell
-   whenever you just want to read values you already have (seemlessly skipping visibly emtpy lines and columns) and
+   whenever you just want to read values you already have (seemlessly skipping most but not all visibly emtpy lines and columns) and
  * getCell, writeGetCell and writeGetCellFromRow whenever you want a cell to be created if it does not exist (which
    is undoubtedly the case, when you want to write to it or assign it a style) !
  The first return nil, if an element does not exist yet, the second always return the desired element.
@@ -297,51 +306,51 @@
 
  = Example 0.8.0
 
-   #  #!/usr/bin/ruby
-   #  # coding: UTF-8
-   #  #
-   #  # Author: Dr. Heinz Breinlinger
-   #  #
-   #  require 'rubygems'
-   #  require 'rods'
+   #!/usr/bin/ruby
+   # coding: UTF-8
+   #
+   # Author: Dr. Heinz Breinlinger
    #
-   #  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")
+   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 0.7.5
 
-   #  #!/usr/bin/ruby
-   #  # coding: UTF-8
-   #  #
-   #  # Author: Dr. Heinz Breinlinger
-   #  #
-   #  require 'rubygems'
-   #  require 'rods'
+   #!/usr/bin/ruby
+   # coding: UTF-8
+   #
+   # Author: Dr. Heinz Breinlinger
    #
-   #  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")
+   require 'rubygems'
+   require 'rods'
+ 
+   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
 
@@ -483,6 +492,9 @@
    # allow the XML-Parser to just continue from the "adjacent" node and 
    # return the previsous/next element without having to start from the top-node 
    # of the document over and over again !
+   # Caveat: According to the explanation above, you definitely know, that a cell/row
+   # exist, if they bear a value; if they don't, it depends on the sheets history,
+   # whether these are 'alive' and therefore accessible by the afore functions or not !
    #---------------------------------------------------------------------------------
    while(row=mySheet.getNextExistentRow(row))  
      i+=1

data/Rakefile

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

@@ -435,7 +435,6 @@ class Rods
   #-------------------------------------------------------------------------
   def renameTable(oldName,newName)
     die("renameTable: table '#{oldName}' does not exist") unless (@tables.has_key?(oldName))
-    # die("renameTable: table '#{oldName}' cannot be renamed as it is the current table !") if (oldName == @currentTableName)
     #------------------------------------------------------
     # XML-Tree anpassen
     #------------------------------------------------------
@@ -810,11 +809,11 @@ class Rods
         else
           text=textElement.text
           if(! text)
-	    text=""
+            text=""
           end
           type=cell.attributes["office:value-type"]
           if(! type)
-	    type="string"
+            type="string"
           end
           text=normalizeText(text,type)
           return text,type
@@ -2599,12 +2598,12 @@ class Rods
   # Also consider that you have to search for the external (i.e. visible)
   # represenation of a cell's content, not it's internal computational value.
   # For instance, when looking for a currency value of 1525 (that is shown as
-  # '1.525 €', you'll have to code
+  # '1.525 EUR'), you'll have to code
   #
-  # result=mySheet.getCellsAndIndicesFor('1[.,]525')
-  # result.each{ |cellHash|
-  #   puts("Found #{cellHash[:cell] on #{cellHash[:row] - #{cellHash[:col]")
-  # }
+  #   result=mySheet.getCellsAndIndicesFor('1[.,]525')
+  #   result.each{ |cellHash|
+  #     puts("Found #{cellHash[:cell] on #{cellHash[:row] - #{cellHash[:col]")
+  #   }
   #-------------------------------------------------------------------------
   def getCellsAndIndicesFor(content)
     die("getCellsAndIndicesFor: 'content' is not of typ String") unless (content.class.to_s == "String")
@@ -2776,8 +2775,16 @@ class Rods
   def insertCellAfter(cell)
     newCell=createCell(1)
     cell.next_sibling=newCell
+    #-----------------------------------------------------------------------
+    # Cave: etwaige Wiederholungen uebertragen
+    #-----------------------------------------------------------------------
+    repetitions=cell.attributes["table:number-columns-repeated"]
+    if(repetitions)
+      cell.attributes.delete("table:number-columns-repeated")
+      newCell.next_sibling=createCell(repetitions.to_i)
+    end
     #-----------------------------------------
-    # bisherige Tabellenbreite überschritten ?
+    # bisherige Tabellenbreite ueberschritten ?
     #-----------------------------------------
     lengthOfRow=getNumberOfSiblings(cell)
     if(lengthOfRow > @tables[@currentTableName][WIDTH])
@@ -2805,6 +2812,14 @@ class Rods
   def insertRowBelow(row)
     newRow=createRow(1)
     row.next_sibling=newRow
+    #-----------------------------------------------------------------------
+    # Cave: etwaige Wiederholungen uebertragen
+    #-----------------------------------------------------------------------
+    repetitions=row.attributes["table:number-rows-repeated"]
+    if(repetitions)
+      row.attributes.delete("table:number-rows-repeated")
+      newRow.next_sibling=createRow(repetitions.to_i)
+    end
     return newRow
   end
   ##########################################################################
@@ -2838,6 +2853,81 @@ class Rods
     end 
   end
   ##########################################################################
+  # internal: returns cell at index if existent, nil otherwise
+  #   row=getRowIfExists(4)
+  #   if(row)
+  #     cell=getCellIfExists(row,7)
+  #     unless(cell) .....
+  #   end
+  #-------------------------------------------------------------------------
+  def getCellIfExists(row,index)
+    return getElementIfExists(row,CELL,index)
+  end
+  ##########################################################################
+  # internal: returns row at index if existent, nil otherwise
+  #   if(mySheet.getRowIfExists(4))
+  #     ........
+  #   end
+  #-------------------------------------------------------------------------
+  def getRowIfExists(index)
+    currentTable=@tables[@currentTableName][NODE]
+    return getElementIfExists(currentTable,ROW,index)
+  end
+  ##########################################################################
+  # internal: examines, whether element of given type (row, cell, column) and index
+  # exists or not.
+  # Returns the element or nil if not existent.
+  #-------------------------------------------------------------------------
+  def getElementIfExists(parent,type,index)
+    die("getElementIfExists: invalid type #{type}")
+    die("getElementIfExists: parent is not a REXML::Element") unless (parent.class.to_s == "REXML::Element")
+    die("getElementIfExists: index #{index} is not a Fixnum/Integer") unless (index.class.to_s == "Fixnum")
+    die("getElementIfExists: invalid range for index #{index}") unless (index > 0)
+    #--------------------------------------------------------------
+    # Typabhaengige Vorbelegungen
+    #--------------------------------------------------------------
+    case type
+      when CELL
+        kindOfSelf="table:table-cell"
+        kindOfParent="table:table-row"
+        kindOfRepetition="table:number-columns-repeated"
+      when COLUMN
+        kindOfSelf="table:table-column"
+        kindOfParent="table:table"
+        kindOfRepetition="table:number-columns-repeated"
+      when ROW
+        kindOfSelf="table:table-row"
+        kindOfParent="table:table"
+        kindOfRepetition="table:number-rows-repeated"
+      else
+        die("getElementIfExists: invalid type #{type}")
+    end
+    #--------------------------------------------------------------
+    # Ist Kind-Element mit Index in Vater-Element vorhanden ?
+    #--------------------------------------------------------------
+    i=0
+    parent.elements.each(kindOfSelf){ |child|
+      i+=1
+      #----------------------------------------------------------
+      # Index ueberschritten ? -> Ruecksprung mit nil
+      # Index gefunden ? -> Rueckgabe des Elementes
+      # sonst: etwaige Wiederholungen zaehlen
+      #----------------------------------------------------------
+      if (i > index)
+        return nil
+      elsif(i == index)
+        tell("getElementIfExists: Found element #{type} at index #{index}")
+        return child
+      elsif(repetition=child.attributes[kindOfRepetition])
+        index+=repetition.to_i-1 # '-1', da aktuelles Element ebenfalls als Wiederholung zaehlt
+      end
+    }
+    #-------------------------------------------------------
+    # Index liegt ausserhalb vorhandener Kind-Elemente
+    #-------------------------------------------------------
+    return nil
+  end
+  ##########################################################################
   # internal: Opens zip-file
   #-------------------------------------------------------------------------
   def open(file)
@@ -2857,7 +2947,7 @@ class Rods
          :getCellFromRow, :getCell, :getRow, :renameTable, :setCurrentTable, 
          :insertTable, :deleteTable, :readCellFromRow, :readCell, :setAttributes, :writeStyleAbbr, 
          :setStyle, :printOfficeStyles, :printAutoStyles, :getNextExistentRow, :getPreviousExistentRow, 
-	 :getNextExistentCell, :getPreviousExistentCell, :insertTableAfter, :insertTableBefore,
+         :getNextExistentCell, :getPreviousExistentCell, :insertTableAfter, :insertTableBefore,
          :writeComment, :save, :saveAs, :initialize, :writeText, :getCellsAndIndicesFor,
          :insertRowBelow, :insertRowAbove, :insertCellBefore, :insertCellAfter, :insertColumn
 
@@ -2868,5 +2958,5 @@ class Rods
           :getAppropriateStyle, :checkStyleAttributes, :insertStyleAttributes, :cloneNode, 
           :writeStyle, :writeStyleXml, :style2Hash, :writeDefaultStyles, :writeXml, 
           :internalizeFormula, :getColorPalette, :open, :printStyles, :insertTableBeforeAfter, 
-          :insertColumnBefore
+          :insertColumnBefore, :getElementIfExists, :getRowIfExists, :getCellIfExists
 end # Klassenende

data/rods.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rods}
-  s.version = "0.8.0"
+  s.version = "0.8.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
   s.authors = ["Dr. Heinz Breinlinger"]
@@ -15,11 +15,10 @@ 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.3.7}
+  s.rubygems_version = %q{1.4.2}
   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: 63
-  prerelease: false
+  hash: 61
+  prerelease: 
   segments: 
   - 0
   - 8
-  - 0
-  version: 0.8.0
+  - 1
+  version: 0.8.1
 platform: ruby
 authors: 
 - Dr. Heinz Breinlinger
@@ -70,7 +70,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: rods
-rubygems_version: 1.3.7
+rubygems_version: 1.4.2
 signing_key: 
 specification_version: 3
 summary: Automation of OpenOffice/LibreOffice by batch-processing of spreadsheets conforming to Open Document v1.1