WriteExcel 0.2.0

data/examples/merge5.rb

@@ -0,0 +1,79 @@
+#!/usr/bin/ruby -w
+
+###############################################################################
+#
+# Example of how to use the Spreadsheet::WriteExcel merge_cells() workbook
+# method with complex formatting and rotation.
+#
+#
+# reverse('©'), September 2002, John McNamara, jmcnamara@cpan.org
+#
+# original written in Perl by John McNamara
+# converted to Ruby by Hideo Nakamura, cxn03651@msj.biglobe.ne.jp
+#
+
+require 'rubygems'
+require 'WriteExcel'
+
+# Create a new workbook and add a worksheet
+workbook  = Spreadsheet::WriteExcel.new('merge5.xls')
+worksheet = workbook.add_worksheet
+
+
+# Increase the cell size of the merged cells to highlight the formatting.
+(3..8).each { |col| worksheet.set_row(col, 36) }
+[1, 3, 5].each { |n| worksheet.set_column(n, n, 15) }
+
+
+###############################################################################
+#
+# Rotation 1, letters run from top to bottom
+#
+format1 = workbook.add_format(
+                                    :border      => 6,
+                                    :bold        => 1,
+                                    :color       => 'red',
+                                    :valign      => 'vcentre',
+                                    :align       => 'centre',
+                                    :rotation    => 270
+                                  )
+
+
+worksheet.merge_range('B4:B9', 'Rotation 270', format1)
+
+
+###############################################################################
+#
+# Rotation 2, 90° anticlockwise
+#
+format2 = workbook.add_format(
+                                    :border      => 6,
+                                    :bold        => 1,
+                                    :color       => 'red',
+                                    :valign      => 'vcentre',
+                                    :align       => 'centre',
+                                    :rotation    => 90
+                                  )
+
+
+worksheet.merge_range('D4:D9', 'Rotation 90°', format2)
+
+
+
+###############################################################################
+#
+# Rotation 3, 90° clockwise
+#
+format3 = workbook.add_format(
+                                    :border      => 6,
+                                    :bold        => 1,
+                                    :color       => 'red',
+                                    :valign      => 'vcentre',
+                                    :align       => 'centre',
+                                    :rotation    => -90
+                                  )
+
+
+worksheet.merge_range('F4:F9', 'Rotation -90°', format3)
+
+workbook.close

data/examples/protection.rb

@@ -0,0 +1,46 @@
+  #!/usr/bin/ruby -w
+
+########################################################################
+#
+# Example of cell locking and formula hiding in an Excel  worksheet via
+# the Spreadsheet::WriteExcel module.
+#
+# reverse('©'), August 2001, John McNamara, jmcnamara@cpan.org
+#
+# original written in Perl by John McNamara
+# converted to Ruby by Hideo Nakamura, cxn03651@msj.biglobe.ne.jp
+#
+
+require 'rubygems'
+require 'WriteExcel'
+
+workbook  = Spreadsheet::WriteExcel.new("protection.xls")
+worksheet = workbook.add_worksheet
+
+# Create some format objects
+locked    = workbook.add_format(:locked => 1)
+unlocked  = workbook.add_format(:locked => 0)
+hidden    = workbook.add_format(:hidden => 1)
+
+# Format the columns
+worksheet.set_column('A:A', 42)
+worksheet.set_selection('B3:B3')
+
+# Protect the worksheet
+worksheet.protect
+
+# Examples of cell locking and hiding
+worksheet.write('A1', 'Cell B1 is locked. It cannot be edited.')
+worksheet.write('B1', '=1+2', locked)
+
+worksheet.write('A2', 'Cell B2 is unlocked. It can be edited.')
+worksheet.write('B2', '=1+2', unlocked)
+
+worksheet.write('A3', "Cell B3 is hidden. The formula isn't visible.")
+worksheet.write('B3', '=1+2', hidden)
+
+worksheet.write('A5', 'Use Menu->Tools->Protection->Unprotect Sheet')
+worksheet.write('A6', 'to remove the worksheet protection.   ')
+
+workbook.close
+

data/examples/regions.rb

