writeexcel 0.6.4 → 0.6.5

data/lib/writeexcel/worksheet.rb

@@ -19,6 +19,8 @@
 class MaxSizeError < StandardError   #:nodoc:
 end
 
+module Writeexcel
+
 #
 # = class Worksheet
 #
@@ -30,14 +32,9 @@ class MaxSizeError < StandardError   #:nodoc:
 #  worksheet1 = workbook.add_worksheet
 #  worksheet2 = workbook.add_worksheet
 #
-
-module Writeexcel
-
 class Worksheet < BIFFWriter
   require 'writeexcel/helper'
 
-  NonAscii = /[^!"#\$%&'\(\)\*\+,\-\.\/\:\;<=>\?@0-9A-Za-z_\[\\\]\{\}^` ~\0\n]/
-
   RowMax   = 65536  # :nodoc:
   ColMax   = 256    # :nodoc:
   StrMax   = 0      # :nodoc:
@@ -192,7 +189,7 @@ def initialize(name, index, encoding, url_format, parser, tempdir,
 
   ###############################################################################
   #
-  # _close()
+  # close()
   #
   # Add data to the beginning of the workbook (note the reverse order)
   # and to the end of the workbook.
@@ -308,13 +305,13 @@ def close #:nodoc:
     store_bof(0x0010)
   end
 
-  def cleanup
+  def cleanup  # :nodoc:
     super
   end
 
   ###############################################################################
   #
-  # _compatibility_mode()
+  # compatibility_mode()
   #
   # Set the compatibility mode.
   #
@@ -642,7 +639,7 @@ def set_row(row, height = nil, format = nil, hidden = 0, level = 0, collapsed =
   #
   # Set the width of a single column or a range of columns.
   #--
-  # See also: _store_colinfo
+  # See also: store_colinfo
   #++
   #
   # This method can be used to change the default properties of a single
@@ -724,7 +721,7 @@ def set_row(row, height = nil, format = nil, hidden = 0, level = 0, collapsed =
   # programs in the examples directory of the distro.
   #
   # Excel allows up to 7 outline levels. Therefore the _level_ parameter
-  # should be in the range 0 <= $level <= 7.
+  # should be in the range 0 <= level <= 7.
   #
   def set_column(*args)
     data = args
@@ -734,12 +731,12 @@ def set_column(*args)
     if cell =~ /^\D/
       data = substitute_cellref(*args)
 
-      # Returned values $row1 and $row2 aren't required here. Remove them.
-      data.shift        # $row1
-      data.delete_at(1) # $row2
+      # Returned values row1 and row2 aren't required here. Remove them.
+      data.shift        # row1
+      data.delete_at(1) # row2
     end
 
-    return if data.size < 3  # Ensure at least $firstcol, $lastcol and $width
+    return if data.size < 3  # Ensure at least firstcol, lastcol and width
     return if data[0].nil?   # Columns must be defined.
     return if data[1].nil?
 
@@ -777,7 +774,7 @@ def set_column(*args)
   #   set_selection('B3:C8')
   #
   # Set which cell or cells are selected in a worksheet: see also the
-  # sub _store_selection
+  # sub store_selection
   #
   # This method can be used to specify which cell or cells are selected in a
   # worksheet. The most common requirement is to select a single cell, in which
@@ -799,9 +796,8 @@ def set_column(*args)
   #
   def set_selection(*args)
     # Check for a cell reference in A1 notation and substitute row and column
-    if args[0] =~ /^\D/
-      args = substitute_cellref(*args)
-    end
+    args = row_col_notation(args)
+
     @selection = args
   end
 
@@ -860,7 +856,7 @@ def outline_settings(*args)
   #
   # Set panes and mark them as frozen.
   #--
-  # See also _store_panes().
+  # See also store_panes().
   #++
   #
   # This method can be used to divide a worksheet into horizontal or vertical
@@ -900,9 +896,8 @@ def outline_settings(*args)
   #
   def freeze_panes(*args)
     # Check for a cell reference in A1 notation and substitute row and column
-    if args[0] =~ /^\D/
-      args = substitute_cellref(*args)
-    end
+    args = row_col_notation(args)
+
     # Extra flag indicated a split and freeze.
     @frozen_no_split = 0 if !args[4].nil? && args[4] != 0
 
@@ -917,7 +912,7 @@ def freeze_panes(*args)
   #
   # Set panes and mark them as split.
   #--
-  # See also _store_panes().
+  # See also store_panes().
   #++
   #
   # This method can be used to divide a worksheet into horizontal or vertical
@@ -929,7 +924,7 @@ def freeze_panes(*args)
   # position of the split. The units for _y_ and _x_ are the same as those
   # used by Excel to specify row height and column width. However, the
   # vertical and horizontal units are different from each other. Therefore you
-  # must specify the $y and $x parameters in terms of the row heights and
+  # must specify the _y_ and _x_ parameters in terms of the row heights and
   # column widths that you have set or the default values which are 12.75 for
   # a row and 8.43 for a column.
   #
@@ -1012,9 +1007,8 @@ def split_panes(*args)
   #
   def merge_range(*args)
     # Check for a cell reference in A1 notation and substitute row and column
-    if args[0] =~ /^\D/
-      args = substitute_cellref(*args)
-    end
+    args = row_col_notation(args)
+
     raise "Incorrect number of arguments" if args.size != 6 and args.size != 7
     raise "Format argument is not a format object" unless args[5].respond_to?(:xf_index)
 
@@ -1066,7 +1060,7 @@ def merge_range(*args)
   end
 
   #
-  # Set the worksheet zoom factor in the range 10 <= $scale <= 400:
+  # Set the worksheet zoom factor in the range 10 <= scale <= 400:
   #
   #     worksheet1.set_zoom(50)
   #     worksheet2.set_zoom(75)
@@ -1082,7 +1076,7 @@ def merge_range(*args)
   def set_zoom(scale = 100)
     # Confine the scale to Excel's range
     if scale < 10 or scale > 400
-      #           carp "Zoom factor $scale outside range: 10 <= zoom <= 400";
+      #           carp "Zoom factor scale outside range: 10 <= zoom <= 400";
       scale = 100
     end
 
@@ -1163,9 +1157,7 @@ def set_tab_color(color)
   #
   def autofilter(*args)
     # Check for a cell reference in A1 notation and substitute row and column
-    if args[0] =~ /^\D/
-      args = substitute_cellref(*args)
-    end
+    args = row_col_notation(args)
 
     return if args.size != 4 # Require 4 parameters
 
@@ -1289,10 +1281,9 @@ def filter_column(col, expression)
     #      raise "Incorrect number of arguments to filter_column()" unless @_ == 2
 
     # Check for a column reference in A1 notation and substitute.
-    if col =~ /^\D/
-      # Convert col ref to a cell ref and then to a col number.
-      no_use, col = substitute_cellref(col + '1')
-    end
+    # Convert col ref to a cell ref and then to a col number.
+    no_use, col = substitute_cellref(col + '1') if col =~ /^\D/
+
     col_first = @filter_area[2]
     col_last  = @filter_area[3]
 
@@ -1674,23 +1665,15 @@ def set_footer(string = '', margin = 0.50, encoding = 0)
     set_header_footer_common(:footer, string, margin, encoding)
   end
 
-  def set_header_footer_common(type, string, margin, encoding)
+  def set_header_footer_common(type, string, margin, encoding)  # :nodoc:
     ruby_19 { string = convert_to_ascii_if_ascii(string) }
 
     limit    = encoding != 0 ? 255 *2 : 255
 
     # 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
 
     if string.bytesize >= limit
@@ -1713,7 +1696,7 @@ def set_header_footer_common(type, string, margin, encoding)
   #
   # Set the rows to repeat at the top of each printed page.
   #--
-  # See also the _store_name_xxxx() methods in Workbook.rb.
+  # See also the store_name_xxxx() methods in Workbook.rb.
   #++
   #
   # Set the number of rows to repeat at the top of each printed page.
@@ -1739,7 +1722,7 @@ def repeat_rows(first_row, last_row = nil)
   #
   # Set the columns to repeat at the left hand side of each printed page.
   #--
-  # See also the _store_names() methods in Workbook.pm.
+  # See also the store_names() methods in Workbook.pm.
   #++
   #
   # For large Excel documents it is often desirable to have the first column
@@ -1760,9 +1743,9 @@ def repeat_columns(*args)
     if args[0] =~ /^\D/
       args = substitute_cellref(*args)
 
-      # Returned values $row1 and $row2 aren't required here. Remove them.
-      args.shift        # $row1
-      args.delete_at(1) # $row2
+      # Returned values row1 and row2 aren't required here. Remove them.
+      args.shift        # row1
+      args.delete_at(1) # row2
     end
 
     @title_colmin  = args[0]
@@ -1815,7 +1798,7 @@ def hide_gridlines(option = 1)
 
   #
   # Set the option to print the row and column headers on the printed page.
-  # See also the _store_print_headers() method.
+  # See also the store_print_headers() method.
   #
   # An Excel worksheet looks something like the following;
   #
@@ -1866,9 +1849,7 @@ def print_row_col_headers(option = nil)
   #
   def print_area(*args)
     # Check for a cell reference in A1 notation and substitute row and column
-    if args[0] =~ /^\D/
-      args = substitute_cellref(*args)
-    end
+    args = row_col_notation(args)
 
     return if args.size != 4 # Require 4 parameters
 
@@ -1903,7 +1884,7 @@ def print_across
   # Store the vertical and horizontal number of pages that will define the
   # maximum area printed.
   #--
-  # See also _store_setup() and _store_wsbool() below.
+  # See also store_setup() and store_wsbool() below.
   #++
   #
   # The fit_to_pages() method is used to fit the printed area to a specific
@@ -1957,7 +1938,7 @@ def fit_to_pages(width = 0, height = 0)
   def set_print_scale(scale = 100)
     # Confine the scale to Excel's range
     if scale < 10 or scale > 400
-      #           carp "Print scale $scale outside range: 10 <= zoom <= 400";
+      #           carp "Print scale scale outside range: 10 <= zoom <= 400";
       scale = 100
     end
 
@@ -2024,7 +2005,7 @@ def set_v_pagebreaks(breaks)
 
   ###############################################################################
   #
-  # _extract_filter_tokens($expression)
+  # extract_filter_tokens(expression)
   #
   # Extract the tokens from the filter expression. The tokens are mainly non-
   # whitespace groups. The only tricky part is to extract string tokens that
@@ -2039,8 +2020,6 @@ def set_v_pagebreaks(breaks)
   def extract_filter_tokens(expression = nil)   #:nodoc:
     return [] unless expression
 
-    #  @tokens = ($expression  =~ /"(?:[^"]|"")*"|\S+/g); #"
-
     tokens = []
     str = expression
     while str =~ /"(?:[^"]|"")*"|\S+/
@@ -2068,7 +2047,7 @@ def extract_filter_tokens(expression = nil)   #:nodoc:
 
   ###############################################################################
   #
-  # _parse_filter_expression(expression, @token)
+  # parse_filter_expression(expression, @token)
   #
   # Converts the tokens of a possibly conditional expression into 1 or 2
   # sub expressions for further parsing.
@@ -2102,7 +2081,7 @@ def parse_filter_expression(expression, tokens)   #:nodoc:
 
   ###############################################################################
   #
-  # _parse_filter_tokens(@token)  # (@expression, @token)
+  # parse_filter_tokens(@token)  # (@expression, @token)
   #
   # Parse the 3 tokens of a filter expression and return the operator and token.
   #
@@ -2219,15 +2198,15 @@ def parse_filter_tokens(expression, tokens)     #:nodoc:
   #    worksheet.write('A1', '01209')
   #
   #    # Write a zero padded number using a format: 01209
-  #    my $format1 = $workbook.add_format(:num_format => '00000')
-  #    $worksheet.write('A2', '01209', format1)
+  #    format1 = workbook.add_format(:num_format => '00000')
+  #    worksheet.write('A2', '01209', format1)
   #
   #    # Write explicitly as a string: 01209
-  #    $worksheet.write_string('A3', '01209')
+  #    worksheet.write_string('A3', '01209')
   #
   #    # Write implicitly as a string: 01209
-  #    $worksheet.keep_leading_zeros()
-  #    $worksheet.write('A4', '01209')
+  #    worksheet.keep_leading_zeros()
+  #    worksheet.write('A4', '01209')
   #
   # The above code would generate a worksheet that looked like the following:
   #
@@ -2329,6 +2308,7 @@ def set_first_row_column(row = 0, col = 0)
     @first_col = col
   end
 
+  #--
   #
   # Allow the user to add their own matches and handlers to the write() method.
   #
@@ -2421,11 +2401,12 @@ def set_first_row_column(row = 0, col = 0)
   # See the write_handler 1-4 programs in the examples directory for further
   # examples.
   #
-  def add_write_handler(regexp, code_ref)
-    #       return unless ref $_[1] eq 'CODE';
-
-    @write_match.push([regexp, code_ref])
-  end
+  #++
+#  def add_write_handler(regexp, code_ref)
+#    #       return unless ref $_[1] eq 'CODE';
+#
+#    @write_match.push([regexp, code_ref])
+#  end
 
   #
   # :call-seq:
@@ -2481,27 +2462,27 @@ def add_write_handler(regexp, code_ref)
   #
   # The "looks like" rule is defined by regular expressions:
   #
-  # write_number() if _token_ is a number based on the following regex:
-  # token =~ /^([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/.
+  # * write_number() if _token_ is a number based on the following regex:
+  #   token =~ /^([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/.
   #
-  # write_string() if keep_leading_zeros() is set and _token_ is an integer
-  # with leading zeros based on the following regex: token =~ /^0\d+$/.
+  # * write_string() if keep_leading_zeros() is set and _token_ is an integer
+  #   with leading zeros based on the following regex: token =~ /^0\d+$/.
   #
-  # write_blank() if _token_ is undef or a blank string: undef, "" or ''.
+  # * write_blank() if _token_ is undef or a blank string: undef, "" or ''.
   #
-  # write_url() if _token_ is a http, https, ftp or mailto URL based on the
-  # following regexes: token =~ m|^[fh]tt?ps?://| or $token =~ m|^mailto:|.
+  # * write_url() if _token_ is a http, https, ftp or mailto URL based on the
+  #   following regexes: token =~ m|^[fh]tt?ps?://| or $token =~ m|^mailto:|.
   #
-  # write_url() if _token_ is an internal or external sheet reference based
-  # on the following regex: token =~ m[^(in|ex)ternal:].
+  # * write_url() if _token_ is an internal or external sheet reference based
+  #   on the following regex: token =~ m[^(in|ex)ternal:].
   #
-  # write_formula() if the first character of _token_ is "=".
+  # * write_formula() if the first character of _token_ is "=".
   #
-  # write_row() if _token_ is an array.
+  # * write_row() if _token_ is an array.
   #
-  # write_col() if _token+ is an array of array.
+  # * write_col() if _token+ is an array of array.
   #
-  # write_string() if none of the previous conditions apply.
+  # * write_string() if none of the previous conditions apply.
   #
   # The format parameter is optional. It should be a valid Format object, see
   # "CELL FORMATTING":
@@ -2539,9 +2520,7 @@ def add_write_handler(regexp, code_ref)
   #
   def write(*args)
     # Check for a cell reference in A1 notation and substitute row and column
-    if args[0] =~ /^\D/
-      args = substitute_cellref(*args)
-    end
+    args = row_col_notation(args)
 
     token = args[2]
 
@@ -2609,9 +2588,7 @@ def write(*args)
   #
   def write_number(*args)
     # Check for a cell reference in A1 notation and substitute row and column
-    if args[0] =~ /^\D/
-      args = substitute_cellref(*args)
-    end
+    args = row_col_notation(args)
 
     return -1 if args.size < 3                # Check the number of args
 
@@ -2687,9 +2664,7 @@ def write_number(*args)
   #
   def write_string(*args)
     # Check for a cell reference in A1 notation and substitute row and column
-    if args[0] =~ /^\D/
-      args = substitute_cellref(*args)
-    end
+    args = row_col_notation(args)
 
     return -1 if (args.size < 3)                # Check the number of args
 
@@ -2707,17 +2682,9 @@ def write_string(*args)
     ruby_19 {str = convert_to_ascii_if_ascii(str) }
 
     # Handle utf8 strings
-    ruby_18 do
-      if str =~ NonAscii
-        str_utf16le = utf8_to_16le(str)
-        return write_utf16le_string(row, col, str_utf16le, args[3])
-      end
-    end
-    ruby_19 do
-      if str.encoding == Encoding::UTF_8
-        str_utf16le = utf8_to_16le(str)
-        return write_utf16le_string(row, col, str_utf16le, args[3])
-      end
+    if is_utf8?(str)
+      str_utf16le = utf8_to_16le(str)
+      return write_utf16le_string(row, col, str_utf16le, args[3])
     end
 
     # Check that row and col are valid and store max and min values
@@ -2749,7 +2716,7 @@ def write_string(*args)
     str_error
   end
 
-  def store_with_compatibility(row, col, data)
+  def store_with_compatibility(row, col, data)  # :nodoc:
     if @compatibility != 0
       store_to_table(row, col, data)
     else
@@ -2758,7 +2725,7 @@ def store_with_compatibility(row, col, data)
   end
   private :store_with_compatibility
 
-  def store_to_table(row, col, data)
+  def store_to_table(row, col, data)  # :nodoc:
     tmp = []
     tmp[col] = data
     @table[row] = tmp
@@ -2802,9 +2769,7 @@ def store_to_table(row, col, data)
   #
   def write_blank(*args)
     # Check for a cell reference in A1 notation and substitute row and column
-    if args[0] =~ /^\D/
-      args = substitute_cellref(*args)
-    end
+    args = row_col_notation(args)
 
     # Check the number of args
     return -1 if args.size < 2
@@ -3111,9 +3076,7 @@ def write_blank(*args)
   # ++
   def write_formula(*args)
     # Check for a cell reference in A1 notation and substitute row and column
-    if (args[0] =~ /^\D/)
-      args = substitute_cellref(args)
-    end
+    args = row_col_notation(args)
 
     return -1 if args.size < 3   # Check the number of args
 
@@ -3216,9 +3179,7 @@ def write_formula(*args)
   #
   def write_row(*args)
     # Check for a cell reference in A1 notation and substitute row and column
-    if args[0] =~ /^\D/
-      args = substitute_cellref(*args)
-    end
+    args = row_col_notation(args)
 
     # Catch non array refs passed by user.
     unless args[2].respond_to?(:to_ary)
@@ -3320,9 +3281,7 @@ def write_row(*args)
   #
   def write_col(*args)
     # Check for a cell reference in A1 notation and substitute row and column
-    if args[0] =~ /^\D/
-      args = substitute_cellref(*args)
-    end
+    args = row_col_notation(args)
 
     # Catch non array refs passed by user.
     unless args[2].respond_to?(:to_ary)
@@ -3533,9 +3492,7 @@ def write_col(*args)
   #
   def write_comment(*args)
     # Check for a cell reference in A1 notation and substitute row and column
-    if args[0] =~ /^\D/
-      args = substitute_cellref(*args)
-    end
+    args = row_col_notation(args)
 
     return -1 if args.size < 3   # Check the number of args
 
@@ -3666,7 +3623,7 @@ def image_mso_size=(val)  # :nodoc:
 
   ###############################################################################
   #
-  # _xf_record_index()
+  # xf_record_index()
   #
   # Returns an index to the XF record in the workbook.
   #
@@ -3693,7 +3650,7 @@ def xf_record_index(row, col, xf=nil)       #:nodoc:
 
   ###############################################################################
   #
-  # _substitute_cellref()
+  # substitute_cellref()
   #
   # Substitute an Excel cell reference in A1 notation for  zero based row and
   # column values in an argument list.
@@ -3733,7 +3690,7 @@ def substitute_cellref(cell, *args)       #:nodoc:
 
   ###############################################################################
   #
-  # _cell_to_rowcol($cell_ref)
+  # cell_to_rowcol($cell_ref)
   #
   # Convert an Excel cell reference in A1 notation to a zero based row and column
   # reference; converts C1 to (0, 2).
@@ -3757,11 +3714,11 @@ def cell_to_rowcol(cell)       #:nodoc:
 
   ###############################################################################
   #
-  # _sort_pagebreaks()
+  # sort_pagebreaks()
   #
   #
   # This is an internal method that is used to filter elements of the array of
-  # pagebreaks used in the _store_hbreak() and _store_vbreak() methods. It:
+  # pagebreaks used in the store_hbreak() and store_vbreak() methods. It:
   #   1. Removes duplicate entries from the list.
   #   2. Sorts the list.
   #   3. Removes 0 from the list if present.
@@ -3778,7 +3735,7 @@ def sort_pagebreaks(breaks)       #:nodoc:
 
   ###############################################################################
   #
-  # _encode_password($password)
+  # encode_password($password)
   #
   # Based on the algorithm provided by Daniel Rentz of OpenOffice.
   #
@@ -3806,7 +3763,7 @@ def encode_password(password)       #:nodoc:
 
   ###############################################################################
   #
-  # _encode_formula_result()
+  # encode_formula_result()
   #     my $value     = $_[0];      # Result to be encoded.
   #
   # Encode the user supplied result for a formula.
@@ -3857,7 +3814,7 @@ def encode_formula_result(value = nil)       #:nodoc:
 
   ###############################################################################
   #
-  # _get_formula_string()
+  # get_formula_string()
   #
   # Pack the string value when a formula evaluates to a string. The value cannot
   # be calculated by the module and thus must be supplied by the user.
@@ -3872,17 +3829,9 @@ def get_formula_string(string)       #:nodoc:
     encoding  = 0              # String encoding.
 
     # 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
 
     length    = 0x03 + string.bytesize  # Length of the record data
@@ -4076,9 +4025,7 @@ def store_formula(formula)       #:nodoc:
   #
   def repeat_formula(*args)       #:nodoc:
     # Check for a cell reference in A1 notation and substitute row and column
-    if args[0] =~ /^\D/
-      args = substitute_cellref(args)
-    end
+    args = row_col_notation(args)
 
     return -1 if (args.size < 2)   # Check the number of args
 
@@ -4132,7 +4079,7 @@ def repeat_formula(*args)       #:nodoc:
     0
   end
 
-  def store_formula_common(row, col, xf, value, formula)
+  def store_formula_common(row, col, xf, value, formula)  # :nodoc:
     # Excel normally stores the last calculated value of the formula in $num.
     # Clearly we are not in a position to calculate this "a priori". Instead
     # we set $num to zero and set the option flags in $grbit to ensure
@@ -4251,9 +4198,7 @@ def store_formula_common(row, col, xf, value, formula)
   #
   def write_url(*args)
     # Check for a cell reference in A1 notation and substitute row and column
-    if args[0] =~ /^\D/
-      args = substitute_cellref(*args)
-    end
+    args = row_col_notation(args)
 
     # Check the number of args
     return -1 if args.size < 3
@@ -4297,9 +4242,7 @@ def write_url(*args)
   #
   def write_url_range(*args)
     # Check for a cell reference in A1 notation and substitute row and column
-    if args[0] =~ /^\D/
-      args = substitute_cellref(*args)
-    end
+    args = row_col_notation(args)
 
     # Check the number of args
     return -1 if args.size < 5
@@ -4320,7 +4263,7 @@ def write_url_range(*args)
 
   ###############################################################################
   #
-  # _write_url_web($row1, $col1, $row2, $col2, $url, $string, $format)
+  # write_url_web($row1, $col1, $row2, $col2, $url, $string, $format)
   #    row1        = $_[0];                        # Start row
   #    col1        = $_[1];                        # Start column
   #    row2        = $_[2];                        # End row
@@ -4360,19 +4303,12 @@ def write_url_web(row1, col1, row2, col2, url, str = nil, format = nil)       #:
     encoding    = 0
 
     # Convert an Utf8 URL type and to a null terminated wchar string.
-    ruby_18 do
-      if url =~ NonAscii
-        url = utf8_to_16be(url)
-        url += "\0\0"                              # URL is null terminated.
-        encoding = 1
-      end
-    end
-    ruby_19 do
-      if url.encoding == Encoding::UTF_8
-        url = url.encode('UTF-16BE')
-        url += "\0\0".force_encoding('UTF-16BE')   # URL is null terminated.
-        encoding = 1
-      end
+    if is_utf8?(url)
+      url = utf8_to_16be(url)
+      # URL is null terminated.
+      ruby_18 { url += "\0\0" } ||
+      ruby_19 { url += "\0\0".force_encoding('UTF-16BE') }
+      encoding = 1
     end
 
     # Convert an Ascii URL type and to a null terminated wchar string.
@@ -4402,7 +4338,7 @@ def write_url_web(row1, col1, row2, col2, url, str = nil, format = nil)       #:
 
   ###############################################################################
   #
-  # _write_url_internal($row1, $col1, $row2, $col2, $url, $string, $format)
+  # write_url_internal($row1, $col1, $row2, $col2, $url, $string, $format)
   #    row1        = $_[0];                        # Start row
   #    col1        = $_[1];                        # Start column
   #    row2        = $_[2];                        # End row
@@ -4440,21 +4376,13 @@ def write_url_internal(row1, col1, row2, col2, url, str = nil, format = nil)
     encoding    = 0
 
     # Convert an Utf8 URL type and to a null terminated wchar string.
-    ruby_18 do
-      if str =~ NonAscii
-        # Quote sheet name if not already, i.e., Sheet!A1 to 'Sheet!A1'.
-        url.sub!(/^(.+)!/, "'\1'!") if not url =~ /^'/;
-        url = utf8_to_16be(url) + "\0\0"  # URL is null terminated.
-        encoding = 1
-      end
-    end
-    ruby_19 do
-      if str.encoding == Encoding::UTF_8
-        # Quote sheet name if not already, i.e., Sheet!A1 to 'Sheet!A1'.
-        url.sub!(/^(.+)!/, "'\1'!") if not url =~ /^'/;
-        url = url.encode('UTF-16LE') + "\0\0".encode('UTF-16LE')  # URL is null terminated.
-        encoding = 1
-      end
+    if is_utf8?(str)
+      # Quote sheet name if not already, i.e., Sheet!A1 to 'Sheet!A1'.
+      url.sub!(/^(.+)!/, "'\1'!") if not url =~ /^'/;
+      # URL is null terminated.
+      ruby_18 { url = utf8_to_16be(url) + "\0\0" } ||
+      ruby_19 { url = url.encode('UTF-16LE') + "\0\0".encode('UTF-16LE') }
+      encoding = 1
     end
 
     # Convert an Ascii URL type and to a null terminated wchar string.
@@ -4482,7 +4410,7 @@ def write_url_internal(row1, col1, row2, col2, url, str = nil, format = nil)
 
   ###############################################################################
   #
-  # _write_url_external($row1, $col1, $row2, $col2, $url, $string, $format)
+  # write_url_external($row1, $col1, $row2, $col2, $url, $string, $format)
   #
   # Write links to external directory names such as 'c:\foo.xls',
   # c:\foo.xls#Sheet1!A1', '../../foo.xls'. and '../../foo.xls#Sheet1!A1'.
@@ -4582,7 +4510,7 @@ def write_url_external(row1, col1, row2, col2, url, str = nil, format = nil)
 
   ###############################################################################
   #
-  # _write_url_external_net($row1, $col1, $row2, $col2, $url, $string, $format)
+  # write_url_external_net($row1, $col1, $row2, $col2, $url, $string, $format)
   #
   # Write links to external MS/Novell network drives and shares such as
   # '//NETWORK/share/foo.xls' and '//NETWORK/share/foo.xls#Sheet1!A1'.
@@ -4648,7 +4576,7 @@ def write_url_external_net(row1, col1, row2, col2, url, str, format)       #:nod
   # parameters accordingly.
   # Split the dir name and sheet name (if it exists)
   #
-  def analyze_link(url, absolute = nil)
+  def analyze_link(url, absolute = nil)  # :nodoc:
     dir_long , sheet = url.split(/\#/)
     link_type = absolute ? (0x01 | absolute) : 0x0103
 
@@ -4716,9 +4644,7 @@ def analyze_link(url, absolute = nil)
   #
   def write_date_time(*args)
     # Check for a cell reference in A1 notation and substitute row and column
-    if args[0] =~ /^\D/
-      args = substitute_cellref(*args)
-    end
+    args = row_col_notation(args)
 
     return -1 if (args.size < 3)                 # Check the number of args
 
@@ -4863,7 +4789,7 @@ def convert_date_time(date_time_string)       #:nodoc:
 
   ###############################################################################
   #
-  # _write_row_default()
+  # write_row_default()
   #        row    : Row Number
   #        colMic : First defined column
   #        colMac : Last defined column
@@ -4889,10 +4815,10 @@ def write_row_default(row, colMic, colMac)       #:nodoc:
 
   ###############################################################################
   #
-  # _check_dimensions($row, $col, $ignore_row, $ignore_col)
+  # check_dimensions($row, $col, $ignore_row, $ignore_col)
   #
   # Check that $row and $col are valid and store max and min values for use in
-  # DIMENSIONS record. See, _store_dimensions().
+  # DIMENSIONS record. See, store_dimensions().
   #
   # The $ignore_row/$ignore_col flags is used to indicate that we wish to
   # perform the dimension check without storing the value.
@@ -4932,14 +4858,14 @@ def check_dimensions(row, col, ignore_row = 0, ignore_col = 0)       #:nodoc:
 
   ###############################################################################
   #
-  # _store_dimensions()
+  # store_dimensions()
   #
   # Writes Excel DIMENSIONS to define the area in which there is cell data.
   #
   # Notes:
   #   Excel stores the max row/col as row/col +1.
   #   Max and min values of 0 are used to indicate that no cell data.
-  #   We set the undef member data to 0 since it is used by _store_table().
+  #   We set the undef member data to 0 since it is used by store_table().
   #   Inserting images or charts doesn't change the DIMENSION data.
   #
   def store_dimensions   #:nodoc:
@@ -4952,7 +4878,7 @@ def store_dimensions   #:nodoc:
     col_min = @dim_colmin.nil? ? 0 : @dim_colmin
     col_max = @dim_colmax.nil? ? 0 : @dim_colmax + 1
 
-    # Set member data to the new max/min value for use by _store_table().
+    # Set member data to the new max/min value for use by store_table().
     @dim_rowmin = row_min
     @dim_rowmax = row_max
     @dim_colmin = col_min
@@ -4968,7 +4894,7 @@ def store_dimensions   #:nodoc:
 
   ###############################################################################
   #
-  # _store_window2()
+  # store_window2()
   #
   # Write BIFF record Window2.
   #
@@ -5022,7 +4948,7 @@ def store_window2   #:nodoc:
 
   ###############################################################################
   #
-  # _store_page_view()
+  # store_page_view()
   #
   # Set page view mode. Only applicable to Mac Excel.
   #
@@ -5035,7 +4961,7 @@ def store_page_view   #:nodoc:
 
   ###############################################################################
   #
-  # _store_tab_color()
+  # store_tab_color()
   #
   # Write the Tab Color BIFF record.
   #
@@ -5057,7 +4983,7 @@ def store_tab_color   #:nodoc:
 
   ###############################################################################
   #
-  # _store_defrow()
+  # store_defrow()
   #
   # Write BIFF record DEFROWHEIGHT.
   #
@@ -5077,7 +5003,7 @@ def store_defrow   #:nodoc:
 
   ###############################################################################
   #
-  # _store_defcol()
+  # store_defcol()
   #
   # Write BIFF record DEFCOLWIDTH.
   #
@@ -5095,7 +5021,7 @@ def store_defcol   #:nodoc:
 
   ###############################################################################
   #
-  # _store_colinfo($firstcol, $lastcol, $width, $format, $hidden)
+  # store_colinfo($firstcol, $lastcol, $width, $format, $hidden)
   #
   #   firstcol : First formatted column
   #   lastcol  : Last formatted column
@@ -5155,7 +5081,7 @@ def store_colinfo(firstcol=0, lastcol=0, width=8.43, format=nil, hidden=0, level
 
   ###############################################################################
   #
-  # _store_filtermode()
+  # store_filtermode()
   #
   # Write BIFF record FILTERMODE to indicate that the worksheet contains
   # AUTOFILTER record, ie. autofilters with a filter set.
@@ -5175,7 +5101,7 @@ def store_filtermode   #:nodoc:
 
   ###############################################################################
   #
-  # _store_autofilterinfo()
+  # store_autofilterinfo()
   #
   # Write BIFF record AUTOFILTERINFO.
   #
@@ -5196,7 +5122,7 @@ def store_autofilterinfo   #:nodoc:
 
   ###############################################################################
   #
-  # _store_selection($first_row, $first_col, $last_row, $last_col)
+  # store_selection($first_row, $first_col, $last_row, $last_col)
   #
   # Write BIFF record SELECTION.
   #
@@ -5238,7 +5164,7 @@ def store_selection(first_row=0, first_col=0, last_row = nil, last_col =nil)   #
 
   ###############################################################################
   #
-  # _store_externcount($count)
+  # store_externcount($count)
   #
   # Write BIFF record EXTERNCOUNT to indicate the number of external sheet
   # references in a worksheet.
@@ -5264,7 +5190,7 @@ def store_externcount(count)   #:nodoc:
 
   ###############################################################################
   #
-  # _store_externsheet($sheetname)
+  # store_externsheet($sheetname)
   #    sheetname  : Worksheet name
   #
   # Writes the Excel BIFF EXTERNSHEET record. These references are used by
@@ -5302,7 +5228,7 @@ def store_externsheet(sheetname)   #:nodoc:
 
   ###############################################################################
   #
-  # _store_panes(y, x, colLeft, no_split, pnnAct)
+  # store_panes(y, x, colLeft, no_split, pnnAct)
   #    y           = args[0] || 0   # Vertical split position
   #    x           = $_[1] || 0;   # Horizontal split position
   #    rwTop       = $_[2];        # Top row visible
@@ -5350,7 +5276,7 @@ def store_panes(y=0, x=0, rwtop=nil,  colleft=nil, no_split=nil, pnnAct=nil)   #
       pnnAct = 3 if (x == 0 && y == 0) # Top left
     end
 
-    @active_pane = pnnAct # Used in _store_selection
+    @active_pane = pnnAct # Used in store_selection
 
     store_simple(record, length, x, y, rwtop, colleft, pnnAct)
   end
@@ -5358,7 +5284,7 @@ def store_panes(y=0, x=0, rwtop=nil,  colleft=nil, no_split=nil, pnnAct=nil)   #
 
   ###############################################################################
   #
-  # _store_setup()
+  # store_setup()
   #
   # Store the page setup SETUP BIFF record.
   #
@@ -5419,7 +5345,7 @@ def store_setup   #:nodoc:
 
   ###############################################################################
   #
-  # _store_header()
+  # store_header()
   #
   # Store the header caption BIFF record.
   #
@@ -5430,7 +5356,7 @@ def store_header   #:nodoc:
 
   ###############################################################################
   #
-  # _store_footer()
+  # store_footer()
   #
   # Store the footer caption BIFF record.
   #
@@ -5442,7 +5368,7 @@ def store_footer   #:nodoc:
   #
   # type :  :header / :footer
   #
-  def store_header_footer_common(type)
+  def store_header_footer_common(type)  # :nodoc:
     if type == :header
       record   = 0x0014
       str      = @header
@@ -5471,7 +5397,7 @@ def store_header_footer_common(type)
 
   ###############################################################################
   #
-  # _store_hcenter()
+  # store_hcenter()
   #
   # Store the horizontal centering HCENTER BIFF record.
   #
@@ -5482,7 +5408,7 @@ def store_hcenter   #:nodoc:
 
   ###############################################################################
   #
-  # _store_vcenter()
+  # store_vcenter()
   #
   # Store the vertical centering VCENTER BIFF record.
   #
@@ -5493,7 +5419,7 @@ def store_vcenter   #:nodoc:
 
   ###############################################################################
   #
-  # _store_margin_left()
+  # store_margin_left()
   #
   # Store the LEFTMARGIN BIFF record.
   #
@@ -5504,7 +5430,7 @@ def store_margin_left   #:nodoc:
 
   ###############################################################################
   #
-  # _store_margin_right()
+  # store_margin_right()
   #
   # Store the RIGHTMARGIN BIFF record.
   #
@@ -5515,7 +5441,7 @@ def store_margin_right   #:nodoc:
 
   ###############################################################################
   #
-  # _store_margin_top()
+  # store_margin_top()
   #
   # Store the TOPMARGIN BIFF record.
   #
@@ -5526,7 +5452,7 @@ def store_margin_top   #:nodoc:
 
   ###############################################################################
   #
-  # _store_margin_bottom()
+  # store_margin_bottom()
   #
   # Store the BOTTOMMARGIN BIFF record.
   #
@@ -5540,7 +5466,7 @@ def store_margin_bottom   #:nodoc:
   # length     : bytes to follow
   # margin     : Margin in inches
   #
-  def store_margin_common(record, length, margin)
+  def store_margin_common(record, length, margin)  # :nodoc:
     header  = [record, length].pack('vv')
     data    = [margin].pack('d')
 
@@ -5559,9 +5485,7 @@ def store_margin_common(record, length, margin)
   #
   def merge_cells(*args) #:nodoc:
     # Check for a cell reference in A1 notation and substitute row and column
-    if args[0] =~ /^\D/
-      args = substitute_cellref(*args)
-    end
+    args = row_col_notation(args)
 
     record  = 0x00E5                    # Record identifier
     length  = 0x000A                    # Bytes to follow
@@ -5584,7 +5508,7 @@ def merge_cells(*args) #:nodoc:
 
   ###############################################################################
   #
-  # _store_print_headers()
+  # store_print_headers()
   #
   # Write the PRINTHEADERS BIFF record.
   #
@@ -5595,7 +5519,7 @@ def store_print_headers   #:nodoc:
 
   ###############################################################################
   #
-  # _store_print_gridlines()
+  # store_print_gridlines()
   #
   # Write the PRINTGRIDLINES BIFF record. Must be used in conjunction with the
   # GRIDSET record.
@@ -5605,7 +5529,7 @@ def store_print_gridlines   #:nodoc:
   end
   private :store_print_gridlines
 
-  def store_biff_common(type)
+  def store_biff_common(type)  # :nodoc:
     case type
     when :hcenter
       record = 0x0083
@@ -5631,7 +5555,7 @@ def store_biff_common(type)
 
   ###############################################################################
   #
-  # _store_gridset()
+  # store_gridset()
   #
   # Write the GRIDSET BIFF record. Must be used in conjunction with the
   # PRINTGRIDLINES record.
@@ -5651,11 +5575,11 @@ def store_gridset   #:nodoc:
 
   ###############################################################################
   #
-  # _store_guts()
+  # store_guts()
   #
   # Write the GUTS BIFF record. This is used to configure the gutter margins
   # where Excel outline symbols are displayed. The visibility of the gutters is
-  # controlled by a flag in WSBOOL. See also _store_wsbool().
+  # controlled by a flag in WSBOOL. See also store_wsbool().
   #
   # We are all in the gutter but some of us are looking at the stars.
   #
@@ -5696,7 +5620,7 @@ def store_guts   #:nodoc:
 
   ###############################################################################
   #
-  # _store_wsbool()
+  # store_wsbool()
   #
   # Write the WSBOOL BIFF record, mainly for fit-to-page. Used in conjunction
   # with the SETUP record.
@@ -5724,7 +5648,7 @@ def store_wsbool   #:nodoc:
 
   ###############################################################################
   #
-  # _store_hbreak()
+  # store_hbreak()
   #
   # Write the HORIZONTALPAGEBREAKS BIFF record.
   #
@@ -5735,7 +5659,7 @@ def store_hbreak   #:nodoc:
 
   ###############################################################################
   #
-  # _store_vbreak()
+  # store_vbreak()
   #
   # Write the VERTICALPAGEBREAKS BIFF record.
   #
@@ -5744,7 +5668,7 @@ def store_vbreak   #:nodoc:
   end
   private :store_vbreak
 
-  def store_breaks_common(breaks)
+  def store_breaks_common(breaks)  # :nodoc:
     unless breaks.empty?
       record  = breaks == @vbreaks ? 0x001a : 0x001b # Record identifier
       cbrk    = breaks.size   # Number of page breaks
@@ -5765,7 +5689,7 @@ def store_breaks_common(breaks)
 
   ###############################################################################
   #
-  # _store_protect()
+  # store_protect()
   #
   # Set the Biff PROTECT record to indicate that the worksheet is protected.
   #
@@ -5776,7 +5700,7 @@ def store_protect   #:nodoc:
 
   ###############################################################################
   #
-  # _store_obj_protect()
+  # store_obj_protect()
   #
   # Set the Biff OBJPROTECT record to indicate that objects are protected.
   #
@@ -5785,7 +5709,7 @@ def store_obj_protect   #:nodoc:
   end
   private :store_obj_protect
 
-  def store_protect_common(type = nil)
+  def store_protect_common(type = nil)  # :nodoc:
     if @protect != 0
       record = if type == :obj      # Record identifier
         0x0063                      # store_obj_protect
@@ -5807,7 +5731,7 @@ def store_protect_common(type = nil)
 
   ###############################################################################
   #
-  # _store_password()
+  # store_password()
   #
   # Write the worksheet PASSWORD record.
   #
@@ -5849,7 +5773,7 @@ def store_password   #:nodoc:
 
   ###############################################################################
   #
-  # _store_table()
+  # store_table()
   #
   # Write cell data stored in the worksheet row/col table.
   #
@@ -5942,9 +5866,9 @@ def store_table   #:nodoc:
 
   ###############################################################################
   #
-  # _store_dbcell()
+  # store_dbcell()
   #
-  # Store the DBCELL record using the offset calculated in _store_table().
+  # Store the DBCELL record using the offset calculated in store_table().
   #
   # This is only used when compatibity_mode() is in operation.
   #
@@ -5964,9 +5888,9 @@ def store_dbcell(row_offset, cell_offsets)   #:nodoc:
 
   ###############################################################################
   #
-  # _store_index()
+  # store_index()
   #
-  # Store the INDEX record using the DBCELL offsets calculated in _store_table().
+  # Store the INDEX record using the DBCELL offsets calculated in store_table().
   #
   # This is only used when compatibity_mode() is in operation.
   #
@@ -6047,9 +5971,7 @@ def store_index   #:nodoc:
   #
   def insert_chart(*args)
     # Check for a cell reference in A1 notation and substitute row and column
-    if args[0] =~ /^\D/
-      args = substitute_cellref(*args)
-    end
+    args = row_col_notation(args)
 
     row         = args[0]
     col         = args[1]
@@ -6132,9 +6054,7 @@ def insert_chart(*args)
   #
   def insert_image(*args)
     # Check for a cell reference in A1 notation and substitute row and column
-    if args[0] =~ /^\D/
-      args = substitute_cellref(*args)
-    end
+    args = row_col_notation(args)
 
     row         = args[0]
     col         = args[1]
@@ -6159,7 +6079,7 @@ def insert_image(*args)
 
   ###############################################################################
   #
-  #  _position_object()
+  #  position_object()
   #
   # Calculate the vertices that define the position of a graphical object within
   # the worksheet.
@@ -6267,7 +6187,7 @@ def position_object(col_start, row_start, x1, y1, width, height)   #:nodoc:
     ]
   end
 
-  def adjust_col_position(x, col)
+  def adjust_col_position(x, col)  # :nodoc:
     while x >= size_col(col)
       x -= size_col(col)
       col += 1
@@ -6276,7 +6196,7 @@ def adjust_col_position(x, col)
   end
   private :adjust_col_position
 
-  def adjust_row_position(y, row)
+  def adjust_row_position(y, row)  # :nodoc:
     while y >= size_row(row)
       y -= size_row(row)
       row += 1
@@ -6287,7 +6207,7 @@ def adjust_row_position(y, row)
 
   ###############################################################################
   #
-  # _size_col($col)
+  # size_col($col)
   #
   # Convert the width of a cell from user's units to pixels. Excel rounds the
   # column width to the nearest pixel. If the width hasn't been set by the user
@@ -6312,7 +6232,7 @@ def size_col(col)   #:nodoc:
 
   ###############################################################################
   #
-  # _size_row($row)
+  # size_row($row)
   #
   # Convert the height of a cell from user's units to pixels. By interpolation
   # the relationship is: y = 4/3x. If the height hasn't been set by the user we
@@ -6335,7 +6255,7 @@ def size_row(row)   #:nodoc:
 
   ###############################################################################
   #
-  # _store_zoom($zoom)
+  # store_zoom($zoom)
   #
   #
   # Store the window zoom factor. This should be a reduced fraction but for
@@ -6365,9 +6285,7 @@ def store_zoom   #:nodoc:
   #
   def write_utf16be_string(*args)
     # Check for a cell reference in A1 notation and substitute row and column
-    if args[0] =~ /^\D/
-      args = substitute_cellref(*args)
-    end
+    args = row_col_notation(args)
 
     return -1 if (args.size < 3)                     # Check the number of args
 
@@ -6433,9 +6351,7 @@ def write_utf16be_string(*args)
   #
   def write_utf16le_string(*args)
     # Check for a cell reference in A1 notation and substitute row and column
-    if args[0] =~ /^\D/
-      args = substitute_cellref(*args)
-    end
+    args = row_col_notation(args)
 
     return -1 if (args.size < 3)                     # Check the number of args
 
@@ -6460,7 +6376,7 @@ def write_utf16le_string(*args)
 
   ###############################################################################
   #
-  # _store_autofilters()
+  # store_autofilters()
   #
   # Function to iterate through the columns that form part of an autofilter
   # range and write Biff AUTOFILTER records if a filter expression has been set.
@@ -6487,7 +6403,7 @@ def store_autofilters   #:nodoc:
 
   ###############################################################################
   #
-  # _store_autofilter()
+  # store_autofilter()
   #    my $index           = $_[0];
   #    my $operator_1      = $_[1];
   #    my $token_1         = $_[2];
@@ -6520,7 +6436,7 @@ def store_autofilter(index, operator_1, token_1,   #:nodoc:
     optimised_1 = 1 if                      operator_1 == 2
     optimised_2 = 1 if !operator_2.nil? and operator_2 == 2
 
-    # Convert non-simple equalities back to type 2. See  _parse_filter_tokens().
+    # Convert non-simple equalities back to type 2. See  parse_filter_tokens().
     operator_1 = 2 if                      operator_1 == 22
     operator_2 = 2 if !operator_2.nil? and operator_2 == 22
 
@@ -6579,7 +6495,7 @@ def store_autofilter(index, operator_1, token_1,   #:nodoc:
 
   ###############################################################################
   #
-  # _pack_doper()
+  # pack_doper()
   #
   # Create a Biff Doper structure that represents a filter expression. Depending
   # on the type of the token we pack an Empty, String or Number doper.
@@ -6605,17 +6521,9 @@ def pack_doper(operator, token)   #:nodoc:
       length   = string.bytesize
 
       # Handle utf8 strings
-      ruby_18 do
-        if string =~ NonAscii
-          string = utf8_to_16be(string)
-          encodign = 1
-        end
-      end
-      ruby_19 do
-        if string.encoding == Encoding::UTF_8
-          string = utf8_to_16be(string)
-          encodign = 1
-        end
+      if is_utf8?(string)
+        string = utf8_to_16be(string)
+        encodign = 1
       end
 
       string =
@@ -6633,7 +6541,7 @@ def pack_doper(operator, token)   #:nodoc:
 
   ###############################################################################
   #
-  # _pack_unused_doper()
+  # pack_unused_doper()
   #
   # Pack an empty Doper structure.
   #
@@ -6644,7 +6552,7 @@ def pack_unused_doper   #:nodoc:
 
   ###############################################################################
   #
-  # _pack_blanks_doper()
+  # pack_blanks_doper()
   #
   # Pack an Blanks/NonBlanks Doper structure.
   #
@@ -6666,7 +6574,7 @@ def pack_blanks_doper(operator, token)   #:nodoc:
 
   ###############################################################################
   #
-  # _pack_string_doper()
+  # pack_string_doper()
   #
   # Pack an string Doper structure.
   #
@@ -6682,7 +6590,7 @@ def pack_string_doper(operator, length)   #:nodoc:
 
   ###############################################################################
   #
-  # _pack_number_doper()
+  # pack_number_doper()
   #
   # Pack an IEEE double number Doper structure.
   #
@@ -6701,7 +6609,7 @@ def pack_number_doper(operator, number)   #:nodoc:
 
   ###############################################################################
   #
-  # _prepare_images()
+  # prepare_images()
   #
   # Turn the HoH that stores the images into an array for easier handling.
   #
@@ -6712,7 +6620,7 @@ def prepare_images   #:nodoc:
 
   ###############################################################################
   #
-  # _prepare_comments()
+  # prepare_comments()
   #
   # Turn the HoH that stores the comments into an array for easier handling.
   #
@@ -6723,7 +6631,7 @@ def prepare_comments   #:nodoc:
 
   ###############################################################################
   #
-  # _prepare_charts()
+  # prepare_charts()
   #
   # Turn the HoH that stores the charts into an array for easier handling.
   #
@@ -6732,7 +6640,7 @@ def prepare_charts   #:nodoc:
   end
 #  private :prepare_charts
 
-  def prepare_common(param)
+  def prepare_common(param)  # :nodoc:
     hash = {
       :images => @images, :comments => @comments, :charts => @charts
     }[param]
@@ -6768,7 +6676,7 @@ def prepare_common(param)
 
   ###############################################################################
   #
-  # _store_images()
+  # store_images()
   #
   # Store the collections of records that make up images.
   #
@@ -6853,7 +6761,7 @@ def store_images   #:nodoc:
   end
   private :store_images
 
-  def store_parent_mso_record(dg_length, ids, spgr_length, spid)
+  def store_parent_mso_record(dg_length, ids, spgr_length, spid)  # :nodoc:
     store_mso_dg_container(dg_length)      +
     store_mso_dg(*ids)                     +
     store_mso_spgr_container(spgr_length)  +
@@ -6863,7 +6771,7 @@ def store_parent_mso_record(dg_length, ids, spgr_length, spid)
   end
   private :store_parent_mso_record
 
-  def store_child_mso_record(spid, *vertices)
+  def store_child_mso_record(spid, *vertices)  # :nodoc:
     store_mso_sp_container(88)             +
     store_mso_sp(201, spid, 0x0A00)        +
     store_mso_opt_filter                   +
@@ -6874,7 +6782,7 @@ def store_child_mso_record(spid, *vertices)
 
   ###############################################################################
   #
-  # _store_charts()
+  # store_charts()
   #
   # Store the collections of records that make up charts.
   #
@@ -6963,12 +6871,12 @@ def store_charts   #:nodoc:
   end
   private :store_charts
 
-  def store_mso_sp_container_sp(spid)
+  def store_mso_sp_container_sp(spid)  # :nodoc:
     store_mso_sp_container(112) + store_mso_sp(201, spid, 0x0A00)
   end
   private :store_mso_sp_container_sp
 
-  def store_mso_opt_chart_client_anchor_client_data(*vertices)
+  def store_mso_opt_chart_client_anchor_client_data(*vertices)  # :nodoc:
     store_mso_opt_chart                   +
     store_mso_client_anchor(0, *vertices) +
     store_mso_client_data
@@ -6977,7 +6885,7 @@ def store_mso_opt_chart_client_anchor_client_data(*vertices)
 
   ###############################################################################
   #
-  # _store_chart_binary
+  # store_chart_binary
   #
   # Add the binary data for a chart. This could either be from a Chart object
   # or from an external binary file (for backwards compatibility).
@@ -6999,7 +6907,7 @@ def store_chart_binary(chart)   #:nodoc:
 
   ###############################################################################
   #
-  # _store_filters()
+  # store_filters()
   #
   # Store the collections of records that make up filters.
   #
@@ -7064,14 +6972,14 @@ def store_filters   #:nodoc:
   end
   private :store_filters
 
-  def unpack_record(data)
+  def unpack_record(data)  # :nodoc:
     data.unpack('C*').map! {|c| sprintf("%02X", c) }.join(' ')
   end
   private :unpack_record
 
   ###############################################################################
   #
-  # _store_comments()
+  # store_comments()
   #
   # Store the collections of records that make up cell comments.
   #
@@ -7151,7 +7059,7 @@ def store_comments   #:nodoc:
 
   ###############################################################################
   #
-  # _store_mso_dg_container()
+  # store_mso_dg_container()
   #
   # Write the Escher DgContainer record that is part of MSODRAWING.
   #
@@ -7166,7 +7074,7 @@ def store_mso_dg_container(length)   #:nodoc:
 
   ###############################################################################
   #
-  # _store_mso_dg()
+  # store_mso_dg()
   #
   # Write the Escher Dg record that is part of MSODRAWING.
   #
@@ -7182,7 +7090,7 @@ def store_mso_dg(instance, num_shapes, max_spid)   #:nodoc:
 
   ###############################################################################
   #
-  # _store_mso_spgr_container()
+  # store_mso_spgr_container()
   #
   # Write the Escher SpgrContainer record that is part of MSODRAWING.
   #
@@ -7198,7 +7106,7 @@ def store_mso_spgr_container(length)   #:nodoc:
 
   ###############################################################################
   #
-  # _store_mso_sp_container()
+  # store_mso_sp_container()
   #
   # Write the Escher SpContainer record that is part of MSODRAWING.
   #
@@ -7214,7 +7122,7 @@ def store_mso_sp_container(length)   #:nodoc:
 
   ###############################################################################
   #
-  # _store_mso_spgr()
+  # store_mso_spgr()
   #
   # Write the Escher Spgr record that is part of MSODRAWING.
   #
@@ -7231,7 +7139,7 @@ def store_mso_spgr   #:nodoc:
 
   ###############################################################################
   #
-  # _store_mso_sp()
+  # store_mso_sp()
   #
   # Write the Escher Sp record that is part of MSODRAWING.
   #
@@ -7248,7 +7156,7 @@ def store_mso_sp(instance, spid, options)   #:nodoc:
 
   ###############################################################################
   #
-  # _store_mso_opt_comment()
+  # store_mso_opt_comment()
   #
   # Write the Escher Opt record that is part of MSODRAWING.
   #
@@ -7260,7 +7168,7 @@ def store_mso_opt_comment(spid, visible = nil, colour = 0x50)   #:nodoc:
     length      = 54
 
     # Use the visible flag if set by the user or else use the worksheet value.
-    # Note that the value used is the opposite of _store_note().
+    # Note that the value used is the opposite of store_note().
     #
     if !visible.nil?
       visible = visible != 0           ? 0x0000 : 0x0002
@@ -7281,7 +7189,7 @@ def store_mso_opt_comment(spid, visible = nil, colour = 0x50)   #:nodoc:
 
   ###############################################################################
   #
-  # _store_mso_opt_image()
+  # store_mso_opt_image()
   #
   # Write the Escher Opt record that is part of MSODRAWING.
   #
@@ -7305,7 +7213,7 @@ def store_mso_opt_image(spid)   #:nodoc:
 
   ###############################################################################
   #
-  # _store_mso_opt_chart()
+  # store_mso_opt_chart()
   #
   # Write the Escher Opt record that is part of MSODRAWING.
   #
@@ -7339,7 +7247,7 @@ def store_mso_opt_chart   #:nodoc:
 
   ###############################################################################
   #
-  # _store_mso_opt_filter()
+  # store_mso_opt_filter()
   #
   # Write the Escher Opt record that is part of MSODRAWING.
   #
@@ -7362,7 +7270,7 @@ def store_mso_opt_filter   #:nodoc:
   end
 #  private :store_mso_opt_filter
 
-  def store_mso_protection_and_text
+  def store_mso_protection_and_text  # :nodoc:
     [0x007F].pack('v')       +        # Protection -> fLockAgainstGrouping
     [0x01040104].pack('V')   +
     [0x00BF].pack('v')       +        # Text -> fFitTextToShape
@@ -7372,7 +7280,7 @@ def store_mso_protection_and_text
 
   ###############################################################################
   #
-  # _store_mso_client_anchor()
+  # store_mso_client_anchor()
   #    my flag         = shift;
   #    my $col_start   = $_[0];    # Col containing upper left corner of object
   #    my $x1          = $_[1];    # Distance to left side of object
@@ -7403,7 +7311,7 @@ def store_mso_client_anchor(flag, col_start, x1, row_start, y1, col_end, x2, row
 
   ###############################################################################
   #
-  # _store_mso_client_data()
+  # store_mso_client_data()
   #
   # Write the Escher ClientData record that is part of MSODRAWING.
   #
@@ -7420,7 +7328,7 @@ def store_mso_client_data   #:nodoc:
 
   ###############################################################################
   #
-  # _store_obj_comment()
+  # store_obj_comment()
   #    my $obj_id      = $_[0];    # Object ID number.
   #
   # Write the OBJ record that is part of cell comments.
@@ -7465,7 +7373,7 @@ def store_obj_comment(obj_id)   #:nodoc:
 
   ###############################################################################
   #
-  # _store_obj_image()
+  # store_obj_image()
   #    my $obj_id      = $_[0];    # Object ID number.
   #
   # Write the OBJ record that is part of image records.
@@ -7516,7 +7424,7 @@ def store_obj_image(obj_id)   #:nodoc:
 
   ###############################################################################
   #
-  # _store_obj_chart()
+  # store_obj_chart()
   #    my $obj_id      = $_[0];    # Object ID number.
   #
   # Write the OBJ record that is part of chart records.
@@ -7555,7 +7463,7 @@ def store_obj_chart(obj_id)   #:nodoc:
 
   ###############################################################################
   #
-  # _store_obj_filter()
+  # store_obj_filter()
   #    my $obj_id      = $_[0];    # Object ID number.
   #    my $col         = $_[1];
   #
@@ -7614,7 +7522,7 @@ def store_obj_filter(obj_id, col)   #:nodoc:
 
   ###############################################################################
   #
-  # _store_mso_drawing_text_box()
+  # store_mso_drawing_text_box()
   #
   # Write the MSODRAWING ClientTextbox record that is part of comments.
   #
@@ -7631,7 +7539,7 @@ def store_mso_drawing_text_box   #:nodoc:
 
   ###############################################################################
   #
-  # _store_mso_client_text_box()
+  # store_mso_client_text_box()
   #
   # Write the Escher ClientTextbox record that is part of MSODRAWING.
   #
@@ -7648,7 +7556,7 @@ def store_mso_client_text_box   #:nodoc:
 
   ###############################################################################
   #
-  # _store_txo()
+  # store_txo()
   #    my $string_len  = $_[0];                # Length of the note text.
   #    my $format_len  = $_[1] || 16;          # Length of the format runs.
   #    my $rotation    = $_[2] || 0;           # Options
@@ -7673,7 +7581,7 @@ def store_txo(string_len, format_len = 16, rotation = 0)   #:nodoc:
 
   ###############################################################################
   #
-  # _store_txo_continue_1()
+  # store_txo_continue_1()
   #    my $string      = $_[0];                # Comment string.
   #    my $encoding    = $_[1] || 0;           # Encoding of the string.
   #
@@ -7687,7 +7595,7 @@ def store_txo_continue_1(string, encoding = 0)   #:nodoc:
     # We can't let BIFFwriter::_add_continue() handled this since an extra
     # encoding byte has to be added similar to the SST block.
     #
-    # We make the limit size smaller than the _add_continue() size and even
+    # We make the limit size smaller than the add_continue() size and even
     # so that UTF16 chars occur in the same block.
     #
     limit = 8218
@@ -7716,7 +7624,7 @@ def store_txo_continue_1(string, encoding = 0)   #:nodoc:
 
   ###############################################################################
   #
-  # _store_txo_continue_2()
+  # store_txo_continue_2()
   #    my $formats     = $_[0];                # Formatting information
   #
   # Write the second CONTINUE record to follow the TXO record. It contains the
@@ -7742,7 +7650,7 @@ def store_txo_continue_2(formats)   #:nodoc:
 
   ###############################################################################
   #
-  # _store_note()
+  # store_note()
   #    my $row         = $_[0];
   #    my $col         = $_[1];
   #    my $obj_id      = $_[2];
@@ -7761,7 +7669,7 @@ def store_note(row, col, obj_id, author = nil, author_enc = nil, visible = nil)
     author_enc = @comments_author_enc if author_enc.nil?
 
     # Use the visible flag if set by the user or else use the worksheet value.
-    # The flag is also set in _store_mso_opt_comment() but with the opposite
+    # The flag is also set in store_mso_opt_comment() but with the opposite
     # value.
     if !visible.nil?
       visible = visible != 0           ? 0x0002 : 0x0000
@@ -7790,7 +7698,7 @@ def store_note(row, col, obj_id, author = nil, author_enc = nil, visible = nil)
 
   ###############################################################################
   #
-  # _comment_params()
+  # comment_params()
   #
   # This method handles the additional optional parameters to write_comment() as
   # well as calculating the comment object position and vertices.
@@ -7834,18 +7742,10 @@ def comment_params(row, col, string, options = {})   #:nodoc:
       string = string.unpack('n*').pack('v*')
     # Handle utf8 strings
     else
-      ruby_18 do
-        if string =~ NonAscii
-          string = NKF.nkf('-w16L0 -m0 -W', string)
-          params[:encoding] = 1
-        end
-      end
-      ruby_19 do
-        if string.encoding == Encoding::UTF_8
-          string = NKF.nkf('-w16L0 -m0 -W', string)
-          string.force_encoding('UTF-16LE')
-          params[:encoding] = 1
-        end
+      if is_utf8?(string)
+        string = NKF.nkf('-w16L0 -m0 -W', string)
+        ruby_19 { string.force_encoding('UTF-16LE') }
+        params[:encoding] = 1
       end
     end
 
@@ -7857,18 +7757,10 @@ def comment_params(row, col, string, options = {})   #:nodoc:
       # Change from UTF-16BE to UTF-16LE
       params[:author] = params[:author].unpack('n*').pack('v*')
     else
-      ruby_18 do
-        if params[:author] =~ NonAscii
-          params[:author] = NKF.nkf('-w16L0 -m0 -W', params[:author])
-          params[:author_encoding] = 1
-        end
-      end
-      ruby_19 do
-        if params[:author].encoding == Encoding::UTF_8
-          params[:author] = NKF.nkf('-w16L0 -m0 -W', params[:author])
-          params[:author].force_encoding('UTF-16LE')
-          params[:author_encoding] = 1
-        end
+      if is_utf8?(params[:author])
+        params[:author] = NKF.nkf('-w16L0 -m0 -W', params[:author])
+        ruby_19 { params[:author].force_encoding('UTF-16LE') }
+        params[:author_encoding] = 1
       end
     end
 
@@ -7968,8 +7860,8 @@ def comment_params(row, col, string, options = {})   #:nodoc:
 
   #
   # :call-seq:
-  #    data_validation(row, col, {...})
-  #    data_validation(first_row, first_col, last_row, last_col, {...})
+  #    data_validation(row, col, params)
+  #    data_validation(first_row, first_col, last_row, last_col, params)
   #
   # This method handles the interface to Excel data validation.
   # Somewhat ironically the this requires a lot of validation code since the
@@ -8076,70 +7968,71 @@ def comment_params(row, col, string, options = {})   #:nodoc:
   #     length
   #     custom
   #
-  #     * any is used to specify that the type of data is unrestricted. This
-  # is the same as not applying a data validation. It is only provided for
-  # completeness and isn't used very often in the context of WriteExcel.
+  # * any is used to specify that the type of data is unrestricted. This
+  #   is the same as not applying a data validation. It is only provided for
+  #   completeness and isn't used very often in the context of WriteExcel.
   #
-  #     * integer restricts the cell to integer values. Excel refers to this
-  # as 'whole number'.
+  # * integer restricts the cell to integer values. Excel refers to this
+  #   as 'whole number'.
   #
-  #           :validate => 'integer',
-  #           :criteria => '>',
-  #           :value    => 100,
+  #     :validate => 'integer',
+  #     :criteria => '>',
+  #     :value    => 100,
   #
-  #     * decimal restricts the cell to decimal values.
+  # * decimal restricts the cell to decimal values.
   #
-  #           :validate => 'decimal',
-  #           :criteria => '>',
-  #           :value    => 38.6,
+  #     :validate => 'decimal',
+  #     :criteria => '>',
+  #     :value    => 38.6,
   #
-  #     * list restricts the cell to a set of user specified values. These
-  # can be passed in an array ref or as a cell range (named ranges aren't
-  # currently supported):
+  # * list restricts the cell to a set of user specified values. These
+  #   can be passed in an array ref or as a cell range (named ranges aren't
+  #   currently supported):
   #
-  #           :validate => 'list',
-  #           :value    => ['open', 'high', 'close'],
-  #           # Or like this:
-  #           :value    => 'B1:B3',
+  #     :validate => 'list',
+  #     :value    => ['open', 'high', 'close'],
+  #     # Or like this:
+  #     :value    => 'B1:B3',
   #
-  #       Excel requires that range references are only to cells on the
+  # Excel requires that range references are only to cells on the
   # same worksheet.
-  #     * date restricts the cell to date values. Dates in Excel are expressed
-  # as integer values but you can also pass an ISO860 style string as used in
-  # write_date_time(). See also "DATES AND TIME IN EXCEL" for more information
-  # about working with Excel's dates.
   #
-  #           :validate => 'date',
-  #           :criteria => '>',
-  #           :value    => 39653, # 24 July 2008
-  #           # Or like this:
-  #           :value    => '2008-07-24T',
+  # * date restricts the cell to date values. Dates in Excel are expressed
+  #   as integer values but you can also pass an ISO860 style string as used in
+  #   write_date_time(). See also "DATES AND TIME IN EXCEL" for more information
+  #   about working with Excel's dates.
   #
-  #     * time restricts the cell to time values. Times in Excel are expressed
-  # as decimal values but you can also pass an ISO860 style string as used in
-  # write_date_time(). See also "DATES AND TIME IN EXCEL" for more information
-  # about working with Excel's times.
+  #     :validate => 'date',
+  #     :criteria => '>',
+  #     :value    => 39653, # 24 July 2008
+  #     # Or like this:
+  #     :value    => '2008-07-24T',
   #
-  #           :validate => 'time',
-  #           :criteria => '>',
-  #           :value    => 0.5, # Noon
-  #           # Or like this:
-  #           :value    => 'T12:00:00',
+  # * time restricts the cell to time values. Times in Excel are expressed
+  #   as decimal values but you can also pass an ISO860 style string as used in
+  #   write_date_time(). See also "DATES AND TIME IN EXCEL" for more information
+  #   about working with Excel's times.
   #
-  #     * length restricts the cell data based on an integer string length.
-  # Excel refers to this as 'Text length'.
+  #     :validate => 'time',
+  #     :criteria => '>',
+  #     :value    => 0.5, # Noon
+  #     # Or like this:
+  #     :value    => 'T12:00:00',
+  #
+  # * length restricts the cell data based on an integer string length.
+  #   Excel refers to this as 'Text length'.
   #
-  #           :validate => 'length',
-  #           :criteria => '>',
-  #           :value    => 10,
+  #     :validate => 'length',
+  #     :criteria => '>',
+  #     :value    => 10,
   #
-  #     * custom restricts the cell based on an external Excel formula that
-  # returns a TRUE/FALSE value.
+  # * custom restricts the cell based on an external Excel formula that
+  #   returns a TRUE/FALSE value.
   #
-  #           :validate => 'custom',
-  #           :value    => '=IF(A10>B10,TRUE,FALSE)',
+  #     :validate => 'custom',
+  #     :value    => '=IF(A10>B10,TRUE,FALSE)',
   #
-  # criteria
+  # ===criteria
   #
   # This parameter is passed in a hash ref to data_validation().
   #
@@ -8177,7 +8070,7 @@ def comment_params(row, col, string, options = {})   #:nodoc:
   #     :validate => 'custom',
   #     :value    => '=IF(A10>B10,TRUE,FALSE)',
   #
-  # ====value | minimum | source
+  # ===value | minimum | source
   #
   # This parameter is passed in a hash ref to data_validation().
   #
@@ -8201,7 +8094,7 @@ def comment_params(row, col, string, options = {})   #:nodoc:
   #     :validate => 'list',
   #     :source   => 'B1:B3',
   #
-  # ====maximum
+  # ===maximum
   #
   # This parameter is passed in a hash ref to data_validation().
   #
@@ -8213,7 +8106,7 @@ def comment_params(row, col, string, options = {})   #:nodoc:
   #     :minimum  => 1,
   #     :maximum  => 100,
   #
-  # ====ignore_blank
+  # ===ignore_blank
   #
   # This parameter is passed in a hash ref to data_validation().
   #
@@ -8224,7 +8117,7 @@ def comment_params(row, col, string, options = {})   #:nodoc:
   #
   #     :ignore_blank => 0,  # Turn the option off
   #
-  # ====dropdown
+  # ===dropdown
   #
   # This parameter is passed in a hash ref to data_validation().
   #
@@ -8234,7 +8127,7 @@ def comment_params(row, col, string, options = {})   #:nodoc:
   #
   #     :dropdown => 0,      # Turn the option off
   #
-  # ====input_title
+  # ===input_title
   #
   # This parameter is passed in a hash ref to data_validation().
   #
@@ -8248,7 +8141,7 @@ def comment_params(row, col, string, options = {})   #:nodoc:
   # The maximum title length is 32 characters. UTF8 strings are handled
   # automatically.
   #
-  # ====input_message
+  # ===input_message
   #
   # This parameter is passed in a hash ref to data_validation().
   #
@@ -8270,7 +8163,7 @@ def comment_params(row, col, string, options = {})   #:nodoc:
   # The maximum message length is 255 characters. UTF8 strings are handled
   # automatically.
   #
-  # ====show_input
+  # ===show_input
   #
   # This parameter is passed in a hash ref to data_validation().
   #
@@ -8281,7 +8174,7 @@ def comment_params(row, col, string, options = {})   #:nodoc:
   #
   #     :show_input => 0,      # Turn the option off
   #
-  # ====error_title
+  # ===error_title
   #
   # This parameter is passed in a hash ref to data_validation().
   #
@@ -8294,7 +8187,7 @@ def comment_params(row, col, string, options = {})   #:nodoc:
   # The maximum title length is 32 characters. UTF8 strings are handled
   # automatically.
   #
-  # ====error_message
+  # ===error_message
   #
   # This parameter is passed in a hash ref to data_validation().
   #
@@ -8318,7 +8211,7 @@ def comment_params(row, col, string, options = {})   #:nodoc:
   # The maximum message length is 255 characters. UTF8 strings are handled
   # automatically.
   #
-  # ====error_type
+  # ===error_type
   #
   # This parameter is passed in a hash ref to data_validation().
   #
@@ -8331,7 +8224,7 @@ def comment_params(row, col, string, options = {})   #:nodoc:
   #
   # The default is 'stop'.
   #
-  # ====show_error
+  # ===show_error
   #
   # This parameter is passed in a hash ref to data_validation().
   #
@@ -8342,7 +8235,7 @@ def comment_params(row, col, string, options = {})   #:nodoc:
   #
   #     :show_error => 0,      # Turn the option off
   #
-  # Examples
+  # ===Examples
   #
   # Example 1. Limiting input to an integer greater than a fixed value.
   #
@@ -8416,9 +8309,7 @@ def comment_params(row, col, string, options = {})   #:nodoc:
   #
   def data_validation(*args)
     # Check for a cell reference in A1 notation and substitute row and column
-    if args[0] =~ /^\D/
-      args = substitute_cellref(*args)
-    end
+    args = row_col_notation(args)
 
     # Check for a valid number of args.
     return -1 if args.size != 5 && args.size != 3
@@ -8627,11 +8518,11 @@ def data_validation(*args)
 
   ###############################################################################
   #
-  # _store_validation_count()
+  # store_validation_count()
   #
   # Store the count of the DV records to follow.
   #
-  # Note, this could be wrapped into _store_dv() but we may require separate
+  # Note, this could be wrapped into store_dv() but we may require separate
   # handling of the object id at a later stage.
   #
   def store_validation_count   #:nodoc:
@@ -8646,7 +8537,7 @@ def store_validation_count   #:nodoc:
 
   ###############################################################################
   #
-  # _store_validations()
+  # store_validations()
   #
   # Store the data_validation records.
   #
@@ -8676,7 +8567,7 @@ def store_validations   #:nodoc:
 
   ###############################################################################
   #
-  # _store_dval()
+  # store_dval()
   #    my $obj_id      = $_[0];        # Object ID number.
   #    my $dv_count    = $_[1];        # Count of DV structs to follow.
   #
@@ -8701,7 +8592,7 @@ def store_dval(obj_id, dv_count)   #:nodoc:
 
   ###############################################################################
   #
-  # _store_dv()
+  # store_dv()
   #    my $cells           = $_[0];        # Aref of cells to which DV applies.
   #    my $validation_type = $_[1];        # Type of data validation.
   #    my $criteria_type   = $_[2];        # Validation criteria.
@@ -8786,7 +8677,7 @@ def store_dv(cells, validation_type, criteria_type,   #:nodoc:
 
   ###############################################################################
   #
-  # _pack_dv_string()
+  # pack_dv_string()
   #
   # Pack the strings used in the input and error dialog captions and messages.
   # Captions are limited to 32 characters. Messages are limited to 255 chars.
@@ -8811,19 +8702,10 @@ def pack_dv_string(string = nil, max_length = 0)   #:nodoc:
     ruby_19 { string = convert_to_ascii_if_ascii(string) }
 
     # Handle utf8 strings
-    ruby_18 do
-      if string =~ NonAscii
-        str_length = string.gsub(/[^\Wa-zA-Z_\d]/, ' ').bytesize   # jlength
-        string = utf8_to_16le(string)
-        encoding = 1
-      end
-    end
-    ruby_19 do
-      if string.encoding == Encoding::UTF_8
-        str_length = string.gsub(/[^\Wa-zA-Z_\d]/, ' ').bytesize   # jlength
-        string = utf8_to_16le(string)
-        encoding = 1
-      end
+    if is_utf8?(string)
+      str_length = string.gsub(/[^\Wa-zA-Z_\d]/, ' ').bytesize   # jlength
+      string = utf8_to_16le(string)
+      encoding = 1
     end
 
     ruby_18 { [str_length, encoding].pack('vC') + string } ||
@@ -8833,7 +8715,7 @@ def pack_dv_string(string = nil, max_length = 0)   #:nodoc:
 
   ###############################################################################
   #
-  # _pack_dv_formula()
+  # pack_dv_formula()
   #
   # Pack the formula used in the DV record. This is the same as an cell formula
   # with some additional header information. Note, DV formulas in Excel use
@@ -8888,6 +8770,16 @@ def pack_dv_formula(formula = nil)   #:nodoc:
 
     [formula.length, unused].pack('vv') + formula
   end
+
+  # Check for a cell reference in A1 notation and substitute row and column
+  def row_col_notation(args)   # :nodoc:
+    if args[0] =~ /^\D/
+      substitute_cellref(*args)
+    else
+      args
+    end
+  end
+  private :row_col_notation
 end  # class Worksheet
 
 end  # module Writeexcel