class Roo::Excelx

Constants

ExceedsMaxError

Public Class Methods

new(filename_or_stream, options = {}) click to toggle source

initialization and opening of a spreadsheet file values for packed: :zip optional cell_max (int) parameter for early aborting attempts to parse enormous documents.

Calls superclass method Roo::Base::new
# File lib/roo/excelx.rb, line 258
def initialize(filename_or_stream, options = {})
  packed = options[:packed]
  file_warning = options.fetch(:file_warning, :error)
  cell_max = options.delete(:cell_max)
  sheet_options = {}
  sheet_options[:expand_merged_ranges] = (options[:expand_merged_ranges] || false)

  unless is_stream?(filename_or_stream)
    file_type_check(filename_or_stream,'.xlsx','an Excel-xlsx', file_warning, packed)
    basename = File.basename(filename_or_stream)
  end

  @tmpdir = make_tmpdir(basename, options[:tmpdir_root])
  @filename = local_filename(filename_or_stream, @tmpdir, packed)
  @comments_files = []
  @rels_files = []
  process_zipfile(@filename || filename_or_stream)

  @sheet_names = workbook.sheets.map do |sheet|
    unless options[:only_visible_sheets] && sheet['state'] == 'hidden'
      sheet['name']
    end
  end.compact
  @sheets = []
  @sheets_by_name = Hash[@sheet_names.map.with_index do |sheet_name, n|
    @sheets[n] = Sheet.new(sheet_name, @rels_files[n], @sheet_files[n], @comments_files[n], styles, shared_strings, workbook, sheet_options)
    [sheet_name, @sheets[n]]
  end]

  if cell_max
    cell_count = ::Roo::Utils.num_cells_in_range(sheet_for(options.delete(:sheet)).dimensions)
    raise ExceedsMaxError.new("Excel file exceeds cell maximum: #{cell_count} > #{cell_max}") if cell_count > cell_max
  end

  super
rescue => e # clean up any temp files, but only if an error was raised
  close
  raise e
end

Public Instance Methods

cell(row, col, sheet=nil) click to toggle source

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.

# File lib/roo/excelx.rb, line 321
def cell(row, col, sheet=nil)
  key = normalize(row,col)
  safe_send(sheet_for(sheet).cells[key], :value)
end
celltype(row,col,sheet=nil) click to toggle source

returns the type of a cell:

  • :float

  • :string,

  • :date

  • :percentage

  • :formula

  • :time

  • :datetime

# File lib/roo/excelx.rb, line 406
def celltype(row,col,sheet=nil)
  key = normalize(row, col)
  safe_send(sheet_for(sheet).cells[key], :type)
end
column(column_number,sheet=nil) click to toggle source

returns all values in this column as an array column numbers are 1,2,3,… like in the spreadsheet

# File lib/roo/excelx.rb, line 332
def column(column_number,sheet=nil)
  if column_number.is_a?(::String)
    column_number = ::Roo::Utils.letter_to_number(column_number)
  end
  sheet_for(sheet).column(column_number)
end
comment(row,col,sheet=nil) click to toggle source

returns the comment at (row/col) nil if there is no comment

# File lib/roo/excelx.rb, line 485
def comment(row,col,sheet=nil)
  key = normalize(row,col)
  sheet_for(sheet).comments[key]
end
comment?(row,col,sheet=nil) click to toggle source

true, if there is a comment

# File lib/roo/excelx.rb, line 491
def comment?(row,col,sheet=nil)
  !!comment(row,col,sheet)
end
comments(sheet=nil) click to toggle source
# File lib/roo/excelx.rb, line 495
def comments(sheet=nil)
  sheet_for(sheet).comments.map do |(x, y), comment|
    [x, y, comment]
  end
end
each_row_streaming(options={}) { |row| ... } click to toggle source

Yield an array of Excelx::Cell Takes options for sheet, pad_cells, and max_rows

# File lib/roo/excelx.rb, line 503
def each_row_streaming(options={})
  sheet_for(options.delete(:sheet)).each_row(options) { |row| yield row }