@@ -0,0 +1,52 @@
+#!/usr/bin/ruby -w
+
+###############################################################################
+#
+# Example of how to use the WriteExcel module to write a basic multiple
+# worksheet Excel file.
+#
+# reverse('©'), March 2001, John McNamara, jmcnamara@cpan.org
+#
+# original written in Perl by John McNamara
+# converted to Ruby by Hideo Nakamura, cxn03651@msj.biglobe.ne.jp
+#
+
+require 'rubygems'
+require 'WriteExcel'
+
+workbook = Spreadsheet::WriteExcel.new("regions.xls")
+
+# Add some worksheets
+north = workbook.add_worksheet("North")
+south = workbook.add_worksheet("South")
+east  = workbook.add_worksheet("East")
+west  = workbook.add_worksheet("West")
+
+# Add a Format
+format = workbook.add_format()
+format.set_bold()
+format.set_color('blue')
+
+# Add a caption to each worksheet
+workbook.sheets.each do |worksheet|
+    worksheet.write(0, 0, "Sales", format)
+end
+
+# Write some data
+north.write(0, 1, 200000)
+south.write(0, 1, 100000)
+east.write(0, 1, 150000)
+west.write(0, 1, 100000)
+
+# Set the active worksheet
+bp=1
+south.activate()
+
+# Set the width of the first column
+south.set_column(0, 0, 20)
+
+# Set the active cell
+south.set_selection(0, 1)
+
+workbook.close
+

data/examples/repeat.rb

@@ -0,0 +1,42 @@
+  #!/usr/bin/ruby -w
+
+######################################################################
+#
+# Example of writing repeated formulas.
+#
+# reverse('©'), August 2002, John McNamara, jmcnamara@cpan.org
+#
+# original written in Perl by John McNamara
+# converted to Ruby by Hideo Nakamura, cxn03651@msj.biglobe.ne.jp
+#
+
+require 'rubygems'
+require 'WriteExcel'
+
+workbook  = Spreadsheet::WriteExcel.new("repeat.xls")
+worksheet = workbook.add_worksheet
+
+limit = 1000
+
+# Write a column of numbers
+0.upto(limit) do |row|
+  worksheet.write(row, 0,  row)
+end
+
+# Store a formula
+formula = worksheet.store_formula('=A1*5+4')
+
+# Write a column of formulas based on the stored formula
+0.upto(limit) do |row|
+  worksheet.repeat_formula(row, 1, formula, nil,
+                                      /A1/, 'A'+(row+1).to_s)
+end
+
+# Direct formula writing. As a speed comparison uncomment the
+# following and run the program again
+
+#for row (0..limit) {
+#    worksheet.write_formula(row, 2, '=A'.(row+1).'*5+4')
+#}
+
+workbook.close

data/examples/stats.rb

@@ -0,0 +1,75 @@
+#!/usr/bin/ruby -w
+
+###############################################################################
+#
+# This is a simple example of how to use functions with the
+# Spreadsheet::WriteExcel module.
+#
+# reverse('©'), March 2001, John McNamara, jmcnamara@cpan.org
+#
+# original written in Perl by John McNamara
+# converted to Ruby by Hideo Nakamura, cxn03651@msj.biglobe.ne.jp
+#
+
+require 'rubygems'
+require 'WriteExcel'
+include Spreadsheet
+xlsfile = 'stats.xls'
+
+workbook = Spreadsheet::WriteExcel.new(xlsfile)
+worksheet = workbook.add_worksheet('Test data')
+
+# Set the column width for columns 1
+worksheet.set_column(0, 0, 20)
+
+
+# Create a format for the headings
+format = workbook.add_format
+format.set_bold
+
+
+# Write the sample data
+worksheet.write(0, 0, 'Sample', format)
+worksheet.write(0, 1, 1)
+worksheet.write(0, 2, 2)
+worksheet.write(0, 3, 3)
+worksheet.write(0, 4, 4)
+worksheet.write(0, 5, 5)
+worksheet.write(0, 6, 6)
+worksheet.write(0, 7, 7)
+worksheet.write(0, 8, 8)
+
+worksheet.write(1, 0, 'Length', format)
+worksheet.write(1, 1, 25.4)
+worksheet.write(1, 2, 25.4)
+worksheet.write(1, 3, 24.8)
+worksheet.write(1, 4, 25.0)
+worksheet.write(1, 5, 25.3)
+worksheet.write(1, 6, 24.9)
+worksheet.write(1, 7, 25.2)
+worksheet.write(1, 8, 24.8)
+
+# Write some statistical functions
+worksheet.write(4,  0, 'Count', format)
+worksheet.write(4,  1, '=COUNT(B1:I1)')
+
+worksheet.write(5,  0, 'Sum', format)
+worksheet.write(5,  1, '=SUM(B2:I2)')
+
+worksheet.write(6,  0, 'Average', format)
+worksheet.write(6,  1, '=AVERAGE(B2:I2)')
+
+worksheet.write(7,  0, 'Min', format)
+worksheet.write(7,  1, '=MIN(B2:I2)')
+
+worksheet.write(8,  0, 'Max', format)
+worksheet.write(8,  1, '=MAX(B2:I2)')
+
+worksheet.write(9,  0, 'Standard Deviation', format)
+worksheet.write(9,  1, '=STDEV(B2:I2)')
+
+worksheet.write(10, 0, 'Kurtosis', format)
+worksheet.write(10, 1, '=KURT(B2:I2)')
+
+workbook.close
+

