axlsx 1.1.6 → 1.2.0

data/lib/axlsx/workbook/worksheet/worksheet_comments.rb

@@ -0,0 +1,57 @@
+module Axlsx
+
+  # A wraper class for comments that defines its on worksheet
+  # serailization
+  class WorksheetComments
+
+    # Creates a new WorksheetComments object
+    # param [Worksheet] worksheet The worksheet comments in thes object belong to
+    def initialize(worksheet)
+      raise ArugumentError, 'You must provide a worksheet' unless worksheet.is_a?(Worksheet)
+      @worksheet = worksheet
+    end
+
+    attr_reader :worksheet
+
+    # The comments for this worksheet.
+    # @return [Comments]
+    def comments
+      @comments ||= Comments.new(worksheet)
+    end
+
+    # Adds a comment
+    # @param [Hash] options
+    # @see Comments#add_comment
+    def add_comment(options={})
+      comments.add_comment(options)
+    end 
+
+    # The relationships defined by this objects comments collection
+    # @return [Relationships]
+    def relationships
+      return [] unless has_comments?
+      comments.relationships
+    end
+
+
+    # Helper method to tell us if there are comments in the comments collection
+    # @return [Boolean]
+    def has_comments?
+      !comments.empty?
+    end
+
+    # The index in the worksheet's relationships for the VML drawing that will render the comments
+    # @return [Integer]
+    def index
+      worksheet.relationships.index { |r| r.Type == VML_DRAWING_R } + 1
+    end
+
+    # Seraalize the object
+    # @param [String] str
+    # @return [String]
+    def to_xml_string(str = '')
+      return unless has_comments?
+      str << "<legacyDrawing r:id='rId#{index}' />"
+    end
+  end
+end

data/lib/axlsx/workbook/worksheet/worksheet_drawing.rb

@@ -0,0 +1,64 @@
+module Axlsx
+  
+  # This is a utility class for serialing the drawing node in a
+  # worksheet. Drawing objects have their own serialization that exports
+  # a drawing document. This is only for the single node in the
+  # worksheet
+  class WorksheetDrawing
+
+    # Creates a new WorksheetDrawing
+    # @param [Worksheet] worksheet
+    def initialize(worksheet)
+      raise ArgumentError, 'you must provide a worksheet' unless worksheet.is_a?(Worksheet)
+      @worksheet = worksheet      
+      @drawing = nil
+    end
+
+    attr_reader :worksheet
+
+    attr_reader :drawing
+    
+    # adds a chart to the drawing object
+    # @param [Class] chart_type The type of chart to add
+    # @param [Hash] options Options to pass on to the drawing and chart
+    # @see Worksheet#add_chart
+    def add_chart(chart_type, options)
+      @drawing ||= Drawing.new worksheet
+      drawing.add_chart(chart_type, options)
+    end
+    
+    # adds an image to the drawing object
+    # @param [Hash] options Options to pass on to the drawing and image 
+    # @see Worksheet#add_image
+    def add_image(options)
+      @drawing ||= Drawing.new worksheet
+      drawing.add_image(options)
+    end 
+  
+    # helper method to tell us if the drawing has something in it or not
+    # @return [Boolean] 
+    def has_drawing?
+      @drawing.is_a? Drawing
+    end
+
+    # The relationship required by this object
+    # @return [Relationship]
+    def relationship
+      return unless has_drawing?
+      Relationship.new(DRAWING_R, "../#{drawing.pn}") 
+    end
+
+    # returns the index of the worksheet releationship that defines this drawing.
+    # @return [Integer]
+    def index
+       worksheet.relationships.index{ |r| r.Type == DRAWING_R } +1 
+    end
+
+    # Serialize the drawing for the worksheet
+    # @param [String] str
+    def to_xml_string(str = '')
+      return unless has_drawing? 
+      str << "<drawing r:id='rId#{index}'/>"
+    end
+  end
+end

data/lib/axlsx.rb

@@ -1,16 +1,11 @@
 # encoding: UTF-8
+require 'htmlentities'
 require 'axlsx/version.rb'
 
 require 'axlsx/util/simple_typed_list.rb'
 require 'axlsx/util/constants.rb'
 require 'axlsx/util/validators.rb'
 
