caxlsx 2.0.2 → 3.0.0

data/lib/axlsx/workbook/defined_names.rb

@@ -11,8 +11,8 @@ module Axlsx
     # @param [String] str
     # @return [String]
     def to_xml_string(str = '')
-      return if @list.empty?
-      str << "<definedNames>"
+      return if empty?
+      str << '<definedNames>'
       each { |defined_name| defined_name.to_xml_string(str) }
       str << '</definedNames>'
     end

data/lib/axlsx/workbook/shared_strings_table.rb

@@ -38,7 +38,7 @@ module Axlsx
       @xml_space = xml_space
       @unique_cells = {}
       @shared_xml_string = ""
-      shareable_cells = cells.flatten.select{ |cell| cell.plain_string? }
+      shareable_cells = cells.flatten.select{ |cell| cell.plain_string? || cell.contains_rich_text? }
       @count = shareable_cells.size
       resolve(shareable_cells)
     end
@@ -47,10 +47,10 @@ module Axlsx
     # @param [String] str
     # @return [String]
     def to_xml_string(str='')
-      str << '<?xml version="1.0" encoding="UTF-8"?><sst xmlns="' << XML_NS << '"'
-      str << ' count="' << @count.to_s << '" uniqueCount="' << unique_count.to_s << '"'
-      str << ' xml:space="' << xml_space.to_s << '">' << @shared_xml_string << '</sst>'
-      str = Axlsx::sanitize(str)
+      Axlsx::sanitize(@shared_xml_string)
+      str << ('<?xml version="1.0" encoding="UTF-8"?><sst xmlns="' << XML_NS << '"')
+      str << (' count="' << @count.to_s << '" uniqueCount="' << unique_count.to_s << '"')
+      str << (' xml:space="' << xml_space.to_s << '">' << @shared_xml_string << '</sst>')
     end
 
     private

data/lib/axlsx/workbook/workbook.rb

@@ -5,10 +5,13 @@ require 'axlsx/workbook/worksheet/auto_filter/auto_filter.rb'
 require 'axlsx/workbook/worksheet/date_time_converter.rb'
 require 'axlsx/workbook/worksheet/protected_range.rb'
 require 'axlsx/workbook/worksheet/protected_ranges.rb'
+require 'axlsx/workbook/worksheet/rich_text_run'
+require 'axlsx/workbook/worksheet/rich_text'
 require 'axlsx/workbook/worksheet/cell_serializer.rb'
 require 'axlsx/workbook/worksheet/cell.rb'
 require 'axlsx/workbook/worksheet/page_margins.rb'
 require 'axlsx/workbook/worksheet/page_set_up_pr.rb'
+require 'axlsx/workbook/worksheet/outline_pr.rb'
 require 'axlsx/workbook/worksheet/page_setup.rb'
 require 'axlsx/workbook/worksheet/header_footer.rb'
 require 'axlsx/workbook/worksheet/print_options.rb'
@@ -37,7 +40,8 @@ require 'axlsx/workbook/worksheet/worksheet_hyperlinks'
 require 'axlsx/workbook/worksheet/break'
 require 'axlsx/workbook/worksheet/row_breaks'
 require 'axlsx/workbook/worksheet/col_breaks'
-
+require 'axlsx/workbook/workbook_view'
+require 'axlsx/workbook/workbook_views'
 
 
 require 'axlsx/workbook/worksheet/worksheet.rb'
@@ -93,6 +97,15 @@ require 'axlsx/workbook/worksheet/selection.rb'
       @use_shared_strings = v
     end
 
+    # If true reverse the order in which the workbook is serialized
+    # @return [Boolean]
+    attr_reader :is_reversed
+
+    def is_reversed=(v)
+      Axlsx::validate_boolean(v)
+      @is_reversed = v
+    end
+
 
    # A collection of worksheets associated with this workbook.
     # @note The recommended way to manage worksheets is add_worksheet