data/examples/stocks.rb

@@ -0,0 +1,80 @@
+  #!/usr/bin/ruby -w
+
+###############################################################################
+#
+# Example of formatting using the Spreadsheet::WriteExcel module
+#
+# This example shows how to use a conditional numerical format
+# with colours to indicate if a share price has gone up or down.
+#
+# reverse('©'), March 2001, John McNamara, jmcnamara@cpan.org
+#
+# original written in Perl by John McNamara
+# converted to Ruby by Hideo Nakamura, cxn03651@msj.biglobe.ne.jp
+#
+
+require 'rubygems'
+require 'WriteExcel'
+
+# Create a new workbook and add a worksheet
+workbook  = Spreadsheet::WriteExcel.new("stocks.xls")
+worksheet = workbook.add_worksheet
+
+# Set the column width for columns 1, 2, 3 and 4
+worksheet.set_column(0, 3, 15)
+
+
+# Create a format for the column headings
+header = workbook.add_format
+header.set_bold
+header.set_size(12)
+header.set_color('blue')
+
+
+# Create a format for the stock price
+f_price = workbook.add_format
+f_price.set_align('left')
+f_price.set_num_format('$0.00')
+
+
+# Create a format for the stock volume
+f_volume = workbook.add_format
+f_volume.set_align('left')
+f_volume.set_num_format('#,##0')
+
+
+# Create a format for the price change. This is an example of a conditional
+# format. The number is formatted as a percentage. If it is positive it is
+# formatted in green, if it is negative it is formatted in red and if it is
+# zero it is formatted as the default font colour (in this case black).
+# Note: the [Green] format produces an unappealing lime green. Try
+# [Color 10] instead for a dark green.
+#
+f_change = workbook.add_format
+f_change.set_align('left')
+f_change.set_num_format('[Green]0.0%;[Red]-0.0%;0.0%')
+
+
+# Write out the data
+worksheet.write(0, 0, 'Company', header)
+worksheet.write(0, 1, 'Price',   header)
+worksheet.write(0, 2, 'Volume',  header)
+worksheet.write(0, 3, 'Change',  header)
+
+worksheet.write(1, 0, 'Damage Inc.'     )
+worksheet.write(1, 1, 30.25,     f_price)  # $30.25
+worksheet.write(1, 2, 1234567,   f_volume) # 1,234,567
+worksheet.write(1, 3, 0.085,     f_change) # 8.5% in green
+
+worksheet.write(2, 0, 'Dump Corp.'      )
+worksheet.write(2, 1, 1.56,      f_price)  # $1.56
+worksheet.write(2, 2, 7564,      f_volume) # 7,564
+worksheet.write(2, 3, -0.015,    f_change) # -1.5% in red
+
+worksheet.write(3, 0, 'Rev Ltd.'        )
+worksheet.write(3, 1, 0.13,      f_price)  # $0.13
+worksheet.write(3, 2, 321,       f_volume) # 321
+worksheet.write(3, 3, 0,         f_change) # 0 in the font color (black)
+
+
+workbook.close

data/examples/tab_colors.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/ruby -w
+
+#######################################################################
+#
+# Example of how to set Excel worksheet tab colours.
+#
+# reverse('©'), May 2006, John McNamara, jmcnamara@cpan.org
+#
+# original written in Perl by John McNamara
+# converted to Ruby by Hideo Nakamura, cxn03651@msj.biglobe.ne.jp
+#
+
+require 'rubygems'
+require 'WriteExcel'
+
+workbook   = Spreadsheet::WriteExcel.new('tab_colors.xls')
+
+worksheet1 =  workbook.add_worksheet
+worksheet2 =  workbook.add_worksheet
+worksheet3 =  workbook.add_worksheet
+worksheet4 =  workbook.add_worksheet
+
+# Worsheet1 will have the default tab colour.
+worksheet2.set_tab_color('red')
+worksheet3.set_tab_color('green')
+worksheet4.set_tab_color(0x35) # Orange
+
+workbook.close
+
+workbook.close

