axlsx 2.0.1 → 3.0.0.pre

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
 

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

@@ -122,22 +122,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 
+      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