-#not even close to being ready but it does not break anything so it stays for now.
-# needs a full re-write to use agile-encryption properly
-# require 'axlsx/util/storage.rb'
-# require 'axlsx/util/cbf.rb'
-# require 'axlsx/util/ms_off_crypto.rb'
-
 # to be included with parsable intitites.
 #require 'axlsx/util/parser.rb'
 
@@ -44,24 +39,36 @@ end
 
 # xlsx generation with charts, images, automated column width, customizable styles and full schema validation. Axlsx excels at helping you generate beautiful Office Open XML Spreadsheet documents without having to understand the entire ECMA specification. Check out the README for some examples of how easy it is. Best of all, you can validate your xlsx file before serialization so you know for sure that anything generated is going to load on your client's machine.
 module Axlsx
+
   # determines the cell range for the items provided
-  def self.cell_range(items)
-    return "" unless items.first.is_a? Cell
-    ref = "'#{items.first.row.worksheet.name}'!" +
-      "#{items.first.r_abs}"
-    ref += ":#{items.last.r_abs}" if items.size > 1
-    ref
+  def self.cell_range(cells, absolute=true)
+    return "" unless cells.first.is_a? Cell
+    sort_cells(cells)
+    reference = "#{cells.first.reference(absolute)}:#{cells.last.reference(absolute)}"
+    absolute ? "'#{cells.first.row.worksheet.name}'!#{reference}" : reference
+  end
+
+  # sorts the array of cells provided to start from the minimum x,y to
+  # the maximum x.y#
+  # @param [Array] cells
+  # @return [Array]
+  def self.sort_cells(cells)
+    cells.sort { |x, y| [x.index, x.row.index] <=> [y.index, y.row.index] }
   end
 
+  #global reference html entity encoding
+  # @return [HtmlEntities]
+  def self.coder
+    @@coder ||= ::HTMLEntities.new
+  end
+  
   # returns the x, y position of a cell
   def self.name_to_indices(name)
     raise ArgumentError, 'invalid cell name' unless name.size > 1
     v = name[/[A-Z]+/].reverse.chars.reduce({:base=>1, :i=>0}) do  |val, c|
       val[:i] += ((c.bytes.first - 64) * val[:base]); val[:base] *= 26; val
     end
-
     [v[:i]-1, ((name[/[1-9][0-9]*/]).to_i)-1]
-
   end
 
   # converts the column index into alphabetical values.
@@ -87,8 +94,9 @@ module Axlsx
   # performs the increadible feat of changing snake_case to CamelCase
   # @param [String] s The snake case string to camelize
   # @return [String]
-  def self.camel(s="")
-    s = s.capitalize.gsub(/_(.)/){ $1.upcase }
+  def self.camel(s="", all_caps = true)
+    s = s.capitalize if all_caps
+    s.gsub(/_(.)/){ $1.upcase }
   end
 
 end

data/test/content_type/tc_content_type.rb

@@ -9,12 +9,7 @@ class TestContentType < Test::Unit::TestCase
 
   def test_valid_document
     schema = Nokogiri::XML::Schema(File.open(Axlsx::CONTENT_TYPES_XSD))
-    errors = []
-    schema.validate(@doc).each do |error|
-      puts error.message
-      errors << error
-    end
-    assert_equal(errors.size, 0, "[Content Types].xml Invalid" + errors.map{ |e| e.message }.to_s)
+    assert(schema.validate(@doc).map{ |e| puts e.message; e.message }.empty?)
   end
 
   def test_pre_built_types

data/test/doc_props/tc_core.rb

@@ -5,7 +5,7 @@ class TestCore < Test::Unit::TestCase
   def setup
     @core = Axlsx::Core.new
     # could still see some false positives if the second changes between the next two calls
-    @time = Time.now.strftime('%Y-%m-%dT%H:%M:%S')
+    @time = Time.now.strftime('%Y-%m-%dT%H:%M:%SZ')
     @doc = Nokogiri::XML(@core.to_xml_string)
   end
 

data/test/drawing/tc_axis.rb

@@ -2,8 +2,10 @@ require 'tc_helper.rb'
 
 class TestAxis < Test::Unit::TestCase
   def setup
