roo 1.13.2 → 2.10.1

data/lib/roo/excel.rb

@@ -1,355 +0,0 @@
-require 'spreadsheet'
-
-# Class for handling Excel-Spreadsheets
-class Roo::Excel < Roo::Base
-  FORMULAS_MESSAGE = 'the spreadsheet gem does not support forumulas, so roo can not.'
-  CHARGUESS =
-    begin
-      require 'charguess'
-      true
-    rescue LoadError
-      false
-    end
-
-  attr_reader :workbook
-
-  # Creates a new Excel spreadsheet object.
-  # Parameter packed: :zip - File is a zip-file
-  def initialize(filename, options = {}, deprecated_file_warning = :error)
-    if Hash === options
-      packed = options[:packed]
-      file_warning = options[:file_warning] || :error
-      mode = options[:mode] || "rb+"
-    else
-      warn 'Supplying `packed` or `file_warning` as separate arguments to `Roo::Excel.new` is deprecated. Use an options hash instead.'
-      packed = options
-      mode = "rb+"
-      file_warning = deprecated_file_warning
-    end
-
-    file_type_check(filename,'.xls','an Excel', file_warning, packed)
-    make_tmpdir do |tmpdir|
-      filename = download_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, mode)
-    end
-    super(filename, options)
-    @formula = Hash.new
-    @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)}
-  end
-
-  # this method lets you find the worksheet with the most data
-  def longest_sheet
-    sheet(@workbook.worksheets.inject {|m,o|
-      o.row_count > m.row_count ? o : m
-    }.name)
-  end
-
-  # 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
-    validate_sheet!(sheet)
-
-    read_cells(sheet)
-    raise "should be read" unless @cells_read[sheet]
-    row,col = normalize(row,col)
-    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
-    if celltype(row,col,sheet) == :string
-      return platform_specific_encoding(@cell[sheet][[row,col]])
-    else
-      if @cell[sheet] and @cell[sheet][[row,col]]
-        return @cell[sheet][[row,col]]
-      else
-        return nil
-      end
-    end
-  end
-
-  # returns the type of a cell:
-  # * :float
-  # * :string,
-  # * :date
-  # * :percentage
-  # * :formula
-  # * :time
-  # * :datetime
-  def celltype(row,col,sheet=nil)
-    sheet ||= @default_sheet
-    read_cells(sheet)
-    row,col = normalize(row,col)
-    begin
-      if @formula[sheet] and @formula[sheet][[row,col]]
-        :formula
-      elsif @cell_type[sheet]
-        @cell_type[sheet][[row,col]]
-      end
-    rescue
-      puts "Error in sheet #{sheet}, row #{row}, col #{col}"
-      raise
-    end
-  end
-
-  # returns NO formula in excel spreadsheets
-  def formula(row,col,sheet=nil)
-    raise NotImplementedError, FORMULAS_MESSAGE
-  end
-  alias_method :formula?, :formula
-
-  # returns NO formulas in excel spreadsheets
-  def formulas(sheet=nil)
-    raise NotImplementedError, FORMULAS_MESSAGE
-  end
-
-  # Given a cell, return the cell's font
-  def font(row, col, sheet=nil)
-    sheet ||= @default_sheet
-    read_cells(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)
-    sheet ||= @default_sheet
-    read_cells(sheet)
-    @cell[sheet].inspect
-  end
-
-  private
-
-  # converts name of a sheet to index (0,1,2,..)
-  def sheet_no(name)
-    return name-1 if name.kind_of?(Fixnum)
-    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
-
-  def normalize_string(value)
-    value = every_second_null?(value) ? remove_every_second_null(value) : value
-    if CHARGUESS && encoding = CharGuess::guess(value)
-      encoding.encode Encoding::UTF_8
-    else
-      platform_specific_encoding(value)
-    end
-  end
-
-  def platform_specific_encoding(value)
-    result =
-      case RUBY_PLATFORM.downcase
-      when /darwin|solaris/
-        value.encode Encoding::UTF_8
-      when /mswin32/
-        value.encode Encoding::ISO_8859_1
-      else
-        value
-      end
-    if every_second_null?(result)
-      result = remove_every_second_null(result)
-    end
-    result
-  end
-
-  def every_second_null?(str)
-    result = true
-    return false if str.length < 2
-    0.upto(str.length/2-1) do |i|
-      if str[i*2+1,1] != "\000"
-        result = false
-        break
-      end
-    end
-    result
-  end
-
-  def remove_every_second_null(str)
-    result = ''
-    0.upto(str.length/2-1) do |i|
-      c = str[i*2,1]
-      result += c
-    end
-    result
-  end
-
-  # helper function to set the internal representation of cells
-  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] = 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
-
-    @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
-    validate_sheet!(sheet)
-    return if @cells_read[sheet]
-
-    worksheet = @workbook.worksheet(sheet_no(sheet))
-    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 && cell.value.nil? # skip empty formula cells
-        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,value_type,formula,tr,font)
-      end #row
-      row_index += 1
-    end # worksheet
-    @cells_read[sheet] = true
-  end
-
-  # Get the contents of a cell, accounting for the
-  # way formula stores the value
-  def read_cell_content(row, idx)
-    cell = row.at(idx)
-    cell = row[idx] if row[idx].class == Spreadsheet::Link
-    cell = cell.value if cell.class == Spreadsheet::Formula
-    cell
-  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 = read_cell_content(row, idx)
-      true if Float(cell) > 0 rescue false
-    else
-      false
-    end
-  end
-
-  # 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)
-    cell = cell.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
-      if row.at(idx).class == Spreadsheet::Formula
-        datetime = row.send(:_datetime, cell)
-      else
-        datetime = row.datetime(idx)
-      end
-      if datetime.hour != 0 or
-          datetime.min != 0 or
-          datetime.sec != 0
-        value_type = :datetime
-        value = datetime
-      else
-        value_type = :date
-        if row.at(idx).class == Spreadsheet::Formula
-          value = row.send(:_date, cell)
-        else
-          value = row.date(idx)
-        end
-        value = sprintf("%04d-%02d-%02d",value.year,value.month,value.day)
-      end
-    end
-    return value_type, value
-  end
-
-  # 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
-      value_type = :float
-      value = cell.to_f
-    when Spreadsheet::Link
-      value_type = :link
-      value = cell
-    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
-
-end

