axlsx 1.0.18 → 1.1.0

data/lib/axlsx/util/constants.rb

@@ -172,6 +172,9 @@ module Axlsx
   # drawing rels part
   DRAWING_RELS_PN = "drawings/_rels/drawing%d.xml.rels"
 
+  # drawing part
+  TABLE_PN = "tables/table%d.xml"
+
   # chart part
   CHART_PN = "charts/chart%d.xml"
 
@@ -228,4 +231,5 @@ module Axlsx
 
   # error message for duplicate sheet names
   ERR_DUPLICATE_SHEET_NAME = "There is already a worksheet in this workbook named '%s'. Please use a unique name"
+
 end

data/lib/axlsx/util/simple_typed_list.rb

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 module Axlsx
-  # A SimpleTypedList is a type restrictive collection that allows some of the methods from Array and supports basic xml serialization.  
+  # A SimpleTypedList is a type restrictive collection that allows some of the methods from Array and supports basic xml serialization.
   # @private
   class SimpleTypedList
     # The class constants of allowed types
@@ -12,14 +12,14 @@ module Axlsx
     attr_reader :locked_at
 
     # The tag name to use when serializing this object
-    # by default the parent node for all items in the list is the classname of the first allowed type with the first letter in lowercase. 
+    # by default the parent node for all items in the list is the classname of the first allowed type with the first letter in lowercase.
     # @return [String]
     attr_reader :serialize_as
 
     # Creats a new typed list
     # @param [Array, Class] type An array of Class objects or a single Class object
     # @param [String] serialize The tag name to use in serialization
-    # @raise [ArgumentError] if all members of type are not Class objects    
+    # @raise [ArgumentError] if all members of type are not Class objects
     def initialize type, serialize_as=nil
       if type.is_a? Array
         type.each { |item| raise ArgumentError, "All members of type must be Class objects" unless item.is_a? Class }
@@ -39,7 +39,7 @@ module Axlsx
       @locked_at = @list.size
       self
     end
-    
+
     def to_ary
       @list
     end
@@ -58,7 +58,7 @@ module Axlsx
     def <<(v)
       DataTypeValidator.validate "SimpleTypedList.<<", @allowed_types, v
       @list << v
-      @list.size - 1      
+      @list.size - 1
     end
 
     # alternate of << method
@@ -104,14 +104,14 @@ module Axlsx
       return false unless @locked_at.is_a? Fixnum
       index < @locked_at
     end
-    
+
     # override the equality method so that this object can be compared to a simple array.
     # if this object's list is equal to the specifiec array, we return true.
     def ==(v)
       v == @list
     end
     # method_mission override to pass allowed methods to the list.
-    # @note 
+    # @note
     #  the following methods are not allowed
     #   :replace
     #   :insert
@@ -140,15 +140,23 @@ module Axlsx
     DELEGATES = Array.instance_methods - self.instance_methods - DESTRUCTIVE
 
     DELEGATES.each do |method|
