roo 1.2.3 → 1.3.5

data/{README.txt → README.markdown}

@@ -1,11 +1,17 @@
-README for roo
-==============
+# README for Roo
 
-Installation:
+This is now the official roo repository and I'll be making a release on RubyForge in the next few weeks.  
 
-    sudo gem install roo
 
-Usage:
+## Installation
+
+    # Run the following if you haven't done so before:
+    gem sources -a http://gems.github.com/
+
+    # Install the gem:
+    sudo gem install hmcgowan-roo
+
+## Usage:
 
     require 'rubygems'
     require 'roo'

data/lib/roo/excel.rb

@@ -1,16 +1,33 @@
-require 'rubygems'
-gem 'parseexcel', '>= 0.5.2'
-require 'parseexcel'
-CHARGUESS = false
-require 'charguess' if CHARGUESS
+require 'spreadsheet'
+CHARGUESS = begin
+  require 'charguess'
+  true
+rescue LoadError => e
+  false
+end
 
-module Spreadsheet # :nodoc
-  module ParseExcel
-    class Worksheet
-      include Enumerable
-      attr_reader :min_row, :max_row, :min_col, :max_col
-    end
+# ruby-spreadsheet has a font object so we're extending it 
+# with our own functionality but still providing full access
+# to the user for other font information
+module ExcelFontExtensions
+  def bold?(*args)
+    #From ruby-spreadsheet doc: 100 <= weight <= 1000, bold => 700, normal => 400
+    case weight
+    when 700    
+     true
+    else
+     false
+    end   
+  end
+
+  def italic?
+    italic
   end
+
+  def underline?
+    underline != :none
+  end
+
 end
 
 # Class for handling Excel-Spreadsheets
@@ -37,7 +54,7 @@ class Excel < GenericSpreadsheet
       unless File.file?(@filename)
         raise IOError, "file #{@filename} does not exist"
       end
-      @workbook = Spreadsheet::ParseExcel.parse(filename)
+      @workbook = Spreadsheet.open(filename)
       @default_sheet = nil
       # no need to set default_sheet if there is only one sheet in the document
       if self.sheets.size == 1
@@ -57,25 +74,14 @@ class Excel < GenericSpreadsheet
     @last_column = Hash.new
     @header_line = 1
     @cells_read = Hash.new
+    @fonts = Hash.new
   end
 
   # returns an array of sheet names in the spreadsheet
   def sheets
     result = []
-    #0.upto(@workbook.worksheets.size - 1) do |i| # spreadsheet
-    0.upto(@workbook.sheet_count - 1) do |i| # parseexcel
-      # TODO: is there a better way to do conversion?
-      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 << platform_specific_iconv(@workbook.worksheet(i).name)
-      end
+    @workbook.worksheets.each do |worksheet| 
+      result << normalize_string(worksheet.name)
     end
     return result
   end
@@ -169,6 +175,14 @@ class Excel < GenericSpreadsheet
     raise EXCEL_NO_FORMULAS
   end
 
+  # Given a cell, return the cell's font
+  def font(row, col, sheet=nil)
+    sheet = @default_sheet unless sheet
+    read_cells(sheet) unless @cells_read[sheet]
+    row,col = normalize(row,col)
+    @fonts[sheet][[row,col]]
+  end 
+  
   # shows the internal representation of all cells
   # mainly for debugging purposes
   def to_s(sheet=nil)
@@ -218,14 +232,10 @@ class Excel < GenericSpreadsheet
   # 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|
-      #0.upto(@workbook.worksheets.size - 1) do |i|
-      # TODO: is there a better way to do conversion?
-      return i if name == platform_specific_iconv(
-        @workbook.worksheet(i).name)
-      #Iconv.new('utf-8','unicode').iconv(
-      #        @workbook.worksheet(i).name
-      #      )
+    i = 0
+    @workbook.worksheets.each do |worksheet|
+      return i if name == normalize_string(worksheet.name)
+      i += 1
     end
     raise StandardError, "sheet '#{name}' not found"
   end
@@ -249,7 +259,16 @@ class Excel < GenericSpreadsheet
     }
     ! content
   end
-
+  
+  def normalize_string(value)
+    value = every_second_null?(value) ? remove_every_second_null(value) : value
+    if CHARGUESS && encoding = CharGuess::guess(value)
+      Iconv.new('utf-8', encoding)
+    else
+      platform_specific_iconv(value)
+    end
+  end
+  
   def platform_specific_iconv(value)
     case RUBY_PLATFORM.downcase
     when /darwin/
