caxlsx 3.4.0 → 4.0.0

data/lib/axlsx/package.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Axlsx
   # Package is responsible for managing all the bits and peices that Open Office XML requires to make a valid
   # xlsx document including validation and serialization.
@@ -31,7 +33,7 @@ module Axlsx
     # Shortcut to specify that the workbook should use autowidth
     # @see Workbook#use_autowidth
     def use_autowidth=(v)
-      Axlsx::validate_boolean(v);
+      Axlsx.validate_boolean(v)
       workbook.use_autowidth = v
     end
 
@@ -44,7 +46,7 @@ module Axlsx
     # Shortcut to specify that the workbook should use shared strings
     # @see Workbook#use_shared_strings
     def use_shared_strings=(v)
-      Axlsx::validate_boolean(v);
+      Axlsx.validate_boolean(v)
       workbook.use_shared_strings = v
     end
 
@@ -99,17 +101,17 @@ module Axlsx
     #   s = p.to_stream()
     #   File.open('example_streamed.xlsx', 'wb') { |f| f.write(s.read) }
     def serialize(output, options = {}, secondary_options = nil)
-      if !workbook.styles_applied
+      unless workbook.styles_applied
         workbook.apply_styles
       end
 
       confirm_valid, zip_command = parse_serialize_options(options, secondary_options)
-      return false unless !confirm_valid || self.validate.empty?
+      return false unless !confirm_valid || validate.empty?
 
       zip_provider = if zip_command
                        ZipCommand.new(zip_command)
                      else
-                       Zip::OutputStream
+                       BufferedZipOutputStream
                      end
       Relationship.initialize_ids_cache
       zip_provider.open(output) do |zip|
@@ -124,15 +126,16 @@ module Axlsx
     # @param [Boolean] confirm_valid Validate the package prior to serialization.
     # @return [StringIO|Boolean] False if confirm_valid and validation errors exist. rewound string IO if not.
     def to_stream(confirm_valid = false)
-      if !workbook.styles_applied
+      unless workbook.styles_applied
         workbook.apply_styles
       end
 
-      return false unless !confirm_valid || self.validate.empty?
+      return false unless !confirm_valid || validate.empty?
 
       Relationship.initialize_ids_cache
-      zip = write_parts(Zip::OutputStream.new(StringIO.new.binmode, true))
-      stream = zip.close_buffer
+      stream = BufferedZipOutputStream.write_buffer do |zip|
+        write_parts(zip)
+      end
       stream.rewind
       stream
     ensure
@@ -142,7 +145,7 @@ module Axlsx
     # Encrypt the package into a CFB using the password provided
     # This is not ready yet
     def encrypt(file_name, password)
-      return false
+      false
       # moc = MsOffCrypto.new(file_name, password)
       # moc.save
     end
@@ -156,7 +159,7 @@ module Axlsx
     #
     #   If by chance you are able to create a package that does not validate it indicates that the internal
     #   validation is not robust enough and needs to be improved. Please report your errors to the gem author.
-    # @see http://www.ecma-international.org/publications/standards/Ecma-376.htm
+    # @see https://www.ecma-international.org/publications-and-standards/standards/ecma-376/
     # @example
     #  # The following will output any error messages found in serialization.
     #  p = Axlsx::Package.new
@@ -213,57 +216,57 @@ module Axlsx
     # @private
     def parts
       parts = [
-        { :entry => "xl/#{STYLES_PN}", :doc => workbook.styles, :schema => SML_XSD },
-        { :entry => CORE_PN, :doc => @core, :schema => CORE_XSD },
-        { :entry => APP_PN, :doc => @app, :schema => APP_XSD },
-        { :entry => WORKBOOK_RELS_PN, :doc => workbook.relationships, :schema => RELS_XSD },
-        { :entry => WORKBOOK_PN, :doc => workbook, :schema => SML_XSD }
+        { entry: "xl/#{STYLES_PN}", doc: workbook.styles, schema: SML_XSD },
+        { entry: CORE_PN, doc: @core, schema: CORE_XSD },
+        { entry: APP_PN, doc: @app, schema: APP_XSD },
+        { entry: WORKBOOK_RELS_PN, doc: workbook.relationships, schema: RELS_XSD },
+        { entry: WORKBOOK_PN, doc: workbook, schema: SML_XSD }
       ]
 
       workbook.drawings.each do |drawing|
