ruby-spreadsheet 0.6.5

data/lib/spreadsheet/excel/reader/biff5.rb

@@ -0,0 +1,22 @@
+module Spreadsheet
+  module Excel
+    class Reader
+##
+# This Module collects reader methods such as read_string that are specific to
+# Biff5.  This Module is likely to be expanded as Support for older Versions
+# of Excel grows.
+module Biff5
+  ##
+  # Read a String of 8-bit Characters
+  def read_string work, count_length=1
+    # Offset    Size  Contents
+    #      0  1 or 2  Length of the string (character count, ln)
+    # 1 or 2      ln  Character array (8-bit characters)
+    fmt = count_length == 1 ? 'C' : 'v'
+    length, = work.unpack fmt
+    work[count_length, length]
+  end
+end
+    end
+  end
+end

data/lib/spreadsheet/excel/reader/biff8.rb

@@ -0,0 +1,193 @@
+module Spreadsheet
+  module Excel
+    class Reader
+##
+# This Module collects reader methods such as read_string that are specific to
+# Biff8.  This Module is likely to be expanded as Support for older Versions
+# of Excel grows and methods get moved here for disambiguation.
+module Biff8
+  include Spreadsheet::Excel::Internals
+  ##
+  # When a String is too long for one Opcode, it is continued in a Continue
+  # Opcode. Excel may reconsider compressing the remainder of the string.
+  # This method appends the available remainder (decompressed if necessary) to
+  # the incomplete string.
+  def continue_string work, incomplete_string=@incomplete_string
+    opts, _ = work.unpack 'C'
+    wide = opts & 1
+    head, chars = incomplete_string
+    owing = chars - head.size / 2
+    size = owing * (wide + 1)
+    string = work[1, size]
+    if wide == 0
+      string = wide string
+    end
+    head << string
+    if head.size >= chars * 2
+      @incomplete_string = nil
+    end
+    size + 1
+  end
+  ##
+  # When a String is too long for one Opcode, it is continued in a Continue
+  # Opcode. Excel may reconsider compressing the remainder of the string.
+  # This method only evaluates the header and registers the address of the
+  # continuation with the previous SstEntry.
+  def continue_string_header work, oppos
+    opts, _ = work.unpack 'C'
+    wide = opts & 1
+    owing = @incomplete_sst.continued_chars
+    size = [work.size, owing * (1 + wide) + 1].min
+    chars = (size - 1) / (1 + wide)
+    skip = size
+    @incomplete_sst.continue oppos + OPCODE_SIZE, size, chars
+    unless @incomplete_sst.continued?
+      @workbook.add_shared_string @incomplete_sst
+      skip += @incomplete_skip
+      @incomplete_sst = nil
+      @incomplete_skip = nil
+    end
+    skip
+  end
+  ##
+  # Read more data into the Shared String Table. (see also: #read_sst)
+  # This method only evaluates the header, the actual work is done in #_read_sst
+  def continue_sst work, oppos, len
+    pos = 0
+    if @incomplete_sst
+      pos = continue_string_header work, oppos
+    end
+    @sst_offset[1] += len
+    _read_sst work, oppos, pos
+  end
+  def postread_workbook # :nodoc:
+    super
+    @incomplete_string, @sst_size, @sst_offset, @incomplete_sst = nil, @incomplete_skip = nil
+  end
+  ##
+  # Store the offset of extsst, so we can write a new extsst when the
+  # sst has changed
+  def read_extsst work, pos, len
+    @workbook.offsets.store :extsst, [pos, len]
+  end
+  ##
+  # Read the Shared String Table present in all Biff8 Files.
+  # This method only evaluates the header, the actual work is done in #_read_sst
+  def read_sst work, pos, len
+    # Offset  Size  Contents
+    #      0     4  Total number of strings in the workbook (see below)
+    #      4     4  Number of following strings (nm)
+    #      8  var.  List of nm Unicode strings, 16-bit string length (➜ 3.4)
+    total, @sst_size = work.unpack 'V2'
+    @sst_offset = [pos, len]
+    @workbook.offsets.store :sst, @sst_offset
+    _read_sst work, pos, 8
+  end
+  ##
+  # Read a string from the Spreadsheet, such as a Worksheet- or Font-Name, or a
+  # Number-Format. See also #read_string_header and #read_string_body
+  def read_string work, count_length=1
+    #   Offset    Size  Contents
+    #        0  1 or 2  Length of the string (character count, ln)
+    #   1 or 2       1  Option flags:
+    #                   Bit  Mask  Contents
+    #                     0  0x01  Character compression (ccompr):
+    #                              0 = Compressed (8-bit characters)
+    #                              1 = Uncompressed (16-bit characters)
+    #                     2  0x04  Asian phonetic settings (phonetic):
+    #                              0 = Does not contain Asian phonetic settings
+    #                              1 = Contains Asian phonetic settings
+    #                     3  0x08  Rich-Text settings (richtext):
+    #                              0 = Does not contain Rich-Text settings
+    #                              1 = Contains Rich-Text settings
+    # [2 or 3]       2  (optional, only if richtext=1)
+    #                   Number of Rich-Text formatting runs (rt)
+    #   [var.]       4  (optional, only if phonetic=1)
+    #                   Size of Asian phonetic settings block (in bytes, sz)
+    #     var.      ln  Character array (8-bit characters
+    #          or 2∙ln               or 16-bit characters, dependent on ccompr)
+    #   [var.]    4∙rt  (optional, only if richtext=1)
+    #                   List of rt formatting runs (➜ 3.2)
+    #   [var.]      sz  (optional, only if phonetic=1)
+    #                   Asian Phonetic Settings Block (➜ 3.4.2)
+    chars, offset, wide, phonetic, richtext, available, owing, skip \
+      = read_string_header work, count_length
+    string, data = read_string_body work, offset, available, wide > 0
+    if owing > 0
+      @incomplete_string = [string, chars]
+    end
+    string
+  end
+  ##
+  # Read the body of a string. Returns the String (decompressed if necessary) and
+  # the available data (unchanged).
+  def read_string_body work, offset, available, wide
+    data = work[offset, available]
+    string = wide ? data : wide(data)
+    [string, data]
+  end
+  ##
+  # Read the header of a string. Returns the following information in an Array:
+  # * The total number of characters in the string
+  # * The offset of the actual string data (= the length of this header in bytes)
+  # * Whether or not the string was compressed (0/1)
+  # * Whether or not the string contains asian phonetic settings (0/1)
+  # * Whether or not the string contains richtext formatting (0/1)
+  # * The number of bytes containing characters in this chunk of data
+  # * The number of characters missing from this chunk of data and expected to
+  #   follow in a Continue Opcode
+  def read_string_header work, count_length=1, offset=0
+    fmt = count_length == 1 ? 'C2' : 'vC'
+    chars, opts = work[offset, 1 + count_length].unpack fmt
+    wide      = opts & 1
+    phonetic  = (opts >> 2) & 1
+    richtext  = (opts >> 3) & 1
+    size      = chars * (wide + 1)
+    skip = 0
+    if richtext > 0
+      runs, = work[offset + 1 + count_length, 2].unpack 'v'
+      skip = 4 * runs
+    end
+    if phonetic > 0
+      psize, = work[offset + 1 + count_length + richtext * 2, 4].unpack 'V'
+      skip += psize
+    end
+    flagsize  = 1 + count_length + richtext * 2 + phonetic * 4
+    avbl      = [work.size - offset, flagsize + size].min
+    have_chrs = (avbl - flagsize) / (1 + wide)
+    owing     = chars - have_chrs
+    [chars, flagsize, wide, phonetic, richtext, avbl, owing, skip]
+  end
+  ##
+  # Insert null-characters into a compressed UTF-16 string
+  def wide string
+    data = ''
+    string.each_byte do |byte| data << byte.chr << 0.chr end
+    data
+  end
+  private
+  ##
+  # Read the Shared String Table present in all Biff8 Files.
+  def _read_sst work, oppos, pos
+    worksize = work.size
+    while @workbook.sst_size < @sst_size && pos < worksize do
+      sst = SstEntry.new :offset => oppos + OPCODE_SIZE + pos,
+                         :ole    => @data,
+                         :reader => self
+      sst.chars, sst.flags, wide, sst.phonetic, sst.richtext, sst.available,
+        sst.continued_chars, skip = read_string_header work, 2, pos
+      sst.wide = wide > 0
+      if sst.continued?
+        @incomplete_sst = sst
+        @incomplete_skip = skip
+        pos += sst.available
+      else
+        @workbook.add_shared_string sst
+        pos += sst.available + skip
+      end
+    end
+  end
+end
+    end
+  end
+end

