caxlsx 3.3.0 → 4.0.0

data/lib/axlsx/workbook/worksheet/cell.rb

@@ -1,5 +1,5 @@
-# encoding: UTF-8
-require 'cgi'
+# frozen_string_literal: true
+
 module Axlsx
   # A cell in a worksheet.
   # Cell stores inforamation requried to serialize a single worksheet cell to xml. You must provde the Row that the cell belongs to and the cells value. The data type will automatically be determed if you do not specify the :type option. The default style will be applied if you do not supply the :style option. Changing the cell's type will recast the value to the type specified. Altering the cell's value via the property accessor will also automatically cast the provided value to the cell's type.
@@ -7,7 +7,6 @@ module Axlsx
   #
   # @see Worksheet#add_row
   class Cell
-
     include Axlsx::OptionsParser
 
     # @param [Row] row The row this cell belongs to.
@@ -30,10 +29,9 @@ module Axlsx
     # @option options [String] color an 8 letter rgb specification
     # @option options [Number] formula_value The value to cache for a formula cell.
     # @option options [Symbol] scheme must be one of :none, major, :minor
-    # @option options [Boolean] escape_formulas - Whether to treat a value starting with an equal
-    #    sign as formula (default) or as simple string.
-    #    Allowing user generated data to be interpreted as formulas can be dangerous
-    #   (see https://www.owasp.org/index.php/CSV_Injection for details).
+    # @option options [Boolean] escape_formulas Whether to treat values starting with an equals
+    #   sign as formulas or as literal strings. Allowing user-generated data to be interpreted as
+    #   formulas is a security risk. See https://www.owasp.org/index.php/CSV_Injection for details.
     def initialize(row, value = nil, options = {})
       @row = row
       # Do not use instance vars if not needed to use less RAM
@@ -42,15 +40,14 @@ module Axlsx
       type = options.delete(:type) || cell_type_from_value(value)
       self.type = type unless type == :string
 
-      escape_formulas = options[:escape_formulas]
-      self.escape_formulas = escape_formulas unless escape_formulas.nil?
-
       val = options.delete(:style)
-      self.style = val unless val.nil? || val == 0
+      self.style = val unless val.nil? || val.zero?
       val = options.delete(:formula_value)
       self.formula_value = val unless val.nil?
+      val = options.delete(:escape_formulas)
+      self.escape_formulas = val unless val.nil?
 
-      parse_options(options)
+      parse_options(options) unless options.empty?
 
       self.value = value
       value.cell = self if contains_rich_text?
@@ -75,6 +72,9 @@ module Axlsx
     CELL_TYPES = [:date, :time, :float, :integer, :richtext,
                   :string, :boolean, :iso_8601, :text].freeze
 
+    # A regular expression to match the alpha(column)numeric(row) reference of a cell
+    CELL_REFERENCE_REGEX = /([A-Z]+)([0-9]+)/.freeze
+
     # The index of the cellXfs item to be applied to this cell.
     # @return [Integer]
     # @see Axlsx::Styles
@@ -82,10 +82,15 @@ module Axlsx
       defined?(@style) ? @style : 0
     end
 
+    # Internal
+    def style_str
+      defined?(@style) ? @style.to_s : '0'
+    end
+
     attr_accessor :raw_style
 
     # The index of the cellXfs item to be applied to this cell.
-    # @param [Hash] styles
+    # @param [Hash] style
     # @see Axlsx::Styles
     def add_style(style)
       self.raw_style ||= {}
@@ -104,7 +109,7 @@ module Axlsx
       self.raw_style = new_style
 
       wb = row.worksheet.workbook
-      
+
       wb.styled_cells << self
     end
 
@@ -117,7 +122,7 @@ module Axlsx
     # automatically determed.
     # @see Cell#cell_type_from_value
     # @return [Symbol] The type of data this cell's value is cast to.
