axlsx 1.0.18 → 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

@@ -29,6 +29,14 @@ 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)
@@ -131,7 +139,9 @@ 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
 
@@ -162,21 +172,25 @@ module Axlsx
     # @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, :schema => DRAWING_XSD}
+        @parts << {:entry => "xl/#{chart.pn}", :doc => chart.to_xml_string, :schema => DRAWING_XSD}
       end
 
       workbook.images.each do |image|
@@ -184,12 +198,12 @@ 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|
-        @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}
+        @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
@@ -224,6 +237,10 @@ module Axlsx
         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}",
                                          :ContentType => WORKSHEET_CT)

data/lib/axlsx/rels/relationship.rb

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