caxlsx 3.3.0 → 4.0.0

data/lib/axlsx/stylesheet/styles.rb

@@ -1,24 +1,25 @@
-# encoding: UTF-8
+# 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'
-
-  #The Styles class manages worksheet styles
+  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.
   # All portions of the stylesheet are implemented here exception colors, which specify legacy and modified pallete colors, and exLst, whic is used as a future feature data storage area.
   # @see  Office Open XML Part 1 18.8.11 for gory details on how this stuff gets put together
@@ -109,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
 
@@ -137,7 +138,7 @@ module Axlsx
     # @option options [Integer] family The font family to use.
     # @option options [String] font_name The name of the font to use
     # @option options [Integer] num_fmt The number format to apply
-    # @option options [String] format_code The formatting to apply. 
+    # @option options [String] format_code The formatting to apply.
     # @option options [Integer|Hash] border The border style to use.
     #   borders support style, color and edges options @see parse_border_options
     # @option options [String] bg_color The background color to apply to the cell
@@ -225,22 +226,26 @@ module Axlsx
     #
     # An index for cell styles where keys are styles codes as per Axlsx::Style and values are Cell#raw_style
     # The reason for the backward key/value ordering is that style lookup must be most efficient, while `add_style` can be less efficient
-    def add_style(options={})
+    def add_style(options = {})
       # Default to :xf
       options[:type] ||= :xf
 
-      raise ArgumentError, "Type must be one of [:xf, :dxf]" unless [:xf, :dxf].include?(options[:type] )
+      raise ArgumentError, "Type must be one of [:xf, :dxf]" unless [:xf, :dxf].include?(options[:type])
 
-      if options[:border].is_a?(Hash) && options[:border][:edges] == :all
-        options[:border][:edges] = Axlsx::Border::EDGES
+      if options[:border].is_a?(Hash)
+        if options[:border][:edges] == :all
+          options[:border][:edges] = Axlsx::Border::EDGES
+        elsif options[:border][:edges]
+          options[:border][:edges] = options[:border][:edges].map(&:to_sym) ### normalize for style caching
+        end
       end
 
       if options[:type] == :xf
         # Check to see if style in cache already
-        
-        font_defaults = {name: @fonts.first.name, sz: @fonts.first.sz, family: @fonts.first.family} 
 
-        raw_style = {type: :xf}.merge(font_defaults).merge(options)
+        font_defaults = { name: @fonts.first.name, sz: @fonts.first.sz, family: @fonts.first.family }
+
+        raw_style = { type: :xf }.merge(font_defaults).merge(options)
 
         if raw_style[:format_code]
           raw_style.delete(:num_fmt)
@@ -260,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)
@@ -273,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
 
@@ -287,8 +290,9 @@ module Axlsx
     # @option options [Boolean] hide boolean value defining cell protection attribute for hiding.
     # @option options [Boolean] locked boolean value defining cell protection attribute for locking.
     # @return [CellProtection]
-    def parse_protection_options(options={})
+    def parse_protection_options(options = {})
       return if (options.keys & [:hidden, :locked]).empty?
+
       CellProtection.new(options)
     end
 
@@ -297,8 +301,9 @@ module Axlsx
     # @option options [Hash] alignment A hash of options to prive the CellAlignment intializer
     # @return [CellAlignment]
     # @see CellAlignment
-    def parse_alignment_options(options={})
+    def parse_alignment_options(options = {})
       return unless options[:alignment]
+
       CellAlignment.new options[:alignment]
     end
 
@@ -317,14 +322,15 @@ module Axlsx
     # @option options [Integer] family The font family to use.
     # @option options [String] font_name The name of the font to use
     # @return [Font|Integer]
-    def parse_font_options(options={})
+    def parse_font_options(options = {})
       return if (options.keys & [:fg_color, :sz, :b, :i, :u, :strike, :outline, :shadow, :charset, :family, :font_name]).empty?
+
       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
@@ -333,37 +339,38 @@ module Axlsx
     # @note noop if :bg_color is not specified in options
     # @option options [String] bg_color The rgb color to apply to the fill
     # @return [Fill|Integer]
-    def parse_fill_options(options={})
+    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)
+      pattern = PatternFill.new(:patternType => :solid, color_key => color)
       fill = Fill.new(pattern)
       dxf ? fill : fills << fill
     end
 
     # parses Style#add_style options for borders.
     # @note noop if :border is not specified in options
-    # @option options [Hash|Integer] A border style definition hash or the index of an existing border. 
-    # Border style definition hashes must include :style and :color key-value entries and 
-    # may include an :edges entry that references an array of symbols identifying which border edges 
+    # @option options [Hash|Integer] A border style definition hash or the index of an existing border.
+    # Border style definition hashes must include :style and :color key-value entries and
+    # may include an :edges entry that references an array of symbols identifying which border edges
     # you wish to apply the style or any other valid Border initializer options.
     # If the :edges entity is not provided the style is applied to all edges of cells that reference this style.
