caxlsx 3.3.0 → 4.0.0

data/lib/axlsx/package.rb

@@ -1,4 +1,5 @@
-# encoding: utf-8
+# 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.
@@ -20,7 +21,7 @@ module Axlsx
     # @option options [Time] :created_at Timestamp in the document properties (defaults to current time).
     # @option options [Boolean] :use_shared_strings This is passed to the workbook to specify that shared strings should be used when serializing the package.
     # @example Package.new :author => 'you!', :workbook => Workbook.new
-    def initialize(options={})
+    def initialize(options = {})
       @workbook = nil
       @core, @app = Core.new, App.new
       @core.creator = options[:author] || @core.creator
@@ -32,12 +33,10 @@ 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
 
-
-
     # Shortcut to determine if the workbook is configured to use shared strings
     # @see Workbook#use_shared_strings
     def use_shared_strings
@@ -47,9 +46,10 @@ 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
+
     # The workbook this package will serialize or validate.
     # @return [Workbook] If no workbook instance has been assigned with this package a new Workbook instance is returned.
     # @raise ArgumentError if workbook parameter is not a Workbook instance.
@@ -101,16 +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
-        workbook.apply_styles 
+      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|
@@ -121,19 +122,20 @@ module Axlsx
       Relationship.clear_ids_cache
     end
 
-
     # Serialize your workbook to a StringIO instance
     # @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
-        workbook.apply_styles 
+    def to_stream(confirm_valid = false)
+      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
@@ -143,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
@@ -157,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
@@ -187,7 +189,7 @@ module Axlsx
         end
         unless part[:path].nil?
           zip.put_next_entry(zip_entry_for_part(part))
-          zip.write IO.read(part[:path], mode: "rb")
+          zip.write File.read(part[:path], mode: "rb")
         end
       end
       zip
@@ -214,58 +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 }
+      workbook.comments.each do |comment|
+        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}
+        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
 
@@ -291,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
@@ -349,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
@@ -378,19 +379,20 @@ module Axlsx
     # @private
     def parse_serialize_options(options, secondary_options)
       if secondary_options
-        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')"
+        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. " +
-          "Use keyword args instead e.g., package.serialize(output, confirm_valid: false)"
+        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
     end

data/lib/axlsx/rels/relationship.rb

@@ -1,9 +1,9 @@
-# encoding: UTF-8
+# frozen_string_literal: true
+
 module Axlsx
   # A relationship defines a reference between package parts.
   # @note Packages automatically manage relationships.
   class Relationship
-    
     class << self
       # Keeps track of relationship ids in use.
       # @return [Array]
@@ -12,27 +12,27 @@ module Axlsx
       end
 
       # Initialize cached ids.
-      # 
+      #
       # This should be called before serializing a package (see {Package#serialize} and
-      # {Package#to_stream}) to make sure that serialization is idempotent (i.e. 
+      # {Package#to_stream}) to make sure that serialization is idempotent (i.e.
       # Relationship instances are generated with the same IDs everytime the package
       # is serialized).
       def initialize_ids_cache
         Thread.current[:axlsx_relationship_ids_cache] = {}
       end
-      
+
       # Clear cached ids.
-      # 
+      #
       # This should be called after serializing a package (see {Package#serialize} and
       # {Package#to_stream}) to free the memory allocated for cache.
-      # 
-      # Also, calling this avoids memory leaks (cached ids lingering around 
-      # forever). 
+      #
+      # Also, calling this avoids memory leaks (cached ids lingering around
+      # forever).
       def clear_ids_cache
         Thread.current[:axlsx_relationship_ids_cache] = nil
       end
-      
-      # Generate and return a unique id (eg. `rId123`) Used for setting {#Id}. 
+
+      # Generate and return a unique id (eg. `rId123`) Used for setting {#Id}.
       #
       # The generated id depends on the number of previously cached ids, so using
       # {clear_ids_cache} will automatically reset the generated ids, too.
@@ -42,12 +42,12 @@ module Axlsx
       end
     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?}
+    # The id of the relationship (eg. "rId123"). Most instances get their own unique id.
+    # However, some instances need to share the same id – see {#ids_cache_key}
     # for details.
     # @return [String]
     attr_reader :Id
-    
+
     # The location of the relationship target
     # @return [String]
     attr_reader :Target