-    @axis = Axlsx::Axis.new 12345, 54321, :gridlines => false
+    
+    @axis = Axlsx::Axis.new 12345, 54321, :gridlines => false, :title => 'Foo'
   end
+
   def teardown
   end
 
@@ -14,6 +16,29 @@ class TestAxis < Test::Unit::TestCase
     assert_equal(@axis.crosses, :autoZero, "tick label position default incorrect")
     assert(@axis.scaling.is_a?(Axlsx::Scaling) && @axis.scaling.orientation == :minMax, "scaling default incorrect")
     assert_raise(ArgumentError) { Axlsx::Axis.new( -1234, 'abcd') }
+    assert_equal('Foo', @axis.title.text)
+  end
+
+  def test_color
+    @axis.color = "00FF00"
+    str  = '<?xml version="1.0" encoding="UTF-8"?>'
+    str << '<c:chartSpace xmlns:c="' << Axlsx::XML_NS_C << '" xmlns:a="' << Axlsx::XML_NS_A << '">'
+    doc = Nokogiri::XML(@axis.to_xml_string(str)) 
+    assert(doc.xpath("//a:srgbClr[@val='00FF00']"))
+  end
+
+  def test_cell_based_axis_title
+    p = Axlsx::Package.new
+    p.workbook.add_worksheet(:name=>'foosheet') do |sheet|
+      sheet.add_row ['battle victories']
+      sheet.add_row ['bird', 1, 2, 1]
+      sheet.add_row ['cat', 7, 9, 10]
+      sheet.add_chart(Axlsx::Line3DChart) do |chart|
+        chart.add_series :data => sheet['B2:D2'], :labels => sheet['B1']
+        chart.valAxis.title = sheet['A1']
+        assert_equal('battle victories', chart.valAxis.title.text)  
+      end
+    end
   end
 
   def test_axis_position
@@ -57,6 +82,6 @@ class TestAxis < Test::Unit::TestCase
     assert(doc.xpath("//c:crosses[@val='#{@axis.crosses.to_s}']"))
     assert(doc.xpath("//c:crossAx[@val='#{@axis.crossAx.to_s}']"))
     assert(doc.xpath("//a:bodyPr[@rot='#{@axis.label_rotation.to_s}']"))
-
+    assert(doc.xpath("//a:t[text()='Foo']"))
   end
 end

data/test/drawing/tc_bar_3D_chart.rb

@@ -15,15 +15,15 @@ class TestBar3DChart < Test::Unit::TestCase
   def test_initialization
     assert_equal(@chart.grouping, :clustered, "grouping defualt incorrect")
     assert_equal(@chart.series_type, Axlsx::BarSeries, "series type incorrect")
-    assert_equal(@chart.barDir, :bar, " bar direction incorrect")
-    assert(@chart.catAxis.is_a?(Axlsx::CatAxis), "category axis not created")
-    assert(@chart.valAxis.is_a?(Axlsx::ValAxis), "value access not created")
+    assert_equal(@chart.bar_dir, :bar, " bar direction incorrect")
+    assert(@chart.cat_axis.is_a?(Axlsx::CatAxis), "category axis not created")
+    assert(@chart.val_axis.is_a?(Axlsx::ValAxis), "value access not created")
   end
 
   def test_bar_direction
-    assert_raise(ArgumentError, "require valid bar direction") { @chart.barDir = :left }
-    assert_nothing_raised("allow valid bar direction") { @chart.barDir = :col }
-    assert(@chart.barDir == :col)
+    assert_raise(ArgumentError, "require valid bar direction") { @chart.bar_dir = :left }
+    assert_nothing_raised("allow valid bar direction") { @chart.bar_dir = :col }
+    assert(@chart.bar_dir == :col)
   end
 
  def test_grouping
@@ -34,15 +34,15 @@ class TestBar3DChart < Test::Unit::TestCase
 
 
  def test_gapWidth
-   assert_raise(ArgumentError, "require valid gap width") { @chart.gapWidth = 200 }
-   assert_nothing_raised("allow valid gapWidth") { @chart.gapWidth = "200%" }
-   assert(@chart.gapWidth == "200%")
+   assert_raise(ArgumentError, "require valid gap width") { @chart.gap_width = 200 }
+   assert_nothing_raised("allow valid gapWidth") { @chart.gap_width = "200%" }
+   assert(@chart.gap_width == "200%")
  end
 
  def test_gapDepth
