axlsx 1.0.18 → 1.1.0

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

@@ -0,0 +1,114 @@
+# encoding: UTF-8
+module Axlsx
+
+  # The Col class defines column attributes for columns in sheets.
+  class Col
+
+    # First column affected by this 'column info' record.
+    # @return [Integer]
+    attr_reader :min
+
+    # Last column affected by this 'column info' record.
+    # @return [Integer]
+    attr_reader :max
+
+    # Flag indicating if the specified column(s) is set to 'best fit'. 'Best fit' is set to true under these conditions:
+    # The column width has never been manually set by the user, AND The column width is not the default width
+    # 'Best fit' means that when numbers are typed into a cell contained in a 'best fit' column, the column width should
+    #  automatically resize to display the number. [Note: In best fit cases, column width must not be made smaller, only larger. end note]
+    # @return [Boolean]
+    attr_reader :bestFit
+
+    # Flag indicating if the outlining of the affected column(s) is in the collapsed state.
+    # @return [Boolean]
+    attr_reader :collapsed
+
+    # Flag indicating if the affected column(s) are hidden on this worksheet.
+    # @return [Boolean]
+    attr_reader :hidden
+
+    # Outline level of affected column(s). Range is 0 to 7.
+    # @return [Integer]
+    attr_reader :outlineLevel
+
+    # Flag indicating if the phonetic information should be displayed by default for the affected column(s) of the worksheet.
+    # @return [Boolean]
+    attr_reader :phonetic
+
+    # Default style for the affected column(s). Affects cells not yet allocated in the column(s). In other words, this style applies to new columns.
+    # @return [Integer]
+    attr_reader :style
+
+    # The width of the column
+    # @return [Numeric]
+    attr_reader :width
+
+    # @return [Boolean]
+    attr_reader :customWidth
+
+    # @see Col#collapsed
+    def collapsed=(v)
+      Axlsx.validate_boolean(v)
+      @collapsed = v
+    end
+
+    # @see Col#hidden
+    def hidden=(v)
+      Axlsx.validate_boolean(v)
+      @hidden = v
+    end
+
+    # @see Col#outline
+    def outlineLevel=(v)
+      Axlsx.validate_boolean(v)
+      @outlineLevel = v
+    end
+
+    # @see Col#phonetic
+    def phonetic=(v)
+      Axlsx.validate_boolean(v)
+      @phonetic = v
+    end
+
+    # @see Col#style
+    def style=(v)
+      Axlsx.validate_unsigned_int(v)
+      @style = v
+    end
+
+   # @see Col#width
+    def width=(v)
+      Axlsx.validate_unsigned_numeric(v) unless v == nil
+      @customWidth = @bestFit = v != nil
+      @width = v
+    end
+
+    # Create a new Col objects
+    # @param min First column affected by this 'column info' record.
+    # @param max Last column affected by this 'column info' record.
+    # @option options [Boolean] collapsed see Col#collapsed
+    # @option options [Boolean] hidden see Col#hidden
+    # @option options [Boolean] outlineLevel see Col#outlineLevel
+    # @option options [Boolean] phonetic see Col#phonetic
+    # @option options [Integer] style see Col#style
+    # @option options [Numeric] width see Col#width
+    def initialize(min, max, options={})
+      Axlsx.validate_unsigned_int(max)
+      Axlsx.validate_unsigned_int(min)
+      @min = min
+      @max = max
+      options.each do |o|
+        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
+      end
+    end
+
+    # Serialize this columns data to an xml string
+    # @param [String] str
+    # @return [String]
+    def to_xml_string(str = '')
+      attrs = self.instance_values.reject{ |key, value| value == nil }
+      str << '<col ' << attrs.map { |key, value| '' << key << '="' << value.to_s << '"' }.join(' ') << '/>'
+    end
+
+  end
+end

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

@@ -12,13 +12,13 @@ module Axlsx
 
     # Default left and right margin (in inches)
     DEFAULT_LEFT_RIGHT = 0.75
-    
+
     # Default top and bottom margins (in inches)
     DEFAULT_TOP_BOTTOM = 1.00
-    
+
     # Default header and footer margins (in inches)
     DEFAULT_HEADER_FOOTER = 0.50
-    
+
     # Left margin (in inches)
     # @return [Float]
     attr_reader :left
@@ -26,23 +26,23 @@ module Axlsx
     # Right margin (in inches)
     # @return [Float]
     attr_reader :right
