axlsx 1.0.15 → 1.1.1

data/lib/axlsx/rels/relationship.rb

@@ -1,6 +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
@@ -21,9 +22,21 @@ module Axlsx
     # @see DRAWING_R
     # @return [String]
     attr_reader :Type
-    def initialize(type, target)
+
+    # The target mode of the relationship
+    # used for hyperlink type relationships to mark the relationship to an external resource
+    # TargetMode can be specified during initialization by passing in a :target_mode option
+    # Target mode must be :external for now.
+    attr_reader :TargetMode
+
+    # 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.
+    def initialize(type, target, options={})
       self.Target=target
       self.Type=type
+      self.TargetMode = options.delete(:target_mode) if options[:target_mode]
     end
 
     # @see Target
@@ -31,14 +44,20 @@ module Axlsx
     # @see Type
     def Type=(v) Axlsx::validate_relationship_type v; @Type = 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.
+    # @see TargetMode
+    def TargetMode=(v) RestrictionValidator.validate 'Relationship.TargetMode', [:External, :Internal], v; @TargetMode = v; end
+
+    # 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

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 module Axlsx
 require 'axlsx/rels/relationship.rb'
 
@@ -10,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()
@@ -18,8 +25,8 @@ require 'axlsx/rels/relationship.rb'
           each_with_index { |rel, index| rel.to_xml(xml, "rId#{index+1}") }
         }
       end
-      builder.to_xml
+      builder.to_xml(:save_with => 0)
     end
-  
+
   end
 end

data/lib/axlsx/stylesheet/border.rb

@@ -1,39 +1,39 @@
+# encoding: UTF-8
 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
@@ -42,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

data/lib/axlsx/stylesheet/border_pr.rb

@@ -1,21 +1,22 @@
+# encoding: UTF-8
 module Axlsx
-  # A border part. 
+  # A border part.
   class BorderPr
-    
+
     # @return [Color] The color of this border part.
     attr_reader :color
 
-    # @return [Symbol] The syle of this border part. 
-    # @note 
+    # @return [Symbol] The syle of this border part.
+    # @note
     #  The following are allowed
-    #   :none 
+    #   :none
     #   :thin
     #   :medium
     #   :dashed
     #   :dotted
     #   :thick
     #   :double
-    #   :hair 
+    #   :hair
     #   :mediumDashed
     #   :dashDot
     #   :mediumDashDot
@@ -25,7 +26,7 @@ module Axlsx
     attr_reader :style
 
     # @return [Symbol] The name of this border part
-    # @note 
+    # @note
     #  The following are allowed
     #   :start
     #   :end
@@ -37,7 +38,7 @@ module Axlsx
     #   :vertical
     #   :horizontal
     attr_reader :name
-    
+
     # Creates a new Border Part Object
     # @option options [Color] color
     # @option options [Symbol] name
@@ -52,17 +53,18 @@ module Axlsx
     # @see name
     def name=(v) RestrictionValidator.validate "BorderPr.name", [:start, :end, :left, :right, :top, :bottom, :diagonal, :vertical, :horizontal], v; @name = v end
     # @see color
-    def color=(v) DataTypeValidator.validate(:color, Color, v); @color = v end    
+    def color=(v) DataTypeValidator.validate(:color, Color, v); @color = v end
     # @see style
     def style=(v) RestrictionValidator.validate "BorderPr.style", [:none, :thin, :medium, :dashed, :dotted, :thick, :double, :hair, :mediumDashed, :dashDot, :mediumDashDot, :dashDotDot, :mediumDashDotDot, :slantDashDot], v; @style = v end
 
-    # Serializes the border part
-    # @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.send(@name, :style => @style) {
-        @color.to_xml(xml) if @color.is_a? Color
-      } 
+    def to_xml_string(str = '')
+      str << '<' << @name.to_s << ' style="' << @style.to_s << '">'
+      @color.to_xml_string(str) if @color.is_a?(Color)
+      str << '</' << @name.to_s << '>'
     end
+
   end
 end

data/lib/axlsx/stylesheet/cell_alignment.rb

