axlsx 1.1.0 → 1.2.0

data/lib/axlsx/drawing/str_data.rb

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+module Axlsx
+
+  #This specifies the last string data used for a chart. (e.g. strLit and strCache)
+  # This class is extended for NumData to include the formatCode attribute required for numLit and numCache
+  class StrData
+
+    # creates a new StrVal object
+    # @option options [Array] :data
+    # @option options [String] :tag_name
+    def initialize(options={})
+      @tag_prefix = :str
+      @type = StrVal
+      @pt = SimpleTypedList.new(@type)
+      options.each do |o|
+        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
+      end
+    end
+
+    # Creates the val objects for this data set. I am not overly confident this is going to play nicely with time and data types.
+    # @param [Array] values An array of cells or values.
+    def data=(values=[])
+      @tag_name = values.first.is_a?(Cell) ? :strCache : :strLit
+      values.each do |value|
+        v = value.is_a?(Cell) ? value.value : value
+        @pt << @type.new(:v => v)
+      end
+    end
+
+    # serialize the object
+    def to_xml_string(str = "")
+      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 << '>'
+    end
+
+  end
+
+end

data/lib/axlsx/drawing/str_val.rb

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+module Axlsx
+
+  #This class specifies data for a particular data point.
+  class StrVal
+
+    # a string value.
+    # @return [String]
+    attr_reader :v
+
+    # creates a new StrVal object
+    # @option options [String] v
+    def initialize(options={})
+      @v = ""
+      @idx = 0
+      options.each do |o|
+        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
+      end
+    end
+    # @see v
+    def v=(v)
+      @v = v.to_s
+    end
+
+    # 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>'
+    end
+
+  end
+
+end

data/lib/axlsx/drawing/title.rb

@@ -46,15 +46,27 @@ module Axlsx
       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>'
+        if @cell.is_a?(Cell)
+          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>'
+        else
+          str << '<c:rich>'
+            str << '<a:bodyPr/>'
+            str << '<a:lstStyle/>'
+            str << '<a:p>'
+              str << '<a:r>'
+                str << '<a:t>' << @text.to_s << '</a:t>'
+              str << '</a:r>'
+            str << '</a:p>'
+          str << '</c:rich>'
+        end
         str << '</c:tx>'
       end
       str << '<c:layout/>'

data/lib/axlsx/drawing/two_cell_anchor.rb

@@ -25,23 +25,33 @@ module Axlsx
     # @return [Drawing]
     attr_reader :drawing
 
-
-    # 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
+    # Creates a new TwoCellAnchor object
     # c.start_at 5, 9
-    # @note the chart_type parameter will be replaced with object in v. 2.0.0
     # @param [Drawing] drawing
-    # @param [Class] chart_type This is passed to the graphic frame for instantiation. must be Chart or a subclass of Chart
-    # @param object The object this anchor holds.
-    # @option options [Array] start_at the col, row to start at
-    # @option options [Array] end_at the col, row to end at
+    # @option options [Array] :start_at the col, row to start at THIS IS DOCUMENTED BUT NOT IMPLEMENTED HERE!
+    # @option options [Array] :end_at the col, row to end at
     def initialize(drawing, options={})
       @drawing = drawing
       drawing.anchors << self
       @from, @to =  Marker.new, Marker.new(:col => 5, :row=>10)
     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. 
+    # @see Chart#start_at
+    def start_at(x, y)
+      set_marker_coords(x, y, from)
+    end
+
+    # sets the col, row attributes for the to marker
+    # @note the recommended way to set the to position for graphical
+    # objects is directly thru the object
+    # @see Char#end_at
+    def end_at(x, y)
+      set_marker_coords(x, y, to) 
+    end
+
     # Creates a graphic frame and chart object associated with this anchor
     # @return [Chart]
     def add_chart(chart_type, options)
@@ -49,6 +59,11 @@ module Axlsx
       @object.chart
     end
 
+    # Creates an image associated with this anchor.
+    def add_pic(options={})
+      @object = Pic.new(self, options)
+    end
+
     # The index of this anchor in the drawing
     # @return [Integer]
     def index
@@ -70,6 +85,28 @@ module Axlsx
       str << '<xdr:clientData/>'
       str << '</xdr:twoCellAnchor>'
     end
+    private 
+
+    # parses coordinates and sets up a marker's row/col propery
+    def set_marker_coords(x, y, marker)
+      marker.col, marker.row = *parse_coord_args(x, y)
+    end
+
+    # handles multiple inputs for setting the position of a marker
+    # @see Chart#start_at
+    def parse_coord_args(x, y=0)
+      if x.is_a?(String)
+        x, y = *Axlsx::name_to_indices(x)
+      end
+      if x.is_a?(Cell)
+        x, y = *x.pos
+      end
+      if x.is_a?(Array)
+        x, y = *x
+      end
+      [x, y]
+    end
+
 
   end
 end