-    
+
     # Top margin (in inches)
     # @return [Float]
     attr_reader :top
-    
+
     # Bottom margin (in inches)
     # @return [Float]
     attr_reader :bottom
-    
+
     # Header margin (in inches)
     # @return [Float]
     attr_reader :header
-    
+
     # Footer margin (in inches)
     # @return [Float]
     attr_reader :footer
-    
+
     # Creates a new PageMargins object
     # @option options [Numeric] left The left margin in inches
     # @option options [Numeric] right The right margin in inches
@@ -60,7 +60,7 @@ module Axlsx
         self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
       end
     end
-    
+
     # Set some or all margins at once.
     # @param [Hash] margins the margins to set (possible keys are :left, :right, :top, :bottom, :header and :footer).
     def set(margins)
@@ -69,7 +69,7 @@ module Axlsx
         send("#{k}=", v)
       end
     end
-    
+
     # @see left
     def left=(v); Axlsx::validate_unsigned_numeric(v); @left = v end
     # @see right
@@ -84,11 +84,14 @@ module Axlsx
     def footer=(v); Axlsx::validate_unsigned_numeric(v); @footer = v end
 
     # Serializes the page margins element
+    # @param [String] str
+    # @return [String]
     # @note For compatibility, this is a noop unless custom margins have been specified.
-    # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
     # @see #custom_margins_specified?
-    def to_xml(xml)
-      xml.pageMargins :left => left, :right => right, :top => top, :bottom => bottom, :header => header, :footer => footer
+    def to_xml_string(str = '')
+      str << '<pageMargins '
+      str << instance_values.map { |key, value| '' << key << '="' << value.to_s << '"' }.join(' ')
+      str << '/>'
     end
   end
 end

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

@@ -60,19 +60,26 @@ module Axlsx
     end
 
     # Serializes the row
-    # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
+    # @param [Integer] r_index The row index, 0 based.
+    # @param [String] str The string this rows xml will be appended to.
     # @return [String]
-    def to_xml(xml)
-      attrs = {:r => index+1}
-      attrs.merge!(:customHeight => 1, :ht => height) if custom_height?
-      xml.row(attrs) { |ixml| @cells.each { |cell| cell.to_xml(ixml) } }
+    def to_xml_string(r_index, str = '')
+      str << '<row r="' << (r_index + 1 ).to_s << '" '
+      if custom_height?
+        str << 'customHeight="1" ht="' << height.to_s << '">'
+      else
+        str << '>'
+      end
+      @cells.each_with_index { |cell, c_index| cell.to_xml_string(r_index, c_index, str) }
+      str << '</row>'
+      str
     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
+      worksheet.send(:update_column_info, self.cells, self.cells.map(&:style))
       c
     end
 
@@ -106,13 +113,6 @@ module Axlsx
     # 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.

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

