axlsx 1.0.17 → 1.1.0

data/lib/axlsx/drawing/two_cell_anchor.rb

@@ -26,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
@@ -38,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
@@ -54,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

@@ -22,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

@@ -3,25 +3,25 @@ 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

@@ -5,34 +5,34 @@ module Axlsx
 
     # 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
@@ -45,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
@@ -69,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

@@ -4,7 +4,7 @@ module Axlsx
   # xlsx document including valdation and serialization.
   class Package
 
-    
+
     # provides access to the app doc properties for this package
     # see App
     attr_reader :app
@@ -29,10 +29,18 @@ module Axlsx
       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); 
+    def use_shared_strings=(v)
+      Axlsx::validate_boolean(v);
       workbook.use_shared_strings = v
     end
 
@@ -45,7 +53,7 @@ module Axlsx
     # 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
@@ -59,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
@@ -77,7 +85,7 @@ module Axlsx
     # @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.
@@ -105,20 +113,20 @@ module Axlsx
       stream.rewind
       stream
     end
-    
+
     # Encrypt the package into a CFB using the password provided
     # This is not ready yet
-    def encrypt(file_name, password)      
+    def encrypt(file_name, password)
       return false
-      moc = MsOffCrypto.new(file_name, password)
-      moc.save    
+      # moc = MsOffCrypto.new(file_name, password)
+      # moc.save
     end
-    
-    # Validate all parts of the package against xsd schema. 
+
+    # 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
@@ -131,65 +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| 
+        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]); 
+            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
         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
 
       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|            
-        @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}        
+      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
@@ -203,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
@@ -217,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 }
@@ -256,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

data/lib/axlsx/rels/relationship.rb

@@ -1,7 +1,7 @@
 # encoding: UTF-8
 module Axlsx
   # A relationship defines a reference between package parts.
-  # @note Packages automatcially manage relationships.
+  # @note Packages automatically manage relationships.
   class Relationship
 
     # The location of the relationship target
@@ -32,7 +32,7 @@ module Axlsx
     # creates a new relationship
     # @param [String] Type The type of the relationship
     # @param [String] Target The target for the relationship
-    # @option [Symbol] target_mode only accepts :external.    
+    # @option [Symbol] target_mode only accepts :external.
     def initialize(type, target, options={})
       self.Target=target
       self.Type=type
@@ -47,14 +47,17 @@ module Axlsx
     # @see TargetMode
     def TargetMode=(v) RestrictionValidator.validate 'Relationship.TargetMode', [:External, :Internal], v; @TargetMode = v; end
 
-    # Serializes the relationship    
-    # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
-    # @param [String] rId the reference id of the object.
+    # serialize relationship
+    # @param [String] str
+    # @param [Integer] rId the id for this relationship
     # @return [String]
-    def to_xml(xml, rId)
+    def to_xml_string(rId, str = '')
       h = self.instance_values
-      h[:Id] = rId
-      xml.Relationship(h)
+      h[:Id] = 'rId' << rId.to_s
+      str << '<Relationship '
+      str << h.map { |key, value| '' << key.to_s << '="' << value.to_s << '"'}.join(' ')
+      str << '/>'
     end
+
   end
 end

data/lib/axlsx/rels/relationships.rb

@@ -11,6 +11,12 @@ require 'axlsx/rels/relationship.rb'
       super Relationship
     end
 
+    def to_xml_string(str = '')
+      str << '<?xml version="1.0" encoding="UTF-8"?>'
+      str << '<Relationships xmlns="' << RELS_R << '">'
+      each_with_index { |rel, index| rel.to_xml_string(index+1, str) }
+      str << '</Relationships>'
+    end
     # Serializes the relationships document.
     # @return [String]
     def to_xml()
@@ -21,6 +27,6 @@ require 'axlsx/rels/relationship.rb'
       end
       builder.to_xml(:save_with => 0)
     end
-  
+
   end
 end

data/lib/axlsx/stylesheet/#num_fmt.rb#