data/lib/axlsx/drawing/view_3D.rb

@@ -4,68 +4,81 @@ module Axlsx
   class View3D
 
     # Validation for hPercent
-    H_PERCENT_REGEX = /0*(([5-9])|([1-9][0-9])|([1-4][0-9][0-9])|500)%/
+    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)%/
+    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
     # must be between -90 and 90
     # @return [Integer]
-    attr_reader :rotX
-
+    attr_reader :rot_x
+    alias :rotX :rot_x
+    
     # height of chart as % of chart
     # must be between 5% and 500%
     # @return [String]
-    attr_reader :hPercent
+    attr_reader :h_percent
+    alias :hPercent :h_percent
 
     # y rotation for the chart
     # must be between 0 and 360
     # @return [Integer]
-    attr_reader :rotY
-
+    attr_reader :rot_y
+    alias :rotY :rot_y
+    
     # depth or chart as % of chart width
     # must be between 20% and 2000%
     # @return [String]
-    attr_reader :depthPercent
+    attr_reader :depth_percent
+    alias :depthPercent :depth_percent
 
     # Chart axis are at right angles
     # @return [Boolean]
-    attr_reader :rAngAx
+    attr_reader :r_ang_ax
+    alias :rAngAx :r_ang_ax
 
     # field of view angle
     # @return [Integer]
     attr_reader :perspective
 
     # Creates a new View3D for charts
-    # @option options [Integer] rotX
-    # @option options [String] hPercent
-    # @option options [Integer] rotY
-    # @option options [String] depthPercent
-    # @option options [Boolean] rAngAx
+    # @option options [Integer] rot_x
+    # @option options [String] h_percent
+    # @option options [Integer] rot_y
+    # @option options [String] depth_percent
+    # @option options [Boolean] r_ang_ax
     # @option options [Integer] perspective
     def initialize(options={})
-      @rotX, @hPercent, @rotY, @depthPercent, @rAngAx, @perspective  = nil, nil, nil, nil, nil, nil
+      @rot_x, @h_percent, @rot_y, @depth_percent, @r_ang_ax, @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
 
-    # @see rotX
-    def rotX=(v) DataTypeValidator.validate "#{self.class}.rotX", [Integer, Fixnum], v, lambda {|arg| arg >= -90 && arg <= 90 }; @rotX = v; end
+    # @see rot_x
+    def rot_x=(v) DataTypeValidator.validate "#{self.class}.rot_x", [Integer, Fixnum], v, lambda {|arg| arg >= -90 && arg <= 90 }; @rot_x = v; end
+    alias :rotX= :rot_x=
 
-    # @see hPercent
-    def hPercent=(v) RegexValidator.validate "#{self.class}.rotX", H_PERCENT_REGEX, v; @hPercent = v; end
-
-    # @see rotY
-    def rotY=(v) DataTypeValidator.validate "#{self.class}.rotY", [Integer, Fixnum], v, lambda {|arg| arg >= 0 && arg <= 360 }; @rotY = v; end
+    # @see h_percent
+    def h_percent=(v)
+      RegexValidator.validate "#{self.class}.h_percent", H_PERCENT_REGEX, v
+      @h_percent = v
+    end
+    alias :hPercent= :h_percent=
 
-    # @see depthPercent
-    def depthPercent=(v) RegexValidator.validate "#{self.class}.depthPercent", DEPTH_PERCENT_REGEX, v; @depthPercent = v; end
+    # @see rot_y
+    def rot_y=(v) DataTypeValidator.validate "#{self.class}.rot_y", [Integer, Fixnum], v, lambda {|arg| arg >= 0 && arg <= 360 }; @rot_y = v; end
+    alias :rotY= :rot_y=
 
-    # @see rAngAx
-    def rAngAx=(v) Axlsx::validate_boolean(v); @rAngAx = v; end
+    # @see depth_percent
+    def depth_percent=(v) RegexValidator.validate "#{self.class}.depth_percent", DEPTH_PERCENT_REGEX, v; @depth_percent = v; end
+    alias :depthPercent= :depth_percent=
 
+    # @see r_ang_ax
+    def r_ang_ax=(v) Axlsx::validate_boolean(v); @r_ang_ax = v; end
+    alias :rAngAx= :r_ang_ax=
+     
     # @see perspective
     def perspective=(v) DataTypeValidator.validate "#{self.class}.perspective", [Integer, Fixnum], v, lambda {|arg| arg >= 0 && arg <= 240 }; @perspective = v; end
 