-   assert_raise(ArgumentError, "require valid gapDepth") { @chart.gapDepth = 200 }
-   assert_nothing_raised("allow valid gapDepth") { @chart.gapDepth = "200%" }
-   assert(@chart.gapDepth == "200%")
+   assert_raise(ArgumentError, "require valid gap_depth") { @chart.gap_depth = 200 }
+   assert_nothing_raised("allow valid gap_depth") { @chart.gap_depth = "200%" }
+   assert(@chart.gap_depth == "200%")
  end
 
   def test_shape

data/test/drawing/tc_bar_series.rb

@@ -5,7 +5,7 @@ class TestBarSeries < Test::Unit::TestCase
   def setup
     p = Axlsx::Package.new
     @ws = p.workbook.add_worksheet :name=>"hmmm"
-    @chart = @ws.drawing.add_chart Axlsx::Bar3DChart, :title => "fishery"
+    @chart = @ws.add_chart Axlsx::Bar3DChart, :title => "fishery"
     @series = @chart.add_series :data=>[0,1,2], :labels=>["zero", "one", "two"], :title=>"bob", :colors => ['FF0000', '00FF00', '0000FF'], :shape => :cone
   end
 
@@ -33,6 +33,5 @@ class TestBarSeries < Test::Unit::TestCase
       assert_equal(doc.xpath("//c:dPt/c:idx[@val='#{index}']").size,1)
       assert_equal(doc.xpath("//c:dPt/c:spPr/a:solidFill/a:srgbClr[@val='#{@series.colors[index]}']").size,1)
     end
-    assert_equal(doc.xpath("//c:shape[@val='#{@series.shape.to_s}']").size, 1)
   end
 end

data/test/drawing/tc_cat_axis.rb

@@ -10,7 +10,7 @@ class TestCatAxis < Test::Unit::TestCase
   def test_initialization
     assert_equal(@axis.auto, 1, "axis auto default incorrect")
     assert_equal(@axis.lblAlgn, :ctr, "label align default incorrect")
-    assert_equal(@axis.lblOffset, "100%", "label offset default incorrect")
+    assert_equal(@axis.lblOffset, "100", "label offset default incorrect")
   end
 
   def test_auto
@@ -24,8 +24,8 @@ class TestCatAxis < Test::Unit::TestCase
   end
 
   def test_lblOffset
-    assert_raise(ArgumentError, "requires valid label offset") { @axis.lblOffset = 100 }
-    assert_nothing_raised("accepts valid label offset") { @axis.lblOffset = "20%" }
+    assert_raise(ArgumentError, "requires valid label offset") { @axis.lblOffset = 'foo' }
+    assert_nothing_raised("accepts valid label offset") { @axis.lblOffset = "20" }
   end
 
 end

data/test/drawing/tc_chart.rb

@@ -73,15 +73,17 @@ class TestChart < Test::Unit::TestCase
   def test_pn
     assert_equal(@chart.pn, "charts/chart1.xml")
   end
-
+  
+  def test_d_lbls
+    assert_equal(nil, @chart.instance_values[:d_lbls])
+    @chart.d_lbls.d_lbl_pos = :t
+    assert(@chart.d_lbls.is_a?(Axlsx::DLbls), 'DLbls instantiated on access')
+  end
+  
   def test_to_xml_string
     schema = Nokogiri::XML::Schema(File.open(Axlsx::DRAWING_XSD))
     doc = Nokogiri::XML(@chart.to_xml_string)
-    errors = []
-    schema.validate(doc).each do |error|
-      errors.push error
-      puts error.message
-    end
+    errors = schema.validate(doc).map { |error| puts error.message; error }
     assert(errors.empty?, "error free validation")
   end
 

data/test/drawing/tc_d_lbls.rb