@@ -139,6 +152,10 @@ require 'axlsx/workbook/worksheet/selection.rb'
     # @return [SimpleTypedList]
     attr_reader :pivot_tables
 
+    # A collection of views for this workbook
+    def views
+      @views ||= WorkbookViews.new
+    end
 
     # A collection of defined names for this workbook
     # @note The recommended way to manage defined names is Workbook#add_defined_name
@@ -263,6 +280,14 @@ require 'axlsx/workbook/worksheet/selection.rb'
       worksheet
     end
 
+    # Adds a new WorkbookView
+    # @return WorkbookViews
+    # @option options [Hash] options passed into the added WorkbookView
+    # @see WorkbookView#initialize
+    def add_view(options={})
+      views << WorkbookView.new(options)
+    end
+
     # Adds a defined name to this workbook
     # @return [DefinedName]
     # @param [String] formula @see DefinedName
@@ -283,7 +308,7 @@ require 'axlsx/workbook/worksheet/selection.rb'
       end
       r << Relationship.new(self, STYLES_R,  STYLES_PN)
       if use_shared_strings
-          r << Relationship.new(self, SHARED_STRINGS_R,  SHARED_STRINGS_PN)
+          r << Relationship.new(self, SHARED_STRINGS_R, SHARED_STRINGS_PN)
       end
       r
     end
@@ -327,23 +352,23 @@ require 'axlsx/workbook/worksheet/selection.rb'
     # @param [String] str
     # @return [String]
     def to_xml_string(str='')
-      add_worksheet unless worksheets.size > 0
+      add_worksheet(name: 'Sheet1') unless worksheets.size > 0
       str << '<?xml version="1.0" encoding="UTF-8"?>'
-      str << '<workbook xmlns="' << XML_NS << '" xmlns:r="' << XML_NS_R << '">'
-      str << '<workbookPr date1904="' << @@date1904.to_s << '"/>'
+      str << ('<workbook xmlns="' << XML_NS << '" xmlns:r="' << XML_NS_R << '">')
+      str << ('<workbookPr date1904="' << @@date1904.to_s << '"/>')
+      views.to_xml_string(str)
       str << '<sheets>'
-      @worksheets.each_with_index do |sheet, index|
-        str << '<sheet name="' << sheet.name << '" sheetId="' << (index+1).to_s << '" r:id="' << sheet.rId << '"/>'
-        if defined_name = sheet.auto_filter.defined_name
-          add_defined_name defined_name, :name => '_xlnm._FilterDatabase', :local_sheet_id => index, :hidden => 1
-        end
+      if is_reversed
+        worksheets.reverse_each { |sheet| sheet.to_sheet_node_xml_string(str) }
+      else
+        worksheets.each { |sheet| sheet.to_sheet_node_xml_string(str) }
       end
       str << '</sheets>'
       defined_names.to_xml_string(str)
       unless pivot_tables.empty?
         str << '<pivotCaches>'
         pivot_tables.each do |pivot_table|
-          str << '<pivotCache cacheId="' << pivot_table.cache_definition.cache_id.to_s << '" r:id="' << pivot_table.cache_definition.rId << '"/>'
+          str << ('<pivotCache cacheId="' << pivot_table.cache_definition.cache_id.to_s << '" r:id="' << pivot_table.cache_definition.rId << '"/>')
         end
         str << '</pivotCaches>'
       end

data/lib/axlsx/workbook/workbook_view.rb

