caxlsx 2.0.2 → 3.0.4

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

@@ -3,43 +3,32 @@ module Axlsx
   # The Cell Serializer class contains the logic for serializing cells based on their type.
   class CellSerializer
     class << self
-
-
       # Calls the proper serialization method based on type.
       # @param [Integer] row_index The index of the cell's row
       # @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 << '" '
+        str << ('<c r="' << Axlsx::cell_r(column_index, row_index) << '" s="' << cell.style.to_s << '" ')
         return str << '/>' if cell.value.nil?
-        method = (cell.type.to_s << '_type_serialization').to_sym
+        method = cell.type
         self.send(method, cell, str)
         str << '</c>'
-      end 
-
+      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 = '')
         if cell.is_text_run?
-          data = cell.instance_values.reject{|key, value| value == nil || key == 'value' || key == 'type' }
-          keys = data.keys & Cell::INLINE_STYLES
-          str << "<r><rPr>"
-          keys.each do |key|
-            case key
-            when 'font_name'
-              str << "<rFont val='"<< cell.font_name << "'/>"
-            when 'color'
-              str << data[key].to_xml_string
-            else
-              str << "<" << key.to_s << " val='" << data[key].to_s << "'/>"
-            end
-          end
-          str << "</rPr>" << "<t>" << cell.value.to_s << "</t></r>"
+          valid = RichTextRun::INLINE_STYLES - [:value, :type]
+          data = Hash[cell.instance_values.map{ |k, v| [k.to_sym, v] }]
+          data = data.select { |key, value| valid.include?(key) && !value.nil? }
+          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.value.to_s << "</t>"
+          str << ('<t>' << cell.clean_value << '</t>')
         end
         str
       end
@@ -48,16 +37,15 @@ 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_type_serialization(cell, str='')
+      def iso_8601(cell, str='')
         value_serialization 'd', cell.value, str
       end
 
-
       # serializes cells that are type date
       # @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_type_serialization(cell, str='')
+      def date(cell, str='')
         value_serialization false, DateTimeConverter::date_to_serial(cell.value).to_s, str
       end
 
@@ -65,7 +53,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 time_type_serialization(cell, str='')
+      def time(cell, str='')
         value_serialization false, DateTimeConverter::time_to_serial(cell.value).to_s, str
       end
 
@@ -73,7 +61,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 boolean_type_serialization(cell, str='')
+      def boolean(cell, str='')
         value_serialization 'b', cell.value.to_s, str
       end
 
@@ -81,26 +69,34 @@ 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_type_serialization(cell, str='')
-        numeric_type_serialization cell, str
+      def float(cell, str='')
+        numeric cell, str
       end
 
       # Serializes cells that are type integer
       # @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_type_serialization(cell, str = '')
-        numeric_type_serialization cell, str
+      def integer(cell, str = '')
+        numeric cell, str
       end
 
-
       # Serializes cells that are type 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 formula_serialization(cell, str='')