-    # @raise [ArgumentExeption] Cell.type must be one of [:date, time, :float, :integer, :string, :boolean]
+    # @raise [ArgumentError] Cell.type must be one of [:date, time, :float, :integer, :string, :boolean]
     # @note
     #  If the value provided cannot be cast into the type specified, type is changed to :string and the following logic is applied.
     #   :string to :integer or :float, type conversions always return 0 or 0.0
@@ -134,16 +139,19 @@ module Axlsx
       self.value = @value unless !defined?(@value) || @value.nil?
     end
 
-    # Whether to treat a value starting with an equal
-    #    sign as formula (default) or as simple string.
-    #    Allowing user generated data to be interpreted as formulas can be dangerous
-    #   (see https://www.owasp.org/index.php/CSV_Injection for details).
+    # Whether to treat values starting with an equals sign as formulas or as literal strings.
+    # Allowing user-generated data to be interpreted as formulas is a security risk.
+    # See https://www.owasp.org/index.php/CSV_Injection for details.
     # @return [Boolean]
-    attr_reader :escape_formulas
+    def escape_formulas
+      defined?(@escape_formulas) ? @escape_formulas : row.worksheet.escape_formulas
+    end
 
-    def escape_formulas=(v)
-      Axlsx.validate_boolean(v)
-      @escape_formulas = v
+    # Sets whether to treat values starting with an equals sign as formulas or as literal strings.
+    # @param [Boolean] value The value to set.
+    def escape_formulas=(value)
+      Axlsx.validate_boolean(value)
+      @escape_formulas = value
     end
 
     # The value of this cell.
@@ -152,13 +160,13 @@ module Axlsx
 
     # @see value
     def value=(v)
-      #TODO: consider doing value based type determination first?
+      # TODO: consider doing value based type determination first?
       @value = cast_value(v)
     end
 
     # Indicates that the cell has one or more of the custom cell styles applied.
     # @return [Boolean]
-    def is_text_run?
+    def is_text_run? # rubocop:disable Naming/PredicateName
       defined?(@is_text_run) && @is_text_run && !contains_rich_text?
     end
 
@@ -168,16 +176,18 @@ module Axlsx
 
     # Indicates if the cell is good for shared string table
     def plain_string?
-      (type == :string || type == :text) &&         # String typed
-        !is_text_run? &&          # No inline styles
-        !@value.nil? &&           # Not nil
-        !@value.empty? &&         # Not empty
-        !@value.start_with?(?=)  # Not a formula
+      (type == :string || type == :text) && # String typed
+        !value.nil? &&
+        !value.empty? &&
+        !is_text_run? && # No inline styles
+        !is_formula? &&
+        !is_array_formula?
     end
 
     # The inline font_name property for the cell
     # @return [String]
     attr_reader :font_name
+
     # @see font_name
     def font_name=(v) set_run_style :validate_string, :font_name, v; end
 
@@ -204,6 +214,7 @@ module Axlsx
     # 255  OEM_CHARSET
     # @return [String]
     attr_reader :charset
+
     # @see charset
     def charset=(v) set_run_style :validate_unsigned_int, :charset, v; end
 
@@ -215,6 +226,7 @@ module Axlsx
     # 4 Script
     # 5 Decorative
     attr_reader :family
+
     # @see family
     def family=(v)
       set_run_style :validate_family, :family, v.to_i
@@ -223,69 +235,77 @@ module Axlsx
     # The inline bold property for the cell
     # @return [Boolean]
     attr_reader :b
+
     # @see b
     def b=(v) set_run_style :validate_boolean, :b, v; end
 
     # The inline italic property for the cell
     # @return [Boolean]
     attr_reader :i
+
     # @see i
     def i=(v) set_run_style :validate_boolean, :i, v; end
 
     # The inline strike property for the cell
     # @return [Boolean]
     attr_reader :strike
+
     # @see strike
     def strike=(v) set_run_style :validate_boolean, :strike, v; end
 
     # The inline outline property for the cell
     # @return [Boolean]
     attr_reader :outline
