roo 0.6.1 → 0.7.0

data/History.txt

@@ -1,3 +1,12 @@
+== 0.7.0 2007-11-23
+* 6 enhancements:
+  * Openoffice/Excel: the most methods can be called with an option 'sheet' 
+    parameter which will be used instead of the default sheet 
+  * Excel: improved the speed of CVS output
+  * Openoffice/Excel: new method #column
+  * Openoffice/Excel: new method #find
+  * Openoffice/Excel: new method #info
+  * better exception if a spreadsheet file does not exist
 == 0.6.1 2007-10-06
 * 2 enhancements:
   * Openoffice: percentage-values are now treated as numbers (not strings)

data/lib/roo/excel.rb

@@ -2,8 +2,23 @@ require 'rubygems'
 gem 'parseexcel', '>= 0.5.2'
 require 'parseexcel'
 
+module Spreadsheet
+  module ParseExcel
+    class Worksheet
+     include Enumerable
+     attr_reader :min_row, :max_row, :min_col, :max_col
+    end
+  end
+end
+
+
+# Class Excel is derived from class Openoffice. It implements almost all methods
+# from the Openoffice class in the same way. 
+# Parameter packed: :zip - File is a zip-file
 class Excel < Openoffice
 
+  EXCEL_NO_FORMULAS = 'formulas are not supported for excel spreadsheets'
+
   def initialize(filename, packed = nil)
     @tmpdir = "oo_"+$$.to_s
     unless File.exists?(@tmpdir)
@@ -15,28 +30,35 @@ class Excel < Openoffice
       warn "are you sure, this is an excel file?"
     end
     @filename = filename
+    unless File.file?(@filename)
+      raise IOError, "file #{@filename} does not exist"
+    end
     @workbook = Spreadsheet::ParseExcel.parse(filename)
     @default_sheet = nil
     # no need to set default_sheet if there is only one sheet in the document
     if self.sheets.size == 1
       @default_sheet = self.sheets.first
     end
-    @first_row = @last_row = @first_column = @last_column = nil
+    # @first_row = @last_row = @first_column = @last_column = nil
+    #if ENV["roo_local"] != "thomas-p"
+      FileUtils::rm_r(@tmpdir)
+    #end
+    @first_row = Hash.new
+    @last_row = Hash.new
+    @first_column = Hash.new
+    @last_column = Hash.new
+    @cells_read = Hash.new
   end
 
   def sheets
-    #if DateTime.now < Date.new(2007,6,10)
-    #  return  ["Tabelle1", "Name of Sheet 2", "Sheet3"]
-    #else
-      result = []
-      0.upto(@workbook.sheet_count - 1) do |i|
-        # TODO: is there a better way to do conversion?
-        result << Iconv.new('utf-8','unicode').iconv(
-                      @workbook.worksheet(i).name
-                           )
-      end
-      return result
-    #end
+    result = []
+    0.upto(@workbook.sheet_count - 1) do |i|
+      # TODO: is there a better way to do conversion?
+      result << Iconv.new('utf-8','unicode').iconv(
+                    @workbook.worksheet(i).name
+                         )
+    end
+    return result
   end
 
   # sets the working sheet (1,2,3,..)
@@ -50,14 +72,15 @@ class Excel < Openoffice
     else
       raise TypeError, "what are you trying to set as default sheet?"
     end
-    @first_row = @last_row = @first_column = @last_column = nil
-    @cells_read = false
+    @first_row[n] = @last_row[n] = @first_column[n] = @last_column[n] = nil
+    @cells_read[n] = false
   end
 
   # returns the content of a cell. The upper left corner is (1,1) or ('A',1)
-  def cell(row,col)
+  def cell(row,col,sheet=nil)
+    sheet = @default_sheet unless sheet
     row,col = normalize(row,col)
-    worksheet = @workbook.worksheet(sheet_no(@default_sheet))
+    worksheet = @workbook.worksheet(sheet_no(sheet))
     skip = 0
     line = 1
     worksheet.each(skip) { |row_par|
@@ -72,90 +95,163 @@ class Excel < Openoffice
           when :text then return cell.to_s('utf-8')
           when :date then return cell.date
         else  
-          return cell.to_s('utf-8')
+          return nil # cell.to_s('utf-8')
         end
       end
       line += 1
     }
   end
 
-  # returns the type of a cell: "float", "string", "date"
-  def celltype(row,col)
+  # returns the type of a cell: :float, :string, :date
+  def celltype(row,col,sheet=nil)
+    default_sheet_check if sheet == nil
+    sheet = @default_sheet unless sheet
     row,col = normalize(row,col)
-    default_sheet_check
-    worksheet = @workbook.worksheet(sheet_no(@default_sheet))
+
+    worksheet = @workbook.worksheet(sheet_no(sheet))
     skip = 0
     line = 1
     worksheet.each(skip) { |row_par|
       if line == row
+        return nil unless row_par
         cell = row_par.at(col-1)
         return nil unless cell
         case cell.type
-        when :numeric then return :float
-        when :text then return :string
-        when :date then return :date
-        else  return cell.type.to_sym
+        when :numeric 
+          return :float
+        when :text 
+          return :string
+        when :date 
+          return :date
+        else  
+          return cell.type.to_sym
         end
       end
       line += 1
     }
   end
 
