write_xlsx 1.09.3 → 1.11.2

data/lib/write_xlsx/utility.rb

@@ -1,21 +1,42 @@
 # -*- coding: utf-8 -*-
 # frozen_string_literal: true
+
 require 'write_xlsx/col_name'
 
 module Writexlsx
   module Utility
-    ROW_MAX  = 1048576  # :nodoc:
-    COL_MAX  = 16384    # :nodoc:
-    STR_MAX  = 32767    # :nodoc:
+    ROW_MAX       = 1048576  # :nodoc:
+    COL_MAX       = 16384    # :nodoc:
+    STR_MAX       = 32767    # :nodoc:
     SHEETNAME_MAX = 31  # :nodoc:
+    CHAR_WIDTHS   = {
+      ' '  =>  3, '!' =>  5, '"' =>  6, '#' =>  7, '$' =>  7, '%' => 11,
+      '&'  => 10, "'" =>  3, '(' =>  5, ')' =>  5, '*' =>  7, '+' =>  7,
+      ','  =>  4, '-' =>  5, '.' =>  4, '/' =>  6, '0' =>  7, '1' =>  7,
+      '2'  =>  7, '3' =>  7, '4' =>  7, '5' =>  7, '6' =>  7, '7' =>  7,
+      '8'  =>  7, '9' =>  7, ':' =>  4, ';' =>  4, '<' =>  7, '=' =>  7,
+      '>'  =>  7, '?' =>  7, '@' => 13, 'A' =>  9, 'B' =>  8, 'C' =>  8,
+      'D'  =>  9, 'E' =>  7, 'F' =>  7, 'G' =>  9, 'H' =>  9, 'I' =>  4,
+      'J'  =>  5, 'K' =>  8, 'L' =>  6, 'M' => 12, 'N' => 10, 'O' => 10,
+      'P'  =>  8, 'Q' => 10, 'R' =>  8, 'S' =>  7, 'T' =>  7, 'U' =>  9,
+      'V'  =>  9, 'W' => 13, 'X' =>  8, 'Y' =>  7, 'Z' =>  7, '[' =>  5,
+      '\\' =>  6, ']' =>  5, '^' =>  7, '_' =>  7, '`' =>  4, 'a' =>  7,
+      'b'  =>  8, 'c' =>  6, 'd' =>  8, 'e' =>  8, 'f' =>  5, 'g' =>  7,
+      'h'  =>  8, 'i' =>  4, 'j' =>  4, 'k' =>  7, 'l' =>  4, 'm' => 12,
+      'n'  =>  8, 'o' =>  8, 'p' =>  8, 'q' =>  8, 'r' =>  5, 's' =>  6,
+      't'  =>  5, 'u' =>  8, 'v' =>  7, 'w' => 11, 'x' =>  7, 'y' =>  7,
+      'z'  =>  6, '{' =>  5, '|' =>  7, '}' =>  5, '~' =>  7
+    }.freeze
 
     #
     # xl_rowcol_to_cell($row, col, row_absolute, col_absolute)
     #
-    def xl_rowcol_to_cell(row, col, row_absolute = false, col_absolute = false)
-      row += 1      # Change from 0-indexed to 1 indexed.
+    def xl_rowcol_to_cell(row_or_name, col, row_absolute = false, col_absolute = false)
+      if row_or_name.is_a?(Integer)
+        row_or_name += 1      # Change from 0-indexed to 1 indexed.
+      end
       col_str = xl_col_to_name(col, col_absolute)
-      "#{col_str}#{absolute_char(row_absolute)}#{row}"
+      "#{col_str}#{absolute_char(row_absolute)}#{row_or_name}"
     end
 
     #
@@ -27,19 +48,19 @@ module Writexlsx
     def xl_cell_to_rowcol(cell)
       cell =~ /(\$?)([A-Z]{1,3})(\$?)(\d+)/
 