@@ -291,19 +310,22 @@ class Excel < GenericSpreadsheet
   end
 
   # helper function to set the internal representation of cells
-  def set_cell_values(sheet,x,y,i,v,vt,formula,tr,str_v)
+  def set_cell_values(sheet,row,col,i,v,vt,formula,tr,font)
     #key = "#{y},#{x+i}"
-    key = [y,x+i]
+    key = [row,col+i]
     @cell_type[sheet] = {} unless @cell_type[sheet]
     @cell_type[sheet][key] = vt 
     @formula[sheet] = {} unless @formula[sheet]
     @formula[sheet][key] = formula  if formula
     @cell[sheet]    = {} unless @cell[sheet]
+    @fonts[sheet] = {} unless @fonts[sheet]
+    @fonts[sheet][key] = font
+    
     case vt # @cell_type[sheet][key]
     when :float
       @cell[sheet][key] = v.to_f
     when :string
-      @cell[sheet][key] = str_v
+      @cell[sheet][key] = v
     when :date
       @cell[sheet][key] = v 
     when :datetime
@@ -328,63 +350,90 @@ class Excel < GenericSpreadsheet
     end
     
     worksheet = @workbook.worksheet(sheet_no(sheet))
-    skip = 0
-    x =1
-    y=1
-    i=0
-    worksheet.each(skip) { |row_par| 
-      if row_par
-        x =1
-        row_par.each do # |void|
-          cell = row_par.at(x-1)
-          if cell
-            case cell.type
-            when :numeric
-              vt = :float
-              v = cell.to_f
-            when :text
-              vt = :string
-              str_v = cell.to_s('utf-8')
-            when :date
-              if cell.to_s.to_f < 1.0
-                vt = :time
-                f = cell.to_s.to_f*24.0*60.0*60.0
-                secs = f.round
-                h = (secs / 3600.0).floor
-                secs = secs - 3600*h
-                m = (secs / 60.0).floor
-                secs = secs - 60*m
-                s = secs
-                v = h*3600+m*60+s
-              else
-                if cell.datetime.hour != 0 or
-                    cell.datetime.min  != 0 or
-                    cell.datetime.sec  != 0 or
-                    cell.datetime.msec != 0
-                  vt = :datetime
-                  v = cell.datetime
-                else
-                  vt = :date
-                  v = cell.date
-                  v = sprintf("%04d-%02d-%02d",v.year,v.month,v.day)
-                end
-              end
-            else
-              vt = cell.type.to_s.downcase.to_sym
-              v = nil
-            end # case
-            formula = tr = nil #TODO:???
-            set_cell_values(sheet,x,y,i,v,vt,formula,tr,str_v)
-          end # if cell
-          
-          x += 1
+    row_index=1
+    worksheet.each(0) do |row| 
+      (0..row.size).each do |cell_index|
+        cell = row.at(cell_index)
+        next if cell.nil?  #skip empty cells
+        next if cell.class == Spreadsheet::Formula
+        if date_or_time?(row, cell_index)
+          vt, v = read_cell_date_or_time(row, cell_index)
+        else
+          vt, v = read_cell(row, cell_index)
         end
-      end
-      y += 1
-    }
+        formula = tr = nil #TODO:???
+        col_index = cell_index + 1
+        font = row.format(cell_index).font
+        font.extend(ExcelFontExtensions)
+        set_cell_values(sheet,row_index,col_index,0,v,vt,formula,tr,font)
+      end #row
+      row_index += 1
+    end # worksheet
     @cells_read[sheet] = true
   end
-
+  
+  # Test the cell to see if it's a valid date/time. 
+  def date_or_time?(row, idx)
+    format = row.format(idx)
+    if format.date_or_time?
+      cell = row.at(idx)
+      true if Float(cell) > 0 rescue false
+    else
+      false
+    end  
+  end
+  private :date_or_time?
+  
+  # Read the date-time cell and convert to, 
+  # the date-time values for Roo
+  def read_cell_date_or_time(row, idx)
+    cell = row.at(idx).to_s.to_f
+    if cell < 1.0
+      value_type = :time
+      f = cell*24.0*60.0*60.0
+      secs = f.round
+      h = (secs / 3600.0).floor
+      secs = secs - 3600*h
+      m = (secs / 60.0).floor
+      secs = secs - 60*m
+      s = secs
+      value = h*3600+m*60+s
+    else
+      datetime = row.datetime(idx)
+      if datetime.hour != 0 or
+         datetime.min != 0 or
+         datetime.sec != 0 
+        value_type = :datetime
+        value = datetime
+      else
+        value_type = :date
+        value = row.date(idx)
+        value = sprintf("%04d-%02d-%02d",value.year,value.month,value.day)
+      end
+    end  
+    return value_type, value
+  end
+  private :read_cell_date_or_time
+  
+  # Read the cell and based on the class, 
+  # return the values for Roo
+  def read_cell(row, idx)
+    cell = row.at(idx)
+    case cell
+    when Float, Integer, Fixnum, Bignum 
+      value_type = :float
+      value = cell.to_f
+    when String, TrueClass, FalseClass
+      value_type = :string
+      value = cell.to_s
+    else
+      value_type = cell.class.to_s.downcase.to_sym
+      value = nil
+    end # case
+    return value_type, value
+  end
+  private :read_cell
+  
   #TODO: testing only
   #  def inject_null_characters(str)
   #    if str.class != String

