keeguon-spreadsheet 0.9.3

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

@@ -0,0 +1,42 @@
+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
+
+  def read_range_address_list work, len
+    # Cell range address, BIFF2-BIFF5:
+    # Offset  Size  Contents
+    # 0       2     Index to first row
+    # 2       2     Index to last row
+    # 4       1     Index to first column
+    # 5       1     Index to last column
+    #
+    offset = 0, results = []
+    return results if len < 2
+    count = work[0..1].unpack('v').first
+    offset = 2
+    count.times do |i|
+      results << work[offset...offset+6].unpack('v2c2')
+      offset += 6
+    end
+    results
+  end
+
+end
+    end
+  end
+end

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

@@ -0,0 +1,231 @@
+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 appends the available remainder (decompressed if necessary) to
+  # the incomplete string.
+  def unpack_string work
+    opts, _ = work.unpack 'C'
+    wide = opts & 1
+    string = work[1, -1]
+    if wide == 0
+      string = wide string
+    end
+  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
+    elsif !@incomplete_skip.nil?
+      pos =  @incomplete_skip
+      @incomplete_skip = nil
+    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)
+    _, @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, _, _, available, owing, _ = read_string_header work, count_length
+    string, _ = 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]
+    widened_data = wide ? data : wide(data)
+    [widened_data, 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
+
+  def read_range_address_list work, len
+    # Cell range address, BIFF8:
+    # Offset  Size  Contents
+    # 0       2     Index to first row
+    # 2       2     Index to last row
+    # 4       2     Index to first column
+    # 6       2     Index to last column
+    # ! In several cases, BIFF8 still writes the BIFF2-BIFF5 format of a cell range address
+    # (using 8-bit values for the column indexes). This will be mentioned at the respective place.
+    #
+    offset = 0, results = []
+    return results if len < 2
+    count = work[0..1].unpack('v').first
+    offset = 2
+    count.times do |i|
+      results << work[offset...offset+8].unpack('v4')
+      offset += 8
+    end
+    results
+  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
+        if pos > worksize
+          @incomplete_skip = pos - worksize
+        end
+      end
+    end
+  end
+end
+    end
+  end
+end

data/lib/spreadsheet/excel/rgb.rb

@@ -0,0 +1,122 @@
+# A quick and dirty class for converting color palette values to RGB values.
+# The values below have the form 0xRRGGBB, where RR is the red level, GG the 
+# green level, and BB the blue level. Each level is a value from 0 to 255,
+# just as one would expect in HTML markup.
+
+# Future directions may include:
+#  - support for mapping RGB values to "best fit" palette values
+#
+# by Dan Caugherty https://github.com/dancaugherty/spreadsheet/compare/master...rgb
+
+module Spreadsheet
+  module Excel
+    class Rgb
+      attr_accessor :r, :g, :b
+
+      @@RGB_MAP = {
+        :xls_color_0     => 0x000000,
+        :xls_color_1     => 0xffffff,
+        :xls_color_2     => 0xff0000,
+        :xls_color_3     => 0x00ff00,
+        :xls_color_4     => 0x0000ff,
+        :xls_color_5     => 0xffff00,
+        :xls_color_6     => 0xff00ff,
+        :xls_color_7     => 0x00ffff,
+        :xls_color_8     => 0x800000,
+        :xls_color_9     => 0x008000,
+        :xls_color_10    => 0x008000,
+        :xls_color_11    => 0x000080,
+        :xls_color_12    => 0x808080,
+        :xls_color_13    => 0x008080,
+        :xls_color_14    => 0xc0c0c0,
+        :xls_color_15    => 0x808080,
+        :xls_color_16    => 0x9999ff,
+        :xls_color_17    => 0x993366,
+        :xls_color_18    => 0xffffcc,
+        :xls_color_19    => 0xccffff,
+        :xls_color_20    => 0x660066,
+        :xls_color_21    => 0xff8080,
+        :xls_color_22    => 0x0066cc,
+        :xls_color_23    => 0xccccff,
+        :xls_color_24    => 0x000080,
+        :xls_color_25    => 0xff00ff,
+        :xls_color_26    => 0xffff00,
+        :xls_color_27    => 0x00ffff,
+        :xls_color_28    => 0x800080,
+        :xls_color_29    => 0x800000,
+        :xls_color_30    => 0x008080,
+        :xls_color_31    => 0x0000ff,
+        :xls_color_32    => 0x00ccff,
+        :xls_color_33    => 0xccffff,
+        :xls_color_34    => 0xccffcc,
+        :xls_color_35    => 0xffff99,
+        :xls_color_36    => 0x99ccff,
+        :xls_color_37    => 0xff99cc,
+        :xls_color_38    => 0xcc99ff,
+        :xls_color_39    => 0xffcc99,
+        :xls_color_40    => 0x3366ff,
+        :xls_color_41    => 0x33cccc,
+        :xls_color_42    => 0x99cc00,
+        :xls_color_43    => 0xffcc00,
+        :xls_color_44    => 0xff9900,
+        :xls_color_45    => 0xff6600,
+        :xls_color_46    => 0x666699,
+        :xls_color_47    => 0x969696,
+        :xls_color_48    => 0x003366,
+        :xls_color_49    => 0x339966,
+        :xls_color_50    => 0x003300,
+        :xls_color_51    => 0x333300,
+        :xls_color_52    => 0x993300,
+        :xls_color_53    => 0x993366,
+        :xls_color_54    => 0x333399,
+        :xls_color_55    => 0x333333,
+        :builtin_black   => 0x000000,
+        :builtin_white   => 0xffffff,
+        :builtin_red     => 0xff0000,
+        :builtin_green   => 0x00ff00,
+        :builtin_blue    => 0x0000ff,
+        :builtin_yellow  => 0xffff00,
+        :builtin_magenta => 0xff00ff,
+        :builtin_cyan    => 0x00ffff,
+        :aqua            => 0x00ffff,
+        :black           => 0x000000,
+        :blue            => 0x0000ff,
+        :cyan            => 0x00ffff,
+        :brown           => 0x800000,
+        :fuchsia         => 0xff00ff,
+        :gray            => 0x808080,
+        :grey            => 0x808080,
+        :green           => 0x008000,
+        :lime            => 0x00ff00,
+        :magenta         => 0xff00ff,
+        :navy            => 0x000080,
+        :orange          => 0xff9900,
+        :purple          => 0x800080,
+        :red             => 0xff0000,
+        :silver          => 0xc0c0c0,
+        :white           => 0xffffff,
+        :yellow          => 0xffff00
+      }
+
+      def self.to_rgb color_symbol
+        col = @@RGB_MAP[color_symbol]
+        return Rgb.new(col >> 16, (col & 0xff00) >> 8, col & 0xff) if col
+        nil
+      end
+
+      def initialize(r,g,b)
+         @r = r & 0xff
+         @g = g & 0xff
+         @b = b & 0xff
+      end
+
+      def to_i
+         (r * (256 * 256)) + (g * 256) + b
+      end
+
+      def as_hex
+         to_i.to_s(16)
+      end
+    end
+  end
+end

data/lib/spreadsheet/excel/row.rb

@@ -0,0 +1,98 @@
+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
+    size.times do |idx|
+      yield 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
+  ##
+  # Returns data as an array. If a cell is formatted as a Date or DateTime, the
+  # decoded Date or DateTime value is returned.
+  def to_a
+    self[0...length]
+  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.to_f % 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