caxlsx 2.0.2 → 3.0.4

data/lib/axlsx/drawing/scaling.rb

@@ -6,7 +6,7 @@ module Axlsx
     include Axlsx::OptionsParser
 
     # creates a new Scaling object
-    # @option options [Integer, Fixnum] logBase
+    # @option options [Integer] logBase
     # @option options [Symbol] orientation
     # @option options [Float] max
     # @option options [Float] min
@@ -35,7 +35,7 @@ module Axlsx
     attr_reader :min
 
     # @see logBase
-    def logBase=(v) DataTypeValidator.validate "Scaling.logBase", [Integer, Fixnum], v, lambda { |arg| arg >= 2 && arg <= 1000}; @logBase = v; end
+    def logBase=(v) DataTypeValidator.validate "Scaling.logBase", [Integer], v, lambda { |arg| arg >= 2 && arg <= 1000}; @logBase = v; end
     # @see orientation
     def orientation=(v) RestrictionValidator.validate "Scaling.orientation", [:minMax, :maxMin], v; @orientation = v; end
     # @see max
@@ -49,10 +49,10 @@ module Axlsx
     # @return [String]
     def to_xml_string(str = '')
       str << '<c:scaling>'
-      str << '<c:logBase val="' << @logBase.to_s << '"/>' unless @logBase.nil?
-      str << '<c:orientation val="' << @orientation.to_s << '"/>' unless @orientation.nil?
-      str << '<c:min val="' << @min.to_s << '"/>' unless @min.nil?
-      str << '<c:max val="' << @max.to_s << '"/>' unless @max.nil?
+      str << ('<c:logBase val="' << @logBase.to_s << '"/>') unless @logBase.nil?
+      str << ('<c:orientation val="' << @orientation.to_s << '"/>') unless @orientation.nil?
+      str << ('<c:min val="' << @min.to_s << '"/>') unless @min.nil?
+      str << ('<c:max val="' << @max.to_s << '"/>') unless @max.nil?
       str << '</c:scaling>'
     end
 

data/lib/axlsx/drawing/scatter_chart.rb

@@ -25,7 +25,7 @@ module Axlsx
     # the y value axis
     # @return [ValAxis]
     def y_val_axis
-      axes[:x_val_axis]
+      axes[:y_val_axis]
     end
     alias :yValAxis :y_val_axis
 
@@ -51,15 +51,15 @@ module Axlsx
     # @param [String] str
     # @return [String]
     def to_xml_string(str = '')
-      super(str) do |str_inner|
-        str_inner << '<c:scatterChart>'
-        str_inner << '<c:scatterStyle val="' << scatter_style.to_s << '"/>'
-        str_inner << '<c:varyColors val="' << vary_colors.to_s << '"/>'
-        @series.each { |ser| ser.to_xml_string(str_inner) }
-        d_lbls.to_xml_string(str_inner) if @d_lbls
-        axes.to_xml_string(str_inner, :ids => true)
-        str_inner << '</c:scatterChart>'
-        axes.to_xml_string(str_inner)
+      super(str) do
+        str << '<c:scatterChart>'
+        str << ('<c:scatterStyle val="' << scatter_style.to_s << '"/>')
+        str << ('<c:varyColors val="' << vary_colors.to_s << '"/>')
+        @series.each { |ser| ser.to_xml_string(str) }
+        d_lbls.to_xml_string(str) if @d_lbls
+        axes.to_xml_string(str, :ids => true)
+        str << '</c:scatterChart>'
+        axes.to_xml_string(str)
       end
       str
     end

data/lib/axlsx/drawing/scatter_series.rb

@@ -21,9 +21,25 @@ module Axlsx
     # @return [String]
     attr_reader :color
 
+    # @return [String]
+    attr_reader :ln_width
+
+    # Line smoothing between data points
+    # @return [Boolean]
+    attr_reader :smooth
+
     # Creates a new ScatterSeries
     def initialize(chart, options={})
       @xData, @yData = nil