data/lib/roo/excel2003xml.rb

@@ -1,300 +0,0 @@
-require 'date'
-require 'base64'
-require 'nokogiri'
-
-class Roo::Excel2003XML < Roo::Base
-
-  # initialization and opening of a spreadsheet file
-  # values for packed: :zip
-  def initialize(filename, options={}, deprecated_file_warning=:error)
-    if Hash === options
-      packed = options[:packed]
-      file_warning = options[:file_warning] || :error
-    else
-      warn 'Supplying `packed` or `file_warning` as separate arguments to `Roo::Excel2003XML.new` is deprecated. Use an options hash instead.'
-      packed = options
-      file_warning = deprecated_file_warning
-    end
-
-    make_tmpdir do |tmpdir|
-      filename = download_uri(filename, tmpdir) if uri?(filename)
-      filename = unzip(filename, tmpdir) if packed == :zip
-
-      file_type_check(filename,'.xml','an Excel 2003 XML', file_warning)
-      @filename = filename
-      unless File.file?(@filename)
-        raise IOError, "file #{@filename} does not exist"
-      end
-      @doc = load_xml(@filename)
-    end
-    super(filename, options)
-    @formula = Hash.new
-    @style = Hash.new
-    @style_defaults = Hash.new { |h,k| h[k] = [] }
-    @style_definitions = Hash.new
-    read_styles
-  end
-
-  # 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 the first line and first row.
-  def cell(row, col, sheet=nil)
-    sheet ||= @default_sheet
-    read_cells(sheet)
-    row,col = normalize(row,col)
-    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[sheet][[row,col]]
-  end
-
-  # Returns the formula at (row,col).
-  # Returns nil if there is no formula.
-  # The method #formula? checks if there is a formula.
-  def formula(row,col,sheet=nil)
-    sheet ||= @default_sheet
-    read_cells(sheet)
-    row,col = normalize(row,col)
-    @formula[sheet][[row,col]] && @formula[sheet][[row,col]]["oooc:".length..-1]
-  end
-  alias_method :formula?, :formula
-
-  class Font
-    attr_accessor :bold, :italic, :underline
-
-    def bold?
-      @bold == '1'
-    end
-
-    def italic?
-      @italic == '1'
-    end
-
-    def underline?
-      @underline != nil
-    end
-  end
-
-  # Given a cell, return the cell's style
-  def font(row, col, sheet=nil)
-    sheet ||= @default_sheet
-    read_cells(sheet)
-    row,col = normalize(row,col)
-    style_name = @style[sheet][[row,col]] || @style_defaults[sheet][col - 1] || 'Default'
-    @style_definitions[style_name]
-  end
-
-  # returns the type of a cell:
-  # * :float
-  # * :string
-  # * :date
-  # * :percentage
-  # * :formula
-  # * :time
-  # * :datetime
-  def celltype(row,col,sheet=nil)
-    sheet ||= @default_sheet
-    read_cells(sheet)
-    row,col = normalize(row,col)
-    if @formula[sheet][[row,col]]
-      return :formula
-    else
-      @cell_type[sheet][[row,col]]
-    end
-  end
-
-  def sheets
-    @doc.xpath("/ss:Workbook/ss:Worksheet").map do |sheet|
-      sheet['ss:Name']
-    end
-  end
-
-  # version of the openoffice document
-  # at 2007 this is always "1.0"
-  def officeversion
-    oo_version
-    @officeversion
-  end
-
-  # shows the internal representation of all cells
-  # mainly for debugging purposes
-  def to_s(sheet=nil)
-    sheet ||= @default_sheet
-    read_cells(sheet)
-    @cell[sheet].inspect
-  end
-
-  # save spreadsheet
-  def save #:nodoc:
-    42
-  end
-
-  # returns each formula in the selected sheet as an array of elements
-  # [row, col, formula]
-  def formulas(sheet=nil)
-    theformulas = Array.new
-    sheet ||= @default_sheet
-    read_cells(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
-      }
-    }
-    theformulas
-  end
-
-  private
-
-  # read the version of the OO-Version
-  def oo_version
-    @doc.find("//*[local-name()='document-content']").each do |office|
-      @officeversion = office['version']
-    end
-  end
-
-  # helper function to set the internal representation of cells
-  def set_cell_values(sheet,x,y,i,v,value_type,formula,table_cell,str_v,style_name)
-    key = [y,x+i]
-    @cell_type[sheet] = {} unless @cell_type[sheet]
-    @cell_type[sheet][key] = value_type
-    @formula[sheet] = {} unless @formula[sheet]
-    @formula[sheet][key] = formula  if formula
-    @cell[sheet]    = {} unless @cell[sheet]
-    @style[sheet] = {} unless @style[sheet]
-    @style[sheet][key] = style_name
-    @cell[sheet][key] =
-      case @cell_type[sheet][key]
-      when :float
-        v.to_f
-      when :string
-        str_v
-      when :datetime
-        DateTime.parse(v)
-      when :percentage
-        v.to_f
-      # when :time
-      #   hms = v.split(':')
-      #   hms[0].to_i*3600 + hms[1].to_i*60 + hms[2].to_i
-      else
-        v
-      end
-  end
-
-  # read all cells in the selected sheet
-  #--
-  # the following construct means '4 blanks'
-  # some content <text:s text:c="3"/>
-  #++
-  def read_cells(sheet=nil)
-    sheet ||= @default_sheet
-    validate_sheet!(sheet)
-    return if @cells_read[sheet]
-    sheet_found = false
-    @doc.xpath("/ss:Workbook/ss:Worksheet[@ss:Name='#{sheet}']").each do |ws|
-      sheet_found = true
-      row = 1
-      col = 1
-      column_attributes = {}
-      idx = 0
-      ws.xpath('./ss:Table/ss:Column').each do |c|
-        column_attributes[(idx += 1).to_s] = c['StyleID']
-      end
-      ws.xpath('./ss:Table/ss:Row').each do |r|
-        skip_to_row = r['Index'].to_i
-        row = skip_to_row if skip_to_row > 0
-        style_name = r['StyleID'] if r['StyleID']
-        r.xpath('./ss:Cell').each do |c|
-          skip_to_col = c['Index'].to_i
-          col = skip_to_col if skip_to_col > 0
-          if c['StyleID']
-            style_name = c['StyleID']
-          elsif
-            style_name ||= column_attributes[c['Index']]
-          end
-          c.xpath('./ss:Data').each do |cell|
-            formula = cell['Formula']
-            value_type = cell['ss:Type'].downcase.to_sym
-            v =  cell.content
-            str_v = v
-            case value_type
-            when :number
-              v = v.to_f
-              value_type = :float
-            when :datetime
-              if v =~ /^1899-12-31T(\d{2}:\d{2}:\d{2})/
-                v = $1
-                value_type = :time
-              elsif v =~ /([^T]+)T00:00:00.000/
-                v = $1
-                value_type = :date
-              end
-            when :boolean
-              v = cell['boolean-value']
-            end
-            set_cell_values(sheet,col,row,0,v,value_type,formula,cell,str_v,style_name)
-          end
-          col += 1
-        end
-        row += 1
-        col = 1
-      end
-    end
-    if !sheet_found
-      raise RangeError, "Unable to find sheet #{sheet} for reading"
-    end
-    @cells_read[sheet] = true
-  end
-
-  def read_styles
-    @doc.xpath("/ss:Workbook/ss:Styles/ss:Style").each do |style|
-      style_id = style['ID']
-      @style_definitions[style_id] = Roo::Excel2003XML::Font.new
-      if font = style.at_xpath('./ss:Font')
-        @style_definitions[style_id].bold = font['Bold']
-        @style_definitions[style_id].italic = font['Italic']
-        @style_definitions[style_id].underline = font['Underline']
-      end
-    end
-  end
-
-  A_ROO_TYPE = {
-    "float"      => :float,
-    "string"     => :string,
-    "date"       => :date,
-    "percentage" => :percentage,
-    "time"       => :time,
-  }
-
-  def self.oo_type_2_roo_type(ootype)
-    return A_ROO_TYPE[ootype]
-  end
-
-  # helper method to convert compressed spaces and other elements within
-  # an text into a string
-  def children_to_string(children)
-    result = ''
-    children.each {|child|
-      if child.text?
-        result = result + child.content
-      else
-        if child.name == 's'
-          compressed_spaces = child['c'].to_i
-          # no explicit number means a count of 1:
-          if compressed_spaces == 0
-            compressed_spaces = 1
-          end
-          result = result + " "*compressed_spaces
-        else
-          result = result + child.content
-        end
-      end
-    }
-    result
-  end
-
-end # class