data/lib/WriteExcel.rb

@@ -0,0 +1,30 @@
+
+
+require "rubygems"
+require "date"
+require "digest/md5"
+require "nkf"
+require "strscan"
+require "racc/parser.rb"
+require 'tempfile'
+require 'stringio'
+require "iconv"
+bdir = "#{File.join(File.dirname(__FILE__), "WriteExcel")}"
+
+autoload :Workbook, File.join(bdir.to_s, "workbook.rb")
+autoload :BIFFWriter, File.join(bdir.to_s, "biffwriter.rb")
+autoload :OLEWriter, File.join(bdir.to_s, "olewriter.rb")
+autoload :ExcelFormulaParser, File.join(bdir.to_s, "excelformulaparser.rb")
+autoload :Formula, File.join(bdir.to_s, "formula.rb")
+autoload :Format , File.join(bdir.to_s, "format.rb")
+autoload :Worksheet, File.join(bdir.to_s, "worksheet.rb")
+require File.join(bdir.to_s, "properties.rb")
+autoload :OLEStorageLite, File.join(bdir.to_s, "storage_lite.rb")
+
+bdir = nil
+
+class Spreadsheet
+  class WriteExcel < Workbook
+    VERSION = "0.2.0"
+  end
+end

data/lib/WriteExcel/biffwriter.rb