-        parts << { :entry => "xl/#{drawing.rels_pn}", :doc => drawing.relationships, :schema => RELS_XSD }
-        parts << { :entry => "xl/#{drawing.pn}", :doc => drawing, :schema => DRAWING_XSD }
+        parts << { entry: "xl/#{drawing.rels_pn}", doc: drawing.relationships, schema: RELS_XSD }
+        parts << { entry: "xl/#{drawing.pn}", doc: drawing, schema: DRAWING_XSD }
       end
 
       workbook.tables.each do |table|
-        parts << { :entry => "xl/#{table.pn}", :doc => table, :schema => SML_XSD }
+        parts << { entry: "xl/#{table.pn}", doc: table, schema: SML_XSD }
       end
       workbook.pivot_tables.each do |pivot_table|
         cache_definition = pivot_table.cache_definition
-        parts << { :entry => "xl/#{pivot_table.rels_pn}", :doc => pivot_table.relationships, :schema => RELS_XSD }
-        parts << { :entry => "xl/#{pivot_table.pn}", :doc => pivot_table } # , :schema => SML_XSD}
-        parts << { :entry => "xl/#{cache_definition.pn}", :doc => cache_definition } # , :schema => SML_XSD}
+        parts << { entry: "xl/#{pivot_table.rels_pn}", doc: pivot_table.relationships, schema: RELS_XSD }
+        parts << { entry: "xl/#{pivot_table.pn}", doc: pivot_table } # , :schema => SML_XSD}
+        parts << { entry: "xl/#{cache_definition.pn}", doc: cache_definition } # , :schema => SML_XSD}
       end
 
       workbook.comments.each do |comment|
-        if comment.size > 0
-          parts << { :entry => "xl/#{comment.pn}", :doc => comment, :schema => SML_XSD }
-          parts << { :entry => "xl/#{comment.vml_drawing.pn}", :doc => comment.vml_drawing, :schema => nil }
+        unless comment.empty?
+          parts << { entry: "xl/#{comment.pn}", doc: comment, schema: SML_XSD }
+          parts << { entry: "xl/#{comment.vml_drawing.pn}", doc: comment.vml_drawing, schema: nil }
         end
       end
 
       workbook.charts.each do |chart|
-        parts << { :entry => "xl/#{chart.pn}", :doc => chart, :schema => DRAWING_XSD }
+        parts << { entry: "xl/#{chart.pn}", doc: chart, schema: DRAWING_XSD }
       end
 
       workbook.images.each do |image|
-        parts << { :entry => "xl/#{image.pn}", :path => image.image_src } unless image.remote?
+        parts << { entry: "xl/#{image.pn}", path: image.image_src } unless image.remote?
       end
 
       if use_shared_strings
-        parts << { :entry => "xl/#{SHARED_STRINGS_PN}", :doc => workbook.shared_strings, :schema => SML_XSD }
+        parts << { entry: "xl/#{SHARED_STRINGS_PN}", doc: workbook.shared_strings, schema: SML_XSD }
       end
 
       workbook.worksheets.each do |sheet|
-        parts << { :entry => "xl/#{sheet.rels_pn}", :doc => sheet.relationships, :schema => RELS_XSD }
-        parts << { :entry => "xl/#{sheet.pn}", :doc => sheet, :schema => SML_XSD }
+        parts << { entry: "xl/#{sheet.rels_pn}", doc: sheet.relationships, schema: RELS_XSD }
+        parts << { entry: "xl/#{sheet.pn}", doc: sheet, schema: SML_XSD }
       end
 
       # Sort parts for correct MIME detection
       [
-        { :entry => CONTENT_TYPES_PN, :doc => content_types, :schema => CONTENT_TYPES_XSD },
-        { :entry => RELS_PN, :doc => relationships, :schema => RELS_XSD },
-        *(parts.sort_by { |part| part[:entry] }.reverse)
+        { entry: CONTENT_TYPES_PN, doc: content_types, schema: CONTENT_TYPES_XSD },
+        { entry: RELS_PN, doc: relationships, schema: RELS_XSD },
+        *parts.sort_by { |part| part[:entry] }.reverse
       ]
     end
 