@@ -0,0 +1,96 @@
+# encoding: UTF-8
+module Axlsx
+  # Table
+  # @note Worksheet#add_table is the recommended way to create tables for your worksheets.
+  # @see README for examples
+  class Table
+
+
+    # The reference to the table data
+    # @return [String]
+    attr_reader :ref
+
+    # The name of the table.
+    # @return [String]
+    attr_reader :name
+
+    # The style for the table.
+    # @return [TableStyle]
+    attr_reader :style
+
+    # Creates a new Table object
+    # @param [String] ref The reference to the table data.
+    # @param [Sheet] ref The sheet containing the table data.
+    # @option options [Cell, String] name
+    # @option options [TableStyle] style
+    def initialize(ref, sheet, options={})
+      @ref = ref
+      @sheet = sheet
+      @style = nil
+      @sheet.workbook.tables << self
+      @name = "Table#{index+1}"
+      options.each do |o|
+        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
+      end
+      yield self if block_given?
+    end
+
+    # The index of this chart in the workbooks charts collection
+    # @return [Integer]
+    def index
+      @sheet.workbook.tables.index(self)
+    end
+
+    # The part name for this table
+    # @return [String]
+    def pn
+      "#{TABLE_PN % (index+1)}"
+    end
+
+    # The relation reference id for this table
+    # @return [String]
+    def rId
+      "rId#{index+1}"
+    end
+
+    # The name of the Table.
+    # @param [String, Cell] v
+    # @return [Title]
+    def name=(v)
+      DataTypeValidator.validate "#{self.class}.name", [String], v
+      if v.is_a?(String)
+        @name = v
+      end
+    end
+
+    # Serializes the object
+    # @param [String] str
+    # @return [String]
+    def to_xml_string(str = '')
+      str << '<?xml version="1.0" encoding="UTF-8"?>'
+      str << '<table xmlns="' << XML_NS << '" id="' << (index+1).to_s << '" name="' << @name << '" displayName="' << @name.gsub(/\s/,'_') << '" '
+      str << 'ref="' << @ref << '" totalsRowShown="0">'
+      str << '<autoFilter ref="' << @ref << '"/>'
+      str << '<tableColumns count="' << header_cells.length.to_s << '">'
+      header_cells.each_with_index do |cell,index|
+        str << '<tableColumn id ="' << (index+1).to_s << '" name="' << cell.value << '"/>'
+      end
+      str << '</tableColumns>'
+      #TODO implement tableStyleInfo
+      str << '<tableStyleInfo showFirstColumn="0" showLastColumn="0" showRowStripes="1" showColumnStripes="0" name="TableStyleMedium9" />'
+      str << '</table>'
+    end
+
+    # The style for the table.
+    # TODO
+    # def style=(v) DataTypeValidator.validate "Table.style", Integer, v, lambda { |arg| arg >= 1 && arg <= 48 }; @style = v; end
+
+    private
+
+    # get the header cells (hackish)
+    def header_cells
+      header = @ref.gsub(/^(\w+)(\d+)\:(\w+)\d+$/, '\1\2:\3\2')
+      @sheet[header]
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+# encoding: UTF-8
+module Axlsx
+  # Table
+  # @note Worksheet#add_table is the recommended way to create charts for your worksheets.
+  # @see README for examples
+  class Table
+
+
+    # The reference to the table data
+    # @return [String]
+    attr_reader :ref
+
+    # The name of the table.
+    # @return [String]
+    attr_reader :name
+
+    # The style for the table. 
+    # @return [TableStyle]
+    attr_reader :style
+   
+    # Creates a new Table object
+    # @param [String] ref The reference to the table data.
+    # @param [Sheet] ref The sheet containing the table data.
+    # @option options [Cell, String] name
+    # @option options [TableStyle] style
+    def initialize(ref, sheet, options={})
+      @ref = ref
+      @sheet = sheet
+      @style = nil
+      @sheet.workbook.tables << self
+      @name = "Table#{index+1}"
+      options.each do |o|
+        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
+      end
+      yield self if block_given?
+    end
+
+    # The index of this chart in the workbooks charts collection
+    # @return [Integer]
+    def index
+      @sheet.workbook.tables.index(self)
+    end
+
+    # The part name for this table
+    # @return [String]
+    def pn
+      "#{TABLE_PN % (index+1)}"
+    end
+    
+    # The relation reference id for this table
+    # @return [String]
+    def rId
+      "rId#{index+1}"
+    end
+
+    # The name of the Table.
+    # @param [String, Cell] v
+    # @return [Title]
+    def name=(v) 
+      DataTypeValidator.validate "#{self.class}.name", [String], v
+      if v.is_a?(String)
+        @name = v
+      end
+    end
+
+    
+    # The style for the table.
+    # TODO 
+    # def style=(v) DataTypeValidator.validate "Chart.style", Integer, v, lambda { |arg| arg >= 1 && arg <= 48 }; @style = v; end
+
+    # Table Serialization
+    # serializes the table
+    def to_xml
+      builder = Nokogiri::XML::Builder.new(:encoding => ENCODING) do |xml|
+        xml.table(:xmlns => XML_NS, :id => index+1, :name => @name, :displayName => @name.gsub(/\s/,'_'), :ref => @ref, :totalsRowShown => 0) {
+          xml.autoFilter :ref=>@ref 
+          xml.tableColumns(:count => header_cells.length) {
+            header_cells.each_with_index do |cell,index|
+              xml.tableColumn :id => index+1, :name => cell.value
+            end
+          }
+          xml.tableStyleInfo :showFirstColumn=>"0", :showLastColumn=>"0", :showRowStripes=>"1", :showColumnStripes=>"0", :name=>"TableStyleMedium9"
+          #TODO implement tableStyleInfo
+        }
+      end
+      builder.to_xml(:save_with => 0)
+    end
+
+    private
+    
+    # get the header cells (hackish)
+    def header_cells 
+      header = @ref.gsub(/^(\w+)(\d+)\:(\w+)\d+$/, '\1\2:\3\2')
+      @sheet[header]
+    end
+  end
+end

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

