unxls 0.0.1

data/lib/formulas/map.rb

@@ -0,0 +1,5 @@
+map.rb
+
+    module ParsedExpressions; end # Groups together Parsed Expressions structures (2.5.198)
+
+require_relative 'biff8/parsed_expressions'

data/lib/formulas/parsed_expressions.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+# 2.5.198 Parsed Expressions
+module Unxls::Biff8::ParsedExpressions
+  extend self
+
+  # 2.5.198.2 BErr
+  # @param id [Integer]
+  # @return [Symbol]
+  def berr(id)
+    {
+      0x00 => :'NULL!',
+      0x07 => :'DIV/0!',
+      0x0F => :'VALUE!',
+      0x17 => :'REF!',
+      0x1D => :'NAME?',
+      0x24 => :'NUM!',
+      0x2A => :'N/A',
+    }[id]
+  end
+
+  # 2.5.198.3 CellParsedFormula
+  # @param data [String]
+  # @return [Hash]
+  def cellparsedformula(data)
+    io = StringIO.new(data)
+    cce = io.read(2).unpack('v').first
+
+    {
+      cce: cce,
+      rgce: rgce(io.read(cce)),
+      rgcb: rgbextra(io.read) # rest of the record
+    }
+  end
+
+  # 2.5.198.4 Cetab
+  # @param id [Integer]
+  # @return [Symbol]
+  def cetab(id)
+    Unxls::Biff8::Constants::CETAB_NAMES[id]
+  end
+
+  # 2.5.198.17 Ftab
+  # @param id [Integer]
+  # @return [Symbol]
+  def ftab(id)
+    Unxls::Biff8::Constants::FTAB_NAMES[id]
+  end
+
+  # 2.5.198.21 NameParsedFormula
+  # @param io [StringIO]
+  # @param cce [Integer]
+  # @return [Hash]
+  def nameparsedformula(io, cce)
+    {
+      rgce: rgce(io.read(cce)),
+      rgcb: rgbextra(io)
+    }
+  end
+
+  # @param id [Integer]
+  def _ptg_name(id)
+    Unxls::Biff8::Constants::PTG_NAMES[id]
+  end
+
+  # @param byte1 [String]
+  def _ptg_2byte_header?(byte1)
+    Set[0x18, 0x19].include?(byte1.unpack('C').first)
+  end
+
+  # 2.5.198.36 PtgAttrIf
+  # @param io [StringIO]
+  # @param id [Integer]
+  # @return [Hash]
+  def ptgattrif(io, id)
+    { offset: io.read(2).unpack('v').first } # specifies the byte offset
+  end
+
+  # 2.5.198.44 PtgDataType
+  # @param id [Integer]
+  # @return [Symbol]
+  def ptgdatatype(id)
+    {
+      1 => :REFERENCE, # reference to a range
+      2 => :VALUE, # single value of a simple type. The type can be a Boolean, a number, a string, or an error code
+      3 => :ARRAY, # array of values
+    }[id]
+  end
+
+  # 2.5.198.58 PtgExp
+  # @param io [StringIO]
+  # @param id [Integer]
+  # @return [Hash]
+  def ptgexp(io, id)
+    rw, cl = io.read(4).unpack('vv')
+    { row: rw, col: cl }
+  end
+
+  # 2.5.198.62 PtgFunc
+  # @param io [StringIO]
+  # @param id [Integer]
+  # @return [Hash]
+  def ptgfunc(io, id)
+    type_id = Unxls::BitOps.new(id).value_at(5..6)
+    ftab_id = io.read(2).unpack('v').first
+
+    {
+      type: type_id,
+      type_d: ptgdatatype(type_id),
+      iftab: ftab(ftab_id)
+    }
+  end
+
+  # 2.5.198.63 PtgFuncVar
+  # @param io [StringIO]
+  # @param id [Integer]
+  # @return [Hash]
+  def ptgfuncvar(io, id)
+    type_id = Unxls::BitOps.new(id).value_at(5..6)
+
+    cparams, tab_c = io.read(3).unpack('Cv')
+    attrs = Unxls::BitOps.new(tab_c)
+    tab = attrs.value_at(0..14)
+    f_ce_func = attrs.set_at?(15)
+    tab_type = f_ce_func ? :cetab : :ftab
+
+    {
+      type: type_id,
+      type_d: ptgdatatype(type_id),
+      cparams: cparams,
+      tab: tab,
+      tab_d: self.send(tab_type, tab),
+      _tab_type: tab_type,
+      fCeFunc: f_ce_func,
+    }
+  end
+
+  # 2.5.198.35 PtgAttrGoto
+  # @param io [StringIO]
+  # @param id [Integer]
+  # @return [Hash]
+  def ptgattrgoto(io, id)
+    { offset: io.read(2).unpack('v').first } # specifies a value 1 less than the byte offset
+  end
+
+  # 2.5.198.66 PtgInt
+  # @param io [StringIO]
+  # @param id [Integer]
+  # @return [Hash]
+  def ptgint(io, id)
+    { integer: io.read(2).unpack('v').first }
+  end
+
+  # 2.5.198.79 PtgNum
+  # @param io [StringIO]
+  # @param id [Integer]
+  # @return [Hash]
+  def ptgnum(io, id)
+    { value: xnum(io.read(8)) }
+  end
+
+  # 2.5.198.84 PtgRef
+  # @param io [StringIO]
+  # @param id [Integer]
+  # @return [Hash]
+  def ptgref(io, id)
+    type_id = Unxls::BitOps.new(id).value_at(5..6)
+    {
+      type: type_id,
+      type_d: ptgdatatype(type_id),
+      loc: rgceloc(io.read(4))
+    }
+  end
+
+  # 2.5.198.89 PtgStr
+  # @param io [StringIO]
+  # @param id [Integer]
+  # @return [Hash]
+  def ptgstr(io, id)
+    { string: shortxlunicodestring(io) }
+  end
+
+  alias :ptgtbl :ptgexp # 2.5.198.92 PtgTbl
+
+  # 2.5.198.104 Rgce
+  # @param data [String]
+  # @return [Hash]
+  def rgce(data)
+    io = StringIO.new(data)
+    ptgs = []
+
+    until io.eof? do
+      id1 = io.read(1)
+      id = if _ptg_2byte_header?(id1)
+        (id1 << io.read(1)).unpack('n').first
+      else
+        id1.unpack('C').first
+      end
+
+      ptg_name = _ptg_name(id)
+      ptg_method = ptg_name.downcase
+      ptg = self.respond_to?(ptg_method) ? self.send(ptg_method, io, id) : {}
+      ptg[:ptg] = ptg_name
+
+      ptgs << ptg
+    end
+
+    ptgs
+  end
+
+  # 2.5.198.109 RgceLoc
+  # @param data [String]
+  # @return [Hash]
+  def rgceloc(data)
+    rw, cl = data.unpack('vv')
+    {
+      row: rw, # RwU that specifies the row coordinate of the cell reference
+      column: colrelu(cl) # ColRelU that specifies the column coordinate of the cell reference and relative reference information
+    }
+  end
+
+  # 2.5.198.103 RgbExtra
+  # @param io [String]
+  # @return [Hash]
+  def rgbextra(io)
+    # @todo
+  end
+
+end