-        str << 't="str">' << '<f>' << cell.value.to_s.sub('=', '') << '</f>'
-        str << '<v>' << cell.formula_value.to_s << '</v>' unless cell.formula_value.nil?
+        str << ('t="str"><f>' << cell.clean_value.to_s.sub('=', '') << '</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?
       end
 
       # Serializes cells that are type inline_string
@@ -108,7 +104,7 @@ module Axlsx
       # @param [String] str The string the serialized content will be appended to.
       # @return [String]
       def inline_string_serialization(cell, str = '')
-        str << 't="inlineStr">' << '<is>'
+        str << 't="inlineStr"><is>'
         run_xml_string cell, str
         str << '</is>'
       end
@@ -117,28 +113,52 @@ 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_type_serialization(cell, str='')
-        if cell.is_formula?
+      def string(cell, str='')
+        if cell.is_array_formula?
+          array_formula_serialization cell, str
+        elsif cell.is_formula?
           formula_serialization cell, str
         elsif !cell.ssti.nil?
-          value_serialization 's', cell.ssti.to_s, str
+          value_serialization 's', cell.ssti, str
         else
           inline_string_serialization cell, str
         end
       end
 
+      # Serializes cells that are of the type richtext
+      # @param [Cell] cell The cell that is being serialized
+      # @param [String] str The string the serialized content will be appended to.
+      # @return [String]
+      def richtext(cell, str)
+        if cell.ssti.nil?
+          inline_string_serialization cell, str
+        else
+          value_serialization 's', cell.ssti, str
+        end
+      end
+
+      # Serializes cells that are of the type text
+      # @param [Cell] cell The cell that is being serialized
+      # @param [String] str The string the serialized content will be appended to.
+      # @return [String]
+      def text(cell, str)
+        if cell.ssti.nil?
+          inline_string_serialization cell, str
+        else
+          value_serialization 's', cell.ssti, str
+        end
+      end
+
       private
 
-      def numeric_type_serialization(cell, str = '')
-        value_serialization 'n', cell.value.to_s, str
+      def numeric(cell, str = '')
+        value_serialization 'n', cell.value, str
       end
 
       def value_serialization(serialization_type, serialization_value, str = '')
-        str << 't="' << serialization_type << '"' if serialization_type
-        str << '><v>' << serialization_value << '</v>'
+        str << ('t="' << serialization_type.to_s << '"') if serialization_type
+        str << ('><v>' << serialization_value.to_s << '</v>')
       end
-
-
     end
   end
 end

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

@@ -54,9 +54,7 @@ module Axlsx
     # @param [String] str
     # @return [String]
     def to_xml_string(str = '')
-      str << '<cfvo '
-      serialized_attributes str
-      str << ' />'
+      serialized_tag('cfvo', str)
     end
   end
 end

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

@@ -8,8 +8,11 @@ module Axlsx
       super(Cfvo)
     end
 
+    # Serialize the Cfvo object
+    # @param [String] str
+    # @return [String]
     def to_xml_string(str='')
-      @list.each { |cfvo| cfvo.to_xml_string(str) }
+      each { |cfvo| cfvo.to_xml_string(str) }
     end
   end
 end

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

@@ -4,6 +4,10 @@ module Axlsx
   # The Col class defines column attributes for columns in sheets.
   class Col
 
+    # Maximum column width limit in MS Excel is 255 characters
+    # https://support.microsoft.com/en-us/office/excel-specifications-and-limits-1672b34d-7043-467e-8e27-269d656771c3
+    MAX_WIDTH = 255
+
     include Axlsx::OptionsParser
     include Axlsx::SerializedAttributes
     # Create a new Col objects
@@ -111,10 +115,10 @@ module Axlsx
       # TODO!!!
       #Axlsx.validate_unsigned_numeric(v) unless v == nil
       @custom_width = @best_fit = v != nil
-      @width = v
+      @width = v.nil? ? v : [v, MAX_WIDTH].min
     end
 
-    # updates the width for this col based on the cells autowidth and 
+    # updates the width for this col based on the cells autowidth and
     # an optionally specified fixed width
     # @param [Cell] cell The cell to use in updating this col's width
     # @param [Integer] fixed_width If this is specified the width is set
@@ -122,22 +126,19 @@ module Axlsx
     # @param [Boolean] use_autowidth If this is false, the cell's
     # autowidth value will be ignored.
     def update_width(cell, fixed_width=nil, use_autowidth=true)
-       if fixed_width.is_a? Numeric
-         self.width = fixed_width
-       elsif use_autowidth
-         cell_width = cell.autowidth
-         self.width = cell_width unless (width || 0) > (cell_width || 0)
-         #self.width = [width || 0, cell.autowidth || 0].max
-       end 
-    end 
+      if fixed_width.is_a? Numeric
+       self.width = fixed_width
+      elsif use_autowidth
+       cell_width = cell.autowidth
+       self.width = cell_width unless (width || 0) > (cell_width || 0)
+      end
+    end
 
     # Serialize this columns data to an xml string
     # @param [String] str
     # @return [String]
     def to_xml_string(str = '')
-      str << '<col '
-      serialized_attributes str
-      str << '/>'
+      serialized_tag('col', str)
     end
 
   end

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

@@ -16,7 +16,7 @@ module Axlsx
     # Break will be passed to the created break object.
     # @see Break
     def add_break(options)
-      @list << Break.new(options.merge(:max => 1048575, :man => true))
+      self << Break.new(options.merge(:max => 1048575, :man => true))
       last
     end
 
@@ -27,7 +27,7 @@ module Axlsx
     # </colBreaks>
     def to_xml_string(str='')
       return if empty?
-      str << '<colBreaks count="' << @list.size.to_s << '" manualBreakCount="' << @list.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/cols.rb

@@ -1,6 +1,6 @@
 module Axlsx
 
-  # The cols class manages the col object used to manage column widths. 
+  # The cols class manages the col object used to manage column widths.
   # This is where the magic happens with autowidth
   class Cols < SimpleTypedList
 
@@ -10,11 +10,14 @@ module Axlsx
       @worksheet = worksheet
     end
 
+    # Serialize the Cols object
+    # @param [String] str
+    # @return [String]
     def to_xml_string(str = '')
      return if empty?
      str << '<cols>'
      each { |item| item.to_xml_string(str) }
-     str << '</cols>' 
+     str << '</cols>'
     end
   end
 end

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

@@ -24,11 +24,10 @@ module Axlsx
     string_attr_accessor :text, :author
     boolean_attr_accessor :visible
 
-      # The owning Comments object
+    # The owning Comments object
     # @return [Comments]
     attr_reader :comments
 
-
     # The string based cell position reference (e.g. 'A1') that determines the positioning of this comment
     # @return [String|Cell]
     attr_reader :ref
@@ -53,7 +52,7 @@ module Axlsx
 
     # @see ref
     def ref=(v)
-      Axlsx::DataTypeValidator.validate "Comment.ref", [String, Cell], v
+      Axlsx::DataTypeValidator.validate :comment_ref, [String, Cell], v
       @ref = v if v.is_a?(String)
       @ref = v.r if v.is_a?(Cell)
     end
@@ -63,15 +62,15 @@ module Axlsx
     # @return [String]
     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
 

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

@@ -42,23 +42,22 @@ module Axlsx
       raise ArgumentError, "Comment require an author" unless options[:author]
       raise ArgumentError, "Comment requires text" unless options[:text]
       raise ArgumentError, "Comment requires ref" unless options[:ref]
-      @list << Comment.new(self, options)
-      yield @list.last if block_given?
-      @list.last
+      self << Comment.new(self, options)
+      yield last if block_given?
+      last
     end
 
     # A sorted list of the unique authors in the contained comments
     # @return [Array]
     def authors
-      @list.map { |comment| comment.author.to_s }.uniq.sort
+      map { |comment| comment.author.to_s }.uniq.sort
     end
 
     # The relationships required by this object
     # @return [Array]
     def relationships
       [Relationship.new(self, VML_DRAWING_R, "../#{vml_drawing.pn}"),
-       Relationship.new(self, COMMENT_R, "../#{pn}"),
-       Relationship.new(self, COMMENT_R_NULL, "NULL")]
+       Relationship.new(self, COMMENT_R, "../#{pn}")]
     end
 
     # serialize the object
