axlsx 1.0.15 → 1.1.1

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

@@ -1,9 +1,9 @@
-# -*- coding: utf-8 -*-
+# encoding: UTF-8
 module Axlsx
-  
-  # The Worksheet class represents a worksheet in the workbook. 
+
+  # The Worksheet class represents a worksheet in the workbook.
   class Worksheet
-    
+
     # The name of the worksheet
     # @return [String]
     attr_reader :name
@@ -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
@@ -21,7 +24,7 @@ module Axlsx
 
     # 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 
+    # @return [Array] of Hash
     attr_reader :auto_fit_data
 
     # An array of merged cell ranges e.d "A1:B3"
@@ -34,63 +37,145 @@ module Axlsx
     # The first row is considered the header, while subsequent rows are considerd to be data.
     # @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
+    #      # using options when creating the worksheet.
+    #      ws = wb.add_worksheet :page_margins => {:left => 1.9, :header => 0.1}
+    #
+    #      # use the set method of the page_margins object
+    #      ws.page_margins.set(:bottom => 3, :footer => 0.7)
+    #
+    #      # set page margins in a block
+    #      ws.page_margins do |margins|
+    #        margins.right = 6
+    #        margins.top = 0.2
+    #      end
+    # @see PageMargins#initialize
+    # @return [PageMargins]
+    def page_margins
+      @page_margins ||= PageMargins.new
+      yield @page_margins if block_given?
+      @page_margins
+
+    end
+
+    # definition of characters which are less than the maximum width of 0-9 in the default font for use in String#count.
+    # This is used for autowidth calculations
+    # @return [String]
+    def self.thin_chars
+      @thin_chars ||= "^.acefijklrstxyzFIJL()-"
+    end
+
     # 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.
+    # @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 = 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
+
+      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
+    # @return [Array] cells
+    def cells
+      rows.flatten
     end
 
-    # Creates merge information for this worksheet. 
+    # Creates merge information for this worksheet.
     # Cells can be merged by calling the merge_cells method on a worksheet.
-    # @example This would merge the three cells C1..E1    #  
+    # @example This would merge the three cells C1..E1    #
     #        worksheet.merge_cells "C1:E1"
     #        # you can also provide an array of cells to be merged
     #        worksheet.merge_cells worksheet.rows.first.cells[(2..4)]
     #        #alternatively you can do it from a single cell
     #        worksheet["C1"].merge worksheet["E1"]
-    # @param [Array, string]    
+    # @param [Array, string]
     def merge_cells(cells)
       @merged_cells << if cells.is_a?(String)
                          cells
                        elsif cells.is_a?(Array)
                          cells = cells.sort { |x, y| x.r <=> y.r }
                          "#{cells.first.r}:#{cells.last.r}"
-                       end 
+                       end
     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]
+    # The demensions of a worksheet. This is not actually a required element by the spec,
+    # but at least a few other document readers expect this for conversion
+    # @return [String] the A1:B2 style reference for the first and last row column intersection in the workbook
+    def dimension
+      dim_start = rows.first.cells.first == nil ? 'A1' : rows.first.cells.first.r
+      dim_end = rows.last.cells.last == nil ? 'AA:200' : rows.last.cells.last.r
+      "#{dim_start}:#{dim_end}"
+    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 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
+
+    # @see selected
+    # @return [Boolean]
+    def selected=(v)
+      Axlsx::validate_boolean v
+      @selected = v
     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]
@@ -101,18 +186,26 @@ module Axlsx
     end
 
     # The name of the worksheet
+    # The name of a worksheet must be unique in the workbook, and must not exceed 31 characters
     # @param [String] v
-    def name=(v) 
+    def name=(v)
       DataTypeValidator.validate "Worksheet.name", String, v
+      raise ArgumentError, (ERR_SHEET_NAME_TOO_LONG % v) if v.size > 31
       sheet_names = @workbook.worksheets.map { |s| s.name }