@@ -0,0 +1,80 @@
+# <xsd:complexType name="CT_BookView">
+#     <xsd:sequence>
+#       <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/>
+#     </xsd:sequence>
+#     <xsd:attribute name="visibility" type="ST_Visibility" use="optional" default="visible"/>
+#     <xsd:attribute name="minimized" type="xsd:boolean" use="optional" default="false"/>
+#     <xsd:attribute name="showHorizontalScroll" type="xsd:boolean" use="optional" default="true"/>
+#     <xsd:attribute name="showVerticalScroll" type="xsd:boolean" use="optional" default="true"/>
+#     <xsd:attribute name="showSheetTabs" type="xsd:boolean" use="optional" default="true"/>
+#     <xsd:attribute name="xWindow" type="xsd:int" use="optional"/>
+#     <xsd:attribute name="yWindow" type="xsd:int" use="optional"/>
+#     <xsd:attribute name="windowWidth" type="xsd:unsignedInt" use="optional"/>
+#     <xsd:attribute name="windowHeight" type="xsd:unsignedInt" use="optional"/>
+#     <xsd:attribute name="tabRatio" type="xsd:unsignedInt" use="optional" default="600"/>
+#     <xsd:attribute name="firstSheet" type="xsd:unsignedInt" use="optional" default="0"/>
+#     <xsd:attribute name="activeTab" type="xsd:unsignedInt" use="optional" default="0"/>
+#     <xsd:attribute name="autoFilterDateGrouping" type="xsd:boolean" use="optional"
+#     default="true"/>
+# </xsd:complexType>
+
+module Axlsx
+
+  # A BookView defines the display properties for a workbook.
+  # Units for window widths and other dimensions are expressed in twips.
+  # Twip measurements are portable between different display resolutions.
+  # The formula is (screen pixels) * (20 * 72) / (logical device dpi),
+  # where the logical device dpi can be different for x and y coordinates.
+  class WorkbookView
+
+    include Axlsx::SerializedAttributes
+    include Axlsx::OptionsParser
+    include Axlsx::Accessors
+
+
+    # Creates a new BookView object
+    # @param [Hash] options  A hash of key/value pairs that will be mapped to this instances attributes.
+    # @option [Symbol] visibility Specifies visible state of the workbook window. The default value for this attribute is :visible.
+    # @option [Boolean] minimized Specifies a boolean value that indicates whether the workbook window is minimized.
+    # @option [Boolean] show_horizontal_scroll Specifies a boolean value that indicates whether to display the horizontal scroll bar in the user interface.
+    # @option [Boolean] show_vertical_scroll Specifies a boolean value that indicates whether to display the vertical scroll bar.
+    # @option [Boolean] show_sheet_tabs Specifies a boolean value that indicates whether to display the sheet tabs in the user interface.
+    # @option [Integer] tab_ratio Specifies ratio between the workbook tabs bar and the horizontal scroll bar.
+    # @option [Integer] first_sheet Specifies the index to the first sheet in this book view.
+    # @option [Integer] active_tab Specifies an unsignedInt that contains the index to the active sheet in this book view.
+    # @option [Integer] x_window Specifies the X coordinate for the upper left corner of the workbook window. The unit of measurement for this value is twips.
+    # @option [Integer] y_window Specifies the Y coordinate for the upper left corner of the workbook window. The unit of measurement for this value is twips.
+    # @option [Integer] window_width Specifies the width of the workbook window. The unit of measurement for this value is twips.
+    # @option [Integer] window_height Specifies the height of the workbook window. The unit of measurement for this value is twips.
+    # @option [Boolean] auto_filter_date_grouping Specifies a boolean value that indicates whether to group dates when presenting the user with filtering options in the user interface.
+    def initialize(options={})
+      parse_options options
+      yield self if block_given?
+    end
+
+
+    unsigned_int_attr_accessor :x_window, :y_window, :window_width, :window_height,
+                               :tab_ratio, :first_sheet, :active_tab
+
+    validated_attr_accessor  [:visibility], :validate_view_visibility
+
+    serializable_attributes :visibility, :minimized,
+                            :show_horizontal_scroll, :show_vertical_scroll,
+                            :show_sheet_tabs, :tab_ratio, :first_sheet, :active_tab,
+                            :x_window, :y_window, :window_width, :window_height,
+                            :auto_filter_date_grouping
+
+    boolean_attr_accessor :minimized, :show_horizontal_scroll, :show_vertical_scroll,
+                          :show_sheet_tabs, :auto_filter_date_grouping
+
+
+    # Serialize the WorkbookView
+    # @param [String] str
+    # @return [String]
+    def to_xml_string(str = '')
+       str << '<workbookView '
+       serialized_attributes str
+       str << '></workbookView>'
+    end
+  end
+end