+      if options[:smooth].nil?
+        # If caller hasn't specified smoothing or not, turn smoothing on or off based on scatter style
+        @smooth = [:smooth, :smoothMarker].include?(chart.scatter_style)
+      else
+        # Set smoothing according to the option provided
+        Axlsx::validate_boolean(options[:smooth])
+        @smooth = options[:smooth]
+      end
+      @ln_width = options[:ln_width] unless options[:ln_width].nil?
       super(chart, options)
       @xData = AxDataSource.new(:tag_name => :xVal, :data => options[:xData]) unless options[:xData].nil?
       @yData = NumDataSource.new({:tag_name => :yVal, :data => options[:yData]}) unless options[:yData].nil?
@@ -34,30 +50,47 @@ module Axlsx
       @color = v
     end
 
+    # @see smooth
+    def smooth=(v)
+      Axlsx::validate_boolean(v)
+      @smooth = v
+    end
+
+    # @see ln_width
+    def ln_width=(v)
+      @ln_width = v
+    end
+
     # Serializes the object
     # @param [String] str
     # @return [String]
     def to_xml_string(str = '')
-      super(str) do |inner_str|
+      super(str) do
         # needs to override the super color here to push in ln/and something else!
         if color
           str << '<c:spPr><a:solidFill>'
-          str << '<a:srgbClr val="' << color << '"/>'
+          str << ('<a:srgbClr val="' << color << '"/>')
           str << '</a:solidFill>'
           str << '<a:ln><a:solidFill>'
-          str << '<a:srgbClr val="' << color << '"/></a:solidFill></a:ln>'
+          str << ('<a:srgbClr val="' << color << '"/></a:solidFill></a:ln>')
           str << '</c:spPr>'
           str << '<c:marker>'
           str << '<c:spPr><a:solidFill>'
-          str << '<a:srgbClr val="' << color << '"/>'
+          str << ('<a:srgbClr val="' << color << '"/>')
           str << '</a:solidFill>'
           str << '<a:ln><a:solidFill>'
-          str << '<a:srgbClr val="' << color << '"/></a:solidFill></a:ln>'
+          str << ('<a:srgbClr val="' << color << '"/></a:solidFill></a:ln>')
           str << '</c:spPr>'
           str << '</c:marker>'
         end
-        @xData.to_xml_string(inner_str) unless @xData.nil?
-        @yData.to_xml_string(inner_str) unless @yData.nil?
+        if ln_width
+          str << '<c:spPr>'
+          str << '<a:ln w="' << ln_width.to_s << '"/>'
+          str << '</c:spPr>'
+        end
+        @xData.to_xml_string(str) unless @xData.nil?
+        @yData.to_xml_string(str) unless @yData.nil?
+        str << ('<c:smooth val="' << ((smooth) ? '1' : '0') << '"/>')
       end
       str
     end

data/lib/axlsx/drawing/ser_axis.rb

@@ -35,8 +35,8 @@ module Axlsx
     def to_xml_string(str = '')
       str << '<c:serAx>'
       super(str)
-      str << '<c:tickLblSkip val="' << @tick_lbl_skip.to_s << '"/>' unless @tick_lbl_skip.nil?
-      str << '<c:tickMarkSkip val="' << @tick_mark_skip.to_s << '"/>' unless @tick_mark_skip.nil?
+      str << ('<c:tickLblSkip val="' << @tick_lbl_skip.to_s << '"/>') unless @tick_lbl_skip.nil?
+      str << ('<c:tickMarkSkip val="' << @tick_mark_skip.to_s << '"/>') unless @tick_mark_skip.nil?
       str << '</c:serAx>'
     end
   end

data/lib/axlsx/drawing/series.rb

@@ -59,10 +59,10 @@ module Axlsx
     # @return [String]
     def to_xml_string(str = '')
       str << '<c:ser>'
-      str << '<c:idx val="' << index.to_s << '"/>'
-      str << '<c:order val="' << (order || index).to_s << '"/>'
+      str << ('<c:idx val="' << index.to_s << '"/>')
+      str << ('<c:order val="' << (order || index).to_s << '"/>')
       title.to_xml_string(str) unless title.nil?
-      yield str if block_given?
+      yield if block_given?
       str << '</c:ser>'
     end
   end

data/lib/axlsx/drawing/series_title.rb