-      raise ArgumentError, (ERR_DUPLICATE_SHEET_NAME % v) if sheet_names.include?(v) 
-      @name=v 
+      raise ArgumentError, (ERR_DUPLICATE_SHEET_NAME % v) if sheet_names.include?(v)
+      @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
-    def auto_filter=(v) 
+    def auto_filter=(v)
       DataTypeValidator.validate "Worksheet.auto_filter", String, v
       @auto_filter = v
     end
@@ -149,18 +242,55 @@ module Axlsx
       @drawing || @drawing = Axlsx::Drawing.new(self)
     end
 
-    # Adds a row to the worksheet and updates auto fit data
+    # Adds a row to the worksheet and updates auto fit data.
+    # @example - put a vanilla row in your spreadsheet
+    #     ws.add_row [1, 'fish on my pl', '8']
+    #
+    # @example - specify a fixed width for a column in your spreadsheet
+    #     # The first column will ignore the content of this cell when calculating column autowidth.
+    #     # The second column will include this text in calculating the columns autowidth
+    #     # The third cell will set a fixed with of 80 for the column.
+    #     # If you need to un-fix a column width, use :auto. That will recalculate the column width based on all content in the column
+    #
+    #     ws.add_row ['I wish', 'for a fish', 'on my fish wish dish'], :widths=>[:ignore, :auto, 80]
+    #
+    # @example - specify a fixed height for a row
+    #     ws.add_row ['I wish', 'for a fish', 'on my fish wish dish'], :height => 40
+    #
+    # @example - create and use a style for all cells in the row
+    #     blue = ws.styles.add_style :color => "#00FF00"
+    #     ws.add_row [1, 2, 3], :style=>blue
+    #
+    # @example - only style some cells
+    #     blue = ws.styles.add_style :color => "#00FF00"
+    #     red = ws.styles.add_style :color => "#FF0000"
+    #     big = ws.styles.add_style :sz => 40
+    #     ws.add_row ["red fish", "blue fish", "one fish", "two fish"], :style=>[red, blue, nil, big] # the last nil is optional
+    #
+    #
+    # @example - force the second cell to be a float value
+    #     ws.add_row [3, 4, 5], :types => [nil, :float]
+    #
+    # @example - use << alias
+    #     ws << [3, 4, 5], :types => [nil, :float]
+    #
+    # @see Worksheet#column_widths
     # @return [Row]
     # @option options [Array] values
-    # @option options [Array, Symbol] types 
-    # @option options [Array, Integer] style 
+    # @option options [Array, Symbol] types
+    # @option options [Array, Integer] style
+    # @option options [Array] widths each member of the widths array will affect how auto_fit behavies.
+    # @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
+      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
 
+    alias :<< :add_row
+
     # Set the style for cells in a specific row
     # @param [Integer] index or range of indexes in the table
     # @param [Integer] the cellXfs index
@@ -193,8 +323,9 @@ module Axlsx
     # @see README.md for an example
     def col_style(index, style, options={})
       offset = options.delete(:row_offset) || 0
-      @rows[(offset..-1)].each do |r| 
+      @rows[(offset..-1)].each do |r|
         cells = r.cells[index]
+        next unless cells
         if cells.is_a?(Array)
           cells.each { |c| c.style = style }
         else
@@ -202,15 +333,31 @@ module Axlsx
         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. 
+
+    # This is a helper method that Lets you specify a fixed width for multiple columns in a worksheet in one go.
+    # Axlsx is sparse, so if you have not set data for a column, you cannot set the width.
+    # Setting a fixed column width to nil will revert the behaviour back to calculating the width for you.
+    # @example This would set the first and third column widhts but leave the second column in autofit state.
+    #      ws.column_widths 7.2, nil, 3
+    # @note For updating only a single column it is probably easier to just set the width of the ws.column_info[col_index].width directly
+    # @param [Integer|Float|Fixnum|nil] values
+    def column_widths(*args)
+      args.each_with_index do |value, index|
+        next if value == nil
+        Axlsx::validate_unsigned_numeric(value) unless value == nil
+        @column_info[index] ||= Col.new index+1, index+1
+        @column_info[index].width = value
+      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 
+    # @option options [Integer] style
+    # @note each chart type also specifies additional options
     # @see Chart
     # @see Pie3DChart
     # @see Bar3DChart
