roo 1.0.2 → 1.1.0

data/lib/roo/generic_spreadsheet.rb

@@ -9,17 +9,20 @@ class GenericSpreadsheet
   # sets the line with attribute names (default: 1)
   attr_accessor :header_line
 
+  def initialize
+  end
+
   # set the working sheet in the document
   def default_sheet=(sheet)
-    if sheet.kind_of? Fixnum 
+    if sheet.kind_of? Fixnum
       if sheet >= 0 and sheet <= sheets.length
-        sheet = self.sheets[sheet-1]      
+        sheet = self.sheets[sheet-1]
       else
         raise RangeError
       end
     elsif sheet.kind_of?(String)
       raise RangeError if ! self.sheets.include?(sheet)
-    else 
+    else
       raise TypeError, "what are you trying to set as default sheet?"
     end
     @default_sheet = sheet
@@ -27,121 +30,6 @@ class GenericSpreadsheet
     @first_row[sheet] = @last_row[sheet] = @first_column[sheet] = @last_column[sheet] = nil
     @cells_read[sheet] = false
   end
-  
-  # converts cell coordinate to numeric values of row,col
-  def normalize(row,col)
-    if row.class == String
-      if col.class == Fixnum
-        # ('A',1):
-        # ('B', 5) -> (5, 2)
-        row, col = col, row
-      else
-        raise ArgumentError
-      end
-    end
-    if col.class == String
-      col = GenericSpreadsheet.letter_to_number(col)
-    end
-    return row,col
-  end
-
-  # true if cell is empty
-  def empty?(row, col, sheet=nil)
-    #def excel_empty?(row, col, sheet=nil)
-    sheet = @default_sheet unless sheet
-    read_cells(sheet) unless @cells_read[sheet] or self.class == Excel
-    row,col = normalize(row,col)
-    return true unless cell(row, col, sheet)
-    return true if celltype(row, col, sheet) == :string && cell(row, col, sheet).empty?
-    #false
-    #end
-
-    # true if a cell is empty
-    #def oo_empty?(row, col, sheet=nil)
-    #sheet = @default_sheet unless sheet
-    #read_cells(sheet) unless @cells_read[sheet]
-    #row,col = normalize(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) == ""
-    #return true if celltype(row, col, sheet) == :string && cell(row, col, sheet) == ""
-    false
-  end
-
-
-  # reopens and read a spreadsheet document
-  def reload
-    ds = @default_sheet
-    initialize(@filename) if self.class == Openoffice or
-      self.class == Excel
-    initialize(@spreadsheetkey,@user,@password) if self.class == Google
-    self.default_sheet = ds
-    #@first_row = @last_row = @first_column = @last_column = nil
-  end
-
-  # Returns information of the spreadsheet document and all sheets within
-  # this document.
-  def info
-    # $log.debug(self.class.to_s+"#info started")
-    result = "File: #{File.basename(@filename)}\n"+
-      "Number of sheets: #{sheets.size}\n"+
-      "Sheets: #{sheets.map{|sheet| sheet+", "}.to_s[0..-3]}\n"
-    n = 1
-    # $log.debug(sheets.inspect)
-    sheets.each {|sheet|
-      # $log.debug("Info fuer Sheet=#{sheet}")
-      self.default_sheet = sheet
-      # $log.debug("nach default_sheet=")
-      result << "Sheet " + n.to_s + ":\n"
-      unless first_row
-        result << "  - empty -"
-      else
-        result << "  First row: #{first_row}\n"
-        result << "  Last row: #{last_row}\n"
-        result << "  First column: #{GenericSpreadsheet.number_to_letter(first_column)}\n"
-        result << "  Last column: #{GenericSpreadsheet.number_to_letter(last_column)}"
-      end
-      result << "\n" if sheet != sheets.last
-      n += 1
-    }
-    # $log.debug(self.class.to_s+"#info ended")
-    result
-  end
-
-  # 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,sheet=nil)
-    sheet = @default_sheet unless sheet
-    result = "--- \n"
-    (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,sheet)} \n"
-          if self.celltype(row,col,sheet) == :time
-            result << "  value: #{GenericSpreadsheet.integer_to_timestring( self.cell(row,col,sheet))} \n"
-          else
-            result << "  value: #{self.cell(row,col,sheet)} \n"
-          end
-        end
-      end
-    end
-    result
-  end
-
-  # recursively removes the current temporary directory
-  # this is only needed if you work with zipped files or files via the web
-  def remove_tmp
-    if File.exists?(@tmpdir)
-      FileUtils::rm_r(@tmpdir)
-    end
-  end
 
   # first non-empty column as a letter
   def first_column_as_letter(sheet=nil)
