write_xlsx 1.10.1 → 1.10.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 66e9354b51872770af7121d5581615b53c0cb3b7e86c221b0ecee60fe54dae4b
-  data.tar.gz: 97d6ae9ed6dee9e57e98981e105da155ef405fd5ea40ea17e8057871f02d90d9
+  metadata.gz: 74c1fe583292a7a5318db09651b114e58358646a8706b5b4d35fc01c1850ec6c
+  data.tar.gz: 424d3f3a1983e4de16de9a943c67718874e7ef7e4a78c440767ecf8c68f0ef88
 SHA512:
-  metadata.gz: a86f539563acd7da100be9fb11e1e3da99c1985200e21eaa91ca9db3f69ea130038f0ecead40ea0ba6efcc5b4f433dcd4acf039006faa65adb60ed88d0d5f005
-  data.tar.gz: f98a3ac1110600e8e2c578127f85a804c1237d44069481f6c0baacc27ff6f21eddbb96f063c544239730ba059a16f7637f39ebfd902f3cc87be4995401bf303b
+  metadata.gz: 4603c1400dd60ec345b8cf4db50ae1c03e87716192a074d2a767cebc7cfc085439c733ea11167cf900efc3aae3fe555a32639731d36338100bf9fbb170f28fd5
+  data.tar.gz: 3ccbb69460382ae8074cc62fc896daa1aa608dbbb6ff894bb1fc425643c0ac3b9e91cc55b0c8e2de05a50113b179621db83fcea033b9b201bf56957f833624e3

data/.rubocop.yml

@@ -38,6 +38,9 @@ Lint/DuplicateBranch:
   Exclude:
     - 'lib/write_xlsx/worksheet.rb'
 
+Lint/UnderscorePrefixedVariableName:
+  Enabled: false
+
 Lint/UselessSetterCall:
   Exclude:
     - 'lib/write_xlsx/worksheet.rb'
@@ -93,6 +96,9 @@ Style/HashSyntax:
   EnforceStyle: ruby19_no_mixed_keys
   EnforcedShorthandSyntax: either
 
+Style/IfUnlessModifier:
+  Enabled: false
+
 Style/NumericLiterals:
   MinDigits: 10
 

data/Changes

@@ -1,5 +1,11 @@
 Change history of write_xlsx rubygem.
 
+2023-02-16 v1.10.2
+    Fixed issue #104. Worksheet#write Ruby 3.2 removed Object#=~
+    making it impossible to write Date objects
+
+    Memory usage optimization.
+
 2023-01-31 v1.10.1
     Fixed PR #99. Remove range [1..] style to work on Ruby 2.5.
 

data/README.md

@@ -85,7 +85,7 @@ the first worksheet in an Excel XML spreadsheet called ruby.xlsx:
 Original Perl module was written by John McNamara(jmcnamara@cpan.org).
 
 Converted to ruby by Hideo NAKAMURA(nakamrua.hideo@gmail.com)
-Copyright (c) 2012-2022 Hideo NAKAMURA.
+Copyright (c) 2012-2023 Hideo NAKAMURA.
 
 See LICENSE.txt for further details.
 

data/lib/write_xlsx/package/conditional_format.rb

@@ -409,12 +409,23 @@ module Writexlsx
 
       def row_col_param_for_conditional_formatting(*args)
         # Check for a cell reference in A1 notation and substitute row and column
-        if args[0].to_s =~ (/^\D/) && (args[0] =~ /,/)
-          # Check for a user defined multiple range like B3:K6,B8:K11.
-          user_range = args[0].sub(/^=/, '').gsub(/\s*,\s*/, ' ').gsub(/\$/, '')
+        user_range = if args[0].to_s =~ (/^\D/) && (args[0] =~ /,/)
+                       # Check for a user defined multiple range like B3:K6,B8:K11.
+                       args[0].sub(/^=/, '').gsub(/\s*,\s*/, ' ').gsub(/\$/, '')
+                     end
+
+        if (row_col_array = row_col_notation(args.first))
+          if row_col_array.size == 2
+            row1, col1 = row_col_array
+            row2 = args[1]
+          elsif row_col_array.size == 4
+            row1, col1, row2, col2 = row_col_array
+            param = args[1]
+          end
+        else
+          row1, col1, row2, col2, param = args
         end
 
-        row1, col1, row2, col2, param = row_col_notation(args)
         if row2.respond_to?(:keys)
           param = row2
           row2 = row1

data/lib/write_xlsx/package/table.rb

@@ -162,41 +162,50 @@ module Writexlsx
 
       private
 
-      def handle_args(*args)
+      def handle_args(row1, col1 = nil, row2 = nil, col2 = nil, param = nil)
         # Check for a cell reference in A1 notation and substitute row and column
-        row1, col1, row2, col2, param = row_col_notation(args)
+        if (row_col_array = row_col_notation(row1))
+          _row1, _col1, _row2, _col2 = row_col_array
+          _param = col1
+        else
+          _row1 = row1
+          _col1 = col1
+          _row2 = row2
+          _col2 = col2
+          _param = param
+        end
 
         # Check for a valid number of args.
-        raise "Not enough parameters to add_table()" if [row1, col1, row2, col2].include?(nil)
+        raise "Not enough parameters to add_table()" if [_row1, _col1, _row2, _col2].include?(nil)
 
         # Check that row and col are valid without storing the values.
-        check_dimensions_and_update_max_min_values(row1, col1, 1, 1)
-        check_dimensions_and_update_max_min_values(row2, col2, 1, 1)
+        check_dimensions_and_update_max_min_values(_row1, _col1, 1, 1)
+        check_dimensions_and_update_max_min_values(_row2, _col2, 1, 1)
 
         # Swap last row/col for first row/col as necessary.
-        row1, row2 = row2, row1 if row1 > row2
-        col1, col2 = col2, col1 if col1 > col2
+        _row1, _row2 = _row2, _row1 if _row1 > _row2
+        _col1, _col2 = _col2, _col1 if _col1 > _col2
 
         # The final hash contains the validation parameters.
-        param ||= {}
+        _param ||= {}
 
         # Turn on Excel's defaults.
-        param[:banded_rows] ||= 1
-        param[:header_row]  ||= 1
-        param[:autofilter]  ||= 1
+        _param[:banded_rows] ||= 1
+        _param[:header_row]  ||= 1
+        _param[:autofilter]  ||= 1
 
         # Check that there are enough rows.
