caxlsx 3.4.1 → 4.1.0

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Axlsx
   # The Cell Serializer class contains the logic for serializing cells based on their type.
   class CellSerializer
@@ -7,28 +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
@@ -38,10 +40,16 @@ 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)
@@ -53,7 +61,7 @@ module Axlsx
     # 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,3 +1,5 @@
+# frozen_string_literal: true
+
 module Axlsx
   # A collection of Cfvo objects that initializes with the required
   # first two items
@@ -9,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

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Axlsx
   # The Col class defines column attributes for columns in sheets.
   class Col
@@ -86,7 +88,7 @@ module Axlsx
     # @see Col#outline
     def outline_level=(v)
       Axlsx.validate_unsigned_numeric(v)
-      raise ArgumentError, 'outlineLevel must be between 0 and 7' unless 0 <= v && v <= 7
+      raise ArgumentError, 'outlineLevel must be between 0 and 7' unless v >= 0 && v <= 7
 
       @outline_level = v
     end
@@ -112,7 +114,7 @@ module Axlsx
       # current @width value.
       # TODO!!!
       # Axlsx.validate_unsigned_numeric(v) unless v == nil
-      @custom_width = @best_fit = v != nil
+      @custom_width = @best_fit = !v.nil?
       @width = v.nil? ? v : [v, MAX_WIDTH].min
     end
 
@@ -135,7 +137,7 @@ module Axlsx
     # Serialize this columns data to an xml string
     # @param [String] str
     # @return [String]
-    def to_xml_string(str = '')
+    def to_xml_string(str = +'')
       serialized_tag('col', str)
     end
   end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Axlsx
   # A collection of Brake objects.
   # Please do not use this class directly. Instead use
@@ -5,7 +7,7 @@ module Axlsx
   class ColBreaks < SimpleTypedList
     # Instantiates a new list restricted to Break types
     def initialize
-      super Break
+      super(Break)
     end
 
     # A column break specific helper for adding a break.
@@ -14,7 +16,7 @@ module Axlsx
     # Break will be passed to the created break object.
     # @see Break
     def add_break(options)
-      self << Break.new(options.merge(:max => 1048575, :man => true))
+      self << Break.new(options.merge(max: 1048575, man: true))
       last
     end
 
@@ -23,10 +25,10 @@ module Axlsx
     # <colBreaks count="1" manualBreakCount="1">
     # <brk id="3" max="1048575" man="1"/>
     # </colBreaks>
-    def to_xml_string(str = '')
+    def to_xml_string(str = +'')
       return if empty?
 
-      str << ('<colBreaks count="' << size.to_s << '" manualBreakCount="' << size.to_s << '">')
+      str << '<colBreaks count="' << size.to_s << '" manualBreakCount="' << size.to_s << '">'
       each { |brk| brk.to_xml_string(str) }
       str << '</colBreaks>'
     end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Axlsx
   # Conditional Format Rule color scale object
   # Describes a gradated color scale in this conditional formatting rule.
@@ -10,8 +12,8 @@ module Axlsx
       # These are the default conditional formatting value objects
       # that define a two tone color gradient.
       def default_cfvos
-        [{ :type => :min, :val => 0, :color => 'FFFF7128' },
-         { :type => :max, :val => 0, :color => 'FFFFEF9C' }]
+        [{ type: :min, val: 0, color: 'FFFF7128' },
+         { type: :max, val: 0, color: 'FFFFEF9C' }]
       end
 
       # A builder for two tone color gradient
@@ -20,7 +22,7 @@ module Axlsx
       #   color_scale = Axlsx::ColorScale.two_tone
       # @see examples/example.rb conditional formatting examples.
       def two_tone
-        self.new
+        new
       end
 
       # A builder for three tone color gradient
@@ -29,9 +31,9 @@ module Axlsx
       #   color_scale = Axlsx::ColorScale.three_tone
       # @see examples/example.rb conditional formatting examples.
       def three_tone
-        self.new({ :type => :min, :val => 0, :color => 'FFF8696B' },
-                 { :type => :percent, :val => '50', :color => 'FFFFEB84' },
-                 { :type => :max, :val => 0, :color => 'FF63BE7B' })
+        new({ type: :min, val: 0, color: 'FFF8696B' },
+            { type: :percent, val: '50', color: 'FFFFEB84' },
+            { type: :max, val: 0, color: 'FF63BE7B' })
       end
     end
     # A simple typed list of cfvos
@@ -66,9 +68,9 @@ module Axlsx
     # @option [Any] val The value of the cfvo to add
     # @option [String] The rgb color for the cfvo
     def add(options = {})
-      value_objects << Cfvo.new(:type => options[:type] || :min, :val => options[:val] || 0)
-      colors << Color.new(:rgb => options[:color] || "FF000000")
-      { :cfvo => value_objects.last, :color => colors.last }
+      value_objects << Cfvo.new(type: options[:type] || :min, val: options[:val] || 0)
+      colors << Color.new(rgb: options[:color] || "FF000000")
+      { cfvo: value_objects.last, color: colors.last }
     end
 
     # removes the cfvo and color pair at the index specified.