-      col_abs = $1 != ""
-      col     = $2
-      row_abs = $3 != ""
-      row     = $4.to_i
+      col_abs = ::Regexp.last_match(1) != ""
+      col     = ::Regexp.last_match(2)
+      row_abs = ::Regexp.last_match(3) != ""
+      row     = ::Regexp.last_match(4).to_i
 
       # Convert base26 column string to number
       # All your Base are belong to us.
-      chars = col.split(//)
+      chars = col.split("")
       expn = 0
       col = 0
 
       chars.reverse.each do |char|
-        col += (char.ord - 'A'.ord + 1) * (26 ** expn)
+        col += (char.ord - 'A'.ord + 1) * (26**expn)
         expn += 1
       end
 
@@ -47,12 +68,17 @@ module Writexlsx
       row -= 1
       col -= 1
 
-      return [row, col, row_abs, col_abs]
+      [row, col, row_abs, col_abs]
     end
 
     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,
@@ -72,33 +98,47 @@ module Writexlsx
       # non-word character or if it isn't already quoted.
       sheetname = "'#{sheetname}'" if sheetname =~ /\W/ && !(sheetname =~ /^'/)
 
-      range1 = xl_rowcol_to_cell( row_1, col_1, 1, 1 )
-      range2 = xl_rowcol_to_cell( row_2, col_2, 1, 1 )
+      range1 = xl_rowcol_to_cell(row_1, col_1, 1, 1)
+      range2 = xl_rowcol_to_cell(row_2, col_2, 1, 1)
 
       "=#{sheetname}!#{range1}:#{range2}"
     end
 
+    #
+    # xl_string_pixel_width($string)
+    #
+    # Get the pixel width of a string based on individual character widths taken
+    # from Excel. UTF8 characters are given a default width of 8.
+    #
+    # Note, Excel adds an additional 7 pixels padding to a cell.
+    #
+    def xl_string_pixel_width(string)
+      length = 0
+      string.to_s.split("").each { |char| length += CHAR_WIDTHS[char] || 8 }
+
+      length
+    end
+
     #
     # Sheetnames used in references should be quoted if they contain any spaces,
     # special characters or if the look like something that isn't a sheet name.
     # TODO. We need to handle more special cases.
     #
-    def quote_sheetname(sheetname) #:nodoc:
+    def quote_sheetname(sheetname) # :nodoc:
       # Use Excel's conventions and quote the sheet name if it comtains any
       # non-word character or if it isn't already quoted.
       name = sheetname.dup
       if name =~ /\W/ && !(name =~ /^'/)
         # Double quote and single quoted strings.
-        name = name.gsub(/'/, "''")
+        name = name.gsub("'", "''")
         name = "'#{name}'"
       end
       name
     end
 
     def check_dimensions(row, col)
-      if !row || row >= ROW_MAX || !col || col >= COL_MAX
-        raise WriteXLSXDimensionError
-      end
+      raise WriteXLSXDimensionError if !row || row >= ROW_MAX || !col || col >= COL_MAX
+
       0
     end
 
@@ -108,11 +148,11 @@ module Writexlsx
     # The function takes a date and time in ISO8601 "yyyy-mm-ddThh:mm:ss.ss" format
     # and converts it to a decimal number representing a valid Excel date.
     #
-    def convert_date_time(date_time_string)       #:nodoc:
+    def convert_date_time(date_time_string)       # :nodoc:
       date_time = date_time_string.to_s.sub(/^\s+/, '').sub(/\s+$/, '').sub(/Z$/, '')
 
       # Check for invalid date char.
-      return nil if date_time =~ /[^0-9T:\-\.Z]/
+      return nil if date_time =~ /[^0-9T:\-.Z]/
 
       # Check for "T" after date or before time.
       return nil unless date_time =~ /\dT|T\d/
@@ -121,15 +161,15 @@ module Writexlsx
       seconds   = 0 # Time expressed as fraction of 24h hours in seconds
 
       # Split into date and time.
-      date, time = date_time.split(/T/)
+      date, time = date_time.split("T")
 
       # We allow the time portion of the input DateTime to be optional.
       if time
         # Match hh:mm:ss.sss+ where the seconds are optional
         if time =~ /^(\d\d):(\d\d)(:(\d\d(\.\d+)?))?/
-          hour   = $1.to_i
-          min    = $2.to_i
-          sec    = $4.to_f || 0
+          hour   = ::Regexp.last_match(1).to_i
+          min    = ::Regexp.last_match(2).to_i
+          sec    = ::Regexp.last_match(4).to_f || 0
         else
           return nil # Not a valid time format.
         end
@@ -140,7 +180,7 @@ module Writexlsx
         return nil if sec  >= 60
 
         # Excel expresses seconds as a fraction of the number in 24 hours.
-        seconds = (hour * 60* 60 + min * 60 + sec) / (24.0 * 60 * 60)
+        seconds = ((hour * 60 * 60) + (min * 60) + sec) / (24.0 * 60 * 60)
       end
 
       # We allow the date portion of the input DateTime to be optional.
@@ -148,9 +188,9 @@ module Writexlsx
 
       # Match date as yyyy-mm-dd.
       if date =~ /^(\d\d\d\d)-(\d\d)-(\d\d)$/
-        year   = $1.to_i
-        month  = $2.to_i
-        day    = $3.to_i
+        year   = ::Regexp.last_match(1).to_i
+        month  = ::Regexp.last_match(2).to_i
+        day    = ::Regexp.last_match(3).to_i
       else
         return nil  # Not a valid date format.
       end
@@ -163,22 +203,21 @@ module Writexlsx
         return 60 + seconds if date == '1900-02-29' # Excel false leapday
       end
 
-
       # We calculate the date by calculating the number of days since the epoch
       # and adjust for the number of leap days. We calculate the number of leap
       # days by normalising the year in relation to the epoch. Thus the year 2000
       # becomes 100 for 4 and 100 year leapdays and 400 for 400 year leapdays.
       #
       epoch   = date_1904? ? 1904 : 1900
-      offset  = date_1904? ?    4 :    0
+      offset  = date_1904? ? 4 : 0
       norm    = 300
       range   = year - epoch
 
       # Set month days and check for leap year.
       mdays   = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
       leap    = 0
-      leap    = 1  if year % 4 == 0 && year % 100 != 0 || year % 400 == 0
-      mdays[1]   = 29 if leap != 0
+      leap    = 1  if (year % 4 == 0 && year % 100 != 0) || year % 400 == 0
+      mdays[1] = 29 if leap != 0
 
       # Some boundary checks
       return nil if year  < epoch or year  > 9999
@@ -187,13 +226,13 @@ module Writexlsx
 
       # Accumulate the number of days since the epoch.
       days = day                               # Add days for current month
-      (0 .. month-2).each do |m|
+      (0..month - 2).each do |m|
         days += mdays[m]                      # Add days for past months
       end
       days += range * 365                      # Add days for past years
-      days += ((range)                /  4)    # Add leapdays
-      days -= ((range + offset)       /100)    # Subtract 100 year leapdays
-      days += ((range + offset + norm)/400)    # Add 400 year leapdays
+      days += (range / 4)    # Add leapdays
+      days -= ((range + offset) / 100)    # Subtract 100 year leapdays
+      days += ((range + offset + norm) / 400)    # Add 400 year leapdays
       days -= leap                             # Already counted above
 
       # Adjust for Excel erroneously treating 1900 as a leap year.
@@ -211,7 +250,7 @@ module Writexlsx
     def escape_url(url)
       unless url =~ /%[0-9a-fA-F]{2}/
         # Escape the URL escape symbol.
-        url = url.gsub(/%/, "%25")
+        url = url.gsub("%", "%25")
 
         # Escape whitespae in URL.
         url = url.gsub(/[\s\x00]/, '%20')
@@ -241,23 +280,20 @@ module Writexlsx
       elsif FileTest.directory?(path)
         Dir.foreach(path) do |file|
           next if file =~ /^\.\.?$/  # '.' or '..'
-          delete_files(path.sub(/\/+$/,"") + '/' + file)
+
+          delete_files(path.sub(%r{/+$}, "") + '/' + file)
         end
         Dir.rmdir(path)
       end
     end
 
     def put_deprecate_message(method)
-      $stderr.puts("Warning: calling deprecated method #{method}. This method will be removed in a future release.")
+      warn("Warning: calling deprecated method #{method}. This method will be removed in a future release.")
     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.respond_to?(:match) && row_or_a1.to_s =~ /^\D/
     end
 
     #
@@ -266,8 +302,8 @@ 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
+    def substitute_cellref(cell, *args)       # :nodoc:
+      #      return [*args] if cell.respond_to?(:coerce) # Numeric
 
       normalized_cell = cell.upcase
 
@@ -275,18 +311,18 @@ module Writexlsx
       # Convert a column range: 'A:A' or 'B:G'.
       # A range such as A:A is equivalent to A1:65536, so add rows as required
       when /\$?([A-Z]{1,3}):\$?([A-Z]{1,3})/
-        row1, col1 =  xl_cell_to_rowcol($1 + '1')
-        row2, col2 =  xl_cell_to_rowcol($2 + ROW_MAX.to_s)
-        return [row1, col1, row2, col2, *args]
+        row1, col1 =  xl_cell_to_rowcol(::Regexp.last_match(1) + '1')
+        row2, col2 =  xl_cell_to_rowcol(::Regexp.last_match(2) + ROW_MAX.to_s)
+        [row1, col1, row2, col2, *args]
       # Convert a cell range: 'A1:B7'
       when /\$?([A-Z]{1,3}\$?\d+):\$?([A-Z]{1,3}\$?\d+)/
-        row1, col1 =  xl_cell_to_rowcol($1)
-        row2, col2 =  xl_cell_to_rowcol($2)
-        return [row1, col1, row2, col2, *args]
+        row1, col1 =  xl_cell_to_rowcol(::Regexp.last_match(1))
+        row2, col2 =  xl_cell_to_rowcol(::Regexp.last_match(2))
+        [row1, col1, row2, col2, *args]
       # Convert a cell reference: 'A1' or 'AD2000'
       when /\$?([A-Z]{1,3}\$?\d+)/
-        row1, col1 =  xl_cell_to_rowcol($1)
-        return [row1, col1, *args]
+        row1, col1 = xl_cell_to_rowcol(::Regexp.last_match(1))
+        [row1, col1, *args]
       else
         raise("Unknown cell reference #{normalized_cell}")
       end
@@ -294,11 +330,11 @@ module Writexlsx
 
     def underline_attributes(underline)
       if underline == 2
-        [['val', 'double']]
+        [%w[val double]]
       elsif underline == 33
-        [['val', 'singleAccounting']]
+        [%w[val singleAccounting]]
       elsif underline == 34
-        [['val', 'doubleAccounting']]
+        [%w[val doubleAccounting]]
       else
         []    # Default to single underline.
       end
@@ -307,7 +343,7 @@ module Writexlsx
     #
     # Write the <color> element.
     #
-    def write_color(writer, name, value) #:nodoc:
+    def write_color(name, value, writer = @writer) # :nodoc:
       attributes = [[name, value]]
 
       writer.empty_tag('color', attributes)
@@ -329,7 +365,7 @@ module Writexlsx
       invalids = params.keys - valid_keys
       unless invalids.empty?
         raise WriteXLSXOptionParameterError,
-              "Unknown parameter '#{invalids.join(', ')}' in #{method}."
+              "Unknown parameter '#{invalids.join(", ")}' in #{method}."
       end
       true
     end
@@ -338,7 +374,7 @@ module Writexlsx
     # Check that row and col are valid and store max and min values for use in
     # other methods/elements.
     #
-    def check_dimensions_and_update_max_min_values(row, col, ignore_row = 0, ignore_col = 0)       #:nodoc:
+    def check_dimensions_and_update_max_min_values(row, col, ignore_row = 0, ignore_col = 0)       # :nodoc:
       check_dimensions(row, col)
       store_row_max_min_values(row) if ignore_row == 0
       store_col_max_min_values(col) if ignore_col == 0
@@ -358,6 +394,7 @@ module Writexlsx
 
     def float_to_str(float)
       return '' unless float
+
       if float == float.to_i
         float.to_i.to_s
       else
@@ -379,17 +416,13 @@ module Writexlsx
       legend.layout = layout_properties(params[:layout])
 
       # Turn off the legend.
-      if params[:none]
-        legend.position = 'none'
-      end
+      legend.position = 'none' if params[:none]
 
       # Set the line properties for the legend.
       line = line_properties(params[:line])
 
       # Allow 'border' as a synonym for 'line'.
-      if params[:border]
-        line = line_properties(params[:border])
-      end
+      line = line_properties(params[:border]) if params[:border]
 
       # Set the fill properties for the legend.
       fill = fill_properties(params[:fill])
@@ -401,9 +434,7 @@ module Writexlsx
       gradient = gradient_properties(params[:gradient])
 
       # Pattern fill overrides solid fill.
-      if pattern
-        fill = nil
-      end
+      fill = nil if pattern
 
       # Gradient fill overrides solid and pattern fills.
       if gradient
@@ -429,17 +460,15 @@ module Writexlsx
     def layout_properties(args, is_text = false)
       return unless ptrue?(args)
 
-      properties = is_text ? [:x, :y] : [:x, :y, :width, :height]
+      properties = is_text ? %i[x y] : %i[x y width height]
 
       # Check for valid properties.
       args.keys.each do |key|
-        unless properties.include?(key.to_sym)
-          raise "Property '#{key}' not allowed in layout options\n"
-        end
+        raise "Property '#{key}' not allowed in layout options\n" unless properties.include?(key.to_sym)
       end
 
       # Set the layout properties
-      layout = Hash.new
+      layout = {}
       properties.each do |property|
         value = args[property]
         # Convert to the format used by Excel for easier testing.
@@ -453,8 +482,8 @@ module Writexlsx
     # Convert vertices from pixels to points.
     #
     def pixels_to_points(vertices)
-      col_start, row_start, x1,    y1,
-      col_end,   row_end,   x2,    y2,
+      _col_start, _row_start, _x1,    _y1,
+      _col_end,   _row_end,   _x2,    _y2,
       left,      top,       width, height  = vertices.flatten
 
       left   *= 0.75
@@ -465,11 +494,10 @@ module Writexlsx
       [left, top, width, height]
     end
 
-    def v_shape_attributes_base(id, z_index)
+    def v_shape_attributes_base(id)
       [
         ['id',    "_x0000_s#{id}"],
-        ['type',  type],
-        ['style', (v_shape_style_base(z_index, vertices) + style_addition).join]
+        ['type',  type]
       ]
     end
 
@@ -514,7 +542,7 @@ module Writexlsx
     def write_comment_path(gradientshapeok, connecttype)
       attributes      = []
 
-      attributes << ['gradientshapeok', 't'] if gradientshapeok
+      attributes << %w[gradientshapeok t] if gradientshapeok
       attributes << ['o:connecttype', connecttype]
 
       @writer.empty_tag('v:path', attributes)
@@ -573,7 +601,7 @@ module Writexlsx
     # Write the <v:stroke> element.
     #
     def write_stroke
-      attributes = [['joinstyle', 'miter']]
+      attributes = [%w[joinstyle miter]]
 
       @writer.empty_tag('v:stroke', attributes)
     end
@@ -620,61 +648,61 @@ module Writexlsx
       retuen nil unless args.has_key?(:fg_color)
 
       types = {
-        'percent_5'                 => 'pct5',
-        'percent_10'                => 'pct10',
-        'percent_20'                => 'pct20',
-        'percent_25'                => 'pct25',
-        'percent_30'                => 'pct30',
-        'percent_40'                => 'pct40',
-
-        'percent_50'                => 'pct50',
-        'percent_60'                => 'pct60',
-        'percent_70'                => 'pct70',
-        'percent_75'                => 'pct75',
-        'percent_80'                => 'pct80',
-        'percent_90'                => 'pct90',
-
-        'light_downward_diagonal'   => 'ltDnDiag',
-        'light_upward_diagonal'     => 'ltUpDiag',
-        'dark_downward_diagonal'    => 'dkDnDiag',
-        'dark_upward_diagonal'      => 'dkUpDiag',
-        'wide_downward_diagonal'    => 'wdDnDiag',
-        'wide_upward_diagonal'      => 'wdUpDiag',
-
-        'light_vertical'            => 'ltVert',
-        'light_horizontal'          => 'ltHorz',
-        'narrow_vertical'           => 'narVert',
-        'narrow_horizontal'         => 'narHorz',
-        'dark_vertical'             => 'dkVert',
-        'dark_horizontal'           => 'dkHorz',
-
-        'dashed_downward_diagonal'  => 'dashDnDiag',
-        'dashed_upward_diagonal'    => 'dashUpDiag',
-        'dashed_horizontal'         => 'dashHorz',
-        'dashed_vertical'           => 'dashVert',
-        'small_confetti'            => 'smConfetti',
-        'large_confetti'            => 'lgConfetti',
-
-        'zigzag'                    => 'zigZag',
-        'wave'                      => 'wave',
-        'diagonal_brick'            => 'diagBrick',
-        'horizontal_brick'          => 'horzBrick',
-        'weave'                     => 'weave',
-        'plaid'                     => 'plaid',
-
-        'divot'                     => 'divot',
-        'dotted_grid'               => 'dotGrid',
-        'dotted_diamond'            => 'dotDmnd',
-        'shingle'                   => 'shingle',
-        'trellis'                   => 'trellis',
-        'sphere'                    => 'sphere',
-
-        'small_grid'                => 'smGrid',
-        'large_grid'                => 'lgGrid',
-        'small_check'               => 'smCheck',
-        'large_check'               => 'lgCheck',
-        'outlined_diamond'          => 'openDmnd',
-        'solid_diamond'             => 'solidDmnd'
+        'percent_5'                => 'pct5',
+        'percent_10'               => 'pct10',
+        'percent_20'               => 'pct20',
+        'percent_25'               => 'pct25',
+        'percent_30'               => 'pct30',
+        'percent_40'               => 'pct40',
+
+        'percent_50'               => 'pct50',
+        'percent_60'               => 'pct60',
+        'percent_70'               => 'pct70',
+        'percent_75'               => 'pct75',
+        'percent_80'               => 'pct80',
+        'percent_90'               => 'pct90',
+
+        'light_downward_diagonal'  => 'ltDnDiag',
+        'light_upward_diagonal'    => 'ltUpDiag',
+        'dark_downward_diagonal'   => 'dkDnDiag',
+        'dark_upward_diagonal'     => 'dkUpDiag',
+        'wide_downward_diagonal'   => 'wdDnDiag',
+        'wide_upward_diagonal'     => 'wdUpDiag',
+
+        'light_vertical'           => 'ltVert',
+        'light_horizontal'         => 'ltHorz',
+        'narrow_vertical'          => 'narVert',
+        'narrow_horizontal'        => 'narHorz',
+        'dark_vertical'            => 'dkVert',
+        'dark_horizontal'          => 'dkHorz',
+
+        'dashed_downward_diagonal' => 'dashDnDiag',
+        'dashed_upward_diagonal'   => 'dashUpDiag',
+        'dashed_horizontal'        => 'dashHorz',
+        'dashed_vertical'          => 'dashVert',
+        'small_confetti'           => 'smConfetti',
+        'large_confetti'           => 'lgConfetti',
+
+        'zigzag'                   => 'zigZag',
+        'wave'                     => 'wave',
+        'diagonal_brick'           => 'diagBrick',
+        'horizontal_brick'         => 'horzBrick',
+        'weave'                    => 'weave',
+        'plaid'                    => 'plaid',
+
+        'divot'                    => 'divot',
+        'dotted_grid'              => 'dotGrid',
+        'dotted_diamond'           => 'dotDmnd',
+        'shingle'                  => 'shingle',
+        'trellis'                  => 'trellis',
+        'sphere'                   => 'sphere',
+
+        'small_grid'               => 'smGrid',
+        'large_grid'               => 'lgGrid',
+        'small_check'              => 'smCheck',
+        'large_check'              => 'lgCheck',
+        'outlined_diamond'         => 'openDmnd',
+        'solid_diamond'            => 'solidDmnd'
       }
 
       # Check for valid types.
@@ -691,7 +719,8 @@ module Writexlsx
     end
 
     def line_fill_properties(params)
-      return { :_defined => 0 } unless params
+      return { _defined: 0 } unless params
+
       ret = params.dup
       ret[:dash_type] = yield if block_given? && ret[:dash_type]
       ret[:_defined] = 1
@@ -700,22 +729,23 @@ module Writexlsx
 
     def dash_types
       {
-        :solid               => 'solid',
-        :round_dot           => 'sysDot',
-        :square_dot          => 'sysDash',
-        :dash                => 'dash',
-        :dash_dot            => 'dashDot',
-        :long_dash           => 'lgDash',
-        :long_dash_dot       => 'lgDashDot',
-        :long_dash_dot_dot   => 'lgDashDotDot',
-        :dot                 => 'dot',
-        :system_dash_dot     => 'sysDashDot',
-        :system_dash_dot_dot => 'sysDashDotDot'
+        solid:               'solid',
+        round_dot:           'sysDot',
+        square_dot:          'sysDash',
+        dash:                'dash',
+        dash_dot:            'dashDot',
+        long_dash:           'lgDash',
+        long_dash_dot:       'lgDashDot',
+        long_dash_dot_dot:   'lgDashDotDot',
+        dot:                 'dot',
+        system_dash_dot:     'sysDashDot',
+        system_dash_dot_dot: 'sysDashDotDot'
       }
     end
 
     def value_or_raise(hash, key, msg)
       raise "Unknown #{msg} '#{key}'" if hash[key.to_sym].nil?
+
       hash[key.to_sym]
     end
 
@@ -723,8 +753,8 @@ module Writexlsx
       # Adjust the colour index.
       idx = index - 8
 
-      rgb = @palette[idx]
-      sprintf("%02X%02X%02X", *rgb)
+      r, g, b = @palette[idx]
+      sprintf("%02X%02X%02X", r, g, b)
     end
 
     #
@@ -735,14 +765,14 @@ module Writexlsx
       when 0
         [{}, {}]
       when 1 # one hash
-        options_keys = [:tempdir, :date_1904, :optimization, :excel2003_style, :strings_to_urls]
+        options_keys = %i[tempdir date_1904 optimization excel2003_style strings_to_urls]
 
         hash = params.first
-        options = hash.reject{|k,v| !options_keys.include?(k)}
+        options = hash.reject { |k, _v| !options_keys.include?(k) }
 
         default_format_properties =
           hash[:default_format_properties] ||
-          hash.reject{|k,v| options_keys.include?(k)}
+          hash.reject { |k, _v| options_keys.include?(k) }
 
         [options, default_format_properties.dup]
       when 2 # array which includes options and default_format_properties
@@ -758,31 +788,30 @@ module Writexlsx
     #
     def convert_font_args(params)
       return unless params
+
       font = params_to_font(params)
 
       # Convert font size units.
       font[:_size] *= 100 if font[:_size] && font[:_size] != 0
 
       # Convert rotation into 60,000ths of a degree.
-      if ptrue?(font[:_rotation])
-        font[:_rotation] = 60_000 * font[:_rotation].to_i
-      end
+      font[:_rotation] = 60_000 * font[:_rotation].to_i if ptrue?(font[:_rotation])
 
       font
     end
 
     def params_to_font(params)
       {
-        :_name         => params[:name],
-        :_color        => params[:color],
-        :_size         => params[:size],
-        :_bold         => params[:bold],
-        :_italic       => params[:italic],
-        :_underline    => params[:underline],
-        :_pitch_family => params[:pitch_family],
-        :_charset      => params[:charset],
-        :_baseline     => params[:baseline] || 0,
-        :_rotation     => params[:rotation]
+        _name:         params[:name],
+        _color:        params[:color],
+        _size:         params[:size],
+        _bold:         params[:bold],
+        _italic:       params[:italic],
+        _underline:    params[:underline],
+        _pitch_family: params[:pitch_family],
+        _charset:      params[:charset],
+        _baseline:     params[:baseline] || 0,
+        _rotation:     params[:rotation]
       }
     end
 
@@ -791,9 +820,7 @@ module Writexlsx
     #
     def write_tx_pr(font, is_y_axis = nil) # :nodoc:
       rotation = nil
-      if font && font.respond_to?(:[]) && font[:_rotation]
-        rotation = font[:_rotation]
-      end
+      rotation = font[:_rotation] if font && font.respond_to?(:[]) && font[:_rotation]
       @writer.tag_elements('c:txPr') do
         # Write the a:bodyPr element.
         write_a_body_pr(rotation, is_y_axis)
@@ -814,14 +841,14 @@ module Writexlsx
         if rot == 16_200_000
           # 270 deg/stacked angle.
           attributes << ['rot',  0]
-          attributes << ['vert', 'wordArtVert']
+          attributes << %w[vert wordArtVert]
         elsif rot == 16_260_000
           # 271 deg/stacked angle.
           attributes << ['rot',  0]
-          attributes << ['vert', 'eaVert']
+          attributes << %w[vert eaVert]
         else
           attributes << ['rot',  rot]
-          attributes << ['vert', 'horz']
+          attributes << %w[vert horz]
         end
       end
 
@@ -871,12 +898,8 @@ module Writexlsx
 
       if !latin_attributes.empty? || has_color
         @writer.tag_elements(tag, style_attributes) do
-          if has_color
-            write_a_solid_fill(:color => font[:_color])
-          end
-          if !latin_attributes.empty?
-            write_a_latin(latin_attributes)
-          end
+          write_a_solid_fill(color: font[:_color]) if has_color
+          write_a_latin(latin_attributes) unless latin_attributes.empty?
         end
       else
         @writer.empty_tag(tag, style_attributes)
@@ -915,7 +938,7 @@ module Writexlsx
     #
     def write_a_srgb_clr(color, transparency = nil) # :nodoc:
       tag        = 'a:srgbClr'
-      attributes = [ ['val', color] ]
+      attributes = [['val', color]]
 
       if ptrue?(transparency)
         @writer.tag_elements(tag, attributes) do
@@ -936,6 +959,7 @@ module Writexlsx
       else
         index = Format.color(color_code)
         raise "Unknown color '#{color_code}' used in chart formatting." unless index
+
         palette_color(index)
       end
     end
@@ -951,12 +975,10 @@ module Writexlsx
       attributes << ['sz', font[:_size]]      if ptrue?(font[:_size])
       attributes << ['b',  font[:_bold]]      if font[:_bold]
       attributes << ['i',  font[:_italic]]    if font[:_italic]
-      attributes << ['u',  'sng']             if font[:_underline]
+      attributes << %w[u sng]             if font[:_underline]
 
       # Turn off baseline when testing fonts that don't have it.
-      if font[:_baseline] != -1
-        attributes << ['baseline', font[:_baseline]]
-      end
+      attributes << ['baseline', font[:_baseline]] if font[:_baseline] != -1
       attributes
     end
 
@@ -964,7 +986,7 @@ module Writexlsx
     # Write the <a:endParaRPr> element.
     #
     def write_a_end_para_rpr # :nodoc:
-      @writer.empty_tag('a:endParaRPr', [ ['lang', 'en-US'] ])
+      @writer.empty_tag('a:endParaRPr', [%w[lang en-US]])
     end
   end