spreadsheet-excel 0.3.4

data/lib/spreadsheet/olewriter.rb

@@ -0,0 +1,178 @@
+# olewriter.rb
+#
+# This class should never be instantiated directly. The entire class, and all
+# its methods should be considered private.
+
+class MaxSizeError < StandardError; end
+
+class OLEWriter < IO
+
+   # Not meant for public consumption
+   MaxSize    = 7087104
+   BlockSize  = 4096
+   BlockDiv   = 512
+   ListBlocks = 127
+
+   attr_reader :biff_size, :book_size, :big_blocks, :list_blocks
+   attr_reader :root_start, :size_allowed
+
+   # Accept an IO object, a fileno, or a String
+   def initialize(arg, &block)
+      if arg.kind_of?(String)
+         super(File.open(arg, "w+").fileno, "w+", &block)
+      elsif arg.respond_to?(:fileno)
+         super(arg.fileno, "w+", &block)
+      else
+         super(arg, "w+", &block)
+      end
+      binmode
+
+      @biff_only     = false
+      @size_allowed  = true
+      @biff_size     = 0
+      @book_size     = 0
+      @big_blocks    = 0
+      @list_blocks   = 0
+      @root_start    = 0
+      @block_count   = 4
+   end
+
+   # 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)
+      raise MaxSizeError if size > MaxSize
+
+      @biff_size = size
+
+      if biff_size > BlockSize
+         @book_size = size
+      else
+         @book_size = BlockSize
+      end
+
+      @size_allowed = true
+   end
+
+   # 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
+
+   # Write root entry, big block list and close the filehandle.
+   def close
+      if @size_allowed == true
+         write_padding
+         write_property_storage
+         write_big_block_depot
+      end
+      super
+   end 
+
+   # Write the OLE header block
+   def write_header
+      return if @biff_only == true
+      calculate_sizes
+      root_start = @root_start
+
+      write([0xD0CF11E0, 0xA1B11AE1].pack("NN"))
+      write([0x00, 0x00, 0x00, 0x00].pack("VVVV"))
+      write([0x3E, 0x03, -2, 0x09].pack("vvvv"))
+      write([0x06, 0x00, 0x00].pack("VVV"))
+      write([@list_blocks, root_start].pack("VV"))
+      write([0x00, 0x1000,-2].pack("VVV"))
+      write([0x00, -2 ,0x00].pack("VVV"))
+
+      unused = [-1].pack("V")
+
+      1.upto(@list_blocks){
+         root_start += 1
+         write([root_start].pack("V"))
+      }
+
+      @list_blocks.upto(108){
+         write(unused)
+      }
+   end
+
+   # Write a big block depot
+   def write_big_block_depot
+      total_blocks = @list_blocks * 128
+      used_blocks  = @big_blocks + @list_blocks + 2
+      
+      marker = [-3].pack("V")
+      eoc    = [-2].pack("V")
+      unused = [-1].pack("V")
+
+      num_blocks = @big_blocks - 1
+
+      1.upto(num_blocks){|n|
+         write([n].pack("V"))
+      }
+
+      write eoc
+      write eoc
+
+      1.upto(@list_blocks){ write(marker) }
+
+      used_blocks.upto(total_blocks){ write(unused) }
+      
+   end
+
+   # Write property storage
+   def write_property_storage
+      write_pps('Root Entry', 0x05,  1,   -2, 0x00)
+      write_pps('Book',       0x02, -1, 0x00, @book_size)
+      write_pps("",           0x00, -1, 0x00, 0x0000)
+      write_pps("",           0x00, -1, 0x00, 0x0000)
+   end
+
+   # Write property sheet in property storage
+   def write_pps(name, type, dir, start, size)
+      length = 0
+      ord_name = []
+      unless name.empty? 
+         name += "\0"
+         ord_name = name.unpack("c*")
+         length = name.length * 2
+      end
+
+      zero = [0].pack("C")
+      unknown = [0].pack("V")
+      
+      write(ord_name.pack("v*"))
+
+      for n in 1..64-length
+         write(zero)
+      end
+
+      write([length,type,-1,-1,dir].pack("vvVVV"))
+
+      for n in 1..5
+         write(unknown)
+      end
+      
+      for n in 1..4
+         write([0].pack("V"))
+      end
+
+      write([start,size].pack("VV"))
+      write(unknown)
+   end
+
+   # 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/spreadsheet/workbook.rb

