WriteExcel 0.2.0

data/lib/WriteExcel/olewriter.rb

@@ -0,0 +1,322 @@
+###############################################################################
+#
+# BIFFwriter - An abstract base class for Excel workbooks and worksheets.
+#
+#
+# Used in conjunction with Spreadsheet::WriteExcel
+#
+# Copyright 2000-2008, John McNamara, jmcnamara@cpan.org
+#
+# original written in Perl by John McNamara
+# converted to Ruby by Hideo Nakamura, cxn03651@msj.biglobe.ne.jp
+#
+class MaxSizeError < StandardError; end
+
+class OLEWriter
+
+  # Not meant for public consumption
+  MaxSize    = 7087104 # Use Spreadsheet::WriteExcel::Big to exceed this
+  BlockSize  = 4096
+  BlockDiv   = 512
+  ListBlocks = 127
+
+  attr_reader :biff_size, :book_size, :big_blocks, :list_blocks
+  attr_reader :root_start, :size_allowed
+  attr_accessor :biff_only, :internal_fh
+
+  # Accept an IO or IO-like object or a filename (as a String)
+  def initialize(arg)
+    if arg.kind_of?(String)
+      @io = File.open(arg, "w")
+    else
+      @io = arg
+    end
+    @io.binmode
+
+    @filehandle    = ""
+    @fileclosed    = false
+    @internal_fh   = 0
+    @biff_only     = 0
+    @size_allowed  = true
+    @biff_size     = 0
+    @book_size     = 0
+    @big_blocks    = 0
+    @list_blocks   = 0
+    @root_start    = 0
+    @block_count   = 4
+  end
+
+  # Imitate IO.open behavior
+
+  ###############################################################################
+  #
+  # _initialize()
+  #
+  # Create a new filehandle or use the provided filehandle.
+  #
+  def _initialize
+    olefile = @olefilename
+
+    # If the filename is a reference it is assumed that it is a valid
+    # filehandle, if not we create a filehandle.
+    #
+
+    # Create a new file, open for writing
+    fh = open(olefile, "wb")
+
+    # Workbook.pm also checks this but something may have happened since
+    # then.
+    raise "Can't open olefile. It may be in use or protected.\n" unless fh
+
+    @internal_fh = 1
+
+    # Store filehandle
+    @filehandle = fh
+  end
+
+  def self.open(arg)
+    if block_given?
+      ole = self.new(arg)
+      result = yield(ole)
+      ole.close
+      result
+    else
+      self.new(arg)
+    end
+  end
+
+  ###############################################################################
+  #
+  # write($data)
+  #
+  # Write BIFF data to OLE file.
+  #
+  def write(data)
+#print "ole write\n"
+#print data.unpack('C*').map! {|c| sprintf("%02X", c) }.join(' ') + "\n\n"
+    @io.write(data)
+  end
+#  def print(data)
+#    @io.print(data)
+#  end
+
+  ###############################################################################
+  #
+  # set_size($biffsize)
+  #
+  # Set the size of the data to be written to the OLE stream
+  #
+  #   $big_blocks = (109 depot block x (128 -1 marker word)
+  #                 - (1 x end words)) = 13842
+  #   $maxsize    = $big_blocks * 512 bytes = 7087104
+  #
+  def set_size(size = BlockSize)
+    if size > MaxSize
+      return @size_allowed = false
+    end
+
+    @biff_size = size
+
+    if biff_size > BlockSize
+      @book_size = size
+    else
+      @book_size = BlockSize
+    end
+
+    @size_allowed = true
+  end
+
+  ###############################################################################
+  #
+  # _calculate_sizes()
+  #
+  # Calculate various sizes needed for the OLE stream
+  #
+  def calculate_sizes
+    @big_blocks  = (@book_size.to_f/BlockDiv.to_f).ceil
+    @list_blocks = (@big_blocks / ListBlocks) + 1
+    @root_start  = @big_blocks
+  end
+
+  ###############################################################################
+  #
+  # close()
+  #
+  # Write root entry, big block list and close the filehandle.
+  # This routine is used to explicitly close the open filehandle without
+  # having to wait for DESTROY.
+  #
+  def close
+    if @size_allowed == true
+#print "write_padding"
+      write_padding          if @biff_only == 0
+#print "write_property_storage"
+      write_property_storage if @biff_only == 0
+#print "write_big_block_depot"
+      write_big_block_depot  if @biff_only == 0
+    end
+    @io.close
+  end
+
+  ###############################################################################
+  #
+  # write_header()
+  #
+  # Write OLE header block.
+  #
+  def write_header
+    return if @biff_only == 1
+    calculate_sizes
+    root_start = @root_start
+    num_lists  = @list_blocks
+
+    id              = [0xD0CF11E0, 0xA1B11AE1].pack("NN")
+    unknown1        = [0x00, 0x00, 0x00, 0x00].pack("VVVV")
+    unknown2        = [0x3E, 0x03].pack("vv")
+    unknown3        = [-2].pack("v")
+    unknown4        = [0x09].pack("v")
+    unknown5        = [0x06, 0x00, 0x00].pack("VVV")
+    num_bbd_blocks  = [num_lists].pack("V")
+    root_startblock = [root_start].pack("V")
+    unknown6        = [0x00, 0x1000].pack("VV")
+    sbd_startblock  = [-2].pack("V")
+    unknown7        = [0x00, -2 ,0x00].pack("VVV")
+
+    write(id)
+    write(unknown1)
+    write(unknown2)
+    write(unknown3)
+    write(unknown4)
+    write(unknown5)
+    write(num_bbd_blocks)
+    write(root_startblock)
+    write(unknown6)
+    write(sbd_startblock)
+    write(unknown7)
+
+    unused = [-1].pack("V")
+
+    1.upto(num_lists){
+      root_start += 1
+      write([root_start].pack("V"))
+    }
+
+    num_lists.upto(108){
+      write(unused)
+    }
+  end
+
+  ###############################################################################
+  #
+  # _write_big_block_depot()
+  #
+  # Write big block depot.
+  #
+  def write_big_block_depot
+    num_blocks   = @big_blocks
+    num_lists    = @list_blocks
+    total_blocks = num_lists * 128
+    used_blocks  = num_blocks + num_lists + 2
+
+    marker          = [-3].pack("V")
+    end_of_chain    = [-2].pack("V")
+    unused          = [-1].pack("V")
+
+    1.upto(num_blocks-1){|n|
+      write([n].pack("V"))
+    }
+
+    write end_of_chain
+    write end_of_chain
+
+    1.upto(num_lists){ write(marker) }
+
+    used_blocks.upto(total_blocks){ write(unused) }
+
+  end
+
+  ###############################################################################
+  #
+  # _write_property_storage()
+  #
+  # Write property storage. TODO: add summary sheets
+  #
+  def write_property_storage
+
+    #########  name         type  dir start size
+    write_pps('Root Entry', 0x05,  1,   -2, 0x00)
+    write_pps('Workbook',   0x02, -1, 0x00, @book_size)
+    write_pps("",           0x00, -1, 0x00, 0x0000)
+    write_pps("",           0x00, -1, 0x00, 0x0000)
+  end
+
+  ###############################################################################
+  #
+  # _write_pps()
+  #
+  # Write property sheet in property storage
+  #
+  def write_pps(name, type, dir, start, size)
+    length = 0
+    ord_name = []
+    unless name.empty?
+      name = name + "\0"
+      ord_name = name.unpack("c*")
+      length = name.length * 2
+    end
+
+    rawname        = ord_name.pack("v*")
+    zero           = [0].pack("C")
+
+    pps_sizeofname = [length].pack("v")   #0x40
+    pps_type       = [type].pack("v")     #0x42
+    pps_prev       = [-1].pack("V")       #0x44
+    pps_next       = [-1].pack("V")       #0x48
+    pps_dir        = [dir].pack("V")      #0x4c
+
+    unknown = [0].pack("V")
+
+    pps_ts1s       = [0].pack("V")        #0x64
+    pps_ts1d       = [0].pack("V")        #0x68
+    pps_ts2s       = [0].pack("V")        #0x6c
+    pps_ts2d       = [0].pack("V")        #0x70
+    pps_sb         = [start].pack("V")    #0x74
+    pps_size       = [size].pack("V")     #0x78
+
+    write(rawname)
+    for n in 1..64-length
+      write(zero)
+    end
+    write(pps_sizeofname)
+    write(pps_type)
+    write(pps_prev)
+    write(pps_next)
+    write(pps_dir)
+    for n in 1..5
+      write(unknown)
+    end
+    write(pps_ts1s)
+    write(pps_ts1d)
+    write(pps_ts2s)
+    write(pps_ts2d)
+    write(pps_sb)
+    write(pps_size)
+    write(unknown)
+  end
+
+  ###############################################################################
+  #
+  # _write_padding()
+  #
+  # Pad the end of the file
+  #
+  def write_padding
+    min_size = 512
+    min_size = BlockSize if @biff_size < BlockSize
+
+    if @biff_size % min_size != 0
+      padding = min_size - (@biff_size % min_size)
+      write("\0" * padding)
+    end
+  end
+end