data/lib/roo/excelx.rb

@@ -1,6 +1,4 @@
-
-require 'rubygems'
-require 'rexml/document'
+require 'xml'
 require 'fileutils'
 require 'zip/zipfilesystem'
 require 'date'
@@ -102,26 +100,27 @@ class Excelx < GenericSpreadsheet
       @file_nr = @@nr
       extract_content(@filename)
       file = File.new(File.join(@tmpdir, @file_nr.to_s+"_roo_workbook.xml"))
-      @workbook_doc = REXML::Document.new file
+      @workbook_doc = XML::Parser.io(file).parse
       file.close
       @shared_table = []
       if File.exist?(File.join(@tmpdir, @file_nr.to_s+'_roo_sharedStrings.xml'))
         file = File.new(File.join(@tmpdir, @file_nr.to_s+'_roo_sharedStrings.xml'))
-        @sharedstring_doc = REXML::Document.new file
+        @sharedstring_doc = XML::Parser.io(file).parse
         file.close
         read_shared_strings(@sharedstring_doc)
       end
       @styles_table = []
+      @style_definitions = Array.new { |h,k| h[k] = {} }
       if File.exist?(File.join(@tmpdir, @file_nr.to_s+'_roo_styles.xml'))
         file = File.new(File.join(@tmpdir, @file_nr.to_s+'_roo_styles.xml'))
-        @styles_doc = REXML::Document.new file
+        @styles_doc = XML::Parser.io(file).parse
         file.close
         read_styles(@styles_doc)
       end
       @sheet_doc = []
       @sheet_files.each_with_index do |item, i|
         file = File.new(item)
-        @sheet_doc[i] = REXML::Document.new file
+        @sheet_doc[i] = XML::Parser.io(file).parse
         file.close
       end
     ensure
@@ -163,7 +162,6 @@ class Excelx < GenericSpreadsheet
       yyyy,mm,dd = date_part.split('-')
       hh,mi,ss = time_part.split(':')
       return DateTime.civil(yyyy.to_i,mm.to_i,dd.to_i,hh.to_i,mi.to_i,ss.to_i)
-      
     end
     @cell[sheet][[row,col]]
   end
@@ -189,6 +187,33 @@ class Excelx < GenericSpreadsheet
     row,col = normalize(row,col)
     formula(row,col) != nil
   end
+  
+  class Font
+    attr_accessor :bold, :italic, :underline
+    
+    def bold?
+      @bold == true
+    end
+        
+    def italic? 
+     @italic == true
+    end
+    
+    def underline?
+      @underline == true
+    end    
+  end
+  
+  # Given a cell, return the cell's style
+  def font(row, col, sheet=nil)
+   sheet = @default_sheet unless sheet
+   read_cells(sheet) unless @cells_read[sheet]
+   row,col = normalize(row,col)
+   s_attribute = @s_attribute[sheet][[row,col]]
+   s_attribute ||= 0
+   s_attribute = s_attribute.to_i
+   @style_definitions[s_attribute]
+  end 
 
   # set a cell to a certain value
   # (this will not be saved back to the spreadsheet file!)
@@ -260,18 +285,11 @@ class Excelx < GenericSpreadsheet
   # returns an array of sheet names in the spreadsheet
   def sheets
     return_sheets = []
-    @workbook_doc.each_element do |workbook|
-      workbook.each_element do |el|
-        if el.name == "sheets"
-          el.each_element do |sheet|
-            return_sheets << sheet.attributes['name']
-          end
-        end
-      end
+    @workbook_doc.find("//*[local-name()='sheet']").each do |sheet|
+      return_sheets << sheet.attributes.to_h['name']
     end
     return_sheets
   end