-  # return this row a an array off cells
-  def row(rownumber)
+  # returns all values in this row as an array
+  # row numbers are 1,2,3,... like in the spreadsheet
+  def row(rownumber,sheet=nil)
+    sheet = @default_sheet unless sheet
     default_sheet_check
-    worksheet = @workbook.worksheet(sheet_no(@default_sheet))
-    therow = worksheet.row(rownumber-1) 
+    worksheet = @workbook.worksheet(sheet_no(sheet))
+    #therow = worksheet.row(rownumber-1) 
     result = []
-    therow.each {|cell|
-      case cell.type
-         when :numeric then result << cell.to_i
-         when :text then result << cell.to_s('utf-8')
-         when :date then result << cell.date
+    worksheet.row(rownumber-1).each {|cell|
+      if cell
+        case cell.type
+           when :numeric then result << cell.to_i
+           when :text then result << cell.to_s('utf-8')
+           when :date then result << cell.date
+        else
+          result << cell.to_s('utf-8')
+        end
       else
-        return result << cell.to_s('utf-8')
+        result << nil
       end
     }
     return result
   end
 
+  # returns all values in this column as an array
+  # column numbers are 1,2,3,... like in the spreadsheet
+  def column(columnnumber,sheet=nil)
+    if columnnumber.class == String
+      columnnumber = Openoffice.letter_to_number(columnnumber)
+    end
+    sheet = @default_sheet unless sheet
+    default_sheet_check
+    worksheet = @workbook.worksheet(sheet_no(sheet))
+    skip = 0
+    result = []
+    worksheet.each(skip) { |row_par|
+      if defined? row_par.at(columnnumber-1)
+        cell = row_par.at(columnnumber-1)
+      #if defined? cell = row_par.at(columnnumber-1)
+        if cell
+          case cell.type
+            when :numeric then result << cell.to_i
+            when :text    then result << cell.to_s('utf-8')
+            when :date    then result << cell.date
+          else
+            result << cell.to_s('utf-8')
+          end
+        else
+          result << nil
+        end
+      else
+        result << nil
+      end
+    } 
+    result
+  end
+
   # returns the first non empty column
-  def first_column
-    return @first_column if @first_column
-    fr, lr, fc, lc = get_firsts_lasts
+  def first_column(sheet=nil)
+    sheet = @default_sheet unless sheet
+    return @first_column[sheet] if @first_column[sheet]
+    fr, lr, fc, lc = get_firsts_lasts(sheet)
     fc
   end
 
   # returns the last non empty column
-  def last_column
-    return @last_column if @last_column
-    fr, lr, fc, lc = get_firsts_lasts
+  def last_column(sheet=nil)
+    sheet = @default_sheet unless sheet
+    return @last_column[sheet] if @last_column[sheet]
+    fr, lr, fc, lc = get_firsts_lasts(sheet)
     lc
   end
 
   # returns the first non empty row
-  def first_row
-    return @first_row if @first_row
-    fr, lr, fc, lc = get_firsts_lasts
+  def first_row(sheet=nil)
+    sheet = @default_sheet unless sheet
+    return @first_row[sheet] if @first_row[sheet]
+    fr, lr, fc, lc = get_firsts_lasts(sheet)
     fr
   end
 
   # returns the last non empty row
-  def last_row
-    return @last_row if @last_row
-    fr, lr, fc, lc = get_firsts_lasts
+  def last_row(sheet=nil)
+    sheet = @default_sheet unless sheet
+    return @last_row[sheet] if @last_row[sheet]
+    fr, lr, fc, lc = get_firsts_lasts(sheet)
     lr
   end
 
   # true if a cell is empty
-  def empty?(row, col)
+  def empty?(row, col, sheet=nil)
+    sheet = @default_sheet unless sheet
     row,col = normalize(row,col)
-    return true if row < first_row || row > last_row || col < first_column || col > last_column
-    return true unless cell(row, col)
-    return true if celltype(row, col) == "string" && cell(row, col) == ""
+    return true if row < first_row(sheet) || row > last_row(sheet) || col < first_column(sheet) || col > last_column(sheet)
+    return true unless cell(row, col, sheet)
+    return true if celltype(row, col, sheet) == "string" && cell(row, col, sheet) == ""
     false
   end
 
+  # first non-empty column as a letter
+  def first_column_as_letter(sheet=nil)
+    sheet = @default_sheet unless sheet
+    Openoffice.number_to_letter(first_column(sheet))
+  end
+  
+  # last non-empty column as a letter
+  def last_column_as_letter(sheet=nil)
+    sheet = @default_sheet unless sheet
+    Openoffice.number_to_letter(last_column(sheet))
+  end
+ 
+  def formula(row,col,sheet=nil)
+    raise EXCEL_NO_FORMULAS
+  end
+  def formula?(row,col,sheet=nil)
+    raise EXCEL_NO_FORMULAS
+  end
+  def formulas(sheet=nil)
+    raise EXCEL_NO_FORMULAS
+  end
+
 private
 
   # check if default_sheet was set
@@ -164,14 +260,33 @@ private
   end
 
   # determine the first and last boundaries
-  def get_firsts_lasts
+  def get_firsts_lasts(sheet=nil)
+    sheet = @default_sheet unless sheet
     fr = fc = 999_999
     lr = lc = -999_999  
-    worksheet = @workbook.worksheet(sheet_no(@default_sheet))
+    #TODO: worksheet = @workbook.worksheet(sheet_no(@default_sheet))
+    worksheet = @workbook.worksheet(sheet_no(sheet))
+    if false #=============================================================
+    if @filename == "test/false_encoding.xls"
+#assert_instance_of(Spreadsheet::ParseExcel::Worksheet, worksheet)
+p worksheet.class
+
+      p worksheet.methods
+      p '### min_row: '+worksheet.min_row.to_s
+      p '### max_row: '+worksheet.max_row.to_s
+      p '### min_col: '+worksheet.min_col.to_s
+      p '### max_col: '+worksheet.max_col.to_s
+    end
+    if @filename == "test/false_encoding.xls"
+      p worksheet
+    end
     skip = 0
     line = 1
     worksheet.each(skip) { |row_par|
       if row_par
+        if @filename == "test/false_encoding.xls"
+          p row_par
+        end
         row_par.each_with_index {|cell,i|
           # nicht beruecksichtigen, wenn nil und vorher noch nichts war
           if cell 
@@ -184,10 +299,23 @@ private
       end
       line += 1
     }
-    @first_row = fr
-    @last_row = lr
-    @first_column = fc
-    @last_column = lc
+    end #=============================================================
+    fr = worksheet.min_row + 1
+    lr = worksheet.max_row + 1
+    fc = worksheet.min_col + 1
+    lc = worksheet.max_col + 1
+    # 2007-11-05 BEGIN
+    # parsexcel liefert (mir unverstaendlich) eine Zeile als letzte Zeile
+    # zurueck, die aber leer ist. Deshalb Korrekturfunktion, die wirklich
+    # die letzte nicht leere Zeile liefert.
+    while empty_row? row(lr,sheet)
+      lr -= 1
+    end
+    # 2007-11-05 END
+    @first_row[sheet]    = fr
+    @last_row[sheet]     = lr
+    @first_column[sheet] = fc
+    @last_column[sheet]  = lc
     return fr, lr, fc, lc
   end
 
@@ -204,4 +332,48 @@ private
     raise StandardError, "sheet '#{name}' not found"
   end
 
+  def write_csv_content(file=nil,sheet=nil)
+    file = STDOUT unless file
+    sheet = @default_sheet unless sheet
+    worksheet = @workbook.worksheet(sheet_no(sheet))
+    skip = 0
+    worksheet.each(skip) { |row_par|
+      1.upto(row_par.length) {|col|
+        file.print(",") if col > 1
+        cell = row_par.at(col-1)
+        unless cell
+          empty = true
+        else
+          case cell.type
+            when :numeric 
+              onecelltype = :float
+              onecell = cell.to_f
+            when :text 
+              onecelltype = :string
+              onecell = cell.to_s('utf-8')
+            when :date 
+              onecelltype = :date
+              onecell = cell.date
+          else
+            onecelltype = nil
+            onecell = nil 
+          end
+        end 
+        file.print one_cell_output(onecelltype,onecell,empty) 
+      }
+      file.print("\n")
+    }
+  end
+
+  def empty_row?(row)
+    content = false
+    row.each {|elem|
+      if elem != ''
+      #if elem.class == String and elem.size > 0
+        content = true
+      end
+    } 
+    ! content
+  end
+
 end

data/lib/roo/openoffice.rb

@@ -4,16 +4,19 @@ require 'rexml/document'
 require 'fileutils'
 require 'zip/zipfilesystem'
 require 'date'
-#require 'llip'
 require 'base64'
-require 'logger'
 
-#require 'lib/roo/spreadsheetparser'
+# The class Openoffice defines the basic functionality for the access to
+# spreadsheet documents. Other classes like _Excel_ are defined as subclasses 
+# of this class.
 
 class Openoffice
 
   @@nr = 0
 
+  # sets the line with attribute names (default: 1)
+  attr_accessor :header_line
+
   # initialization and opening of a spreadsheet file
   # values for packed: :zip
   def initialize(filename, packed=nil) #, create = false)
@@ -29,17 +32,18 @@ class Openoffice
     #if create and ! File.exists?(filename)
     #  self.create_openoffice(filename)
     #end
-    @cells_read = false
+    @cells_read = Hash.new
+    #TODO: @cells_read[:default] = false
     @filename = filename
+    unless File.file?(@filename)
+      raise IOError, "file #{@filename} does not exist"
+    end
     @@nr += 1
     @file_nr = @@nr
     extract_content
     file = File.new(File.join(@tmpdir, @file_nr.to_s+"_roo_content.xml")) 
     @doc = REXML::Document.new file
     file.close
-    @cell = Hash.new
-    @cell_type = Hash.new
-    @formula = Hash.new
     #if ENV["roo_local"] != "thomas-p"
       FileUtils::rm_r(@tmpdir)
     #end
@@ -48,15 +52,18 @@ class Openoffice
     if self.sheets.size == 1
       @default_sheet = self.sheets.first
     end
-    @first_column = @last_column = nil
-    @first_row = @last_row = nil
-#    trap('INT') {
-#      FileUtils::rm_r(@tmpdir)
-#    }
+    @cell = Hash.new
+    @cell_type = Hash.new
+    @formula = Hash.new
+    @first_row = Hash.new
+    @last_row = Hash.new
+    @first_column = Hash.new
+    @last_column = Hash.new
+    @header_line = 1
   end
 
   # creates a new empty openoffice-spreadsheet file
-  def create_openoffice(filename)
+  def create_openoffice(filename) #:nodoc:
     #TODO: a better way for creating the file contents
     # now you have to call mkbase64...rb to create an include file with all
     # the empty files in an openoffice zip-file
@@ -69,70 +76,80 @@ class Openoffice
 
   # reopens and read a spreadsheet document
   def reload
-    default_sheet = @default_sheet
+    ds = @default_sheet
     initialize(@filename) 
-    self.default_sheet = default_sheet
-    @first_row = @last_row = @first_column = @last_column = nil
+    self.default_sheet = ds
+    #@first_row = @last_row = @first_column = @last_column = nil
   end
 
-  # returns the content of a spreadsheet-cell
-  # (1,1) is the upper left corner
+  # Returns the content of a spreadsheet-cell.
+  # (1,1) is the upper left corner.
   # (1,1), (1,'A'), ('A',1), ('a',1) all refers to the
-  # cell at first line, first row
-  def cell(row,col)
-    read_cells unless @cells_read
+  # cell at the first line and first row.
+  def cell(row, col, sheet=nil)
+    sheet = @default_sheet unless sheet
+    read_cells(sheet) unless @cells_read[sheet]
     row,col = normalize(row,col)
-    if celltype(row,col) == :date
-      yyyy,mm,dd = @cell["#{row},#{col}"].split('-')
+    if celltype(row,col,sheet) == :date
+      yyyy,mm,dd = @cell[sheet]["#{row},#{col}"].split('-')
       return Date.new(yyyy.to_i,mm.to_i,dd.to_i)
     end
-    @cell["#{row},#{col}"]
+    @cell[sheet]["#{row},#{col}"]
   end
 
-  # returns the formula at (row,col)
-  # nil if there is no formula
-  def formula(row,col)
-    read_cells unless @cells_read
+  # Returns the formula at (row,col).
+  # Returns nil if there is no formula.
+  # The method Openoffice#formula? checks if there is a formula.
+  def formula(row,col,sheet=nil)
+    sheet = @default_sheet unless sheet
+    read_cells(sheet) unless @cells_read[sheet]
     row,col = normalize(row,col)
-    if @formula["#{row},#{col}"] == nil
+    if @formula[sheet]["#{row},#{col}"] == nil
       return nil
     else
-      return @formula["#{row},#{col}"]["oooc:".length..-1]
+      return @formula[sheet]["#{row},#{col}"]["oooc:".length..-1]
     end
   end
 
   # true, if there is a formula
-  def formula?(row,col)
-    read_cells unless @cells_read
+  def formula?(row,col,sheet=nil)
+    sheet = @default_sheet unless sheet
+    read_cells unless @cells_read[sheet]
     row,col = normalize(row,col)
     formula(row,col) != nil
   end
 
   # set a cell to a certain value
   # (this will not be saved back to the spreadsheet file!)
-  def set(row,col,value)
-    read_cells unless @cells_read
+  def set(row,col,value,sheet=nil) #:nodoc:
+    sheet = @default_sheet unless sheet
+    read_cells(sheet) unless @cells_read[sheet]
     row,col = normalize(row,col)
-    set_value(row,col,value)
+    set_value(row,col,value,sheet)
     if value.class == Fixnum
-      set_type(row,col,:float)
+      set_type(row,col,:float,sheet)
     elsif value.class == String
-      set_type(row,col,:string)
+      set_type(row,col,:string,sheet)
     elsif value.class == Float
-      set_type(row,col,:string)
+      set_type(row,col,:string,sheet)
     else
-      raise ArgumentError, "Typ fuer "+value.to_s+" nicht gesetzt"
+      raise ArgumentError, "Type for "+value.to_s+" not set"
     end 
   end
 
-  # returns the open-office type of a cell
-  def celltype(row,col)
-    read_cells unless @cells_read
+  # returns the type of a cell:
+  # * :float 
+  # * :string, 
+  # * :date
+  # * :percentage
+  def celltype(row,col,sheet=nil)
+    sheet = @default_sheet unless sheet
+    read_cells(sheet) unless @cells_read[sheet]
     row,col = normalize(row,col)
-    if @formula["#{row},#{col}"]
+    if @formula[sheet]["#{row},#{col}"]
       return :formula
     else
-      @cell_type["#{row},#{col}"]
+      @cell_type[sheet]["#{row},#{col}"]
     end
   end
 
@@ -175,12 +192,9 @@ class Openoffice
       raise TypeError, "what are you trying to set as default sheet?"
     end
     @default_sheet = sheet
-    @first_row = @last_row = @first_column = @last_column = nil
-    @cells_read = false
-    @cell = Hash.new
-    @cell_type = Hash.new
-    @formula = Hash.new
     check_default_sheet
+    @first_row[sheet] = @last_row[sheet] = @first_column[sheet] = @last_column[sheet] = nil
+    @cells_read[sheet] = false
   end
 
   alias set_default_sheet default_sheet=
@@ -195,18 +209,20 @@ class Openoffice
 
   # shows the internal representation of all cells
   # mainly for debugging purposes
-  def to_s
-    read_cells unless @cells_read
-    @cell.inspect
+  def to_s(sheet=nil)
+    sheet = @default_sheet unless sheet
+    read_cells(sheet) unless @cells_read[sheet]
+    @cell[sheet].inspect
   end
 
   # returns all values in this row as an array
   # row numbers are 1,2,3,... like in the spreadsheet
-  def row(rownumber)
-    read_cells unless @cells_read
+  def row(rownumber,sheet=nil)
+    sheet = @default_sheet unless sheet
+    read_cells(sheet) unless @cells_read[sheet]
     result = []
     tmp_arr = []
-    @cell.each_pair {|key,value|
+    @cell[sheet].each_pair {|key,value|
       y,x = key.split(',')
       x = x.to_i
       y = y.to_i
@@ -220,105 +236,129 @@ class Openoffice
     end
     result
   end
-  
+ 
+  # returns all values in this column as an array
+  # column numbers are 1,2,3,... like in the spreadsheet
+  def column(columnnumber,sheet=nil)
+    if columnnumber.class == String
+      columnnumber = Openoffice.letter_to_number(columnnumber)
+    end
+    sheet = @default_sheet unless sheet
+    read_cells(sheet) unless @cells_read[sheet]
+    result = []
+    first_row(sheet).upto(last_row(sheet)) do |row|
+      result << cell(row,columnnumber,sheet)
+    end
+    result
+  end 
+
   # returns the number of the last non-empty row
-  def last_row
-    read_cells unless @cells_read
-    if @last_row
-      return @last_row
+  def last_row(sheet=nil)
+    sheet = @default_sheet unless sheet 
+    read_cells(sheet) unless @cells_read[sheet]
+    if @last_row[sheet]
+      return @last_row[sheet]
     end
     impossible_value = 0
     result = impossible_value
-    @cell.each_pair {|key,value|
+    @cell[sheet].each_pair {|key,value|
       y,x = key.split(',')
       y = y.to_i
       result = [result, y].max if value
     }
     result = nil if result == impossible_value 
-    @last_row = result
+    @last_row[sheet] = result
     result
   end
 
   # returns the number of the last non-empty column
-  def last_column
-    read_cells unless @cells_read
-    if @last_column
-      return @last_column
+  def last_column(sheet=nil)
+    sheet = @default_sheet unless sheet
+    read_cells(sheet) unless @cells_read[sheet]
+    if @last_column[sheet]
+      return @last_column[sheet]
     end
     impossible_value = 0
     result = impossible_value
-    @cell.each_pair {|key,value|
+    @cell[sheet].each_pair {|key,value|
       y,x = key.split(',')
       x = x.to_i
       result = [result, x].max if value
     }
     result = nil if result == impossible_value
-    @last_column = result
+    @last_column[sheet] = result
     result
   end
 
   # returns the number of the first non-empty row
-  def first_row
-    read_cells unless @cells_read
-    if @first_row
-      return @first_row
+  def first_row(sheet=nil)
+    if sheet == nil
+      sheet = @default_sheet
+    end
+    read_cells(sheet) unless @cells_read[sheet]
+    if @first_row[sheet]
+      return @first_row[sheet]
     end
     impossible_value = 999_999 # more than a spreadsheet can hold
     result = impossible_value 
-    @cell.each_pair {|key,value|
+    @cell[sheet].each_pair {|key,value|
       y,x = key.split(',')
       y = y.to_i
       result = [result, y].min if value
     }
     result = nil if result == impossible_value
-    @first_row = result
+    @first_row[sheet] = result
     result
   end
 
   # returns the number of the first non-empty column
-  def first_column
-    read_cells unless @cells_read
-    if @first_column
-      return @first_column
+  def first_column(sheet=nil)
+    if sheet == nil
+      sheet = @default_sheet
+    end
+    read_cells(sheet) unless @cells_read[sheet]
+    if @first_column[sheet]
+      return @first_column[sheet]
     end
     impossible_value = 999_999 # more than a spreadsheet can hold
     result = impossible_value 
-    @cell.each_pair {|key,value|
+    @cell[sheet].each_pair {|key,value|
       y,x = key.split(',')
       x = x.to_i
       result = [result, x].min if value
     }
     result = nil if result == impossible_value
-    @first_column = result
+    @first_column[sheet] = result
     result
   end
 
   # first non-empty column as a letter
-  def first_column_as_letter
-    Openoffice.number_to_letter(first_column)
+  def first_column_as_letter(sheet=nil)
+    Openoffice.number_to_letter(first_column(sheet))
   end
 
   # last non-empty column as a letter
-  def last_column_as_letter
-    Openoffice.number_to_letter(last_column)
+  def last_column_as_letter(sheet=nil)
+    Openoffice.number_to_letter(last_column(sheet))
   end
 
   # true if cell is empty
-  def empty?(row, col)
-    read_cells unless @cells_read
-    return true unless cell(row, col)
-    return true if celltype(row, col) == :string && cell(row, col).empty?
+  def empty?(row, col, sheet=nil)
+    sheet = @default_sheet unless sheet
+    read_cells(sheet) unless @cells_read[sheet]
+    return true unless cell(row, col, sheet)
+    return true if celltype(row, col, sheet) == :string && cell(row, col, sheet).empty?
     false
   end
 
   # save spreadsheet
-  def save
+  def save #:nodoc:
     42
   end
 
   # evaluate the formula at this cell 
   # experimental: DO NOT USE THIS!
-  def solve(row,col)
+  def solve(row,col) #:nodoc:
     parser = SpreadsheetParser.new
     visitor = Visitor.new
     #puts cell(row,col)
@@ -332,13 +372,14 @@ class Openoffice
 
   # returns each formula in the selected sheet as an array of elements
   # [row, col, formula]
-  def formulas
+  def formulas(sheet=nil)
     theformulas = Array.new
-    read_cells unless @cells_read
-    first_row.upto(last_row) {|row|
-      first_column.upto(last_column) {|col|
-        if formula?(row,col)
-          f = [row, col, formula(row,col)]
+    sheet = @default_sheet unless sheet
+    read_cells(sheet) unless @cells_read[sheet]
+    first_row(sheet).upto(last_row(sheet)) {|row|
+      first_column(sheet).upto(last_column(sheet)) {|col|
+        if formula?(row,col,sheet)
+          f = [row, col, formula(row,col,sheet)]
           theformulas << f
         end
       }
@@ -349,19 +390,20 @@ class Openoffice
   # returns a rectangular area (default: all cells) as yaml-output 
   # you can add additional attributes with the prefix parameter like:
   # oo.to_yaml({"file"=>"flightdata_2007-06-26", "sheet" => "1"})
-  def to_yaml(prefix={}, from_row=nil, from_column=nil, to_row=nil, to_column=nil)
+  def to_yaml(prefix={}, from_row=nil, from_column=nil, to_row=nil, to_column=nil,sheet=nil)
+    sheet = @default_sheet unless sheet
     result = "--- \n"
-    (from_row||first_row).upto(to_row||last_row) do |row|
-      (from_column||first_column).upto(to_column||last_column) do |col|
-        unless self.empty?(row,col)
+    (from_row||first_row(sheet)).upto(to_row||last_row(sheet)) do |row|
+      (from_column||first_column(sheet)).upto(to_column||last_column(sheet)) do |col|
+        unless empty?(row,col,sheet)
           result << "cell_#{row}_#{col}: \n" 
           prefix.each {|k,v|
             result << "  #{k}: #{v} \n"
           }
           result << "  row: #{row} \n" 
           result << "  col: #{col} \n" 
-          result << "  celltype: #{self.celltype(row,col)} \n" 
-          result << "  value: #{self.cell(row,col)} \n" 
+          result << "  celltype: #{self.celltype(row,col,sheet)} \n" 
+          result << "  value: #{self.cell(row,col,sheet)} \n" 
         end
       end
     end
@@ -369,20 +411,120 @@ class Openoffice
   end
 
   # write the current spreadsheet to stdout or into a file
-  def to_csv(filename=nil)
+  def to_csv(filename=nil,sheet=nil)
+    sheet = @default_sheet unless sheet
     if filename
       file = File.open(filename,"w") # do |file|
-      write_csv_content(file)
+      write_csv_content(file,sheet)
       file.close
     else
-      write_csv_content
+      write_csv_content(STDOUT,sheet)
     end
     true
   end
 
-protected
+  # find a row either by row number or a condition
+  # Caution: this works only within the default sheet -> set default_sheet before you call this method
+  # (experimental. see examples in the test_roo.rb file)
+  def find(*args)
+    result_array = false
+    args.each {|arg,val|
+      if arg.class == Hash
+        arg.each { |hkey,hval|
+          if hkey == :array and hval == true
+            result_array = true
+          end
+        }
+      end
+    }
+    column_with = {}
+    1.upto(last_column) do |col|
+      column_with[cell(@header_line,col)] = col
+    end
+    result = Array.new
+    #-- id
+    if args[0].class == Fixnum
+      rownum = args[0]
+      tmp = {}
+      1.upto(self.row(rownum).size) {|j|
+        x = ''
+        column_with.each { |key,val|
+          if val == j
+            x = key
+          end
+        }
+        tmp[x] = cell(rownum,j) 
+      } 
+      result = [ tmp ] # row(rownum)
+    #-- :all
+    elsif args[0] == :all 
+      if args[1].class == Hash
+        args[1].each {|key,val|
+          if key == :conditions
+            column_with = {}
+            1.upto(last_column) do |col|
+              column_with[cell(@header_line,col)] = col
+            end
+            conditions = val
+            first_row.upto(last_row) do |i|
+              # are all conditions met?
+              found = 1
+              conditions.each { |key,val|
+                if cell(i,column_with[key]) == val
+                  found *= 1
+                else
+                  found *= 0
+                end
+              }
+              # p self.row(i) if found > 0
+              if found > 0
+                tmp = {}
+                1.upto(self.row(i).size) {|j|
+                  x = ''
+                  column_with.each { |key,val|
+                    if val == j
+                      x = key
+                    end
+                  }
+                  tmp[x] = cell(i,j) 
+                } 
+                if result_array
+                  result << self.row(i)
+                else
+                  result << tmp
+                end
+              end
+            end
+          end # :conditions
+        }
+      end
+    end
+    result
+  end
+
+  # Returns information of the spreadsheet document and all sheets within
+  # this document.
+  def info
+    result = "File: #{@filename}\n"+
+    "Number of sheets: #{sheets.size}\n"+
+    "Sheets: #{sheets.map{|sheet| sheet+", "}.to_s[0..-3]}\n"
+    n = 1
+    sheets.each {|sheet|
+      self.default_sheet = sheet
+      result << "Sheet " + n.to_s + ":\n"
+      result << "  First row: #{first_row}\n"
+      result << "  Last row: #{last_row}\n"
+      result << "  First column: #{Openoffice.number_to_letter(first_column)}\n"
+      result << "  Last column: #{Openoffice.number_to_letter(last_column)}"
+      result << "\n" if sheet != sheets.last
+      n += 1
+    }
+    result
+  end
 
-  def process_zipfile_packed(zip, path='')
+private
+
+  def process_zipfile_packed(zip, path='') 
     ret=nil
     if zip.file.file? path
       # extract and return filename
@@ -405,7 +547,6 @@ protected
     ret
   end
 
-private
   def unzip(filename) 
     ret = nil
     Zip::ZipFile.open(filename) do |zip|
@@ -416,27 +557,31 @@ private
 
   # read the version of the OO-Version
   def oo_version
-    sheet_found = false
+    #sheet_found = false
     @doc.each_element do |oo_document|
       @officeversion = oo_document.attributes['version']
     end
   end
 
-  def belegen(x,y,i,v,vt,formula,tr,str_v)
-    @cell_type["#{y},#{x+i}"] = Openoffice.oo_type_2_roo_type(vt)
-    @formula["#{y},#{x+i}"] = formula if formula
-    case @cell_type["#{y},#{x+i}"] 
+  def set_cell_values(sheet,x,y,i,v,vt,formula,tr,str_v)
+    key = "#{y},#{x+i}"
+    @cell_type[sheet] = {} unless @cell_type[sheet]
+    @cell_type[sheet][key] = Openoffice.oo_type_2_roo_type(vt) 
+    @formula[sheet] = {} unless @formula[sheet]
+    @formula[sheet][key] = formula  if formula
+    @cell[sheet]    = {} unless @cell[sheet]
+    case @cell_type[sheet][key] 
     when :float
-      @cell["#{y},#{x+i}"] = v.to_f
+      @cell[sheet][key] = v.to_f 
     when :string
-      @cell["#{y},#{x+i}"] = str_v
+      @cell[sheet][key] = str_v 
     when :date
-      @cell["#{y},#{x+i}"] = tr.attributes['date-value']
+      @cell[sheet][key] = tr.attributes['date-value'] 
     when :percentage
-      @cell["#{y},#{x+i}"] = v.to_f
+      @cell[sheet][key] = v.to_f 
     else
-      @cell["#{y},#{x+i}"] = v
-    end                       
+      @cell[sheet][key] = v 
+    end                      
   end
 
   # read all cells in the selected sheet
@@ -444,9 +589,10 @@ private
   # the following construct means '4 blanks'
   # some content <text:s text:c="3"/>
   #++
-  def read_cells
+  def read_cells(sheet=nil)
+    sheet = @default_sheet unless sheet
     sheet_found = false
-    raise ArgumentError, "Error: default_sheet not set" if @default_sheet == nil
+    raise ArgumentError, "Error: sheet '#{sheet||'nil'}' not valid" if @default_sheet == nil and sheet==nil
     oo_document_count = 0
     @doc.each_element do |oo_document|
       # @officeversion = oo_document.attributes['version']
@@ -459,7 +605,7 @@ private
             if be.name == "spreadsheet"
               be.each_element do |se|
                 if se.name == "table"
-                  if se.attributes['name']==@default_sheet
+                  if se.attributes['name']==sheet #@default_sheet
                     sheet_found = true
                     x=1
                     y=1
@@ -502,12 +648,12 @@ private
                             if skip
                               if v != nil or tr.attributes['date-value']
                                 0.upto(skip.to_i-1) do |i|
-                                  belegen(x,y,i,v,vt,formula,tr,str_v)
+                                  set_cell_values(sheet,x,y,i,v,vt,formula,tr,str_v)
                                 end
                               end
                               x += (skip.to_i - 1)
                             end # if skip
-                            belegen(x,y,0,v,vt,formula,tr,str_v)
+                            set_cell_values(sheet,x,y,0,v,vt,formula,tr,str_v)
                             x += 1
                           end
                         end
@@ -523,10 +669,10 @@ private
         end
       end
     end
-    if sheet_found == false
+    if !sheet_found 
       raise RangeError 
     end
-    @cells_read = true
+    @cells_read[sheet] = true
   end
 
   # Checks if the default_sheet exists. If not an RangeError exception is 
@@ -615,7 +761,9 @@ private
     result = 0
     while letters && letters.length > 0
       character = letters[0,1].upcase
-      num = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".index(character)+1
+      num = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".index(character)
+      raise ArgumentError, "invalid column character '#{letters[0,1]}'" if num == nil
+      num += 1
       result = result * 26 + num
       letters = letters[1..-1]
     end
@@ -623,12 +771,14 @@ private
   end
 
   
-  def set_value(row,col,value)
-    @cell["#{row},#{col}"] = value
+  def set_value(row,col,value,sheet=nil)
+    sheet = @default_value unless sheet
+    @cell[sheet]["#{row},#{col}"] = value
   end
 
-  def set_type(row,col,type)
-    @cell_type["#{row},#{col}"] = type
+  def set_type(row,col,type,sheet=nil)
+    sheet = @default_value unless sheet
+    @cell_type[sheet]["#{row},#{col}"] = type
   end
 
   A_ROO_TYPE = {
@@ -658,39 +808,65 @@ private
     File.join(@tmpdir, File.basename(uri))
   end
 
-  def write_csv_content(file=nil)
+  def write_csv_content(file=nil,sheet=nil)
     file = STDOUT unless file
-      first_row.upto(last_row) do |row|
-        cells = []
-        1.upto(last_column) do |col|
+    if first_row # sheet is not empty
+      first_row(sheet).upto(last_row(sheet)) do |row|
+        1.upto(last_column(sheet)) do |col|
           file.print(",") if col > 1
-          onecell = cell(row,col)
-          onecelltype = celltype(row,col)
-          if empty?(row,col)
-            file.print('')
+          onecell = cell(row,col,sheet)
+          onecelltype = celltype(row,col,sheet)
+          file.print one_cell_output(onecelltype,onecell,empty?(row,col,sheet))
+        end
+        file.print("\n")
+      end # sheet not empty
+    end
+  end
+
+  def one_cell_output(onecelltype,onecell,empty)
+    str = ""
+    if empty 
+      str += ''
+    else
+      case onecelltype 
+      when :string
+        if onecell == ""
+          str << ''
+        else
+          onecell.gsub!(/"/,'""')
+          str << ('"'+onecell+'"')
+        end
+      when :float,:percentage
+        if onecell == onecell.to_i
+          str << onecell.to_i.to_s
+        else
+          str << onecell.to_s
+        end
+      when :formula
+        if onecell.class == String
+          if onecell == ""
+            str << ''
           else
-            case onecelltype 
-            when :string
-              if onecell == ""
-                file.print('')
-              else
-                onecell.gsub!(/"/,'""')
-                file.print('"'+onecell+'"')
-              end
-            when :float
-              if onecell == onecell.to_i
-                file.print onecell.to_i
-              else
-                file.print onecell
-              end
-            else
-              raise "unhandled celltype "+celltype.to_s
-            end
+            onecell.gsub!(/"/,'""')
+            str << '"'+onecell+'"'
+          end
+        elsif onecell.class == Float
+          if onecell == onecell.to_i
+            str << onecell.to_i.to_s
+          else
+            str << onecell.to_s
           end
-          cells << onecell
+        else
+          raise "unhandled onecell-class "+onecell.class.to_s
         end
-        file.print("\n")
+      when :date
+        str << '"'+onecell.to_s+'"'
+      else
+        raise "unhandled celltype "+onecelltype.to_s
       end
+    end
+    #cells << onecell
+    str
   end
 
   # helper method to convert compressed spaces and other elements within