writeexcel 0.6.4 → 0.6.5

data/.gitignore

@@ -13,6 +13,9 @@ tmtags
 ## VIM
 *.swp
 
+## REDCAR
+.redcar
+
 ## PROJECT::GENERAL
 coverage
 rdoc

data/README.rdoc

@@ -80,6 +80,8 @@ when use urf8 string data.
 * ruby 1.8, ruby 1.9.1, ruby 1.9.2
 
 == Recent Changes
+v0.6.5
+* Bug fix. if workbook already has worksheet of utf8 name, Workbook#add_worksheet, Workbook#add_chart, Workbook#add_chart_ext raise exception when add new worksheet of utf8 name.
 
 v0.6.4
 * Bug fix. endless loop when inserted image size > 8224bytes.

data/VERSION

@@ -1 +1 @@
-0.6.4
+0.6.5

data/lib/writeexcel/chart.rb

@@ -54,8 +54,6 @@ module Writeexcel
 class Chart < Worksheet
   require 'writeexcel/helper'
 
-  NonAscii = /[^!"#\$%&'\(\)\*\+,\-\.\/\:\;<=>\?@0-9A-Za-z_\[\\\]\{\}^` ~\0\n]/
-
   ###############################################################################
   #
   # factory()
@@ -691,17 +689,9 @@ def encode_utf16(str, encoding = 0)  # :nodoc:
     ruby_19 { string = convert_to_ascii_if_ascii(string) }
 
     # Handle utf8 strings.
-    ruby_18 do
-      if string =~ NonAscii
-        string = utf8_to_16be(string)
-        encoding = 1
-      end
-    end
-    ruby_19 do
-      if string.encoding == Encoding::UTF_8
-        string = utf8_to_16be(string)
-        encoding = 1
-      end
+    if is_utf8?(string)
+      string = utf8_to_16be(string)
+      encoding = 1
     end
 
     # Chart strings are limited to 255 characters.

data/lib/writeexcel/format.rb

@@ -23,7 +23,7 @@
 module Writeexcel
 
 class Format < Colors
-  NonAscii = /[^!"#\$%&'\(\)\*\+,\-\.\/\:\;<=>\?@0-9A-Za-z_\[\\\]\{\}^` ~\0\n]/
+  require 'writeexcel/helper'
 
   ###############################################################################
   #
@@ -373,17 +373,9 @@ def get_font  # :nodoc:
     ruby_19 { rgch = convert_to_ascii_if_ascii(rgch) }
 
     # Handle utf8 strings
-    ruby_18 do
-      if rgch =~ NonAscii
-        rgch = utf8_to_16be(rgch)
-        encoding = 1
-      end
-    end
-    ruby_19 do
-      if rgch.encoding == Encoding::UTF_8
-        rgch = utf8_to_16be(rgch)
-        encoding = 1
-      end
+    if is_utf8?(rgch)
+      rgch = utf8_to_16be(rgch)
+      encoding = 1
     end
 
     cch = rgch.bytesize

data/lib/writeexcel/formula.rb

@@ -19,8 +19,6 @@ module Writeexcel
 class Formula < ExcelFormulaParser       #:nodoc:
   require 'writeexcel/helper'
 
-  NonAscii = /[^!"#\$%&'\(\)\*\+,\-\.\/\:\;<=>\?@0-9A-Za-z_\[\\\]\{\}^` ~\0\n]/
-
   attr_accessor :byte_order, :workbook, :ext_sheets, :ext_refs, :ext_ref_count
 
   def initialize(byte_order)
@@ -313,19 +311,10 @@ def convert_string(str)
              ruby_19 { str.length }
 
     # Handle utf8 strings
-    ruby_18 do
-      if str =~ NonAscii
-        str = utf8_to_16le(str)
-        ruby_19 { str.force_encoding('BINARY') }
-        encoding = 1
-      end
-    end
-    ruby_19 do
-      if str.encoding == Encoding::UTF_8
-        str = utf8_to_16le(str)
-        ruby_19 { str.force_encoding('BINARY') }
-        encoding = 1
-      end
+    if is_utf8?(str)
+      str = utf8_to_16le(str)
+      ruby_19 { str.force_encoding('BINARY') }
+      encoding = 1
     end
 
     exit "String in formula has more than 255 chars\n" if length > 255
@@ -513,15 +502,9 @@ def get_sheet_index(sheet_name)
     ruby_19 { sheet_name = convert_to_ascii_if_ascii(sheet_name) }
 
     # Handle utf8 sheetnames
-    ruby_18 do
-      if sheet_name =~ NonAscii
-        sheet_name = utf8_to_16be(sheet_name)
-      end
-    end
-    ruby_19 do
-      if sheet_name.encoding == Encoding::UTF_8
-        sheet_name = sheet_name.encode('UTF-16BE')
-      end
+    if is_utf8?(sheet_name)
+      ruby_18 { sheet_name = utf8_to_16be(sheet_name) } ||
+      ruby_19 { sheet_name = sheet_name.encode('UTF-16BE') }
     end
 
     if @ext_sheets[sheet_name].nil?

data/lib/writeexcel/helper.rb

@@ -66,3 +66,10 @@ def chars_to_col(chars)
     col
   end
   private :chars_to_col
+
+  NonAscii = /[^!"#\$%&'\(\)\*\+,\-\.\/\:\;<=>\?@0-9A-Za-z_\[\\\]\{\}^` ~\0\n]/
+
+  def is_utf8?(str)
+    ruby_18 { str =~ NonAscii } ||
+    ruby_19 { str.encoding == Encoding::UTF_8 }
+  end

data/lib/writeexcel/workbook.rb

@@ -26,18 +26,23 @@ class Workbook < BIFFWriter
   require 'writeexcel/properties'
   require 'writeexcel/helper'
 
-  NonAscii = /[^!"#\$%&'\(\)\*\+,\-\.\/\:\;<=>\?@0-9A-Za-z_\[\\\]\{\}^` ~\0\n]/
-
-  BOF = 11  # :nodoc:
+  BOF = 12  # :nodoc:
   EOF = 4   # :nodoc:
   SheetName = "Sheet"  # :nodoc:
 
+  private
+
+  attr_accessor :add_doc_properties       #:nodoc:
+  attr_reader :formats, :defined_names    #:nodoc:
+
+  public
+
   #
-  # file is a filename (as string) or io object where to out spreadsheet data.
-  # you can set default format of workbook using default_formats.
+  # _file_ is a filename (as string) or io object where to out spreadsheet data.
+  # you can set default format of workbook using _default_formats_.
   #
   # A new Excel workbook is created using the new() constructor which accepts
-  # either a filename or a filehandle as a parameter. The following example
+  # either a filename or an IO object as a parameter. The following example
   # creates a new Excel file based on a filename:
   #
   #     workbook  = WriteExcel.new('filename.xls')
@@ -74,8 +79,6 @@ def initialize(file, default_formats = {})
     @parser                = Writeexcel::Formula.new(@byte_order)
     @tempdir               = nil
     @date_1904             = false
-    @sheet                 =
-
     @selected              = 0
     @xf_index              = 0
     @fileclosed            = false
@@ -88,7 +91,6 @@ def initialize(file, default_formats = {})
     @codepage              = 0x04E4
     @country               = 1
     @worksheets            = []
-    @sheetnames            = []
     @formats               = []
     @palette               = []
     @biff_only             = 0
@@ -117,7 +119,6 @@ def initialize(file, default_formats = {})
     @hideobj               = 0
     @compatibility         = 0
 
-    @add_doc_properties    = 0
     @summary               = ''
     @doc_summary           = ''
     @localtime             = Time.now
@@ -165,7 +166,7 @@ def initialize(file, default_formats = {})
 
   ###############################################################################
   #
-  # _get_checksum_method.
+  # get_checksum_method.
   #
   # Check for modules available to calculate image checksum. Excel uses MD4 but
   # MD5 will also work.
@@ -182,12 +183,6 @@ def get_checksum_method       #:nodoc:
   # Calls finalization methods and explicitly close the OLEwriter files
   # handle.
   #
-  # In general your Excel file will be closed automatically when your program
-  # ends or when the Workbook object goes out of scope, however the close method
-  # can be used to explicitly close an Excel file.
-  #
-  #     workbook.close
-  #
   # An explicit close() is required if the file must be closed prior to performing
   # some external action on it such as copying it, reading its size or attaching
   # it to an email.
@@ -195,12 +190,6 @@ def get_checksum_method       #:nodoc:
   # In general, if you create a file with a size of 0 bytes or you fail to create
   # a file you need to call close().
   #
-  # The return value of close() is the same as that returned by perl when it
-  # closes the file created by new(). This allows you to handle error conditions
-  # in the usual way:
-  #
-  #     $workbook.close() or die "Error closing file: $!";
-  #
   def close
     return if @fileclosed  # Prevent close() from being called twice.
 
@@ -245,11 +234,7 @@ def sheets(*args)
     if args.empty?
       @worksheets
     else
-      ary = []
-      args.each do |i|
-        ary << @worksheets[i]
-      end
-      ary
+      args.collect{|i| @worksheets[i] }
     end
   end
 
@@ -266,7 +251,7 @@ def sheets(*args)
   #     worksheet3 = workbook.add_worksheet('Data')    # Data
   #     worksheet4 = workbook.add_worksheet            # Sheet4
   #
-  # If sheetname is not specified the default Excel convention will be followed,
+  # If _sheetname_ is not specified the default Excel convention will be followed,
   # i.e. Sheet1, Sheet2, etc. The utf_16_be parameter is optional, see below.
   #
   # The worksheet name must be a valid Excel worksheet name, i.e. it cannot
@@ -308,14 +293,10 @@ def add_worksheet(sheetname = '', encoding = 0)
     ]
     worksheet = Writeexcel::Worksheet.new(*init_data)
     @worksheets[index] = worksheet      # Store ref for iterator
-    @sheetnames[index] = name           # Store EXTERNSHEET names
     @parser.set_ext_sheets(name, index) # Store names in Formula.rb
     worksheet
   end
 
-  ###############################################################################
-  #
-  # add_chart(params)
   #
   # Create a chart for embedding or as as new sheet.
   #
@@ -327,72 +308,78 @@ def add_worksheet(sheetname = '', encoding = 0)
   #
   # The properties that can be set are:
   #
-  #     :type     (required)
-  #     :name     (optional)
-  #     :embedded (optional)
+  #   :type      (required)
+  #   :name      (optional)
+  #   :encoding  (optional)
+  #   :embedded  (optional)
+  #
+  # * type
   #
-  #     * type
+  # This is a required parameter. It defines the type of chart that will be created.
   #
-  #       This is a required parameter. It defines the type of chart that will be created.
+  #   chart = workbook.add_chart(:type => 'Chart::Line')
   #
-  #           chart = workbook.add_chart(:type => 'Chart::Line')
+  # The available types are:
   #
-  #       The available types are:
+  #   'Chart::Column'
+  #   'Chart::Bar'
+  #   'Chart::Line'
+  #   'Chart::Area'
+  #   'Chart::Pie'
+  #   'Chart::Scatter'
+  #   'Chart::Stock'
   #
-  #           'Chart::Column'
-  #           'Chart::Bar'
-  #           'Chart::Line'
-  #           'Chart::Area'
-  #           'Chart::Pie'
-  #           'Chart::Scatter'
-  #           'Chart::Stock'
+  # * :name
   #
-  #     * :name
+  # Set the name for the chart sheet. The name property is optional and
+  # if it isn't supplied will default to Chart1 .. n. The name must be
+  # a valid Excel worksheet name. See add_worksheet() for more details
+  # on valid sheet names. The name property can be omitted for embedded
+  # charts.
   #
-  #       Set the name for the chart sheet. The name property is optional and
-  #       if it isn't supplied will default to Chart1 .. n. The name must be
-  #        a valid Excel worksheet name. See add_worksheet() for more details
-  #        on valid sheet names. The name property can be omitted for embedded
-  #        charts.
+  #   chart = workbook.add_chart(
+  #              :type => 'Chart::Line',
+  #              :name => 'Results Chart'
+  #           )
   #
-  #           chart = workbook.add_chart(
-  #                           :type => 'Chart::Line',
-  #                           :name => 'Results Chart'
-  #                   )
+  # * :encoding
   #
-  #     * :embedded
+  # if :name is UTF-16BE format, pass 1 as :encoding.
   #
-  #       Specifies that the Chart object will be inserted in a worksheet via
-  #       the insert_chart() Worksheet method. It is an error to try insert a
-  #       Chart that doesn't have this flag set.
+  # * :embedded
   #
-  #           chart = workbook.add_chart(:type => 'Chart::Line', :embedded => 1)
+  # Specifies that the Chart object will be inserted in a worksheet via
+  # the insert_chart() Worksheet method. It is an error to try insert a
+  # Chart that doesn't have this flag set.
   #
-  #           # Configure the chart.
-  #           ...
+  #   chart = workbook.add_chart(:type => 'Chart::Line', :embedded => 1)
   #
-  #           # Insert the chart into the a worksheet.
-  #           worksheet.insert_chart('E2', chart)
+  #   # Configure the chart.
+  #   ...
+  #
+  #   # Insert the chart into the a worksheet.
+  #   worksheet.insert_chart('E2', chart)
   #
   # See WriteExcel::Chart for details on how to configure the
-  # chart object once it is created. See also the chart_*.pl programs in the
+  # chart object once it is created. See also the chart_*.rb programs in the
   # examples directory of the distro.
   #
-  def add_chart(params)
+  def add_chart(properties)
     name = ''
     encoding = 0
     index    = @worksheets.size
 
     # Type must be specified so we can create the required chart instance.
-    type = params[:type]
-    print "Must define chart type in add_chart()" if type.nil?
+    type = properties[:type]
+    raise "Must define chart type in add_chart()" if type.nil?
 
     # Ensure that the chart defaults to non embedded.
-    embedded = params[:embedded]
+    embedded = properties[:embedded]
 
     # Check the worksheet name for non-embedded charts.
     unless embedded
-      name, encoding = check_sheetname(params[:name], params[:name_encoding], 1)
+      name, encoding =
+        check_sheetname(properties[:name], properties[:encoding], true)
     end
 
     init_data = [
@@ -412,7 +399,6 @@ def add_chart(params)
     # If the chart isn't embedded let the workbook control it.
     if !embedded
       @worksheets[index] = chart          # Store ref for iterator
-      @sheetnames[index] = name           # Store EXTERNSHEET names
     else
       # Set index to 0 so that the activate() and set_first_sheet() methods
       # point back to the first worksheet if used for embedded charts.
@@ -423,9 +409,6 @@ def add_chart(params)
     chart
   end
 
-  ###############################################################################
-  #
-  # add_chart_ext($filename, $name)
   #
   # Add an externally created chart.
   #
@@ -454,24 +437,21 @@ def add_chart_ext(filename, name, encoding = 0)
 
     chart = Writeexcel::Chart.factory(self, type, init_data)
     @worksheets[index] = chart      # Store ref for iterator
-    @sheetnames[index] = name           # Store EXTERNSHEET names
     chart
   end
 
   ###############################################################################
   #
-  # _check_sheetname($name, $encoding)
+  # check_sheetname(name, encoding)
   #
   # Check for valid worksheet names. We check the length, if it contains any
   # invalid characters and if the name is unique in the workbook.
   #
-  def check_sheetname(name, encoding = 0, chart = 0)       #:nodoc:
+  def check_sheetname(name, encoding = 0, chart = nil)       #:nodoc:
     encoding ||= 0
-    limit           = encoding != 0 ? 62 : 31
-    invalid_char    = %r![\[\]:*?/\\]!
 
     # Increment the Sheet/Chart number used for default sheet names below.
-    if chart != 0
+    if chart
       @chart_count += 1
     else
       @sheet_count += 1
@@ -480,7 +460,7 @@ def check_sheetname(name, encoding = 0, chart = 0)       #:nodoc:
     # Supply default Sheet/Chart name if none has been defined.
     if name.nil? || name == ""
       encoding = 0
-      if chart != 0
+      if chart
         name = @chart_name + @chart_count.to_s
       else
         name = @sheet_name + @sheet_count.to_s
@@ -488,16 +468,39 @@ def check_sheetname(name, encoding = 0, chart = 0)       #:nodoc:
     end
 
     ruby_19 { name = convert_to_ascii_if_ascii(name) }
+    check_sheetname_length(name, encoding)
+    check_sheetname_even(name) if encoding == 1
+    check_sheetname_valid_chars(name, encoding)
+
+    # Handle utf8 strings
+    if is_utf8?(name)
+      name = utf8_to_16be(name)
+      encoding = 1
+    end
 
+    check_sheetname_uniq(name, encoding)
+    [name,  encoding]
+  end
+  private :check_sheetname
+
+  def check_sheetname_length(name, encoding)       #:nodoc:
     # Check that sheetname is <= 31 (1 or 2 byte chars). Excel limit.
+    limit           = encoding != 0 ? 62 : 31
     raise "Sheetname $name must be <= 31 chars" if name.bytesize > limit
+  end
+  private :check_sheetname_length
 
+  def check_sheetname_even(name)       #:nodoc:
     # Check that Unicode sheetname has an even number of bytes
-    if encoding == 1 && (name.bytesize % 2 != 0)
+    if (name.bytesize % 2 != 0)
       raise "Odd number of bytes in Unicode worksheet name: #{name}"
     end
+  end
+  private :check_sheetname_even
 
+  def check_sheetname_valid_chars(name, encoding)       #:nodoc:
     # Check that sheetname doesn't contain any invalid characters
+    invalid_char    = %r![\[\]:*?/\\]!
     if encoding != 1 && name =~ invalid_char
       # Check ASCII names
       raise "Invalid character []:*?/\\ in worksheet name: #{name}"
@@ -512,32 +515,21 @@ def check_sheetname(name, encoding = 0, chart = 0)       #:nodoc:
         str = $~.post_match
       end
     end
+  end
+  private :check_sheetname_valid_chars
 
-    # Handle utf8 strings
-    ruby_18 do
-      if name =~ NonAscii
-        name = utf8_to_16be(name)
-        encoding = 1
-      end
-    end
-    ruby_19 do
-      if name.encoding == Encoding::UTF_8
-        name = utf8_to_16be(name)
-        encoding = 1
-      end
-    end
-
-    # Check that the worksheet name doesn't already exist since this is a fatal
-    # error in Excel 97. The check must also exclude case insensitive matches
-    # since the names 'Sheet1' and 'sheet1' are equivalent. The tests also have
-    # to take the encoding into account.
-    #
+  # Check that the worksheet name doesn't already exist since this is a fatal
+  # error in Excel 97. The check must also exclude case insensitive matches
+  # since the names 'Sheet1' and 'sheet1' are equivalent. The tests also have
+  # to take the encoding into account.
+  #
+  def check_sheetname_uniq(name, encoding)       #:nodoc:
     @worksheets.each do |worksheet|
       name_a  = name
       encd_a  = encoding
       name_b  = worksheet.name
       encd_b  = worksheet.encoding
-      error   = 0;
+      error   = false
 
       if    encd_a == 0 and encd_b == 0
         error  = (name_a.downcase == name_b.downcase)
@@ -569,9 +561,8 @@ def check_sheetname(name, encoding = 0, chart = 0)       #:nodoc:
         raise "Worksheet name '#{name}', with case ignored, is already in use"
       end
     end
-    [name,  encoding]
   end
-  private :check_sheetname
+  private :check_sheetname_uniq
 
   #
   # The add_format method can be used to create new Format objects which are
@@ -584,11 +575,11 @@ def check_sheetname(name, encoding = 0, chart = 0)       #:nodoc:
   # See the "CELL FORMATTING" section for more details about Format properties and how to set them.
   #
   def add_format(*args)
-    formats = {}
-    args.each { |arg| formats = formats.merge(arg) }
-    format = Writeexcel::Format.new(@xf_index, @default_formats.merge(formats))
+    fmts = {}
+    args.each { |arg| fmts = fmts.merge(arg) }
+    format = Writeexcel::Format.new(@xf_index, @default_formats.merge(fmts))
     @xf_index += 1
-    @formats.push format # Store format reference
+    formats.push format # Store format reference
     format
   end
 
@@ -819,7 +810,6 @@ def set_palette_xl97       #:nodoc:
       [0x33, 0x33, 0x99, 0x00],   # 62
       [0x33, 0x33, 0x33, 0x00]    # 63
     ]
-    0
   end
   private :set_palette_xl97
 
@@ -948,7 +938,7 @@ def define_name(name, formula, encoding = 0)
     # Parse the tokens into a formula string.
     formula = parser.parse_tokens(tokens)
 
-    @defined_names.push(
+    defined_names.push(
        {
          :name        => name,
          :encoding    => encoding,
@@ -957,7 +947,7 @@ def define_name(name, formula, encoding = 0)
        }
      )
 
-    index = @defined_names.size
+    index = defined_names.size
 
     parser.set_ext_name(name, index)
   end
@@ -1020,107 +1010,111 @@ def set_properties(params)
     params.each do |k, v|
       params[k] = convert_to_ascii_if_ascii(v) if v.respond_to?(:to_str)
     end
-    # List of valid input parameters.
-    properties = {
-      :codepage      => [0x0001, 'VT_I2'      ],
-      :title         => [0x0002, 'VT_LPSTR'   ],
-      :subject       => [0x0003, 'VT_LPSTR'   ],
-      :author        => [0x0004, 'VT_LPSTR'   ],
-      :keywords      => [0x0005, 'VT_LPSTR'   ],
-      :comments      => [0x0006, 'VT_LPSTR'   ],
-      :last_author   => [0x0008, 'VT_LPSTR'   ],
-      :created       => [0x000C, 'VT_FILETIME'],
-      :category      => [0x0002, 'VT_LPSTR'   ],
-      :manager       => [0x000E, 'VT_LPSTR'   ],
-      :company       => [0x000F, 'VT_LPSTR'   ],
-      :utf8          => 1
-    }
 
     # Check for valid input parameters.
-    params.each_key do |k|
-      unless properties.has_key?(k)
-        raise "Unknown parameter '#{k}' in set_properties()";
-      end
-    end
+    check_valid_params_for_properties(params)
 
     # Set the creation time unless specified by the user.
-    unless params.has_key?(:created)
-      params[:created] = @localtime
-    end
+    params[:created] = @localtime unless params.has_key?(:created)
 
     #
     # Create the SummaryInformation property set.
     #
 
     # Get the codepage of the strings in the property set.
-    strings = ["title", "subject", "author", "keywords",  "comments", "last_author"]
-    params[:codepage] = get_property_set_codepage(params, strings)
+    properties = [:title, :subject, :author, :keywords,  :comments, :last_author]
+    params[:codepage] = get_property_set_codepage(params, properties)
 
     # Create an array of property set values.
-    property_sets = []
-    strings.unshift("codepage")
-    strings.push("created")
-    strings.each do |string|
-      property = string.to_sym
-      property_sets.push(property_set(properties, property, params)) if params[property]
-    end
+    properties.unshift(:codepage)
+    properties.push(:created)
 
     # Pack the property sets.
-    @summary = create_summary_property_set(property_sets)
+    @summary =
+      create_summary_property_set(property_sets(properties, params))
 
     #
     # Create the DocSummaryInformation property set.
     #
 
     # Get the codepage of the strings in the property set.
-    strings = ["category", "manager", "company"]
-    params[:codepage] = get_property_set_codepage(params, strings)
+    properties = [:category, :manager, :company]
+    params[:codepage] = get_property_set_codepage(params, properties)
 
     # Create an array of property set values.
-    property_sets = []
-
-    [:codepage, :category, :manager, :company].each do |property|
-      property_sets.push(property_set(properties, property, params)) if params[property]
-    end
+    properties.unshift(:codepage)
 
     # Pack the property sets.
-    @doc_summary = create_doc_summary_property_set(property_sets)
+    @doc_summary =
+      create_doc_summary_property_set(property_sets(properties, params))
 
     # Set a flag for when the files is written.
-    @add_doc_properties = 1
+    add_doc_properties = true
   end
 
-  def property_set(properties, property, params)
-    [ properties[property][0], properties[property][1], params[property] ]
+  def property_set(property, params)       #:nodoc:
+    valid_properties[property][0..1] + [params[property]]
   end
   private :property_set
 
+  def property_sets(properties, params)       #:nodoc:
+    properties.select { |property| params[property.to_sym] }.
+      collect do |property|
+        property_set(property.to_sym, params)
+      end
+  end
+  private :property_sets
+
+  # List of valid input parameters.
+  def valid_properties       #:nodoc:
+    {
+      :codepage      => [0x0001, 'VT_I2'      ],
+      :title         => [0x0002, 'VT_LPSTR'   ],
+      :subject       => [0x0003, 'VT_LPSTR'   ],
+      :author        => [0x0004, 'VT_LPSTR'   ],
+      :keywords      => [0x0005, 'VT_LPSTR'   ],
+      :comments      => [0x0006, 'VT_LPSTR'   ],
+      :last_author   => [0x0008, 'VT_LPSTR'   ],
+      :created       => [0x000C, 'VT_FILETIME'],
+      :category      => [0x0002, 'VT_LPSTR'   ],
+      :manager       => [0x000E, 'VT_LPSTR'   ],
+      :company       => [0x000F, 'VT_LPSTR'   ],
+      :utf8          => 1
+    }
+  end
+  private :valid_properties
+
+  def check_valid_params_for_properties(params)       #:nodoc:
+    params.each_key do |k|
+      unless valid_properties.has_key?(k)
+        raise "Unknown parameter '#{k}' in set_properties()";
+      end
+    end
+  end
+  private :check_valid_params_for_properties
+
   ###############################################################################
   #
-  # _get_property_set_codepage()
+  # get_property_set_codepage()
   #
   # Get the character codepage used by the strings in a property set. If one of
   # the strings used is utf8 then the codepage is marked as utf8. Otherwise
   # Latin 1 is used (although in our case this is limited to 7bit ASCII).
   #
-  def get_property_set_codepage(params, strings)       #:nodoc:
+  def get_property_set_codepage(params, properties)       #:nodoc:
     # Allow for manually marked utf8 strings.
-    unless params[:utf8].nil?
-      return 0xFDE9
-    else
-      strings.each do |string|
-        next unless params.has_key?(string.to_sym)
-        ruby_18 { return 0xFDE9 if params[string.to_sym] =~ NonAscii }
-        ruby_19 { return 0xFDE9 if params[string.to_sym].encoding == Encoding::UTF_8 }
-      end
-      return 0x04E4; # Default codepage, Latin 1.
+    return 0xFDE9 unless params[:utf8].nil?
+    properties.each do |property|
+      next unless params.has_key?(property.to_sym)
+      return 0xFDE9 if is_utf8?(params[property.to_sym])
     end
+    return 0x04E4; # Default codepage, Latin 1.
   end
   private :get_property_set_codepage
 
   ###############################################################################
   #
-  # _store_workbook()
+  # store_workbook()
   #
   # Assemble worksheets into a workbook and send the BIFF data to an OLE
   # storage.
@@ -1168,7 +1162,7 @@ def store_workbook       #:nodoc:
     end
 
     # NOTE: If any records are added between here and EOF the
-    # _calc_sheet_offsets() should be updated to include the new length.
+    # calc_sheet_offsets() should be updated to include the new length.
     store_country
     if @ext_refs.keys.size != 0
       store_supbook
@@ -1213,7 +1207,7 @@ def localtime=(val)  # :nodoc:
 
   ###############################################################################
   #
-  # _store_ole_filie()
+  # store_ole_filie()
   #
   # Store the workbook in an OLE container using the default handler or using
   # OLE::Storage_Lite if the workbook data is > ~ 7MB.
@@ -1222,7 +1216,7 @@ def store_ole_filie       #:nodoc:
     maxsize = 7_087_104
 #    maxsize = 1
 
-    if @add_doc_properties == 0 && @biffsize <= maxsize
+    if !add_doc_properties && @biffsize <= maxsize
       # Write the OLE file using OLEwriter if data <= 7MB
       ole  = OLEWriter.new(@fh_out)
 
@@ -1266,7 +1260,7 @@ def store_ole_filie       #:nodoc:
       streams << workbook
 
       # Create the properties streams, if any.
-      if @add_doc_properties != 0
+      if add_doc_properties
         stream  = "\5SummaryInformation".unpack('C*').pack('v*')
         summary = OLEStorageLitePPSFile.new(stream, @summary)
         streams << summary
@@ -1293,14 +1287,11 @@ def store_ole_filie       #:nodoc:
 
   ###############################################################################
   #
-  # _calc_sheet_offsets()
+  # calc_sheet_offsets()
   #
   # Calculate Worksheet BOF offsets records for use in the BOUNDSHEET records.
   #
   def calc_sheet_offsets       #:nodoc:
-    _bof     = 12
-    _eof     = 4
-
     offset  = @datasize
 
     # Add the length of the COUNTRY record
@@ -1316,16 +1307,16 @@ def calc_sheet_offsets       #:nodoc:
     offset += calculate_extern_sizes
 
     # Add the length of the MSODRAWINGGROUP records including an extra 4 bytes
-    # for any CONTINUE headers. See _add_mso_drawing_group_continue().
+    # for any CONTINUE headers. See add_mso_drawing_group_continue().
     mso_size = @mso_size
     mso_size += 4 * Integer((mso_size -1) / Float(@limit))
     offset   += mso_size
 
     @worksheets.each do |sheet|
-      offset += _bof + sheet.name.bytesize
+      offset += BOF + sheet.name.bytesize
     end
 
-    offset += _eof
+    offset += EOF
     @worksheets.each do |sheet|
       sheet.offset = offset
       sheet.close
@@ -1338,7 +1329,7 @@ def calc_sheet_offsets       #:nodoc:
 
   ###############################################################################
   #
-  # _calc_mso_sizes()
+  # calc_mso_sizes()
   #
   # Calculate the MSODRAWINGGROUP sizes and the indexes of the Worksheet
   # MSODRAWING records.
@@ -1419,7 +1410,7 @@ def calc_mso_sizes       #:nodoc:
 
   ###############################################################################
   #
-  # _process_images()
+  # process_images()
   #
   # We need to process each image in each worksheet and extract information.
   # Some of this information is stored and used in the Workbook and some is
@@ -1554,10 +1545,10 @@ def process_images       #:nodoc:
 
   ###############################################################################
   #
-  # _image_checksum()
+  # image_checksum()
   #
   # Generate a checksum for the image using whichever module is available..The
-  # available modules are checked in _get_checksum_method(). Excel uses an MD4
+  # available modules are checked in get_checksum_method(). Excel uses an MD4
   # checksum but any other will do. In the event of no checksum module being
   # available we simulate a checksum using the image index.
   #
@@ -1580,7 +1571,7 @@ def image_checksum(data, index1, index2 = 0)       #:nodoc:
 
   ###############################################################################
   #
-  # _process_png()
+  # process_png()
   #
   # Extract width and height information from a PNG file.
   #
@@ -1595,7 +1586,7 @@ def process_png(data)       #:nodoc:
 
   ###############################################################################
   #
-  # _process_bmp()
+  # process_bmp()
   #
   # Extract width and height information from a BMP file.
   #
@@ -1644,7 +1635,7 @@ def process_bmp(data, filename)       #:nodoc:
 
   ###############################################################################
   #
-  # _process_jpg()
+  # process_jpg()
   #
   # Extract width and height information from a JPEG file.
   #
@@ -1683,12 +1674,12 @@ def process_jpg(data, filename) # :nodoc:
 
   ###############################################################################
   #
-  # _store_all_fonts()
+  # store_all_fonts()
   #
   # Store the Excel FONT records.
   #
   def store_all_fonts       #:nodoc:
-    format  = @formats[15]   # The default cell format.
+    format  = formats[15]   # The default cell format.
     font    = format.get_font
 
     # Fonts are 0-indexed. According to the SDK there is no index 4,
@@ -1751,7 +1742,7 @@ def store_all_fonts       #:nodoc:
     # Fonts that are marked as '_font_only' are always stored. These are used
     # mainly for charts and may not have an associated XF record.
 
-    @formats.each do |fmt|
+    formats.each do |fmt|
       key = fmt.get_font_key
       if fmt.font_only == 0 and !fonts[key].nil?
         # FONT has already been used
@@ -1774,7 +1765,7 @@ def store_all_fonts       #:nodoc:
 
   ###############################################################################
   #
-  # _store_all_num_formats()
+  # store_all_num_formats()
   #
   # Store user defined numerical formats i.e. FORMAT records
   #
@@ -1785,7 +1776,7 @@ def store_all_num_formats       #:nodoc:
     # Iterate through the XF objects and write a FORMAT record if it isn't a
     # built-in format type and if the FORMAT string hasn't already been used.
     #
-    @formats.each do |format|
+    formats.each do |format|
       num_format = format.num_format
       encoding   = format.num_format_enc
 
@@ -1813,12 +1804,12 @@ def store_all_num_formats       #:nodoc:
 
   ###############################################################################
   #
-  # _store_all_xfs()
+  # store_all_xfs()
   #
   # Write all XF records.
   #
   def store_all_xfs       #:nodoc:
-    @formats.each do |format|
+    formats.each do |format|
       xf = format.get_xf
       append(xf)
     end
@@ -1827,7 +1818,7 @@ def store_all_xfs       #:nodoc:
 
   ###############################################################################
   #
-  # _store_all_styles()
+  # store_all_styles()
   #
   # Write all STYLE records.
   #
@@ -1858,13 +1849,13 @@ def store_all_styles       #:nodoc:
 
   ###############################################################################
   #
-  # _store_names()
+  # store_names()
   #
   # Write the NAME record to define the print area and the repeat rows and cols.
   #
   def store_names  # :nodoc:
     # Create the user defined names.
-    @defined_names.each do |defined_name|
+    defined_names.each do |defined_name|
       store_name(
         defined_name[:name],
         defined_name[:encoding],
@@ -1875,20 +1866,28 @@ def store_names  # :nodoc:
 
     # Sort the worksheets into alphabetical order by name. This is a
     # requirement for some non-English language Excel patch levels.
-    worksheets = @worksheets.sort_by{ |x| x.name }
+    sorted_worksheets = @worksheets.sort_by{ |x| x.name }
 
     # Create the autofilter NAME records
-    worksheets.each do |worksheet|
+    create_autofilter_name_records(sorted_worksheets)
+
+    # Create the print area NAME records
+    create_print_area_name_records(sorted_worksheets)
+
+    # Create the print title NAME records
+    create_print_title_name_records(sorted_worksheets)
+  end
+
+  def create_autofilter_name_records(sorted_worksheets)       #:nodoc:
+    sorted_worksheets.each do |worksheet|
       index = worksheet.index
-      key = "#{index}:#{index}"
-      ref = @ext_refs[key]
 
       # Write a Name record if Autofilter has been defined
       if worksheet.filter_count != 0
         store_name_short(
           worksheet.index,
           0x0D, # NAME type = Filter Database
-          ref,
+          @ext_refs["#{index}:#{index}"],
           worksheet.filter_area[0],
           worksheet.filter_area[1],
           worksheet.filter_area[2],
@@ -1897,19 +1896,19 @@ def store_names  # :nodoc:
         )
       end
     end
+  end
+  private :create_autofilter_name_records
 
-    # Create the print area NAME records
-    worksheets.each do |worksheet|
+  def create_print_area_name_records(sorted_worksheets)       #:nodoc:
+    sorted_worksheets.each do |worksheet|
       index  = worksheet.index
-      key = "#{index}:#{index}"
-      ref = @ext_refs[key]
 
       # Write a Name record if the print area has been defined
       if !worksheet.print_rowmin.nil?
         store_name_short(
           worksheet.index,
           0x06, # NAME type = Print_Area
-          ref,
+          @ext_refs["#{index}:#{index}"],
           worksheet.print_rowmin,
           worksheet.print_rowmax,
           worksheet.print_colmin,
@@ -1917,9 +1916,11 @@ def store_names  # :nodoc:
         )
       end
     end
+  end
+  private :create_print_area_name_records
 
-    # Create the print title NAME records
-    worksheets.each do |worksheet|
+  def create_print_title_name_records(sorted_worksheets)       #:nodoc:
+    sorted_worksheets.each do |worksheet|
       index = worksheet.index
       rowmin = worksheet.title_rowmin
       rowmax = worksheet.title_rowmax
@@ -1970,6 +1971,7 @@ def store_names  # :nodoc:
       end
     end
   end
+  private :create_print_title_name_records
 
   ###############################################################################
   ###############################################################################
@@ -1980,7 +1982,7 @@ def store_names  # :nodoc:
 
   ###############################################################################
   #
-  # _store_window1()
+  # store_window1()
   #
   # Write Excel BIFF WINDOW1 record.
   #
@@ -2014,7 +2016,7 @@ def store_window1       #:nodoc:
 
   ###############################################################################
   #
-  # _store_boundsheet()
+  # store_boundsheet()
   #    my $sheetname = $_[0];                # Worksheet name
   #    my $offset    = $_[1];                # Location of worksheet BOF
   #    my $type      = $_[2];                # Worksheet type
@@ -2046,7 +2048,7 @@ def store_boundsheet(sheetname, offset, type, hidden, encoding)       #:nodoc:
 
   ###############################################################################
   #
-  # _store_style()
+  # store_style()
   #    type      = $_[0]  # Built-in style
   #    xf_index  = $_[1]  # Index to style XF
   #
@@ -2069,7 +2071,7 @@ def store_style(type, xf_index)       #:nodoc:
 
   ###############################################################################
   #
-  # _store_num_format()
+  # store_num_format()
   #    my $format    = $_[0];          # Custom format string
   #    my $ifmt      = $_[1];          # Format index code
   #    my $encoding  = $_[2];          # Char encoding for format string
@@ -2086,17 +2088,9 @@ def store_num_format(format, ifmt, encoding)       #:nodoc:
     ruby_19 { format = convert_to_ascii_if_ascii(format) }
 
     # Handle utf8 strings
-    ruby_18 do
-      if format =~ NonAscii
-        format = utf8_to_16be(format)
-        encoding = 1
-      end
-    end
-    ruby_19 do
-      if format.encoding == Encoding::UTF_8
-        format = utf8_to_16be(format)
-        encoding = 1
-      end
+    if is_utf8?(format)
+      format = utf8_to_16be(format)
+      encoding = 1
     end
 
     # Handle Unicode format strings.
@@ -2125,7 +2119,7 @@ def store_num_format(format, ifmt, encoding)       #:nodoc:
 
   ###############################################################################
   #
-  # _store_1904()
+  # store_1904()
   #
   # Write Excel 1904 record to indicate the date system in use.
   #
@@ -2144,7 +2138,7 @@ def store_1904       #:nodoc:
 
   ###############################################################################
   #
-  # _store_supbook()
+  # store_supbook()
   #
   # Write BIFF record SUPBOOK to indicate that the workbook contains external
   # references, in our case, formula, print area and print title refs.
@@ -2165,7 +2159,7 @@ def store_supbook       #:nodoc:
 
   ###############################################################################
   #
-  # _store_externsheet()
+  # store_externsheet()
   #
   # Writes the Excel BIFF EXTERNSHEET record. These references are used by
   # formulas. TODO NAME record is required to define the print area and the
@@ -2198,8 +2192,8 @@ def store_externsheet  # :nodoc:
   # Store the NAME record used for storing the print area, repeat rows, repeat
   # columns, autofilters and defined names.
   #
-  # TODO. This is a more generic version that will replace _store_name_short()
-  #       and _store_name_long().
+  # TODO. This is a more generic version that will replace store_name_short()
+  #       and store_name_long().
   #
   def store_name(name, encoding, sheet_index, formula)  # :nodoc:
     ruby_19 { formula = convert_to_ascii_if_ascii(formula) }
@@ -2248,7 +2242,7 @@ def store_name(name, encoding, sheet_index, formula)  # :nodoc:
 
   ###############################################################################
   #
-  # _store_name_short()
+  # store_name_short()
   #    index           = shift        # Sheet index
   #    type            = shift
   #    ext_ref         = shift        # TODO
@@ -2309,7 +2303,7 @@ def store_name_short(index, type, ext_ref, rowmin, rowmax, colmin, colmax, hidde
 
   ###############################################################################
   #
-  # _store_name_long()
+  # store_name_long()
   #    my $index           = shift;        # Sheet index
   #    my $type            = shift;
   #    my $ext_ref         = shift;        # TODO
@@ -2321,7 +2315,7 @@ def store_name_short(index, type, ext_ref, rowmin, rowmax, colmin, colmax, hidde
   #
   # Store the NAME record in the long format that is used for storing the repeat
   # rows and columns when both are specified. This share a lot of code with
-  # _store_name_short() but we use a separate method to keep the code clean.
+  # store_name_short() but we use a separate method to keep the code clean.
   # Code abstraction for reuse can be carried too far, and I should know. ;-)
   #
   def store_name_long(index, type, ext_ref, rowmin, rowmax, colmin, colmax)       #:nodoc:
@@ -2385,7 +2379,7 @@ def store_name_long(index, type, ext_ref, rowmin, rowmax, colmin, colmax)
 
   ###############################################################################
   #
-  # _store_palette()
+  # store_palette()
   #
   # Stores the PALETTE biff record.
   #
@@ -2408,7 +2402,7 @@ def store_palette       #:nodoc:
 
   ###############################################################################
   #
-  # _store_codepage()
+  # store_codepage()
   #
   # Stores the CODEPAGE biff record.
   #
@@ -2423,7 +2417,7 @@ def store_codepage       #:nodoc:
 
   ###############################################################################
   #
-  # _store_country()
+  # store_country()
   #
   # Stores the COUNTRY biff record.
   #
@@ -2439,7 +2433,7 @@ def store_country       #:nodoc:
 
   ###############################################################################
   #
-  # _store_hideobj()
+  # store_hideobj()
   #
   # Stores the HIDEOBJ biff record.
   #
@@ -2452,7 +2446,7 @@ def store_hideobj       #:nodoc:
   end
   private :store_hideobj
 
-  def store_common(record, length, *data)
+  def store_common(record, length, *data)       #:nodoc:
     header = [record, length].pack("vv")
     add_data   = [*data].pack("v*")
 
@@ -2462,7 +2456,7 @@ def store_common(record, length, *data)
 
   ###############################################################################
   #
-  # _calculate_extern_sizes()
+  # calculate_extern_sizes()
   #
   # We need to calculate the space required by the SUPBOOK, EXTERNSHEET and NAME
   # records so that it can be added to the BOUNDSHEET offsets.
@@ -2472,14 +2466,14 @@ def calculate_extern_sizes  # :nodoc:
     length          = 0
     index           = 0
 
-    unless @defined_names.empty?
+    unless defined_names.empty?
       index   = 0
       key     = "#{index}:#{index}"
 
       add_ext_refs(ext_refs, key) unless ext_refs.has_key?(key)
     end
 
-    @defined_names.each do |defined_name|
+    defined_names.each do |defined_name|
       length += 19 + defined_name[:name].bytesize + defined_name[:formula].bytesize
     end
 
@@ -2535,26 +2529,26 @@ def calculate_extern_sizes  # :nodoc:
     length
   end
 
-  def add_ext_refs(ext_refs, key)
+  def add_ext_refs(ext_refs, key)       #:nodoc:
     ext_refs[key] = ext_refs.keys.size
   end
   private :add_ext_refs
 
   ###############################################################################
   #
-  # _calculate_shared_string_sizes()
+  # calculate_shared_string_sizes()
   #
   # Handling of the SST continue blocks is complicated by the need to include an
   # additional continuation byte depending on whether the string is split between
   # blocks or whether it starts at the beginning of the block. (There are also
   # additional complications that will arise later when/if Rich Strings are
   # supported). As such we cannot use the simple CONTINUE mechanism provided by
-  # the _add_continue() method in BIFFwriter.pm. Thus we have to make two passes
+  # the add_continue() method in BIFFwriter.pm. Thus we have to make two passes
   # through the strings data. The first is to calculate the required block sizes
-  # and the second, in _store_shared_strings(), is to write the actual strings.
+  # and the second, in store_shared_strings(), is to write the actual strings.
   # The first pass through the data is also used to calculate the size of the SST
   # and CONTINUE records for use in setting the BOUNDSHEET record offsets. The
-  # downside of this is that the same algorithm repeated in _store_shared_strings.
+  # downside of this is that the same algorithm repeated in store_shared_strings.
   #
   def calculate_shared_string_sizes       #:nodoc:
     strings = Array.new(@sinfo[:str_unique])
@@ -2570,12 +2564,12 @@ def calculate_shared_string_sizes       #:nodoc:
     #
     # The SST blocks requires a specialised CONTINUE block, so we have to
     # ensure that the maximum data block size is less than the limit used by
-    # _add_continue() in BIFFwriter.pm. For simplicity we use the same size
+    # add_continue() in BIFFwriter.pm. For simplicity we use the same size
     # for the SST and CONTINUE records:
     #   8228 : Maximum Excel97 block size
     #     -4 : Length of block header
     #     -8 : Length of additional SST header information
-    #     -8 : Arbitrary number to keep within _add_continue() limit
+    #     -8 : Arbitrary number to keep within add_continue() limit
     # = 8208
     #
     continue_limit = 8208
@@ -2605,7 +2599,7 @@ def calculate_shared_string_sizes       #:nodoc:
       split_string  = 0
       while block_length >= continue_limit
         header_length, space_remaining, align, split_string =
-          _split_string_setup(encoding, split_string, continue_limit, written, continue)
+          split_string_setup(encoding, split_string, continue_limit, written, continue)
 
         if space_remaining > header_length
           # Write as much as possible of the string in the current block
@@ -2667,7 +2661,7 @@ def calculate_shared_string_sizes       #:nodoc:
   end
   private :calculate_shared_string_sizes
 
-  def _split_string_setup(encoding, split_string, continue_limit, written, continue)
+  def split_string_setup(encoding, split_string, continue_limit, written, continue)       #:nodoc:
     # We need to avoid the case where a string is continued in the first
     # n bytes that contain the string header information.
     header_length   = 3 # Min string + header size -1
@@ -2697,15 +2691,15 @@ def _split_string_setup(encoding, split_string, continue_limit, written, continu
     end
     [header_length, space_remaining, align, split_string]
   end
-  private :_split_string_setup
+  private :split_string_setup
 
   ###############################################################################
   #
-  # _store_shared_strings()
+  # store_shared_strings()
   #
   # Write all of the workbooks strings into an indexed array.
   #
-  # See the comments in _calculate_shared_string_sizes() for more information.
+  # See the comments in calculate_shared_string_sizes() for more information.
   #
   # We also use this routine to record the offsets required by the EXTSST table.
   # In order to do this we first identify the first string in an EXTSST bucket
@@ -2726,7 +2720,7 @@ def store_shared_strings       #:nodoc:
     continue       = 0
 
     # The SST and CONTINUE block sizes have been pre-calculated by
-    # _calculate_shared_string_sizes()
+    # calculate_shared_string_sizes()
     block_sizes    = @str_block_sizes
 
     # The SST record is required even if it contains no strings. Thus we will
@@ -2785,7 +2779,7 @@ def store_shared_strings       #:nodoc:
       split_string  = 0
       while block_length >= continue_limit
         header_length, space_remaining, align, split_string =
-          _split_string_setup(encoding, split_string, continue_limit, written, continue)
+          split_string_setup(encoding, split_string, continue_limit, written, continue)
 
         if space_remaining > header_length
           # Write as much as possible of the string in the current block
@@ -2857,7 +2851,7 @@ def store_shared_strings       #:nodoc:
 
   ###############################################################################
   #
-  # _calculate_extsst_size
+  # calculate_extsst_size
   #
   # The number of buckets used in the EXTSST is between 0 and 128. The number of
   # strings per bucket (bucket size) has a minimum value of 8 and a theoretical
@@ -2884,9 +2878,9 @@ def calculate_extsst_size       #:nodoc:
 
   ###############################################################################
   #
-  # _store_extsst
+  # store_extsst
   #
-  # Write EXTSST table using the offsets calculated in _store_shared_strings().
+  # Write EXTSST table using the offsets calculated in store_shared_strings().
   #
   def store_extsst       #:nodoc:
     offsets     = @extsst_offsets
@@ -2912,7 +2906,7 @@ def store_extsst       #:nodoc:
 
   ###############################################################################
   #
-  # _add_mso_drawing_group()
+  # add_mso_drawing_group()
   #
   # Write the MSODRAWINGGROUP record that keeps track of the Escher drawing
   # objects in the file such as images, comments and filters.
@@ -2943,7 +2937,7 @@ def add_mso_drawing_group  #:nodoc:
 
   ###############################################################################
   #
-  # _add_mso_drawing_group_continue()
+  # add_mso_drawing_group_continue()
   #
   # See first the WriteExcel::BIFFwriter::_add_continue() method.
   #
@@ -2962,7 +2956,7 @@ def add_mso_drawing_group_continue(data)       #:nodoc:
     continue    = 0x003C # Record identifier
     block_count = 1
 
-    # Ignore the base class _add_continue() method.
+    # Ignore the base class add_continue() method.
     @ignore_continue = 1
 
     # Case 1 above. Just return the data as it is.
@@ -2995,12 +2989,12 @@ def add_mso_drawing_group_continue(data)       #:nodoc:
     header = [continue, data.bytesize].pack("vv")
     append(header, data)
 
-    # Turn the base class _add_continue() method back on.
+    # Turn the base class add_continue() method back on.
     @ignore_continue = 0
   end
   private :add_mso_drawing_group_continue
 
-  def devide_string(string, nth)
+  def devide_string(string, nth)       #:nodoc:
     first_string = string[0, nth]
     latter_string = string[nth, string.size - nth]
     [first_string, latter_string]
@@ -3009,7 +3003,7 @@ def devide_string(string, nth)
 
   ###############################################################################
   #
-  # _store_mso_dgg_container()
+  # store_mso_dgg_container()
   #
   # Write the Escher DggContainer record that is part of MSODRAWINGGROUP.
   #
@@ -3026,7 +3020,7 @@ def store_mso_dgg_container       #:nodoc:
 
   ###############################################################################
   #
-  # _store_mso_dgg()
+  # store_mso_dgg()
   #    my $max_spid        = $_[0];
   #    my $num_clusters    = $_[1];
   #    my $shapes_saved    = $_[2];
@@ -3058,7 +3052,7 @@ def store_mso_dgg(max_spid, num_clusters, shapes_saved, drawings_saved, clusters
 
   ###############################################################################
   #
-  # _store_mso_bstore_container()
+  # store_mso_bstore_container()
   #
   # Write the Escher BstoreContainer record that is part of MSODRAWINGGROUP.
   #
@@ -3077,7 +3071,7 @@ def store_mso_bstore_container       #:nodoc:
 
   ###############################################################################
   #
-  # _store_mso_images()
+  # store_mso_images()
   #    ref_count   = $_[0]
   #    image_type  = $_[1]
   #    image       = $_[2]
@@ -3109,7 +3103,7 @@ def store_mso_images(ref_count, image_type, image, size, checksum1, checksum2)
 
   ###############################################################################
   #
-  # _store_mso_blip_store_entry()
+  # store_mso_blip_store_entry()
   #    ref_count   = $_[0]
   #    image_type  = $_[1]
   #    size        = $_[2]
@@ -3140,7 +3134,7 @@ def store_mso_blip_store_entry(ref_count, image_type, size, checksum1)       #:n
 
   ###############################################################################
   #
-  # _store_mso_blip()
+  # store_mso_blip()
   #    image_type  = $_[0]
   #    image_data  = $_[1]
   #    size        = $_[2]
@@ -3172,7 +3166,7 @@ def store_mso_blip(image_type, image_data, size, checksum1, checksum2)       #:n
 
   ###############################################################################
   #
-  # _store_mso_opt()
+  # store_mso_opt()
   #
   # Write the Escher Opt record that is part of MSODRAWINGGROUP.
   #
@@ -3191,7 +3185,7 @@ def store_mso_opt       #:nodoc:
 
   ###############################################################################
   #
-  # _store_mso_split_menu_colors()
+  # store_mso_split_menu_colors()
   #
   # Write the Escher SplitMenuColors record that is part of MSODRAWINGGROUP.
   #
@@ -3208,8 +3202,9 @@ def store_mso_split_menu_colors       #:nodoc:
   end
   private :store_mso_split_menu_colors
 
-  def cleanup
+  def cleanup       #:nodoc:
     super
     sheets.each { |sheet| sheet.cleanup }
   end
+  private :cleanup
 end