@@ -77,24 +77,24 @@ module Axlsx
     # The source object the relations belongs to (e.g. a hyperlink, drawing, ...). Needed when
     # looking up the relationship for a specific object (see {Relationships#for}).
     attr_reader :source_obj
-    
-    # Initializes a new relationship. 
+
+    # Initializes a new relationship.
     # @param [Object] source_obj see {#source_obj}
     # @param [String] type The type of the relationship
     # @param [String] target The target for the relationship
     # @option [Symbol] :target_mode only accepts :external.
-    def initialize(source_obj, type, target, options={})
+    def initialize(source_obj, type, target, options = {})
       @source_obj = source_obj
-      self.Target=target
-      self.Type=type
+      self.Target = target
+      self.Type = type
       self.TargetMode = options[:target_mode] if options[:target_mode]
       @Id = (self.class.ids_cache[ids_cache_key] ||= self.class.next_free_id)
     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
@@ -102,18 +102,21 @@ module Axlsx
     # serialize relationship
     # @param [String] str
     # @return [String]
-    def to_xml_string(str = '')
-      h = Axlsx.instance_values_for(self).reject{|k, _| k == "source_obj"}
+    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
-    
+
     # A key that determines whether this relationship should use already generated id.
     #
     # Instances designating the same relationship need to use the same id. We can not simply
-    # compare the {#Target} attribute, though: `foo/bar.xml`, `../foo/bar.xml`, 
-    # `../../foo/bar.xml` etc. are all different but probably mean the same file (this 
+    # compare the {#Target} attribute, though: `foo/bar.xml`, `../foo/bar.xml`,
+    # `../../foo/bar.xml` etc. are all different but probably mean the same file (this
     # is especially an issue for relationships in the context of pivot tables). So lets
     # just ignore this attribute for now (except when {#TargetMode} is set to `:External` –
     # then {#Target} will be an absolute URL and thus can safely be compared).
@@ -125,6 +128,5 @@ module Axlsx
       key << self.Target if self.TargetMode == :External
       key
     end
-    
   end
 end

data/lib/axlsx/rels/relationships.rb

@@ -1,11 +1,11 @@
-# encoding: UTF-8
+# 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.
   class Relationships < SimpleTypedList
-
     # Creates a new Relationships collection based on SimpleTypedList
     def initialize
       super Relationship
@@ -15,18 +15,17 @@ require 'axlsx/rels/relationship.rb'
     # @see Relationship#source_obj
     # @return [Relationship]
     def for(source_obj)
-      find{ |rel| rel.source_obj == source_obj }
+      find { |rel| rel.source_obj == source_obj }
     end
 
     # 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 << '">')
-      each{ |rel| rel.to_xml_string(str) }
+      str << '<Relationships xmlns="' << RELS_R << '">'
+      each { |rel| rel.to_xml_string(str) }
       str << '</Relationships>'
     end
-
   end
 end

data/lib/axlsx/stylesheet/border.rb

@@ -1,8 +1,8 @@
-# encoding: UTF-8
+# frozen_string_literal: true
+
 module Axlsx
   # This class details a border used in Office Open XML spreadsheet styles.
   class Border
-
     include Axlsx::SerializedAttributes
     include Axlsx::OptionsParser
 
@@ -21,7 +21,7 @@ module Axlsx
     #
     # @note The recommended way to manage borders is with Style#add_style
     # @see Style#add_style
-    def initialize(options={})
+    def initialize(options = {})
       @prs = SimpleTypedList.new BorderPr
       parse_options options
     end
@@ -43,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 << '>'
@@ -68,6 +68,5 @@ module Axlsx
       end
       str << '</border>'
     end
-
   end
 end

data/lib/axlsx/stylesheet/border_pr.rb

@@ -1,4 +1,5 @@
-# encoding: UTF-8
+# frozen_string_literal: true
+
 module Axlsx
   # A border part.
   class BorderPr
@@ -44,11 +45,11 @@ module Axlsx
     # @option options [Symbol] name
     # @option options [Symbol] style
     # @see Axlsx::Border
-    def initialize(options={})
+    def initialize(options = {})
       parse_options(options)
-      #options.each do |o|
+      # options.each do |o|
       #  self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
-      #end
+      # end
     end
 
     # @see name
@@ -61,11 +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