caxlsx 3.4.0 → 4.0.0

data/lib/axlsx/stylesheet/font.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Axlsx
   # The Font class details a font instance for use in styling cells.
   # @note The recommended way to manage fonts, and other styles is Styles#add_style
@@ -110,46 +112,46 @@ module Axlsx
     attr_reader :sz
 
     # @see name
-    def name=(v) Axlsx::validate_string v; @name = v end
+    def name=(v) Axlsx.validate_string v; @name = v end
     # @see charset
-    def charset=(v) Axlsx::validate_unsigned_int v; @charset = v end
+    def charset=(v) Axlsx.validate_unsigned_int v; @charset = v end
     # @see family
-    def family=(v) Axlsx::validate_unsigned_int v; @family = v end
+    def family=(v) Axlsx.validate_unsigned_int v; @family = v end
     # @see b
-    def b=(v) Axlsx::validate_boolean v; @b = v end
+    def b=(v) Axlsx.validate_boolean v; @b = v end
     # @see i
-    def i=(v) Axlsx::validate_boolean v; @i = v end
+    def i=(v) Axlsx.validate_boolean v; @i = v end
 
     # @see u
     def u=(v)
-      v = :single if (v == true || v == 1 || v == :true || v == 'true')
-      v = :none if (v == false || v == 0 || v == :false || v == 'false')
-      Axlsx::validate_cell_u v
+      v = :single if v == true || v == 1 || v == :true || v == 'true'
+      v = :none if v == false || v == 0 || v == :false || v == 'false'
+      Axlsx.validate_cell_u v
       @u = v
     end
 
     # @see strike
-    def strike=(v) Axlsx::validate_boolean v; @strike = v end
+    def strike=(v) Axlsx.validate_boolean v; @strike = v end
     # @see outline
-    def outline=(v) Axlsx::validate_boolean v; @outline = v end
+    def outline=(v) Axlsx.validate_boolean v; @outline = v end
     # @see shadow
-    def shadow=(v) Axlsx::validate_boolean v; @shadow = v end
+    def shadow=(v) Axlsx.validate_boolean v; @shadow = v end
     # @see condense
-    def condense=(v) Axlsx::validate_boolean v; @condense = v end
+    def condense=(v) Axlsx.validate_boolean v; @condense = v end
     # @see extend
-    def extend=(v) Axlsx::validate_boolean v; @extend = v end
+    def extend=(v) Axlsx.validate_boolean v; @extend = v end
     # @see color
     def color=(v) DataTypeValidator.validate "Font.color", Color, v; @color = v end
     # @see sz
-    def sz=(v) Axlsx::validate_unsigned_int v; @sz = v end
+    def sz=(v) Axlsx.validate_unsigned_int v; @sz = v end
 
     # Serializes the object
     # @param [String] str
     # @return [String]
-    def to_xml_string(str = '')
+    def to_xml_string(str = +'')
       str << '<font>'
       Axlsx.instance_values_for(self).each do |k, v|
-        v.is_a?(Color) ? v.to_xml_string(str) : (str << ('<' << k.to_s << ' val="' << Axlsx.booleanize(v).to_s << '"/>'))
+        v.is_a?(Color) ? v.to_xml_string(str) : (str << '<' << k.to_s << ' val="' << Axlsx.booleanize(v).to_s << '"/>')
       end
       str << '</font>'
     end

data/lib/axlsx/stylesheet/gradient_fill.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Axlsx
   # A GradientFill defines the color and positioning for gradiant cell fill.
   # @see Open Office XML Part 1 §18.8.24
@@ -53,10 +55,10 @@ module Axlsx
     attr_reader :stop
 
     # @see type
-    def type=(v) Axlsx::validate_gradient_type v; @type = v end
+    def type=(v) Axlsx.validate_gradient_type v; @type = v end
 
     # @see degree
-    def degree=(v) Axlsx::validate_float v; @degree = v end
+    def degree=(v) Axlsx.validate_float v; @degree = v end
 
     # @see left
     def left=(v)
@@ -84,13 +86,13 @@ module Axlsx
 
     # validates that the value provided is between 0.0 and 1.0
     def validate_format_percentage(name, value)
-      DataTypeValidator.validate name, Float, value, lambda { |arg| arg >= 0.0 && arg <= 1.0 }
+      DataTypeValidator.validate name, Float, value, ->(arg) { arg >= 0.0 && arg <= 1.0 }
     end
 
     # Serializes the object
     # @param [String] str
     # @return [String]