data/lib/spreadsheet/excel/row.rb

@@ -0,0 +1,92 @@
+require 'date'
+require 'spreadsheet/row'
+
+module Spreadsheet
+  module Excel
+##
+# Excel-specific Row methods
+class Row < Spreadsheet::Row
+  ##
+  # The Excel date calculation erroneously assumes that 1900 is a leap-year. All
+  # Dates after 28.2.1900 are off by one.
+  LEAP_ERROR = Date.new 1900, 2, 28
+  ##
+  # Force convert the cell at _idx_ to a Date
+  def date idx
+    _date at(idx)
+  end
+  ##
+  # Force convert the cell at _idx_ to a DateTime
+  def datetime idx
+    _datetime at(idx)
+  end
+  def each &block
+    size.times do |idx|
+      block.call self[idx]
+    end
+  end
+  ##
+  # Access data in this Row like you would in an Array. If a cell is formatted
+  # as a Date or DateTime, the decoded Date or DateTime value is returned.
+  def [] idx, len=nil
+    if len
+      idx = idx...(idx+len)
+    end
+    if idx.is_a? Range
+      data = []
+      idx.each do |i|
+        data.push enriched_data(i, at(i))
+      end
+      data
+    else
+      enriched_data idx, at(idx)
+    end
+  end
+  private
+  def _date data # :nodoc:
+    return data if data.is_a?(Date)
+    datetime = _datetime data
+    Date.new datetime.year, datetime.month, datetime.day
+  end
+  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
+  def enriched_data idx, data # :nodoc:
+    res = nil
+    if link = @worksheet.links[[@idx, idx]]
+      res = link
+    elsif data.is_a?(Numeric) && fmt = format(idx)
+      res = if fmt.datetime? || fmt.time?
+              _datetime data
+            elsif fmt.date?
+              _date data
+            end
+    end
+    res || data
+  end
+end
+  end
+end