@@ -66,14 +65,12 @@ module Axlsx
     # @return [String]
     def to_xml_string(str="")
       str << '<?xml version="1.0" encoding="UTF-8"?>'
-      str << '<comments xmlns="' << XML_NS << '">'
-      str << '<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>'
-      str << '<commentList>'
-      @list.each do |comment|
+      str << '</authors><commentList>'
+      each do |comment|
         comment.to_xml_string str
       end
       str << '</commentList></comments>'

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

@@ -74,7 +74,7 @@ module Axlsx
     # @param [String] str
     # @return [String]
     def to_xml_string(str = '')
-      str << '<conditionalFormatting sqref="' << sqref << '">'
+      str << ('<conditionalFormatting sqref="' << sqref << '">')
       str << rules.collect{ |rule| rule.to_xml_string }.join(' ')
       str << '</conditionalFormatting>'
     end

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

@@ -210,7 +210,7 @@ module Axlsx
       str << '<cfRule '
       serialized_attributes str
       str << '>'
-      str << '<formula>' << [*self.formula].join('</formula><formula>') << '</formula>' if @formula
+      str << ('<formula>' << [*self.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/data_bar.rb

@@ -107,12 +107,10 @@ module Axlsx
     # @param [String] str
     # @return [String]
     def to_xml_string(str="")
-      str << '<dataBar '
-      serialized_attributes str
-      str << '>'
-      value_objects.to_xml_string(str)
-      self.color.to_xml_string(str)
-      str << '</dataBar>'
+      serialized_tag('dataBar', str) do
+        value_objects.to_xml_string(str)
+        self.color.to_xml_string(str)
+      end
     end
 
     private