@@ -12,6 +12,9 @@ module Axlsx
     # @return [Workbook]
     attr_reader :workbook
 
+    # The tables in this worksheet
+    # @return [Array] of Table
+    attr_reader :tables
 
     # The rows in this worksheet
     # @note The recommended way to manage rows is Worksheet#add_row
@@ -35,6 +38,26 @@ module Axlsx
     # @return Array
     attr_reader :auto_filter
 
+    # Indicates if the worksheet should show gridlines or not
+    # @return Boolean
+    attr_reader :show_gridlines
+
+
+    # Indicates if the worksheet is selected in the workbook
+    # It is possible to have more than one worksheet selected, however it might cause issues
+    # in some older versions of excel when using copy and paste.
+    # @return Boolean
+    attr_reader :selected
+
+    # Indicates if the worksheet should print in a single page
+    # @return Boolean
+    attr_reader :fit_to_page
+
+
+    # Column info for the sheet
+    # @return [SimpleTypedList]
+    attr_reader :column_info
+
     # Page margins for printing the worksheet.
     # @example
     #      wb = Axlsx::Package.new.workbook
@@ -55,6 +78,7 @@ module Axlsx
       @page_margins ||= PageMargins.new
       yield @page_margins if block_given?
       @page_margins
+
     end
 
     # Creates a new worksheet.
@@ -62,19 +86,36 @@ module Axlsx
     # @see Workbook#add_worksheet
     # @option options [String] name The name of this worksheet.
     # @option options [Hash] page_margins A hash containing page margins for this worksheet. @see PageMargins
+    # @option options [Boolean] show_gridlines indicates if gridlines should be shown for this sheet.
     def initialize(wb, options={})
-      @drawing = @page_margins = @auto_filter = 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
+      @drawing = @page_margins = @auto_filter = nil
       @merged_cells = []
+      @auto_fit_data = []
 
+      @selected = false
+      @show_gridlines = true
+      self.name = "Sheet" + (index+1).to_s
       @page_margins = PageMargins.new options[:page_margins] if options[:page_margins]
+
+      @rows = SimpleTypedList.new Row
+      @column_info = SimpleTypedList.new Col
+      # @cols = SimpleTypedList.new Cell
+      @tables = SimpleTypedList.new Table
+
+      if self.workbook.use_autowidth
+        require 'RMagick' unless defined?(Magick)
+        @magick_draw = Magick::Draw.new
+      else
+        @magick_draw = nil
+      end
+
+      options.each do |o|
+        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
+      end
+
     end
 
     # convinience method to access all cells in this worksheet
@@ -109,29 +150,31 @@ module Axlsx
       "#{rows.first.cells.first.r}:#{rows.last.cells.last.r}"
     end
 
+    # Indicates if gridlines should be shown in the sheet.
+    # This is true by default.
+    # @return [Boolean]
+    def show_gridlines=(v)
+      Axlsx::validate_boolean v
+      @show_gridlines = v
+    end
 
-    # Returns the cell or cells defined using excel style A1:B3 references.
-    # @param [String|Integer] cell_def the string defining the cell or range of cells, or the rownumber
-    # @return [Cell, Array]
-    def [](cell_def)
-      return rows[cell_def - 1] if cell_def.is_a? Integer
-      parts = cell_def.split(':')
-      first = name_to_cell parts[0]
+    # @see selected
+    # @return [Boolean]
+    def selected=(v)
+      Axlsx::validate_boolean v
+      @selected = v
+    end
 
-      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
+
+    # Indicates if the worksheet should print in a single page.
+    # This is true by default.
+    # @return [Boolean]
+    def fit_to_page=(v)
+      Axlsx::validate_boolean v
+      @fit_to_page = v
     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]
@@ -152,6 +195,12 @@ module Axlsx
       @name=v
     end
 
+    # The absolute auto filter range
+    # @see auto_filter
+    def abs_auto_filter
+      Axlsx.cell_range(@auto_filter.split(':').collect { |name| name_to_cell(name)}) if @auto_filter
+    end
+
     # The auto filter range for the worksheet
     # @param [String] v
     # @see auto_filter
@@ -233,7 +282,8 @@ module Axlsx
     # @option options [Float] height the row's height (in points)
     def add_row(values=[], options={})
       Row.new(self, values, options)