@@ -1,10 +1,11 @@
+# encoding: UTF-8
 module Axlsx
   # CellAlignment stores information about the cell alignment of a style Xf Object.
-  # @note Using Styles#add_style is the recommended way to manage cell alignment. 
+  # @note Using Styles#add_style is the recommended way to manage cell alignment.
   # @see Styles#add_style
   class CellAlignment
     # The horizontal alignment of the cell.
-    # @note 
+    # @note
     #  The horizontal cell alignement style must be one of
     #   :general
     #   :left
@@ -35,7 +36,7 @@ module Axlsx
     # Indicate if the text of the cell should wrap
     # @return [Boolean]
     attr_reader :wrapText
-    
+
     # The amount of indent
     # @return [Integer]
     attr_reader :indent
@@ -53,12 +54,12 @@ module Axlsx
     attr_reader :shrinkToFit
 
     # The reading order of the text
-    # 0 Context Dependent 
+    # 0 Context Dependent
     # 1 Left-to-Right
     # 2 Right-to-Left
     # @return [Integer]
     attr_reader :readingOrder
-    
+
     # Create a new cell_alignment object
     # @option options [Symbol] horizontal
     # @option options [Symbol] vertical
@@ -73,33 +74,35 @@ module Axlsx
       options.each do |o|
         self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
       end
-    end        
-    
+    end
+
     # @see horizontal
-    def horizontal=(v) Axlsx::validate_horizontal_alignment v; @horizontal = v end    
+    def horizontal=(v) Axlsx::validate_horizontal_alignment v; @horizontal = v end
     # @see vertical
-    def vertical=(v) Axlsx::validate_vertical_alignment v; @vertical = v end    
+    def vertical=(v) Axlsx::validate_vertical_alignment v; @vertical = v end
     # @see textRotation
-    def textRotation=(v) Axlsx::validate_unsigned_int v; @textRotation = v end    
+    def textRotation=(v) Axlsx::validate_unsigned_int v; @textRotation = v end
     # @see wrapText
-    def wrapText=(v) Axlsx::validate_boolean v; @wrapText = v end    
+    def wrapText=(v) Axlsx::validate_boolean v; @wrapText = v end
     # @see indent
-    def indent=(v) Axlsx::validate_unsigned_int v; @indent = v end    
+    def indent=(v) Axlsx::validate_unsigned_int v; @indent = v end
     # @see relativeIndent
-    def relativeIndent=(v) Axlsx::validate_int v; @relativeIndent = v end    
+    def relativeIndent=(v) Axlsx::validate_int v; @relativeIndent = v end
     # @see justifyLastLine
-    def justifyLastLine=(v) Axlsx::validate_boolean v; @justifyLastLine = v end    
+    def justifyLastLine=(v) Axlsx::validate_boolean v; @justifyLastLine = v end
     # @see shrinkToFit
-    def shrinkToFit=(v) Axlsx::validate_boolean v; @shrinkToFit = v end    
+    def shrinkToFit=(v) Axlsx::validate_boolean v; @shrinkToFit = v end
     # @see readingOrder
-    def readingOrder=(v) Axlsx::validate_unsigned_int v; @readingOrder = v end  
+    def readingOrder=(v) Axlsx::validate_unsigned_int v; @readingOrder = v end
 
-    # Serializes the cell alignment
-    # @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.alignment(self.instance_values)      
+    def to_xml_string(str = '')
+      str << '<alignment '
+      str << instance_values.map { |key, value| '' << key.to_s << '="' << value.to_s << '"' }.join(' ')
+      str << '/>'
     end
-    
+
   end
 end

data/lib/axlsx/stylesheet/cell_protection.rb

@@ -1,9 +1,10 @@
+# encoding: UTF-8
 module Axlsx
   # CellProtection stores information about locking or hiding cells in spreadsheet.
   # @note Using Styles#add_style is the recommended way to manage cell protection.
   # @see Styles#add_style
   class CellProtection
-    
+
     # specifies locking for cells that have the style containing this protection
     # @return [Boolean]
     attr_reader :hidden
@@ -22,15 +23,18 @@ module Axlsx
     end
 
     # @see hidden
