roo 1.10.1 → 1.10.2

data/lib/roo/csv.rb

@@ -1,5 +1,6 @@
 require 'rubygems'
 require 'csv'
+require 'time'
 
 # The Csv class can read csv files (must be separated with commas) which then
 # can be handled like spreadsheets. This means you can access cells like A5
@@ -7,10 +8,9 @@ require 'csv'
 # The Csv class provides only string objects. If you want conversions to other
 # types you have to do it yourself.
 
-class Csv < GenericSpreadsheet
+class Roo::Csv < Roo::GenericSpreadsheet
   def initialize(filename, packed=nil, file_warning=:error, tmpdir=nil)
     @filename = filename
-    super()
     @cell = Hash.new
     @cell_type = Hash.new
     @cells_read = Hash.new
@@ -27,14 +27,14 @@ class Csv < GenericSpreadsheet
   end
 
   def cell(row, col, sheet=nil)
-    sheet = @default_sheet unless sheet
+    sheet ||= @default_sheet
     read_cells(sheet) unless @cells_read[sheet]
     row,col = normalize(row,col)
     @cell[[row,col]]
   end
 
   def celltype(row, col, sheet=nil)
-    sheet = @default_sheet unless sheet
+    sheet ||= @default_sheet
     read_cells(sheet) unless @cells_read[sheet]
     row,col = normalize(row,col)
     @cell_type[[row,col]]
@@ -46,17 +46,19 @@ class Csv < GenericSpreadsheet
 
   private
 
+  TYPE_MAP = {
+    String => :string,
+    Float => :float,
+    Date => :date,
+    DateTime => :datetime,
+  }
+
   def celltype_class(value)
-    return {String => :string,
-      Float => :float,
-      Date => :date,
-      DateTime => :datetime,
-    }[value.class]
-    raise "unknown type for #{value.inspect}"
+    TYPE_MAP[value.class]
   end
 
   def read_cells(sheet=nil)
-    sheet = @default_sheet unless sheet
+    sheet ||= @default_sheet
     @cell_type = {} unless @cell_type
     @cell = {} unless @cell
     @first_row[sheet] = 1

data/lib/roo/excel.rb

@@ -1,127 +1,35 @@
 require 'rubygems'
 require 'spreadsheet'
+require 'iconv'
 #require 'lib/roo/generic_spreadsheet'
 #require 'parseexcel'
-CHARGUESS = begin
-  require 'charguess'
-  true
-rescue LoadError => e
-  false
-end
-
-# The Spreadsheet library has a bug in handling Excel 
-# base dates so if the file is a 1904 base date then 
-# dates are off by a day. 1900 base dates work fine
-module Spreadsheet
-  module Excel
-    class Row < Spreadsheet::Row
-      def _date data # :nodoc:
-        return data if data.is_a?(Date)
-        date = @worksheet.date_base + data.to_i
-        if LEAP_ERROR > @worksheet.date_base
-          date -= 1
-        end
-        date
-      end
-      public :_datetime
-    end
-  end
-end
-
-#=====================================================================
-# TODO:
-# redefinition of this method, the method in the spreadsheet gem has a bug
-# redefinition can be removed, if spreadsheet does it in the correct way
-module Spreadsheet
-  module Excel
-    class Row < Spreadsheet::Row
-      def _datetime data # :nodoc:
-        return data if data.is_a?(DateTime)
-        base = @worksheet.date_base
-        date = base + data.to_f
-        hour = (data % 1) * 24
-        min  = (hour % 1) * 60
-        sec  = ((min % 1) * 60).round
-        min = min.floor
-        hour = hour.floor
-        if sec > 59
-          sec = 0
-          min += 1
-        end
-        if min > 59
-          min = 0
-          hour += 1
-        end
-        if hour > 23
-          hour = 0
-          date += 1
-        end
-        if LEAP_ERROR > base
-          date -= 1
-        end
-        DateTime.new(date.year, date.month, date.day, hour, min, sec)
-      end
-    end
-  end
-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
+CHARGUESS =
+  begin
+    require 'charguess'
+    true
+  rescue LoadError
+    false
   end
 
