axlsx 1.0.15 → 1.1.0

data/lib/axlsx/drawing/series_title.rb

@@ -1,22 +1,23 @@
+# encoding: UTF-8
 module Axlsx
   # A series title is a Title with a slightly different serialization than chart titles.
   class SeriesTitle < Title
 
-    # Serializes the series title
-    # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
+    # Serializes the object
+    # @param [String] str
     # @return [String]
-    def to_xml(xml)
-      xml[:c].tx {
-        xml[:c].strRef {
-          xml[:c].f Axlsx::cell_range([@cell])
-          xml[:c].strCache {
-            xml[:c].ptCount :val=>1
-            xml[:c].pt(:idx=>0) {
-              xml[:c].v @text
-            }
-          }
-        }
-      }
+    def to_xml_string(str = '')
+      str << '<c:tx>'
+      str << '<c:strRef>'
+      str << '<c:f>' << Axlsx::cell_range([@cell]) << '</c:f>'
+      str << '<c:strCache>'
+      str << '<c:ptCount val="1"/>'
+      str << '<c:pt idx="0">'
+      str << '<c:v>' << @text << '</c:v>'
+      str << '</c:pt>'
+      str << '</c:strCache>'
+      str << '</c:strRef>'
+      str << '</c:tx>'
     end
   end
 end

data/lib/axlsx/drawing/title.rb

@@ -1,7 +1,8 @@
+# encoding: UTF-8
 module Axlsx
   # A Title stores information about the title of a chart
   class Title
-    
+
     # The text to be shown. Setting this property directly with a string will remove the cell reference.
     # @return [String]
     attr_reader :text
@@ -16,9 +17,9 @@ module Axlsx
       self.cell = title if title.is_a?(Cell)
       self.text = title.to_s unless title.is_a?(Cell)
     end
-    
+
     # @see text
-    def text=(v) 
+    def text=(v)
       DataTypeValidator.validate 'Title.text', String, v
       @text = v
       @cell = nil
@@ -29,7 +30,7 @@ module Axlsx
     def cell=(v)
       DataTypeValidator.validate 'Title.text', Cell, v
       @cell = v
-      @text = v.value.to_s      
+      @text = v.value.to_s
       v
     end
 
@@ -37,29 +38,29 @@ module Axlsx
     #def layout=(v) DataTypeValidator.validate 'Title.layout', Layout, v; @layout = v; end
     #def overlay=(v) Axlsx::validate_boolean v; @overlay=v; end
     #def spPr=(v) DataTypeValidator.validate 'Title.spPr', SpPr, v; @spPr = v; end
-    
-    # Serializes the chart title
-    # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
+
+    # Serializes the object
+    # @param [String] str
     # @return [String]
-    def to_xml(xml)
-      xml[:c].title {
-        unless @text.empty?
-          xml[:c].tx {
-            xml[:c].strRef {
-              xml[:c].f Axlsx::cell_range([@cell])
-              xml[:c].strCache {
-                xml[:c].ptCount :val=>1
-                xml[:c].pt(:idx=>0) {
-                  xml[:c].v @text
-                }
-              }
-            }
-          }
-        end
-        xml[:c].layout
-        xml[:c].overlay :val=>0
-      }      
+    def to_xml_string(str = '')
+      str << '<c:title>'
+      unless @text.empty?
+        str << '<c:tx>'
+        str << '<c:strRef>'
+        str << '<c:f>' << Axlsx::cell_range([@cell]) << '</c:f>'
+        str << '<c:strCache>'
+        str << '<c:ptCount val="1"/>'
+        str << '<c:pt idx="0">'
+        str << '<c:v>' << @text << '</c:v>'
+        str << '</c:pt>'
+        str << '</c:strCache>'
+        str << '</c:strRef>'
+        str << '</c:tx>'
+      end
+      str << '<c:layout/>'
+      str << '<c:overlay val="0"/>'
+      str << '</c:title>'
     end
-    
+
   end
 end

data/lib/axlsx/drawing/two_cell_anchor.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 module Axlsx
   # This class details the anchor points for drawings.
   # @note The recommended way to manage drawings and charts is Worksheet#add_chart. Anchors are specified by the :start_at and :end_at options to that method.
@@ -25,7 +26,7 @@ module Axlsx
     attr_reader :drawing
 
 
