Some small improvements

					 total        real
axlsx_noautowidth    1.650000 (  1.684738)
axlsx                4.470000 (  4.580439)
axlsx_shared         7.990000 (  8.151813)
axlsx_stream         4.420000 (  4.435809)
csv                  0.250000 (  0.259114)

4 files changed, 89 insertions, 41 deletions

diff --git a/lib/axlsx/package.rb b/lib/axlsx/package.rb
index 505f8cc9..35ab181a 100644
--- a/lib/axlsx/package.rb
+++ b/lib/axlsx/package.rb
@@ -196,7 +196,7 @@ module Axlsx
       end
 
       if use_shared_strings
-        @parts << {:entry => "xl/#{SHARED_STRINGS_PN}", :doc => workbook.shared_strings.to_xml, :schema => SML_XSD}
+        @parts << {:entry => "xl/#{SHARED_STRINGS_PN}", :doc => workbook.shared_strings.to_xml_string, :schema => SML_XSD}
       end
 
       workbook.worksheets.each do |sheet|
diff --git a/lib/axlsx/stylesheet/color.rb b/lib/axlsx/stylesheet/color.rb
index 4e9806ad..a4942724 100644
--- a/lib/axlsx/stylesheet/color.rb
+++ b/lib/axlsx/stylesheet/color.rb
@@ -5,9 +5,9 @@ module Axlsx
     # Determines if the color is system color dependant
     # @return [Boolean]
     attr_reader :auto
-    
-    # The color as defined in rgb terms. 
-    # @note 
+
+    # The color as defined in rgb terms.
+    # @note
     #  rgb colors need to conform to ST_UnsignedIntHex. That basically means put 'FF' before you color
     # When assigning the rgb value the behavior is much like CSS selectors and can use shorthand versions as follows:
     # If you provide a two character value it will be repeated for each r, g, b assignment
@@ -25,16 +25,16 @@ module Axlsx
     # no support for theme just yet
     # @return [Integer]
     #attr_reader :theme
-    
+
     # The tint value.
     # @note valid values are between -1.0 and 1.0
     # @return [Float]
     attr_reader :tint
-    
+
     # Creates a new Color object
     # @option options [Boolean] auto
     # @option options [String] rgb
-    # @option options [Float] tint    
+    # @option options [Float] tint
     def initialize(options={})
       @rgb = "FF000000"
       options.each do |o|
@@ -42,7 +42,7 @@ module Axlsx
       end
     end
     # @see auto
-    def auto=(v) Axlsx::validate_boolean v; @auto = v end    
+    def auto=(v) Axlsx::validate_boolean v; @auto = v end
     # @see color
     def rgb=(v)
       Axlsx::validate_string(v)
@@ -56,11 +56,19 @@ module Axlsx
     def tint=(v) Axlsx::validate_float v; @tint = v end
 
     # This version does not support themes
-    # def theme=(v) Axlsx::validate_unsigned_integer v; @theme = v end    
-    
+    # def theme=(v) Axlsx::validate_unsigned_integer v; @theme = v end
+
     # Indexed colors are for backward compatability which I am choosing not to support
-    # def indexed=(v) Axlsx::validate_unsigned_integer v; @indexed = v end     
+    # def indexed=(v) Axlsx::validate_unsigned_integer v; @indexed = v end
 
+    def to_xml_string
+      str = ["<color "]
+      str << "tint='%s' " % tint if @tint
+      str << "rgb='%s' " % rgb if @rgb
+      str << "auto='%s'" % auto if @auto
+      str << "/>"
+      str.join
+    end
 
     # Serializes the color
     # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
diff --git a/lib/axlsx/workbook/shared_strings_table.rb b/lib/axlsx/workbook/shared_strings_table.rb
index 91892c38..2fffdd6b 100644
--- a/lib/axlsx/workbook/shared_strings_table.rb
+++ b/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,14 +15,14 @@ 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
 
@@ -35,10 +35,14 @@ module Axlsx
       resolve(cells)
     end
 
+    def to_xml_string
+      str = "<sst xmlns=\"%s\" count='%s' uniqueCount='%s'>%s</sst>" % [XML_NS, count, unique_count, @unique_cells.map {|cell| cell.run_xml_string}.join]
+    end
 
     # Generate the xml document for the Shared Strings Table
     # @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|
@@ -50,9 +54,9 @@ module Axlsx
     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
@@ -66,6 +70,6 @@ module Axlsx
           cell.send :ssti=, index
         end
       end
-    end    
+    end
   end
 end
diff --git a/lib/axlsx/workbook/worksheet/cell.rb b/lib/axlsx/workbook/worksheet/cell.rb
index 5e59aa40..4ed8c1a4 100644
--- a/lib/axlsx/workbook/worksheet/cell.rb
+++ b/lib/axlsx/workbook/worksheet/cell.rb
@@ -25,11 +25,18 @@ module Axlsx
 
 
     # An array of available inline styes.
-    INLINE_STYLES = ['value', 'type', 'font_name', 'charset',
+    # 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 = ['font_name', 'charset',
                          'family', 'b', 'i', 'strike','outline',
                          'shadow', 'condense', 'extend', 'u',
                          'vertAlign', 'sz', 'color', 'scheme']
 
+    INLINE_ATTR = [:font_name => { :validator=>:validate_string}]
+
 
     # The index of the cellXfs item to be applied to this cell.
     # @return [Integer]
@@ -69,71 +76,85 @@ 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
+
+
+    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
     # 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 +162,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.
@@ -259,14 +287,23 @@ module Axlsx
       self.row.worksheet.merge_cells "#{self.r}:#{range_end}" unless range_end.nil?
     end
 
-
     def run_xml_string
-      #if (self.instance_values.keys & INLINE_STYLES).size > 0
-      #  str = "<r><rPr></rPr><r>"
-      #else
-      #  "<t>%s</t>" % value.to_s
-      #end
-      "<t>%s</t>" % value.to_s
+      str = []
+      if is_text_run?
+        keys = self.instance_values.reject{|key, value| value == nil }.keys & INLINE_STYLES
+        keys.delete 'font_name'
+        str << "<r><rPr>"
+        str << "<rFont val='%s'/>" % @font_name if @font_name
+        keys.each do |key|
+          str << "<%s val='%s'/>" % [key, self.instance_values[key]]
+        end
+        str << "</rPr>"
+        str << "<t>%s</t>" % value.to_s
+        str << "</r>"
+      else
+        str << "<t>%s</t>" % value.to_s
+      end
+      str.join
     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.
@@ -303,7 +340,6 @@ module Axlsx
     # 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
-
     FORMULA = "<c r=\"%s\" t=\"str\" s=\"%i\"><f>%s</f></c>"
     SHARED_STRING = "<c r=\"%s\" t=\"s\" s=\"%i\"><v>%i</v></c>"
     INLINE_STRING = "<c r=\"%s\" t=\"inlineStr\" s=\"%i\"><is>%s</is></c>"