data/lib/axlsx/workbook/workbook_views.rb

@@ -0,0 +1,22 @@
+module Axlsx
+  # a simple types list of BookView objects
+  class WorkbookViews < SimpleTypedList
+
+    # creates the book views object
+    def initialize
+      super WorkbookView
+    end
+
+    # Serialize to xml
+    # @param [String] str
+    # @return [String]
+    def to_xml_string(str = '')
+      return if empty?
+      str << "<bookViews>"
+      each { |view| view.to_xml_string(str) }
+      str << '</bookViews>'
+    end
+  end
+end
+
+

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

@@ -47,8 +47,8 @@ module Axlsx
       columns.last
     end
 
-    # actually performs the filtering of rows who's cells do not 
-    # match the filter.  
+    # actually performs the filtering of rows who's cells do not
+    # match the filter.
     def apply
       first_cell, last_cell = range.split(':')
       start_point = Axlsx::name_to_indices(first_cell)

data/lib/axlsx/workbook/worksheet/auto_filter/filters.rb

@@ -237,9 +237,7 @@ include Axlsx::SerializedAttributes
       # Serialize the object to xml
       # @param [String] str The string object this serialization will be concatenated to.
       def to_xml_string(str = '')
-        str << '<dateGroupItem '
-        serialized_attributes str
-        str << '/>'
+        serialized_tag('dateGroupItem', str)
       end
     end
   end

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

@@ -28,9 +28,7 @@ module Axlsx
 
     # serializes the break to xml
     def to_xml_string(str='')
-      str << '<brk '
-      serialized_attributes str
-      str << '></brk>'
+      serialized_tag('brk', str)
     end
   end
 end

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

@@ -30,17 +30,24 @@ 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
-    def initialize(row, value="", options={})
-      self.row=row
-      @value = nil
-      #@value = @font_name = @charset = @family = @b = @i = @strike = @outline = @shadow = nil
-      #@formula_value = @condense = @u = @vertAlign = @sz = @color = @scheme = @extend = @ssti = nil
-      @styles = row.worksheet.workbook.styles
-      @row.cells << self
-      parse_options options
-      @style ||= 0
-      @type ||= cell_type_from_value(value)
-      @value = cast_value(value)
+    def initialize(row, value = nil, options = {})
+      @row = row
+      # Do not use instance vars if not needed to use less RAM
+      # And do not call parse_options on frequently used options
+      # to get less GC cycles
+      type = options.delete(:type) || cell_type_from_value(value)
+      self.type = type unless type == :string
+
+
+      val = options.delete(:style)
+      self.style = val unless val.nil? || val == 0
+      val = options.delete(:formula_value)
+      self.formula_value = val unless val.nil?
+
+      parse_options(options)
+
+      self.value = value
+      value.cell = self if contains_rich_text?
     end
 
     # this is the cached value for formula cells. If you want the values to render in iOS/Mac OSX preview
@@ -53,21 +60,27 @@ module Axlsx
     # needs to define bla=(v) and bla methods on the class that hook into a
     # set_attr method that kicks the suplied validator and updates the instance_variable
     # for the key
-    INLINE_STYLES = ['value', 'type', 'font_name', 'charset',
-                     'family', 'b', 'i', 'strike','outline',
-                     'shadow', 'condense', 'extend', 'u',
-                     'vertAlign', 'sz', 'color', 'scheme']
+    INLINE_STYLES = [:value, :type, :font_name, :charset,
+                     :family, :b, :i, :strike, :outline,
+                     :shadow, :condense, :extend, :u,
+                     :vertAlign, :sz, :color, :scheme].freeze
+
+    # An array of valid cell types
+    CELL_TYPES = [:date, :time, :float, :integer, :richtext,
+                  :string, :boolean, :iso_8601, :text].freeze
 
     # The index of the cellXfs item to be applied to this cell.
     # @return [Integer]
     # @see Axlsx::Styles