data/lib/WriteExcel/properties.rb

@@ -0,0 +1,250 @@
+###############################################################################
+#
+# Properties - A module for creating Excel property sets.
+#
+#
+# Used in conjunction with Spreadsheet::WriteExcel
+#
+# Copyright 2000-2008, John McNamara.
+#
+# original written in Perl by John McNamara
+# converted to Ruby by Hideo Nakamura, cxn03651@msj.biglobe.ne.jp
+#
+
+#require 'date'
+
+###############################################################################
+#
+# create_summary_property_set().
+#
+# Create the SummaryInformation property set. This is mainly used for the
+# Title, Subject, Author, Keywords, Comments, Last author keywords and the
+# creation date.
+#
+def create_summary_property_set(properties)
+    byte_order          = [0xFFFE].pack('v')
+    version             = [0x0000].pack('v')
+    system_id           = [0x00020105].pack('V')
+    class_id            = ['00000000000000000000000000000000'].pack('H*')
+    num_property_sets   = [0x0001].pack('V')
+    format_id           = ['E0859FF2F94F6810AB9108002B27B3D9'].pack('H*')
+    offset              = [0x0030].pack('V')
+    num_property        = [properties.size].pack('V')
+    property_offsets    = ''
+
+    # Create the property set data block and calculate the offsets into it.
+    property_data, offsets = pack_property_data(properties)
+
+    # Create the property type and offsets based on the previous calculation.
+    0.upto(properties.size-1) do |i|
+      property_offsets = property_offsets + [properties[i][0], offsets[i]].pack('VV')
+    end
+
+    # Size of size (4 bytes) +  num_property (4 bytes) + the data structures.
+    size = 8 + (property_offsets).length + property_data.length
+    size = [size].pack('V')
+    
+    return  byte_order         +
+            version            +
+            system_id          +
+            class_id           +
+            num_property_sets  +
+            format_id          +
+            offset             +
+            size               +
+            num_property       +
+            property_offsets   +
+            property_data
+end
+
+
+###############################################################################
+#
+# Create the DocSummaryInformation property set. This is mainly used for the
+# Manager, Company and Category keywords.
+#
+# The DocSummary also contains a stream for user defined properties. However
+# this is a little arcane and probably not worth the implementation effort.
+#
+def create_doc_summary_property_set(properties)
+    byte_order          = [0xFFFE].pack('v')
+    version             = [0x0000].pack('v')
+    system_id           = [0x00020105].pack('V')
+    class_id            = ['00000000000000000000000000000000'].pack('H*')
+    num_property_sets   = [0x0002].pack('V')
+    
+    format_id_0         = ['02D5CDD59C2E1B10939708002B2CF9AE'].pack('H*')
+    format_id_1         = ['05D5CDD59C2E1B10939708002B2CF9AE'].pack('H*')
+    offset_0            = [0x0044].pack('V')
+    num_property_0      = [properties.size].pack('V')
+    property_offsets_0  = ''
+
+    # Create the property set data block and calculate the offsets into it.
+    property_data_0, offsets = pack_property_data(properties)
+
+    # Create the property type and offsets based on the previous calculation.
+    0.upto(properties.size-1) do |i|
+      property_offsets_0 = property_offsets_0 + [properties[i][0], offsets[i]].pack('VV')
+    end
+
+    # Size of size (4 bytes) +  num_property (4 bytes) + the data structures.
+    data_len = 8 + (property_offsets_0).length + property_data_0.length
+    size_0   = [data_len].pack('V')
+    
+    # The second property set offset is at the end of the first property set.
+    offset_1 = [0x0044 + data_len].pack('V')
+
+    # We will use a static property set stream rather than try to generate it.
+    property_data_1 = [%w(
+        98 00 00 00 03 00 00 00 00 00 00 00 20 00 00 00
+        01 00 00 00 36 00 00 00 02 00 00 00 3E 00 00 00
+        01 00 00 00 02 00 00 00 0A 00 00 00 5F 50 49 44
+        5F 47 55 49 44 00 02 00 00 00 E4 04 00 00 41 00
+        00 00 4E 00 00 00 7B 00 31 00 36 00 43 00 34 00
+        42 00 38 00 33 00 42 00 2D 00 39 00 36 00 35 00
+        46 00 2D 00 34 00 42 00 32 00 31 00 2D 00 39 00
+        30 00 33 00 44 00 2D 00 39 00 31 00 30 00 46 00
+        41 00 44 00 46 00 41 00 37 00 30 00 31 00 42 00
+        7D 00 00 00 00 00 00 00 2D 00 39 00 30 00 33 00
+    ).join('')].pack('H*')
+
+    return  byte_order         +
+            version            +
+            system_id          +
+            class_id           +
+            num_property_sets  +
+            format_id_0        +
+            offset_0           +
+            format_id_1        +
+            offset_1           +
+
+            size_0             +
+            num_property_0     +
+            property_offsets_0 +
+            property_data_0    +
+
+            property_data_1
+end
+
+
+###############################################################################
+#
+# _pack_property_data().
+#
+# Create a packed property set structure. Strings are null terminated and
+# padded to a 4 byte boundary. We also use this function to keep track of the
+# property offsets within the data structure. These offsets are used by the
+# calling functions. Currently we only need to handle 4 property types:
+# VT_I2, VT_LPSTR, VT_FILETIME.
+#
+def pack_property_data(properties, offset = 0)
+    packed_property     = ''
+    data                = ''
+    offsets             = []
+
+    # Get the strings codepage from the first property.
+    codepage = properties[0][2]
+
+    # The properties start after 8 bytes for size + num_properties + 8 bytes
+    # for each propety type/offset pair.
+    offset += 8 * (properties.size + 1)
+
+    properties.each do |property|
+      offsets.push(offset)
+
+      property_type = property[1]
+
+      if    property_type == 'VT_I2'
+        packed_property = pack_VT_I2(property[2])
+      elsif property_type == 'VT_LPSTR'
+        packed_property = pack_VT_LPSTR(property[2], codepage)
+      elsif property_type == 'VT_FILETIME'
+        packed_property = pack_VT_FILETIME(property[2])
+      else
+        raise "Unknown property type: '#{property_type}'\n"
+      end
+
+      offset += packed_property.length
+      data    = data + packed_property
+    end
+
+    return [data, offsets]
+end
+
+###############################################################################
+#
+# _pack_VT_I2().
+#
+# Pack an OLE property type: VT_I2, 16-bit signed integer.
+#
+def pack_VT_I2(value)
+    type    = 0x0002
+    data = [type, value].pack('VV')
+end
+
+###############################################################################
+#
+# _pack_VT_LPSTR().
+#
+# Pack an OLE property type: VT_LPSTR, String in the Codepage encoding.
+# The strings are null terminated and padded to a 4 byte boundary.
+#
+def pack_VT_LPSTR(str, codepage)
+    type        = 0x001E
+    string      = str + "\0"
+
+    if codepage == 0x04E4
+      # Latin1
+      byte_string = string
+      length      = byte_string.length
+    elsif codepage == 0xFDE9
+      # UTF-8
+      nonAscii = /[^!"#\$%&'\(\)\*\+,\-\.\/\:\;<=>\?@0-9A-Za-z_\[\\\]^` ~\0\n]/
+      if string =~ nonAscii
+        require 'jcode'
+        byte_string = string
+        length = byte_string.jlength
+      else
+        byte_string = string
+        length = byte_string.length
+      end
+    else
+      raise "Unknown codepage: codepage\n"
+    end
+
+    # Pack the data.
+    data = [type, length].pack('VV')
+    data = data + byte_string
+
+    # The packed data has to null padded to a 4 byte boundary.
+    if (extra = length % 4) != 0
+        data  = data + "\0" * (4 - extra)
+    end
+    return data
+end
+
+###############################################################################
+#
+# _pack_VT_FILETIME().
+#
+# Pack an OLE property type: VT_FILETIME.
+#
+def pack_VT_FILETIME(localtime)
+  type        = 0x0040
+  
+  epoch = DateTime.new(1601, 1, 1)
+
+  datetime = DateTime.new(
+                localtime.year,
+                localtime.mon,
+                localtime.mday,
+                localtime.hour,
+                localtime.min,
+                localtime.sec,
+                localtime.usec
+              )
+  bignum = (datetime - epoch) * 86400 * 1e7.to_i
+  high, low = bignum.divmod 1 << 32
+  
+  [type].pack('V') + [low, high].pack('V2')
+end