-    # Creates a new TwoCellAnchor object and sets up a reference to the from and to markers in the 
+    # Creates a new TwoCellAnchor object and sets up a reference to the from and to markers in the
     # graphic_frame's chart. That means that you can do stuff like
     # c = worksheet.add_chart Axlsx::Chart
     # c.start_at 5, 9
@@ -37,13 +38,13 @@ module Axlsx
     # @option options [Array] end_at the col, row to end at
     def initialize(drawing, options={})
       @drawing = drawing
-      drawing.anchors << self      
+      drawing.anchors << self
       @from, @to =  Marker.new, Marker.new(:col => 5, :row=>10)
     end
 
     # Creates a graphic frame and chart object associated with this anchor
     # @return [Chart]
-    def add_chart(chart_type, options)      
+    def add_chart(chart_type, options)
       @object = GraphicFrame.new(self, chart_type, options)
       @object.chart
     end
@@ -53,24 +54,22 @@ module Axlsx
     def index
       @drawing.anchors.index(self)
     end
-    # Serializes the two cell anchor
-    # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
-    # @return [String]
-    def to_xml(xml)
-      #build it for now, break it down later!
-      xml[:xdr].twoCellAnchor {
-        xml.from {
-          from.to_xml(xml)
-        }
-        xml.to {
-          to.to_xml(xml)
-        }
-        @object.to_xml(xml)
-        xml.clientData
-      }
-    end    
 
-    private
+    # Serializes the object
+    # @param [String] str
+    # @return [String]
+    def to_xml_string(str = '')
+      str << '<xdr:twoCellAnchor>'
+      str << '<xdr:from>'
+      from.to_xml_string str
+      str << '</xdr:from>'
+      str << '<xdr:to>'
+      to.to_xml_string str
+      str << '</xdr:to>'
+      object.to_xml_string(str)
+      str << '<xdr:clientData/>'
+      str << '</xdr:twoCellAnchor>'
+    end
 
   end
 end

data/lib/axlsx/drawing/val_axis.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 module Axlsx
   # the ValAxis class defines a chart value axis.
   class ValAxis < Axis
@@ -21,14 +22,15 @@ module Axlsx
     # @see crossBetween
     def crossBetween=(v) RestrictionValidator.validate "ValAxis.crossBetween", [:between, :midCat], v; @crossBetween = v; end
 
-    # Serializes the value axis
-    # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
+    # Serializes the object
+    # @param [String] str
     # @return [String]
-    def to_xml(xml)
-      xml.valAx {
-        super(xml)
-        xml.crossBetween :val=>@crossBetween
-      }
+    def to_xml_string(str = '')
+      str << '<c:valAx>'
+      super(str)
+      str << '<c:crossBetween val="' << @crossBetween.to_s << '"/>'
+      str << '</c:valAx>'
     end
+
   end
 end

data/lib/axlsx/drawing/val_axis_data.rb

@@ -1,26 +1,27 @@
+# encoding: UTF-8
 module Axlsx
   # The ValAxisData class manages the values for a chart value series.
   class ValAxisData < CatAxisData
 
-    # Serializes the value axis data
-    # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
+    # Serializes the object
+    # @param [String] str
     # @return [String]
-    def to_xml(xml)
-      xml.val {
-        xml.numRef {
-          xml.f Axlsx::cell_range(@list)
-          xml.numCache {
-            xml.formatCode 'General'
-            xml.ptCount :val=>size
-            each_with_index do |item, index|
-              v = item.is_a?(Cell) ? item.value : item
-              xml.pt(:idx=>index) { xml.v v }
-            end
-          }                        
-        }
-      }
+    def to_xml_string(str = '')
+      str << '<c:val>'
+      str << '<c:numRef>'
+      str << '<c:f>' << Axlsx::cell_range(@list) << '</c:f>'
+      str << '<c:numCache>'
+      str << '<c:formatCode>General</c:formatCode>'
+      str << '<c:ptCount val="' << size.to_s << '"/>'
+      each_with_index do |item, index|
+        v = item.is_a?(Cell) ?  item.value.to_s : item
+        str << '<c:pt idx="' << index.to_s << '"><c:v>' << v << '</c:v></c:pt>'
+      end
+      str << '</c:numCache>'
+      str << '</c:numRef>'
+      str << '</c:val>'
     end
 
   end
-  
+
 end

data/lib/axlsx/drawing/view_3D.rb