-    def to_xml_string(str = '')
+    def to_xml_string(str = +'')
       str << '<gradientFill '
       serialized_attributes str
       str << '>'

data/lib/axlsx/stylesheet/gradient_stop.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Axlsx
   # The GradientStop object represents a color point in a gradient.
   # @see Open Office XML Part 1 §18.8.24
@@ -22,14 +24,14 @@ module Axlsx
     # @see color
     def color=(v) DataTypeValidator.validate "GradientStop.color", Color, v; @color = v end
     # @see position
-    def position=(v) DataTypeValidator.validate "GradientStop.position", Float, v, lambda { |arg| arg >= 0 && arg <= 1 }; @position = v end
+    def position=(v) DataTypeValidator.validate "GradientStop.position", Float, v, ->(arg) { arg >= 0 && arg <= 1 }; @position = v end
 
     # Serializes the object
     # @param [String] str
     # @return [String]
-    def to_xml_string(str = '')
-      str << ('<stop position="' << position.to_s << '">')
-      self.color.to_xml_string(str)
+    def to_xml_string(str = +'')
+      str << '<stop position="' << position.to_s << '">'
+      color.to_xml_string(str)
       str << '</stop>'
     end
   end

data/lib/axlsx/stylesheet/num_fmt.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Axlsx
   # A NumFmt object defines an identifier and formatting code for data in cells.
   # @note The recommended way to manage styles is Styles#add_style
@@ -18,7 +20,7 @@ module Axlsx
     serializable_attributes :formatCode, :numFmtId
 
     # @return [String] The formatting to use for this number format.
-    # @see http://support.microsoft.com/kb/264372
+    # @see https://support.microsoft.com/kb/264372
     attr_reader :formatCode
 
     # @return [Integer] An unsigned integer referencing a standard or custom number format.
@@ -59,25 +61,21 @@ module Axlsx
     attr_reader :numFmtId
 
     # @see numFmtId
-    def numFmtId=(v) Axlsx::validate_unsigned_int v; @numFmtId = v end
+    def numFmtId=(v) Axlsx.validate_unsigned_int v; @numFmtId = v end
 
     # @see formatCode
-    def formatCode=(v) Axlsx::validate_string v; @formatCode = v end
+    def formatCode=(v) Axlsx.validate_string v; @formatCode = v end
 
     # Serializes the object
     # @param [String] str
     # @return [String]
-    def to_xml_string(str = '')
+    def to_xml_string(str = +'')
       serialized_tag('numFmt', str)
     end
 
     # Override to avoid removing underscores
-    def serialized_attributes(str = '', additional_attributes = {})
-      attributes = declared_attributes.merge! additional_attributes
-      attributes.each do |key, value|
-        str << "#{Axlsx.camel(key, false)}=\"#{Axlsx.booleanize(value)}\" "
-      end
-      str
+    def serialized_attributes(str = +'', additional_attributes = {})
+      super(str, additional_attributes, false)
     end
   end
 end

data/lib/axlsx/stylesheet/pattern_fill.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Axlsx
   # A PatternFill is the pattern and solid fill styling for a cell.
   # @note The recommended way to manage styles is with Styles#add_style
@@ -51,13 +53,13 @@ module Axlsx
     # @see bgColor
     def bgColor=(v) DataTypeValidator.validate "PatternFill.bgColor", Color, v; @bgColor = v end
     # @see patternType
-    def patternType=(v) Axlsx::validate_pattern_type v; @patternType = v end
+    def patternType=(v) Axlsx.validate_pattern_type v; @patternType = v end
 
     # Serializes the object
     # @param [String] str
     # @return [String]
-    def to_xml_string(str = '')
-      str << ('<patternFill patternType="' << patternType.to_s << '">')
+    def to_xml_string(str = +'')
+      str << '<patternFill patternType="' << patternType.to_s << '">'
       if fgColor.is_a?(Color)
         fgColor.to_xml_string str, "fgColor"
       end

data/lib/axlsx/stylesheet/styles.rb

@@ -1,21 +1,23 @@
+# frozen_string_literal: true
+
 module Axlsx