-    # Also available :border_top, :border_right, :border_bottom and :border_left options with :style and/or :color 
+    # Also available :border_top, :border_right, :border_bottom and :border_left options with :style and/or :color
     # key-value entries, which override :border values.
     # @example
     #   #apply a thick red border to the top and bottom
     #   { :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? }
+    def parse_border_options(options = {})
+      if options[:border].nil? && Border::EDGES.all? { |x| options["border_#{x}".to_sym].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
@@ -373,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
       }
 
@@ -383,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|
@@ -434,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
 
@@ -458,15 +463,15 @@ module Axlsx
     # noop if neither :format_code or :num_format options are set.
     # @option options [Hash] A hash describing the :format_code and/or :num_fmt integer for the style.
     # @return [NumFmt|Integer]
-    def parse_num_fmt_options(options={})
+    def parse_num_fmt_options(options = {})
       return if (options.keys & [:format_code, :num_fmt]).empty?
 
-      #When the user provides format_code - we always need to create a new numFmt object
-      #When the type is :dxf we always need to create a new numFmt object
+      # When the user provides format_code - we always need to create a new numFmt object
+      # 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)
+        # If this is a standard xf we pull from numFmts the highest current and increment for num_fmt
+        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]
@@ -476,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?
@@ -486,50 +491,51 @@ module Axlsx
     end
 
     private
+
     # Creates the default set of styles the exel requires to be valid as well as setting up the
     # 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,9 +1,9 @@
-# encoding: UTF-8
+# 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.
   class TableStyle < SimpleTypedList
-
     include Axlsx::OptionsParser
     include Axlsx::SerializedAttributes
 
@@ -12,7 +12,7 @@ module Axlsx
     # @param [String] name
     # @option options [Boolean] pivot
     # @option options [Boolean] table
-    def initialize(name, options={})
+    def initialize(name, options = {})
       self.name = name
       parse_options options
       super TableStyleElement
@@ -33,22 +33,21 @@ 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>'
     end
-
   end
 end

data/lib/axlsx/stylesheet/table_style_element.rb

@@ -1,9 +1,9 @@
-# encoding: UTF-8
+# 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.
   class TableStyleElement
-
     include Axlsx::OptionsParser
     include Axlsx::SerializedAttributes
 
@@ -11,7 +11,7 @@ module Axlsx
     # @option options [Symbol] type
     # @option options [Integer] size
     # @option options [Integer] dxfId
-    def initialize(options={})
+    def initialize(options = {})
       parse_options options
     end
 
@@ -58,20 +58,19 @@ 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
 end

data/lib/axlsx/stylesheet/table_styles.rb

@@ -1,15 +1,15 @@
-# encoding: UTF-8
+# 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.
   class TableStyles < SimpleTypedList
-
     include Axlsx::SerializedAttributes
 
     # Creates a new TableStyles object that is a container for TableStyle objects
     # @option options [String] defaultTableStyle
     # @option options [String] defaultPivotStyle
-    def initialize(options={})
+    def initialize(options = {})
       @defaultTableStyle = options[:defaultTableStyle] || "TableStyleMedium9"
       @defaultPivotStyle = options[:defaultPivotStyle] || "PivotStyleLight16"
       super TableStyle
@@ -25,22 +25,20 @@ module Axlsx
     # @return [String]
     attr_reader :defaultPivotStyle
 
-   # @see defaultTableStyle
-    def defaultTableStyle=(v) Axlsx::validate_string(v); @defaultTableStyle = v; end
+    # @see defaultTableStyle
+    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>'
     end
-
   end
-
 end

data/lib/axlsx/stylesheet/xf.rb

@@ -1,9 +1,10 @@
-# encoding: UTF-8
+# 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
   class Xf
-    #does not support extList (ExtensionList)
+    # does not support extList (ExtensionList)
 
     include Axlsx::SerializedAttributes
     include Axlsx::OptionsParser
@@ -23,7 +24,7 @@ module Axlsx
     # @option options [Boolean] applyProtection
     # @option options [CellAlignment] alignment
     # @option options [CellProtection] protection
-    def initialize(options={})
+    def initialize(options = {})
       parse_options options
     end
 
@@ -93,55 +94,53 @@ module Axlsx
     # @return [Boolean]
     attr_reader :applyProtection
 
-      # @see Xf#alignment
+    # @see Xf#alignment
     def alignment=(v) DataTypeValidator.validate "Xf.alignment", CellAlignment, v; @alignment = v end
 
     # @see protection
     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
 end