-
   # shows the internal representation of all cells
   # for debugging purposes
   def to_s(sheet=nil)
@@ -376,82 +394,62 @@ class Excelx < GenericSpreadsheet
     raise ArgumentError, "Error: sheet '#{sheet||'nil'}' not valid" if @default_sheet == nil and sheet==nil
     raise RangeError unless self.sheets.include? sheet
     n = self.sheets.index(sheet)
-    @sheet_doc[n].each_element do |worksheet|
-      worksheet.each_element do |elem|
-        if elem.name == 'sheetData'
-          elem.each_element do |sheetdata|
-            if sheetdata.name == 'row'
-              sheetdata.each_element do |row|
-                if row.name == 'c'
-                  if row.attributes['t'] == 's'
-                    tmp_type = :shared
-                  else
-                    s_attribute = row.attributes['s']
-                    format = attribute2format(s_attribute)
-                    tmp_type = format2type(format)
-                  end
-                  formula = nil
-                  row.each_element do |cell|
-#                    puts "cell.name: #{cell.name}" if cell.text.include? "22606.5120"
-#                    puts "cell.text: #{cell.text}" if cell.text.include? "22606.5120"
-                    if cell.name == 'f'
-                      formula = cell.text
-                    end
-                    if cell.name == 'v'
-                      #puts "tmp_type: #{tmp_type}" if cell.text.include? "22606.5120"
-                      #puts cell.name
-                      if tmp_type == :time or tmp_type == :datetime #2008-07-26
-                        #p cell.text
-                       # p cell.text.to_f if cell.text.include? "22606.5120"
-                        if cell.text.to_f >= 1.0 # 2008-07-26
-                        #  puts ">= 1.0" if cell.text.include? "22606.5120"
-                         # puts "cell.text.to_f: #{cell.text.to_f}" if cell.text.include? "22606.5120"
-                          #puts "cell.text.to_f.floor: #{cell.text.to_f.floor}" if cell.text.include? "22606.5120"
-                          if (cell.text.to_f - cell.text.to_f.floor).abs > 0.000001 #TODO: 
-                           # puts "abs ist groesser"  if cell.text.include? "22606.5120"
-                            # @cell[sheet][key] = DateTime.parse(tr.attributes['date-value'])
-                            tmp_type = :datetime
-                            
-                          else
-                            #puts ":date"
-                            tmp_type = :date # 2008-07-26
-                          end
-                        else
-                          #puts "<1.0"
-                        end # 2008-07-26
-                      end # 2008-07-26
-                      excelx_type = [:numeric_or_formula,format]
-                      excelx_value = cell.text
-                      if tmp_type == :shared
-                        vt = :string
-                        str_v = @shared_table[cell.text.to_i]
-                        excelx_type = :string
-                      elsif tmp_type == :date
-                        vt = :date
-                        v = cell.text
-                      elsif tmp_type == :time
-                        vt = :time
-                        v = cell.text
-                      elsif tmp_type == :datetime
-                        vt = :datetime
-                        v = cell.text
-                      elsif tmp_type == :formula
-                        vt = :formula
-                        v = cell.text.to_f #TODO: !!!!
-                      else
-                        vt = :float
-                        v = cell.text
-                      end
-                      #puts "vt: #{vt}" if cell.text.include? "22606.5120"
-                      x,y = split_coordinate(row.attributes['r'])
-                      tr=nil #TODO: ???s
-                      set_cell_values(sheet,x,y,0,v,vt,formula,tr,str_v,excelx_type,excelx_value,s_attribute)
-                    end
-                  end
-                end
+    @sheet_doc[n].find("//*[local-name()='c']").each do |c|
+       s_attribute = c.attributes.to_h['s'].to_i   # should be here
+       if (c.attributes.to_h['t'] == 's')
+         tmp_type = :shared
+       elsif (c.attributes.to_h['t'] == 'b')
+         tmp_type = :boolean
+       else
+       #  s_attribute = c.attributes.to_h['s'].to_i     # was here
+         format = attribute2format(s_attribute)
+         tmp_type = format2type(format)
+       end
+      formula = nil
+      c.each_element do |cell|
+        if cell.name == 'f'
+          formula = cell.content
+        end
+        if cell.name == 'v'
+          if tmp_type == :time or tmp_type == :datetime
+            if cell.content.to_f >= 1.0 
+              if (cell.content.to_f - cell.content.to_f.floor).abs > 0.000001 
+                tmp_type = :datetime 
+              else
+                tmp_type = :date
               end