@@ -0,0 +1,47 @@
+require 'tc_helper'
+
+class TestDLbls < Test::Unit::TestCase
+
+  def setup
+    @d_lbls = Axlsx::DLbls.new(Axlsx::Pie3DChart)
+  end
+
+  def test_initialization
+    assert_equal(:bestFit, @d_lbls.d_lbl_pos)
+    Axlsx::DLbls::BOOLEAN_ATTRIBUTES.each do |attr|
+      assert_equal(false, @d_lbls.send(attr))
+    end
+  end
+
+  def test_initialization_with_optoins
+    options_hash = Hash[*[Axlsx::DLbls::BOOLEAN_ATTRIBUTES.map { |name| [name, true] }] ]
+    d_lbls = Axlsx::DLbls.new(Axlsx::Pie3DChart, options_hash.merge( { :d_lbl_pos => :t }))
+    Axlsx::DLbls::BOOLEAN_ATTRIBUTES.each do |attr|
+      assert_equal(true, d_lbls.send(attr), "boolean attributes set by options")
+    end
+    assert_equal(:t, d_lbls.d_lbl_pos, "d_lbl_pos set by options")
+  end
+  def test_d_lbl_pos
+    assert_raise(ArgumentError, 'invlaid label positions are rejected') { @d_lbls.d_lbl_pos = :upside_down }
+    assert_nothing_raised('accepts valid label position') { @d_lbls.d_lbl_pos = :ctr }
+  end
+
+  def test_boolean_attributes
+    Axlsx::DLbls::BOOLEAN_ATTRIBUTES.each do |attr|
+      assert_raise(ArgumentError, "rejects non boolean value for #{attr}") { @d_lbls.send("#{attr}=", :foo) }
+      assert_nothing_raised("accepts boolean value for #{attr}") { @d_lbls.send("#{attr}=", true) }
+      assert_nothing_raised("accepts boolean value for #{attr}") { @d_lbls.send("#{attr}=", false) }
+    end
+  end
+
+  def test_to_xml_string
+      str = '<?xml version="1.0" encoding="UTF-8"?>'
+      str << '<c:chartSpace xmlns:c="' << Axlsx::XML_NS_C << '" xmlns:a="' << Axlsx::XML_NS_A << '" xmlns:r="' << Axlsx::XML_NS_R << '">'
+      @d_lbls.to_xml_string(str) 
+      str << '</c:chartSpace>'
+      doc = Nokogiri::XML(str)
+      @d_lbls.instance_values.each do |name, value|
+        assert(doc.xpath("//c:#{Axlsx::camel(name, false)}[@val='#{value}']"), "#{name} is properly serialized")
+      end
+  end
+end

data/test/drawing/tc_drawing.rb

@@ -9,8 +9,6 @@ class TestDrawing < Test::Unit::TestCase
 
   def test_initialization
     assert(@ws.workbook.drawings.empty?)
-    assert_equal(@ws.drawing, @ws.workbook.drawings.last, "drawing is added to workbook")
-    assert(@ws.drawing.anchors.is_a?(Axlsx::SimpleTypedList) && @ws.drawing.anchors.empty?, "anchor list is created and empty")
   end
 
   def test_add_chart
@@ -39,7 +37,6 @@ class TestDrawing < Test::Unit::TestCase
     assert(image.is_a?(Axlsx::Pic))
   end
   def test_charts
-    assert(@ws.drawing.charts.empty?)
     chart = @ws.add_chart(Axlsx::Pie3DChart, :title=>"bob", :start_at=>[0,0], :end_at=>[1,1])
     assert_equal(@ws.drawing.charts.last, chart, "add chart is returned")
     chart = @ws.add_chart(Axlsx::Pie3DChart, :title=>"nancy", :start_at=>[1,5], :end_at=>[5,10])
@@ -47,23 +44,26 @@ class TestDrawing < Test::Unit::TestCase
   end
 
   def test_pn
+    @ws.add_chart(Axlsx::Pie3DChart)
     assert_equal(@ws.drawing.pn, "drawings/drawing1.xml")
   end
 
   def test_rels_pn
+    @ws.add_chart(Axlsx::Pie3DChart)
     assert_equal(@ws.drawing.rels_pn, "drawings/_rels/drawing1.xml.rels")
   end
 
   def test_rId
+    @ws.add_chart(Axlsx::Pie3DChart)
     assert_equal(@ws.drawing.rId, "rId1")
   end
 
   def test_index
+    @ws.add_chart(Axlsx::Pie3DChart)
     assert_equal(@ws.drawing.index, @ws.workbook.drawings.index(@ws.drawing))
   end
 
   def test_relationships