end
empty?(row,col,sheet=nil) click to toggle source
# File lib/roo/excelx.rb, line 433
def empty?(row,col,sheet=nil)
  sheet = sheet_for(sheet)
  key = normalize(row,col)
  cell = sheet.cells[key]
  !cell || !cell.value || (cell.type == :string && cell.value.empty?) \
    || (row < sheet.first_row || row > sheet.last_row || col < sheet.first_column || col > sheet.last_column)
end
excelx_format(row,col,sheet=nil) click to toggle source

returns the internal format of an excel cell

# File lib/roo/excelx.rb, line 428
def excelx_format(row,col,sheet=nil)
  key = normalize(row,col)
  sheet_for(sheet).excelx_format(key)
end
excelx_type(row,col,sheet=nil) click to toggle source

returns the internal type of an excel cell

  • :numeric_or_formula

  • :string

Note: this is only available within the Excelx class

# File lib/roo/excelx.rb, line 415
def excelx_type(row,col,sheet=nil)
  key = normalize(row,col)
  safe_send(sheet_for(sheet).cells[key], :excelx_type)
end
excelx_value(row,col,sheet=nil) click to toggle source

returns the internal value of an excelx cell Note: this is only available within the Excelx class

# File lib/roo/excelx.rb, line 422
def excelx_value(row,col,sheet=nil)
  key = normalize(row,col)
  safe_send(sheet_for(sheet).cells[key], :excelx_value)
end
first_column(sheet=nil) click to toggle source

returns the number of the first non-empty column

# File lib/roo/excelx.rb, line 350
def first_column(sheet=nil)
  sheet_for(sheet).first_column
end
first_row(sheet=nil) click to toggle source

returns the number of the first non-empty row

# File lib/roo/excelx.rb, line 340
def first_row(sheet=nil)
  sheet_for(sheet).first_row
end
font(row, col, sheet=nil) click to toggle source

Given a cell, return the cell’s style

# File lib/roo/excelx.rb, line 392
def font(row, col, sheet=nil)
  key = normalize(row,col)
  definition_index = safe_send(sheet_for(sheet).cells[key], :style)
  styles.definitions[definition_index] if definition_index
end
formula(row,col,sheet=nil) click to toggle source

Returns the formula at (row,col). Returns nil if there is no formula. The method formula? checks if there is a formula.

# File lib/roo/excelx.rb, line 371
def formula(row,col,sheet=nil)
  key = normalize(row,col)
  safe_send(sheet_for(sheet).cells[key], :formula)
end
formula?(*args) click to toggle source

Predicate methods really should return a boolean value. Hopefully no one was relying on the fact that this previously returned either nil/formula

# File lib/roo/excelx.rb, line 379
def formula?(*args)
  !!formula(*args)
end
formulas(sheet=nil) click to toggle source

returns each formula in the selected sheet as an array of tuples in following format

[row, col, formula], [row, col, formula],…
# File lib/roo/excelx.rb, line 385
def formulas(sheet=nil)
  sheet_for(sheet).cells.select {|_, cell| cell.formula }.map do |(x, y), cell|
    [x, y, cell.formula]
  end
end
label(name) click to toggle source

returns the row,col values of the labelled cell (nil,nil) if label is not defined

# File lib/roo/excelx.rb, line 449
def label(name)
  labels = workbook.defined_names
  if labels.empty? || !labels.key?(name)
    [nil,nil,nil]
  else
    [labels[name].row,
      labels[name].col,
      labels[name].sheet]
  end
end
labels() click to toggle source

Returns an array which all labels. Each element is an array with

labelname, [row,col,sheetname]
# File lib/roo/excelx.rb, line 462
def labels
  @labels ||= workbook.defined_names.map do |name, label|
    [ name,
      [ label.row,
        label.col,
        label.sheet,
      ] ]
  end
end
last_column(sheet=nil) click to toggle source

returns the number of the last non-empty column

# File lib/roo/excelx.rb, line 355
def last_column(sheet=nil)
  sheet_for(sheet).last_column
end
last_row(sheet=nil) click to toggle source

returns the number of the last non-empty row

# File lib/roo/excelx.rb, line 345
def last_row(sheet=nil)
  sheet_for(sheet).last_row