@@ -153,80 +41,43 @@ class GenericSpreadsheet
     GenericSpreadsheet.number_to_letter(last_column(sheet))
   end
 
-  def open_from_uri(uri)
-    require 'open-uri' ;
-    tempfilename = File.join(@tmpdir, File.basename(uri))
-    f = File.open(tempfilename,"wb")
-    begin
-      open(uri) do |net|
-        f.write(net.read)
-      end
-    rescue
-      raise "could not open #{uri}"
+  # returns the number of the first non-empty row
+  def first_row(sheet=nil)
+    if sheet == nil
+      sheet = @default_sheet
     end
-    f.close
-    File.join(@tmpdir, File.basename(uri))
-  end
-
-  # returns the number of the last non-empty 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]
+    if @first_row[sheet]
+      return @first_row[sheet]
     end
-    impossible_value = 0
+    impossible_value = 999_999 # more than a spreadsheet can hold
     result = impossible_value
     @cell[sheet].each_pair {|key,value|
       y,x = key.split(',')
       y = y.to_i
-      result = [result, y].max if value
+      result = [result, y].min if value
     } if @cell[sheet]
     result = nil if result == impossible_value
-    @last_row[sheet] = result
+    @first_row[sheet] = result
     result
   end
 
-  # returns the number of the last non-empty column
-  def last_column(sheet=nil)
-    # $log.debug("#{self.class.to_s}#last_column(#{sheet})")
+  # returns the number of the last non-empty row
+  def last_row(sheet=nil)
     sheet = @default_sheet unless sheet
     read_cells(sheet) unless @cells_read[sheet]
-    if @last_column[sheet]
-      # $log.debug("last_column of sheet #{sheet} already set")
-      return @last_column[sheet]
+    if @last_row[sheet]
+      return @last_row[sheet]
     end
-    # $log.debug("last_column of sheet #{sheet} not yet set")
     impossible_value = 0
     result = impossible_value
     @cell[sheet].each_pair {|key,value|
-      y,x = key.split(',')
-      x = x.to_i
-      result = [result, x].max if value
-    } if @cell[sheet]
-    result = nil if result == impossible_value
-    @last_column[sheet] = result
-    result
-  end
-
-  # returns the number of the first non-empty 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[sheet].each_pair {|key,value|
       y,x = key.split(',')
       y = y.to_i
-      result = [result, y].min if value
+      result = [result, y].max if value
     } if @cell[sheet]
     result = nil if result == impossible_value
-    @first_row[sheet] = result
+    @last_row[sheet] = result
     result
   end
 
@@ -251,27 +102,51 @@ class GenericSpreadsheet
     result
   end
 
-  # convert a number to something like this: 'AB'
-  def GenericSpreadsheet.number_to_letter(n)
-    letters=""
-    while n > 0
-      num = n%26
-      letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"[num-1,1] + letters
-      n = n.div(26)
+  # returns the number of the last non-empty column
+  def last_column(sheet=nil)
+    # $log.debug("#{self.class.to_s}#last_column(#{sheet})")
+    sheet = @default_sheet unless sheet
+    read_cells(sheet) unless @cells_read[sheet]
+    if @last_column[sheet]
+      # $log.debug("last_column of sheet #{sheet} already set")
+      return @last_column[sheet]
     end
-    letters
+    # $log.debug("last_column of sheet #{sheet} not yet set")
+    impossible_value = 0
+    result = impossible_value
+    @cell[sheet].each_pair {|key,value|
+      y,x = key.split(',')
+      x = x.to_i
+      result = [result, x].max if value
+    } if @cell[sheet]
+    result = nil if result == impossible_value
+    @last_column[sheet] = result
+    result
   end
 
