roo 0.7.0 → 0.8.0

data/History.txt

@@ -1,3 +1,7 @@
+== 0.8.0 2007-12-15
+* 2 enhancements:
+  * Google online spreadsheets were implemented
+  * some methods common to more than one class were factored out to the GenericSpreadsheet (virtual) class
 == 0.7.0 2007-11-23
 * 6 enhancements:
   * Openoffice/Excel: the most methods can be called with an option 'sheet' 

data/Manifest.txt

@@ -6,8 +6,10 @@ Rakefile
 base64include.rb
 examples/roo_soap_server.rb
 examples/roo_soap_client.rb
+examples/write_me.rb
 lib/roo.rb
 lib/roo/version.rb
+lib/roo/generic_spreadsheet.rb
 lib/roo/openoffice.rb
 lib/roo/excel.rb
 lib/roo/google.rb

data/README.txt

@@ -3,4 +3,3 @@ README for roo
 
 see http://roo.rubyforge.org for examples
 
-PLEASE DON'T USE THE Google class - its only experimental.

data/Rakefile

@@ -14,7 +14,7 @@ require File.join(File.dirname(__FILE__), 'lib', 'roo', 'version')
 
 AUTHOR = 'Thomas Preymesser'  # can also be an array of Authors
 EMAIL = "thopre@gmail.com"
-DESCRIPTION = "roo can access the contents of OpenOffice-Spreadsheets and Excel-Spreadsheets"
+DESCRIPTION = "roo can access the contents of OpenOffice-, Excel- or Google-Spreadsheets"
 GEM_NAME = 'roo' # what ppl will type to install your gem
 
 @config_file = "~/.rubyforge/user-config.yml"
@@ -107,7 +107,7 @@ desc 'Generate and upload website files'
 task :website => [:website_generate, :website_upload]
 
 desc 'Release the website and new gem version'
-task :deploy => [:check_version, :website, :release] do
+task :deploy => [:check_log_params, :check_version, :website, :release ] do
   puts "Remember to create SVN tag:"
   puts "svn copy svn+ssh://#{rubyforge_username}@rubyforge.org/var/svn/#{PATH}/trunk " +
     "svn+ssh://#{rubyforge_username}@rubyforge.org/var/svn/#{PATH}/tags/REL-#{VERS} "
@@ -115,6 +115,16 @@ task :deploy => [:check_version, :website, :release] do
   puts "Tagging release #{CHANGES}"
 end
 
+desc 'Check to ensure the LOG_* constant in Test are set off'
+task :check_log_params do
+  require 'test/test_roo'
+  if DISPLAY_LOG
+    raise 'please turn off the DISPLAY_LOG constant for deployment!'
+  end
+  if DB_LOG
+    raise 'please turn off the DB_LOG constant for deployment!'
+  end
+end
 desc 'Runs tasks website_generate and install_gem as a local deployment of the gem'
 task :local_deploy => [:website_generate, :install_gem]
 

data/examples/write_me.rb

@@ -0,0 +1,33 @@
+require 'rubygems'
+require 'roo'
+
+#-- create a new spreadsheet within your google-spreadsheets and paste
+#-- the 'key' parameter in the spreadsheet URL 
+MAXTRIES = 1000
+print "what's your name? "
+my_name = gets.chomp
+print "where do you live? "
+my_location = gets.chomp
+print "your message? (if left blank, only your name and location will be inserted) "
+my_message = gets.chomp
+spreadsheet = Google.new('ptu6bbahNZpY0N0RrxQbWdw')
+spreadsheet.default_sheet = 'Sheet1'
+success = false
+MAXTRIES.times do
+  col = rand(10)+1
+  row = rand(10)+1
+  if spreadsheet.empty?(row,col)
+    if my_message.empty?
+      text = Time.now.to_s+" "+"Greetings from #{my_name} (#{my_location})"
+    else
+      text = Time.now.to_s+" "+"#{my_message} from #{my_name} (#{my_location})"
+    end
+    spreadsheet.set_value(row,col,text)
+    puts "message written to row #{row}, column #{col}"
+    success = true
+    break
+  end
+  puts "Row #{row}, column #{col} already occupied, trying again..."
+end
+puts "no empty cell found within #{MAXTRIES} tries" if !success
+

data/lib/roo.rb