-      class_eval %{ 
+      class_eval %{
         def #{method}(*args, &block)
           @list.send(:#{method}, *args, &block)
         end
       }
     end
 
+    def to_xml_string(str = '')
+      classname = @allowed_types[0].name.split('::').last
+      el_name = serialize_as || (classname[0,1].downcase + classname[1..-1])
+      str << '<' << el_name << ' count="' << @list.size.to_s << '">'
+      @list.each { |item| item.to_xml_string(str) }
+      str << '</' << el_name << '>'
+    end
+
     # Serializes the list
-    # If the serialize_as property is set, it is used as the parent node name. 
+    # If the serialize_as property is set, it is used as the parent node name.
     # If the serialize_as property is nil, the first item in the list of allowed_types will be used, having the first letter of the class changed to lower case.
     # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
     # @return [String]
@@ -159,6 +167,7 @@ module Axlsx
         @list.each { |item| item.to_xml(xml) }
       }
     end
+
   end
 
 

data/lib/axlsx/util/validators.rb

@@ -5,11 +5,11 @@ module Axlsx
     # Perform validation
     # @param [String] name The name of what is being validatied. This is included in the error message
     # @param [Array] choices The list of choices to validate against
-    # @param [Any] v The value to be validated  
+    # @param [Any] v The value to be validated
     # @raise [ArgumentError] Raised if the value provided is not in the list of choices.
     # @return [Boolean] true if validation succeeds.
     def self.validate(name, choices, v)
-      raise ArgumentError, (ERR_RESTRICTION % [v.to_s, name, choices.inspect]) unless choices.include?(v)      
+      raise ArgumentError, (ERR_RESTRICTION % [v.to_s, name, choices.inspect]) unless choices.include?(v)
       true
     end
   end
@@ -55,7 +55,7 @@ module Axlsx
 
   # Requires that the value is a Fixnum Integer or Float and is greater or equal to 0
   # @param [Any] v The value validated
-  # @raise [ArgumentError] raised if the value is not a Fixnum or Integer value greater or equal to 0
+  # @raise [ArgumentError] raised if the value is not a Fixnun, Integer, Float value greater or equal to 0
   # @return [Boolean] true if the data is valid
   def self.validate_unsigned_numeric(v)
     DataTypeValidator.validate("Invalid column width", [Fixnum, Integer, Float], v, lambda { |arg| arg.respond_to?(:>=) && arg >= 0 })
@@ -68,7 +68,7 @@ module Axlsx
   end
 
   # Requires that the value is a form that can be evaluated as a boolean in an xml document.
-  # The value must be an instance of Fixnum, String, Integer, Symbol, TrueClass or FalseClass and 
+  # The value must be an instance of Fixnum, String, Integer, Symbol, TrueClass or FalseClass and
   # it must be one of 0, 1, "true", "false", :true, :false, true, false, "0", or "1"
   # @param [Any] v The value validated
   def self.validate_boolean(v)
@@ -79,13 +79,13 @@ module Axlsx
   # @param [Any] v The value validated
   def self.validate_string(v)
     DataTypeValidator.validate :string, String, v
-  end   
+  end
 
   # Requires that the value is a Float
   # @param [Any] v The value validated
   def self.validate_float(v)
     DataTypeValidator.validate :float, Float, v
-  end   
+  end
 
   # Requires that the value is valid pattern type.
   # valid pattern types must be one of :none, :solid, :mediumGray, :darkGray, :lightGray, :darkHorizontal, :darkVertical, :darkDown,
@@ -103,6 +103,13 @@ module Axlsx
     RestrictionValidator.validate :gradient_type, [:linear, :path], v
   end
 
+  # Requires that the value is a valid scatterStyle
+  # must be one of :none | :line | :lineMarker | :marker | :smooth | :smoothMarker
+  # must be one of "none" | "line" | "lineMarker" | "marker" | "smooth" | "smoothMarker"
+  # @param [Symbol|String] the value to validate
+  def self.validate_scatter_style(v)
+    Axlsx::RestrictionValidator.validate "ScatterChart.scatterStyle", [:none, :line, :lineMarker, :marker, :smooth, :smoothMarker], v.to_sym
+  end
   # Requires that the value is a valid horizontal_alignment
   # :general, :left, :center, :right, :fill, :justify, :centerContinuous, :distributed are allowed
   # @param [Any] v The value validated

data/lib/axlsx/version.rb

@@ -5,6 +5,6 @@ module Axlsx
   # When using bunle exec rake and referencing the gem on github or locally
   # it will use the gemspec, which preloads this constant for the gem's version.
   # We check to make sure that it has not already been loaded
-  VERSION="1.0.18" unless Axlsx.const_defined? :VERSION
+  VERSION="1.1.0" unless defined? Axlsx::VERSION
 
 end

data/lib/axlsx/workbook/shared_strings_table.rb

@@ -3,7 +3,7 @@ module Axlsx
 
   # The Shared String Table class is responsible for managing and serializing common strings in a workbook.
   # While the ECMA-376 spec allows for both inline and shared strings it seems that at least some applications like iWorks Numbers
-  # and Google Docs require that the shared string table is populated in order to interoperate properly. 
+  # and Google Docs require that the shared string table is populated in order to interoperate properly.
   # As a developer, you should never need to directly work against this class. Simply set 'use_shared_strings'
   # on the package or workbook to generate a package that uses the shared strings table instead of inline strings.
   # @note Serialization performance is affected by using this serialization method so if you do not need interoperability
@@ -15,57 +15,55 @@ module Axlsx
     # @return [Integer]
     attr_reader :count
 
-    # The total number of unique strings in the workbook. 
+    # The total number of unique strings in the workbook.
     # @return [Integer]
     def unique_count
       @unique_cells.size
     end
 
     # An array of unique cells. Multiple attributes of the cell are used in comparison
-    # each of these unique cells is parsed into the shared string table.     
+    # each of these unique cells is parsed into the shared string table.
     # @see Cell#sharable
     attr_reader :unique_cells
 
     # Creates a new Shared Strings Table agains an array of cells
     # @param [Array] cells This is an array of all of the cells in the workbook
     def initialize(cells)
-      cells = cells.flatten.reject { |c| c.type != :string || c.value.start_with?('=') }
+      cells = cells.flatten.reject { |c| c.type != :string || c.value.nil? || c.value.start_with?('=') }
       @count = cells.size
       @unique_cells = []
+      @shared_xml_string = ""
       resolve(cells)
     end
 
-
-    # Generate the xml document for the Shared Strings Table
+    # Serializes the object
+    # @param [String] str
     # @return [String]
-    def to_xml
-      builder = Nokogiri::XML::Builder.new(:encoding => ENCODING) do |xml|
-        xml.sst(:xmlns => Axlsx::XML_NS, :count => count, :uniqueCount => unique_count) {
-          @unique_cells.each do |cell|
-            xml.si { cell.run_xml(xml) }
-          end
-        }
-      end
-      builder.to_xml(:save_with => 0)
+    def to_xml_string
+      '<?xml version="1.0" encoding="UTF-8"?><sst xmlns="' << XML_NS << '" count="' << @count.to_s << '" uniqueCount="' << unique_count.to_s << '">' << @shared_xml_string << '</sst>'
     end
 
     private
-    
-    # Interate over all of the cells in the array. 
-    # if our unique cells array does not contain a sharable cell, 
+
+    # Interate over all of the cells in the array.
+    # if our unique cells array does not contain a sharable cell,
     # add the cell to our unique cells array and set the ssti attribute on the index of this cell in the shared strings table
     # if a sharable cell already exists in our unique_cells array, set the ssti attribute of the cell and move on.
     # @return [Array] unique cells
     def resolve(cells)
       cells.each do |cell|
-        index = @unique_cells.index { |item| item.shareable(cell) }
+        cell_hash = cell.shareable_hash
+        index = @unique_cells.index do |item|
+          item == cell_hash
+        end
         if index == nil
           cell.send :ssti=, @unique_cells.size
-          @unique_cells << cell
+          @shared_xml_string << '<si>' << cell.run_xml_string << '</si>'
+          @unique_cells << cell_hash
         else
           cell.send :ssti=, index
         end
       end
-    end    
+    end
   end
 end

data/lib/axlsx/workbook/workbook.rb

@@ -5,8 +5,10 @@ require 'axlsx/workbook/worksheet/date_time_converter.rb'
 require 'axlsx/workbook/worksheet/cell.rb'
 require 'axlsx/workbook/worksheet/page_margins.rb'
 require 'axlsx/workbook/worksheet/row.rb'
+require 'axlsx/workbook/worksheet/col.rb'
 require 'axlsx/workbook/worksheet/worksheet.rb'
 require 'axlsx/workbook/shared_strings_table.rb'
+require 'axlsx/workbook/worksheet/table.rb'
 
   # The Workbook class is an xlsx workbook that manages worksheets, charts, drawings and styles.
   # The following parts of the Office Open XML spreadsheet specification are not implimented in this version.
@@ -46,7 +48,7 @@ require 'axlsx/workbook/shared_strings_table.rb'
     end
 
 
-    # A collection of worksheets associated with this workbook.
+   # A collection of worksheets associated with this workbook.
     # @note The recommended way to manage worksheets is add_worksheet
     # @see Workbook#add_worksheet
     # @see Worksheet
@@ -74,6 +76,14 @@ require 'axlsx/workbook/shared_strings_table.rb'
     # @return [SimpleTypedList]
     attr_reader :drawings
 
+    # A colllection of tables associated with this workbook
+    # @note The recommended way to manage drawings is Worksheet#add_table
+    # @see Worksheet#add_table
+    # @see Table
+    # @return [SimpleTypedList]
+    attr_reader :tables
+
+
     # The styles associated with this workbook
     # @note The recommended way to manage styles is Styles#add_style
     # @see Style#add_style
@@ -88,6 +98,7 @@ require 'axlsx/workbook/shared_strings_table.rb'
     # Indicates if the epoc date for serialization should be 1904. If false, 1900 is used.
     @@date1904 = false
 
+
     # lets come back to this later when we are ready for parsing.
     #def self.parse entry
     #  io = entry.get_input_stream
@@ -106,6 +117,9 @@ require 'axlsx/workbook/shared_strings_table.rb'
       @drawings = SimpleTypedList.new Drawing
       @charts = SimpleTypedList.new Chart
       @images = SimpleTypedList.new Pic
+      @tables = SimpleTypedList.new Table
+      @use_autowidth = true
+
       self.date1904= !options[:date1904].nil? && options[:date1904]
       yield self if block_given?
     end
@@ -125,6 +139,14 @@ require 'axlsx/workbook/shared_strings_table.rb'
     # @return [Boolean]
     def self.date1904() @@date1904; end
 
+    # Indicates if the workbook should use autowidths or not.
+    # this must be set before instantiating a worksheet to avoid Rmagix inclusion
+    # @return [Boolean]
+    def use_autowidth() @use_autowidth; end
+
+    # see @use_autowidth
+    def use_autowidth=(v) Axlsx::validate_boolean v; @use_autowidth = v; end
+
     # Adds a worksheet to this workbook
     # @return [Worksheet]
     # @option options [String] name The name of the worksheet.
@@ -167,27 +189,29 @@ require 'axlsx/workbook/shared_strings_table.rb'
       worksheet[cell_def.gsub(/.+!/,"")]
     end
 
-    # Serializes the workbook document
+    # Serialize the workbook
+    # @param [String] str
     # @return [String]
-    def to_xml()
+    def to_xml_string(str='')
       add_worksheet unless worksheets.size > 0
-      builder = Nokogiri::XML::Builder.new(:encoding => ENCODING) do |xml|
-        xml.workbook(:xmlns => XML_NS, :'xmlns:r' => XML_NS_R) {
-          xml.workbookPr(:date1904=>@@date1904)
-          #<x:workbookProtection workbookPassword="xsd:hexBinary data" lockStructure="1" lockWindows="1" />
-          # Required to support rubyXL parsing as it requires sheetView, which requires this.
-          # and removed because it seems to cause some odd [Grouped] behaviour in excel.
-          # xml.bookViews {
-          #    xml.workbookView :activeTab=>0
-          # }
-          xml.sheets {
-            @worksheets.each_with_index do |sheet, index|
-              xml.sheet(:name=>sheet.name, :sheetId=>index+1, :"r:id"=>sheet.rId)
-            end
-          }
-        }
+      str << '<?xml version="1.0" encoding="UTF-8"?>'
+      str << '<workbook xmlns="' << XML_NS << '" xmlns:r="' << XML_NS_R << '">'
+      str << '<workbookPr date1904="' << @@date1904.to_s << '"/>'
+      str << '<sheets>'
+      @worksheets.each_with_index do |sheet, index|
+         str << '<sheet name="' << sheet.name << '" sheetId="' << (index+1).to_s << '" r:id="' << sheet.rId << '"/>'
       end
-      builder.to_xml(:save_with => 0)
+      str << '</sheets>'
+      str << '<definedNames>'
+      @worksheets.each_with_index do |sheet, index|
+        if sheet.auto_filter
+          str << '<definedName name="_xlnm._FilterDatabase" localSheetId="' << index.to_s << '" hidden="1">'
+          str << sheet.abs_auto_filter << '</definedName>'
+        end
+      end
+      str << '</definedNames>'
+      str << '</workbook>'
     end
+
   end
 end

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

@@ -1,4 +1,5 @@
 # encoding: UTF-8
+require 'cgi'
 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.
@@ -25,12 +26,16 @@ module Axlsx
 
 
     # An array of available inline styes.
+    # TODO change this to a hash where each key defines attr name and validator (and any info the validator requires)
+    # then move it out to a module so we can re-use in in other classes.
+    # 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']
 
-
     # The index of the cellXfs item to be applied to this cell.
     # @return [Integer]
     # @see Axlsx::Styles
@@ -69,71 +74,79 @@ module Axlsx
       @value = cast_value(v)
     end
 
+
+    # Indicates that the cell has one or more of the custom cell styles applied.
+    # @return [Boolean]
+    def is_text_run?
+      @is_text_run ||= false
+    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
+    def font_name=(v) set_run_style :validate_string, :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
+    def charset=(v) set_run_style :validate_unsigned_int, :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
+    def family=(v) set_run_style :validate_string, :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
+    def b=(v) set_run_style :validate_boolean, :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
+    def i=(v) set_run_style :validate_boolean, :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
+    def strike=(v) set_run_style :validate_boolean, :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
+    def outline=(v) set_run_style :validate_boolean, :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
+    def shadow=(v) set_run_style :validate_boolean, :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
+    def condense=(v) set_run_style :validate_boolean, :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
+    def extend=(v) set_run_style :validate_boolean, :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
+    def u=(v) set_run_style :validate_boolean, :u, v; end
 
     # The inline color property for the cell
     # @return [Color]
@@ -141,27 +154,34 @@ module Axlsx
     # @param [String] The 8 character representation for an rgb color #FFFFFFFF"
     def color=(v)
       @color = v.is_a?(Color) ? v : Color.new(:rgb=>v)
+      @has_run_style = true
     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
+    def sz=(v) set_run_style :validate_unsigned_int, :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
+    def vertAlign=(v)
+      RestrictionValidator.validate "Cell.vertAlign", [:baseline, :subscript, :superscript], v
+      set_run_style nil, :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
+    def scheme=(v)
+      RestrictionValidator.validate "Cell.schema", [:none, :major, :minor], v
+      set_run_style nil, :scheme, v
+    end
 
     # @param [Row] row The row this cell belongs to.
     # @param [Any] value The value associated with this cell.
@@ -202,16 +222,11 @@ module Axlsx
 
     # equality comparison to test value, type and inline style attributes
     # this is how we work out if the cell needs to be added or already exists in the shared strings table
-    def shareable(v)
-
-      #using reject becase 1.8.7 select returns an array...
-      v_hash = v.instance_values.reject { |key, val| !INLINE_STYLES.include?(key) }
-      self_hash = self.instance_values.reject { |key, val| !INLINE_STYLES.include?(key) }
-      # required as color is an object, and the comparison will fail even though both use the same color.
-      v_hash['color'] = v_hash['color'].instance_values if v_hash['color']
+    def shareable_hash
+      self_hash = {}
+      INLINE_STYLES.each { |style| self_hash[style] = self.instance_variable_get("@" + style) }
       self_hash['color'] = self_hash['color'].instance_values if self_hash['color']
-
-      v_hash == self_hash
+      self_hash
     end
 
     # @return [Integer] The index of the cell in the containing row.
@@ -222,15 +237,16 @@ module Axlsx
     # @return [String] The alpha(column)numeric(row) reference for this sell.
     # @example Relative Cell Reference
     #   ws.rows.first.cells.first.r #=> "A1"
+    # @note this will be discontinued in 1.1.0 -  prefer Axlsx.cell_r
     def r
-      "#{col_ref}#{@row.index+1}"
+      "#{Axlsx::col_ref(index)}#{@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('$')}"
+      "$#{r.match(%r{([A-Z]+)([0-9]+)})[1,2].join('$')}"
     end
 
     # @return [Integer] The cellXfs item index applied to this cell.
@@ -259,77 +275,76 @@ module Axlsx
       self.row.worksheet.merge_cells "#{self.r}:#{range_end}" unless range_end.nil?
     end
 
-    # builds an xml text run based on this cells attributes. This is extracted from to_xml so that shared strings can use it.
-    # @param [Nokogiri::XML::Builder] xml The document builder instance this output will be added to.
-    # @return [String] the xml for this cell's text run
-    def run_xml(xml)
-      if (self.instance_values.keys & INLINE_STYLES).size > 0
-        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 @vertAlign
-            # :none, major, :minor
-            xml.scheme(:val=>@scheme) if @scheme
-          }
-          xml.t @value.to_s
-        }
+    # 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(str = '')
+      if is_text_run?
+        data = self.instance_values.reject{|key, value| value == nil }
+        keys = data.keys & INLINE_STYLES
+        keys.delete ['value', 'type']
+        str << "<r><rPr>"
+        keys.each do |key|
+          case key
+          when 'font_name'
+            str << "<rFont val='"<< @font_name << "'/>"
+          when 'color'
+            str << data[key].to_xml_string
+          else
+            "<" << key.to_s << " val='" << data[key].to_s << "'/>"
+          end
+        end
+        str << "</rPr>" << "<t>" << value.to_s << "</t></r>"
       else