+
     # @see outline
     def outline=(v) set_run_style :validate_boolean, :outline, v; end
 
     # The inline shadow property for the cell
     # @return [Boolean]
     attr_reader :shadow
+
     # @see shadow
     def shadow=(v) set_run_style :validate_boolean, :shadow, v; end
 
     # The inline condense property for the cell
     # @return [Boolean]
     attr_reader :condense
+
     # @see condense
     def condense=(v) set_run_style :validate_boolean, :condense, v; end
 
     # The inline extend property for the cell
     # @return [Boolean]
     attr_reader :extend
+
     # @see extend
     def extend=(v) set_run_style :validate_boolean, :extend, v; end
 
     # The inline underline property for the cell.
-    # It must be one of :none, :single, :double, :singleAccounting, :doubleAccounting, true
+    # It must be one of :none, :single, :double, :singleAccounting, :doubleAccounting
     # @return [Boolean]
     # @return [String]
-    # @note true is for backwards compatability and is reassigned to :single
     attr_reader :u
+
     # @see u
     def u=(v)
-      v = :single if (v == true || v == 1 || v == :true || v == 'true')
       set_run_style :validate_cell_u, :u, v
     end
 
     # The inline color property for the cell
     # @return [Color]
     attr_reader :color
+
     # @param [String] v The 8 character representation for an rgb color #FFFFFFFF"
     def color=(v)
-      @color = v.is_a?(Color) ? v : Color.new(:rgb=>v)
+      @color = v.is_a?(Color) ? v : Color.new(rgb: v)
       @is_text_run = true
     end
 
     # The inline sz property for the cell
     # @return [Inteter]
     attr_reader :sz
+
     # @see sz
     def sz=(v) set_run_style :validate_unsigned_int, :sz, v; end
 
@@ -293,6 +313,7 @@ module Axlsx
     # this must be one of [:baseline, :subscript, :superscript]
     # @return [Symbol]
     attr_reader :vertAlign
+
     # @see vertAlign
     def vertAlign=(v)
       RestrictionValidator.validate :cell_vertAlign, [:baseline, :subscript, :superscript], v
@@ -303,6 +324,7 @@ module Axlsx
     # this must be one of [:none, major, minor]
     # @return [Symbol]
     attr_reader :scheme
+
     # @see scheme
     def scheme=(v)
       RestrictionValidator.validate :cell_scheme, [:none, :major, :minor], v
@@ -322,22 +344,23 @@ module Axlsx
     # @example Relative Cell Reference
     #   ws.rows.first.cells.first.r #=> "A1"
     def r
-      Axlsx::cell_r index, @row.row_index
+      Axlsx.cell_r index, @row.row_index
     end
 
-    # @return [String] The absolute alpha(column)numeric(row) reference for this sell.
+    # @return [String] The absolute alpha(column)numeric(row) reference for this cell.
     # @example Absolute Cell Reference
     #   ws.rows.first.cells.first.r #=> "$A$1"
     def r_abs
-      "$#{r.match(%r{([A-Z]+)([0-9]+)})[1,2].join('$')}"
+      "$#{CELL_REFERENCE_REGEX.match(r)[1, 2].join('$')}"
     end
 
     # @return [Integer] The cellXfs item index applied to this cell.
     # @raise [ArgumentError] Invalid cellXfs id if the value provided is not within cellXfs items range.
     def style=(v)
-      Axlsx::validate_unsigned_int(v)
+      Axlsx.validate_unsigned_int(v)
       count = styles.cellXfs.size
       raise ArgumentError, "Invalid cellXfs id" unless v < count
+
       @style = v
     end
 
@@ -351,11 +374,11 @@ module Axlsx
     # @param [Cell, String] target The last cell, or str ref for the cell in the merge range
     def merge(target)
       start, stop = if target.is_a?(String)