@@ -3,6 +3,7 @@ end
 
 require 'roo/version'
 # require 'roo/spreadsheetparser' TODO:
+require 'roo/generic_spreadsheet' 
 require 'roo/openoffice'
 require 'roo/excel'
 require 'roo/google'

data/lib/roo/excel.rb

@@ -1,24 +1,25 @@
 require 'rubygems'
 gem 'parseexcel', '>= 0.5.2'
 require 'parseexcel'
+CHARGUESS=false
+require 'charguess' if CHARGUESS
 
 module Spreadsheet
   module ParseExcel
     class Worksheet
-     include Enumerable
-     attr_reader :min_row, :max_row, :min_col, :max_col
+      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
+class Excel < GenericSpreadsheet  #Openoffice
 
   EXCEL_NO_FORMULAS = 'formulas are not supported for excel spreadsheets'
 
+  # Creates a new Excel spreadsheet object.
+  # Parameter packed: :zip - File is a zip-file
   def initialize(filename, packed = nil)
     @tmpdir = "oo_"+$$.to_s
     unless File.exists?(@tmpdir)
@@ -26,7 +27,7 @@ class Excel < Openoffice
     end
     filename = open_from_uri(filename) if filename[0,7] == "http://"
     filename = unzip(filename) if packed and packed == :zip
-    if filename[-4..-1] != ".xls"
+    if File.extname(filename) != ".xls"
       warn "are you sure, this is an excel file?"
     end
     @filename = filename
@@ -41,7 +42,7 @@ class Excel < Openoffice
     end
     # @first_row = @last_row = @first_column = @last_column = nil
     #if ENV["roo_local"] != "thomas-p"
-      FileUtils::rm_r(@tmpdir)
+    FileUtils::rm_r(@tmpdir)
     #end
     @first_row = Hash.new
     @last_row = Hash.new
@@ -54,9 +55,19 @@ class Excel < Openoffice
     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
-                         )
+      if CHARGUESS
+        encoding = CharGuess::guess(@workbook.worksheet(i).name)
+        encoding = 'unicode' unless encoding
+
+
+        result << Iconv.new('utf-8',encoding).iconv(
+          @workbook.worksheet(i).name
+        )
+      else
+        result << Iconv.new('utf-8','unicode').iconv(
+          @workbook.worksheet(i).name
+        )
+      end
     end
     return result
   end
@@ -64,14 +75,14 @@ class Excel < Openoffice
   # sets the working sheet (1,2,3,..)
   def default_sheet=(n)
     if n.kind_of?(Fixnum)
-      @default_sheet = n #-1
+      #
     elsif n.kind_of?(String)
       raise RangeError if ! self.sheets.include?(n)
       # parseexcel supports now the name of a sheet
-      @default_sheet = n
     else
       raise TypeError, "what are you trying to set as default sheet?"
     end
+    @default_sheet = n
     @first_row[n] = @last_row[n] = @first_column[n] = @last_column[n] = nil
     @cells_read[n] = false
   end
@@ -91,9 +102,9 @@ class Excel < Openoffice
         cell = row_par.at(col-1)
         return nil unless cell
         case cell.type
-          when :numeric then return cell.to_f
-          when :text then return cell.to_s('utf-8')
-          when :date then return cell.date
+        when :numeric then return cell.to_f
+        when :text then return cell.to_s('utf-8')
+        when :date then return cell.date
         else  
           return nil # cell.to_s('utf-8')
         end
@@ -142,9 +153,9 @@ class Excel < Openoffice
     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
+        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
@@ -169,12 +180,12 @@ class Excel < Openoffice
     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 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
+          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
@@ -219,40 +230,23 @@ class Excel < Openoffice
     fr, lr, fc, lc = get_firsts_lasts(sheet)
     lr
   end
-
-  # true if a cell is empty
-  def empty?(row, col, sheet=nil)
-    sheet = @default_sheet unless 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) == ""
-    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
- 
+  # returns NO formula in excel spreadsheets
   def formula(row,col,sheet=nil)
     raise EXCEL_NO_FORMULAS
   end
+
+  # raises an exception because formulas are not supported for excel files
   def formula?(row,col,sheet=nil)
     raise EXCEL_NO_FORMULAS
   end
+  
+  # returns NO formulas in excel spreadsheets
   def formulas(sheet=nil)
     raise EXCEL_NO_FORMULAS
   end
 