data/lib/formulas/record.rb

@@ -0,0 +1,130 @@
+record.rb
+
+globals
+
+  # @todo move formula parsing to a separate branch
+  # 2.4.150 Lbl
+  # @return [Hash]
+  def r_lbl
+    @multiple = true
+
+    a_j_raw, ch_key, cch, cce, _, itab = @bytes.read(14).unpack('vCCvvvCCCC')
+    a_j = Unxls::BitOps.new(a_j_raw)
+    result = {
+      fHidden: a_j.set_at?(0), # A - fHidden (1 bit): A bit that specifies whether the defined name is not visible in the list of defined names.
+      fFunc: a_j.set_at?(1), # B - fFunc (1 bit): A bit that specifies whether the defined name represents an Excel macro (XLM). If this bit is 1, fProc MUST also be 1.
+      fOB: a_j.set_at?(2), # C - fOB (1 bit): A bit that specifies whether the defined name represents a Visual Basic for Applications (VBA) macro. If this bit is 1, the fProc MUST also be 1.
+      fProc: a_j.set_at?(3), # D - fProc (1 bit): A bit that specifies whether the defined name represents a macro.
+      fCalcExp: a_j.set_at?(4), # E - fCalcExp (1 bit): A bit that specifies whether rgce contains a call to a function that can return an array.
+      fBuiltin: a_j.set_at?(5), # F - fBuiltin (1 bit): A bit that specifies whether the defined name represents a built-in name.
+    }
+
+    # fGrp (6 bits): An unsigned integer that specifies the function category for the defined name. MUST be less than or equal to 31. The values 17 to 31 are user-defined. User-defined values are specified in the FnGroupName record. The values 0 to 16 are defined as specified in the following table:
+    f_grp = a_j.value_at(6..11)
+    f_grp_d = {
+      0 => :All,
+      1 => :Financial,
+      2 => :'Date Time',
+      3 => :'Math Trigonometry',
+      4 => :Statistical,
+      5 => :Lookup,
+      6 => :Database,
+      7 => :Text,
+      8 => :Logical,
+      9 => :Info,
+      10 => :Commands,
+      11 => :Customize,
+      12 => :'Macro Control',
+      13 => :'DDE External',
+      14 => :'User Defined',
+      15 => :Engineering,
+      16 => :Cube
+    }[f_grp]
+
+    result[:fGrp] = f_grp
+    result[:fGrp_d] = f_grp_d
+
+    # G - reserved1 (1 bit): MUST be zero, and MUST be ignored.
+
+    # H - fPublished (1 bit): A bit that specifies whether the defined name is published. This bit is
+    # ignored if the fPublishedBookItems field of the BookExt_Conditional12 structure is 0.
+    result[:fPublished] = a_j.set_at?(13)
+
+    result[:fWorkbookParam] = a_j.set_at?(14) # I - fWorkbookParam (1 bit): A bit that specifies whether the defined name is a workbook parameter.
+
+    # J - reserved2 (1 bit): MUST be zero, and MUST be ignored.
+
+    # chKey (1 byte): The unsigned integer value of the ASCII character that specifies the shortcut key for the macro represented by the defined name. MUST be 0 (no shortcut key) if fFunc is 1 or if fProc is 0. Otherwise MUST<97> be greater than or equal to 0x41 and less than or equal to 0x5A, or greater than or equal to 0x61 and less than or equal to 0x7A.
+    result[:chKey] = ch_key
+
+    result[:cch] = cch # cch (1 byte): An unsigned integer that specifies the number of characters in Name. MUST be greater than or equal to zero.
+    result[:cce] = cce # cce (2 bytes): An unsigned integer that specifies length of rgce in bytes.
+
+    # reserved3 (2 bytes): MUST be zero, and MUST be ignored.
+
+    result[:itab] = itab # itab (2 bytes): An unsigned integer that specifies if the defined name is a local name, and if so, which sheet it is on. If itab is not 0, the defined name is a local name and the value MUST be a one-based index to the collection of BoundSheet8 records as they appear in the Globals Substream.
+
+    # reserved4 (1 byte): MUST be zero, and MUST be ignored.
+    # reserved5 (1 byte): MUST be zero, and MUST be ignored.
+    # reserved6 (1 byte): MUST be zero, and MUST be ignored.
+    # reserved7 (1 byte): MUST be zero, and MUST be ignored.
+
+    # Name (variable): An XLUnicodeStringNoCch structure that specifies the name for the defined name. If fBuiltin is 0, this field MUST satisfy the same restrictions as the name field of the XLNameUnicodeString structure. If fBuiltin is 1, this field is for a built-in name. Each built-in name has a zero-based index value associated with it.
+    name_pos = @bytes.pos
+    result[:Name] = Unxls::Biff8::Structure.xlunicodestringnocch(@bytes, cch)
+
+    # ?? "A built-in name or its index value MUST be used for this field"
+    if @bytes.pos - name_pos == 1
+      @bytes.pos -= 1
+      name_index = @bytes.read(1).unpack('C').first
+      result[:Name_d] = {
+        0x00 => :Consolidate_Area,
+        0x01 => :Auto_Open,
+        0x02 => :Auto_Close,
+        0x03 => :Extract,
+        0x04 => :Database,
+        0x05 => :Criteria,
+        0x06 => :Print_Area,
+        0x07 => :Print_Titles,
+        0x08 => :Recorder,
+        0x09 => :Data_Form,
+        0x0A => :Auto_Activate,
+        0x0B => :Auto_Deactivate,
+        0x0C => :Sheet_Title,
+        0x0D => :_FilterDatabase
+      }[name_index]
+    end
+
+    # rgce (variable): A NameParsedFormula structure that specifies the formula for the defined name.
+    # result[:rgce] = Unxls::Biff8::ParsedExpressions.nameparsedformula(@bytes, cce) # @todo formula parsing to a separate branch
+
+    result
+  end
+
+sheet
+
+  # 2.4.127 Formula
+  # @return [Hash]
+  def r_formula
+    @multiple = true
+
+    result = {
+      cell: Unxls::Biff8::Structure.cell(@bytes.read(6)),
+      val: Unxls::Biff8::Structure.formulavalue(@bytes.read(8))
+    }
+
+    a_f_raw = @bytes.read(2).unpack('v').first
+    a_f = Unxls::BitOps.new(a_f_raw)
+    result[:fAlwaysCalc] = a_f.set_at?(0) # (A) specifies whether the formula needs to be calculated during the next recalculation
+    result[:fFill] = a_f.set_at?(2) # (C) cell has either a fill alignment or a center-across-selection alignment
+    result[:fShrFmla] = a_f.set_at?(3) # (D) specifies whether the formula is part of a shared formula as defined in ShrFmla. If this formula is part of a shared formula, formula.rgce MUST begin with a PtgExp structure
+    result[:fClearErrors] = a_f.set_at?(5) # (F) specifies whether the formula is excluded from formula error checking
+
+    @bytes.read(4) # specifies an application-specific cache of information, exists for performance reasons only
+
+    # @todo move formula parsing to a separate branch
+    # result[:formula] = Unxls::Biff8::ParsedExpressions.cellparsedformula(@bytes.read) # rest of record
+    @bytes.read # ignore for now
+
+    result
+  end