end
method_missing(method,*args) click to toggle source
Calls superclass method Roo::Base#method_missing
# File lib/roo/excelx.rb, line 298
def method_missing(method,*args)
  if label = workbook.defined_names[method.to_s]
    safe_send(sheet_for(label.sheet).cells[label.key], :value)
  else
    # call super for methods like #a1
    super
  end
end
row(rownumber,sheet=nil) click to toggle source
# File lib/roo/excelx.rb, line 326
def row(rownumber,sheet=nil)
  sheet_for(sheet).row(rownumber)
end
sheet_for(sheet) click to toggle source
# File lib/roo/excelx.rb, line 311
def sheet_for(sheet)
  sheet ||= default_sheet
  validate_sheet!(sheet)
  @sheets_by_name[sheet]
end
sheets() click to toggle source
# File lib/roo/excelx.rb, line 307
def sheets
  @sheet_names
end
to_s(sheet=nil) click to toggle source

shows the internal representation of all cells for debugging purposes

# File lib/roo/excelx.rb, line 443
def to_s(sheet=nil)
  sheet_for(sheet).cells.inspect
end

Private Instance Methods

clean_sheet(sheet) click to toggle source
# File lib/roo/excelx.rb, line 509
def clean_sheet(sheet)
  @sheets_by_name[sheet].cells.each_pair do |coord, value|
    next unless value.value.is_a?(::String)

    @sheets_by_name[sheet].cells[coord].value = sanitize_value(value.value)
  end

  @cleaned[sheet] = true
end
extract_sheets_in_order(entries, sheet_ids, sheets, tmpdir) click to toggle source
# File lib/roo/excelx.rb, line 577
def extract_sheets_in_order(entries, sheet_ids, sheets, tmpdir)
  sheet_ids.each_with_index do |id, i|
    name = sheets[id]
    entry = entries.find { |entry| entry.name =~ /#{name}$/ }
    path = "#{tmpdir}/roo_sheet#{i + 1}"
    @sheet_files << path
    entry.extract(path)
  end
end
extract_worksheet_ids(entries, path) click to toggle source

Internal: extracts the worksheet_ids from the workbook.xml file. xlsx

documents require a workbook.xml file, so a if the file is missing
it is not a valid xlsx file. In these cases, an ArgumentError is
raised.

wb - a Zip::Entry for the workbook.xml file. path - A String for Zip::Entry’s destination path.

Examples

extract_worksheet_ids(<Zip::Entry>, 'tmpdir/roo_workbook.xml')
# => ["rId1", "rId2", "rId3"]

Returns an Array of Strings.

# File lib/roo/excelx.rb, line 533
def extract_worksheet_ids(entries, path)
    wb = entries.find { |e| e.name[/workbook.xml$/] }
    fail ArgumentError 'missing required workbook file' if wb.nil?

    wb.extract(path)
    workbook_doc = Roo::Utils.load_xml(path).remove_namespaces!
    workbook_doc.xpath('//sheet').map{ |s| s.attributes['id'].value }
end
extract_worksheet_rels(entries, path) click to toggle source

Internal

wb_rels - A Zip::Entry for the workbook.xml.rels file. path - A String for the Zip::Entry’s destination path.

Examples

extract_worksheets(<Zip::Entry>, 'tmpdir/roo_workbook.xml.rels')
# => {
      "rId1"=>"worksheets/sheet1.xml",
      "rId2"=>"worksheets/sheet2.xml",
      "rId3"=>"worksheets/sheet3.xml"
     }

Returns a Hash.

# File lib/roo/excelx.rb, line 557
def extract_worksheet_rels(entries, path)
  wb_rels = entries.find { |e| e.name[/workbook.xml.rels$/] }
  fail ArgumentError 'missing required workbook file' if wb_rels.nil?

  wb_rels.extract(path)
  rels_doc = Roo::Utils.load_xml(path).remove_namespaces!
  worksheet_type ='http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet'

  relationships = rels_doc.xpath('//Relationship').select do |relationship|
    relationship.attributes['Type'].value == worksheet_type
  end

  relationships.inject({}) do |hash, relationship|
    attributes = relationship.attributes
    id = attributes['Id'];
    hash[id.value] = attributes['Target'].value
    hash
  end
