keeguon-spreadsheet 0.9.3

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,115 @@
+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, :notes
+  def initialize opts = {}
+    @row_addresses = nil
+    super
+    @offset, @ole, @reader = opts[:offset], opts[:ole], opts[:reader]
+    @dimensions = nil
+    @links = {}
+    @guts = {}
+    @notes = {}
+  end
+  def add_link row, column, link
+    @links.store [row, column], link
+  end
+  def add_note row, column, note
+    @notes.store [row, column], note
+  end
+  def column idx
+    ensure_rows_read
+    super
+  end
+  def date_base
+    @workbook.date_base
+  end
+  def margins
+    ensure_rows_read
+    super
+  end
+  def pagesetup
+    ensure_rows_read
+    super
+  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 rows
+    self.to_a
+  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

data/lib/spreadsheet/excel/writer.rb

@@ -0,0 +1 @@
+require 'spreadsheet/excel/writer/workbook'

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

@@ -0,0 +1,75 @@
+require 'spreadsheet/encodings'
+
+module Spreadsheet
+  module Excel
+    module Writer
+##
+# This Module collects writer methods such as unicode_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::Encodings
+  ##
+  # Check whether the string _data_ can be compressed (i.e. every second byte
+  # is a Null-byte) and perform compression.
+  # Returns the data and compression_status (0/1)
+  def compress_unicode_string data
+    compressed = internal('')
+    expect_null = false
+    data.each_byte do |byte|
+      if expect_null
+        if byte != 0
+          return [data, 1] # 1 => Data consists of wide Chars
+        end
+        expect_null = false
+      else
+        compressed << byte
+        expect_null = true
+      end
+    end
+    [compressed, 0] # 0 => Data consists of compressed Chars
+  end
+  ##
+  # Encode _string_ into a Biff8 Unicode String. Header and body are encoded
+  # separately by #_unicode_string. This method simply combines the two.
+  def unicode_string string, count_length=1
+    header, data, _ = _unicode_string string, count_length
+    header << data
+  end
+  @@bytesize = RUBY_VERSION >= '1.9' ? :bytesize : :size
+  ##
+  # Encode _string_ into a Biff8 Unicode String Header and Body.
+  def _unicode_string string, count_length=1
+    data = internal string
+    size = data.send(@@bytesize) / 2
+    fmt = count_length == 1 ? 'C2' : 'vC'
+    data, wide = compress_unicode_string data
+    opts = wide
+    header = [
+      size, # Length of the string (character count, ln)
+      opts, # 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
+      #0x00,# (optional, only if richtext=1) Number of Rich-Text
+            #                                formatting runs (rt)
+      #0x00,# (optional, only if phonetic=1) Size of Asian phonetic
+            #                                settings block (in bytes, sz)
+    ].pack fmt
+    data << '' # (optional, only if richtext=1)
+               # List of rt formatting runs (➜ 3.2)
+    data << '' # (optional, only if phonetic=1)
+               # Asian Phonetic Settings Block (➜ 3.4.2)
+    [header, data, wide]
+  end
+end
+    end
+  end
+end

data/lib/spreadsheet/excel/writer/format.rb