@@ -75,11 +88,11 @@ module Axlsx
     # @return [String]
     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:rotX val="' << @rot_x.to_s << '"/>' unless @rot_x.nil?
+      str << '<c:hPercent val="' << @h_percent.to_s << '"/>' unless @h_percent.nil?
+      str << '<c:rotY val="' << @rot_y.to_s << '"/>' unless @rot_y.nil?
+      str << '<c:depthPercent val="' << @depth_percent.to_s << '"/>' unless @depth_percent.nil?
+      str << '<c:rAngAx val="' << @r_ang_ax.to_s << '"/>' unless @r_ang_ax.nil?
       str << '<c:perspective val="' << @perspective.to_s << '"/>' unless @perspective.nil?
       str << '</c:view3D>'
     end

data/lib/axlsx/drawing/vml_drawing.rb

@@ -0,0 +1,42 @@
+module Axlsx
+
+  # a vml drawing used for comments in excel.
+  class VmlDrawing
+
+    # creates a new Vml Drawing object.
+    # @param [Comments] comments the comments object this drawing is associated with
+    def initialize(comments)
+      raise ArgumentError, "you must provide a comments object" unless comments.is_a?(Comments)
+      @comments = comments
+    end
+
+    # The part name for this vml drawing
+    # @return [String]
+    def pn
+      "#{VML_DRAWING_PN}" % (@comments.worksheet.index + 1)
+    end
+
+    # serialize the vml_drawing to xml.
+    # @param [String] str
+    # @return [String]
+    def to_xml_string(str = '')
+      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">
+ <o:shapelayout v:ext="edit">
+  <o:idmap v:ext="edit" data="#{@comments.worksheet.index+1}"/>
+ </o:shapelayout>
+ <v:shapetype id="_x0000_t202" coordsize="21600,21600" o:spt="202"
+  path="m0,0l0,21600,21600,21600,21600,0xe">
+  <v:stroke joinstyle="miter"/>
+  <v:path gradientshapeok="t" o:connecttype="rect"/>
+ </v:shapetype>
+BAD_PROGRAMMER
+      @comments.each { |comment| comment.vml_shape.to_xml_string str }
+      str << "</xml>"
+
+    end
+
+  end
+end

data/lib/axlsx/drawing/vml_shape.rb

@@ -0,0 +1,125 @@
+module Axlsx
+
+  # A VmlShape is used to position and render a comment.
+  class VmlShape
+
+    # The row anchor position for this shape determined by the comment's ref value
+    # @return [Integer]
+    attr_reader :row
+
+    # The column anchor position for this shape determined by the comment's ref value
+    # @return [Integer]
+    attr_reader :column
+
+    # The left column for this shape
+    # @return [Integer]
+    attr_reader :left_column
+
+    # The left offset for this shape
+    # @return [Integer]
+    attr_reader :left_offset
+
+    # The top row for this shape
+    # @return [Integer]
+    attr_reader :top_row
+
+    # The top offset for this shape
+    # @return [Integer]
+    attr_reader :top_offset
+
+    # The right column for this shape
+    # @return [Integer]
+    attr_reader :right_column
+
+    # The right offset for this shape
+    # @return [Integer]
+    attr_reader :right_offset
+
+    # The botttom row for this shape
+    # @return [Integer]
+    attr_reader :bottom_row
+
+    # The bottom offset for this shape
+    # @return [Integer]
+    attr_reader :bottom_offset
+
+    # Creates a new VmlShape
+    # @option options [Integer|String] left_column
+    # @option options [Integer|String] left_offset
+    # @option options [Integer|String] top_row
+    # @option options [Integer|String] top_offset
+    # @option options [Integer|String] right_column
+    # @option options [Integer|String] right_offset
+    # @option options [Integer|String] bottom_row
+    # @option options [Integer|String] bottom_offset
+    def initialize(options={})
+      @row = @column = @left_column = @top_row = @right_column = @bottom_row = 0
+      @left_offset = 15
+      @top_offset = 2
+      @right_offset = 50
+      @bottom_offset = 5
+      @id = (0...8).map{65.+(rand(25)).chr}.join
+      options.each do |o|
+        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
+      end
+      yield self if block_given?
+    end
+
+    # @see column
+    def column=(v); Axlsx::validate_integerish(v); @column = v.to_i end
+ 
+    # @see row
+    def row=(v); Axlsx::validate_integerish(v); @row = v.to_i end
+    # @see left_column
+    def left_column=(v); Axlsx::validate_integerish(v); @left_column = v.to_i end
+
+    # @see left_offset
+    def left_offset=(v); Axlsx::validate_integerish(v); @left_offset = v.to_i end
+
+    # @see top_row
+    def top_row=(v); Axlsx::validate_integerish(v); @top_row = v.to_i end
+
+    # @see top_offset
+    def top_offset=(v); Axlsx::validate_integerish(v); @top_offset = v.to_i end
+
+    # @see right_column
+    def right_column=(v); Axlsx::validate_integerish(v); @right_column = v.to_i end
+
+    # @see right_offset
+    def right_offset=(v); Axlsx::validate_integerish(v); @right_offset = v.to_i end
+
+    # @see bottom_row
+    def bottom_row=(v); Axlsx::validate_integerish(v); @bottom_row = v.to_i end
+
+    # @see bottom_offset
+    def bottom_offset=(v); Axlsx::validate_integerish(v); @bottom_offset = v.to_i end
+
+    # serialize the shape to a string
+    # @param [String] str
+    # @return [String]
+    def to_xml_string(str ='')
+str << <<SHAME_ON_YOU
+
+<v:shape id="#{@id}" type="#_x0000_t202" fillcolor="#ffffa1 [80]" o:insetmode="auto">
+  <v:fill color2="#ffffa1 [80]"/>
+  <v:shadow on="t" obscured="t"/>
+  <v:path o:connecttype="none"/>
+  <v:textbox style='mso-fit-text-with-word-wrap:t'>
+   <div style='text-align:left'></div>
+  </v:textbox>
+
+  <x:ClientData ObjectType="Note">
+   <x:MoveWithCells/>
+   <x:SizeWithCells/>
+   <x:Anchor>#{left_column}, #{left_offset}, #{top_row}, #{top_offset}, #{right_column}, #{right_offset}, #{bottom_row}, #{bottom_offset}</x:Anchor>
+   <x:AutoFill>False</x:AutoFill>
+   <x:Row>#{row}</x:Row>
+   <x:Column>#{column}</x:Column>
+   <x:Visible/>
+  </x:ClientData>
+ </v:shape>
+SHAME_ON_YOU
+
+    end
+  end
+end