-        xml.t @value.to_s
+        str << "<t>" << value.to_s << "</t>"
       end
+      str
     end
 
     # Serializes the cell
-    # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
+    # @param [Integer] r_index The row index for the cell
+    # @param [Integer] c_index The cell index in the row.
+    # @param [String] str The string index the cell content will be appended to. Defaults to empty string.
     # @return [String] xml text for the cell
-    def to_xml(xml)
-      if @type == :string
+    def to_xml_string(r_index, c_index, str = '')
+      return str if @value.nil?
+      str << '<c r="' << Axlsx::cell_r(c_index, r_index) << '" s="' << @style.to_s << '" '
+      case @type
+      when :string
         #parse formula
         if @value.start_with?('=')
-          xml.c(:r => r, :t=>:str, :s=>style) {
-            xml.f @value.to_s.gsub('=', '')
-          }
+          str  << 't="str"><f>' << @value.to_s.gsub('=', '') << '</f>'
         else
           #parse shared
           if @ssti
-            xml.c(:r => r, :s=>style, :t => :s) { xml.v ssti }
+            str << 't="s"><v>' << @ssti.to_s << '</v>'
           else
-            #parse inline string
-            xml.c(:r => r, :s=>style, :t => :inlineStr) {
-              xml.is {
-                run_xml(xml)
-              }
-            }
+            str << 't="inlineStr"><is>' << run_xml_string << '</is>'
           end
         end