@@ -1,37 +1,38 @@
+# encoding: UTF-8
 module Axlsx
   # 3D attributes for a chart.
   class View3D
 
     # Validation for hPercent
     H_PERCENT_REGEX = /0*(([5-9])|([1-9][0-9])|([1-4][0-9][0-9])|500)%/
-    
+
     # validation for depthPercent
     DEPTH_PERCENT_REGEX = /0*(([2-9][0-9])|([1-9][0-9][0-9])|(1[0-9][0-9][0-9])|2000)%/
 
-    # x rotation for the chart 
+    # x rotation for the chart
     # must be between -90 and 90
     # @return [Integer]
     attr_reader :rotX
-    
+
     # height of chart as % of chart
     # must be between 5% and 500%
     # @return [String]
     attr_reader :hPercent
-    
+
     # y rotation for the chart
     # must be between 0 and 360
     # @return [Integer]
     attr_reader :rotY
-    
+
     # depth or chart as % of chart width
     # must be between 20% and 2000%
     # @return [String]
     attr_reader :depthPercent
-    
+
     # Chart axis are at right angles
     # @return [Boolean]
     attr_reader :rAngAx
-    
+
     # field of view angle
     # @return [Integer]
     attr_reader :perspective
@@ -44,10 +45,10 @@ module Axlsx
     # @option options [Boolean] rAngAx
     # @option options [Integer] perspective
     def initialize(options={})
-      @rotX, @hPercent, @rotY, @depthPercent, @rAngAx, @perspective  = nil, nil, nil, nil, nil, nil 
+      @rotX, @hPercent, @rotY, @depthPercent, @rAngAx, @perspective  = nil, nil, nil, nil, nil, nil
       options.each do |o|
         self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
-      end    
+      end
     end
 
     # @see rotX
@@ -68,18 +69,20 @@ module Axlsx
     # @see perspective
     def perspective=(v) DataTypeValidator.validate "#{self.class}.perspective", [Integer, Fixnum], v, lambda {|arg| arg >= 0 && arg <= 240 }; @perspective = v; end
 
-    # Serializes the view3D properties
-    # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
+
+    # Serializes the object
+    # @param [String] str
     # @return [String]
-    def to_xml(xml)
-      xml[:c].view3D {
-        xml[:c].rotX :val=>@rotX unless @rotX.nil?
-        xml[:c].hPercent :val=>@hPercent unless @hPercent.nil?
-        xml[:c].rotY :val=>@rotY unless @rotY.nil?
-        xml[:c].depthPercent :val=>@depthPercent unless @depthPercent.nil?
-        xml[:c].rAngAx :val=>@rAngAx unless @rAngAx.nil?
-        xml[:c].perspective :val=>@perspective unless @perspective.nil?
-      }
+    def to_xml_string(str = '')
+      str << '<c:view3D>'
+      str << '<c:rotX val="' << @rotX.to_s << '"/>' unless @rotX.nil?
+      str << '<c:hPercent val="' << @hPercent.to_s << '"/>' unless @hPercent.nil?
+      str << '<c:rotY val="' << @rotY.to_s << '"/>' unless @rotY.nil?
+      str << '<c:depthPercent val="' << @depthPercent.to_s << '"/>' unless @depthPercent.nil?
+      str << '<c:rAngAx val="' << @rAngAx.to_s << '"/>' unless @rAngAx.nil?
+      str << '<c:perspective val="' << @perspective.to_s << '"/>' unless @perspective.nil?
+      str << '</c:view3D>'
     end
+
   end
 end

data/lib/axlsx/package.rb

@@ -1,10 +1,10 @@
-# -*- coding: utf-8 -*-
+# encoding: UTF-8
 module Axlsx
   # Package is responsible for managing all the bits and peices that Open Office XML requires to make a valid
   # xlsx document including valdation and serialization.
   class Package
 
-    # plain text password
+
     # provides access to the app doc properties for this package
     # see App
     attr_reader :app
@@ -17,18 +17,43 @@ module Axlsx
     #
     # @param [Hash] options A hash that you can use to specify the author and workbook for this package.
     # @option options [String] :author The author of the document
+    # @option options [Boolean] :use_shared_strings This is passed to the workbook to specify that shared strings should be used when serializing the package.
     # @example Package.new :author => 'you!', :workbook => Workbook.new
     def initialize(options={})
       @workbook = nil
       @core, @app  =  Core.new, App.new
       @core.creator = options[:author] || @core.creator