-  # convert letters like 'AB' to a number
-  def self.letter_to_number(letters)
-    result = 0
-    while letters && letters.length > 0
-      character = letters[0,1].upcase
-      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]
+  # 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,sheet=nil)
+    sheet = @default_sheet unless sheet
+    result = "--- \n"
+    (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,sheet)} \n"
+          if self.celltype(row,col,sheet) == :time
+            result << "  value: #{GenericSpreadsheet.integer_to_timestring( self.cell(row,col,sheet))} \n"
+          else
+            result << "  value: #{self.cell(row,col,sheet)} \n"
+          end
+        end
+      end
     end
     result
   end
@@ -333,7 +208,7 @@ class GenericSpreadsheet
       if @header_line
         result = [ tmp ]
       else
-        result = tmp 
+        result = tmp
       end
       #-- :all
     elsif args[0] == :all
@@ -381,46 +256,224 @@ class GenericSpreadsheet
     result
   end
 
+  # 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
+    read_cells(sheet) unless @cells_read[sheet]
+    result = []
+    tmp_arr = []
+    @cell[sheet].each_pair {|key,value|
+      y,x = key.split(',')
+      x = x.to_i
+      y = y.to_i
+      if y == rownumber
+        tmp_arr[x] = value
+      end
+    }
+    result = tmp_arr[1..-1]
+    while result && result[-1] == nil
+      result = result[0..-2]
+    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 = Excel.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
+
+  # reopens and read a spreadsheet document
+  def reload
+    ds = @default_sheet
+    initialize(@filename) if self.class == Openoffice or
+      self.class == Excel
+    initialize(@spreadsheetkey,@user,@password) if self.class == Google
+    self.default_sheet = ds
+    #@first_row = @last_row = @first_column = @last_column = nil
+  end
+
+  # true if cell is empty
+  def empty?(row, col, sheet=nil)
+    sheet = @default_sheet unless sheet
+    read_cells(sheet) unless @cells_read[sheet] or self.class == Excel
+    row,col = normalize(row,col)
+    return true unless cell(row, col, sheet)
+    return true if celltype(row, col, sheet) == :string && cell(row, col, sheet).empty?
+    return true if row < first_row(sheet) || row > last_row(sheet) || col < first_column(sheet) || col > last_column(sheet)
+    false
+  end
+
+  # recursively removes the current temporary directory
+  # this is only needed if you work with zipped files or files via the web
+  def remove_tmp
+    if File.exists?(@tmpdir)
+      FileUtils::rm_r(@tmpdir)
+    end
+  end
+
+  # Returns information of the spreadsheet document and all sheets within
+  # this document.
+  def info
+    # $log.debug(self.class.to_s+"#info started")
+    result = "File: #{File.basename(@filename)}\n"+
+      "Number of sheets: #{sheets.size}\n"+
+      "Sheets: #{sheets.map{|sheet| sheet+", "}.to_s[0..-3]}\n"
+    n = 1
+    # $log.debug(sheets.inspect)
+    sheets.each {|sheet|
+      # $log.debug("Info fuer Sheet=#{sheet}")
+      self.default_sheet = sheet
+      # $log.debug("nach default_sheet=")
+      result << "Sheet " + n.to_s + ":\n"
+      unless first_row
+        result << "  - empty -"
+      else
+        result << "  First row: #{first_row}\n"
+        result << "  Last row: #{last_row}\n"
+        result << "  First column: #{GenericSpreadsheet.number_to_letter(first_column)}\n"
+        result << "  Last column: #{GenericSpreadsheet.number_to_letter(last_column)}"
+      end
+      result << "\n" if sheet != sheets.last
+      n += 1
+    }
+    # $log.debug(self.class.to_s+"#info ended")
+    result
+  end
+
   def to_xml
     xml_document = ''
     xml = Builder::XmlMarkup.new(:target => xml_document, :indent => 2)
     xml.instruct! :xml, :version =>"1.0", :encoding => "utf-8"