@@ -7,13 +7,15 @@ module Axlsx
     # @param [String] str
     # @return [String]
     def to_xml_string(str = '')
+      clean_value = Axlsx::trust_input ? @text.to_s : ::CGI.escapeHTML(Axlsx::sanitize(@text.to_s))
+
       str << '<c:tx>'
       str << '<c:strRef>'
-      str << '<c:f>' << Axlsx::cell_range([@cell]) << '</c:f>'
+      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:v>' << clean_value << '</c:v>')
       str << '</c:pt>'
       str << '</c:strCache>'
       str << '</c:strRef>'

data/lib/axlsx/drawing/str_data.rb

@@ -29,12 +29,12 @@ module Axlsx
 
     # serialize the object
     def to_xml_string(str = "")
-      str << '<c:' << @tag_name.to_s << '>'
-      str << '<c:ptCount val="' << @pt.size.to_s << '"/>'
+      str << ('<c:' << @tag_name.to_s << '>')
+      str << ('<c:ptCount val="' << @pt.size.to_s << '"/>')
       @pt.each_with_index do |value, index|
         value.to_xml_string index, str
       end
-      str << '</c:' << @tag_name.to_s << '>'
+      str << ('</c:' << @tag_name.to_s << '>')
     end
 
   end

data/lib/axlsx/drawing/str_val.rb

@@ -26,7 +26,9 @@ module Axlsx
     # serialize the object
     def to_xml_string(idx, str = "")
       Axlsx::validate_unsigned_int(idx)
-      str << '<c:pt idx="' << idx.to_s << '"><c:v>' << v.to_s << '</c:v></c:pt>'
+      if !v.to_s.empty?
+        str << ('<c:pt idx="' << idx.to_s << '"><c:v>' << ::CGI.escapeHTML(v.to_s) << '</c:v></c:pt>')
+      end
     end
   end
 end

data/lib/axlsx/drawing/title.rb

@@ -7,15 +7,24 @@ module Axlsx
     # @return [String]
     attr_reader :text
 
+    # Text size property
+    # @return [String]
+    attr_reader :text_size
+
     # The cell that holds the text for the title. Setting this property will automatically update the text attribute.
     # @return [Cell]
     attr_reader :cell
 
     # Creates a new Title object
     # @param [String, Cell] title The cell or string to be used for the chart's title
-    def initialize(title="")
+    def initialize(title="", title_size="")
       self.cell = title if title.is_a?(Cell)
       self.text = title.to_s unless title.is_a?(Cell)
+      if title_size.to_s.empty?
+        self.text_size = "1600"
+      else
+        self.text_size = title_size.to_s
+      end
     end
 
     # @see text
@@ -26,6 +35,14 @@ module Axlsx
       v
     end
 
+    # @see text_size
+    def text_size=(v)
+      DataTypeValidator.validate 'Title.text_size', String, v
+      @text_size = v
+      @cell = nil
+      v
+    end
+
     # @see cell
     def cell=(v)
       DataTypeValidator.validate 'Title.text', Cell, v
@@ -45,14 +62,15 @@ module Axlsx
     def to_xml_string(str = '')
       str << '<c:title>'
       unless @text.empty?
+        clean_value = Axlsx::trust_input ? @text.to_s : ::CGI.escapeHTML(Axlsx::sanitize(@text.to_s))
         str << '<c:tx>'
         if @cell.is_a?(Cell)
           str << '<c:strRef>'
-          str << '<c:f>' << Axlsx::cell_range([@cell]) << '</c:f>'
+          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:v>' << clean_value << '</c:v>')
           str << '</c:pt>'
           str << '</c:strCache>'
           str << '</c:strRef>'
@@ -62,7 +80,8 @@ module Axlsx
             str << '<a:lstStyle/>'
             str << '<a:p>'
               str << '<a:r>'
-                str << '<a:t>' << @text.to_s << '</a:t>'
+                str << ('<a:rPr sz="' << @text_size.to_s << '"/>')
+                str << ('<a:t>' << clean_value << '</a:t>')
               str << '</a:r>'
             str << '</a:p>'
           str << '</c:rich>'

data/lib/axlsx/drawing/two_cell_anchor.rb