@@ -0,0 +1,264 @@
+require 'delegate'
+require 'spreadsheet/format'
+require 'spreadsheet/excel/internals'
+
+module Spreadsheet
+  module Excel
+    module Writer
+##
+# This class encapsulates everything that is needed to write an XF record.
+class Format < DelegateClass Spreadsheet::Format
+  include Spreadsheet::Excel::Internals
+  def Format.boolean *args
+    args.each do |key|
+      define_method key do
+        @format.send("#{key}?") ? 1 : 0
+      end
+    end
+  end
+  def Format.color key, default
+    define_method key do
+      color_code(@format.send(key) || default)
+    end
+  end
+  def Format.line_style key, default
+    define_method key do
+      style_code(@format.send(key) || default)
+    end
+  end
+  boolean :hidden, :locked, :merge_range, :shrink, :text_justlast, :text_wrap,
+          :cross_down, :cross_up
+	line_style	:left, 			 :none
+	line_style	:right,			 :none
+	line_style	:top, 			 :none
+	line_style	:bottom,		 :none
+  color :left_color,       :black
+  color :right_color,      :black
+  color :top_color,        :black
+  color :bottom_color,     :black
+  color :diagonal_color,   :black
+  color :pattern_fg_color, :pattern_bg
+  color :pattern_bg_color, :pattern_bg
+  attr_reader :format
+  def initialize writer, workbook, format=workbook.default_format, opts={}
+    @opts = { :type => :format }.merge opts
+    @format = format
+    @writer = writer
+    @workbook = workbook
+    super format
+  end
+  def color_code color
+    SEDOC_ROLOC[color]
+  end
+  def style_code style
+    SELYTS_ENIL_REDROB_FX[style]
+  end
+  def font_index
+    @writer.font_index @workbook, font.key
+  end
+  def horizontal_align
+    XF_H_ALIGN.fetch @format.horizontal_align, 0
+  end
+  def num_format
+    @writer.number_format_index @workbook, @format.number_format
+  end
+  def text_direction
+    XF_TEXT_DIRECTION.fetch @format.text_direction, 0
+  end
+  def vertical_align
+    XF_V_ALIGN.fetch @format.vertical_align, 2
+  end
+  def write_op writer, op, *args
+    data = args.join
+    writer.write [op,data.size].pack("v2")
+    writer.write data
+  end
+  def write_xf writer, type=@opts[:type]
+    xf_type = xf_type_prot type
+    data = [
+      font_index,   # Index to FONT record (➜ 6.43)
+      num_format,   # Index to FORMAT record (➜ 6.45)
+      xf_type,      #  Bit  Mask    Contents
+                    #  2-0  0x0007  XF_TYPE_PROT – XF type, cell protection
+                    #               Bit  Mask  Contents
+                    #                 0  0x01  1 = Cell is locked
+                    #                 1  0x02  1 = Formula is hidden
+                    #                 2  0x04  0 = Cell XF; 1 = Style XF
+                    # 15-4  0xfff0  Index to parent style XF
+                    #               (always 0xfff in style XFs)
+      xf_align,     #  Bit  Mask    Contents
+                    #  2-0  0x07    XF_HOR_ALIGN – Horizontal alignment
+                    #               Value  Horizontal alignment
+                    #               0x00   General
+                    #               0x01   Left
+                    #               0x02   Centred
+                    #               0x03   Right
+                    #               0x04   Filled
+                    #               0x05   Justified (BIFF4-BIFF8X)
+                    #               0x06   Centred across selection
+                    #                      (BIFF4-BIFF8X)
+                    #               0x07   Distributed (BIFF8X)
+                    #    3  0x08    1 = Text is wrapped at right border
+                    #  6-4  0x70    XF_VERT_ALIGN – Vertical alignment
+                    #               Value  Vertical alignment
+                    #               0x00   Top
+                    #               0x01   Centred
+                    #               0x02   Bottom
+                    #               0x03   Justified (BIFF5-BIFF8X)
+                    #               0x04   Distributed (BIFF8X)
+      xf_rotation,  # XF_ROTATION:  Text rotation angle
+                    #  Value  Text rotation
+                    #      0  Not rotated
+                    #   1-90  1 to 90 degrees counterclockwise
+                    # 91-180  1 to 90 degrees clockwise
+                    #    255  Letters are stacked top-to-bottom,
+                    #         but not rotated
+      xf_indent,    #  Bit  Mask  Contents
+                    #  3-0  0x0f  Indent level
+                    #    4  0x10  1 = Shrink content to fit into cell
+                    #    5  0x40  1 = Merge Range (djberger)
+                    #  7-6  0xc0  Text direction (BIFF8X only)
+                    #             0 = According to context
+                    #             1 = Left-to-right
+                    #             2 = Right-to-left
+      xf_used_attr, #  Bit  Mask  Contents
+                    #  7-2  0xfc  XF_USED_ATTRIB – Used attributes
+                    #             Each bit describes the validity of a
+                    #             specific group of attributes. In cell XFs
+                    #             a cleared bit means the attributes of the
+                    #             parent style XF are used (but only if the
+                    #             attributes are valid there), a set bit
+                    #             means the attributes of this XF are used.
+                    #             In style XFs a cleared bit means the
+                    #             attribute setting is valid, a set bit
+                    #             means the attribute should be ignored.
+                    #             Bit  Mask  Contents
+                    #               0  0x01  Flag for number format
+                    #               1  0x02  Flag for font
+                    #               2  0x04  Flag for horizontal and
+                    #                        vertical alignment, text wrap,
+                    #                        indentation, orientation,
+                    #                        rotation, and text direction
+                    #               3  0x08  Flag for border lines
+                    #               4  0x10  Flag for background area style
+                    #               5  0x20  Flag for cell protection (cell
+                    #                        locked and formula hidden)
+      xf_borders,   # Cell border lines and background area:
+                    #   Bit  Mask        Contents
+                    #  3- 0  0x0000000f  Left line style (➜ 3.10)
+                    #  7- 4  0x000000f0  Right line style (➜ 3.10)
+                    # 11- 8  0x00000f00  Top line style (➜ 3.10)
+                    # 15-12  0x0000f000  Bottom line style (➜ 3.10)
+                    # 22-16  0x007f0000  Colour index (➜ 6.70)
+                    #                    for left line colour
+                    # 29-23  0x3f800000  Colour index (➜ 6.70)
+                    #                    for right line colour
+                    #    30  0x40000000  1 = Diagonal line
+                    #                    from top left to right bottom
+                    #    31  0x80000000  1 = Diagonal line
+                    #                    from bottom left to right top
+      xf_brdcolors, #   Bit  Mask        Contents
+                    #  6- 0  0x0000007f  Colour index (➜ 6.70)
+                    #                    for top line colour
+                    # 13- 7  0x00003f80  Colour index (➜ 6.70)
+                    #                    for bottom line colour
+                    # 20-14  0x001fc000  Colour index (➜ 6.70)
+                    #                    for diagonal line colour
+                    # 24-21  0x01e00000  Diagonal line style (➜ 3.10)
+                    # 31-26  0xfc000000  Fill pattern (➜ 3.11)
+      xf_pattern    #   Bit  Mask        Contents
+                    #   6-0  0x007f      Colour index (➜ 6.70)
+                    #                    for pattern colour
+                    #  13-7  0x3f80      Colour index (➜ 6.70)
+                    #                    for pattern background
+    ]
+    write_op writer, 0x00e0, data.pack(binfmt(:xf))
+  end
+  def xf_align
+    align = horizontal_align
+    align |= text_wrap      << 3
+    align |= vertical_align << 4
+    align |= text_justlast  << 7
+    align
+  end
+  def xf_borders
+    border  = left
+    border |= right       <<  4
+    border |= top         <<  8
+    border |= bottom      << 12
+    border |= left_color  << 16
+    border |= right_color << 23
+    border |= cross_down  << 30
+    border |= cross_up    << 31
+    border
+  end
+  def xf_brdcolors
+    border  = top_color
+    border |= bottom_color   << 7
+    border |= diagonal_color << 14
+    border |= pattern        << 26
+    border
+  end
+  def xf_indent
+    indent  = indent_level & 0x0f
+    indent |= shrink         << 4
+    indent |= merge_range    << 5
+    indent |= text_direction << 6
+    indent
+  end
+  def xf_pattern
+    ptrn  = pattern_fg_color
+    ptrn |= pattern_bg_color << 7
+    ptrn
+  end
+  def xf_rotation
+    rot = @format.rotation
+    if @format.rotation_stacked?
+      rot = 255
+    elsif rot >= -90 or rotation <= 90
+      rot = -rot + 90 if rot < 0
+    else
+      warn "rotation outside -90..90; rotation set to 0"
+      rot = 0
+    end
+    rot
+  end
+  def xf_type_prot type
+    type = type.to_s.downcase == 'style' ? 0xfff4 : 0x0000
+    type |= locked
+    type |= hidden << 1
+    type
+  end
+  def xf_used_attr
+    atr_num = num_format & 1
+    atr_fnt = font_index & 1
+    atr_fnt = 1 unless @format.font.color == :text
+    atr_alc = 0
+    if horizontal_align != 0 \
+      || vertical_align != 2 \
+      || indent_level > 0 \
+      || shrink? || merge_range? || text_wrap?
+    then
+      atr_alc = 1
+    end
+    atr_bdr = 1 
+    atr_pat = 0
+    if  @format.pattern_fg_color != :border \
+      || @format.pattern_bg_color != :pattern_bg \
+      || pattern != 0x00
+    then
+      atr_pat = 1
+    end
+    atr_prot = hidden? || locked? ? 1 : 0
+    attrs  = atr_num
+    attrs |= atr_fnt << 1
+    attrs |= atr_alc << 2
+    attrs |= atr_bdr << 3
+    attrs |= atr_pat << 4
+    attrs |= atr_prot << 5
+    attrs << 2
+  end
+end
+    end
+  end
+end