-    def hidden=(v) Axlsx::validate_boolean v; @hidden = v end    
+    def hidden=(v) Axlsx::validate_boolean v; @hidden = v end
     # @see locked
-    def locked=(v) Axlsx::validate_boolean v; @locked = v end    
+    def locked=(v) Axlsx::validate_boolean v; @locked = v end
 
-    # Serializes the cell protection
-    # @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.protection(self.instance_values)
+    def to_xml_string(str = '')
+      str << '<protection '
+      str << instance_values.map { |key, value| '' << key.to_s << '="' << value.to_s << '"' }.join(' ')
+      str << '/>'
     end
+
   end
 end

data/lib/axlsx/stylesheet/cell_style.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 module Axlsx
   # CellStyle defines named styles that reference defined formatting records and can be used in your worksheet.
   # @note Using Styles#add_style is the recommended way to manage cell styling.
@@ -6,7 +7,7 @@ module Axlsx
     # The name of this cell style
     # @return [String]
     attr_reader :name
-    
+
     # The formatting record id this named style utilizes
     # @return [Integer]
     # @see Axlsx::Xf
@@ -54,12 +55,15 @@ module Axlsx
     # @see customBuiltin
     def customBuiltin=(v) Axlsx::validate_boolean v; @customBuiltin = v end
 
-    # Serializes the cell style
-    # @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.cellStyle(self.instance_values)
+    def to_xml_string(str = '')
+      str << '<cellStyle '
+      str << instance_values.map { |key, value| '' << key.to_s << '="' << value.to_s << '"' }.join(' ')
+      str << '/>'
     end
+
   end
 
 end

data/lib/axlsx/stylesheet/color.rb

@@ -1,12 +1,13 @@
+# encoding: UTF-8
 module Axlsx
   # The color class represents a color used for borders, fills an fonts
   class Color
     # Determines if the color is system color dependant
     # @return [Boolean]
     attr_reader :auto
-    
-    # The color as defined in rgb terms. 
-    # @note 
+
+    # The color as defined in rgb terms.
+    # @note
     #  rgb colors need to conform to ST_UnsignedIntHex. That basically means put 'FF' before you color
     # When assigning the rgb value the behavior is much like CSS selectors and can use shorthand versions as follows:
     # If you provide a two character value it will be repeated for each r, g, b assignment
@@ -24,16 +25,16 @@ module Axlsx
     # no support for theme just yet
     # @return [Integer]
     #attr_reader :theme
-    
+
     # The tint value.
     # @note valid values are between -1.0 and 1.0
     # @return [Float]
     attr_reader :tint
-    
+
     # Creates a new Color object
     # @option options [Boolean] auto
     # @option options [String] rgb
-    # @option options [Float] tint    
+    # @option options [Float] tint
     def initialize(options={})
       @rgb = "FF000000"
       options.each do |o|
@@ -41,7 +42,7 @@ module Axlsx
       end
     end
     # @see auto
-    def auto=(v) Axlsx::validate_boolean v; @auto = v end    
+    def auto=(v) Axlsx::validate_boolean v; @auto = v end
     # @see color
     def rgb=(v)
       Axlsx::validate_string(v)
@@ -55,15 +56,20 @@ module Axlsx
     def tint=(v) Axlsx::validate_float v; @tint = v end
 
     # This version does not support themes
-    # def theme=(v) Axlsx::validate_unsigned_integer v; @theme = v end    
-    
-    # Indexed colors are for backward compatability which I am choosing not to support
-    # def indexed=(v) Axlsx::validate_unsigned_integer v; @indexed = v end     
+    # def theme=(v) Axlsx::validate_unsigned_integer v; @theme = v end
 
+    # Indexed colors are for backward compatability which I am choosing not to support
+    # def indexed=(v) Axlsx::validate_unsigned_integer v; @indexed = v end
 
-    # Serializes the color
-    # @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.color(self.instance_values) end
+    def to_xml_string(str = '')
+      str << "<color "
+      self.instance_values.each do |key, value|
+        str << key.to_s << '="' << value.to_s << '" '
+      end
+      str << "/>"
+    end
   end
 end