-  require 'axlsx/stylesheet/border.rb'
-  require 'axlsx/stylesheet/border_pr.rb'
-  require 'axlsx/stylesheet/cell_alignment.rb'
-  require 'axlsx/stylesheet/cell_style.rb'
-  require 'axlsx/stylesheet/color.rb'
-  require 'axlsx/stylesheet/fill.rb'
-  require 'axlsx/stylesheet/font.rb'
-  require 'axlsx/stylesheet/gradient_fill.rb'
-  require 'axlsx/stylesheet/gradient_stop.rb'
-  require 'axlsx/stylesheet/num_fmt.rb'
-  require 'axlsx/stylesheet/pattern_fill.rb'
-  require 'axlsx/stylesheet/table_style.rb'
-  require 'axlsx/stylesheet/table_styles.rb'
-  require 'axlsx/stylesheet/table_style_element.rb'
-  require 'axlsx/stylesheet/dxf.rb'
-  require 'axlsx/stylesheet/xf.rb'
-  require 'axlsx/stylesheet/cell_protection.rb'
+  require 'axlsx/stylesheet/border'
+  require 'axlsx/stylesheet/border_pr'
+  require 'axlsx/stylesheet/cell_alignment'
+  require 'axlsx/stylesheet/cell_style'
+  require 'axlsx/stylesheet/color'
+  require 'axlsx/stylesheet/fill'
+  require 'axlsx/stylesheet/font'
+  require 'axlsx/stylesheet/gradient_fill'
+  require 'axlsx/stylesheet/gradient_stop'
+  require 'axlsx/stylesheet/num_fmt'
+  require 'axlsx/stylesheet/pattern_fill'
+  require 'axlsx/stylesheet/table_style'
+  require 'axlsx/stylesheet/table_styles'
+  require 'axlsx/stylesheet/table_style_element'
+  require 'axlsx/stylesheet/dxf'
+  require 'axlsx/stylesheet/xf'
+  require 'axlsx/stylesheet/cell_protection'
 
   # The Styles class manages worksheet styles
   # In addition to creating the require style objects for a valid xlsx package, this class provides the key mechanism for adding styles to your workbook, and safely applying them to the cells of your worksheet.
@@ -108,14 +110,14 @@ module Axlsx
     # @see Styles#add_style
     attr_reader :dxfs
 
-    # The collection of table styles that will be available to the user in the excel UI
+    # The collection of table styles that will be available to the user in the Excel UI
     # @return [SimpleTypedList]
     # @note The recommended way to manage styles is with add_style
     # @see Styles#add_style
     attr_reader :tableStyles
 
     # Creates a new Styles object and prepopulates it with the requires objects to generate a valid package style part.
-    def initialize()
+    def initialize
       load_default_styles
     end
 
@@ -263,12 +265,12 @@ module Axlsx
       alignment = parse_alignment_options options
       protection = parse_protection_options options
 
-      case options[:type]
-      when :dxf
-        style = Dxf.new :fill => fill, :font => font, :numFmt => numFmt, :border => border, :alignment => alignment, :protection => protection
-      else
-        style = Xf.new :fillId => fill || 0, :fontId => font || 0, :numFmtId => numFmt || 0, :borderId => border || 0, :alignment => alignment, :protection => protection, :applyFill => !fill.nil?, :applyFont => !font.nil?, :applyNumberFormat => !numFmt.nil?, :applyBorder => !border.nil?, :applyAlignment => !alignment.nil?, :applyProtection => !protection.nil?
-      end
+      style = case options[:type]
+              when :dxf
+                Dxf.new fill: fill, font: font, numFmt: numFmt, border: border, alignment: alignment, protection: protection
+              else
+                Xf.new fillId: fill || 0, fontId: font || 0, numFmtId: numFmt || 0, borderId: border || 0, alignment: alignment, protection: protection, applyFill: !fill.nil?, applyFont: !font.nil?, applyNumberFormat: !numFmt.nil?, applyBorder: !border.nil?, applyAlignment: !alignment.nil?, applyProtection: !protection.nil?
+              end
 
       if options[:type] == :xf
         xf_index = (cellXfs << style)
@@ -276,11 +278,9 @@ module Axlsx
         # Add styles to style_index cache for re-use
         style_index[xf_index] = raw_style
 
-        return xf_index
+        xf_index
       else
-        dxf_index = (dxfs << style)
-
-        return dxf_index
+        dxfs << style
       end
     end
 