data/lib/axlsx/package.rb

@@ -80,9 +80,8 @@ module Axlsx
 
     # Serialize your workbook to disk as an xlsx document.
     #
-    # @param [File] output The file you want to serialize your package to
+    # @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.
-    # @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.
@@ -90,10 +89,15 @@ module Axlsx
     # @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.
     #   # Take a look at the README for an example of how to do it!
-    #   f = File.open('test.xlsx', 'w')
-    #   Package.new.serialize(f)
     #
-    #   # You will find a file called test.xlsx
+    #   #serialize to a file
+    #   p = Axlsx::Package.new
+    #   # ......add cool stuff to your workbook......
+    #   p.serialize("example.xlsx")
+    #
+    #   # 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)
       return false unless !confirm_valid || self.validate.empty?
       Zip::ZipOutputStream.open(output) do |zip|
@@ -152,18 +156,18 @@ module Axlsx
     # @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
+      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
 
@@ -180,15 +184,24 @@ module Axlsx
        {: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_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.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 }
+        end
+      end
+
       workbook.charts.each do |chart|
         @parts << {:entry => "xl/#{chart.pn}", :doc => chart.to_xml_string, :schema => DRAWING_XSD}
       end
@@ -229,18 +242,33 @@ module Axlsx
     # @private
     def content_types
       c_types = base_content_types
+
       workbook.drawings.each do |drawing|
         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)
       end
+
       workbook.tables.each do |table|
         c_types << Axlsx::Override.new(:PartName => "/xl/#{table.pn}",
                                        :ContentType => TABLE_CT)
       end
+
+      workbook.comments.each do |comment|
+        if comment.size > 0
+        c_types << Axlsx::Override.new(:PartName => "/xl/#{comment.pn}",
+                                       :ContentType => COMMENT_CT)
+        end
+      end
+
+      if workbook.comments.size > 0
+        c_types << Axlsx::Default.new(:Extension => "vml", :ContentType => VML_DRAWING_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

@@ -30,9 +30,9 @@ module Axlsx
     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.
+    # @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

data/lib/axlsx/rels/relationships.rb

@@ -10,23 +10,13 @@ require 'axlsx/rels/relationship.rb'
     def initialize
       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()
-      builder = Nokogiri::XML::Builder.new(:encoding => ENCODING) do |xml|
-        xml.Relationships(:xmlns => Axlsx::RELS_R) {
-          each_with_index { |rel, index| rel.to_xml(xml, "rId#{index+1}") }
-        }
-      end
-      builder.to_xml(:save_with => 0)
-    end
 
   end
 end

data/lib/axlsx/stylesheet/color.rb

@@ -71,6 +71,5 @@ module Axlsx
       end
       str << "/>"
     end
-
   end
 end