data/lib/formulas/structure.rb

@@ -0,0 +1,30 @@
+structure.rb
+
+  extend Unxls::Biff8::ParsedExpressions
+
+  # 2.5.133 FormulaValue
+  # @param data [String]
+  # @return [Hash]
+  def formulavalue(data)
+    f_expr_o = data[6..7].unpack('v').first
+
+    return { _value: xnum(data), _type: :float } if f_expr_o != 0xFFFF # value is Xnum if last 2 bytes are FFFF
+
+    byte1_val = data[0].unpack('C').first
+    value_type = {
+      0 => :string,
+      1 => :boolean,
+      2 => :error,
+      3 => :blank_string
+    }[byte1_val]
+
+    value = case value_type
+    when :string then nil # value is stored in a String record that immediately follows Formula record
+    when :boolean then data[2] != "\0" # byte3 specifies Boolean value
+    when :error then berr(data[2].unpack('C').first) # byte 3 specifies an error
+    when :blank_string then ''
+    else raise "Unknown value type #{byte1_val} in FormulaValue structure"
+    end
+
+    { _value: value, _type: value_type }
+  end

data/lib/unxls.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'unxls/map'
+
+module Unxls
+  # @param path [String, Pathname]
+  # @param settings [Hash]
+  # @return [Hash]
+  def self.parse(path, settings = {})
+    file = File.open(path, 'rb')
+    Unxls::Parser.new(file, settings).parse
+  ensure
+    file.close if file
+  end
+
+end