@@ -289,56 +292,56 @@ module Axlsx
     def content_types
       c_types = base_content_types
       workbook.drawings.each do |drawing|
-        c_types << Axlsx::Override.new(:PartName => "/xl/#{drawing.pn}",
-                                       :ContentType => DRAWING_CT)
+        c_types << Axlsx::Override.new(PartName: "/xl/#{drawing.pn}",
+                                       ContentType: DRAWING_CT)
       end
 
       workbook.charts.each do |chart|
-        c_types << Axlsx::Override.new(:PartName => "/xl/#{chart.pn}",
-                                       :ContentType => CHART_CT)
+        c_types << Axlsx::Override.new(PartName: "/xl/#{chart.pn}",
+                                       ContentType: CHART_CT)
       end
 
       workbook.tables.each do |table|
-        c_types << Axlsx::Override.new(:PartName => "/xl/#{table.pn}",
-                                       :ContentType => TABLE_CT)
+        c_types << Axlsx::Override.new(PartName: "/xl/#{table.pn}",
+                                       ContentType: TABLE_CT)
       end
 
       workbook.pivot_tables.each do |pivot_table|
-        c_types << Axlsx::Override.new(:PartName => "/xl/#{pivot_table.pn}",
-                                       :ContentType => PIVOT_TABLE_CT)
-        c_types << Axlsx::Override.new(:PartName => "/xl/#{pivot_table.cache_definition.pn}",
-                                       :ContentType => PIVOT_TABLE_CACHE_DEFINITION_CT)
+        c_types << Axlsx::Override.new(PartName: "/xl/#{pivot_table.pn}",
+                                       ContentType: PIVOT_TABLE_CT)
+        c_types << Axlsx::Override.new(PartName: "/xl/#{pivot_table.cache_definition.pn}",
+                                       ContentType: PIVOT_TABLE_CACHE_DEFINITION_CT)
       end
 
       workbook.comments.each do |comment|
-        if comment.size > 0
-          c_types << Axlsx::Override.new(:PartName => "/xl/#{comment.pn}",
-                                         :ContentType => COMMENT_CT)
+        unless comment.empty?
+          c_types << Axlsx::Override.new(PartName: "/xl/#{comment.pn}",
+                                         ContentType: COMMENT_CT)
         end
       end
 
-      if workbook.comments.size > 0
-        c_types << Axlsx::Default.new(:Extension => "vml", :ContentType => VML_DRAWING_CT)
+      unless workbook.comments.empty?
+        c_types << Axlsx::Default.new(Extension: "vml", ContentType: VML_DRAWING_CT)
       end
 
       workbook.worksheets.each do |sheet|
-        c_types << Axlsx::Override.new(:PartName => "/xl/#{sheet.pn}",
-                                       :ContentType => WORKSHEET_CT)
+        c_types << Axlsx::Override.new(PartName: "/xl/#{sheet.pn}",
+                                       ContentType: WORKSHEET_CT)
       end
       exts = workbook.images.map { |image| image.extname.downcase }
       exts.uniq.each do |ext|
-        ct = if ['jpeg', 'jpg'].include?(ext)
+        ct = if JPEG_EXS.include?(ext)
                JPEG_CT
-             elsif ext == 'gif'
+             elsif ext == GIF_EX
                GIF_CT
-             elsif ext == 'png'
+             elsif ext == PNG_EX
                PNG_CT
              end
-        c_types << Axlsx::Default.new(:ContentType => ct, :Extension => ext)
+        c_types << Axlsx::Default.new(ContentType: ct, Extension: ext)
       end
       if use_shared_strings