-      update_auto_fit_data @rows.last.cells, options.delete(:widths) || []
+      update_column_info @rows.last.cells, options.delete(:widths) ||[], options.delete(:style) || []
+      # update_auto_fit_data @rows.last.cells, options.delete(:widths) || []
       yield @rows.last if block_given?
       @rows.last
     end
@@ -292,9 +342,9 @@ module Axlsx
     # @param [Integer|Float|Fixnum|nil] values
     def column_widths(*args)
       args.each_with_index do |value, index|
-        raise ArgumentError, "Invalid column specification" unless index < @auto_fit_data.size
+        raise ArgumentError, "Invalid column specification" unless index < @column_info.size
         Axlsx::validate_unsigned_numeric(value) unless value == nil
-        @auto_fit_data[index][:fixed] = value
+        @column_info[index].width = value
       end
     end
 
@@ -317,6 +367,14 @@ module Axlsx
       chart
     end
 
+    # needs documentation
+    def add_table(ref, options={})
+      table = Table.new(ref, self, options)
+      @tables << table
+      yield table if block_given?
+      table
+    end
+
     # Adds a media item to the worksheets drawing
     # @param [Class] media_type
     # @option options [] unknown
@@ -326,125 +384,101 @@ module Axlsx
       image
     end
 
-    # Serializes the worksheet document
+    # Serializes the object
+    # @param [String] str
     # @return [String]
-    def to_xml
-      builder = Nokogiri::XML::Builder.new(:encoding => ENCODING) do |xml|
-        xml.worksheet(:xmlns => XML_NS,
-                      :'xmlns:r' => XML_NS_R) {
-          # another patch for the folks at rubyXL as thier parser depends on this optional element.
-          xml.dimension :ref=>dimension unless rows.size == 0
-          # this is required by rubyXL, spec says who cares - but it seems they didnt notice
-          # however, it also seems to be causing some odd [Grouped] stuff in excel 2011 - so
-          # removing until I understand it better.
-          # xml.sheetViews {
-          #  xml.sheetView(:tabSelected => 1, :workbookViewId => 0) {
-          #    xml.selection :activeCell=>"A1", :sqref => "A1"
-          #  }
-          # }
-
-          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=>1)
-              end
-            }
-          end
-          xml.sheetData {
-            @rows.each do |row|
-              row.to_xml(xml)
-            end
-          }
-          xml.autoFilter :ref=>@auto_filter if @auto_filter
-          xml.mergeCells(:count=>@merged_cells.size) { @merged_cells.each { | mc | xml.mergeCell(:ref=>mc) } } unless @merged_cells.empty?
-          page_margins.to_xml(xml) if @page_margins
-          xml.drawing :"r:id"=>"rId1" if @drawing
-        }
+    def to_xml_string
+      str = '<?xml version="1.0" encoding="UTF-8"?>'
+      str.concat "<worksheet xmlns=\"%s\" xmlns:r=\"%s\">" % [XML_NS, XML_NS_R]
+      str.concat "<sheetPr><pageSetUpPr fitToPage=\"%s\"></pageSetUpPr></sheetPr>" % fit_to_page if fit_to_page
+      str.concat "<dimension ref=\"%s\"></dimension>" % dimension unless rows.size == 0
+      str.concat "<sheetViews><sheetView tabSelected='%s' workbookViewId='0' showGridLines='%s'><selection activeCell=\"A1\" sqref=\"A1\"/></sheetView></sheetViews>" % [@selected, show_gridlines]
+
+      if @column_info.size > 0
+        str << "<cols>"
+        @column_info.each { |col| col.to_xml_string(str) }
+        str.concat '</cols>'
+      end
+      str.concat '<sheetData>'
+      @rows.each_with_index { |row, index| row.to_xml_string(index, str) }
+      str.concat '</sheetData>'
+      page_margins.to_xml_string(str) if @page_margins
+      str.concat "<autoFilter ref='%s'></autoFilter>" % @auto_filter if @auto_filter
+      str.concat "<mergeCells count='%s'>%s</mergeCells>" % [@merged_cells.size, @merged_cells.reduce('') { |memo, obj| "<mergeCell ref='%s'></mergeCell>" % obj } ] unless @merged_cells.empty?
+      str.concat "<drawing r:id='rId1'></drawing>" if @drawing
+      unless @tables.empty?
+        str.concat "<tableParts count='%s'>%s</tableParts>" % [@tables.size, @tables.reduce('') { |memo, obj| memo += "<tablePart r:id='%s'/>" % obj.rId }]
       end
