axlsx 1.0.11 → 1.0.12

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

@@ -1,340 +0,0 @@
-# -*- coding: utf-8 -*-
-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.
-  # @example Manually creating and manipulating Cell objects
-  #   ws = Workbook.new.add_worksheet 
-  #   # This is the simple, and recommended way to create cells. Data types will automatically be determined for you.
-  #   ws.add_row :values => [1,"fish",Time.now]
-  #
-  #   # but you can also do this
-  #   r = ws.add_row
-  #   r.add_cell 1
-  # 
-  #   # or even this
-  #   r = ws.add_row
-  #   c = Cell.new row, 1, :value=>integer
-  #
-  #   # cells can also be accessed via Row#cells. The example here changes the cells type, which will automatically updated the value from 1 to 1.0
-  #   r.cells.last.type = :float
-  # 
-  # @note The recommended way to generate cells is via Worksheet#add_row
-  # 
-  # @see Worksheet#add_row
-  class Cell
-
-    # The index of the cellXfs item to be applied to this cell.
-    # @return [Integer] 
-    # @see Axlsx::Styles
-    attr_reader :style
-
-    # The row this cell belongs to.
-    # @return [Row]
-    attr_reader :row
-    
-    # The cell's data type. Currently only four types are supported, :time, :float, :integer and :string.
-    # 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
-    # @return [Symbol] The type of data this cell's value is cast to. 
-    # @raise [ArgumentExeption] Cell.type must be one of [:time, :float, :integer, :string]
-    # @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 coversions 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
-    # @see type
-    def type=(v) 
-      RestrictionValidator.validate "Cell.type", [:time, :float, :integer, :string], v      
-      @type=v 
-      self.value = @value
-    end
-
-
-    # The value of this cell.
-    # @return [String, Integer, Float, Time] casted value based on cell's type attribute.
-    attr_reader :value
-    # @see value
-    def value=(v)
-      #TODO: consider doing value based type determination first?
-      @value = cast_value(v)
-    end
-    
-    # The inline font_name property for the cell
-    # @return [String]
-    attr_reader :font_name
-    # @see font_name
-    def font_name=(v) Axlsx::validate_string(v); @font_name = v; end
-
-    # The inline charset property for the cell
-    # @return [String]
-    attr_reader :charset
-    # @see charset
-    def charset=(v) Axlsx::validate_unsigned_int(v); @charset = v; end
-
-    # The inline family property for the cell
-    # @return [String]
-    attr_reader :family
-    # @see family
-    def family=(v) Axlsx::validate_string(v); @family = v; end
-
-    # The inline bold property for the cell
-    # @return [Boolean]
-    attr_reader :b
-    # @see b
-    def b=(v) Axlsx::validate_boolean(v); @b = v; end
-
-    # The inline italic property for the cell
-    # @return [Boolean]
-    attr_reader :i
-    # @see i
-    def i=(v) Axlsx::validate_boolean(v); @i = v; end
-
-    # The inline strike property for the cell
-    # @return [Boolean]
-    attr_reader :strike
-    # @see strike
-    def strike=(v) Axlsx::validate_boolean(v); @strike = v; end
-
-    # The inline outline property for the cell
-    # @return [Boolean]
-    attr_reader :outline
-    # @see outline
-    def outline=(v) Axlsx::validate_boolean(v); @outline = v; end
-
-    # The inline shadow property for the cell
-    # @return [Boolean]
-    attr_reader :shadow
-    # @see shadow
-    def shadow=(v) Axlsx::validate_boolean(v); @shadow = v; end
-
-    # The inline condense property for the cell
-    # @return [Boolean]
-    attr_reader :condense
-    # @see condense
-    def condense=(v) Axlsx::validate_boolean(v); @condense = v; end
-
-    # The inline extend property for the cell
-    # @return [Boolean]
-    attr_reader :extend
-    # @see extend
-    def extend=(v) Axlsx::validate_boolean(v); @extend = v; end
-
-    # The inline underline property for the cell
-    # @return [Boolean]
-    attr_reader :u
-    # @see u
-    def u=(v) Axlsx::validate_boolean(v); @u = v; end
-
-    # The inline color property for the cell
-    # @return [Color]
-    attr_reader :color
-    # @param [String] The 8 character representation for an rgb color #FFFFFFFF"
-    def color=(v) 
-      @color = v.is_a?(Color) ? v : Color.new(:rgb=>v)
-    end
-
-    # The inline sz property for the cell
-    # @return [Boolean]
-    attr_reader :sz
-    # @see sz
-    def sz=(v) Axlsx::validate_unsigned_int(v); @sz = v; end
-
-    # The inline vertical alignment property for the cell
-    # 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; @vertAlign = v; end
-
-    # The inline scheme property for the cell
-    # this must be one of [:none, major, minor]
-    # @return [Symbol]
-    attr_reader :scheme
-    # @see scheme
-    def scheme=(v) RestrictionValidator.validate "Cell.schema", [:none, :major, :minor], v; @scheme = v; end
-
-    # @param [Row] row The row this cell belongs to.
-    # @param [Any] value The value associated with this cell. 
-    # @option options [Symbol] type The intended data type for this cell. If not specified the data type will be determined internally based on the vlue provided.
-    # @option options [Integer] style The index of the cellXfs item to be applied to this cell. If not specified, the default style (0) will be applied.
-    # @option options [String] font_name
-    # @option options [Integer] charset
-    # @option options [String] family
-    # @option options [Boolean] b
-    # @option options [Boolean] i
-    # @option options [Boolean] strike
-    # @option options [Boolean] outline
-    # @option options [Boolean] shadow
-    # @option options [Boolean] condense
-    # @option options [Boolean] extend
-    # @option options [Boolean] u
-    # @option options [Symbol] vertAlign must be one of :baseline, :subscript, :superscript
-    # @option options [Integer] sz
-    # @option options [String] color an 8 letter rgb specification
-    # @option options [Symbol] scheme must be one of :none, major, :minor
-    def initialize(row, value="", options={})
-      self.row=row
-      @styles = row.worksheet.workbook.styles
-      @style = 0 
-      @type = cell_type_from_value(value)
-      @row.cells << self      
-      options.each do |o|
-        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
-      end
-      @value = cast_value(value)
-    end
-
-    # @return [Integer] The index of the cell in the containing row.
-    def index
-      @row.cells.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
-      "#{col_ref}#{@row.index+1}"      
-    end
-
-    # @return [String] The absolute alpha(column)numeric(row) reference for this sell.
-    # @example Absolute Cell Reference
-    #   ws.rows.first.cells.first.r #=> "$A$1" 
-    def r_abs
-      "$#{r.split('').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)
-      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.
-    def pos
-      [index, row.index]
-    end
-
-    # Serializes the cell
-    # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
-    # @return [String] xml text for the cell
-    # @note
-    #   Shared Strings are not used in this library. All values are set directly in the each sheet.
-    def to_xml(xml)
-      # Both 1.8 and 1.9 return the same 'fast_xf'
-      # &#12491;&#12507;&#12531;&#12468;
-      # &#12491;&#12507;&#12531;&#12468;
-      
-      # however nokogiri does a nice 'force_encoding' which we shall remove!
-      if @type == :string 
-        #parse formula
-        if @value.start_with?('=')
-          xml.c(:r => r, :s=>style) {
-            xml.f @value.to_s.gsub('=', '')
-          }
-        else
-          #parse standard string
-          #xml.c(:r => r, :t=>:inlineStr, :s=>style) {
-          #  xml.is { xml.t @value.to_s } 
-          #}
-          #parse styled string
-          xml.c(:r => r, :s=>style) {
-            xml.is {
-              xml.r {
-                xml.rPr {
-                  xml.rFont(:val=>@font_name) if @font_name
-                  xml.charset(:val=>@charset) if @charset
-                  xml.family(:val=>@family) if @family
-                  xml.b(:val=>@b) if @b
-                  xml.i(:val=>@i) if @i
-                  xml.strike(:val=>@strike) if @strike
-                  xml.outline(:val=>@outline) if @outline
-                  xml.shadow(:val=>@shadow) if @shadow
-                  xml.condense(:val=>@condense) if @condense
-                  xml.extend(:val=>@extend) if @extend
-                  @color.to_xml(xml) if @color
-                  xml.sz(:val=>@sz) if @sz
-                  xml.u(:val=>@u) if @u
-                  # :baseline, :subscript, :superscript
-                  xml.vertAlign(:val=>@vertAlign) if @verAlign
-                  # :none, major, :minor
-                  xml.scheme(:val=>@scheme) if @scheme
-                }
-                xml.t @value.to_s
-              }
-            }
-          }
-        end
-
-      else
-        xml.c(:r => r, :s => style) { xml.v value }
-      end
-    end
-
-
-    private 
-
-    # assigns the owning row for this cell.
-    def row=(v) DataTypeValidator.validate "Cell.row", Row, v; @row=v end
-    
-    # converts the column index into alphabetical values.
-    # @note This follows the standard spreadsheet convention of naming columns A to Z, followed by AA to AZ etc.
-    # @return [String]
-    def col_ref
-      chars = []
-      index = self.index
-      while index >= 26 do
-        chars << ((index % 26) + 65).chr
-        index /= 26
-      end
-      chars << ((chars.empty? ? index : index-1) + 65).chr
-      chars.reverse.join
-    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 Time, the type is set to :time
-    #   2. :float and :integer types are determined by regular expression matching.
-    #   3. Anything that does not meet either of the above is determined to be :string.
-    # @return [Symbol] The determined type
-    def cell_type_from_value(v)      
-      if v.is_a? Time
-        :time
-      elsif v.to_s.match(/\A[+-]?\d+?\Z/) #numeric
-        :integer
-      elsif v.to_s.match(/\A[+-]?\d+\.\d+?\Z/) #float
-        :float
-      else
-        :string
-      end
-    end
-
-    # Cast the value into this cells data type. 
-    # @note 
-    #   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)
-      if (@type == :time && v.is_a?(Time)) || (@type == :time && v.respond_to?(:to_time))
-        v = v.respond_to?(:to_time) ? v.to_time : v
-        self.style = STYLE_DATE if self.style == 0
-        # Using hardcoded offsets here as some operating systems will not except a 'negative' offset from the ruby epoc.
-        # (1970)
-        epoc1900 = -2209021200 #Time.local(1900, 1, 1) 
-        epoc1904 = -2082877200 #Time.local(1904, 1, 1) 
-        epoc = Workbook.date1904 ? epoc1904 : epoc1900
-        ((v.localtime.to_f - epoc) /60.0/60.0/24.0).to_f
-      elsif @type == :float
-        v.to_f
-      elsif @type == :integer
-        v.to_i
-      else
-        @type = :string
-        v.to_s
-      end
-    end    
-  end
-end

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