@@ -0,0 +1,69 @@
+# encoding: UTF-8
+module Axlsx
+  # A NumFmt object defines an identifier and formatting code for data in cells.
+  # @note The recommended way to manage styles is Styles#add_style
+  class NumFmt
+    # @return [Integer] An unsinged integer referencing a standard or custom number format.
+    # @note
+    #  These are the known formats I can dig up. The constant NUM_FMT_PERCENT is 9, and uses the default % formatting. Axlsx also defines a few formats for date and time that are commonly used in asia as NUM_FMT_YYYYMMDD and NUM_FRM_YYYYMMDDHHMMSS.
+    #   1 0
+    #   2 0.00
+    #   3 #,##0
+    #   4 #,##0.00
+    #   5 $#,##0_);($#,##0)
+    #   6 $#,##0_);[Red]($#,##0)
+    #   7 $#,##0.00_);($#,##0.00)
+    #   8 $#,##0.00_);[Red]($#,##0.00)
+    #   9 0%
+    #   10 0.00%
+    #   11 0.00E+00
+    #   12 # ?/?
+    #   13 # ??/??
+    #   14 m/d/yyyy
+    #   15 d-mmm-yy
+    #   16 d-mmm
+    #   17 mmm-yy
+    #   18 h:mm AM/PM
+    #   19 h:mm:ss AM/PM
+    #   20 h:mm
+    #   21 h:mm:ss
+    #   22 m/d/yyyy h:mm
+    #   37 #,##0_);(#,##0)
+    #   38 #,##0_);[Red](#,##0)
+    #   39 #,##0.00_);(#,##0.00)
+    #   40 #,##0.00_);[Red](#,##0.00)
+    #   45 mm:ss
+    #   46 [h]:mm:ss
+    #   47 mm:ss.0
+    #   48 ##0.0E+0
+    #   49 @
+    # @see Axlsx
+    attr_reader :numFmtId
+
+    # @return [String] The formatting to use for this number format.
+    # @see http://support.microsoft.com/kb/264372
+    attr_reader :formatCode
+    def initialize(options={})
+      @numFmtId = 0
+      @formatCode = ""
+      options.each do |o|
+        self.send("#{o[0]}=", o[1]) if self.respond_to? o[0]
+      end
+    end
+
+    # @see numFmtId
+    def numFmtId=(v) Axlsx::validate_unsigned_int v; @numFmtId = v end
+    # @see formatCode
+    def formatCode=(v) Axlsx::validate_string v; @formatCode = v end
+
+    # Serializes the object
+    # @param [String] str
+    # @return [String]
+    def to_xml_string(str = '')
+      str << '<numFmt '
+      str << instance_values.map { |key, value| '' << key.to_s << '="' << value.to_s << '"' }.join(' ')
+      str << '/>'
+    end
+
+  end
+end

data/lib/axlsx/stylesheet/border.rb

@@ -3,38 +3,37 @@ module Axlsx
   # This class details a border used in Office Open XML spreadsheet styles.
   class Border
 
-    # @return [Boolean] The diagonal up property for the border that indicates if the border should include a diagonal line from the bottom left to the top right of the cell. 
+    # @return [Boolean] The diagonal up property for the border that indicates if the border should include a diagonal line from the bottom left to the top right of the cell.
     attr_reader :diagonalUp
-    
+
     # @return [Boolean] The diagonal down property for the border that indicates if the border should include a diagonal line from the top left to the top right of the cell.
     attr_reader :diagonalDown
 
     # @return [Boolean] The outline property for the border indicating that top, left, right and bottom borders should only be applied to the outside border of a range of cells.
     attr_reader :outline
 
-    # @return [SimpleTypedList] A list of BorderPr objects for this border. 
+    # @return [SimpleTypedList] A list of BorderPr objects for this border.
     attr_reader :prs
 
     # Creates a new Border object
     # @option options [Boolean] diagonalUp
     # @option options [Boolean] diagonalDown
     # @option options [Boolean] outline
-    # @example Making a border
-    #   p = Package.new
-    #   red_border = Border.new
-    #   [:left, :right, :top, :bottom].each do |item| 
-    #     red_border.prs << BorderPr.new(:name=>item, :style=>:thin, :color=>Color.new(:rgb=>"FFFF0000"))     #   
-    #   end
-    #   # this sets red_border to be the index for the created border.
-    #   red_border = p.workbook.styles.@borders << red_border
-    #   #used in row creation as follows. This will add a red border to each of the cells in the row.
-    #   p.workbook.add_worksheet.rows << :values=>[1,2,3] :style=>red_border
+    # @example - Making a border
+    #   p = Axlsx::Package.new
+    #   red_border = p.workbook.styles.add_style :border => { :style => :thin, :color => "FFFF0000" }
+    #   ws = p.workbook.add_worksheet
+    #   ws.add_row [1,2,3], :style => red_border
+    #   p.serialize('red_border.xlsx')
+    #
+    # @note The recommended way to manage borders is with Style#add_style
+    # @see Style#add_style
     def initialize(options={})
       @prs = SimpleTypedList.new BorderPr
       options.each do |o|
         self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
       end
-    end        
+    end
 
     # @see diagonalUp
     def diagonalUp=(v) Axlsx::validate_boolean v; @diagonalUp = v end
@@ -43,16 +42,21 @@ module Axlsx
     # @see outline
     def outline=(v) Axlsx::validate_boolean v; @outline = v end
 
-    # Serializes the border element
-    # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
-    def to_xml(xml)
-      xml.border(self.instance_values.select{ |k,v| [:diagonalUp, :diagonalDown, :outline].include? k }) {
-        [:start, :end, :left, :right, :top, :bottom, :diagonal, :vertical, :horizontal].each do |k|
-          @prs.select { |pr| pr.name == k }.each do |part| 
-            part.to_xml(xml) 
-          end
+    # Serializes the object
+    # @param [String] str
+    # @return [String]
+    def to_xml_string(str = '')
+      str << '<border '
+      h = self.instance_values.select{ |k,v| [:diagonalUp, :diagonalDown, :outline].include? k }
+      str << h.map { |key, value| '' << key.to_s << '="' << value.to_s << '"' }.join(' ')
+      str << '>'
+      [:start, :end, :left, :right, :top, :bottom, :diagonal, :vertical, :horizontal].each do |k|
+        @prs.select { |pr| pr.name == k }.each do |part|
+          part.to_xml_string(str)
         end
-      }
+      end
+      str << '</border>'
     end
+
   end
 end