-                      [self.r, target]
-                    elsif(target.is_a?(Cell))
-                      Axlsx.sort_cells([self, target]).map { |c| c.r }
+                      [r, target]
+                    elsif target.is_a?(Cell)
+                      Axlsx.sort_cells([self, target]).map(&:r)
                     end
-      self.row.worksheet.merge_cells "#{start}:#{stop}" unless stop.nil?
+      row.worksheet.merge_cells "#{start}:#{stop}" unless stop.nil?
     end
 
     # Serializes the cell
@@ -363,18 +386,22 @@ module Axlsx
     # @param [Integer] c_index The cell index in the row.
     # @param [String] str The string index the cell content will be appended to. Defaults to empty string.
     # @return [String] xml text for the cell
-    def to_xml_string(r_index, c_index, str = '')
+    def to_xml_string(r_index, c_index, str = +'')
       CellSerializer.to_xml_string r_index, c_index, self, str
     end
 
-    def is_formula?
+    def is_formula? # rubocop:disable Naming/PredicateName
       return false if escape_formulas
 
-      type == :string && @value.to_s.start_with?(?=)
+      type == :string && @value.to_s.start_with?(FORMULA_PREFIX)
     end
 
-    def is_array_formula?
-      type == :string && @value.to_s.start_with?('{=') && @value.to_s.end_with?('}')
+    def is_array_formula? # rubocop:disable Naming/PredicateName
+      return false if escape_formulas
+
+      type == :string &&
+        @value.to_s.start_with?(ARRAY_FORMULA_PREFIX) &&
+        @value.to_s.end_with?(ARRAY_FORMULA_SUFFIX)
     end
 
     # returns the absolute or relative string style reference for
@@ -382,7 +409,7 @@ module Axlsx
     # @param [Boolean] absolute -when false a relative reference will be
     # returned.
     # @return [String]
-    def reference(absolute=true)
+    def reference(absolute = true)
       absolute ? r_abs : r
     end
 
@@ -398,7 +425,7 @@ module Axlsx
     # Attempts to determine the correct width for this cell's content
     # @return [Float]
     def autowidth
-      return if is_formula? || value.nil?
+      return if value.nil? || is_formula?
 
       if contains_rich_text?
         string_width('', font_size) + value.autowidth
@@ -414,12 +441,13 @@ module Axlsx
       end
     end
 
-    # Returns the sanatized value
-    # TODO find a better way to do this as it accounts for 30% of
+    # Returns the sanitized value
+    # TODO: find a better way to do this as it accounts for 30% of
     # processing time in benchmarking...
+    # @return [String] The sanitized value
     def clean_value
-      if (type == :string || type == :text) && !Axlsx::trust_input
-        Axlsx::sanitize(::CGI.escapeHTML(@value.to_s))
+      if (type == :string || type == :text) && !Axlsx.trust_input
+        Axlsx.sanitize(::CGI.escapeHTML(@value.to_s))
       else
         @value.to_s
       end
@@ -452,14 +480,15 @@ module Axlsx
     # Utility method for setting inline style attributes
     def set_run_style(validator, attr, value)
       return unless INLINE_STYLES.include?(attr.to_sym)
+
       Axlsx.send(validator, value) unless validator.nil?
-      self.instance_variable_set :"@#{attr.to_s}", value
+      instance_variable_set :"@#{attr}", value
       @is_text_run = true
     end
 
     # @see ssti
     def ssti=(v)
-      Axlsx::validate_unsigned_int(v)
+      Axlsx.validate_unsigned_int(v)
       @ssti = v
     end
 
@@ -478,13 +507,11 @@ module Axlsx
         :time
       elsif v.is_a?(TrueClass) || v.is_a?(FalseClass)
         :boolean
-      elsif v.to_s =~ Axlsx::NUMERIC_REGEX && v.respond_to?(:to_i)
+      elsif v.respond_to?(:to_i) && Axlsx::NUMERIC_REGEX.match?(v.to_s)
         :integer