-    attr_reader :style
+    def style
+      defined?(@style) ? @style : 0
+    end
 
     # The row this cell belongs to.
     # @return [Row]
     attr_reader :row
 
-    # The cell's data type. Currently only six types are supported, :date, :time, :float, :integer, :string and :boolean.
+    # The cell's data type.
     # Changing the type for a cell will recast the value into that type. If no type option is specified in the constructor, the type is
     # automatically determed.
     # @see Cell#cell_type_from_value
@@ -78,18 +91,21 @@ module Axlsx
     #   :string to :integer or :float, type conversions always return 0 or 0.0
     #   :string, :integer, or :float to :time conversions always return the original value as a string and set the cells type to :string.
     #  No support is currently implemented for parsing time strings.
-    attr_reader :type
+    def type
+      defined?(@type) ? @type : :string
+    end
+
     # @see type
     def type=(v)
-      RestrictionValidator.validate "Cell.type", [:date, :time, :float, :integer, :string, :boolean, :iso_8601], v
-      @type=v
-      self.value = @value unless @value.nil?
+      RestrictionValidator.validate :cell_type, CELL_TYPES, v
+      @type = v
+      self.value = @value unless !defined?(@value) || @value.nil?
     end
 
-
     # The value of this cell.
     # @return [String, Integer, Float, Time, Boolean] casted value based on cell's type attribute.
     attr_reader :value
+
     # @see value
     def value=(v)
       #TODO: consider doing value based type determination first?
@@ -99,16 +115,20 @@ module Axlsx
     # Indicates that the cell has one or more of the custom cell styles applied.
     # @return [Boolean]
     def is_text_run?
-      @is_text_run ||= false
+      defined?(@is_text_run) && @is_text_run && !contains_rich_text?
+    end
+
+    def contains_rich_text?
+      type == :richtext
     end
 
     # Indicates if the cell is good for shared string table
     def plain_string?