-            end
+            else
+            end 
+          end
+          excelx_type = [:numeric_or_formula,format]
+          excelx_value = cell.content
+          if tmp_type == :shared
+            vt = :string
+            str_v = @shared_table[cell.content.to_i]
+            excelx_type = :string
+          elsif tmp_type == :boolean
+            vt = :boolean
+            cell.content.to_i == 1 ? v = 'TRUE' : v = 'FALSE'
+          elsif tmp_type == :date
+            vt = :date
+            v = cell.content
+          elsif tmp_type == :time
+            vt = :time
+            v = cell.content
+          elsif tmp_type == :datetime
+            vt = :datetime
+            v = cell.content
+          elsif tmp_type == :formula
+            vt = :formula
+            v = cell.content.to_f #TODO: !!!!
+          else
+            vt = :float
+            v = cell.content
           end
+          #puts "vt: #{vt}" if cell.text.include? "22606.5120"
+          x,y = split_coordinate(c.attributes.to_h['r'])
+          tr=nil #TODO: ???s
+          set_cell_values(sheet,x,y,0,v,vt,formula,tr,str_v,excelx_type,excelx_value,s_attribute)
         end
       end
     end
@@ -467,17 +465,9 @@ class Excelx < GenericSpreadsheet
   def check_default_sheet
     sheet_found = false
     raise ArgumentError, "Error: default_sheet not set" if @default_sheet == nil
-    @workbook_doc.each_element do |workbook|
-      workbook.each_element do |el|
-        if el.name == "sheets"
-          el.each_element do |sheet|
-            if @default_sheet == sheet.attributes['name']
-              sheet_found = true
-            end
-          end
-        end
-      end
-    end
+    
+    sheet_found = true if sheets.include?(@default_sheet)
+    
     if ! sheet_found
       raise RangeError, "sheet '#{@default_sheet}' not found"
     end
@@ -537,18 +527,21 @@ class Excelx < GenericSpreadsheet
 
   # read the shared strings xml document
   def read_shared_strings(doc)
-    doc.each_element do |sst|
-      if sst.name == 'sst'
-        sst.each_element do |si|
-          if si.name == 'si'
-            si.each_element do |elem|
-              if elem.name == 't'
-                @shared_table << elem.text
-              end
+    doc.find("//*[local-name()='si']").each do |si|
+      shared_table_entry = ''
+      si.each_element do |elem|
+        if (elem.name == 'r')
+          elem.each_element do |r_elem|
+            if (r_elem.name == 't')
+              shared_table_entry << r_elem.content
             end
           end
         end
+        if (elem.name == 't')
+          shared_table_entry = elem.content
+        end
       end
+      @shared_table << shared_table_entry
     end
   end
 
@@ -556,28 +549,40 @@ class Excelx < GenericSpreadsheet
   def read_styles(doc)
     @numFmts = []
     @cellXfs = []
-    doc.each_element do |e1|
-      if e1.name == "styleSheet"
-        e1.each_element do |e2|
-          if e2.name == "numFmts"
-            e2.each_element do |e3|
-              if e3.name == 'numFmt'
-                numFmtId = e3.attributes['numFmtId']
-                formatCode = e3.attributes['formatCode']
-                @numFmts << [numFmtId, formatCode]
-              end
-            end
-          elsif e2.name == "cellXfs"
-            e2.each_element do |e3|
-              if e3.name == 'xf'
-                numFmtId = e3.attributes['numFmtId'] 
-                @cellXfs << [numFmtId]
+    fonts = []
+    
+    doc.find("//*[local-name()='numFmt']").each do |numFmt|
+      numFmtId = numFmt.attributes.to_h['numFmtId']
+      formatCode = numFmt.attributes.to_h['formatCode']
+      @numFmts << [numFmtId, formatCode]
+    end
+    doc.find("//*[local-name()='fonts']").each do |fonts_el|
+      fonts_el.each_element do |font_el|
+        if font_el.name == 'font'
+          font = Excelx::Font.new
+          font_el.each_element do |font_sub_el|
+            case font_sub_el.name
+              when 'b'
+                font.bold = true
+              when 'i'
+                font.italic = true
+              when 'u'
+                font.underline = true
               end
-            end
           end
+          fonts << font
         end
       end
     end
+    
+    doc.find("//*[local-name()='cellXfs']").each do |xfs|
+        xfs.each do |xf|
+          numFmtId = xf.attributes.to_h['numFmtId']
+          @cellXfs << [numFmtId]
+          fontId = xf.attributes.to_h['fontId'].to_i
+          @style_definitions << fonts[fontId]
+        end
+    end
   end
 
   # convert internal excelx attribute to a format