-    assert(@ws.drawing.relationships.empty?)
     chart = @ws.add_chart(Axlsx::Pie3DChart, :title=>"bob", :start_at=>[0,0], :end_at=>[1,1])
     assert_equal(@ws.drawing.relationships.size, 1, "adding a chart adds a relationship")
     chart = @ws.add_chart(Axlsx::Pie3DChart, :title=>"nancy", :start_at=>[1,5], :end_at=>[5,10])
@@ -72,6 +72,7 @@ class TestDrawing < Test::Unit::TestCase
 
   def test_to_xml
     schema = Nokogiri::XML::Schema(File.open(Axlsx::DRAWING_XSD))
+    @ws.add_chart(Axlsx::Pie3DChart)
     doc = Nokogiri::XML(@ws.drawing.to_xml_string)
     errors = []
     schema.validate(doc).each do |error|

data/test/drawing/tc_line_series.rb

@@ -5,7 +5,7 @@ class TestLineSeries < Test::Unit::TestCase
   def setup
     p = Axlsx::Package.new
     @ws = p.workbook.add_worksheet :name=>"hmmm"
-    chart = @ws.drawing.add_chart Axlsx::Line3DChart, :title => "fishery"
+    chart = @ws.add_chart Axlsx::Line3DChart, :title => "fishery"
     @series = chart.add_series :data=>[0,1,2], :labels=>["zero", "one", "two"], :title=>"bob", :color => "#FF0000"
   end
 

data/test/drawing/tc_num_data.rb

@@ -9,7 +9,11 @@ class TestNumData < Test::Unit::TestCase
   def test_initialize
     assert_equal(@num_data.format_code, "General")
   end
-
+ 
+  def test_formula_based_cell
+  
+  end
+ 
   def test_format_code
     assert_raise(ArgumentError) {@num_data.format_code = 7}
     assert_nothing_raised {@num_data.format_code = 'foo_bar'}

data/test/drawing/tc_pie_3D_chart.rb

@@ -6,26 +6,22 @@ class TestPie3DChart < Test::Unit::TestCase
     p = Axlsx::Package.new
     ws = p.workbook.add_worksheet
     @row = ws.add_row ["one", 1, Time.now]
-    @chart = ws.drawing.add_chart Axlsx::Pie3DChart, :title => "fishery"
+    @chart = ws.add_chart Axlsx::Pie3DChart, :title => "fishery"
   end
 
   def teardown
   end
 
   def test_initialization
-    assert_equal(@chart.view3D.rotX, 30, "view 3d default rotX incorrect")
-    assert_equal(@chart.view3D.perspective, 30, "view 3d default perspective incorrect")
+    assert_equal(@chart.view_3D.rot_x, 30, "view 3d default rot_x incorrect")
+    assert_equal(@chart.view_3D.perspective, 30, "view_3d default perspective incorrect")
     assert_equal(@chart.series_type, Axlsx::PieSeries, "series type incorrect")
   end
 
   def test_to_xml
     schema = Nokogiri::XML::Schema(File.open(Axlsx::DRAWING_XSD))
     doc = Nokogiri::XML(@chart.to_xml_string)
-    errors = []
-    schema.validate(doc).each do |error|
-      errors.push error
-      puts error.message
-    end
+    errors = schema.validate(doc).map {|error| puts error.message; error }
     assert(errors.empty?, "error free validation")
   end
 

data/test/drawing/tc_pie_series.rb

@@ -5,7 +5,7 @@ class TestPieSeries < Test::Unit::TestCase
   def setup
     p = Axlsx::Package.new
     @ws = p.workbook.add_worksheet :name=>"hmmm"
-    chart = @ws.drawing.add_chart Axlsx::Pie3DChart, :title => "fishery"
+    chart = @ws.add_chart Axlsx::Pie3DChart, :title => "fishery"
     @series = chart.add_series :data=>[0,1,2], :labels=>["zero", "one", "two"], :title=>"bob", :colors => ["FF0000", "00FF00", "0000FF"]
   end
 

data/test/drawing/tc_scatter_series.rb

@@ -5,7 +5,7 @@ class TestScatterSeries < Test::Unit::TestCase
   def setup
     p = Axlsx::Package.new
     @ws = p.workbook.add_worksheet :name=>"hmmm"