-end
-
 # Class for handling Excel-Spreadsheets
-class Excel < GenericSpreadsheet 
-
-  EXCEL_NO_FORMULAS = 'Formulas are not supported for excel spreadsheets.'
+class Roo::Excel < Roo::GenericSpreadsheet
 
   # Creates a new Excel spreadsheet object.
   # Parameter packed: :zip - File is a zip-file
   def initialize(filename, packed = nil, file_warning = :error)
-    super()
-    @file_warning = file_warning
-    file_type_check(filename,'.xls','an Excel',packed)
-    @tmpdir = GenericSpreadsheet.next_tmpdir
-    @tmpdir = File.join(ENV['ROO_TMP'], @tmpdir) if ENV['ROO_TMP'] 
-    unless File.exists?(@tmpdir)
-      FileUtils::mkdir(@tmpdir)
-    end
-    filename = open_from_uri(filename) if filename[0,7] == "http://"
-    filename = open_from_stream(filename[7..-1]) if filename[0,7] == "stream:"
-    filename = unzip(filename) if packed and packed == :zip
-    @filename = filename
-    unless File.file?(@filename)
-      FileUtils::rm_r(@tmpdir)
-      raise IOError, "file #{@filename} does not exist"
-    end
-    begin
+    file_type_check(filename,'.xls','an Excel', file_warning, packed)
+    make_tmpdir do |tmpdir|
+      filename = open_from_uri(filename, tmpdir) if uri?(filename)
+      filename = open_from_stream(filename[7..-1], tmpdir) if filename[0,7] == "stream:"
+      filename = unzip(filename, tmpdir) if packed == :zip
+
+      @filename = filename
+      unless File.file?(@filename)
+        raise IOError, "file #{@filename} does not exist"
+      end
       @workbook = Spreadsheet.open(filename)
-    rescue Ole::Storage::FormatError
-      FileUtils::rm_r(@tmpdir)
-      raise # nach aussen weiterhin sichtbar
     end
     @default_sheet = self.sheets.first
-    FileUtils::rm_r(@tmpdir)
     @cell = Hash.new
     @cell_type = Hash.new
     @formula = Hash.new
@@ -134,6 +42,10 @@ class Excel < GenericSpreadsheet
     @fonts = Hash.new
   end
 
+  def encoding=(codepage)
+    @workbook.encoding = codepage
+  end
+
   # returns an array of sheet names in the spreadsheet
   def sheets
     @workbook.worksheets.collect {|worksheet| normalize_string(worksheet.name)}
@@ -141,8 +53,9 @@ class Excel < GenericSpreadsheet
 
   # returns the content of a cell. The upper left corner is (1,1) or ('A',1)
   def cell(row,col,sheet=nil)
-    sheet = @default_sheet unless sheet
-    raise ArgumentError unless sheet
+    sheet ||= @default_sheet
+    validate_sheet!(sheet)
+
     read_cells(sheet) unless @cells_read[sheet]
     raise "should be read" unless @cells_read[sheet]
     row,col = normalize(row,col)
@@ -170,18 +83,14 @@ class Excel < GenericSpreadsheet
   # * :time
   # * :datetime
   def celltype(row,col,sheet=nil)
-    sheet = @default_sheet unless sheet
+    sheet ||= @default_sheet
     read_cells(sheet) unless @cells_read[sheet]
     row,col = normalize(row,col)
     begin
       if @formula[sheet] and @formula[sheet][[row,col]]
-        return :formula
-      else
-        if @cell_type[sheet] and @cell_type[sheet][[row,col]]
-          return @cell_type[sheet][[row,col]]
-        else
-          return nil
-        end
+        :formula
+      elsif @cell_type[sheet]
+        @cell_type[sheet][[row,col]]
       end
     rescue
       puts "Error in sheet #{sheet}, row #{row}, col #{col}"
@@ -206,36 +115,20 @@ class Excel < GenericSpreadsheet
 
   # Given a cell, return the cell's font
   def font(row, col, sheet=nil)