data/lib/spreadsheet/excel/sst_entry.rb

@@ -0,0 +1,46 @@
+require 'spreadsheet/encodings'
+
+module Spreadsheet
+  module Excel
+##
+# Shared String Table Entry
+class SstEntry
+  include Spreadsheet::Encodings
+  attr_accessor :chars, :phonetic, :richtext, :flags, :available,
+                :continued_chars, :wide
+  def initialize opts = {}
+    @content = nil
+    @offset = opts[:offset]
+    @ole    = opts[:ole]
+    @reader = opts[:reader]
+    @continuations = []
+  end
+  ##
+  # Access the contents of this Shared String
+  def content
+    @content or begin
+      data = nil
+      data = @ole[@offset, @available]
+      content, _ = @reader.read_string_body data, @flags, @available, @wide
+      @continuations.each do |offset, len|
+        @reader.continue_string(@ole[offset,len], [content, @chars])
+      end
+      content = client content, 'UTF-16LE'
+      if @reader.memoize?
+        @content = content
+      end
+      content
+    end
+  end
+  ##
+  # Register the offset of a String continuation
+  def continue offset, size, chars
+    @continued_chars -= chars
+    @continuations.push [offset, size]
+  end
+  def continued? # :nodoc:
+    @continued_chars > 0
+  end
+end
+  end
+end

data/lib/spreadsheet/excel/workbook.rb

@@ -0,0 +1,80 @@
+require 'spreadsheet/workbook'
+require 'spreadsheet/excel/offset'
+require 'spreadsheet/excel/writer'
+require 'ole/storage'
+
+module Spreadsheet
+  module Excel
+##
+# Excel-specific Workbook methods. These are mostly pertinent to the Excel
+# reader. You should have no reason to use any of these.
+class Workbook < Spreadsheet::Workbook
+  include Spreadsheet::Encodings
+  include Spreadsheet::Excel::Offset
+  BIFF_VERSIONS = {
+    0x000 => 2,
+    0x007 => 2,
+    0x200 => 2,
+    0x300 => 3,
+    0x400 => 4,
+    0x500 => 5,
+    0x600 => 8,
+  }
+  VERSION_STRINGS = {
+    0x600 => 'Microsoft Excel 97/2000/XP',
+    0x500 => 'Microsoft Excel 95',
+  }
+  offset :encoding, :boundsheets, :sst
+  attr_accessor :bof, :ole
+  attr_writer :date_base
+  def Workbook.open io, opts = {}
+    @reader = Reader.new opts
+    @reader.read io
+  end
+  def initialize *args
+    super
+    enc = 'UTF-16LE'
+    if RUBY_VERSION >= '1.9'
+      enc = Encoding.find enc
+    end
+    @encoding = enc
+    @version = 0x600
+    @sst = []
+  end
+  def add_shared_string str
+    @sst.push str
+  end
+  def add_worksheet worksheet
+    @changes.store :boundsheets, true
+    super
+  end
+  def biff_version
+    case @bof
+    when 0x009
+      2
+    when 0x209
+      3
+    when 0x409
+      4
+    else
+      BIFF_VERSIONS.fetch(@version) { raise "Unkown BIFF_VERSION '#@version'" }
+    end
+  end
+  def date_base
+    @date_base ||= DateTime.new 1899, 12, 31
+  end
+  def shared_string idx
+    @sst[idx.to_i].content
+  end
+  def sst_size
+    @sst.size
+  end
+  def uninspect_variables
+    super.push '@sst', '@offsets', '@changes'
+  end
+  def version_string
+    client VERSION_STRINGS.fetch(@version, "Unknown"), 'UTF-8'
+  end
+end
+  end
+end