-      elsif v.to_s =~ Axlsx::SAFE_FLOAT_REGEX && v.respond_to?(:to_f)
+      elsif v.respond_to?(:to_f) && (Axlsx::SAFE_FLOAT_REGEX.match?(v.to_s) || ((matchdata = MAYBE_FLOAT_REGEX.match(v.to_s)) && matchdata[:exp].to_i.between?(Float::MIN_10_EXP, Float::MAX_10_EXP)))
         :float
-      elsif (matchdata = v.to_s.match(MAYBE_FLOAT_REGEX)) && (Float::MIN_10_EXP..Float::MAX_10_EXP).cover?(matchdata[:exp].to_i) && v.respond_to?(:to_f)
-        :float
-      elsif v.to_s =~ Axlsx::ISO_8601_REGEX
+      elsif Axlsx::ISO_8601_REGEX.match?(v.to_s)
         :iso_8601
       elsif v.is_a? RichText
         :richtext
@@ -498,17 +525,18 @@ module Axlsx
     #   About Time - Time in OOXML is *different* from what you might expect. The history as to why is interesting, but you can safely assume that if you are generating docs on a mac, you will want to specify Workbook.1904 as true when using time typed values.
     # @see Axlsx#date1904
     def cast_value(v)
-      return v if v.is_a?(RichText) || v.nil?
+      return v if v.nil? || v.is_a?(RichText)
+
       case type
       when :date
-        self.style = STYLE_DATE if self.style == 0
+        self.style = STYLE_DATE if style.zero?
         if !v.is_a?(Date) && v.respond_to?(:to_date)
           v.to_date
         else
           v
         end
       when :time
-        self.style = STYLE_DATE if self.style == 0
+        self.style = STYLE_DATE if style.zero?
         if !v.is_a?(Time) && v.respond_to?(:to_time)
           v.to_time
         else
@@ -521,12 +549,11 @@ module Axlsx
       when :boolean
         v ? 1 : 0
       when :iso_8601
-        #consumer is responsible for ensuring the iso_8601 format when specifying this type
+        # consumer is responsible for ensuring the iso_8601 format when specifying this type
         v
       else
         v.to_s
       end
     end
-
   end
 end

data/lib/axlsx/workbook/worksheet/cell_serializer.rb

@@ -1,5 +1,6 @@
-module Axlsx
+# frozen_string_literal: true
 
+module Axlsx
   # The Cell Serializer class contains the logic for serializing cells based on their type.
   class CellSerializer
     class << self
@@ -8,27 +9,30 @@ module Axlsx
       # @param [Integer] column_index The index of the cell's column
       # @param [String] str The string to apend serialization to.
       # @return [String]
-      def to_xml_string(row_index, column_index, cell, str='')
-        str << ('<c r="' << Axlsx::cell_r(column_index, row_index) << '" s="' << cell.style.to_s << '" ')
+      def to_xml_string(row_index, column_index, cell, str = +'')
+        str << '<c r="'
+        str << Axlsx.col_ref(column_index) << Axlsx.row_ref(row_index)
+        str << '" s="' << cell.style_str << '" '
         return str << '/>' if cell.value.nil?
+
         method = cell.type
-        self.send(method, cell, str)
+        send(method, cell, str)
         str << '</c>'
       end
 
       # builds an xml text run based on this cells attributes.
       # @param [String] str The string instance this run will be concated to.
       # @return [String]
-      def run_xml_string(cell, str = '')
+      def run_xml_string(cell, str = +'')
         if cell.is_text_run?
           valid = RichTextRun::INLINE_STYLES - [:value, :type]
-          data = Hash[Axlsx.instance_values_for(cell).map{ |k, v| [k.to_sym, v] }]
-          data = data.select { |key, value| valid.include?(key) && !value.nil? }
+          data = Axlsx.instance_values_for(cell).transform_keys(&:to_sym)
+          data = data.select { |key, value| !value.nil? && valid.include?(key) }
           RichText.new(cell.value.to_s, data).to_xml_string(str)
         elsif cell.contains_rich_text?
           cell.value.to_xml_string(str)
         else