-    sheet = @default_sheet unless sheet
+    sheet ||= @default_sheet
     read_cells(sheet) unless @cells_read[sheet]
     row,col = normalize(row,col)
     @fonts[sheet][[row,col]]
-  end 
-  
+  end
+
   # shows the internal representation of all cells
   # mainly for debugging purposes
   def to_s(sheet=nil)
-    sheet = @default_sheet unless sheet
+    sheet ||= @default_sheet
     read_cells(sheet) unless @cells_read[sheet]
     @cell[sheet].inspect
   end
 
-  # returns the row,col values of the labelled cell
-  # (nil,nil) if label is not defined
-  # sheet parameter is not really needed because label names are global
-  # to the whole spreadsheet
-  def label(labelname,sheet=nil)
-    sheet = @default_sheet unless sheet
-    read_cells(sheet) unless @cells_read[sheet]
-    if @labels.has_key? labelname
-      return @labels[labelname][1].to_i,
-        GenericSpreadsheet.letter_to_number(@labels[labelname][2]),
-        @labels[labelname][0]
-    else
-      return nil,nil,nil
-    end
-  end
-
   private
 
   # converts name of a sheet to index (0,1,2,..)
@@ -249,26 +142,6 @@ class Excel < GenericSpreadsheet
     raise StandardError, "sheet '#{name}' not found"
   end
 
-  def empty_row?(row)
-    content = false
-    row.compact.each {|elem|
-      if elem != ''
-        content = true
-      end
-    }
-    ! content
-  end
-
-  def empty_column?(col)
-    content = false
-    col.compact.each {|elem|
-      if elem != ''
-        content = true
-      end
-    }
-    ! content
-  end
-  
   def normalize_string(value)
     value = every_second_null?(value) ? remove_every_second_null(value) : value
     if CHARGUESS && encoding = CharGuess::guess(value)
@@ -277,18 +150,17 @@ class Excel < GenericSpreadsheet
       platform_specific_iconv(value)
     end
   end
-  
+
   def platform_specific_iconv(value)
-    case RUBY_PLATFORM.downcase
-    when /darwin/
-      result = Iconv.new('utf-8','utf-8').iconv(value)
-    when /solaris/
-      result = Iconv.new('utf-8','utf-8').iconv(value)
-    when /mswin32/
-      result = Iconv.new('utf-8','iso-8859-1').iconv(value)
-    else
-      result = value
-    end # case
+    result =
+      case RUBY_PLATFORM.downcase
+      when /darwin|solaris/
+        Iconv.new('utf-8','utf-8').iconv(value)
+      when /mswin32/
+        Iconv.new('utf-8','iso-8859-1').iconv(value)
+      else
+        value
+      end
     if every_second_null?(result)
       result = remove_every_second_null(result)
     end
@@ -299,10 +171,8 @@ class Excel < GenericSpreadsheet
     result = true
     return false if str.length < 2
     0.upto(str.length/2-1) do |i|
-      c = str[i*2,1]
-      n = str[i*2+1,1]
-      if n != "\000"
-        result = false 
+      if str[i*2+1,1] != "\000"
+        result = false
         break
       end
     end
@@ -319,62 +189,81 @@ class Excel < GenericSpreadsheet
   end
 
   # helper function to set the internal representation of cells
-  def set_cell_values(sheet,row,col,i,v,vt,formula,tr,font)
+  def set_cell_values(sheet,row,col,i,v,value_type,formula,tr,font)
     #key = "#{y},#{x+i}"
     key = [row,col+i]
     @cell_type[sheet] = {} unless @cell_type[sheet]
-    @cell_type[sheet][key] = vt 
+    @cell_type[sheet][key] = value_type
     @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 