-private
+  private
 
   # check if default_sheet was set
   def default_sheet_check
@@ -264,42 +258,7 @@ private
     sheet = @default_sheet unless sheet
     fr = fc = 999_999
     lr = lc = -999_999  
-    #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 
-            fc = [fc, i+1].min
-            lc = [lc, i+1].max
-            fr = [fr, line].min
-            lr = [lr, line].max
-          end
-        }
-      end
-      line += 1
-    }
-    end #=============================================================
     fr = worksheet.min_row + 1
     lr = worksheet.max_row + 1
     fc = worksheet.min_col + 1
@@ -319,19 +278,19 @@ p worksheet.class
     return fr, lr, fc, lc
   end
 
-
   # converts name of a sheet to index (0,1,2,..)
   def sheet_no(name)
     return name-1 if name.kind_of?(Fixnum)
     0.upto(@workbook.sheet_count - 1) do |i|
       # TODO: is there a better way to do conversion?
       return i if name == Iconv.new('utf-8','unicode').iconv(
-                    @workbook.worksheet(i).name
-                         )
+        @workbook.worksheet(i).name
+      )
     end
     raise StandardError, "sheet '#{name}' not found"
   end
 
+  # writes csv output to stdout or file
   def write_csv_content(file=nil,sheet=nil)
     file = STDOUT unless file
     sheet = @default_sheet unless sheet
@@ -345,15 +304,15 @@ p worksheet.class
           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
+          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 
@@ -369,7 +328,7 @@ p worksheet.class
     content = false
     row.each {|elem|
       if elem != ''
-      #if elem.class == String and elem.size > 0
+        #if elem.class == String and elem.size > 0
         content = true
       end
     } 

data/lib/roo/generic_spreadsheet.rb

@@ -0,0 +1,303 @@
+# Base class for all other types of spreadsheets
+class GenericSpreadsheet
+
+  attr_reader :default_sheet
+
+  # 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: #{@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"
+      result << "  First row: #{first_row}\n"
+      # $log.debug("nach first_row")
+      result << "  Last row: #{last_row}\n"
+      # $log.debug("nach last_row")
+      result << "  First column: #{GenericSpreadsheet.number_to_letter(first_column)}\n"
+      # $log.debug("nach first_column")
+      result << "  Last column: #{GenericSpreadsheet.number_to_letter(last_column)}"
+      # $log.debug("nach last_column")
+      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"
+          result << "  value: #{self.cell(row,col,sheet)} \n"
+        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)
+    GenericSpreadsheet.number_to_letter(first_column(sheet))
+  end
+
+  # last non-empty column as a letter
+  def last_column_as_letter(sheet=nil)
+    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}"
+    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]
+    end
+    impossible_value = 0
+    result = impossible_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[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})")
+    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
+    # $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
+    }
+    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 = nil if result == impossible_value
+    @first_row[sheet] = result
+    result
+  end
+
+  # returns the number of the first non-empty 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[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[sheet] = result
+    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)
+    end
+    letters
+  end
+
+  # convert letters like 'AB' to a number
+  def GenericSpreadsheet.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
+
+  protected
+
+  def unzip(filename)
+    ret = nil
+    Zip::ZipFile.open(filename) do |zip|
+      ret = process_zipfile_packed zip
+    end
+    ret
+  end
+
+  # helper method
+  def after(d)
+    if DateTime.now > d
+      yield
+    end  
+  end  
+
+  # helper method
+  def before(d)
+    if DateTime.now <= d 
+      yield
+    end  
+  end  
+
+  private
+
+  def initialize
+
+  end
+
+  def process_zipfile_packed(zip, path='')
+    ret=nil
+    if zip.file.file? path
+      # extract and return filename
+      @tmpdir = "oo_"+$$.to_s
+      unless File.exists?(@tmpdir)
+        FileUtils::mkdir(@tmpdir)
+      end
+      file = File.open(File.join(@tmpdir, path),"wb")
+      file.write(zip.read(path))
+      file.close
+      return File.join(@tmpdir, path)
+    else
+      unless path.empty?
+        path += '/'
+      end
+      zip.dir.foreach(path) do |filename|
+        ret = process_zipfile_packed(zip, path + filename)
+      end
+    end
+    ret
+  end
+
+end