-      elsif @type == :date
+      when :date
         # TODO: See if this is subject to the same restriction as Time below
-        v = DateTimeConverter::date_to_serial @value
-        xml.c(:r => r, :s => style) { xml.v v }
-      elsif @type == :time
-        v = DateTimeConverter::time_to_serial @value
-        xml.c(:r => r, :s => style) { xml.v v }
-      elsif @type == :boolean
-        xml.c(:r => r, :s => style, :t => :b) { xml.v value }
+        str << '><v>' << DateTimeConverter::date_to_serial(@value).to_s << '</v>'
+      when :time
+        str << '><v>' << DateTimeConverter::time_to_serial(@value).to_s << '</v>'
+      when :boolean
+        str << 't="b"><v>' << @value.to_s << '</v>'
       else
-        xml.c(:r => r, :s => style) { xml.v value }
+        str << '><v>' << @value.to_s << '</v>'
       end
+      str << '</c>'
     end
 
     private
 
+    # 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
+      self.instance_variable_set :"@#{attr.to_s}", value
+      @is_text_run = true
+    end
+
     # @see ssti
     def ssti=(v)
       Axlsx::validate_unsigned_int(v)
@@ -339,20 +354,6 @@ module Axlsx
     # 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 Date, the type is set to :date
@@ -382,6 +383,7 @@ 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
         self.style = STYLE_DATE if self.style == 0
         v
@@ -396,7 +398,7 @@ module Axlsx
         v ? 1 : 0
       else
         @type = :string
-        v.to_s
+        ::CGI.escapeHTML(v.to_s)
       end
     end
   end