@@ -1,107 +0,0 @@
-module Axlsx
-  # A Row is a single row in a worksheet.
-  # @note The recommended way to manage rows and cells is to use Worksheet#add_row
-  # @see Worksheet#add_row
-  class Row
-
-    # The worksheet this row belongs to
-    # @return [Worksheet]
-    attr_reader :worksheet
-
-    # The cells this row holds
-    # @return [SimpleTypedList]
-    attr_reader :cells
-
-    # Creates a new row. New Cell objects are created based on the values, types and style options.
-    # A new cell is created for each item in the values array. style and types options are applied as follows:
-    #   If the types option is defined and is a symbol it is applied to all the cells created.
-    #   If the types option is an array, cell types are applied by index for each cell
-    #   If the types option is not set, the cell will automatically determine its type.
-    #   If the style option is defined and is an Integer, it is applied to all cells created.
-    #   If the style option is an array, style is applied by index for each cell.
-    #   If the style option is not defined, the default style (0) is applied to each cell.
-    # @param [Worksheet] worksheet
-    # @option options [Array] values
-    # @option options [Array, Symbol] types 
-    # @option options [Array, Integer] style 
-    # @see Row#array_to_cells
-    # @see Cell
-    def initialize(worksheet, values=[], options={})
-      self.worksheet = worksheet
-      @cells = SimpleTypedList.new Cell
-      @worksheet.rows << self
-      array_to_cells(values, options)
-    end
-
-    # The index of this row in the worksheet
-    # @return [Integer]
-    def index 
-      worksheet.rows.index(self)
-    end
-    
-    # Serializes the row
-    # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
-    # @return [String]
-    def to_xml(xml)
-      xml.row(:r => index+1) { @cells.each { |cell| cell.to_xml(xml) } }
-    end
-
-    # Adds a singel sell to the row based on the data provided and updates the worksheet's autofit data.
-    # @return [Cell]
-    def add_cell(value="", options={})
-      c = Cell.new(self, value, options)
-      update_auto_fit_data
-      c
-    end
-    
-    # sets the style for every cell in this row
-    def style=(style)
-      cells.each_with_index do | cell, index |
-        s = style.is_a?(Array) ? style[index] : style
-        cell.style = s
-      end
-    end
-
-    # returns the cells in this row as an array
-    # This lets us transpose the rows into columns 
-    # @return [Array]
-    def to_ary
-      @cells.to_ary
-    end
-
-    private
-
-    # assigns the owning worksheet for this row
-    def worksheet=(v) DataTypeValidator.validate "Row.worksheet", Worksheet, v; @worksheet=v; end
-    
-    # Tell the worksheet to update autofit data for the columns based on this row's cells.
-    # @return [SimpleTypedList]
-    def update_auto_fit_data
-      worksheet.send(:update_auto_fit_data, self.cells)
-    end
-
-
-    # Converts values, types, and style options into cells and associates them with this row.
-    # A new cell is created for each item in the values array.
-    # If value option is defined and is a symbol it is applied to all the cells created.
-    # If the value option is an array, cell types are applied by index for each cell
-    # If the style option is defined and is an Integer, it is applied to all cells created.
-    # If the style option is an array, style is applied by index for each cell.
-    # @option options [Array] values
-    # @option options [Array, Symbol] types 
-    # @option options [Array, Integer] style 
-    def array_to_cells(values, options={})
-      values = values
-      DataTypeValidator.validate 'Row.array_to_cells', Array, values
-      types, style = options.delete(:types), options.delete(:style)
-      values.each_with_index do |value, index|        
-        cell_style = style.is_a?(Array) ? style[index] : style
-        options[:style] = cell_style if cell_style
-        cell_type = types.is_a?(Array)? types[index] : types
-        options[:type] = cell_type if cell_type
-        Cell.new(self, value, options)
-      end
-    end
-  end
-  
-end

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