-    @chart = @ws.drawing.add_chart Axlsx::ScatterChart, :title => "Scatter Chart"
+    @chart = @ws.add_chart Axlsx::ScatterChart, :title => "Scatter Chart"
     @series = @chart.add_series :xData=>[1,2,4], :yData=>[1,3,9], :title=>"exponents", :color => 'FF0000'
   end
 

data/test/drawing/tc_series.rb

@@ -5,7 +5,7 @@ class TestSeries < Test::Unit::TestCase
   def setup
     p = Axlsx::Package.new
     @ws = p.workbook.add_worksheet :name=>"hmmm"
-    chart = @ws.drawing.add_chart Axlsx::Chart, :title => "fishery"
+    chart = @ws.add_chart Axlsx::Chart, :title => "fishery"
     @series = chart.add_series :title=>"bob"
   end
 

data/test/drawing/tc_title.rb

@@ -1,3 +1,5 @@
+$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../"
+
 require 'tc_helper.rb'
 
 class TestTitle < Test::Unit::TestCase
@@ -30,4 +32,18 @@ class TestTitle < Test::Unit::TestCase
     assert(@title.text == "one")
   end
 
+  def test_to_xml_string_text
+    @chart.title.text = 'foo'
+    doc = Nokogiri::XML(@chart.to_xml_string)
+    assert_equal(1, doc.xpath('//c:rich').size)
+    assert_equal(1, doc.xpath("//a:t[text()='foo']").size)
+  end
+
+  def test_to_xml_string_cell
+    @chart.title.cell = @row.cells.first
+    doc = Nokogiri::XML(@chart.to_xml_string)
+    assert_equal(1, doc.xpath('//c:strCache').size)
+    assert_equal(1, doc.xpath('//c:v[text()="one"]').size)
+  end
+
 end

data/test/drawing/tc_view_3D.rb

@@ -9,33 +9,33 @@ class TestView3D < Test::Unit::TestCase
   end
 
   def test_options
-    v = Axlsx::View3D.new :rotX => 10, :rotY => 5, :hPercent => "30%", :depthPercent => "45%", :rAngAx => false, :perspective => 10
-    assert_equal(v.rotX, 10)
-    assert_equal(v.rotY, 5)
-    assert_equal(v.hPercent, "30%")
-    assert_equal(v.depthPercent, "45%")
-    assert_equal(v.rAngAx, false)
+    v = Axlsx::View3D.new :rot_x => 10, :rot_y => 5, :h_percent => "30%", :depth_percent => "45%", :r_ang_ax => false, :perspective => 10
+    assert_equal(v.rot_x, 10)
+    assert_equal(v.rot_y, 5)
+    assert_equal(v.h_percent, "30%")
+    assert_equal(v.depth_percent, "45%")
+    assert_equal(v.r_ang_ax, false)
     assert_equal(v.perspective, 10)
   end
 
-  def test_rotX
-    assert_raise(ArgumentError) {@view.rotX = "bob"}
-    assert_nothing_raised {@view.rotX = -90}
+  def test_rot_x
+    assert_raise(ArgumentError) {@view.rot_x = "bob"}
+    assert_nothing_raised {@view.rot_x = -90}
   end
 
-  def test_rotY
-    assert_raise(ArgumentError) {@view.rotY = "bob"}
-    assert_nothing_raised {@view.rotY = 90}
+  def test_rot_y
+    assert_raise(ArgumentError) {@view.rot_y = "bob"}
+    assert_nothing_raised {@view.rot_y = 90}
   end
 
-  def test_hPercent
-    assert_raise(ArgumentError) {@view.hPercent = "bob"}
-    assert_nothing_raised {@view.hPercent = "500%"}
+  def test_h_percent
+    assert_raise(ArgumentError) {@view.h_percent = "bob"}
+    assert_nothing_raised {@view.h_percent = "500%"}
   end
 
-  def test_depthPercent
-    assert_raise(ArgumentError) {@view.depthPercent = "bob"}
-    assert_nothing_raised {@view.depthPercent = "20%"}
+  def test_depth_percent
+    assert_raise(ArgumentError) {@view.depth_percent = "bob"}
+    assert_nothing_raised {@view.depth_percent = "20%"}
   end