-        c_types << Axlsx::Override.new(:PartName => "/xl/#{SHARED_STRINGS_PN}",
-                                       :ContentType => SHARED_STRINGS_CT)
+        c_types << Axlsx::Override.new(PartName: "/xl/#{SHARED_STRINGS_PN}",
+                                       ContentType: SHARED_STRINGS_CT)
       end
       c_types
     end
@@ -347,13 +350,13 @@ module Axlsx
     # @return [ContentType]
     # @private
     def base_content_types
-      c_types = ContentType.new()
-      c_types << Default.new(:ContentType => RELS_CT, :Extension => RELS_EX)
-      c_types << Default.new(:Extension => XML_EX, :ContentType => XML_CT)
-      c_types << Override.new(:PartName => "/#{APP_PN}", :ContentType => APP_CT)
-      c_types << Override.new(:PartName => "/#{CORE_PN}", :ContentType => CORE_CT)
-      c_types << Override.new(:PartName => "/xl/#{STYLES_PN}", :ContentType => STYLES_CT)
-      c_types << Axlsx::Override.new(:PartName => "/#{WORKBOOK_PN}", :ContentType => WORKBOOK_CT)
+      c_types = ContentType.new
+      c_types << Default.new(ContentType: RELS_CT, Extension: RELS_EX)
+      c_types << Default.new(Extension: XML_EX, ContentType: XML_CT)
+      c_types << Override.new(PartName: "/#{APP_PN}", ContentType: APP_CT)
+      c_types << Override.new(PartName: "/#{CORE_PN}", ContentType: CORE_CT)
+      c_types << Override.new(PartName: "/xl/#{STYLES_PN}", ContentType: STYLES_CT)
+      c_types << Axlsx::Override.new(PartName: "/#{WORKBOOK_PN}", ContentType: WORKBOOK_CT)
       c_types.lock
       c_types
     end
@@ -376,19 +379,19 @@ module Axlsx
     # @private
     def parse_serialize_options(options, secondary_options)
       if secondary_options
-        warn "[DEPRECATION] Axlsx::Package#serialize with 3 arguments is deprecated. " +
+        warn "[DEPRECATION] Axlsx::Package#serialize with 3 arguments is deprecated. " \
              "Use keyword args instead e.g., package.serialize(output, confirm_valid: false, zip_command: 'zip')"
       end
       if options.is_a?(Hash)
         options.merge!(secondary_options || {})
         invalid_keys = options.keys - [:confirm_valid, :zip_command]
         if invalid_keys.any?
-          raise ArgumentError.new("Invalid keyword arguments: #{invalid_keys}")
+          raise ArgumentError, "Invalid keyword arguments: #{invalid_keys}"
         end
 
         [options.fetch(:confirm_valid, false), options.fetch(:zip_command, nil)]
       else
-        warn "[DEPRECATION] Axlsx::Package#serialize with confirm_valid as a boolean is deprecated. " +
+        warn "[DEPRECATION] Axlsx::Package#serialize with confirm_valid as a boolean is deprecated. " \
              "Use keyword args instead e.g., package.serialize(output, confirm_valid: false)"
         parse_serialize_options((secondary_options || {}).merge(confirm_valid: options), nil)
       end

data/lib/axlsx/rels/relationship.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Axlsx
   # A relationship defines a reference between package parts.
   # @note Packages automatically manage relationships.
@@ -41,7 +43,7 @@ module Axlsx
     end
 
     # The id of the relationship (eg. "rId123"). Most instances get their own unique id.
-    # However, some instances need to share the same id – see {#should_use_same_id_as?}
+    # However, some instances need to share the same id – see {#ids_cache_key}
     # for details.
     # @return [String]
     attr_reader :Id
@@ -90,9 +92,9 @@ module Axlsx
     end
 
     # @see Target
-    def Target=(v) Axlsx::validate_string v; @Target = v end
+    def Target=(v) Axlsx.validate_string v; @Target = v end
     # @see Type