@@ -82,7 +84,7 @@ module Axlsx
     # Serialize this color_scale object data to an xml string
     # @param [String] str
     # @return [String]
-    def to_xml_string(str = '')
+    def to_xml_string(str = +'')
       str << '<colorScale>'
       value_objects.to_xml_string(str)
       colors.each { |color| color.to_xml_string(str) }

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Axlsx
   # The cols class manages the col object used to manage column widths.
   # This is where the magic happens with autowidth
@@ -5,14 +7,14 @@ module Axlsx
     def initialize(worksheet)
       raise ArgumentError, "you must provide a worksheet" unless worksheet.is_a?(Worksheet)
 
-      super Col
+      super(Col)
       @worksheet = worksheet
     end
 
     # Serialize the Cols object
     # @param [String] str
     # @return [String]
-    def to_xml_string(str = '')
+    def to_xml_string(str = +'')
       return if empty?
 
       str << '<cols>'

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Axlsx
   # A comment is the text data for a comment
   class Comment
@@ -59,17 +61,17 @@ module Axlsx
     # serialize the object
     # @param [String] str
     # @return [String]
-    def to_xml_string(str = "")
+    def to_xml_string(str = +'')
       author = @comments.authors[author_index]
-      str << ('<comment ref="' << ref << '" authorId="' << author_index.to_s << '">')
+      str << '<comment ref="' << ref << '" authorId="' << author_index.to_s << '">'
       str << '<text>'
       unless author.to_s == ""
         str << '<r><rPr><b/><color indexed="81"/></rPr>'
-        str << ("<t>" << ::CGI.escapeHTML(author.to_s) << ":\n</t></r>")
+        str << "<t>" << ::CGI.escapeHTML(author.to_s) << ":\n</t></r>"
       end
       str << '<r>'
       str << '<rPr><color indexed="81"/></rPr>'
-      str << ('<t>' << ::CGI.escapeHTML(text) << '</t></r></text>')
+      str << '<t>' << ::CGI.escapeHTML(text) << '</t></r></text>'
       str << '</comment>'
     end
 
@@ -78,8 +80,8 @@ module Axlsx
     # initialize the vml shape based on this comment's ref/position in the worksheet.
     # by default, all columns are 5 columns wide and 5 rows high
     def initialize_vml_shape
-      pos = Axlsx::name_to_indices(ref)
-      @vml_shape = VmlShape.new(:row => pos[1], :column => pos[0], :visible => @visible) do |vml|
+      pos = Axlsx.name_to_indices(ref)
+      @vml_shape = VmlShape.new(row: pos[1], column: pos[0], visible: @visible) do |vml|
         vml.left_column = vml.column
         vml.right_column = vml.column + 2
         vml.top_row = vml.row

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Axlsx
   # Comments is a collection of Comment objects for a worksheet
   class Comments < SimpleTypedList
@@ -18,7 +20,7 @@ module Axlsx
     # The part name for this object
     # @return [String]
     def pn
-      "#{COMMENT_PN % (index + 1)}"
+      format(COMMENT_PN, index + 1)
     end
 
     # Creates a new Comments object
@@ -62,11 +64,11 @@ module Axlsx
     # serialize the object
     # @param [String] str
     # @return [String]
-    def to_xml_string(str = "")
+    def to_xml_string(str = +'')
       str << '<?xml version="1.0" encoding="UTF-8"?>'
-      str << ('<comments xmlns="' << XML_NS << '"><authors>')
+      str << '<comments xmlns="' << XML_NS << '"><authors>'
       authors.each do |author|
-        str << ('<author>' << author.to_s << '</author>')
+        str << '<author>' << author.to_s << '</author>'
       end
       str << '</authors><commentList>'
       each do |comment|

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Axlsx
   # Conditional formatting allows styling of ranges based on functions
   #
@@ -59,9 +61,15 @@ module Axlsx
     end
 
     # @see rules
-    def rules=(v); @rules = v end
+    def rules=(v)
+      @rules = v
+    end
+
     # @see sqref
-    def sqref=(v); Axlsx::validate_string(v); @sqref = v end
+    def sqref=(v)
+      Axlsx.validate_string(v)
+      @sqref = v
+    end
 
     # Serializes the conditional formatting element
     # @example Conditional Formatting XML looks like:
@@ -72,9 +80,12 @@ module Axlsx
     #    </conditionalFormatting>
     # @param [String] str
     # @return [String]
-    def to_xml_string(str = '')
-      str << ('<conditionalFormatting sqref="' << sqref << '">')
-      str << rules.collect { |rule| rule.to_xml_string }.join(' ')
+    def to_xml_string(str = +'')
+      str << '<conditionalFormatting sqref="' << sqref << '">'
+      rules.each_with_index do |rule, index|
+        str << ' ' unless index.zero?
+        rule.to_xml_string(str)
+      end
       str << '</conditionalFormatting>'
     end
   end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Axlsx
   # Conditional formatting rules specify formulas whose evaluations
   # format cells