-        num_rows = row2 - row1
-        num_rows -= 1 if ptrue?(param[:header_row])
+        num_rows = _row2 - _row1
+        num_rows -= 1 if ptrue?(_param[:header_row])
 
         raise "Must have at least one data row in in add_table()" if num_rows < 0
 
         # If the header row if off the default is to turn autofilter off.
-        param[:autofilter] = 0 if param[:header_row] == 0
+        _param[:autofilter] = 0 if _param[:header_row] == 0
 
-        check_parameter(param, valid_table_parameter, 'add_table')
+        check_parameter(_param, valid_table_parameter, 'add_table')
 
-        [row1, row2, col1, col2, param]
+        [_row1, _row2, _col1, _col2, _param]
       end
 
       # List of valid input parameters.

data/lib/write_xlsx/utility.rb

@@ -53,7 +53,12 @@ module Writexlsx
 
     def xl_col_to_name(col, col_absolute)
       col_str = ColName.instance.col_str(col)
-      "#{absolute_char(col_absolute)}#{col_str}"
+      if col_absolute
+        "#{absolute_char(col_absolute)}#{col_str}"
+      else
+        # Do not allocate new string
+        col_str
+      end
     end
 
     def xl_range(row_1, row_2, col_1, col_2,
@@ -252,12 +257,8 @@ module Writexlsx
     end
 
     # Check for a cell reference in A1 notation and substitute row and column
-    def row_col_notation(args)   # :nodoc:
-      if args[0].to_s =~ /^\D/
-        substitute_cellref(*args)
-      else
-        args
-      end
+    def row_col_notation(row_or_a1)   # :nodoc:
+      substitute_cellref(row_or_a1) if row_or_a1.to_s =~ /^\D/
     end
 
     #
@@ -267,7 +268,7 @@ module Writexlsx
     # Ex: ("A4", "Hello") is converted to (3, 0, "Hello").
     #
     def substitute_cellref(cell, *args)       # :nodoc:
-      return [*args] if cell.respond_to?(:coerce) # Numeric
+      #      return [*args] if cell.respond_to?(:coerce) # Numeric
 
       normalized_cell = cell.upcase
 

data/lib/write_xlsx/version.rb

@@ -1,3 +1,3 @@
 # frozen_string_literal: true
 
-WriteXLSX_VERSION = "1.10.1"
+WriteXLSX_VERSION = "1.10.2"

data/lib/write_xlsx/worksheet/data_validation.rb

@@ -13,7 +13,19 @@ module Writexlsx
 
       def initialize(*args)
         # Check for a cell reference in A1 notation and substitute row and column.
-        row1, col1, row2, col2, options = row_col_notation(args)
+        if (row_col_array = row_col_notation(args.first))
+          case row_col_array.size
+          when 2
+            row1, col1 = row_col_array
+            row2, col2, options = args[1..-1]
+          when 4
+            row1, col1, row2, col2 = row_col_array
+            options = args[1]
+          end
+        else
+          row1, col1, row2, col2, options = args
+        end
+
         if row2.respond_to?(:keys)
           options_to_instance_variable(row2.dup)
           row2 = row1

data/lib/write_xlsx/worksheet.rb

@@ -15,6 +15,7 @@ require 'write_xlsx/worksheet/data_validation'
 require 'write_xlsx/worksheet/hyperlink'
 require 'write_xlsx/worksheet/page_setup'
 require 'tempfile'
+require 'date'
 
 module Writexlsx
   class Worksheet
@@ -395,7 +396,12 @@ module Writexlsx
     def set_selection(*args)
       return if args.empty?
 
-      row_first, col_first, row_last, col_last = row_col_notation(args)
+      if (row_col_array = row_col_notation(args.first))
+        row_first, col_first, row_last, col_last = row_col_array
+      else
+        row_first, col_first, row_last, col_last = args
+      end
+
       active_cell = xl_rowcol_to_cell(row_first, col_first)
 
       if row_last  # Range selection.
@@ -420,10 +426,15 @@ module Writexlsx
     #
     # Set the first visible cell at the top left of the worksheet.
     #
-    def set_top_left_cell(*args)
-      row, col = row_col_notation(args)
+    def set_top_left_cell(row, col = nil)
+      if (row_col_array = row_col_notation(row))
+        _row, _col = row_col_array
+      else
+        _row = row
+        _col = col
+      end
 
-      @top_left_cell = xl_rowcol_to_cell(row, col)
+      @top_left_cell = xl_rowcol_to_cell(_row, _col)
     end
 
     #
@@ -439,7 +450,12 @@ module Writexlsx
       return if args.empty?
 
       # Check for a cell reference in A1 notation and substitute row and column.
-      row, col, top_row, left_col, type = row_col_notation(args)
+      if (row_col_array = row_col_notation(args.first))
+        row, col, top_row, left_col = row_col_array
+        type = args[1]
+      else
+        row, col, top_row, left_col, type = args
+      end
 
       col      ||= 0
       top_row  ||= row
@@ -772,7 +788,12 @@ module Writexlsx
     def print_area(*args)
       return @page_setup.print_area.dup if args.empty?
 
-      row1, col1, row2, col2 = row_col_notation(args)
+      if (row_col_array = row_col_notation(args.first))
+        row1, col1, row2, col2 = row_col_array
+      else
+        row1, col1, row2, col2 = args
+      end
+
       return if [row1, col1, row2, col2].include?(nil)
 
       # Ignore max print area since this is the same as no print area for Excel.
@@ -889,50 +910,62 @@ module Writexlsx
     # data the {#write()}[#method-i-write] method acts as a general alias for several more
     # specific methods:
     #
-    def write(*args)
+    def write(row, col, token = nil, format = nil, value1 = nil, value2 = nil)
       # Check for a cell reference in A1 notation and substitute row and column
-      row_col_args = row_col_notation(args)
-      token = row_col_args[2] || ''
-      token = token.to_s if token.instance_of?(Time)
+      if (row_col_array = row_col_notation(row))
+        _row, _col = row_col_array
+        _token     = col
+        _format    = token
+        _value1    = format
+        _value2    = value1
+      else
+        _row = row
+        _col = col
+        _token = token
+        _format = format
+        _value1 = value1
+        _value2 = value2
+      end
+      _token ||= ''
+      _token = _token.to_s if token.instance_of?(Time) || token.instance_of?(Date)
 
-      fmt = row_col_args[3]
-      if fmt.respond_to?(:force_text_format?) && fmt.force_text_format?
-        write_string(*args) # Force text format
+      if _format.respond_to?(:force_text_format?) && _format.force_text_format?
+        write_string(_row, _col, _token, _format) # Force text format
       # Match an array ref.
-      elsif token.respond_to?(:to_ary)
-        write_row(*args)
-      elsif token.respond_to?(:coerce)  # Numeric
-        write_number(*args)
+      elsif _token.respond_to?(:to_ary)
+        write_row(_row, _col, _token, _format, _value1, _value2)
+      elsif _token.respond_to?(:coerce)  # Numeric
+        write_number(_row, _col, _token, _format)
       # Match integer with leading zero(s)
-      elsif @leading_zeros && token =~ /^0\d*$/
-        write_string(*args)
-      elsif token =~ /\A([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?\Z/
-        write_number(*args)
+      elsif @leading_zeros && _token =~ /^0\d*$/
+        write_string(_row, _col, _token, _format)
+      elsif _token =~ /\A([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?\Z/
+        write_number(_row, _col, _token, _format)
       # Match formula
-      elsif token =~ /^=/
-        write_formula(*args)
+      elsif _token =~ /^=/
+        write_formula(_row, _col, _token, _format, _value1)
       # Match array formula
-      elsif token =~ /^\{=.*\}$/
-        write_formula(*args)
+      elsif _token =~ /^\{=.*\}$/
+        write_formula(_row, _col, _token, _format, _value1)
       # Match blank
-      elsif token == ''
-        row_col_args.delete_at(2)     # remove the empty string from the parameter list
-        write_blank(*row_col_args)
+      elsif _token == ''
+        #        row_col_args.delete_at(2)     # remove the empty string from the parameter list
+        write_blank(_row, _col, _format)
       elsif @workbook.strings_to_urls
         # Match http, https or ftp URL
-        if token =~ %r{\A[fh]tt?ps?://}
-          write_url(*args)
+        if _token =~ %r{\A[fh]tt?ps?://}
+          write_url(_row, _col, _token, _format, _value1, _value2)
         # Match mailto:
-        elsif token =~ /\Amailto:/
-          write_url(*args)
+        elsif _token =~ /\Amailto:/
+          write_url(_row, _col, _token, _format, _value1, _value2)
         # Match internal or external sheet link
-        elsif token =~ /\A(?:in|ex)ternal:/
-          write_url(*args)
+        elsif _token =~ /\A(?:in|ex)ternal:/
+          write_url(_row, _col, _token, _format, _value1, _value2)
         else
-          write_string(*args)
+          write_string(_row, _col, _token, _format)
         end
       else
-        write_string(*args)
+        write_string(_row, _col, _token, _format)
       end
     end
 
@@ -944,19 +977,28 @@ module Writexlsx
     # the elements of the array are in turn array. This allows the writing
     # of 1D or 2D arrays of data in one go.
     #
-    def write_row(*args)
+    def write_row(row, col, tokens = nil, *options)
       # Check for a cell reference in A1 notation and substitute row and column
-      row, col, tokens, *options = row_col_notation(args)
-      raise "Not an array ref in call to write_row()$!" unless tokens.respond_to?(:to_ary)
+      if (row_col_array = row_col_notation(row))
+        _row, _col = row_col_array
+        _tokens    = col
+        _options   = [tokens] + options
+      else
+        _row = row
+        _col = col
+        _tokens = tokens
+        _options = options
+      end
+      raise "Not an array ref in call to write_row()$!" unless _tokens.respond_to?(:to_ary)
 
-      tokens.each do |token|
+      _tokens.each do |_token|
         # Check for nested arrays
-        if token.respond_to?(:to_ary)
-          write_col(row, col, token, *options)
+        if _token.respond_to?(:to_ary)
+          write_col(_row, _col, _token, *_options)
         else
-          write(row, col, token, *options)
+          write(_row, _col, _token, *_options)
         end
-        col += 1
+        _col += 1
       end
     end
 
@@ -968,13 +1010,22 @@ module Writexlsx
     # the elements of the array are in turn array. This allows the writing
     # of 1D or 2D arrays of data in one go.
     #
-    def write_col(*args)
-      row, col, tokens, *options = row_col_notation(args)
+    def write_col(row, col, tokens = nil, *options)
+      if (row_col_array = row_col_notation(row))
+        _row, _col = row_col_array
+        _tokens    = col
+        _options   = [tokens] + options if options
+      else
+        _row = row
+        _col = col
+        _tokens = tokens
+        _options = options
+      end
 
-      tokens.each do |token|
+      _tokens.each do |_token|
         # write() will deal with any nested arrays
-        write(row, col, token, *options)
-        row += 1
+        write(_row, _col, _token, *_options)
+        _row += 1
       end
     end
 
@@ -984,19 +1035,28 @@ module Writexlsx
     #
     # Write a comment to the specified row and column (zero indexed).
     #
-    def write_comment(*args)
+    def write_comment(row, col, string = nil, options = nil)
       # Check for a cell reference in A1 notation and substitute row and column
-      row, col, string, options = row_col_notation(args)
-      raise WriteXLSXInsufficientArgumentError if [row, col, string].include?(nil)
+      if (row_col_array = row_col_notation(row))
+        _row, _col = row_col_array
+        _string    = col
+        _options   = string
+      else
+        _row = row
+        _col = col
+        _string = string
+        _options = options
+      end
+      raise WriteXLSXInsufficientArgumentError if [_row, _col, _string].include?(nil)
 
       # Check that row and col are valid and store max and min values
-      check_dimensions(row, col)
-      store_row_col_max_min_values(row, col)
+      check_dimensions(_row, _col)
+      store_row_col_max_min_values(_row, _col)
 
       @has_vml = true
 
       # Process the properties of the cell comment.
-      @comments.add(@workbook, self, row, col, string, options)
+      @comments.add(@workbook, self, _row, _col, _string, _options)
     end
 
     #
@@ -1005,16 +1065,25 @@ module Writexlsx
     #
     # Write an integer or a float to the cell specified by row and column:
     #
-    def write_number(*args)
+    def write_number(row, col, number, format = nil)
       # Check for a cell reference in A1 notation and substitute row and column
-      row, col, num, xf = row_col_notation(args)
-      raise WriteXLSXInsufficientArgumentError if row.nil? || col.nil? || num.nil?
+      if (row_col_array = row_col_notation(row))
+        _row, _col = row_col_array
+        _number = col
+        _format = number
+      else
+        _row = row
+        _col = col
+        _number = number
+        _format = format
+      end
+      raise WriteXLSXInsufficientArgumentError if _row.nil? || _col.nil? || _number.nil?
 
       # Check that row and col are valid and store max and min values
-      check_dimensions(row, col)
-      store_row_col_max_min_values(row, col)
+      check_dimensions(_row, _col)
+      store_row_col_max_min_values(_row, _col)
 
-      store_data_to_table(NumberCellData.new(num, xf), row, col)
+      store_data_to_table(NumberCellData.new(_number, _format), _row, _col)
     end
 
     #
@@ -1024,19 +1093,28 @@ module Writexlsx
     # Write a string to the specified row and column (zero indexed).
     # +format+ is optional.
     #
-    def write_string(*args)
+    def write_string(row, col, string = nil, format = nil)
       # Check for a cell reference in A1 notation and substitute row and column
-      row, col, str, xf = row_col_notation(args)
-      str &&= str.to_s
-      raise WriteXLSXInsufficientArgumentError if row.nil? || col.nil? || str.nil?
+      if (row_col_array = row_col_notation(row))
+        _row, _col = row_col_array
+        _string = col
+        _format = string
+      else
+        _row = row
+        _col = col
+        _string = string
+        _format = format
+      end
+      _string &&= _string.to_s
+      raise WriteXLSXInsufficientArgumentError if _row.nil? || _col.nil? || _string.nil?
 
       # Check that row and col are valid and store max and min values
-      check_dimensions(row, col)
-      store_row_col_max_min_values(row, col)
+      check_dimensions(_row, _col)
+      store_row_col_max_min_values(_row, _col)
 
-      index = shared_string_index(str.length > STR_MAX ? str[0, STR_MAX] : str)
+      index = shared_string_index(_string.length > STR_MAX ? _string[0, STR_MAX] : _string)
 
-      store_data_to_table(StringCellData.new(index, xf), row, col)
+      store_data_to_table(StringCellData.new(index, _format), _row, _col)
     end
 
     #
@@ -1047,24 +1125,31 @@ module Writexlsx
     # The method receives string fragments prefixed by format objects. The final
     # format object is used as the cell format.
     #
-    def write_rich_string(*args)
+    def write_rich_string(row, col, *rich_strings)
       # Check for a cell reference in A1 notation and substitute row and column
-      row, col, *rich_strings = row_col_notation(args)
-      raise WriteXLSXInsufficientArgumentError if [row, col, rich_strings[0]].include?(nil)
+      if (row_col_array = row_col_notation(row))
+        _row, _col    = row_col_array
+        _rich_strings = [col] + rich_strings
+      else
+        _row = row
+        _col = col
+        _rich_strings = rich_strings
+      end
+      raise WriteXLSXInsufficientArgumentError if [_row, _col, _rich_strings[0]].include?(nil)
 
-      xf = cell_format_of_rich_string(rich_strings)
+      _xf = cell_format_of_rich_string(_rich_strings)
 
       # Check that row and col are valid and store max and min values
-      check_dimensions(row, col)
-      store_row_col_max_min_values(row, col)
+      check_dimensions(_row, _col)
+      store_row_col_max_min_values(_row, _col)
 
-      fragments, _length = rich_strings_fragments(rich_strings)
+      _fragments, _length = rich_strings_fragments(_rich_strings)
       # can't allow 2 formats in a row
-      return -4 unless fragments
+      return -4 unless _fragments
 
-      index = shared_string_index(xml_str_of_rich_string(fragments))
+      index = shared_string_index(xml_str_of_rich_string(_fragments))
 
-      store_data_to_table(StringCellData.new(index, xf), row, col)
+      store_data_to_table(StringCellData.new(index, _xf), _row, _col)
     end
 
     #
@@ -1075,19 +1160,26 @@ module Writexlsx
     # A blank cell is used to specify formatting without adding a string
     # or a number.
     #
-    def write_blank(*args)
+    def write_blank(row, col, format = nil)
       # Check for a cell reference in A1 notation and substitute row and column
-      row, col, xf = row_col_notation(args)
-      raise WriteXLSXInsufficientArgumentError if [row, col].include?(nil)
+      if (row_col_array = row_col_notation(row))
+        _row, _col = row_col_array
+        _format = col
+      else
+        _row = row
+        _col = col
+        _format = format
+      end
+      raise WriteXLSXInsufficientArgumentError if [_row, _col].include?(nil)
 
       # Don't write a blank cell unless it has a format
-      return unless xf
+      return unless _format
 
       # Check that row and col are valid and store max and min values
-      check_dimensions(row, col)
-      store_row_col_max_min_values(row, col)
+      check_dimensions(_row, _col)
+      store_row_col_max_min_values(_row, _col)
 
-      store_data_to_table(BlankCellData.new(xf), row, col)
+      store_data_to_table(BlankCellData.new(_format), _row, _col)
     end
 
     def expand_formula(formula, function, addition = '')
@@ -1261,28 +1353,39 @@ module Writexlsx
     #
     # Write a formula or function to the cell specified by +row+ and +column+:
     #
-    def write_formula(*args)
+    def write_formula(row, col, formula = nil, format = nil, value = nil)
       # Check for a cell reference in A1 notation and substitute row and column
-      row, col, formula, format, value = row_col_notation(args)
-      raise WriteXLSXInsufficientArgumentError if [row, col, formula].include?(nil)
+      if (row_col_array = row_col_notation(row))
+        _row, _col = row_col_array
+        _formula   = col
+        _format    = formula
+        _value     = format
+      else
+        _row = row
+        _col = col
+        _formula = formula
+        _format = format
+        _value = value
+      end
+      raise WriteXLSXInsufficientArgumentError if [_row, _col, _formula].include?(nil)
 
       # Check for dynamic array functions.
       regex = /\bLET\(|\bSORT\(|\bLAMBDA\(|\bSINGLE\(|\bSORTBY\(|\bUNIQUE\(|\bXMATCH\(|\bFILTER\(|\bXLOOKUP\(|\bSEQUENCE\(|\bRANDARRAY\(|\bANCHORARRAY\(/
-      if formula =~ regex
+      if _formula =~ regex
         return write_dynamic_array_formula(
-          row, col, row, col, formula, format, value
+          _row, _col, _row, _col, _formula, _format, _value
         )
       end
 
       # Hand off array formulas.
-      if formula =~ /^\{=.*\}$/
-        write_array_formula(row, col, row, col, formula, format, value)
+      if _formula =~ /^\{=.*\}$/
+        write_array_formula(_row, _col, _row, _col, _formula, _format, _value)
       else
-        check_dimensions(row, col)
-        store_row_col_max_min_values(row, col)
-        formula = formula.sub(/^=/, '')
+        check_dimensions(_row, _col)
+        store_row_col_max_min_values(_row, _col)
+        _formula = _formula.sub(/^=/, '')
 
-        store_data_to_table(FormulaCellData.new(formula, format, value), row, col)
+        store_data_to_table(FormulaCellData.new(_formula, _format, _value), _row, _col)
       end
     end
 
@@ -1300,7 +1403,12 @@ module Writexlsx
         params = args
       end
 
-      row1, col1, row2, col2, formula, xf, value = row_col_notation(params)
+      if (row_col_array = row_col_notation(params.first))
+        row1, col1, row2, col2 = row_col_array
+        formula, xf, value = params[1..-1]
+      else
+        row1, col1, row2, col2, formula, xf, value = params
+      end
       raise WriteXLSXInsufficientArgumentError if [row1, col1, row2, col2, formula].include?(nil)
 
       # Swap last row/col with first row/col as necessary
@@ -1349,8 +1457,8 @@ module Writexlsx
     #
     # Write an array formula to the specified row and column (zero indexed).
     #
-    def write_array_formula(*args)
-      write_array_formula_base('a', *args)
+    def write_array_formula(row1, col1, row2 = nil, col2 = nil, formula = nil, format = nil, value = nil)
+      write_array_formula_base('a', row1, col1, row2, col2, formula, format, value)
     end
 
     #
@@ -1358,8 +1466,8 @@ module Writexlsx
     #
     # Write a dynamic formula to the specified row and column (zero indexed).
     #
-    def write_dynamic_array_formula(*args)
-      write_array_formula_base('d', *args)
+    def write_dynamic_array_formula(row1, col1, row2 = nil, col2 = nil, formula = nil, format = nil, value = nil)
+      write_array_formula_base('d', row1, col1, row2, col2, formula, format, value)
       @has_dynamic_arrays = true
     end
 
@@ -1368,18 +1476,27 @@ module Writexlsx
     #
     # Write a boolean value to the specified row and column (zero indexed).
     #
-    def write_boolean(*args)
-      row, col, val, xf = row_col_notation(args)
-      raise WriteXLSXInsufficientArgumentError if row.nil? || col.nil?
+    def write_boolean(row, col, val = nil, format = nil)
+      if (row_col_array = row_col_notation(row))
+        _row, _col = row_col_array
+        _val       = col
+        _format    = val
+      else
+        _row = row
+        _col = col
+        _val = val
+        _format = format
+      end
+      raise WriteXLSXInsufficientArgumentError if _row.nil? || _col.nil?
 
-      val = val ? 1 : 0  # Boolean value.
+      _val = _val ? 1 : 0  # Boolean value.
       # xf : cell format.
 
       # Check that row and col are valid and store max and min values
-      check_dimensions(row, col)
-      store_row_col_max_min_values(row, col)
+      check_dimensions(_row, _col)
+      store_row_col_max_min_values(_row, _col)
 
-      store_data_to_table(BooleanCellData.new(val, xf), row, col)
+      store_data_to_table(BooleanCellData.new(_val, _format), _row, _col)
     end
 
     #
@@ -1388,28 +1505,35 @@ module Writexlsx
     #
     # Update formatting of the cell to the specified row and column (zero indexed).
     #
-    def update_format_with_params(*args)
-      row, col, params = row_col_notation(args)
-      raise WriteXLSXInsufficientArgumentError if row.nil? || col.nil? || params.nil?
+    def update_format_with_params(row, col, params = nil)
+      if (row_col_array = row_col_notation(row))
+        _row, _col = row_col_array
+        _params = args[1]
+      else
+        _row = row
+        _col = col
+        _params = params
+      end
+      raise WriteXLSXInsufficientArgumentError if _row.nil? || _col.nil? || _params.nil?
 
       # Check that row and col are valid and store max and min values
-      check_dimensions(row, col)
-      store_row_col_max_min_values(row, col)
+      check_dimensions(_row, _col)
+      store_row_col_max_min_values(_row, _col)
 
       format = nil
       cell_data = nil
-      if @cell_data_table[row].nil? || @cell_data_table[row][col].nil?
-        format = @workbook.add_format(params)
-        write_blank(row, col, format)
+      if @cell_data_table[_row].nil? || @cell_data_table[_row][_col].nil?
+        format = @workbook.add_format(_params)
+        write_blank(_row, _col, format)
       else
-        if @cell_data_table[row][col].xf.nil?
-          format = @workbook.add_format(params)
-          cell_data = @cell_data_table[row][col]
+        if @cell_data_table[_row][_col].xf.nil?
+          format = @workbook.add_format(_params)
+          cell_data = @cell_data_table[_row][_col]
         else
           format = @workbook.add_format
-          cell_data = @cell_data_table[row][col]
+          cell_data = @cell_data_table[_row][_col]
           format.copy(cell_data.xf)
-          format.set_format_properties(params)
+          format.set_format_properties(_params)
         end
         # keep original value of cell
         value = if cell_data.is_a? FormulaCellData
@@ -1421,7 +1545,7 @@ module Writexlsx
                 else
                   cell_data.data
                 end
-        write(row, col, value, format)
+        write(_row, _col, value, format)
       end
     end
 
@@ -1431,22 +1555,31 @@ module Writexlsx
     #
     # Update formatting of cells in range to the specified row and column (zero indexed).
     #
-    def update_range_format_with_params(*args)
-      row_first, col_first, row_last, col_last, params = row_col_notation(args)
+    def update_range_format_with_params(row_first, col_first, row_last = nil, col_last = nil, params = nil)
+      if (row_col_array = row_col_notation(row_first))
+        _row_first, _col_first, _row_last, _col_last = row_col_array
+        params = args[1..-1]
+      else
+        _row_first = row_first
+        _col_first = col_first
+        _row_last  = row_last
+        _col_last  = col_last
+        _params    = params
+      end
 
-      raise WriteXLSXInsufficientArgumentError if [row_first, col_first, row_last, col_last, params].include?(nil)
+      raise WriteXLSXInsufficientArgumentError if [_row_first, _col_first, _row_last, _col_last, _params].include?(nil)
 
       # Swap last row/col with first row/col as necessary
-      row_first,  row_last = row_last,  row_first  if row_first > row_last
-      col_first, col_last = col_last, col_first if col_first > col_last
+      _row_first, _row_last = _row_last, _row_first if _row_first > _row_last
+      _col_first, _col_last = _col_last, _col_first if _col_first > _col_last
 
       # Check that column number is valid and store the max value
-      check_dimensions(row_last, col_last)
-      store_row_col_max_min_values(row_last, col_last)
+      check_dimensions(_row_last, _col_last)
+      store_row_col_max_min_values(_row_last, _col_last)
 
-      (row_first..row_last).each do |row|
-        (col_first..col_last).each do |col|
-          update_format_with_params(row, col, params)
+      (_row_first.._row_last).each do |row|
+        (_col_first.._col_last).each do |col|
+          update_format_with_params(row, col, _params)
         end
       end
     end
@@ -1483,26 +1616,39 @@ module Writexlsx
     # The label is written using the {#write()}[#method-i-write] method. Therefore it is
     # possible to write strings, numbers or formulas as labels.
     #
-    def write_url(*args)
+    def write_url(row, col, url = nil, format = nil, str = nil, tip = nil)
       # Check for a cell reference in A1 notation and substitute row and column
-      row, col, url, xf, str, tip = row_col_notation(args)
-      xf, str = str, xf if str.respond_to?(:xf_index) || !xf.respond_to?(:xf_index)
-      raise WriteXLSXInsufficientArgumentError if [row, col, url].include?(nil)
+      if (row_col_array = row_col_notation(row))
+        _row, _col = row_col_array
+        _url       = col
+        _format    = url
+        _str       = format
+        _tip       = str
+      else
+        _row = row
+        _col = col
+        _url = url
+        _format = format
+        _str = str
+        _tip = tip
+      end
+      _format, _str = _str, _format if _str.respond_to?(:xf_index) || !_format.respond_to?(:xf_index)
+      raise WriteXLSXInsufficientArgumentError if [_row, _col, _url].include?(nil)
 
       # Check that row and col are valid and store max and min values
-      check_dimensions(row, col)
-      store_row_col_max_min_values(row, col)
+      check_dimensions(_row, _col)
+      store_row_col_max_min_values(_row, _col)
 
-      hyperlink = Hyperlink.factory(url, str, tip)
-      store_hyperlink(row, col, hyperlink)
+      hyperlink = Hyperlink.factory(_url, _str, _tip)
+      store_hyperlink(_row, _col, hyperlink)
 
       raise "URL '#{url}' added but URL exceeds Excel's limit of 65,530 URLs per worksheet." if hyperlinks_count > 65_530
 
       # Add the default URL format.
-      xf ||= @default_url_format
+      _format ||= @default_url_format
 
       # Write the hyperlink string.
-      write_string(row, col, hyperlink.str, xf)
+      write_string(_row, _col, hyperlink.str, _format)
     end
 
     #
@@ -1512,22 +1658,31 @@ module Writexlsx
     # Write a datetime string in ISO8601 "yyyy-mm-ddThh:mm:ss.ss" format as a
     # number representing an Excel date. format is optional.
     #
-    def write_date_time(*args)
+    def write_date_time(row, col, str, format = nil)
       # Check for a cell reference in A1 notation and substitute row and column
-      row, col, str, xf = row_col_notation(args)
-      raise WriteXLSXInsufficientArgumentError if [row, col, str].include?(nil)
+      if (row_col_array = row_col_notation(row))
+        _row, _col = row_col_array
+        _str       = col
+        _format    = str
+      else
+        _row = row
+        _col = col
+        _str = str
+        _format = format
+      end
+      raise WriteXLSXInsufficientArgumentError if [_row, _col, _str].include?(nil)
 
       # Check that row and col are valid and store max and min values
-      check_dimensions(row, col)
-      store_row_col_max_min_values(row, col)
+      check_dimensions(_row, _col)
+      store_row_col_max_min_values(_row, _col)
 
-      date_time = convert_date_time(str)
+      date_time = convert_date_time(_str)
 
       if date_time
-        store_data_to_table(NumberCellData.new(date_time, xf), row, col)
+        store_data_to_table(NumberCellData.new(date_time, _format), _row, _col)
       else
         # If the date isn't valid then write it as a string.
-        write_string(*args)
+        write_string(_row, _col, _str, _format)
       end
     end
 
@@ -1539,13 +1694,22 @@ module Writexlsx
     # The Chart must be created by the add_chart() Workbook method and
     # it must have the embedded option set.
     #
-    def insert_chart(*args)
+    def insert_chart(row, col, chart = nil, *options)
       # Check for a cell reference in A1 notation and substitute row and column.
-      row, col, chart, *options = row_col_notation(args)
-      raise WriteXLSXInsufficientArgumentError if [row, col, chart].include?(nil)
+      if (row_col_array = row_col_notation(row))
+        _row, _col = row_col_array
+        _chart     = col
+        _options   = [chart] + options
+      else
+        _row = row
+        _col = col
+        _chart = chart
+        _options = options
+      end
+      raise WriteXLSXInsufficientArgumentError if [_row, _col, _chart].include?(nil)
 
-      if options.first.instance_of?(Hash)
-        params = options.first
+      if _options.first.instance_of?(Hash)
+        params = _options.first
         x_offset    = params[:x_offset]
         y_offset    = params[:y_offset]
         x_scale     = params[:x_scale]
@@ -1554,7 +1718,7 @@ module Writexlsx
         description = params[:description]
         decorative  = params[:decorative]
       else
-        x_offset, y_offset, x_scale, y_scale, anchor = options
+        x_offset, y_offset, x_scale, y_scale, anchor = _options
       end
       x_offset ||= 0
       y_offset ||= 0
@@ -1562,24 +1726,24 @@ module Writexlsx
       y_scale  ||= 1
       anchor   ||= 1
 
-      raise "Not a Chart object in insert_chart()" unless chart.is_a?(Chart) || chart.is_a?(Chartsheet)
-      raise "Not a embedded style Chart object in insert_chart()" if chart.respond_to?(:embedded) && chart.embedded == 0
+      raise "Not a Chart object in insert_chart()" unless _chart.is_a?(Chart) || _chart.is_a?(Chartsheet)
+      raise "Not a embedded style Chart object in insert_chart()" if _chart.respond_to?(:embedded) && _chart.embedded == 0
 
-      if chart.already_inserted? || (chart.combined && chart.combined.already_inserted?)
+      if _chart.already_inserted? || (_chart.combined && _chart.combined.already_inserted?)
         raise "Chart cannot be inserted in a worksheet more than once"
       else
-        chart.already_inserted          = true
-        chart.combined.already_inserted = true if chart.combined
+        _chart.already_inserted          = true
+        _chart.combined.already_inserted = true if _chart.combined
       end
 
       # Use the values set with chart.set_size, if any.
-      x_scale  = chart.x_scale  if chart.x_scale  != 1
-      y_scale  = chart.y_scale  if chart.y_scale  != 1
-      x_offset = chart.x_offset if ptrue?(chart.x_offset)
-      y_offset = chart.y_offset if ptrue?(chart.y_offset)
+      x_scale  = _chart.x_scale  if _chart.x_scale  != 1
+      y_scale  = _chart.y_scale  if _chart.y_scale  != 1
+      x_offset = _chart.x_offset if ptrue?(_chart.x_offset)
+      y_offset = _chart.y_offset if ptrue?(_chart.y_offset)
 
       @charts << [
-        row,     col,     chart,  x_offset,    y_offset,
+        _row,    _col,    _chart, x_offset,    y_offset,
         x_scale, y_scale, anchor, description, decorative
       ]
     end
@@ -1588,14 +1752,23 @@ module Writexlsx
     # :call-seq:
     #   insert_image(row, column, filename, options)
     #
-    def insert_image(*args)
+    def insert_image(row, col, image = nil, *options)
       # Check for a cell reference in A1 notation and substitute row and column.
-      row, col, image, *options = row_col_notation(args)
-      raise WriteXLSXInsufficientArgumentError if [row, col, image].include?(nil)
+      if (row_col_array = row_col_notation(row))
+        _row, _col = row_col_array
+        _image     = col
+        _options   = [image] + options
+      else
+        _row = row
+        _col = col
+        _image = image
+        _options = options
+      end
+      raise WriteXLSXInsufficientArgumentError if [_row, _col, _image].include?(nil)
 
-      if options.first.instance_of?(Hash)
+      if _options.first.instance_of?(Hash)
         # Newer hash bashed options
-        params      = options.first
+        params      = _options.first
         x_offset    = params[:x_offset]
         y_offset    = params[:y_offset]
         x_scale     = params[:x_scale]
@@ -1606,7 +1779,7 @@ module Writexlsx
         description = params[:description]
         decorative  = params[:decorative]
       else
-        x_offset, y_offset, x_scale, y_scale, anchor = options
+        x_offset, y_offset, x_scale, y_scale, anchor = _options
       end
       x_offset ||= 0
       y_offset ||= 0
@@ -1615,7 +1788,7 @@ module Writexlsx
       anchor   ||= 2
 
       @images << [
-        row, col, image, x_offset, y_offset,
+        _row, _col, _image, x_offset, y_offset,
         x_scale, y_scale, url, tip, anchor, description, decorative
       ]
     end
@@ -1627,32 +1800,43 @@ module Writexlsx
     # Deprecated. This is a writeexcel gem's method that is no longer
     # required by WriteXLSX.
     #
-    def repeat_formula(*args)
+    def repeat_formula(row, col, formula, format, *pairs)
       # Check for a cell reference in A1 notation and substitute row and column.
-      row, col, formula, format, *pairs = row_col_notation(args)
-      raise WriteXLSXInsufficientArgumentError if [row, col].include?(nil)
+      if (row_col_array = row_col_notation(row))
+        _row, _col = row_col_array
+        _formula   = col
+        _format    = formula
+        _pairs     = [format] + pairs
+      else
+        _row = row
+        _col = col
+        _formula = formula
+        _format = format
+        _pairs = pairs
+      end
+      raise WriteXLSXInsufficientArgumentError if [_row, _col].include?(nil)
 
-      raise "Odd number of elements in pattern/replacement list" unless pairs.size.even?
-      raise "Not a valid formula" unless formula.respond_to?(:to_ary)
+      raise "Odd number of elements in pattern/replacement list" unless _pairs.size.even?
+      raise "Not a valid formula" unless _formula.respond_to?(:to_ary)
 
-      tokens  = formula.join("\t").split("\t")
+      tokens  = _formula.join("\t").split("\t")
       raise "No tokens in formula" if tokens.empty?
 
-      value = nil
-      if pairs[-2] == 'result'
-        value = pairs.pop
-        pairs.pop
+      _value = nil
+      if _pairs[-2] == 'result'
+        _value = _pairs.pop
+        _pairs.pop
       end
-      until pairs.empty?
-        pattern = pairs.shift
-        replace = pairs.shift
+      until _pairs.empty?
+        pattern = _pairs.shift
+        replace = _pairs.shift
 
         tokens.each do |token|
           break if token.sub!(pattern, replace)
         end
       end
-      formula = tokens.join('')
-      write_formula(row, col, formula, format, value)
+      _formula = tokens.join('')
+      write_formula(_row, _col, _formula, _format, _value)
     end
 
     #
@@ -1741,7 +1925,13 @@ module Writexlsx
     # others should be blank. All cells should contain the same format.
     #
     def merge_range(*args)
-      row_first, col_first, row_last, col_last, string, format, *extra_args = row_col_notation(args)
+      if (row_col_array = row_col_notation(args.first))
+        row_first, col_first, row_last, col_last = row_col_array
+        string, format, *extra_args = args[1..-1]
+      else
+        row_first, col_first, row_last, col_last,
+        string, format, *extra_args = args
+      end
 
       raise "Incorrect number of arguments" if [row_first, col_first, row_last, col_last, format].include?(nil)
       raise "Fifth parameter must be a format object" unless format.respond_to?(:xf_index)
@@ -1774,10 +1964,21 @@ module Writexlsx
     def merge_range_type(type, *args)
       case type
       when 'array_formula', 'blank', 'rich_string'
-        row_first, col_first, row_last, col_last, *others = row_col_notation(args)
+        if (row_col_array = row_col_notation(args.first))
+          row_first, col_first, row_last, col_last = row_col_array
+          *others = args[1..-1]
+        else
+          row_first, col_first, row_last, col_last, *others = args
+        end
         format = others.pop
       else
-        row_first, col_first, row_last, col_last, token, format, *others = row_col_notation(args)
+        if (row_col_array = row_col_notation(args.first))
+          row_first, col_first, row_last, col_last = row_col_array
+          token, format, *others = args[1..-1]
+        else
+          row_first, col_first, row_last, col_last,
+          token, format, *others = args
+        end
       end
 
       raise "Format object missing or in an incorrect position" unless format.respond_to?(:xf_index)
@@ -1870,8 +2071,16 @@ module Writexlsx
     # The insert_button() method can be used to insert an Excel form button
     # into a worksheet.
     #
-    def insert_button(*args)
-      @buttons_array << button_params(*row_col_notation(args))
+    def insert_button(row, col, properties = nil)
+      if (row_col_array = row_col_notation(row))
+        _row, _col = row_col_array
+        _properties = col
+      else
+        _row = row
+        _col = col
+        _properties = properties
+      end
+      @buttons_array << button_params(_row, _col, _properties)
       @has_vml = 1
     end
 
@@ -1937,17 +2146,24 @@ module Writexlsx
     #
     # Set the autofilter area in the worksheet.
     #
-    def autofilter(*args)
-      row1, col1, row2, col2 = row_col_notation(args)
-      return if [row1, col1, row2, col2].include?(nil)
+    def autofilter(row1, col1 = nil, row2 = nil, col2 = nil)
+      if (row_col_array = row_col_notation(row1))
+        _row1, _col1, _row2, _col2 = row_col_array
+      else
+        _row1 = row1
+        _col1 = col1
+        _row2 = row2
+        _col2 = col2
+      end
+      return if [_row1, _col1, _row2, _col2].include?(nil)
 
       # Reverse max and min values if necessary.
-      row1, row2 = row2, row1 if row2 < row1
-      col1, col2 = col2, col1 if col2 < col1
+      _row1, _row2 = _row2, _row1 if _row2 < _row1
+      _col1, _col2 = _col2, _col1 if _col2 < _col1
 
-      @autofilter_area = convert_name_area(row1, col1, row2, col2)
-      @autofilter_ref  = xl_range(row1, row2, col1, col2)
-      @filter_range    = [col1, col2]
+      @autofilter_area = convert_name_area(_row1, _col1, _row2, _col2)
+      @autofilter_ref  = xl_range(_row1, _row2, _col1, _col2)
+      @filter_range    = [_col1, _col2]
     end
 
     #
@@ -2228,10 +2444,12 @@ module Writexlsx
     # Write the cell value <v> element.
     #
     def write_cell_value(value = '') # :nodoc:
-      return write_cell_formula('=NA()') if !value.nil? && value.is_a?(Float) && value.nan?
+      return write_cell_formula('=NA()') if value.is_a?(Float) && value.nan?
 
       value ||= ''
-      value = value.to_i if value == value.to_i
+
+      int_value = value.to_i
+      value = int_value if value == int_value
       @writer.data_element('v', value)
     end
 
@@ -2902,19 +3120,38 @@ EOS
     #
     # Insert a shape into the worksheet.
     #
-    def insert_shape(*args)
+    def insert_shape(
+          row_start, column_start, shape = nil, x_offset = nil, y_offset = nil,
+          x_scale = nil, y_scale = nil, anchor = nil
+        )
       # Check for a cell reference in A1 notation and substitute row and column.
-      row_start, column_start, shape, x_offset, y_offset, x_scale, y_scale, anchor =
-        row_col_notation(args)
-      raise "Insufficient arguments in insert_shape()" if [row_start, column_start, shape].include?(nil)
+      if (row_col_array = row_col_notation(row_start))
+        _row_start, _column_start = row_col_array
+        _shape    = column_start
+        _x_offset = shape
+        _y_offset = x_offset
+        _x_scale  = y_offset
+        _y_scale  = x_scale
+        _anchor   = y_scale
+      else
+        _row_start = row_start
+        _column_start = column_start
+        _shape = shape
+        _x_offset = x_offset
+        _y_offset = y_offset
+        _x_scale = x_scale
+        _y_scale = y_scale
+        _anchor = anchor
+      end
+      raise "Insufficient arguments in insert_shape()" if [_row_start, _column_start, _shape].include?(nil)
 
-      shape.set_position(
-        row_start, column_start, x_offset, y_offset,
-        x_scale, y_scale, anchor
+      _shape.set_position(
+        _row_start, _column_start, _x_offset, _y_offset,
+        _x_scale, _y_scale, _anchor
       )
       # Assign a shape ID.
       while true
-        id = shape.id || 0
+        id = _shape.id || 0
         used = @shape_hash[id]
 
         # Test if shape ID is already used. Otherwise assign a new one.
@@ -2922,20 +3159,20 @@ EOS
           break
         else
           @last_shape_id += 1
-          shape.id = @last_shape_id
+          _shape.id = @last_shape_id
         end
       end
 
       # Allow lookup of entry into shape array by shape ID.
-      @shape_hash[shape.id] = shape.element = @shapes.size
+      @shape_hash[_shape.id] = _shape.element = @shapes.size
 
-      insert = if ptrue?(shape.stencil)
+      insert = if ptrue?(_shape.stencil)
                  # Insert a copy of the shape, not a reference so that the shape is
                  # used as a stencil. Previously stamped copies don't get modified
                  # if the stencil is modified.
-                 shape.dup
+                 _shape.dup
                else
-                 shape
+                 _shape
                end
 
       # For connectors change x/y coords based on location of connected shapes.
@@ -3333,8 +3570,11 @@ EOS
     end
 
     def write_cell_column_dimension(row_num)  # :nodoc:
+      row = @cell_data_table[row_num]
       (@dim_colmin..@dim_colmax).each do |col_num|
-        @cell_data_table[row_num][col_num].write_cell(self, row_num, col_num) if @cell_data_table[row_num][col_num]
+        if (cell = row[col_num])
+          cell.write_cell(self, row_num, col_num)
+        end
       end
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: write_xlsx
 version: !ruby/object:Gem::Version
-  version: 1.10.1
+  version: 1.10.2
 platform: ruby
 authors:
 - Hideo NAKAMURA
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-30 00:00:00.000000000 Z
+date: 2023-02-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
@@ -275,7 +275,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.1
+rubygems_version: 3.4.5
 signing_key:
 specification_version: 4
 summary: write_xlsx is a gem to create a new file in the Excel 2007+ XLSX format.