@@ -0,0 +1,259 @@
+#
+# 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
+#
+
+
+#require 'tempfile'
+
+class BIFFWriter
+  BIFF_Version = 0x0600
+  BigEndian    = [1].pack("I") == [1].pack("N")
+
+  attr_reader :byte_order, :data, :datasize
+
+  ######################################################################
+  # The args here aren't used by BIFFWriter, but they are needed by its
+  # subclasses.  I don't feel like creating multiple constructors.
+  ######################################################################
+
+  def initialize
+    set_byte_order
+    @data            = ''
+    @datasize        = 0
+    @limit           = 8224
+    @ignore_continue = 0
+    
+    # Open a tmp file to store the majority of the Worksheet data. If this fails,
+    # for example due to write permissions, store the data in memory. This can be
+    # slow for large files.
+    @filehandle = Tempfile.new('spreadsheetWriteExcel')
+    @filehandle.binmode
+
+    # failed. store temporary data in memory.
+    @using_tmpfile = @filehandle ? true : false
+    
+  end
+
+  ###############################################################################
+  #
+  # _set_byte_order()
+  #
+  # Determine the byte order and store it as class data to avoid
+  # recalculating it for each call to new().
+  #
+  def set_byte_order
+    # Check if "pack" gives the required IEEE 64bit float
+    teststr = [1.2345].pack("d")
+    hexdata = [0x8D, 0x97, 0x6E, 0x12, 0x83, 0xC0, 0xF3, 0x3F]
+    number  = hexdata.pack("C8")
+
+    if number == teststr
+      @byte_order = 0    # Little Endian
+    elsif number == teststr.reverse
+      @byte_order = 1    # Big Endian
+    else
+      # Give up. I'll fix this in a later version.
+      raise( "Required floating point format not supported "  +
+      "on this platform. See the portability section " +
+      "of the documentation."
+      )
+    end
+  end
+
+  ###############################################################################
+  #
+  # _prepend($data)
+  #
+  # General storage function
+  #
+  def prepend(*args)
+    d = args.join
+    d = add_continue(d) if d.length > @limit
+
+    @datasize += d.length
+    @data      = d + @data
+
+#print "prepend\n"
+#print d.unpack('C*').map! {|c| sprintf("%02X", c) }.join(' ') + "\n\n"
+    return d
+  end
+
+  ###############################################################################
+  #
+  # _append($data)
+  #
+  # General storage function
+  #
+  def append(*args)
+    d = args.join
+    # Add CONTINUE records if necessary
+    d = add_continue(d) if d.length > @limit
+    if @using_tmpfile
+      @filehandle.write d
+      @datasize += d.length
+    else
+      @datasize += d.length
+      @data      = @data + d
+    end
+#print "apend\n"
+#print d.unpack('C*').map! {|c| sprintf("%02X", c) }.join(' ') + "\n\n"
+    return d
+  end
+
+  ###############################################################################
+  #
+  # get_data().
+  #
+  # Retrieves data from memory in one chunk, or from disk in $buffer
+  # sized chunks.
+  #
+  def get_data
+    buflen = 4096
+
+    # Return data stored in memory
+    unless @data.nil?
+      tmp   = @data
+      @data = nil
+      if @using_tmpfile
+        @filehandle.open
+        @filehandle.binmode
+      end
+      return tmp
+    end
+
+    # Return data stored on disk
+    if @using_tmpfile
+      return @filehandle.read(buflen)
+    end
+
+    # No data to return
+    return nil
+  end
+
+  ###############################################################################
+  #
+  # _store_bof($type)
+  #
+  # $type = 0x0005, Workbook
+  # $type = 0x0010, Worksheet
+  #
+  # Writes Excel BOF record to indicate the beginning of a stream or
+  # sub-stream in the BIFF file.
+  #
+  def store_bof(type = 0x0005)
+    record  = 0x0809      # Record identifier
+    length  = 0x0010      # Number of bytes to follow
+
+    # According to the SDK $build and $year should be set to zero.
+    # However, this throws a warning in Excel 5. So, use these
+    # magic numbers.
+    build   = 0x0DBB
+    year    = 0x07CC
+
+    bfh     = 0x00000041
+    sfo     = 0x00000006
+
+    header  = [record,length].pack("vv")
+    data    = [BIFF_Version,type,build,year,bfh,sfo].pack("vvvvVV")
+
+    prepend(header, data)
+  end
+
+  ###############################################################################
+  #
+  # _store_eof()
+  #
+  # Writes Excel EOF record to indicate the end of a BIFF stream.
+  #
+  def store_eof
+    record = 0x000A
+    length = 0x0000
+    header = [record,length].pack("vv")
+
+    append(header)
+  end
+
+  ###############################################################################
+  #
+  # _add_continue()
+  #
+  # Excel limits the size of BIFF records. In Excel 5 the limit is 2084 bytes. In
+  # Excel 97 the limit is 8228 bytes. Records that are longer than these limits
+  # must be split up into CONTINUE blocks.
+  #
+  # This function take a long BIFF record and inserts CONTINUE records as
+  # necessary.
+  #
+  # Some records have their own specialised Continue blocks so there is also an
+  # option to bypass this function.
+  #
+  def add_continue(data)
+    record      = 0x003C # Record identifier
+
+    # Skip this if another method handles the continue blocks.
+    return data if @ignore_continue != 0
+
+    # The first 2080/8224 bytes remain intact. However, we have to change
+    # the length field of the record.
+    #
+
+    # in perl
+    #  $tmp = substr($data, 0, $limit, "");
+    if data.length > @limit
+      tmp = data[0, @limit]
+      data[0, @limit] = ''
+    else
+      tmp = data.dup
+      data = ''
+    end
+
+    tmp[2, 2] = [@limit-4].pack('v')
+
+    # Strip out chunks of 2080/8224 bytes +4 for the header.
+    while (data.length > @limit)
+      header  = [record, @limit].pack("vv")
+      tmp     = tmp + header + data[0, @limit]
+      data[0, @limit] = ''
+    end
+
+    # Mop up the last of the data
+    header  = [record, data.length].pack("vv")
+    tmp     = tmp + header + data
+
+    return tmp
+  end
+
+  ###############################################################################
+  #
+  # _add_mso_generic()
+  #    my $type        = $_[0];
+  #    my $version     = $_[1];
+  #    my $instance    = $_[2];
+  #    my $data        = $_[3];
+  #
+  # Create a mso structure that is part of an Escher drawing object. These are
+  # are used for images, comments and filters. This generic method is used by
+  # other methods to create specific mso records.
+  #
+  # Returns the packed record.
+  #
+  def add_mso_generic(type, version, instance, data, length = nil)
+    length  = length.nil? ? data.length : length
+
+    # The header contains version and instance info packed into 2 bytes.
+    header  = version | (instance << 4)
+
+    record  = [header, type, length].pack('vvV') + data
+
+    return record
+  end
+
+end