+      options.each do |o|
+        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
+      end
       yield self if block_given?
     end
 
+    # Shortcut to specify that the workbook should use autowidth
+    # @see Workbook#use_autowidth
+    def use_autowidth=(v)
+      Axlsx::validate_boolean(v);
+      workbook.use_autowidth = v
+    end
+
+
+    # Shortcut to specify that the workbook should use shared strings
+    # @see Workbook#use_shared_strings
+    def use_shared_strings=(v)
+      Axlsx::validate_boolean(v);
+      workbook.use_shared_strings = v
+    end
+
+    # Shortcut to determine if the workbook is configured to use shared strings
+    # @see Workbook#use_shared_strings
+    def use_shared_strings
+      workbook.use_shared_strings
+    end
+
     # The workbook this package will serialize or validate.
     # @return [Workbook] If no workbook instance has been assigned with this package a new Workbook instance is returned.
     # @raise ArgumentError if workbook parameter is not a Workbook instance.
-    # @note As there are multiple ways to instantiate a workbook for the package, 
+    # @note As there are multiple ways to instantiate a workbook for the package,
     #   here are a few examples:
     #     # assign directly during package instanciation
     #     wb = Package.new(:workbook => Workbook.new).workbook
@@ -42,13 +67,13 @@ module Axlsx
       yield @workbook if block_given?
       @workbook
     end
-    
+
     #def self.parse(input, confirm_valid = false)
     #  p = Package.new
     #  z = Zip::ZipFile.open(input)
     #  p.workbook = Workbook.parse z.get_entry(WORKBOOK_PN)
     #  p
-    #end    
+    #end
 
     # @see workbook
     def workbook=(workbook) DataTypeValidator.validate "Package.workbook", Workbook, workbook; @workbook = workbook; end
@@ -57,9 +82,10 @@ module Axlsx
     #
     # @param [File] output The file you want to serialize your package to
     # @param [Boolean] confirm_valid Validate the package prior to serialization.
+    # @option options stream indicates if we should be writing to a stream or a file. True for stream, nil for file
     # @return [Boolean] False if confirm_valid and validation errors exist. True if the package was serialized
     # @note A tremendous amount of effort has gone into ensuring that you cannot create invalid xlsx documents.
-    #   confirm_valid should be used in the rare case that you cannot open the serialized file. 
+    #   confirm_valid should be used in the rare case that you cannot open the serialized file.
     # @see Package#validate
     # @example
     #   # This is how easy it is to create a valid xlsx file. Of course you might want to add a sheet or two, and maybe some data, styles and charts.
@@ -70,35 +96,37 @@ module Axlsx
     #   # You will find a file called test.xlsx
     def serialize(output, confirm_valid=false)
       return false unless !confirm_valid || self.validate.empty?
-      p = parts
       Zip::ZipOutputStream.open(output) do |zip|
-        p.each do |part| 
-          unless part[:doc].nil?
-            zip.put_next_entry(part[:entry]);
-            entry = ['1.9.2', '1.9.3'].include?(RUBY_VERSION) ? part[:doc].force_encoding('BINARY') : part[:doc]
-            zip.puts(entry)
-          end
-          unless part[:path].nil?
-            zip.put_next_entry(part[:entry]); 
-            # binread for 1.9.3
-            zip.write IO.respond_to?(:binread) ? IO.binread(part[:path]) : IO.read(part[:path])
-          end          
-        end
+        write_parts(zip)
       end
       true
     end
-    
+
+
+    # Serialize your workbook to a StringIO instance
+    # @param [Boolean] confirm_valid Validate the package prior to serialization.
+    # @return [StringIO|Boolean] False if confirm_valid and validation errors exist. rewound string IO if not.
+    def to_stream(confirm_valid=false)
+      return false unless !confirm_valid || self.validate.empty?
+      zip = write_parts(Zip::ZipOutputStream.new("streamed", true))
+      stream = zip.close_buffer
+      stream.rewind
+      stream
+    end
+
     # Encrypt the package into a CFB using the password provided