@@ -37,11 +37,16 @@ module Axlsx
       drawing.anchors << self
       @from, @to =  Marker.new, Marker.new(:col => 5, :row=>10)
       parse_options options
+
+      # bit of a hack to work around the fact that the coords for start at and end at
+      # are passed in as an array when specified in intialization options - however
+      start_at(*options[:start_at]) if options[:start_at]
+      end_at(*options[:end_at]) if options[:end_at]
     end
 
     # sets the col, row attributes for the from marker.
     # @note The recommended way to set the start position for graphical
-    # objects is directly thru the object. 
+    # objects is directly thru the object.
     # @see Chart#start_at
     def start_at(x, y=nil)
       from.coord x, y

data/lib/axlsx/drawing/val_axis.rb

@@ -29,7 +29,7 @@ module Axlsx
     def to_xml_string(str = '')
       str << '<c:valAx>'
       super(str)
-      str << '<c:crossBetween val="' << @cross_between.to_s << '"/>'
+      str << ('<c:crossBetween val="' << @cross_between.to_s << '"/>')
       str << '</c:valAx>'
     end
 

data/lib/axlsx/drawing/view_3D.rb

@@ -86,12 +86,12 @@ module Axlsx
     alias :rAngAx= :r_ang_ax=
 
       # @see perspective
-      def perspective=(v) 
+      def perspective=(v)
         RangeValidator.validate "View3D.perspective", 0, 240, v
         @perspective = v
       end
 
-    # DataTypeValidator.validate "#{self.class}.perspective", [Integer, Fixnum], v, lambda {|arg| arg >= 0 && arg <= 240 }; @perspective = v; end
+    # DataTypeValidator.validate "#{self.class}.perspective", [Integer], v, lambda {|arg| arg >= 0 && arg <= 240 }; @perspective = v; end
 
     # Serializes the object
     # @param [String] str

data/lib/axlsx/drawing/vml_drawing.rb

@@ -20,7 +20,7 @@ module Axlsx
     # @param [String] str
     # @return [String]
     def to_xml_string(str = '')
-      str = <<BAD_PROGRAMMER
+      str << <<BAD_PROGRAMMER
 <xml xmlns:v="urn:schemas-microsoft-com:vml"
  xmlns:o="urn:schemas-microsoft-com:office:office"
  xmlns:x="urn:schemas-microsoft-com:office:excel">

data/lib/axlsx/package.rb

@@ -1,7 +1,7 @@
-# encoding: 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.
+  # xlsx document including validation and serialization.
   class Package
     include Axlsx::OptionsParser
 
@@ -22,7 +22,7 @@ module Axlsx
     # @example Package.new :author => 'you!', :workbook => Workbook.new
     def initialize(options={})
       @workbook = nil
-      @core, @app  =  Core.new, App.new
+      @core, @app = Core.new, App.new
       @core.creator = options[:author] || @core.creator
       @core.created = options[:created_at]
       parse_options options
@@ -68,20 +68,16 @@ module Axlsx
       @workbook
     end
 
-    #def self.parse(input, confirm_valid = false)
-    #  p = Package.new
-    #  z = Zip::File.open(input)
-    #  p.workbook = Workbook.parse z.get_entry(WORKBOOK_PN)
-    #  p
-    #end
-
     # @see workbook
-    def workbook=(workbook) DataTypeValidator.validate "Package.workbook", Workbook, workbook; @workbook = workbook; end
+    def workbook=(workbook) DataTypeValidator.validate :Package_workbook, Workbook, workbook; @workbook = workbook; end
 
     # Serialize your workbook to disk as an xlsx document.
     #
     # @param [String] output The name of the file you want to serialize your package to
     # @param [Boolean] confirm_valid Validate the package prior to serialization.
+    # @param [String, nil] zip_command When `nil`, `#serialize` with RubyZip to
+    #   zip the XLSX file contents. When a String, the provided zip command (e.g.,
+    #   "zip") is used to zip the file contents (may be faster for large files)
     # @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.
@@ -95,16 +91,28 @@ module Axlsx
     #   # ......add cool stuff to your workbook......
     #   p.serialize("example.xlsx")
     #