-    when :float
-      @cell[sheet][key] = v.to_f
-    when :string
-      @cell[sheet][key] = v
-    when :date
-      @cell[sheet][key] = v 
-    when :datetime
-      @cell[sheet][key] = DateTime.new(v.year,v.month,v.day,v.hour,v.min,v.sec)
-    when :percentage
-      @cell[sheet][key] = v.to_f
-    when :time
-      @cell[sheet][key] = v 
-    else
-      @cell[sheet][key] = v
+
+    @cell[sheet][key] =
+      case value_type
+      when :float
+        v.to_f
+      when :string
+        v
+      when :date
+        v
+      when :datetime
+        @cell[sheet][key] = DateTime.new(v.year,v.month,v.day,v.hour,v.min,v.sec)
+      when :percentage
+        v.to_f
+      when :time
+        v
+      else
+        v
+      end
+  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
+      weight == 700
+    end
+
+    def italic?
+      italic
+    end
+
+    def underline?
+      underline != :none
     end
   end
 
   # read all cells in the selected sheet
   def read_cells(sheet=nil)
-    sheet = @default_sheet unless sheet
-    raise ArgumentError, "Error: sheet '#{sheet||'nil'}' not valid" if @default_sheet == nil and sheet==nil
-    raise RangeError unless self.sheets.include? sheet
-    
+    sheet ||= @default_sheet
+    validate_sheet!(sheet)
+
     if @cells_read[sheet]
       raise "sheet #{sheet} already read"
     end
-    
+
     worksheet = @workbook.worksheet(sheet_no(sheet))
     row_index=1
-    worksheet.each(0) do |row| 
+    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 && cell.value.nil? # skip empty formula cells
-        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
+        value_type, v =
+          if date_or_time?(row, cell_index)
+            read_cell_date_or_time(row, cell_index)
+          else
+            read_cell(row, cell_index)
+          end
         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)
+        set_cell_values(sheet,row_index,col_index,0,v,value_type,formula,tr,font)
       end #row
       row_index += 1
     end # worksheet
@@ -388,8 +277,8 @@ class Excel < GenericSpreadsheet
     cell = cell.value if cell.class == Spreadsheet::Formula
     cell
   end
-    
-  # Test the cell to see if it's a valid date/time. 
+
+  # 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?
@@ -397,11 +286,11 @@ class Excel < GenericSpreadsheet
       true if Float(cell) > 0 rescue false
     else
       false
-    end  
+    end
   end
   private :date_or_time?
-  
-  # Read the date-time cell and convert to, 
+
+  # Read the date-time cell and convert to,
   # the date-time values for Roo
   def read_cell_date_or_time(row, idx)
     cell = read_cell_content(row, idx)
@@ -418,10 +307,10 @@ class Excel < GenericSpreadsheet
       value = h*3600+m*60+s
     else
       if row.at(idx).class == Spreadsheet::Formula
-        datetime = row._datetime(cell)
+        datetime = row.send(:_datetime, cell)
       else
         datetime = row.datetime(idx)
-      end    
+      end
       if datetime.hour != 0 or
           datetime.min != 0 or
           datetime.sec != 0
@@ -430,23 +319,23 @@ class Excel < GenericSpreadsheet
       else
         value_type = :date
         if row.at(idx).class == Spreadsheet::Formula
-          value = row._date(cell)
+          value = row.send(:_date, cell)
         else
           value = row.date(idx)
-        end    
+        end
         value = sprintf("%04d-%02d-%02d",value.year,value.month,value.day)
       end
-    end  
+    end
     return value_type, value
   end
   private :read_cell_date_or_time
-  
-  # Read the cell and based on the class, 
+
+  # Read the cell and based on the class,
   # return the values for Roo
   def read_cell(row, idx)
     cell = read_cell_content(row, idx)
     case cell
-    when Float, Integer, Fixnum, Bignum 
+    when Float, Integer, Fixnum, Bignum
       value_type = :float
       value = cell.to_f
     when String, TrueClass, FalseClass
@@ -462,7 +351,7 @@ class Excel < GenericSpreadsheet
 
   def wait_for_version_080
     if Spreadsheet::VERSION<='0.8.0'
-      raise EXCEL_NO_FORMULAS+
+      raise 'Formulas are not supported for excel spreadsheets.' +
         " We have to wait for the 0.8.0 version of the Spreadsheet gem (currently used version is #{Spreadsheet::VERSION})"
     else
       raise 'Thomas should implement formulas from Spreadsheet gem'