-      builder.to_xml(:save_with => 0)
+      str + '</worksheet>'
     end
 
     # The worksheet relationships. This is managed automatically by the worksheet
     # @return [Relationships]
     def relationships
         r = Relationships.new
+        @tables.each do |table|
+          r << Relationship.new(TABLE_R, "../#{table.pn}")
+        end
         r << Relationship.new(DRAWING_R, "../#{@drawing.pn}") if @drawing
         r
     end
 
+    # Returns the cell or cells defined using excel style A1:B3 references.
+    # @param [String|Integer] cell_def the string defining the cell or range of cells, or the rownumber
+    # @return [Cell, Array]
+
+    def [] (cell_def)
+      return rows[cell_def] if cell_def.is_a?(Integer)
+
+      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
+
     private
 
     # assigns the owner workbook for this worksheet
     def workbook=(v) DataTypeValidator.validate "Worksheet.workbook", Workbook, v; @workbook = v; end
 
-    # Updates auto fit data.
-    # We store an auto_fit_data item for each column. when a row is added we multiple the font size by the length of the text to
-    # attempt to identify the longest cell in the column. This is not 100% accurate as it needs to take into account
-    # any formatting that will be applied to the data, as well as the actual rendering size when the length and size is equal
-    # for two cells.
-
-    # @return [Array] of Cell objects
-    # @param [Array] cells an array of cells
-    # @param [Array] widths an array of cell widths @see Worksheet#add_row
-    def update_auto_fit_data(cells, widths=[])
-      # TODO delay this until rendering. too much work when we dont know what they are going to do to the sheet.
+
+    def update_column_info(cells, widths=[], style=[])
       styles = self.workbook.styles
       cellXfs, fonts = styles.cellXfs, styles.fonts
       sz = 11
-      cells.each_with_index do |item, index|
-        col = @auto_fit_data[index] ||= {:longest=>"", :sz=>sz, :fixed=>nil}
+      cells.each_with_index do |cell, index|
+        @column_info[index] ||= Col.new index+1, index+1
+        col = @column_info[index]
         width = widths[index]
-        # set fixed width and skip if numeric width is given
-        col[:fixed] = width if [Integer, Float, Fixnum].include?(width.class)
-        # ignore default column widths and formula
-        next if width == :ignore || (item.value.is_a?(String) && item.value.start_with?('='))
-        # make sure we can turn that fixed with off!
-        col[:fixed] = nil if width == :auto
-
-        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
+        col.width = width if [Integer, Float, Fixnum].include?(width.class)
+        c_style = style[index] if [Integer, Fixnum].include?(style[index].class)
+        next if width == :ignore || col.width || (cell.value.is_a?(String) && cell.value.start_with?('='))
+        if self.workbook.use_autowidth
+          cell_xf = cellXfs[(c_style || 0)]
+          font = fonts[(cell_xf.fontId || 0)]
+          sz = cell.sz || font.sz || sz
+          col.width = [(col.width || 0), calculate_width(cell.value.to_s, sz)].max
         end
       end
-      cells
     end
 
-    # Determines the proper width for a column based on content.
-    # @note
-    #   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)
-      return col[:fixed] unless col[:fixed] == nil
-
-      mdw_count, font_scale, mdw = 0, col[:sz]/11.0, 6.0
-      mdw_count = col[:longest].scan(/./mu).reduce(0) do | count, char |
+    def calculate_width(text, sz)
+      mdw_count, font_scale, mdw = 0, sz/11.0, 6.0
+      mdw_count = text.scan(/./mu).reduce(0) do | count, char |
         count +=1 if @magick_draw.get_type_metrics(char).max_advance >= mdw
         count
       end
       ((mdw_count * mdw + 5) / mdw * 256) / 256.0 * font_scale
     end
-
-    # Something to look into:
-    #  width calculation actually needs to be done agains the formatted value for items that apply a
-    # format
-    # def excel_format(cell)
-    #   # The most common case.
-    #   return time.value.to_s if cell.style == 0
-    #
-    #   # The second most common case
-    #   num_fmt = workbook.styles.cellXfs[items.style].numFmtId
-    #   return value.to_s if num_fmt == 0
-    #
-    #   format_code = workbook.styles.numFmts[num_fmt]
-    #   # need to find some exceptionally fast way of parsing value according to
-    #   # an excel format_code
-    #   item.value.to_s
-    # end
-
   end
 end