end
process_zipfile(zipfilename_or_stream) click to toggle source

Extracts all needed files from the zip file

# File lib/roo/excelx.rb, line 588
def process_zipfile(zipfilename_or_stream)
  @sheet_files = []

  unless is_stream?(zipfilename_or_stream)
    process_zipfile_entries Zip::File.open(zipfilename_or_stream).to_a.sort_by(&:name)
  else
    stream = Zip::InputStream.open zipfilename_or_stream
    begin
      entries = []
      while entry = stream.get_next_entry
        entries << entry
      end
      process_zipfile_entries entries
    ensure
      stream.close
    end
  end
end
process_zipfile_entries(entries) click to toggle source
# File lib/roo/excelx.rb, line 607
def process_zipfile_entries entries
  # NOTE: When Google or Numbers 3.1 exports to xlsx, the worksheet filenames
  #       are not in order. With Numbers 3.1, the first sheet is always
  #       sheet.xml, not sheet1.xml. With Google, the order of the worksheets is
  #       independent of a worksheet's filename (i.e. sheet6.xml can be the
  #       first worksheet).
  #
  #       workbook.xml lists the correct order of worksheets and
  #       workbook.xml.rels lists the filenames for those worksheets.
  #
  #       workbook.xml:
  #         <sheet state="visible" name="IS" sheetId="1" r:id="rId3"/>
  #         <sheet state="visible" name="BS" sheetId="2" r:id="rId4"/>
  #       workbook.xml.rel:
  #         <Relationship Id="rId4" Target="worksheets/sheet5.xml" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet"/>
  #         <Relationship Id="rId3" Target="worksheets/sheet4.xml" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet"/>
  sheet_ids = extract_worksheet_ids(entries, "#{@tmpdir}/roo_workbook.xml")
  sheets = extract_worksheet_rels(entries, "#{@tmpdir}/roo_workbook.xml.rels")
  extract_sheets_in_order(entries, sheet_ids, sheets, @tmpdir)

  entries.each do |entry|
    path =
    case entry.name.downcase
    when /sharedstrings.xml$/
      "#{@tmpdir}/roo_sharedStrings.xml"
    when /styles.xml$/
      "#{@tmpdir}/roo_styles.xml"
    when /comments([0-9]+).xml$/
      # FIXME: Most of the time, The order of the comment files are the same
      #       the sheet order, i.e. sheet1.xml's comments are in comments1.xml.
      #       In some situations, this isn't true. The true location of a
      #       sheet's comment file is in the sheet1.xml.rels file. SEE
      #       ECMA-376 12.3.3 in "Ecma Office Open XML Part 1".
      nr = Regexp.last_match[1].to_i
      @comments_files[nr - 1] = "#{@tmpdir}/roo_comments#{nr}"
    when /sheet([0-9]+).xml.rels$/
      # FIXME: Roo seems to use sheet[\d].xml.rels for hyperlinks only, but
      #        it also stores the location for sharedStrings, comments,
      #        drawings, etc.
      nr = Regexp.last_match[1].to_i
      @rels_files[nr - 1] = "#{@tmpdir}/roo_rels#{nr}"
    end

    entry.extract(path) if path
  end
end
safe_send(object, method, *args) click to toggle source
# File lib/roo/excelx.rb, line 666
def safe_send(object, method, *args)
  object.send(method, *args) if object && object.respond_to?(method)
end
shared_strings() click to toggle source
# File lib/roo/excelx.rb, line 658
def shared_strings
  @shared_strings ||= SharedStrings.new(File.join(@tmpdir, 'roo_sharedStrings.xml'))
end
styles() click to toggle source
# File lib/roo/excelx.rb, line 654
def styles
  @styles ||= Styles.new(File.join(@tmpdir, 'roo_styles.xml'))
end
workbook() click to toggle source
# File lib/roo/excelx.rb, line 662
def workbook
  @workbook ||= Workbook.new(File.join(@tmpdir, "roo_workbook.xml"))
end