data/lib/unxls/biff8/browser.rb

@@ -0,0 +1,347 @@
+# frozen_string_literal: true
+
+class Unxls::Biff8::Browser
+
+  attr_reader :parsed
+
+  # @param file [String, Pathname, File]
+  # @param settings [Hash]
+  def initialize(file, settings = {})
+    @file = Pathname.new(file).to_s
+    @settings = settings
+    reload
+  end
+
+  # @param return_self [true, false] (true)
+  # @return [Unxls::Biff8::Browser, nil]
+  def reload(return_self = true)
+    @parsed = Unxls.parse(@file, @settings)
+    self if return_self
+  end
+
+  # WorkBookStream
+  # @return [Hash]
+  def wbs
+    @parsed[:workbook_stream]
+  end
+
+  # Workbook stream, globals substream
+  # @return [Hash]
+  def globals
+    raise unless wbs.first[:BOF][:dt_d] == :globals
+    wbs.first
+  end
+
+  # Cell address to location index
+  # @return [Hash]
+  def cell_index
+    wbs.last
+  end
+
+  # Map certain records, or their non-nil attributes, or anything non-nil that the passed block will return.
+  #
+  # @example
+  #   # Collect all records of certain type:
+  #   Browser.new(parsed).mapif(:Font)
+  #   #=> [{ dyHeight: … }, …]
+  #
+  #   # Collect certain attributes:
+  #   Browser.new(parsed).mapif(:Font) { |record| record[:fontName] }
+  #   #=> ['Arial', …]
+  #
+  #   # Index is passed into the block:
+  #   Browser.new(parsed).mapif(:Font) do |r, index|
+  #     { index => r[:fontName] }
+  #   end
+  #   #=> [{ 0 => 'Arial' }, … ]
+  #
+  #   # Wrap in other value to collect nils:
+  #   Browser.new(parsed).mapif(:SomeRecord) { |r| [r[:someField]] }
+  #   #=> [[nil], [18], [23], …]
+  #
+  #   # Collect only those records that have attributes of certain value:
+  #   Browser.new(parsed).mapif(:Blank, :LabelSst) { |r| r if r[:ixfe] == 42 }
+  #   #=> [{ ifxe: 42, _record: { name: :Blank, … } }, …]
+  #
+  #   # Join other records. Browser instance and substream index are passed into the block as well for unlimited power:
+  #   Browser.new(parsed).mapif(:XF) do |r1, i1, browser, substream_index|
+  #     { [substream_index, i1] => browser.mapif(:Style) { |r2| r2 if r2[:ixfe] == i1 } }
+  #   end
+  #   #=> [
+  #   #=>   { [0, 0] => { ixfe: 0, fBuiltIn: true, … } },
+  #   #=>   { [0, 1] => [] },
+  #   #=>   …
+  #   #=> ]
+  #
+  # @param *record_types [Array<Symbol>] list of types of records to map
+  # @param first: [TrueClass, FalseClass] false Only return the first match
+  # @return [Array, Object, nil]
+  def mapif(*record_types, first: false)
+    result = []
+
+    wbs.each_with_index do |substream, substream_index|
+      record_types.each do |rt|
+        [substream[rt]].flatten.compact.each_with_index do |record, index|
+          if block_given?
+            temp = yield(record, index, self, substream_index)
+            next if temp.nil?
+            return(temp) if first
+            result << temp
+          else
+            result << record
+          end
+        end
+      end
+    end
+
+    first ? result.first : result
+  end
+
+  # @param sheet_name [String, Symbol]
+  # @return [Integer, nil]
+  def get_substream_index(sheet_name)
+    ref = globals[:BoundSheet8].find { |s| s[:stName] == sheet_name.to_s }
+    return unless ref
+
+    wbs.find_index do |s|
+      s[:BOF][:_record][:pos] == ref[:lbPlyPos] if s[:BOF] && s[:BOF][:dt_d] != :globals
+    end
+  end
+
+  # @param name [String, Symbol]
+  # @return [Hash, nil]
+  def get_sheet(name)
+    sheet_index = get_substream_index(name)
+    wbs[sheet_index] if sheet_index
+  end
+
+  # @param substream_index [Integer]
+  # @param row [Integer]
+  # @param column [Integer]
+  # @param :record_type [Symbol] (nil)
+  # @return [Hash, nil]
+  def get_cell(substream_index, row, column, record_type: nil)
+    address_key = Unxls::Biff8::WorkbookStream.make_address_key(substream_index, row, column)
+    return unless (access_address = cell_index[address_key])
+    inferred_record_type, record_index = access_address.to_s.split('_')
+    wbs[substream_index][record_type || inferred_record_type.to_sym][record_index.to_i]
+  end
+
+  # @param font_index [Integer]
+  # @return [Hash, nil]
+  def get_font(font_index)
+    font_index -= 1 if font_index >= 4 # See 2.5.129 FontIndex, p. 677
+    globals[:Font][font_index]
+  end
+
+  # @param substream_index [Integer]
+  # @param row [Integer]
+  # @param column [Integer]
+  # @return [Hash, nil]
+  def get_format(substream_index, row, column)
+    return unless (xf = get_xf(substream_index, row, column))
+
+    format_index = xf[:ifmt]
+    globals[:Format].find { |r| r[:ifmt] == format_index }
+  end
+
+  # @param substream_index [Integer]
+  # @param row [Integer]
+  # @param column [Integer]
+  # @return [Hash, nil]
+  def get_sst(substream_index, row, column)
+    sst_index = get_cell(substream_index, row, column)[:isst]
+    globals[:SST][:rgb][sst_index] if sst_index
+  end
+
+  # @param substream_index [Integer]
+  # @param row [Integer]
+  # @param column [Integer]
+  # @return [Hash, nil]
+  def get_xf(substream_index, row, column)
+    return unless (cell = get_cell(substream_index, row, column))
+    globals[:XF][cell_xf_index(cell, column)]
+  end
+
+  # @param substream_index [Integer]
+  # @param row [Integer]
+  # @param column [Integer]
+  # @return [Hash, nil]
+  def get_xfext(substream_index, row, column)
+    return unless (cell = get_cell(substream_index, row, column))
+    ixfe = cell_xf_index(cell, column)
+    globals[:XFExt].find { |r| r[:ixfe] == ixfe } # @todo speedup with xf_xfext index?
+  end
+
+  def get_style(substream_index, row, column)
+    return unless (xf = get_xf(substream_index, row, column))
+    cell_parent_xf_ixfe = xf[:ixfParent]
+    globals[:Style].find { |r| r[:ixfe] == cell_parent_xf_ixfe }
+  end
+
+  def get_styleext(substream_index, row, column)
+    style = get_style(substream_index, row, column)
+    globals[:StyleExt][style[:_record][:index]]
+  end
+
+  def get_tablestyle(tablestyle_name)
+    globals[:TableStyle].find { |r| r[:rgchName] == tablestyle_name }
+  end
+
+  def get_tablestyleelement(tablestyle_name, type)
+    index = get_tablestyle(tablestyle_name)[:_record][:index]
+    globals[:TableStyleElement].find { |r| r[:_tsi] == index && r[:tseType_d] == type }
+  end
+
+  # DXF related to TableStyleElement record
+  # @param tablestyle_name [String]
+  # @param type [Symbol]
+  # @return [Hash]
+  def get_tse_dxf(tablestyle_name, type)
+    globals[:DXF][ get_tablestyleelement(tablestyle_name, type)[:index] ]
+  end
+
+  # @param substream_index [Integer]
+  # @param column [Integer]
+  # @return [Hash, nil]
+  def get_colinfo(substream_index, column)
+    wbs[substream_index][:ColInfo].find { |r| column >= r[:colFirst] && column <= r[:colLast] }
+  end
+
+  # @param substream_index [Integer]
+  # @param row [Integer]
+  # @return [Hash, nil]
+  def get_row(substream_index, row)
+    wbs[substream_index][:Row].find { |r| r[:rw] == row }
+  end
+
+  # @param substream_index [Integer]
+  # @param row [Integer]
+  # @param column [Integer]
+  # @return [Hash, nil]
+  def get_note(substream_index, row, column)
+    address_key = Unxls::Biff8::WorkbookStream.make_address_key(substream_index, row, column)
+    return unless (record_index = cell_index[:notes][address_key])
+    wbs[substream_index][:Note][record_index]
+  end
+  
+  # @param substream_index [Integer]
+  # @param object_id [Integer]
+  # @return [Hash, nil]
+  def get_obj(substream_index, object_id)
+    wbs[substream_index][:Obj].find { |r| r[:cmo][:id] == object_id }
+  end
+
+  # @param substream_index [Integer]
+  # @param row [Integer]
+  # @param column [Integer]
+  # @return [Hash, nil]
+  def get_hlink(substream_index, row, column)
+    address_key = Unxls::Biff8::WorkbookStream.make_address_key(substream_index, row, column)
+    return unless (record_index = cell_index[:hlinks][address_key])
+    wbs[substream_index][:HLink][record_index]
+  end
+
+  # @param substream_index [Integer]
+  # @param row [Integer]
+  # @param column [Integer]
+  # @return [Hash, nil]
+  def get_hlinktooltip(substream_index, row, column)
+    address_key = Unxls::Biff8::WorkbookStream.make_address_key(substream_index, row, column)
+    return unless (record_index = cell_index[:hlinktooltips][address_key])
+    wbs[substream_index][:HLinkTooltip][record_index]
+  end
+
+  # @todo @debug
+  # @param substream_index [Integer]
+  # @param row [Integer]
+  # @param column [Integer]
+  # @return [Hash, nil]
+  def get_cell_styling(substream_index, row, column) # @todo -> xf_record_chain ?
+    return unless (cell = get_cell(substream_index, row, column))
+    cell_ixfe = cell_xf_index(cell, column)
+
+    cell_xf = globals[:XF][cell_ixfe]
+    cell_xfext = globals[:XFExt].find { |r| r[:ixfe] == cell_ixfe } # @todo index?
+
+    cell_parent_xf_ixfe = cell_xf[:ixfParent]
+
+    style_xf = globals[:XF][cell_parent_xf_ixfe]
+    style_xfext = globals[:XFExt].find { |r| r[:ixfe] == cell_parent_xf_ixfe } # @todo index?
+
+    style = globals[:Style].find { |r| r[:ixfe] == cell_parent_xf_ixfe } # @todo index?
+    styleext = globals[:StyleExt][style[:_record][:index]]
+
+    result = {
+      xf: cell_xf,
+      xfext: cell_xfext,
+      style_xf: style_xf,
+      style_xfext: style_xfext,
+      style: style,
+      styleext: styleext,
+    }
+
+    cell_xf_font_index = cell_xf[:ifnt]
+    cell_xf_font_index -= 1 if cell_xf_font_index >= 4 # See 2.5.129 FontIndex, p. 677
+    result[:xf_font] = globals[:Font][cell_xf_font_index]
+
+    if (style_xf_font_index = style_xf[:ifnt]) != cell_xf[:ifnt]
+      style_xf_font_index -= 1 if style_xf_font_index >= 4 # See 2.5.129 FontIndex, p. 677
+      result[:style_xf_font] = globals[:Font][style_xf_font_index]
+    end
+
+    cell_xf_format_index = cell_xf[:ifmt]
+    result[:xf_format] = globals[:Format].find { |r| r[:ifmt] == cell_xf_format_index }
+
+    if (style_xf_format_index = style_xf[:ifmt]) != cell_xf_format_index
+      result[:style_xf_format] = globals[:Format].find { |r| r[:ifmt] == style_xf_format_index }
+    end
+
+    if (rows = wbs[substream_index][:Row])
+      row_record = rows.find { |r| r[:rw] == row }
+      result[:row] = row_record if row_record
+    end
+
+    if (columns = wbs[substream_index][:ColInfo])
+      column_record = columns.find { |r| (r[:colFirst]..r[:colLast]).include?(column) }
+      result[:column] = column_record if column_record
+    end
+
+    result
+  end
+
+  # @todo @debug
+  def xf_styles
+    mapif(:XF) do |r, i, s|
+      style = s.mapif(:Style) { |r1| r1 if r1[:ixfe] == i  }.first
+      {
+        index:     i,
+        fStyle:    r[:fStyle],
+        _builtin:  r[:_description],
+        ixfParent: r[:ixfParent],
+        Style:     style
+      } if style
+    end
+  end
+
+  private
+
+  # @param cell [Hash]
+  # @param column [Integer]
+  # @return [Integer]
+  def cell_xf_index(cell, column)
+    case (record_type = cell[:_record][:name])
+    when :LabelSst, :RK, :Blank, :Formula, :Number, :BoolErr, :Label
+      cell[:ixfe]
+    when :MulRk
+      rgkrec_index = column - cell[:colFirst]
+      cell[:rgrkrec][rgkrec_index][:ixfe]
+    when :MulBlank
+      rgixfe_index = column - cell[:colFirst]
+      cell[:rgixfe][rgixfe_index]
+    else
+      raise "Dunno how to process record type :#{record_type}"
+    end
+  end
+
+end