@@ -327,10 +327,10 @@ module Axlsx
 
       Axlsx.instance_values_for(fonts.first).each do |key, value|
         # Thanks for that 1.8.7 - cant do a simple merge...
-        options[key.to_sym] = value unless options.keys.include?(key.to_sym)
+        options[key.to_sym] = value unless options.key?(key.to_sym)
       end
       font = Font.new(options)
-      font.color = Color.new(:rgb => options[:fg_color]) if options[:fg_color]
+      font.color = Color.new(rgb: options[:fg_color]) if options[:fg_color]
       font.name = options[:font_name] if options[:font_name]
       options[:type] == :dxf ? font : fonts << font
     end
@@ -342,7 +342,7 @@ module Axlsx
     def parse_fill_options(options = {})
       return unless options[:bg_color]
 
-      color = Color.new(:rgb => options[:bg_color])
+      color = Color.new(rgb: options[:bg_color])
       dxf = options[:type] == :dxf
       color_key = dxf ? :bgColor : :fgColor
       pattern = PatternFill.new(:patternType => :solid, color_key => color)
@@ -370,7 +370,7 @@ module Axlsx
 
       if options[:border].is_a?(Integer)
         if options[:border] >= borders.size
-          raise ArgumentError, (ERR_INVALID_BORDER_ID % options[:border])
+          raise ArgumentError, format(ERR_INVALID_BORDER_ID, options[:border])
         end
 
         if options[:type] == :dxf
@@ -380,9 +380,9 @@ module Axlsx
         end
       end
 