-    def Type=(v) Axlsx::validate_relationship_type v; @Type = v end
+    def Type=(v) Axlsx.validate_relationship_type v; @Type = v end
 
     # @see TargetMode
     def TargetMode=(v) RestrictionValidator.validate 'Relationship.TargetMode', [:External, :Internal], v; @TargetMode = v; end
@@ -100,10 +102,13 @@ module Axlsx
     # serialize relationship
     # @param [String] str
     # @return [String]
-    def to_xml_string(str = '')
+    def to_xml_string(str = +'')
       h = Axlsx.instance_values_for(self).reject { |k, _| k == "source_obj" }
       str << '<Relationship '
-      str << (h.map { |key, value| '' << key.to_s << '="' << Axlsx::coder.encode(value.to_s) << '"' }.join(' '))
+      h.each_with_index do |key_value, index|
+        str << ' ' unless index.zero?
+        str << key_value.first.to_s << '="' << Axlsx.coder.encode(key_value.last.to_s) << '"'
+      end
       str << '/>'
     end
 

data/lib/axlsx/rels/relationships.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Axlsx
-  require 'axlsx/rels/relationship.rb'
+  require 'axlsx/rels/relationship'
 
   # Relationships are a collection of Relations that define how package parts are related.
   # @note The package automatically manages releationships.
@@ -19,9 +21,9 @@ module Axlsx
     # serialize relationships
     # @param [String] str
     # @return [String]
-    def to_xml_string(str = '')
+    def to_xml_string(str = +'')
       str << '<?xml version="1.0" encoding="UTF-8"?>'
-      str << ('<Relationships xmlns="' << RELS_R << '">')
+      str << '<Relationships xmlns="' << RELS_R << '">'
       each { |rel| rel.to_xml_string(str) }
       str << '</Relationships>'
     end

data/lib/axlsx/stylesheet/border.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Axlsx
   # This class details a border used in Office Open XML spreadsheet styles.
   class Border
@@ -41,20 +43,20 @@ module Axlsx
     attr_reader :prs
 
     # @see diagonalUp
-    def diagonal_up=(v) Axlsx::validate_boolean v; @diagonal_up = v end
+    def diagonal_up=(v) Axlsx.validate_boolean v; @diagonal_up = v end
     alias :diagonalUp= :diagonal_up=
 
     # @see diagonalDown
-    def diagonal_down=(v) Axlsx::validate_boolean v; @diagonal_down = v end
+    def diagonal_down=(v) Axlsx.validate_boolean v; @diagonal_down = v end
     alias :diagonalDown= :diagonal_down=
 
     # @see outline
-    def outline=(v) Axlsx::validate_boolean v; @outline = v end
+    def outline=(v) Axlsx.validate_boolean v; @outline = v end
 
     # Serializes the object
     # @param [String] str
     # @return [String]
-    def to_xml_string(str = '')
+    def to_xml_string(str = +'')
       str << '<border '
       serialized_attributes str
       str << '>'

data/lib/axlsx/stylesheet/border_pr.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Axlsx
   # A border part.
   class BorderPr
@@ -60,10 +62,10 @@ module Axlsx
     # Serializes the object
     # @param [String] str
     # @return [String]
-    def to_xml_string(str = '')
-      str << ('<' << @name.to_s << ' style="' << @style.to_s << '">')
+    def to_xml_string(str = +'')
+      str << '<' << @name.to_s << ' style="' << @style.to_s << '">'
       @color.to_xml_string(str) if @color.is_a?(Color)
-      str << ('</' << @name.to_s << '>')
+      str << '</' << @name.to_s << '>'
     end
   end
 end

data/lib/axlsx/stylesheet/cell_alignment.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Axlsx
   # CellAlignment stores information about the cell alignment of a style Xf Object.
   # @note Using Styles#add_style is the recommended way to manage cell alignment.
@@ -84,40 +86,40 @@ module Axlsx
     alias :readingOrder :reading_order
 
     # @see horizontal
-    def horizontal=(v) Axlsx::validate_horizontal_alignment v; @horizontal = v end
+    def horizontal=(v) Axlsx.validate_horizontal_alignment v; @horizontal = v end
     # @see vertical