+    #   # Serialize to a file, using a system zip binary
+    #   p.serialize("example.xlsx", false, zip_command: "zip")
+    #   p.serialize("example.xlsx", false, zip_command: "/path/to/zip")
+    #   p.serialize("example.xlsx", false, zip_command: "zip -1")
+    #
     #   # Serialize to a stream
     #   s = p.to_stream()
     #   File.open('example_streamed.xlsx', 'w') { |f| f.write(s.read) }
-    def serialize(output, confirm_valid=false)
+    def serialize(output, confirm_valid=false, zip_command: nil)
       return false unless !confirm_valid || self.validate.empty?
-      Relationship.clear_cached_instances
-      Zip::OutputStream.open(output) do |zip|
+      zip_provider = if zip_command
+                       ZipCommand.new(zip_command)
+                     else
+                       Zip::OutputStream
+                     end
+      Relationship.initialize_ids_cache
+      zip_provider.open(output) do |zip|
         write_parts(zip)
       end
       true
+    ensure
+      Relationship.clear_ids_cache
     end
 
 
@@ -113,11 +121,13 @@ module Axlsx
     # @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?
-      Relationship.clear_cached_instances
+      Relationship.initialize_ids_cache
       zip = write_parts(Zip::OutputStream.new(StringIO.new, true))
       stream = zip.close_buffer
       stream.rewind
       stream
+    ensure
+      Relationship.clear_ids_cache
     end
 
     # Encrypt the package into a CFB using the password provided
@@ -135,7 +145,7 @@ module Axlsx
     #   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
+    #   If by chance you are able to create a package that does not validate it indicates that the internal
     #   validation is not robust enough and needs to be improved. Please report your errors to the gem author.
     # @see http://www.ecma-international.org/publications/standards/Ecma-376.htm
     # @example
@@ -146,7 +156,9 @@ module Axlsx
     def validate
       errors = []
       parts.each do |part|
-        errors.concat validate_single_doc(part[:schema], part[:doc]) unless part[:schema].nil?
+        unless part[:schema].nil?
+          errors.concat validate_single_doc(part[:schema], part[:doc].to_xml_string)
+        end
       end
       errors
     end
@@ -154,20 +166,18 @@ module Axlsx
     private
 
     # Writes the package parts to a zip archive.
-    # @param [Zip::OutputStream] zip
-    # @return [Zip::OutputStream]
+    # @param [Zip::OutputStream, ZipCommand] zip
+    # @return [Zip::OutputStream, ZipCommand]
     def write_parts(zip)
       p = parts
       p.each do |part|
         unless part[:doc].nil?
           zip.put_next_entry(zip_entry_for_part(part))
-          entry = ['1.9.2', '1.9.3'].include?(RUBY_VERSION) ? part[:doc].force_encoding('BINARY') : part[:doc]
-          zip.puts(entry)
+          part[:doc].to_xml_string(zip)
         end
         unless part[:path].nil?
           zip.put_next_entry(zip_entry_for_part(part))
-          # binread for 1.9.3
-          zip.write IO.respond_to?(:binread) ? IO.binread(part[:path]) : IO.read(part[:path])
+          zip.write IO.read(part[:path], mode: "rb")
         end
       end
       zip
@@ -194,40 +204,40 @@ module Axlsx
     # @private
     def parts
       parts = [
-       {: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}
+       {:entry => RELS_PN, :doc => relationships, :schema => RELS_XSD},
+       {:entry => "xl/#{STYLES_PN}", :doc => workbook.styles, :schema => SML_XSD},
+       {:entry => CORE_PN, :doc => @core, :schema => CORE_XSD},
+       {:entry => APP_PN, :doc => @app, :schema => APP_XSD},
+       {:entry => WORKBOOK_RELS_PN, :doc => workbook.relationships, :schema => RELS_XSD},
+       {:entry => CONTENT_TYPES_PN, :doc => content_types, :schema => CONTENT_TYPES_XSD},
+       {:entry => WORKBOOK_PN, :doc => workbook, :schema => SML_XSD}
       ]
 
       workbook.drawings.each do |drawing|