-    # def encrypt(file_name, password)      
-    #   moc = MsOffCrypto.new(file_name, password)
-    #   moc.save    
-    # end
-    
-    # Validate all parts of the package against xsd schema. 
+    # This is not ready yet
+    def encrypt(file_name, password)
+      return false
+      # moc = MsOffCrypto.new(file_name, password)
+      # moc.save
+    end
+
+    # Validate all parts of the package against xsd schema.
     # @return [Array] An array of all validation errors found.
     # @note This gem includes all schema from OfficeOpenXML-XMLSchema-Transitional.zip and OpenPackagingConventions-XMLSchema.zip
     #   as per ECMA-376, Third edition. opc schema require an internet connection to import remote schema from dublin core for dc,
-    #   dcterms and xml namespaces. Those remote schema are included in this gem, and the original files have been altered to 
+    #   dcterms and xml namespaces. Those remote schema are included in this gem, and the original files have been altered to
     #   refer to the local versions.
     #
     #   If by chance you are able to creat a package that does not validate it indicates that the internal
@@ -111,41 +139,71 @@ module Axlsx
     #  p.validate.each { |error| puts error.message }
     def validate
       errors = []
-      parts.each { |part| errors.concat validate_single_doc(part[:schema], part[:doc]) unless part[:schema].nil? }
+      parts.each do |part|
+        errors.concat validate_single_doc(part[:schema], part[:doc]) unless part[:schema].nil?
+      end
       errors
     end
 
-    private 
+    private
+
+    # Writes the package parts to a zip archive.
+    # @param [Zip::ZipOutputStream] zip
+    # @return [Zip::ZipOutputStream]
+    def write_parts(zip)
+      p = parts
+        p.each do |part|
+          unless part[:doc].nil?
+            zip.put_next_entry(part[:entry]);
+            entry = ['1.9.2', '1.9.3'].include?(RUBY_VERSION) ? part[:doc].force_encoding('BINARY') : part[:doc]
+            zip.puts(entry)
+          end
+          unless part[:path].nil?
+            zip.put_next_entry(part[:entry]);
+            # binread for 1.9.3
+            zip.write IO.respond_to?(:binread) ? IO.binread(part[:path]) : IO.read(part[:path])
+          end
+        end
+      zip
+    end
 
     # The parts of a package
-    # @return [Array] An array of hashes that define the entry, document and schema for each part of the package. 
+    # @return [Array] An array of hashes that define the entry, document and schema for each part of the package.
     # @private
     def parts
       @parts = [
-       {:entry => RELS_PN, :doc => relationships.to_xml, :schema => RELS_XSD},
-       {:entry => "xl/#{STYLES_PN}", :doc => workbook.styles.to_xml, :schema => SML_XSD},
-       {:entry => CORE_PN, :doc => @core.to_xml, :schema => CORE_XSD},
-       {:entry => APP_PN, :doc => @app.to_xml, :schema => APP_XSD},
-       {:entry => WORKBOOK_RELS_PN, :doc => workbook.relationships.to_xml, :schema => RELS_XSD},
-       {:entry => CONTENT_TYPES_PN, :doc => content_types.to_xml, :schema => CONTENT_TYPES_XSD},
-       {:entry => WORKBOOK_PN, :doc => workbook.to_xml, :schema => SML_XSD}
+       {:entry => RELS_PN, :doc => relationships.to_xml_string, :schema => RELS_XSD},
+       {:entry => "xl/#{STYLES_PN}", :doc => workbook.styles.to_xml_string, :schema => SML_XSD},
+       {:entry => CORE_PN, :doc => @core.to_xml_string, :schema => CORE_XSD},
+       {:entry => APP_PN, :doc => @app.to_xml_string, :schema => APP_XSD},
+       {:entry => WORKBOOK_RELS_PN, :doc => workbook.relationships.to_xml_string, :schema => RELS_XSD},
+       {:entry => CONTENT_TYPES_PN, :doc => content_types.to_xml_string, :schema => CONTENT_TYPES_XSD},
+       {:entry => WORKBOOK_PN, :doc => workbook.to_xml_string, :schema => SML_XSD}
       ]
       workbook.drawings.each do |drawing|