@@ -153,33 +155,88 @@ module Axlsx
     end
 
     # @see type
-    def type=(v); Axlsx::validate_conditional_formatting_type(v); @type = v end
+    def type=(v)
+      Axlsx.validate_conditional_formatting_type(v)
+      @type = v
+    end
+
     # @see aboveAverage
-    def aboveAverage=(v); Axlsx::validate_boolean(v); @aboveAverage = v end
+    def aboveAverage=(v)
+      Axlsx.validate_boolean(v)
+      @aboveAverage = v
+    end
+
     # @see bottom
-    def bottom=(v); Axlsx::validate_boolean(v); @bottom = v end
+    def bottom=(v)
+      Axlsx.validate_boolean(v)
+      @bottom = v
+    end
+
     # @see dxfId
-    def dxfId=(v); Axlsx::validate_unsigned_numeric(v); @dxfId = v end
+    def dxfId=(v)
+      Axlsx.validate_unsigned_numeric(v)
+      @dxfId = v
+    end
+
     # @see equalAverage
-    def equalAverage=(v); Axlsx::validate_boolean(v); @equalAverage = v end
+    def equalAverage=(v)
+      Axlsx.validate_boolean(v)
+      @equalAverage = v
+    end
+
     # @see priority
-    def priority=(v); Axlsx::validate_unsigned_numeric(v); @priority = v end
+    def priority=(v)
+      Axlsx.validate_unsigned_numeric(v)
+      @priority = v
+    end
+
     # @see operator
-    def operator=(v); Axlsx::validate_conditional_formatting_operator(v); @operator = v end
+    def operator=(v)
+      Axlsx.validate_conditional_formatting_operator(v)
+      @operator = v
+    end
+
     # @see text
-    def text=(v); Axlsx::validate_string(v); @text = v end
+    def text=(v)
+      Axlsx.validate_string(v)
+      @text = v
+    end
+
     # @see percent
-    def percent=(v); Axlsx::validate_boolean(v); @percent = v end
+    def percent=(v)
+      Axlsx.validate_boolean(v)
+      @percent = v
+    end
+
     # @see rank
-    def rank=(v); Axlsx::validate_unsigned_numeric(v); @rank = v end
+    def rank=(v)
+      Axlsx.validate_unsigned_numeric(v)
+      @rank = v
+    end
+
     # @see stdDev
-    def stdDev=(v); Axlsx::validate_unsigned_numeric(v); @stdDev = v end
+    def stdDev=(v)
+      Axlsx.validate_unsigned_numeric(v)
+      @stdDev = v
+    end
+
     # @see stopIfTrue
-    def stopIfTrue=(v); Axlsx::validate_boolean(v); @stopIfTrue = v end
+    def stopIfTrue=(v)
+      Axlsx.validate_boolean(v)
+      @stopIfTrue = v
+    end
+
     # @see timePeriod
-    def timePeriod=(v); Axlsx::validate_time_period_type(v); @timePeriod = v end
+    def timePeriod=(v)
+      Axlsx.validate_time_period_type(v)
+      @timePeriod = v
+    end
+
     # @see formula
-    def formula=(v); [*v].each { |x| Axlsx::validate_string(x) }; @formula = [*v].map { |form| ::CGI.escapeHTML(form) } end
+    def formula=(v)
+      [*v].each { |x| Axlsx.validate_string(x) }
+      @formula = [*v].map { |form| ::CGI.escapeHTML(form) }
+    end
 
     # @see color_scale
     def color_scale=(v)
@@ -202,11 +259,11 @@ module Axlsx
     # Serializes the conditional formatting rule
     # @param [String] str
     # @return [String]
-    def to_xml_string(str = '')
+    def to_xml_string(str = +'')
       str << '<cfRule '
       serialized_attributes str
       str << '>'
-      str << ('<formula>' << [*self.formula].join('</formula><formula>') << '</formula>') if @formula
+      str << '<formula>' << [*formula].join('</formula><formula>') << '</formula>' if @formula
       @color_scale.to_xml_string(str) if @color_scale && @type == :colorScale
       @data_bar.to_xml_string(str) if @data_bar && @type == :dataBar
       @icon_set.to_xml_string(str) if @icon_set && @type == :iconSet

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Axlsx
   # A simple, self serializing class for storing conditional formattings
   class ConditionalFormattings < SimpleTypedList
@@ -5,7 +7,7 @@ module Axlsx
     def initialize(worksheet)
       raise ArgumentError, "you must provide a worksheet" unless worksheet.is_a?(Worksheet)
 
-      super ConditionalFormatting
+      super(ConditionalFormatting)
       @worksheet = worksheet
     end
 
@@ -14,7 +16,7 @@ module Axlsx
     attr_reader :worksheet
 
     # serialize the conditional formattings
-    def to_xml_string(str = "")
+    def to_xml_string(str = +'')
       return if empty?
 
       each { |item| item.to_xml_string(str) }