-        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}
+        parts << {:entry => "xl/#{drawing.rels_pn}", :doc => drawing.relationships, :schema => RELS_XSD}
+        parts << {:entry => "xl/#{drawing.pn}", :doc => drawing, :schema => DRAWING_XSD}
       end
 
 
       workbook.tables.each do |table|
-        parts << {:entry => "xl/#{table.pn}", :doc => table.to_xml_string, :schema => SML_XSD}
+        parts << {:entry => "xl/#{table.pn}", :doc => table, :schema => SML_XSD}
       end
       workbook.pivot_tables.each do |pivot_table|
         cache_definition = pivot_table.cache_definition
-        parts << {:entry => "xl/#{pivot_table.rels_pn}", :doc => pivot_table.relationships.to_xml_string, :schema => RELS_XSD}
-        parts << {:entry => "xl/#{pivot_table.pn}", :doc => pivot_table.to_xml_string} #, :schema => SML_XSD}
-        parts << {:entry => "xl/#{cache_definition.pn}", :doc => cache_definition.to_xml_string} #, :schema => SML_XSD}
+        parts << {:entry => "xl/#{pivot_table.rels_pn}", :doc => pivot_table.relationships, :schema => RELS_XSD}
+        parts << {:entry => "xl/#{pivot_table.pn}", :doc => pivot_table} #, :schema => SML_XSD}
+        parts << {:entry => "xl/#{cache_definition.pn}", :doc => cache_definition} #, :schema => SML_XSD}
       end
 
       workbook.comments.each do|comment|
         if comment.size > 0
-          parts << { :entry => "xl/#{comment.pn}", :doc => comment.to_xml_string, :schema => SML_XSD }
-          parts << { :entry => "xl/#{comment.vml_drawing.pn}", :doc => comment.vml_drawing.to_xml_string, :schema => nil }
+          parts << { :entry => "xl/#{comment.pn}", :doc => comment, :schema => SML_XSD }
+          parts << { :entry => "xl/#{comment.vml_drawing.pn}", :doc => comment.vml_drawing, :schema => nil }
         end
       end
 
       workbook.charts.each do |chart|
-        parts << {:entry => "xl/#{chart.pn}", :doc => chart.to_xml_string, :schema => DRAWING_XSD}
+        parts << {:entry => "xl/#{chart.pn}", :doc => chart, :schema => DRAWING_XSD}
       end
 
       workbook.images.each do |image|
@@ -235,14 +245,16 @@ module Axlsx
       end
 
       if use_shared_strings
-        parts << {:entry => "xl/#{SHARED_STRINGS_PN}", :doc => workbook.shared_strings.to_xml_string, :schema => SML_XSD}
+        parts << {:entry => "xl/#{SHARED_STRINGS_PN}", :doc => workbook.shared_strings, :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}
+        parts << {:entry => "xl/#{sheet.rels_pn}", :doc => sheet.relationships, :schema => RELS_XSD}
+        parts << {:entry => "xl/#{sheet.pn}", :doc => sheet, :schema => SML_XSD}
       end
-      parts
+
+      # Sort parts for correct MIME detection
+      parts.sort_by { |part| part[:entry] }
     end
 
     # Performs xsd validation for a signle document
@@ -303,7 +315,7 @@ module Axlsx
         c_types << Axlsx::Override.new(:PartName => "/xl/#{sheet.pn}",
                                          :ContentType => WORKSHEET_CT)
       end
-      exts = workbook.images.map { |image| image.extname }
+      exts = workbook.images.map { |image| image.extname.downcase }
       exts.uniq.each do |ext|
         ct = if  ['jpeg', 'jpg'].include?(ext)
                JPEG_CT
@@ -326,8 +338,8 @@ module Axlsx
     # @private
     def base_content_types
       c_types = ContentType.new()
-      c_types <<  Default.new(:ContentType => RELS_CT, :Extension => RELS_EX)
-      c_types <<  Default.new(:Extension => XML_EX, :ContentType => XML_CT)
+      c_types << Default.new(:ContentType => RELS_CT, :Extension => RELS_EX)
+      c_types << Default.new(:Extension => XML_EX, :ContentType => XML_CT)
       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)
@@ -349,4 +361,3 @@ module Axlsx
     end
   end
 end
-