-      validate_border_hash = ->(val) {
-        if !(val.keys.include?(:style) && val.keys.include?(:color))
-          raise ArgumentError, (ERR_INVALID_BORDER_OPTIONS % options[:border])
+      validate_border_hash = lambda { |val|
+        unless val.key?(:style) && val.key?(:color)
+          raise ArgumentError, format(ERR_INVALID_BORDER_OPTIONS, options[:border])
         end
       }
 
@@ -390,24 +390,22 @@ module Axlsx
 
       if options[:border].nil?
         base_border_opts = {}
-      else
-        if options[:border].is_a?(Array)
-          borders_array += options[:border]
+      elsif options[:border].is_a?(Array)
+        borders_array += options[:border]
 
-          base_border_opts = {}
+        base_border_opts = {}
 
-          options[:border].each do |b_opts|
-            if b_opts[:edges].nil?
-              base_border_opts = base_border_opts.merge(b_opts)
-            end
+        options[:border].each do |b_opts|
+          if b_opts[:edges].nil?
+            base_border_opts = base_border_opts.merge(b_opts)
           end
-        else
-          borders_array << options[:border]
+        end
+      else
+        borders_array << options[:border]
 
-          base_border_opts = options[:border]
+        base_border_opts = options[:border]
 
-          validate_border_hash.call(base_border_opts)
-        end
+        validate_border_hash.call(base_border_opts)
       end
 
       Border::EDGES.each do |edge|
@@ -441,23 +439,23 @@ module Axlsx
           next
         end
 
-        if !edge_b_opts.empty?
+        unless edge_b_opts.empty?
           if base_border_opts.empty?
             validate_border_hash.call(edge_b_opts)
           end
 
           border.prs << BorderPr.new({
-            :name => edge,
-            :style => edge_b_opts[:style],
-            :color => Color.new(:rgb => edge_b_opts[:color])
+            name: edge,
+            style: edge_b_opts[:style],
+            color: Color.new(rgb: edge_b_opts[:color])
           })
         end
       end
 
       if options[:type] == :dxf
-        return border
+        border
       else
-        return borders << border
+        borders << border
       end
     end
 
@@ -472,8 +470,8 @@ module Axlsx
       # When the type is :dxf we always need to create a new numFmt object
       if options[:format_code] || options[:type] == :dxf
         # If this is a standard xf we pull from numFmts the highest current and increment for num_fmt
-        options[:num_fmt] ||= (@numFmts.map { |num_fmt| num_fmt.numFmtId }.max + 1) if options[:type] != :dxf
-        numFmt = NumFmt.new(:numFmtId => options[:num_fmt] || 0, :formatCode => options[:format_code].to_s)
+        options[:num_fmt] ||= (@numFmts.map(&:numFmtId).max + 1) if options[:type] != :dxf
+        numFmt = NumFmt.new(numFmtId: options[:num_fmt] || 0, formatCode: options[:format_code].to_s)
         options[:type] == :dxf ? numFmt : (numFmts << numFmt; numFmt.numFmtId)
       else
         options[:num_fmt]
@@ -483,8 +481,8 @@ module Axlsx
     # Serializes the object
     # @param [String] str
     # @return [String]
-    def to_xml_string(str = '')
-      str << ('<styleSheet xmlns="' << XML_NS << '">')
+    def to_xml_string(str = +'')
+      str << '<styleSheet xmlns="' << XML_NS << '">'
       instance_vals = Axlsx.instance_values_for(self)
       [:numFmts, :fonts, :fills, :borders, :cellStyleXfs, :cellXfs, :cellStyles, :dxfs, :tableStyles].each do |key|
         instance_vals[key.to_s].to_xml_string(str) unless instance_vals[key.to_s].nil?
@@ -498,46 +496,46 @@ module Axlsx
     # Axlsx::STYLE_THIN_BORDER
     def load_default_styles
       @numFmts = SimpleTypedList.new NumFmt, 'numFmts'
-      @numFmts << NumFmt.new(:numFmtId => NUM_FMT_YYYYMMDD, :formatCode => "yyyy/mm/dd")
-      @numFmts << NumFmt.new(:numFmtId => NUM_FMT_YYYYMMDDHHMMSS, :formatCode => "yyyy/mm/dd hh:mm:ss")
+      @numFmts << NumFmt.new(numFmtId: NUM_FMT_YYYYMMDD, formatCode: "yyyy/mm/dd")
+      @numFmts << NumFmt.new(numFmtId: NUM_FMT_YYYYMMDDHHMMSS, formatCode: "yyyy/mm/dd hh:mm:ss")
 
       @numFmts.lock
 
       @fonts = SimpleTypedList.new Font, 'fonts'
-      @fonts << Font.new(:name => "Arial", :sz => 11, :family => 1)
+      @fonts << Font.new(name: "Arial", sz: 11, family: 1)
       @fonts.lock
 
       @fills = SimpleTypedList.new Fill, 'fills'
-      @fills << Fill.new(Axlsx::PatternFill.new(:patternType => :none))
-      @fills << Fill.new(Axlsx::PatternFill.new(:patternType => :gray125))
+      @fills << Fill.new(Axlsx::PatternFill.new(patternType: :none))
+      @fills << Fill.new(Axlsx::PatternFill.new(patternType: :gray125))
       @fills.lock
 
       @borders = SimpleTypedList.new Border, 'borders'
       @borders << Border.new
       black_border = Border.new
       [:left, :right, :top, :bottom].each do |item|
-        black_border.prs << BorderPr.new(:name => item, :style => :thin, :color => Color.new(:rgb => "FF000000"))
+        black_border.prs << BorderPr.new(name: item, style: :thin, color: Color.new(rgb: "FF000000"))
       end
       @borders << black_border
       @borders.lock
 
       @cellStyleXfs = SimpleTypedList.new Xf, "cellStyleXfs"
-      @cellStyleXfs << Xf.new(:borderId => 0, :numFmtId => 0, :fontId => 0, :fillId => 0)
+      @cellStyleXfs << Xf.new(borderId: 0, numFmtId: 0, fontId: 0, fillId: 0)
       @cellStyleXfs.lock
 
       @cellStyles = SimpleTypedList.new CellStyle, 'cellStyles'
-      @cellStyles << CellStyle.new(:name => "Normal", :builtinId => 0, :xfId => 0)
+      @cellStyles << CellStyle.new(name: "Normal", builtinId: 0, xfId: 0)
       @cellStyles.lock
 
       @cellXfs = SimpleTypedList.new Xf, "cellXfs"
-      @cellXfs << Xf.new(:borderId => 0, :xfId => 0, :numFmtId => 0, :fontId => 0, :fillId => 0)
-      @cellXfs << Xf.new(:borderId => 1, :xfId => 0, :numFmtId => 0, :fontId => 0, :fillId => 0)
+      @cellXfs << Xf.new(borderId: 0, xfId: 0, numFmtId: 0, fontId: 0, fillId: 0)
+      @cellXfs << Xf.new(borderId: 1, xfId: 0, numFmtId: 0, fontId: 0, fillId: 0)
       # default date formatting
-      @cellXfs << Xf.new(:borderId => 0, :xfId => 0, :numFmtId => 14, :fontId => 0, :fillId => 0, :applyNumberFormat => 1)
+      @cellXfs << Xf.new(borderId: 0, xfId: 0, numFmtId: 14, fontId: 0, fillId: 0, applyNumberFormat: 1)
       @cellXfs.lock
 
       @dxfs = SimpleTypedList.new(Dxf, "dxfs"); @dxfs.lock
-      @tableStyles = TableStyles.new(:defaultTableStyle => "TableStyleMedium9", :defaultPivotStyle => "PivotStyleLight16"); @tableStyles.lock
+      @tableStyles = TableStyles.new(defaultTableStyle: "TableStyleMedium9", defaultPivotStyle: "PivotStyleLight16"); @tableStyles.lock
     end
   end
 end

data/lib/axlsx/stylesheet/table_style.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Axlsx
   # A single table style definition and is a collection for tableStyleElements
   # @note Table are not supported in this version and only the defaults required for a valid workbook are created.
@@ -31,18 +33,18 @@ module Axlsx
     attr_reader :table
 
     # @see name
-    def name=(v) Axlsx::validate_string v; @name = v end
+    def name=(v) Axlsx.validate_string v; @name = v end
     # @see pivot
-    def pivot=(v) Axlsx::validate_boolean v; @pivot = v end
+    def pivot=(v) Axlsx.validate_boolean v; @pivot = v end
     # @see table
-    def table=(v) Axlsx::validate_boolean v; @table = v end
+    def table=(v) Axlsx.validate_boolean v; @table = v end
 
     # Serializes the object
     # @param [String] str
     # @return [String]
-    def to_xml_string(str = '')
+    def to_xml_string(str = +'')
       str << '<tableStyle '
-      serialized_attributes str, { :count => self.size }
+      serialized_attributes str, { count: size }
       str << '>'
       each { |table_style_el| table_style_el.to_xml_string(str) }
       str << '</tableStyle>'

data/lib/axlsx/stylesheet/table_style_element.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Axlsx
   # an element of style that belongs to a table style.
   # @note tables and table styles are not supported in this version. This class exists in preparation for that support.
@@ -56,18 +58,18 @@ module Axlsx
     attr_reader :dxfId
 
     # @see type
-    def type=(v) Axlsx::validate_table_element_type v; @type = v end
+    def type=(v) Axlsx.validate_table_element_type v; @type = v end
 
     # @see size
-    def size=(v) Axlsx::validate_unsigned_int v; @size = v end
+    def size=(v) Axlsx.validate_unsigned_int v; @size = v end
 
     # @see dxfId
-    def dxfId=(v) Axlsx::validate_unsigned_int v; @dxfId = v end
+    def dxfId=(v) Axlsx.validate_unsigned_int v; @dxfId = v end
 
     # Serializes the object
     # @param [String] str
     # @return [String]
-    def to_xml_string(str = '')
+    def to_xml_string(str = +'')
       serialized_tag('tableStyleElement', str)
     end
   end

data/lib/axlsx/stylesheet/table_styles.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Axlsx
   # TableStyles represents a collection of style definitions for table styles and pivot table styles.
   # @note Support for custom table styles does not exist in this version. Many of the classes required are defined in preparation for future release. Please do not attempt to add custom table styles.
@@ -24,16 +26,16 @@ module Axlsx
     attr_reader :defaultPivotStyle
 
     # @see defaultTableStyle
-    def defaultTableStyle=(v) Axlsx::validate_string(v); @defaultTableStyle = v; end
+    def defaultTableStyle=(v) Axlsx.validate_string(v); @defaultTableStyle = v; end
     # @see defaultPivotStyle
-    def defaultPivotStyle=(v) Axlsx::validate_string(v); @defaultPivotStyle = v; end
+    def defaultPivotStyle=(v) Axlsx.validate_string(v); @defaultPivotStyle = v; end
 
     # Serializes the object
     # @param [String] str
     # @return [String]
-    def to_xml_string(str = '')
+    def to_xml_string(str = +'')
       str << '<tableStyles '
-      serialized_attributes str, { :count => self.size }
+      serialized_attributes str, { count: size }
       str << '>'
       each { |table_style| table_style.to_xml_string(str) }
       str << '</tableStyles>'

data/lib/axlsx/stylesheet/xf.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Axlsx
   # The Xf class defines a formatting record for use in Styles. The recommended way to manage styles for your workbook is with Styles#add_style
   # @see Styles#add_style
@@ -99,45 +101,45 @@ module Axlsx
     def protection=(v) DataTypeValidator.validate "Xf.protection", CellProtection, v; @protection = v end
 
     # @see numFmtId
-    def numFmtId=(v) Axlsx::validate_unsigned_int v; @numFmtId = v end
+    def numFmtId=(v) Axlsx.validate_unsigned_int v; @numFmtId = v end
 
     # @see fontId
-    def fontId=(v) Axlsx::validate_unsigned_int v; @fontId = v end
+    def fontId=(v) Axlsx.validate_unsigned_int v; @fontId = v end
     # @see fillId
-    def fillId=(v) Axlsx::validate_unsigned_int v; @fillId = v end
+    def fillId=(v) Axlsx.validate_unsigned_int v; @fillId = v end
     # @see borderId
-    def borderId=(v) Axlsx::validate_unsigned_int v; @borderId = v end
+    def borderId=(v) Axlsx.validate_unsigned_int v; @borderId = v end
     # @see xfId
-    def xfId=(v) Axlsx::validate_unsigned_int v; @xfId = v end
+    def xfId=(v) Axlsx.validate_unsigned_int v; @xfId = v end
     # @see quotePrefix
-    def quotePrefix=(v) Axlsx::validate_boolean v; @quotePrefix = v end
+    def quotePrefix=(v) Axlsx.validate_boolean v; @quotePrefix = v end
     # @see pivotButton
-    def pivotButton=(v) Axlsx::validate_boolean v; @pivotButton = v end
+    def pivotButton=(v) Axlsx.validate_boolean v; @pivotButton = v end
     # @see applyNumberFormat
-    def applyNumberFormat=(v) Axlsx::validate_boolean v; @applyNumberFormat = v end
+    def applyNumberFormat=(v) Axlsx.validate_boolean v; @applyNumberFormat = v end
     # @see applyFont
-    def applyFont=(v) Axlsx::validate_boolean v; @applyFont = v end
+    def applyFont=(v) Axlsx.validate_boolean v; @applyFont = v end
     # @see applyFill
-    def applyFill=(v) Axlsx::validate_boolean v; @applyFill = v end
+    def applyFill=(v) Axlsx.validate_boolean v; @applyFill = v end
 
     # @see applyBorder
-    def applyBorder=(v) Axlsx::validate_boolean v; @applyBorder = v end
+    def applyBorder=(v) Axlsx.validate_boolean v; @applyBorder = v end
 
     # @see applyAlignment
-    def applyAlignment=(v) Axlsx::validate_boolean v; @applyAlignment = v end
+    def applyAlignment=(v) Axlsx.validate_boolean v; @applyAlignment = v end
 
     # @see applyProtection
-    def applyProtection=(v) Axlsx::validate_boolean v; @applyProtection = v end
+    def applyProtection=(v) Axlsx.validate_boolean v; @applyProtection = v end
 
     # Serializes the object
     # @param [String] str
     # @return [String]
-    def to_xml_string(str = '')
+    def to_xml_string(str = +'')
       str << '<xf '
       serialized_attributes str
       str << '>'
-      alignment.to_xml_string(str) if self.alignment
-      protection.to_xml_string(str) if self.protection
+      alignment.to_xml_string(str) if alignment
+      protection.to_xml_string(str) if protection
       str << '</xf>'
     end
   end

data/lib/axlsx/util/accessors.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Axlsx
   # This module defines some of the more common validating attribute
   # accessors that we use in Axlsx
@@ -43,7 +45,7 @@ module Axlsx
       end
 
       # Template for defining validated write accessors
-      SETTER = "def %s=(value) Axlsx::%s(value); @%s = value; end".freeze
+      SETTER = "def %s=(value) Axlsx::%s(value); @%s = value; end"
 
       # Creates the reader and writer access methods
       # @param [Array] symbols The names of the attributes to create
@@ -54,7 +56,7 @@ module Axlsx
         symbols.each do |symbol|
           attr_reader symbol
 
-          module_eval(SETTER % [symbol, validator, symbol], __FILE__, __LINE__)
+          module_eval(format(SETTER, symbol, validator, symbol), __FILE__, __LINE__)
         end
       end
     end