data/lib/spreadsheet/excel/worksheet.rb

@@ -0,0 +1,100 @@
+require 'spreadsheet/excel/offset'
+require 'spreadsheet/excel/row'
+require 'spreadsheet/worksheet'
+
+module Spreadsheet
+  module Excel
+##
+# Excel-specific Worksheet methods. These are mostly pertinent to the Excel
+# reader, and to recording changes to the Worksheet. You should have no reason
+# to use any of these.
+class Worksheet < Spreadsheet::Worksheet
+  include Spreadsheet::Excel::Offset
+  offset :dimensions
+  attr_reader :offset, :ole, :links, :guts
+  def initialize opts = {}
+    @row_addresses = nil
+    super
+    @offset, @ole, @reader = opts[:offset], opts[:ole], opts[:reader]
+    @dimensions = nil
+    @links = {}
+    @guts = {}
+  end
+  def add_link row, column, link
+    @links.store [row, column], link
+  end
+  def column idx
+    ensure_rows_read
+    super
+  end
+  def date_base
+    @workbook.date_base
+  end
+  def each *args
+    ensure_rows_read
+    super
+  end
+  def ensure_rows_read
+    return if @row_addresses
+    @dimensions = nil
+    @row_addresses = []
+    @reader.read_worksheet self, @offset if @reader
+  end
+  def row idx
+    @rows[idx] or begin
+      ensure_rows_read
+      if addr = @row_addresses[idx]
+        row = @reader.read_row self, addr
+        [:default_format, :height, :outline_level, :hidden, ].each do |key|
+          row.send "unupdated_#{key}=", addr[key]
+        end
+        row.worksheet = self
+        row
+      else
+        Row.new self, idx
+      end
+    end
+  end
+  def row_updated idx, row
+    res = super
+    @workbook.changes.store self, true
+    @workbook.changes.store :boundsheets, true
+    @changes.store idx, true
+    @changes.store :dimensions, true
+    res
+  end
+  def set_row_address idx, opts
+    @offsets.store idx, opts[:row_block]
+    @row_addresses[idx] = opts
+  end
+  def shared_string idx
+    @workbook.shared_string idx
+  end
+  private
+  ## premature optimization?
+  def have_set_dimensions value, pos, len
+    if @row_addresses.size < row_count
+      @row_addresses.concat Array.new(row_count - @row_addresses.size)
+    end
+  end
+  def recalculate_dimensions
+    ensure_rows_read
+    shorten @rows
+    @dimensions = []
+    @dimensions[0] = [ index_of_first(@rows),
+                       index_of_first(@row_addresses) ].compact.min || 0
+    @dimensions[1] = [ @rows.size, @row_addresses.size ].compact.max || 0
+    compact = @rows.compact
+    first_rows = compact.collect do |row| row.first_used end.compact.min
+    first_addrs = @row_addresses.compact.collect do |addr|
+      addr[:first_used] end.min
+    @dimensions[2] = [ first_rows, first_addrs ].compact.min || 0
+    last_rows = compact.collect do |row| row.first_unused end.max
+    last_addrs = @row_addresses.compact.collect do |addr|
+      addr[:first_unused] end.max
+    @dimensions[3] = [last_rows, last_addrs].compact.max || 0
+    @dimensions
+  end
+end
+  end
+end