-        @parts << {:entry => "xl/#{drawing.rels_pn}", :doc => drawing.relationships.to_xml, :schema => RELS_XSD}
-        @parts << {:entry => "xl/#{drawing.pn}", :doc => drawing.to_xml, :schema => DRAWING_XSD}
+        @parts << {:entry => "xl/#{drawing.rels_pn}", :doc => drawing.relationships.to_xml_string, :schema => RELS_XSD}
+        @parts << {:entry => "xl/#{drawing.pn}", :doc => drawing.to_xml_string, :schema => DRAWING_XSD}
+      end
+
+      workbook.tables.each do |table|
+        @parts << {:entry => "xl/#{table.pn}", :doc => table.to_xml_string, :schema => SML_XSD}
+      end
+
+      workbook.charts.each do |chart|
+        @parts << {:entry => "xl/#{chart.pn}", :doc => chart.to_xml_string, :schema => DRAWING_XSD}
       end
-        
-      workbook.charts.each do |chart|          
-        @parts << {:entry => "xl/#{chart.pn}", :doc => chart.to_xml, :schema => DRAWING_XSD}
-      end                  
 
       workbook.images.each do |image|
         @parts << {:entry => "xl/#{image.pn}", :path => image.image_src}
       end
 
-      workbook.worksheets.each do |sheet|            
-        @parts << {:entry => "xl/#{sheet.rels_pn}", :doc => sheet.relationships.to_xml, :schema => RELS_XSD}
-        @parts << {:entry => "xl/#{sheet.pn}", :doc => sheet.to_xml, :schema => SML_XSD}        
+      if use_shared_strings
+        @parts << {:entry => "xl/#{SHARED_STRINGS_PN}", :doc => workbook.shared_strings.to_xml_string, :schema => SML_XSD}
+      end
+
+      workbook.worksheets.each do |sheet|
+        @parts << {:entry => "xl/#{sheet.rels_pn}", :doc => sheet.relationships.to_xml_string, :schema => RELS_XSD}
+        @parts << {:entry => "xl/#{sheet.pn}", :doc => sheet.to_xml_string, :schema => SML_XSD}
       end
       @parts
     end
@@ -159,7 +217,6 @@ module Axlsx
     def validate_single_doc(schema, doc)
       schema = Nokogiri::XML::Schema(File.open(schema))
       doc = Nokogiri::XML(doc)
-
       errors = []
       schema.validate(doc).each do |error|
         errors << error
@@ -173,15 +230,19 @@ module Axlsx
     def content_types
       c_types = base_content_types
       workbook.drawings.each do |drawing|
-        c_types << Axlsx::Override.new(:PartName => "/xl/#{drawing.pn}", 
+        c_types << Axlsx::Override.new(:PartName => "/xl/#{drawing.pn}",
                                        :ContentType => DRAWING_CT)
       end
       workbook.charts.each do |chart|
-        c_types << Axlsx::Override.new(:PartName => "/xl/#{chart.pn}", 
-                                       :ContentType => CHART_CT)                    
+        c_types << Axlsx::Override.new(:PartName => "/xl/#{chart.pn}",
+                                       :ContentType => CHART_CT)
+      end
+      workbook.tables.each do |table|
+        c_types << Axlsx::Override.new(:PartName => "/xl/#{table.pn}",
+                                       :ContentType => TABLE_CT)
       end
       workbook.worksheets.each do |sheet|
-        c_types << Axlsx::Override.new(:PartName => "/xl/#{sheet.pn}", 
+        c_types << Axlsx::Override.new(:PartName => "/xl/#{sheet.pn}",
                                          :ContentType => WORKSHEET_CT)
       end
       exts = workbook.images.map { |image| image.extname }
@@ -195,6 +256,10 @@ module Axlsx
              end
         c_types << Axlsx::Default.new(:ContentType => ct, :Extension => ext )
       end
+      if use_shared_strings
+        c_types << Axlsx::Override.new(:PartName => "/xl/#{SHARED_STRINGS_PN}",
+                                       :ContentType => SHARED_STRINGS_CT)
+      end
       c_types
     end
 
@@ -208,7 +273,7 @@ module Axlsx
       c_types << Override.new(:PartName => "/#{APP_PN}", :ContentType => APP_CT)
       c_types << Override.new(:PartName => "/#{CORE_PN}", :ContentType => CORE_CT)
       c_types << Override.new(:PartName => "/xl/#{STYLES_PN}", :ContentType => STYLES_CT)
-      c_types << Axlsx::Override.new(:PartName => "/#{WORKBOOK_PN}", :ContentType => WORKBOOK_CT)      
+      c_types << Axlsx::Override.new(:PartName => "/#{WORKBOOK_PN}", :ContentType => WORKBOOK_CT)
       c_types.lock
       c_types
     end