-    def vertical=(v) Axlsx::validate_vertical_alignment v; @vertical = v end
+    def vertical=(v) Axlsx.validate_vertical_alignment v; @vertical = v end
     # @see textRotation
-    def text_rotation=(v) Axlsx::validate_unsigned_int v; @text_rotation = v end
+    def text_rotation=(v) Axlsx.validate_unsigned_int v; @text_rotation = v end
     alias :textRotation= :text_rotation=
 
     # @see wrapText
-    def wrap_text=(v) Axlsx::validate_boolean v; @wrap_text = v end
+    def wrap_text=(v) Axlsx.validate_boolean v; @wrap_text = v end
     alias :wrapText= :wrap_text=
 
     # @see indent
-    def indent=(v) Axlsx::validate_unsigned_int v; @indent = v end
+    def indent=(v) Axlsx.validate_unsigned_int v; @indent = v end
 
     # @see relativeIndent
-    def relative_indent=(v) Axlsx::validate_int v; @relative_indent = v end
+    def relative_indent=(v) Axlsx.validate_int v; @relative_indent = v end
     alias :relativeIndent= :relative_indent=
 
     # @see justifyLastLine
-    def justify_last_line=(v) Axlsx::validate_boolean v; @justify_last_line = v end
+    def justify_last_line=(v) Axlsx.validate_boolean v; @justify_last_line = v end
     alias :justifyLastLine= :justify_last_line=
 
     # @see shrinkToFit
-    def shrink_to_fit=(v) Axlsx::validate_boolean v; @shrink_to_fit = v end
+    def shrink_to_fit=(v) Axlsx.validate_boolean v; @shrink_to_fit = v end
     alias :shrinkToFit= :shrink_to_fit=
 
     # @see readingOrder
-    def reading_order=(v) Axlsx::validate_unsigned_int v; @reading_order = v end
+    def reading_order=(v) Axlsx.validate_unsigned_int v; @reading_order = v end
     alias :readingOrder= :reading_order=
 
     # Serializes the object
     # @param [String] str
     # @return [String]
-    def to_xml_string(str = '')
+    def to_xml_string(str = +'')
       serialized_tag('alignment', str)
     end
   end

data/lib/axlsx/stylesheet/cell_protection.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Axlsx
   # CellProtection stores information about locking or hiding cells in spreadsheet.
   # @note Using Styles#add_style is the recommended way to manage cell protection.
@@ -24,14 +26,14 @@ module Axlsx
     end
 
     # @see hidden
-    def hidden=(v) Axlsx::validate_boolean v; @hidden = v end
+    def hidden=(v) Axlsx.validate_boolean v; @hidden = v end
     # @see locked
-    def locked=(v) Axlsx::validate_boolean v; @locked = v end
+    def locked=(v) Axlsx.validate_boolean v; @locked = v end
 
     # Serializes the object
     # @param [String] str
     # @return [String]
-    def to_xml_string(str = '')
+    def to_xml_string(str = +'')
       serialized_tag('protection', str)
     end
   end

data/lib/axlsx/stylesheet/cell_style.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Axlsx
   # CellStyle defines named styles that reference defined formatting records and can be used in your worksheet.
   # @note Using Styles#add_style is the recommended way to manage cell styling.
@@ -37,7 +39,7 @@ module Axlsx
     # @return [Integer]
     attr_reader :iLevel
 
-    # Determines if this named style should show in the list of styles when using excel
+    # Determines if this named style should show in the list of styles when using Excel
     # @return [Boolean]
     attr_reader :hidden
 
@@ -46,22 +48,22 @@ module Axlsx
     attr_reader :customBuiltin
 
     # @see name
-    def name=(v) Axlsx::validate_string v; @name = v end
+    def name=(v) Axlsx.validate_string v; @name = 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 builtinId
-    def builtinId=(v) Axlsx::validate_unsigned_int v; @builtinId = v end
+    def builtinId=(v) Axlsx.validate_unsigned_int v; @builtinId = v end
     # @see iLivel