@@ -1,278 +0,0 @@
-# -*- coding: utf-8 -*-
-module Axlsx
-  
-  # The Worksheet class represents a worksheet in the workbook. 
-  class Worksheet
-    
-    # The name of the worksheet
-    # @return [String]
-    attr_reader :name
-
-    # The workbook that owns this worksheet
-    # @return [Workbook]
-    attr_reader :workbook
-
-
-    # The rows in this worksheet
-    # @note The recommended way to manage rows is Worksheet#add_row
-    # @return [SimpleTypedList]
-    # @see Worksheet#add_row
-    attr_reader :rows
-
-    # An array of content based calculated column widths.
-    # @note a single auto fit data item is a hash with :longest => [String] and :sz=> [Integer] members.
-    # @return [Array] of Hash 
-    attr_reader :auto_fit_data
-
-    # TODO Merge Cells
-    # attr_reader :merge_cells
-    
-    # Creates a new worksheet.
-    # @note the recommended way to manage worksheets is Workbook#add_worksheet
-    # @see Workbook#add_worksheet
-    # @option options [String] name The name of this sheet.
-    def initialize(wb, options={})
-      @drawing = nil
-      @rows = SimpleTypedList.new Row
-      self.workbook = wb
-      @workbook.worksheets << self
-      @auto_fit_data = []
-      self.name = options[:name] || "Sheet" + (index+1).to_s
-      @magick_draw = Magick::Draw.new
-      @cols = SimpleTypedList.new Cell
-    end
-
-    # Returns the cell or cells defined using excel style A1:B3 references.
-    # @param [String] cell_def the string defining the cell or range of cells
-    # @return [Cell, Array]
-    def [](cell_def)
-      parts = cell_def.split(':')
-      first = name_to_cell parts[0]
-
-      if parts.size == 1
-        first
-      else
-        cells = []
-        last = name_to_cell(parts[1])
-        rows[(first.row.index..last.row.index)].each do |r|
-          r.cells[(first.index..last.index)].each do |c|
-            cells << c
-          end
-        end
-        cells
-      end
-    end
-
-    # returns the column and row index for a named based cell
-    # @param [String] name The cell or cell range to return. "A1" will return the first cell of the first row.
-    # @return [Cell]
-    def name_to_cell(name)
-      col_index, row_index = *Axlsx::name_to_indices(name)
-      r = rows[row_index]
-      r.cells[col_index] if r
-    end
-
-    # The name of the worksheet
-    # @param [String] v
-    def name=(v) 
-      DataTypeValidator.validate "Worksheet.name", String, v
-      sheet_names = @workbook.worksheets.map { |s| s.name }
-      raise ArgumentError, (ERR_DUPLICATE_SHEET_NAME % v) if sheet_names.include?(v) 
-      @name=v 
-    end
-
-    # The part name of this worksheet
-    # @return [String]
-    def pn
-      "#{WORKSHEET_PN % (index+1)}"
-    end
-
-    # The relationship part name of this worksheet
-    # @return [String]
-    def rels_pn
-      "#{WORKSHEET_RELS_PN % (index+1)}"
-    end
-
-    # The relationship Id of thiw worksheet
-    # @return [String]
-    def rId
-      "rId#{index+1}"
-    end
-
-    # The index of this worksheet in the owning Workbook's worksheets list.
-    # @return [Integer]
-    def index
-      @workbook.worksheets.index(self)
-    end
-
-    # The drawing associated with this worksheet.
-    # @note the recommended way to work with drawings and charts is Worksheet#add_chart
-    # @return [Drawing]
-    # @see Worksheet#add_chart
-    def drawing
-      @drawing || @drawing = Axlsx::Drawing.new(self)
-    end
-
-    # Adds a row to the worksheet and updates auto fit data
-    # @return [Row]
-    # @option options [Array] values
-    # @option options [Array, Symbol] types 
-    # @option options [Array, Integer] style 
-    def add_row(values=[], options={})
-      Row.new(self, values, options)
-      update_auto_fit_data @rows.last.cells
-      yield @rows.last if block_given?
-      @rows.last
-    end
-
-    # Set the style for cells in a specific row
-    # @param [Integer] index or range of indexes in the table
-    # @param [Integer] the cellXfs index
-    # @option options [Integer] col_offset only cells after this column will be updated.
-    # @note You can also specify the style in the add_row call
-    # @see Worksheet#add_row
-    # @see README.md for an example
-    def row_style(index, style, options={})
-      offset = options.delete(:col_offset) || 0
-      rs = @rows[index]
-      if rs.is_a?(Array)
-        rs.each { |r| r.cells[(offset..-1)].each { |c| c.style = style } }
-      else
-        rs.cells[(offset..-1)].each { |c| c.style = style }
-      end
-    end
-
-    # returns the sheet data as columnw
-    def cols
-      @rows.transpose
-    end
-
-
-    # Set the style for cells in a specific column
-    # @param [Integer] index the index of the column
-    # @param [Integer] the cellXfs index
-    # @option options [Integer] row_offset only cells after this column will be updated.
-    # @note You can also specify the style for specific columns in the call to add_row by using an array for the :styles option
-    # @see Worksheet#add_row
-    # @see README.md for an example
-    def col_style(index, style, options={})
-      offset = options.delete(:row_offset) || 0
-      @rows[(offset..-1)].each do |r| 
-        cells = r.cells[index]
-        if cells.is_a?(Array)
-          cells.each { |c| c.style = style }
-        else
-          cells.style = style
-        end
-      end
-    end
-    
-    # Adds a chart to this worksheets drawing. This is the recommended way to create charts for your worksheet. This method wraps the complexity of dealing with ooxml drawing, anchors, markers graphic frames chart objects and all the other dirty details. 
-    # @param [Class] chart_type
-    # @option options [Array] start_at
-    # @option options [Array] end_at
-    # @option options [Cell, String] title
-    # @option options [Boolean] show_legend
-    # @option options [Integer] style 
-    # @note each chart type also specifies additional options 
-    # @see Chart
-    # @see Pie3DChart
-    # @see Bar3DChart
-    # @see Line3DChart
-    # @see README for examples
-    def add_chart(chart_type, options={})
-      chart = drawing.add_chart(chart_type, options)
-      yield chart if block_given?
-      chart
-    end
-
-    # Adds a media item to the worksheets drawing
-    # @param [Class] media_type
-    # @option options [] unknown
-    def add_image(options={})
-      image = drawing.add_image(options)
-      yield image if block_given?
-      image
-    end
-
-    # Serializes the worksheet document
-    # @return [String]
-    def to_xml
-      builder = Nokogiri::XML::Builder.new(:encoding => ENCODING) do |xml|
-        xml.worksheet(:xmlns => XML_NS, :'xmlns:r' => XML_NS_R) {
-          if @auto_fit_data.size > 0
-            xml.cols {
-              @auto_fit_data.each_with_index do |col, index|
-                min_max = index+1
-                xml.col(:min=>min_max, :max=>min_max, :width => auto_width(col), :customWidth=>"true")
-              end
-            }
-          end
-          xml.sheetData {
-            @rows.each do |row|
-              row.to_xml(xml)
-            end
-          }
-          xml.drawing :"r:id"=>"rId1" if @drawing          
-        }
-      end
-      builder.to_xml
-    end
-
-    # The worksheet relationships. This is managed automatically by the worksheet
-    # @return [Relationships]
-    def relationships
-        r = Relationships.new
-        r << Relationship.new(DRAWING_R, "../#{@drawing.pn}") if @drawing
-        r
-    end
-
-    private 
-
-    # assigns the owner workbook for this worksheet
-    def workbook=(v) DataTypeValidator.validate "Worksheet.workbook", Workbook, v; @workbook = v; end
-
-    # Updates auto fit data. 
-    # Autofit data attempts to determine the cell in a column that has the greatest width by comparing the length of the text multiplied by the size of the font.
-    # @return [Array] of Cell objects
-    # @param [Array] cells an array of cells
-    def update_auto_fit_data(cells)
-      styles = self.workbook.styles
-      cellXfs, fonts = styles.cellXfs, styles.fonts
-      sz = fonts[0].sz
-      cells.each_with_index do |item, index|
-        next if item.value.is_a?(String) && item.value.start_with?('=')
-        col = @auto_fit_data[index] || {:longest=>"", :sz=>sz} 
-        cell_xf = cellXfs[item.style]
-        font = fonts[cell_xf.fontId || 0]
-        sz = item.sz || font.sz || fonts[0].sz
-        if (col[:longest].scan(/./mu).size * col[:sz]) < (item.value.to_s.scan(/./mu).size * sz)
-          col[:sz] =  sz
-          col[:longest] = item.value.to_s
-        end
-        @auto_fit_data[index] = col
-      end
-      cells
-    end
-
-    # Determines the proper width for a column based on content.
-    # @note 
-    #  From ECMA docs
-    #   Column width measured as the number of characters of the maximum digit width of the numbers 0 .. 9 as 
-    #   rendered in the normal style's font. There are 4 pixels of margin padding (two on each side), plus 1 pixel padding for the gridlines.
-    #   width = Truncate([!{Number of Characters} * !{Maximum Digit Width} + !{5 pixel padding}]/{Maximum Digit Width}*256)/256
-    # @return [Float]
-    # @param [Hash] A hash of auto_fit_data 
-    def auto_width(col)
-      mdw = 6.0 # maximum digit with is always 6.0 with RMagick's default font
-      mdw_count = 0 
-      best_guess = 1.5  #direct testing shows the results of the documented formula to be a bit too small. This is a best guess scaling
-      font_scale = col[:sz].to_f / (self.workbook.styles.fonts[0].sz.to_f || 11.0)
-      
-      col[:longest].scan(/./mu).each do |i|
-        mdw_count +=1 if @magick_draw.get_type_metrics(i).width >= mdw 
-      end
-      ((mdw_count * mdw + 5) / mdw * 256) / 256.0 * best_guess * font_scale      
-    end   
-  end
-end