-          str << ('<t>' << cell.clean_value << '</t>')
+          str << '<t>' << cell.clean_value << '</t>'
         end
         str
       end
@@ -37,7 +41,7 @@ module Axlsx
       # @param [Cell] cell The cell that is being serialized
       # @param [String] str The string the serialized content will be appended to.
       # @return [String]
-      def iso_8601(cell, str='')
+      def iso_8601(cell, str = +'')
         value_serialization 'd', cell.value, str
       end
 
@@ -45,23 +49,23 @@ module Axlsx
       # @param [Cell] cell The cell that is being serialized
       # @param [String] str The string the serialized content will be appended to.
       # @return [String]
-      def date(cell, str='')
-        value_serialization false, DateTimeConverter::date_to_serial(cell.value).to_s, str
+      def date(cell, str = +'')
+        value_serialization false, DateTimeConverter.date_to_serial(cell.value).to_s, str
       end
 
       # Serializes cells that are type time
       # @param [Cell] cell The cell that is being serialized
       # @param [String] str The string the serialized content will be appended to.
       # @return [String]
-      def time(cell, str='')
-        value_serialization false, DateTimeConverter::time_to_serial(cell.value).to_s, str
+      def time(cell, str = +'')
+        value_serialization false, DateTimeConverter.time_to_serial(cell.value).to_s, str
       end
 
       # Serializes cells that are type boolean
       # @param [Cell] cell The cell that is being serialized
       # @param [String] str The string the serialized content will be appended to.
       # @return [String]
-      def boolean(cell, str='')
+      def boolean(cell, str = +'')
         value_serialization 'b', cell.value.to_s, str
       end
 
@@ -69,7 +73,7 @@ module Axlsx
       # @param [Cell] cell The cell that is being serialized
       # @param [String] str The string the serialized content will be appended to.
       # @return [String]
-      def float(cell, str='')
+      def float(cell, str = +'')
         numeric cell, str
       end
 
@@ -77,7 +81,7 @@ module Axlsx
       # @param [Cell] cell The cell that is being serialized
       # @param [String] str The string the serialized content will be appended to.
       # @return [String]
-      def integer(cell, str = '')
+      def integer(cell, str = +'')
         numeric cell, str
       end
 
@@ -85,25 +89,25 @@ module Axlsx
       # @param [Cell] cell The cell that is being serialized
       # @param [String] str The string the serialized content will be appended to.
       # @return [String]
-      def formula_serialization(cell, str='')
-        str << ('t="str"><f>' << cell.clean_value.to_s.sub('=', '') << '</f>')
-        str << ('<v>' << cell.formula_value.to_s << '</v>') unless cell.formula_value.nil?
+      def formula_serialization(cell, str = +'')
+        str << 't="str"><f>' << cell.clean_value.delete_prefix(FORMULA_PREFIX) << '</f>'
+        str << '<v>' << cell.formula_value.to_s << '</v>' unless cell.formula_value.nil?
       end
 
       # Serializes cells that are type array formula
       # @param [Cell] cell The cell that is being serialized
       # @param [String] str The string the serialized content will be appended to.
       # @return [String]
-      def array_formula_serialization(cell, str='')
-        str << ('t="str">' << '<f t="array" ref="' << cell.r << '">' << cell.clean_value.to_s.sub('{=', '').sub(/}$/, '') << '</f>')
-        str << ('<v>' << cell.formula_value.to_s << '</v>') unless cell.formula_value.nil?
+      def array_formula_serialization(cell, str = +'')
+        str << 't="str">' << '<f t="array" ref="' << cell.r << '">' << cell.clean_value.delete_prefix(ARRAY_FORMULA_PREFIX).delete_suffix(ARRAY_FORMULA_SUFFIX) << '</f>'
+        str << '<v>' << cell.formula_value.to_s << '</v>' unless cell.formula_value.nil?
       end
 
       # Serializes cells that are type inline_string
       # @param [Cell] cell The cell that is being serialized
       # @param [String] str The string the serialized content will be appended to.
       # @return [String]
