caxlsx 3.4.1 → 4.1.0

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
@@ -20,16 +22,23 @@ module Axlsx
     end
 
     # @see color
-    def color=(v) DataTypeValidator.validate "GradientStop.color", Color, v; @color = v end
+    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,27 @@ 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
@@ -47,17 +49,28 @@ module Axlsx
     attr_reader :patternType
 
     # @see fgColor
-    def fgColor=(v) DataTypeValidator.validate "PatternFill.fgColor", Color, v; @fgColor = v end
+    def fgColor=(v)
+      DataTypeValidator.validate "PatternFill.fgColor", Color, v
+      @fgColor = v
+    end
+
     # @see bgColor
-    def bgColor=(v) DataTypeValidator.validate "PatternFill.bgColor", Color, v; @bgColor = v end
+    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,25 +327,62 @@ 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
 
     # parses add_style options for fills. If the options hash contains :type => :dxf we return a Fill object. If not, we return the index of the fill after being added to the fills collection.
-    # @note noop if :bg_color is not specified in options
-    # @option options [String] bg_color The rgb color to apply to the fill
+    # @note noop unless at least one of the documented attributes is specified in options
+    # @option options [String] bg_color The rgb color to apply to the fill. An alias for pattern_bg_color if you need only a solid background
+    # @option options [String] pattern_type The fill pattern to apply to the fill
+    # @option options [String] pattern_bg_color The rgb color to apply to the fill as the first color
+    # @option options [String] pattern_fg_color The rgb color to apply to the fill as the second color
     # @return [Fill|Integer]
     def parse_fill_options(options = {})
-      return unless options[:bg_color]
+      return unless options[:bg_color] || options[:pattern_type] || options[:pattern_bg_color] || options[:pattern_fg_color]
 
-      color = Color.new(:rgb => options[:bg_color])
+      pattern_type = options[:pattern_type] || :solid
       dxf = options[:type] == :dxf
-      color_key = dxf ? :bgColor : :fgColor
-      pattern = PatternFill.new(:patternType => :solid, color_key => color)
+
+      pattern_options = {
+        patternType: pattern_type
+      }
+
+      if options[:pattern_bg_color] && options[:bg_color]
+        warn 'Both `bg_color` and `pattern_bg_color` got defined. To get a solid background without defining it in `patter_type`, use only `bg_color`, otherwise use only `pattern_bg_color` to avoid confusion.'
+      end
+
+      bg_color = options[:pattern_bg_color] || options[:bg_color]
+      fg_color = options[:pattern_fg_color]
+
+      # Both bgColor and fgColor happens to configure the background of the cell.
+      # One of them sets the "background" of the cell, while the other one is
+      # responsibe for the "pattern" of the cell. When you pick "solid" pattern for
+      # a normal xf style, then it's a rectangle covering all bgColor with fgColor,
+      # which means we need to to set the given background color to fgColor as well.
+      # For some reason I wasn't able find, it works the opposite for dxf styles
+      # (differential formatting records), so to get the expected color, we need
+      # to put it into bgColor. We only need these cross-assignments when using
+      # "solid" pattern and the user provided only one color to get the least
+      # amount of surprise
+
+      if bg_color
+        pattern_options[:bgColor] = Color.new(rgb: bg_color)
+      elsif pattern_type == :solid && fg_color
+        pattern_options[:bgColor] = Color.new(rgb: fg_color)
+      end
+
+      if fg_color
+        pattern_options[:fgColor] = Color.new(rgb: fg_color)
+      elsif pattern_type == :solid && bg_color
+        pattern_options[:fgColor] = Color.new(rgb: bg_color)
+      end
+
+      pattern = PatternFill.new(pattern_options)
       fill = Fill.new(pattern)
       dxf ? fill : fills << fill
     end
@@ -364,13 +401,13 @@ module Axlsx
     #   { :border => { :style => :thick, :color => "FFFF0000", :edges => [:top, :bottom] }
     # @return [Border|Integer]
     def parse_border_options(options = {})
-      if options[:border].nil? && Border::EDGES.all? { |x| options["border_#{x}".to_sym].nil? }
+      if options[:border].nil? && Border::EDGES.all? { |x| options[:"border_#{x}"].nil? }
         return nil
       end
 
       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 +417,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,28 +427,26 @@ 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|
-        val = options["border_#{edge}".to_sym]
+        val = options[:"border_#{edge}"]
 
         if val
           borders_array << val.merge(edges: [edge])
@@ -432,8 +467,8 @@ module Axlsx
           end
         end
 
-        if options["border_#{edge}".to_sym]
-          edge_b_opts = edge_b_opts.merge(options["border_#{edge}".to_sym])
+        if options[:"border_#{edge}"]
+          edge_b_opts = edge_b_opts.merge(options[:"border_#{edge}"])
           skip_edge = false
         end
 
@@ -441,23 +476,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,9 +507,14 @@ 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[:type] == :dxf ? numFmt : (numFmts << numFmt; numFmt.numFmtId)
+        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)
+        if options[:type] == :dxf
+          numFmt
+        else
+          numFmts << numFmt
+          numFmt.numFmtId
+        end
       else
         options[:num_fmt]
       end
@@ -483,8 +523,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 +538,48 @@ 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
+      @dxfs = SimpleTypedList.new(Dxf, "dxfs")
+      @dxfs.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.
@@ -13,7 +15,7 @@ module Axlsx
     def initialize(name, options = {})
       self.name = name
       parse_options options
-      super TableStyleElement
+      super(TableStyleElement)
     end
 
     serializable_attributes :name, :pivot, :table
@@ -31,18 +33,29 @@ 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,27 @@ 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.
@@ -10,7 +12,7 @@ module Axlsx
     def initialize(options = {})
       @defaultTableStyle = options[:defaultTableStyle] || "TableStyleMedium9"
       @defaultPivotStyle = options[:defaultPivotStyle] || "PivotStyleLight16"
-      super TableStyle
+      super(TableStyle)
     end
 
     serializable_attributes :defaultTableStyle, :defaultPivotStyle
@@ -24,16 +26,23 @@ 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>'