@@ -0,0 +1,279 @@
+class Workbook < BIFFWriter
+   BOF = 11
+   EOF = 4
+   SheetName = "Sheet"
+
+   attr_accessor :date_system
+   attr_reader :formats, :xf_index, :worksheets
+
+   def initialize(file)
+      super
+
+      @file       = file
+      @format     = Format.new
+
+      @active_sheet = 0
+      @first_sheet  = 0
+      @biffsize     = 0
+      @date_system  = 1900
+      @xf_index     = 16
+
+      @worksheets = []
+      @formats    = []
+
+      @url_format = add_format(:color=>"blue", :underline=>1)
+   end
+
+   def close
+      store_workbook
+   end
+
+   def add_format(*args)
+      if args[0].kind_of?(Hash)
+         f = Format.new(args[0], @xf_index)
+      elsif args[0].nil?
+         f = Format.new
+      else
+         raise TypeError unless args[0].kind_of?(Format)
+         f = args[0]
+         f.xf_index = @xf_index
+      end
+      @xf_index += 1
+      @formats.push(f)
+      return f
+   end
+
+   def add_worksheet(name=nil)
+      index = @worksheets.length
+
+      if name.nil?
+         name = SheetName + (index + 1).to_s
+      end
+      
+      args = [name,index, @active_sheet, @first_sheet, @url_format]
+      ws = Worksheet.new(*args)
+      @worksheets[index] = ws
+      return ws
+   end
+
+   def calc_sheet_offsets
+      offset = @datasize
+      @worksheets.each{ |sheet|
+         offset += BOF + sheet.name.length
+      }
+
+      offset += EOF
+
+      @worksheets.each{ |sheet|
+         sheet.offset = offset
+         offset += sheet.datasize
+      }
+
+      @biffsize = offset
+   end
+
+   def store_workbook
+      @worksheets.each{ |sheet|
+         sheet.close
+      }
+
+      store_bof(0x0005)
+      store_window1
+      store_date_system
+      store_all_fonts
+      store_all_num_formats
+      store_all_xfs
+      store_all_styles
+      calc_sheet_offsets
+
+      @worksheets.each{ |sheet|
+         store_boundsheet(sheet.name, sheet.offset)
+      }
+
+      store_eof
+      store_ole_file
+   end
+   
+   def store_ole_file
+      OLEWriter.open(@file){ |ole|
+         ole.set_size(@biffsize)
+         ole.write_header
+         ole.print(@data)
+         @worksheets.each{ |sheet|
+            ole.print(sheet.data)
+         }
+         ole.close # Added because of bug introduced in Ruby 1.8.3   
+      }
+   end
+
+   def store_window1
+      record    = 0x003D
+      length    = 0x0012
+
+      xWn       = 0x0000
+      yWn       = 0x0000
+      dxWn      = 0x25BC
+      dyWn      = 0x1572
+
+      grbit     = 0x0038
+      ctabsel   = 0x0001
+      wTabRatio = 0x0258
+
+      itabFirst = @first_sheet
+      itabCur   = @active_sheet
+
+      header = [record,length].pack("vv")
+      fields = [xWn,yWn,dxWn,dyWn,grbit,itabCur,itabFirst,ctabsel,wTabRatio]
+      data   = fields.pack("vvvvvvvvv")
+
+      append(header,data)
+   end
+
+   def store_all_fonts
+      font = @format.font_biff
+      for n in 1..5
+         append(font)
+      end
+
+      fonts = Hash.new(0)
+      index = 6
+      key = @format.font_key
+      fonts[key] = 0
+
+      @formats.each{ |format|
+         key = format.font_key
+         if fonts.has_key?(key)
+            format.font_index = fonts[key]
+         else
+            fonts[key] = index
+            format.font_index = index
+            index += 1
+            append(format.font_biff)
+         end
+      }
+   end
+
+   def store_xf(style)
+      name   = 0x00E0
+      length = 0x0010
+
+      ifnt      = 0x0000
+      ifmt      = 0x0000
+      align     = 0x0020
+      icv       = 0x20C0
+      fill      = 0x0000
+      brd_line  = 0x0000
+      brd_color = 0x0000
+
+      header = [name, length].pack("vv")
+      fields = [ifnt,ifmt,style,align,icv,fill,brd_line,brd_color]
+      data   = fields.pack("vvvvvvvv")
+
+      append(header, data);
+   end
+
+   def store_all_num_formats
+      index = 164
+
+      num_formats_hash = {}
+      num_formats_array = []
+
+      @formats.each{ |format|
+         num_format = format.num_format
+         next if num_format.kind_of?(Numeric)
+         if num_formats_hash.has_key?(num_format)
+            format.num_format = num_formats_hash[num_format]
+         else
+            num_formats_hash[num_format] = index
+            format.num_format = index
+            num_formats_array.push(num_format)
+            index += 1
+         end
+      }
+
+      index = 164
+      num_formats_array.each{ |num_format|
+         store_num_format(num_format,index)
+         index += 1
+      }
+   end
+
+   def store_all_xfs
+      xf = @format.xf_biff(0xFFF5)
+      for n in 1..15
+         append(xf)
+      end
+
+      xf = @format.xf_biff(0x0001)
+      append(xf)
+         
+      @formats.each{ |format|
+         xf = format.xf_biff(0x0001)
+         append(xf)
+      }
+   end
+
+   def store_style
+      record = 0x0293
+      length = 0x0004
+
+      ixfe    = 0x8000
+      builtin = 0x00
+      iLevel  = 0xff
+
+      header = [record, length].pack("vv")
+      data   = [ixfe, builtin, iLevel].pack("vCC")
+
+      append(header, data)
+   end
+
+   alias store_all_styles store_style
+
+   def store_boundsheet(sheet_name, offset)
+      name   = 0x0085
+      length = 0x07 + sheet_name.length
+
+      grbit = 0x0000
+      cch   = sheet_name.length
+
+      header = [name, length].pack("vv")
+      data   = [offset, grbit, cch].pack("VvC")
+
+      append(header, data, sheet_name)
+   end
+
+   def store_num_format(format, ifmt)
+      record = 0x041E
+      cch    = format.length
+      length = 0x03 + cch
+
+      header = [record, length].pack("vv")
+      data   = [ifmt, cch].pack("vC")
+
+      append(header, data, format)
+   end
+
+   def store_date_system
+      record = 0x0022
+      length = 0x0002
+      
+      f1904 = 0
+      f1904 = 1 if @date_system == 1904
+
+      header = [record, length].pack("vv")
+      data   = [f1904].pack("v")
+
+      append(header, data)
+   end
+end
+
+=begin
+= Notes on the difference between Workbook.pm and workbook.rb
+---deprecated methods
+   I generally elminated any deprecated methods.  That means no 'write'
+   methods.
+---date_system
+   This is the 1904 attribute.  However, since a number can't be a method,
+   this doesn't work very well for attribute_accessor.  Besides, date_system
+   is more descriptive.
+=end