-      def inline_string_serialization(cell, str = '')
+      def inline_string_serialization(cell, str = +'')
         str << 't="inlineStr"><is>'
         run_xml_string cell, str
         str << '</is>'
@@ -113,7 +117,7 @@ module Axlsx
       # @param [Cell] cell The cell that is being serialized
       # @param [String] str The string the serialized content will be appended to.
       # @return [String]
-      def string(cell, str='')
+      def string(cell, str = +'')
         if cell.is_array_formula?
           array_formula_serialization cell, str
         elsif cell.is_formula?
@@ -151,13 +155,13 @@ module Axlsx
 
       private
 
-      def numeric(cell, str = '')
+      def numeric(cell, str = +'')
         value_serialization 'n', cell.value, str
       end
 
-      def value_serialization(serialization_type, serialization_value, str = '')
-        str << ('t="' << serialization_type.to_s << '"') if serialization_type
-        str << ('><v>' << serialization_value.to_s << '</v>')
+      def value_serialization(serialization_type, serialization_value, str = +'')
+        str << 't="' << serialization_type.to_s << '"' if serialization_type
+        str << '><v>' << serialization_value.to_s << '</v>'
       end
     end
   end

data/lib/axlsx/workbook/worksheet/cfvo.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Axlsx
   # Conditional Format Value Object
   # Describes the values of the interpolation points in a gradient scale. This object is used by ColorScale, DataBar and IconSet classes
@@ -7,7 +9,6 @@ module Axlsx
   # @see ConditionalFormattingRule#initialize
   #
   class Cfvo
-
     include Axlsx::OptionsParser
     include Axlsx::SerializedAttributes
 
@@ -15,7 +16,7 @@ module Axlsx
     # @option options [Symbol] type The type of conditional formatting value object
     # @option options [Boolean]  gte threshold value usage indicator
     # @option options [String] val The value of the conditional formatting object
-    def initialize(options={})
+    def initialize(options = {})
       @gte = true
       parse_options options
     end
@@ -39,21 +40,22 @@ module Axlsx
     attr_reader :val
 
     # @see type
-    def type=(v); Axlsx::validate_conditional_formatting_value_object_type(v); @type = v end
+    def type=(v); Axlsx.validate_conditional_formatting_value_object_type(v); @type = v end
 
     # @see gte
-    def gte=(v); Axlsx::validate_boolean(v); @gte = v end
+    def gte=(v); Axlsx.validate_boolean(v); @gte = v end
 
     # @see val
     def val=(v)
       raise ArgumentError, "#{v.inspect} must respond to to_s" unless v.respond_to?(:to_s)
+
       @val = v.to_s
     end
 
     # serialize the Csvo object
     # @param [String] str
     # @return [String]
-    def to_xml_string(str = '')
+    def to_xml_string(str = +'')
       serialized_tag('cfvo', str)
     end
   end

data/lib/axlsx/workbook/worksheet/cfvos.rb

@@ -1,9 +1,9 @@
-module Axlsx
+# frozen_string_literal: true
 
-  #A collection of Cfvo objects that initializes with the required
-  #first two items
+module Axlsx
+  # A collection of Cfvo objects that initializes with the required
+  # first two items
   class Cfvos < SimpleTypedList
-
     def initialize
       super(Cfvo)
     end
@@ -11,7 +11,7 @@ module Axlsx
     # Serialize the Cfvo object
     # @param [String] str
     # @return [String]
-    def to_xml_string(str='')
+    def to_xml_string(str = +'')
       each { |cfvo| cfvo.to_xml_string(str) }
     end
   end