data/lib/axlsx/stylesheet/fill.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 module Axlsx
   # The Fill is a formatting object that manages the background color, and pattern for cells.
   # @note The recommended way to manage styles in your workbook is to use Styles#add_style.
@@ -11,17 +12,19 @@ module Axlsx
     attr_reader :fill_type
 
     # Creates a new Fill object
-    # @param [PatternFill, GradientFill] fill_type 
+    # @param [PatternFill, GradientFill] fill_type
     # @raise [ArgumentError] if the fill_type parameter is not a PatternFill or a GradientFill instance
     def initialize(fill_type)
       self.fill_type = fill_type
     end
 
-    # Serializes the fill
-    # @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.fill { @fill_type.to_xml(xml) }
+    def to_xml_string(str = '')
+      str << '<fill>'
+      @fill_type.to_xml_string(str)
+      str << '</fill>'
     end
 
     # @see fill_type

data/lib/axlsx/stylesheet/font.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 module Axlsx
   # The Font class details a font instance for use in styling cells.
   # @note The recommended way to manage fonts, and other styles is Styles#add_style
@@ -6,7 +7,7 @@ module Axlsx
     # The name of the font
     # @return [String]
     attr_reader :name
-    
+
     # The charset of the font
     # @return [Integer]
     # @note
@@ -31,9 +32,9 @@ module Axlsx
     #   238 EASTEUROPE_CHARSET
     #   255 OEM_CHARSET
     attr_reader :charset
-    
+
     # The font's family
-    # @note 
+    # @note
     #  The following are defined OOXML specification
     #   0 Not applicable.
     #   1 Roman
@@ -53,6 +54,10 @@ module Axlsx
     # @return [Boolean]
     attr_reader :i
 
+    # Indicates if the font should be rendered underlined
+    # @return [Boolean]
+    attr_reader :u
+
     # Indicates if the font should be rendered with a strikthrough
     # @return [Boolean]
     attr_reader :strike
@@ -88,6 +93,7 @@ module Axlsx
     # @option options [Integer] family
     # @option options [Boolean] b
     # @option options [Boolean] i
+    # @option options [Boolean] u
     # @option options [Boolean] strike
     # @option options [Boolean] outline
     # @option options [Boolean] shadow
@@ -101,21 +107,23 @@ module Axlsx
       end
     end
     # @see name
-    def name=(v) Axlsx::validate_string v; @name = v end    
+    def name=(v) Axlsx::validate_string v; @name = v end
     # @see charset
     def charset=(v) Axlsx::validate_unsigned_int v; @charset = v end
     # @see family
     def family=(v) Axlsx::validate_unsigned_int v; @family = v end
     # @see b
-    def b=(v) Axlsx::validate_boolean v; @b = v end    
+    def b=(v) Axlsx::validate_boolean v; @b = v end
     # @see i
     def i=(v) Axlsx::validate_boolean v; @i = v end
+    # @see u
+    def u=(v) Axlsx::validate_boolean v; @u = v end
     # @see strike
     def strike=(v) Axlsx::validate_boolean v; @strike = v end
     # @see outline
     def outline=(v) Axlsx::validate_boolean v; @outline = v end
     # @see shadow
-    def shadow=(v) Axlsx::validate_boolean v; @shadow = v end    
+    def shadow=(v) Axlsx::validate_boolean v; @shadow = v end
     # @see condense
     def condense=(v) Axlsx::validate_boolean v; @condense = v end
     # @see extend
@@ -125,15 +133,15 @@ module Axlsx
     # @see sz
     def sz=(v) Axlsx::validate_unsigned_int v; @sz=v end
 
-    # Serializes the fill
-    # @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.font {
-        self.instance_values.each do |k, v|
-          v.is_a?(Color) ? v.to_xml(xml) : xml.send(k, {:val => v})            
-        end
-      }
+    def to_xml_string(str = '')
+      str << '<font>'
+      instance_values.each do |k, v|
+        v.is_a?(Color) ? v.to_xml_string(str) : (str << '<' << k.to_s << ' val="' << v.to_s << '"/>')
+      end
+      str << '</font>'
     end
   end
 end