@@ -222,6 +369,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
@@ -231,105 +386,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) {
-          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?
-          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
-      builder.to_xml
+      str.concat '<sheetData>'
+      @rows.each_with_index { |row, index| row.to_xml_string(index, str) }
+      str.concat '</sheetData>'
+      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| memo += "<mergeCell ref='%s'></mergeCell>" % obj } ] unless @merged_cells.empty?
+      page_margins.to_xml_string(str) if @page_margins
+      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
+      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
 
-    private 
+    # 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
-    def update_auto_fit_data(cells)
-      # TODO delay this until rendering. too much work when we dont know what they are going to do to the sheet.
+
+    # TODO this needs cleanup!
+    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|
-        # ignore formula - there is no way for us to know the result
-        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
+
+      cells.each_with_index do |cell, index|
+        @column_info[index] ||= Col.new index+1, index+1
+        col = @column_info[index]
+        width = widths[index]
+        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 || (cell.value.is_a?(String) && cell.value.start_with?('=') || cell.value == nil)
+        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
-        @auto_fit_data[index] = col
-      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)
-      mdw_count, font_scale, mdw = 0, col[:sz]/11.0, 6.0
-      mdw_count = col[:longest].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      
 
+    # If you *REALLY* want to know what this does, check the spec for how column width is specified.
+    def calculate_width(text, sz)
+      mdw = 1.78 #magic numbers ftw! This is the widest width of 0..9 in the "standard" font (arial@10px)
+      font_scale = sz/10.0
+      ((text.count(Worksheet.thin_chars) * mdw + 5) / mdw * 256) / 256.0 * font_scale
+    end
   end
 end

data/lib/axlsx.rb

@@ -1,14 +1,15 @@
-Encoding::default_internal = 'UTF-8' unless RUBY_VERSION < '1.9'
-Encoding::default_external = 'UTF-8' unless RUBY_VERSION < '1.9'
-
+# encoding: UTF-8
 require 'axlsx/version.rb'
 
 require 'axlsx/util/simple_typed_list.rb'
 require 'axlsx/util/constants.rb'
 require 'axlsx/util/validators.rb'
-# require 'axlsx/util/storage.rb'
-# require 'axlsx/util/cbf.rb'
-# require 'axlsx/util/ms_off_crypto.rb'
+require 'axlsx/util/storage.rb'
+
+#not even close to being ready but it does not break anything so it stays for now.
+# needs a full re-write to use agile-encryption properly
+require 'axlsx/util/cbf.rb'
+require 'axlsx/util/ms_off_crypto.rb'
 
 
 # to be included with parsable intitites.
@@ -24,24 +25,29 @@ require 'axlsx/rels/relationships.rb'
 require 'axlsx/drawing/drawing.rb'
 require 'axlsx/workbook/workbook.rb'
 require 'axlsx/package.rb'
-
 #required gems
 require 'nokogiri'
-require 'active_support/core_ext/object/instance_variables'
-require 'active_support/inflector'
-require 'RMagick'
 require 'zip/zip'
 
 #core dependencies
 require 'bigdecimal'
 require 'time'
 