-    def iLevel=(v) Axlsx::validate_unsigned_int v; @iLevel = v end
+    def iLevel=(v) Axlsx.validate_unsigned_int v; @iLevel = v end
     # @see hidden
-    def hidden=(v) Axlsx::validate_boolean v; @hidden = v end
+    def hidden=(v) Axlsx.validate_boolean v; @hidden = v end
     # @see customBuiltin
-    def customBuiltin=(v) Axlsx::validate_boolean v; @customBuiltin = v end
+    def customBuiltin=(v) Axlsx.validate_boolean v; @customBuiltin = v end
 
     # Serializes the object
     # @param [String] str
     # @return [String]
-    def to_xml_string(str = '')
+    def to_xml_string(str = +'')
       serialized_tag('cellStyle', str)
     end
   end

data/lib/axlsx/stylesheet/color.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Axlsx
   # The color class represents a color used for borders, fills an fonts
   class Color
@@ -45,21 +47,21 @@ module Axlsx
     attr_reader :tint
 
     # @see auto
-    def auto=(v) Axlsx::validate_boolean v; @auto = v end
+    def auto=(v) Axlsx.validate_boolean v; @auto = v end
 
     # @see color
     def rgb=(v)
-      Axlsx::validate_string(v)
+      Axlsx.validate_string(v)
       v = v.upcase
-      v = v * 3 if v.size == 2
+      v *= 3 if v.size == 2
       v = v.rjust(8, 'FF')
-      raise ArgumentError, "Invalid color rgb value: #{v}." unless v.match(/[0-9A-F]{8}/)
+      raise ArgumentError, "Invalid color rgb value: #{v}." unless /[0-9A-F]{8}/.match?(v)
 
       @rgb = v
     end
 
     # @see tint
-    def tint=(v) Axlsx::validate_float v; @tint = v end
+    def tint=(v) Axlsx.validate_float v; @tint = v end
 
     # This version does not support themes
     # def theme=(v) Axlsx::validate_unsigned_integer v; @theme = v end
@@ -70,8 +72,8 @@ module Axlsx
     # Serializes the object
     # @param [String] str
     # @return [String]
-    def to_xml_string(str = '', tag_name = 'color')
-      serialized_tag('' + tag_name + '', str)
+    def to_xml_string(str = +'', tag_name = 'color')
+      serialized_tag(tag_name.to_s, str)
     end
   end
 end

data/lib/axlsx/stylesheet/dxf.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Axlsx
   # The Dxf class defines an incremental formatting record for use in Styles. The recommended way to manage styles for your workbook is with Styles#add_style
   # @see Styles#add_style
@@ -6,7 +8,7 @@ module Axlsx
 
     # The order in which the child elements is put in the XML seems to
     # be important for Excel
-    CHILD_ELEMENTS = [:font, :numFmt, :fill, :alignment, :border, :protection]
+    CHILD_ELEMENTS = [:font, :numFmt, :fill, :alignment, :border, :protection].freeze
     # does not support extList (ExtensionList)
 
     # The cell alignment for this style
@@ -62,12 +64,12 @@ module Axlsx
     # Serializes the object
     # @param [String] str
     # @return [String]
-    def to_xml_string(str = '')
+    def to_xml_string(str = +'')
       str << '<dxf>'
       # Dxf elements have no attributes. All of the instance variables
       # are child elements.
       CHILD_ELEMENTS.each do |element|
-        self.send(element).to_xml_string(str) if self.send(element)
+        send(element).to_xml_string(str) if send(element)
       end
       str << '</dxf>'
     end

data/lib/axlsx/stylesheet/fill.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Axlsx
   # The Fill is a formatting object that manages the background color, and pattern for cells.
   # @note The recommended way to manage styles in your workbook is to use Styles#add_style.
@@ -19,7 +21,7 @@ module Axlsx
     # Serializes the object
     # @param [String] str
     # @return [String]
-    def to_xml_string(str = '')
+    def to_xml_string(str = +'')
       str << '<fill>'
       @fill_type.to_xml_string(str)
       str << '</fill>'