-      @type == :string &&         # String typed
+      (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
+        !@value.start_with?(?=)  # Not a formula
     end
 
     # The inline font_name property for the cell
@@ -231,7 +251,7 @@ module Axlsx
     attr_reader :vertAlign
     # @see vertAlign
     def vertAlign=(v)
-      RestrictionValidator.validate "Cell.vertAlign", [:baseline, :subscript, :superscript], v
+      RestrictionValidator.validate :cell_vertAlign, [:baseline, :subscript, :superscript], v
       set_run_style nil, :vertAlign, v
     end
 
@@ -241,7 +261,7 @@ module Axlsx
     attr_reader :scheme
     # @see scheme
     def scheme=(v)
-      RestrictionValidator.validate "Cell.schema", [:none, :major, :minor], v
+      RestrictionValidator.validate :cell_scheme, [:none, :major, :minor], v
       set_run_style nil, :scheme, v
     end
 
@@ -251,14 +271,14 @@ module Axlsx
 
     # @return [Integer] The index of the cell in the containing row.
     def index
-      @row.cells.index(self)
+      @row.index(self)
     end
 
     # @return [String] The alpha(column)numeric(row) reference for this sell.
     # @example Relative Cell Reference
     #   ws.rows.first.cells.first.r #=> "A1"
     def r
-      Axlsx::cell_r index, @row.index
+      Axlsx::cell_r index, @row.row_index
     end
 
     # @return [String] The absolute alpha(column)numeric(row) reference for this sell.
@@ -272,26 +292,26 @@ module Axlsx
     # @raise [ArgumentError] Invalid cellXfs id if the value provided is not within cellXfs items range.
     def style=(v)
       Axlsx::validate_unsigned_int(v)
-      count = @styles.cellXfs.size
+      count = styles.cellXfs.size
       raise ArgumentError, "Invalid cellXfs id" unless v < count
       @style = v
     end
 
-    # @return [Array] of x/y coordinates in the cheet for this cell.
+    # @return [Array] of x/y coordinates in the sheet for this cell.
     def pos
-      [index, row.index]
+      [index, row.row_index]
     end
 
     # Merges all the cells in a range created between this cell and the cell or string name for a cell  provided
     # @see worksheet.merge_cells
     # @param [Cell, String] target The last cell, or str ref for the cell in the merge range
     def merge(target)
-      range_end = if target.is_a?(String)
-                    target
-                  elsif(target.is_a?(Cell))
-                    target.r
-                  end
-      self.row.worksheet.merge_cells "#{self.r}:#{range_end}" unless range_end.nil?
+      start, stop = if target.is_a?(String)
+                      [self.r, target]
+                    elsif(target.is_a?(Cell))
+                      Axlsx.sort_cells([self, target]).map { |c| c.r }
+                    end
+      self.row.worksheet.merge_cells "#{start}:#{stop}" unless stop.nil?
     end
 
     # Serializes the cell
@@ -304,17 +324,11 @@ module Axlsx
     end
 
     def is_formula?
-      @type == :string && @value.to_s.start_with?('=')
+      type == :string && @value.to_s.start_with?(?=)
     end
 
-    # This is still not perfect...
-    #  - scaling is not linear as font sizes increst
-    #  - different fonts have different mdw and char widths
-    def autowidth
-      return if is_formula? || value == nil
-      mdw = 1.78 #This is the widest width of 0..9 in arial@10px)
-      font_scale = (font_size/10.0).to_f
-      ((value.to_s.count(Worksheet.thin_chars) * mdw + 5) / mdw * 256) / 256.0 * font_scale
+    def is_array_formula?
+      type == :string && @value.to_s.start_with?('{=') && @value.to_s.end_with?('}')
     end
 
     # returns the absolute or relative string style reference for
@@ -326,21 +340,71 @@ module Axlsx
       absolute ? r_abs : r
     end
 
+    # Creates a defined name in the workbook for this cell.
+    def name=(label)
+      row.worksheet.workbook.add_defined_name "#{row.worksheet.name}!#{r_abs}", name: label
+      @name = label
+    end
+
+    # returns the name of the cell
+    attr_reader :name
+
+    # Attempts to determine the correct width for this cell's content
+    # @return [Float]
+    def autowidth
+      return if is_formula? || value.nil?
+      if contains_rich_text?
+        string_width('', font_size) + value.autowidth
+      elsif styles.cellXfs[style].alignment && styles.cellXfs[style].alignment.wrap_text
+        max_width = 0
+        value.to_s.split(/\r?\n/).each do |line|
+          width = string_width(line, font_size)
+          max_width = width if width > max_width
+        end
+        max_width
+      else
+        string_width(value, font_size)
+      end
+    end
+
+    # Returns the sanatized value
+    # TODO find a better way to do this as it accounts for 30% of
+    # processing time in benchmarking...
+    def clean_value
+      if (type == :string || type == :text) && !Axlsx::trust_input
+        Axlsx::sanitize(::CGI.escapeHTML(@value.to_s))
+      else
+        @value.to_s
+      end
+    end
+
     private
 
+    def styles
+      row.worksheet.styles
+    end
+
+    # Returns the width of a string according to the current style
+    # This is still not perfect...
+    #  - scaling is not linear as font sizes increase
+    def string_width(string, font_size)
+      font_scale = font_size / 10.0
+      (string.to_s.count(Worksheet::THIN_CHARS) + 3.0) * font_scale
+    end
+
     # we scale the font size if bold style is applied to either the style font or
     # the cell itself. Yes, it is a bit of a hack, but it is much better than using
     # imagemagick and loading metrics for every character.
     def font_size
-      font = @styles.fonts[@styles.cellXfs[style].fontId] || @styles.fonts[0]
-      size_from_styles = (font.b || b) ? font.sz * 1.5 : font.sz
-      sz || size_from_styles
+      return sz if sz
+      font = styles.fonts[styles.cellXfs[style].fontId] || styles.fonts[0]
+      (font.b || (defined?(@b) && @b)) ? (font.sz * 1.5) : font.sz
     end
 
     # Utility method for setting inline style attributes
-    def set_run_style( validator, attr, value)
-      return unless INLINE_STYLES.include?(attr.to_s)
-      Axlsx.send(validator, value) unless validator == nil
+    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
       @is_text_run = true
     end
@@ -351,9 +415,6 @@ module Axlsx
       @ssti = v
     end
 
-    # assigns the owning row for this cell.
-    def row=(v) @row=v end
-
     # Determines the cell type based on the cell value.
     # @note This is only used when a cell is created but no :type option is specified, the following rules apply:
     #   1. If the value is an instance of Date, the type is set to :date
@@ -369,15 +430,14 @@ module Axlsx
         :time
       elsif v.is_a?(TrueClass) || v.is_a?(FalseClass)
         :boolean
-      elsif v.to_s =~ /\A[+-]?\d+?\Z/ #numeric
+      elsif v.to_s =~ Axlsx::NUMERIC_REGEX
         :integer
-      elsif v.to_s =~ /\A[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?\Z/ #float
+      elsif v.to_s =~ Axlsx::FLOAT_REGEX
         :float
-        # \A(-?(?:[1-9][0-9]*)?[0-9]{4})-(1[0-2]|0[1-9])-(3[0-1]|0[1-9]|[1-2][0-9])
-        # T(2[0-3]|[0-1][0-9]):([0-5][0-9]):([0-5][0-9])(\.[0-9]+)?
-        # (Z|[+-](?:2[0-3]|[0-1][0-9]):[0-5][0-9])?\Z
-      elsif v.to_s =~/\A(-?(?:[1-9][0-9]*)?[0-9]{4})-(1[0-2]|0[1-9])-(3[0-1]|0[1-9]|[1-2][0-9])T(2[0-3]|[0-1][0-9]):([0-5][0-9]):([0-5][0-9])(\.[0-9]+)?(Z|[+-](?:2[0-3]|[0-1][0-9]):[0-5][0-9])?\Z/
+      elsif v.to_s =~ Axlsx::ISO_8601_REGEX
         :iso_8601
+      elsif v.is_a? RichText
+        :richtext
       else
         :string
       end
@@ -388,27 +448,29 @@ 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 nil if v.nil?
-      if @type == :date
+      return v if v.is_a?(RichText) || v.nil?
+      case type
+      when :date
         self.style = STYLE_DATE if self.style == 0
         v
-      elsif (@type == :time && v.is_a?(Time)) || (@type == :time && v.respond_to?(:to_time))
+      when :time
         self.style = STYLE_DATE if self.style == 0
-        v.respond_to?(:to_time) ? v.to_time : v
-      elsif @type == :float
+        if !v.is_a?(Time) && v.respond_to?(:to_time)
+          v.to_time
+        else
+          v
+        end
+      when :float
         v.to_f
-      elsif @type == :integer
+      when :integer
         v.to_i
-      elsif @type == :boolean
+      when :boolean
         v ? 1 : 0
-      elsif @type == :iso_8601
+      when :iso_8601
         #consumer is responsible for ensuring the iso_8601 format when specifying this type
         v
       else
-        @type = :string
-        # TODO find a better way to do this as it accounts for 30% of
-        # processing time in benchmarking...
-        Axlsx::trust_input ? v.to_s : ::CGI.escapeHTML(v.to_s)
+        v.to_s
       end
     end