+#if object does not have this already, I am borrowing it from active_support.
+# I am a very big fan of activesupports instance_values method, but do not want to require nor include the entire
+# library just for this one method.
+if !Object.respond_to?(:instance_values)
+  Object.send :public  # patch for 1.8.7 as it uses private scope
+  Object.send :define_method, :instance_values do
+    Hash[instance_variables.map { |name| [name.to_s[1..-1], instance_variable_get(name)] }]
+  end
+end
 
 # xlsx generation with charts, images, automated column width, customizable styles and full schema validation. Axlsx excels at helping you generate beautiful Office Open XML Spreadsheet documents without having to understand the entire ECMA specification. Check out the README for some examples of how easy it is. Best of all, you can validate your xlsx file before serialization so you know for sure that anything generated is going to load on your client's machine.
 module Axlsx
   # determines the cell range for the items provided
   def self.cell_range(items)
-    return "" unless items.first.is_a? Cell          
+    return "" unless items.first.is_a? Cell
     ref = "'#{items.first.row.worksheet.name}'!" +
       "#{items.first.r_abs}"
     ref += ":#{items.last.r_abs}" if items.size > 1
@@ -50,11 +56,32 @@ module Axlsx
 
   def self.name_to_indices(name)
     raise ArgumentError, 'invalid cell name' unless name.size > 1
-    v = name[/[A-Z]+/].reverse.chars.reduce({:base=>1, :i=>0}) do  |v, c|        
-      v[:i] += ((c.bytes.first - 65) + v[:base]); v[:base] *= 26; v 
+    v = name[/[A-Z]+/].reverse.chars.reduce({:base=>1, :i=>0}) do  |val, c|
+      val[:i] += ((c.bytes.first - 64) * val[:base]); val[:base] *= 26; val
     end
 
-    [v[:i]-1, ((name[/[1-9]+/]).to_i)-1]
+    [v[:i]-1, ((name[/[1-9][0-9]*/]).to_i)-1]
 
   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 self.col_ref(index)
+    chars = []
+    while index >= 26 do
+      chars << ((index % 26) + 65).chr
+      index = index / 26 - 1
+    end
+    chars << (index + 65).chr
+    chars.reverse.join
+  end
+
+  # @return [String] The alpha(column)numeric(row) reference for this sell.
+  # @example Relative Cell Reference
+  #   ws.rows.first.cells.first.r #=> "A1"
+  def self.cell_r(c_index, r_index)
+    Axlsx::col_ref(c_index).to_s << (r_index+1).to_s
+  end
+
 end

data/lib/schema/dc.xsd

@@ -12,7 +12,7 @@
 
       Created 2003-04-02
 
-      Created by 
+      Created by
 
       Tim Cole (t-cole3@uiuc.edu)
       Tom Habing (thabing@uiuc.edu)
@@ -23,14 +23,14 @@
       This schema declares XML elements for the 15 DC elements from the
       http://purl.org/dc/elements/1.1/ namespace.
 
-      It defines a complexType SimpleLiteral which permits mixed content 
+      It defines a complexType SimpleLiteral which permits mixed content
       and makes the xml:lang attribute available. It disallows child elements by
       use of minOcccurs/maxOccurs.
 
       However, this complexType does permit the derivation of other complexTypes
       which would permit child elements.
 
-      All elements are declared as substitutable for the abstract element any, 
+      All elements are declared as substitutable for the abstract element any,
       which means that the default type for all elements is dc:SimpleLiteral.
 
     </xs:documentation>
@@ -49,7 +49,7 @@
             It permits text content only with optional
             xml:lang attribute.
             Text is allowed because mixed="true", but sub-elements
-            are disallowed because minOccurs="0" and maxOccurs="0" 
+            are disallowed because minOccurs="0" and maxOccurs="0"
             are on the xs:any tag.
 
     	    This complexType allows for restriction or extension permitting
@@ -89,7 +89,7 @@
   	<xs:annotation>
     	<xs:documentation xml:lang="en">
     	    This group is included as a convenience for schema authors
-            who need to refer to all the elements in the 
+            who need to refer to all the elements in the
             http://purl.org/dc/elements/1.1/ namespace.
     	</xs:documentation>
   	</xs:annotation>