-   
-    xml.spreadsheet { 
-    self.sheets.each do |sheet|
-      self.default_sheet = sheet
-      xml.sheet(:name => sheet) { |x|
-        first_row.upto(last_row) do |row|
-          first_column.upto(last_column) do |col|
-            unless empty?(row,col)
-              x.cell(cell(row,col), 
-                     :row =>row, 
-                     :column => col, 
-                     :type => celltype(row,col))
+    xml.spreadsheet {
+      self.sheets.each do |sheet|
+        self.default_sheet = sheet
+        xml.sheet(:name => sheet) { |x|
+          if first_row and last_row and first_column and last_column
+            # sonst gibt es Fehler bei leeren Blaettern
+            first_row.upto(last_row) do |row|
+              first_column.upto(last_column) do |col|
+                unless empty?(row,col)
+                  x.cell(cell(row,col),
+                    :row =>row,
+                    :column => col,
+                    :type => celltype(row,col))
+                end
+              end
             end
           end
-        end
-      }
-    end
-}
-    
+        }
+      end
+    }
     xml_document
   end
-  
+
   protected
 
-  def unzip(filename)
-    ret = nil
-    Zip::ZipFile.open(filename) do |zip|
-      ret = process_zipfile_packed zip
+  def file_type_check(filename, ext, name)
+    new_expression = {
+      '.ods' => 'Openoffice.new',
+      '.xls' => 'Excel.new',
+      '.xlsx' => 'Excelx.new',
+    }
+    case ext
+    when '.ods', '.xls', '.xlsx'
+      correct_class = "use #{new_expression[ext]} to handle #{ext} spreadsheet files"
+    else
+      raise "unknown file type: #{ext}"
+    end
+    if File.extname(filename).downcase != ext
+      case @file_warning
+      when :error
+        warn correct_class
+        raise TypeError, "#{filename} is not #{name} file"
+      when :warning
+        warn "are you sure, this is #{name} spreadsheet file?"
+        warn correct_class
+      when :ignore
+        # ignore
+      else
+        raise "#{@file_warning} illegal state of file_warning"
+      end
     end
-    ret
   end
 
+
   private
 
-  def initialize
+  # converts cell coordinate to numeric values of row,col
+  def normalize(row,col)
+    if row.class == String
+      if col.class == Fixnum
+        # ('A',1):
+        # ('B', 5) -> (5, 2)
+        row, col = col, row
+      else
+        raise ArgumentError
+      end
+    end
+    if col.class == String
+      col = GenericSpreadsheet.letter_to_number(col)
+    end
+    return row,col
+  end
 
+  def open_from_uri(uri)
+    require 'open-uri' ;
+    tempfilename = File.join(@tmpdir, File.basename(uri))
+    f = File.open(tempfilename,"wb")
+    begin
+      open(uri) do |net|
+        f.write(net.read)
+      end
+    rescue
+      raise "could not open #{uri}"
+    end
+    f.close
+    File.join(@tmpdir, File.basename(uri))
+  end
+
+  # convert a number to something like this: 'AB'
+  def GenericSpreadsheet.number_to_letter(n)
+    letters=""
+    while n > 0
+      num = n%26
+      letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"[num-1,1] + letters
+      n = n.div(26)
+    end
+    letters
+  end
+
+  # convert letters like 'AB' to a number
+  def self.letter_to_number(letters)
+    result = 0
+    while letters && letters.length > 0
+      character = letters[0,1].upcase
+      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
+    result
+  end
+
+  def unzip(filename)
+    ret = nil
+    Zip::ZipFile.open(filename) do |zip|
+      ret = process_zipfile_packed zip
+    end
+    ret
   end
 
   # check if default_sheet was set and exists in sheets-array
@@ -460,7 +513,6 @@ class GenericSpreadsheet
   end
 
   def write_csv_content(file=nil,sheet=nil)
-    # sheet = @default_sheet unless sheet
     file = STDOUT unless file
     if first_row(sheet) # sheet is not empty
       first_row(sheet).upto(last_row(sheet)) do |row|
@@ -512,20 +564,16 @@ class GenericSpreadsheet
           raise "unhandled onecell-class "+onecell.class.to_s
         end
       when :date
-        # str << '"'+onecell.to_s+'"'
         str << onecell.to_s
-        # str << onecell.strftime("%d.%m.%y")
       when :time
         str << GenericSpreadsheet.integer_to_timestring(onecell)
       else
         raise "unhandled celltype "+onecelltype.to_s
       end
     end
-    #cells << onecell
     str
   end
 
-  private 
   def  GenericSpreadsheet.integer_to_timestring(content)
     h = (content/3600.0).floor
     content = content - h*3600