axlsx 1.2.0 → 2.0.0

data/test/benchmark.rb

@@ -1,14 +1,13 @@
 #!/usr/bin/env ruby -s
-# -*- coding: utf-8 -*-
 $:.unshift "#{File.dirname(__FILE__)}/../lib"
 require 'axlsx'
 require 'csv'
 require 'benchmark'
-
+Axlsx::trust_input = true
 row = []
 input = (32..126).to_a.pack('U*').chars.to_a
 20.times { row << input.shuffle.join}
-times = 2000
+times = 3000
 Benchmark.bmbm(30) do |x|
 
   x.report('axlsx_noautowidth') {

data/test/content_type/tc_default.rb

@@ -3,14 +3,6 @@ require 'tc_helper.rb'
 
 class TestDefault < Test::Unit::TestCase
 
-  def test_initialization_requires_Extension_and_ContentType
-    assert_raise(ArgumentError, "raises argument error if Extension and/or ContentType are not specified") { Axlsx::Default.new }
-    assert_raise(ArgumentError, "raises argument error if Extension and/or ContentType are not specified") { Axlsx::Default.new :Extension=>"xml" }
-    assert_raise(ArgumentError, "raises argument error if Extension and/or ContentType are not specified") { Axlsx::Default.new :ContentType=>"asdf" }
-
-    assert_nothing_raised {Axlsx::Default.new :Extension=>"foo", :ContentType=>Axlsx::XML_CT}
-
-  end
   def test_content_type_restriction
     assert_raise(ArgumentError, "raises argument error if invlalid ContentType is") { Axlsx::Default.new :ContentType=>"asdf" }
   end
@@ -20,8 +12,5 @@ class TestDefault < Test::Unit::TestCase
     doc = Nokogiri::XML(type.to_xml_string)
     assert_equal(doc.xpath("Default[@ContentType='#{Axlsx::XML_CT}']").size, 1)
     assert_equal(doc.xpath("Default[@Extension='xml']").size, 1)
-
   end
-
-
 end

data/test/content_type/tc_override.rb

@@ -1,16 +1,6 @@
-# -*- coding: utf-8 -*-
 require 'tc_helper.rb'
-
 class TestOverride < Test::Unit::TestCase
 
-  def test_initialization_requires_Extension_and_ContentType
-    err = "requires PartName and ContentType options"
-    assert_raise(ArgumentError, err) { Axlsx::Override.new }
-    assert_raise(ArgumentError, err) { Axlsx::Override.new :PartName=>"xml" }
-    assert_raise(ArgumentError, err) { Axlsx::Override.new :ContentType=>"asdf" }
-    assert_nothing_raised {Axlsx::Override.new :PartName=>"foo", :ContentType=>Axlsx::CHART_CT}
-  end
-
   def test_content_type_restriction
     assert_raise(ArgumentError, "requires known content type") { Axlsx::Override.new :ContentType=>"asdf" }
   end
@@ -20,8 +10,5 @@ class TestOverride < Test::Unit::TestCase
     doc = Nokogiri::XML(type.to_xml_string)
     assert_equal(doc.xpath("Override[@ContentType='#{Axlsx::CHART_CT}']").size, 1)
     assert_equal(doc.xpath("Override[@PartName='somechart.xml']").size, 1)
-
   end
-
-
 end

data/test/doc_props/tc_core.rb

@@ -23,6 +23,13 @@ class TestCore < Test::Unit::TestCase
     assert_equal(@doc.xpath('//dcterms:created').text, @time, "dcterms:created incorrect")
   end
 
+  def test_created_as_option
+    time = Time.utc(2013, 1, 1, 12, 00)
+    c = Axlsx::Core.new :created => time
+    doc = Nokogiri::XML(c.to_xml_string)
+    assert_equal(doc.xpath('//dcterms:created').text, time.xmlschema, "dcterms:created incorrect")
+  end
+
   def test_populates_default_name
     assert_equal(@doc.xpath('//dc:creator').text, "axlsx", "Default name not populated")
   end

data/test/drawing/tc_axes.rb

@@ -0,0 +1,8 @@
+require 'tc_helper.rb'
+
+class TestAxes < Test::Unit::TestCase
+  def test_constructor_requires_cat_axis_first
+    assert_raise(ArgumentError) { Axlsx::Axes.new(:val_axis => Axlsx::ValAxis, :cat_axis => Axlsx::CatAxis) }
+    assert_nothing_raised { Axlsx::Axes.new(:cat_axis => Axlsx::CatAxis, :val_axis => Axlsx::ValAxis) }
+  end
+end

data/test/drawing/tc_axis.rb

@@ -2,25 +2,22 @@ require 'tc_helper.rb'
 
 class TestAxis < Test::Unit::TestCase
   def setup
-    
-    @axis = Axlsx::Axis.new 12345, 54321, :gridlines => false, :title => 'Foo'
+    @axis = Axlsx::Axis.new :gridlines => false, :title => 'Foo'
   end
 
-  def teardown
-  end
 
   def test_initialization
-    assert_equal(@axis.axPos, :b, "axis position default incorrect")
-    assert_equal(@axis.tickLblPos, :nextTo, "tick label position default incorrect")
-    assert_equal(@axis.tickLblPos, :nextTo, "tick label position default incorrect")
+    assert_equal(@axis.ax_pos, :b, "axis position default incorrect")
+    assert_equal(@axis.tick_lbl_pos, :nextTo, "tick label position default incorrect")
+    assert_equal(@axis.tick_lbl_pos, :nextTo, "tick label position default incorrect")
     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"
+    @axis.cross_axis = Axlsx::CatAxis.new
     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)) 
@@ -35,15 +32,15 @@ class TestAxis < Test::Unit::TestCase
       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)  
+        chart.val_axis.title = sheet['A1']
+        assert_equal('battle victories', chart.val_axis.title.text)
       end
     end
   end
 
   def test_axis_position
-    assert_raise(ArgumentError, "requires valid axis position") { @axis.axPos = :nowhere }
-    assert_nothing_raised("accepts valid axis position") { @axis.axPos = :r }
+    assert_raise(ArgumentError, "requires valid axis position") { @axis.ax_pos = :nowhere }
+    assert_nothing_raised("accepts valid axis position") { @axis.ax_pos = :r }
   end
 
   def test_label_rotation
@@ -55,13 +52,13 @@ class TestAxis < Test::Unit::TestCase
   end
 
   def test_tick_label_position
-    assert_raise(ArgumentError, "requires valid tick label position") { @axis.tickLblPos = :nowhere }
-    assert_nothing_raised("accepts valid tick label position") { @axis.tickLblPos = :high }
+    assert_raise(ArgumentError, "requires valid tick label position") { @axis.tick_lbl_pos = :nowhere }
+    assert_nothing_raised("accepts valid tick label position") { @axis.tick_lbl_pos = :high }
   end
 
   def test_format_code
-    assert_raise(ArgumentError, "requires valid format code") { @axis.format_code = 1 }
-    assert_nothing_raised("accepts valid format code") { @axis.tickLblPos = :high }
+    assert_raise(ArgumentError, "requires valid format code") { @axis.format_code = :high }
+    assert_nothing_raised("accepts valid format code") { @axis.format_code = "00.##"  }
   end
 
   def test_crosses
@@ -75,12 +72,13 @@ class TestAxis < Test::Unit::TestCase
   end
   
   def test_to_xml_string
+    @axis.cross_axis = Axlsx::CatAxis.new
     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:noFill'))
     assert(doc.xpath("//c:crosses[@val='#{@axis.crosses.to_s}']"))
-    assert(doc.xpath("//c:crossAx[@val='#{@axis.crossAx.to_s}']"))
+    assert(doc.xpath("//c:crossAx[@val='#{@axis.cross_axis.to_s}']"))
     assert(doc.xpath("//a:bodyPr[@rot='#{@axis.label_rotation.to_s}']"))
     assert(doc.xpath("//a:t[text()='Foo']"))
   end

data/test/drawing/tc_bar_3D_chart.rb

@@ -62,4 +62,10 @@ class TestBar3DChart < Test::Unit::TestCase
     assert(errors.empty?, "error free validation")
   end
 
+  def test_to_xml_string_has_axes_in_correct_order
+    str = @chart.to_xml_string
+    cat_axis_position = str.index(@chart.axes[:cat_axis].id.to_s)
+    val_axis_position = str.index(@chart.axes[:val_axis].id.to_s)
+    assert(cat_axis_position < val_axis_position, "cat_axis must occur earlier than val_axis in the XML")
+  end
 end

data/test/drawing/tc_cat_axis.rb

@@ -2,15 +2,15 @@ require 'tc_helper.rb'
 
 class TestCatAxis < Test::Unit::TestCase
   def setup
-    @axis = Axlsx::CatAxis.new 12345, 54321
+    @axis = Axlsx::CatAxis.new
   end
   def teardown
   end
 
   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.lbl_algn, :ctr, "label align default incorrect")
+    assert_equal(@axis.lbl_offset, "100", "label offset default incorrect")
   end
 
   def test_auto
@@ -18,14 +18,14 @@ class TestCatAxis < Test::Unit::TestCase
     assert_nothing_raised("accepts valid auto") { @axis.auto = false }
   end
 
-  def test_lblAlgn
-    assert_raise(ArgumentError, "requires valid label alignment") { @axis.lblAlgn = :nowhere }
-    assert_nothing_raised("accepts valid label alignment") { @axis.lblAlgn = :r }
+  def test_lbl_algn
+    assert_raise(ArgumentError, "requires valid label alignment") { @axis.lbl_algn = :nowhere }
+    assert_nothing_raised("accepts valid label alignment") { @axis.lbl_algn = :r }
   end
 
-  def test_lblOffset
-    assert_raise(ArgumentError, "requires valid label offset") { @axis.lblOffset = 'foo' }
-    assert_nothing_raised("accepts valid label offset") { @axis.lblOffset = "20" }
+  def test_lbl_offset
+    assert_raise(ArgumentError, "requires valid label offset") { @axis.lbl_offset = 'foo' }
+    assert_nothing_raised("accepts valid label offset") { @axis.lbl_offset = "20" }
   end
 
 end

data/test/drawing/tc_chart.rb

@@ -37,6 +37,21 @@ class TestChart < Test::Unit::TestCase
     assert_nothing_raised { @chart.style = 2 }
     assert_equal(@chart.style, 2)
   end
+  
+  def test_vary_colors
+    assert_equal(true, @chart.vary_colors)
+    assert_raise(ArgumentError) { @chart.vary_colors = 7 }
+    assert_nothing_raised { @chart.vary_colors = false }
+    assert_equal(false, @chart.vary_colors)
+  end
+
+  def test_display_blanks_as
+    assert_equal(:gap, @chart.display_blanks_as, "default is not :gap")
+    assert_raise(ArgumentError, "did not validate possible values") { @chart.display_blanks_as = :hole }
+    assert_nothing_raised { @chart.display_blanks_as = :zero }
+    assert_nothing_raised { @chart.display_blanks_as = :span }
+    assert_equal(:span, @chart.display_blanks_as)
+  end
 
   def test_start_at
     @chart.start_at 15, 25
@@ -87,4 +102,9 @@ class TestChart < Test::Unit::TestCase
     assert(errors.empty?, "error free validation")
   end
 
+  def test_to_xml_string_for_display_blanks_as
+    @chart.display_blanks_as = :span
+    doc = Nokogiri::XML(@chart.to_xml_string)
+    assert_equal("span", doc.xpath("//c:dispBlanksAs").attr("val").value, "did not use the display_blanks_as configuration")
+  end
 end

data/test/drawing/tc_d_lbls.rb

@@ -4,19 +4,29 @@ class TestDLbls < Test::Unit::TestCase
 
   def setup
     @d_lbls = Axlsx::DLbls.new(Axlsx::Pie3DChart)
+    @boolean_attributes =[:show_legend_key, 
+                          :show_val, 
+                          :show_cat_name, 
+                          :show_ser_name, 
+                          :show_percent, 
+                          :show_bubble_size, 
+                          :show_leader_lines]
   end
 
   def test_initialization
     assert_equal(:bestFit, @d_lbls.d_lbl_pos)
-    Axlsx::DLbls::BOOLEAN_ATTRIBUTES.each do |attr|
+    @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] }] ]
+    
+    options_hash = Hash[*[@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|
+   
+    @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")
@@ -27,7 +37,7 @@ class TestDLbls < Test::Unit::TestCase
   end
 
   def test_boolean_attributes
-    Axlsx::DLbls::BOOLEAN_ATTRIBUTES.each do |attr|
+    @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) }

data/test/drawing/tc_drawing.rb

@@ -53,11 +53,6 @@ class TestDrawing < Test::Unit::TestCase
     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))

data/test/drawing/tc_graphic_frame.rb

@@ -17,9 +17,11 @@ class TestGraphicFrame < Test::Unit::TestCase
   end
 
   def test_rId
-    assert_equal(@frame.rId, "rId1")
-    chart = @ws.add_chart Axlsx::Chart
-    assert_equal(chart.graphic_frame.rId, "rId2")
+    assert_equal @ws.drawing.relationships.for(@chart).Id, @frame.rId
   end
 
+  def test_to_xml_has_correct_rId
+    doc = Nokogiri::XML(@frame.to_xml_string)
+    assert_equal @frame.rId, doc.xpath("//c:chart", doc.collect_namespaces).first["r:id"]
+  end
 end

data/test/drawing/tc_hyperlink.rb

@@ -51,10 +51,6 @@ class TestHyperlink < Test::Unit::TestCase
     assert_equal(@hyperlink.highlightClick, false )
   end
 
-  def test_id
-    assert_equal(@hyperlink.send(:id), 2)
-  end
-
   def test_history
     assert_nothing_raised { @hyperlink.history = false }
     assert_raise(ArgumentError) {@hyperlink.history = "bob"}

data/test/drawing/tc_line_chart.rb

@@ -0,0 +1,39 @@
+require 'tc_helper.rb'
+
+class TestLineChart < Test::Unit::TestCase
+
+  def setup
+    @p = Axlsx::Package.new
+    ws = @p.workbook.add_worksheet
+    @row = ws.add_row ["one", 1, Time.now]
+    @chart = ws.add_chart Axlsx::LineChart, :title => "fishery"
+  end
+
+  def teardown
+  end
+
+  def test_initialization
+    assert_equal(@chart.grouping, :standard, "grouping defualt incorrect")
+    assert_equal(@chart.series_type, Axlsx::LineSeries, "series type 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_grouping
+   assert_raise(ArgumentError, "require valid grouping") { @chart.grouping = :inverted }
+   assert_nothing_raised("allow valid grouping") { @chart.grouping = :stacked }
+   assert(@chart.grouping == :stacked)
+ 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
+    assert(errors.empty?, "error free validation")
+  end
+
+end

data/test/drawing/tc_line_series.rb

@@ -6,7 +6,7 @@ class TestLineSeries < Test::Unit::TestCase
     p = Axlsx::Package.new
     @ws = p.workbook.add_worksheet :name=>"hmmm"
     chart = @ws.add_chart Axlsx::Line3DChart, :title => "fishery"
-    @series = chart.add_series :data=>[0,1,2], :labels=>["zero", "one", "two"], :title=>"bob", :color => "#FF0000"
+    @series = chart.add_series :data=>[0,1,2], :labels=>["zero", "one", "two"], :title=>"bob", :color => "#FF0000", :show_marker => true
   end
 
   def test_initialize
@@ -15,10 +15,16 @@ class TestLineSeries < Test::Unit::TestCase
     assert_equal(@series.data.class, Axlsx::NumDataSource)
 
   end
-  
+
+  def test_show_marker
+    assert_equal(true, @series.show_marker)
+    @series.show_marker = false
+    assert_equal(false, @series.show_marker)
+  end  
   def test_to_xml_string
     doc = Nokogiri::XML(@series.to_xml_string)
     assert(doc.xpath("//srgbClr[@val='#{@series.color}']"))
+    assert(doc.xpath("//marker"))
   end
   #TODO serialization testing
 end

data/test/drawing/tc_pic.rb

@@ -6,6 +6,7 @@ class TestPic < Test::Unit::TestCase
     @p = Axlsx::Package.new
     ws = @p.workbook.add_worksheet
     @test_img =  File.dirname(__FILE__) + "/../../examples/image1.jpeg"
+    @test_img_up = File.dirname(__FILE__) + "/../../examples/IMAGE1UP.JPEG"
     @image = ws.add_image :image_src => @test_img, :hyperlink => 'https://github.com/randym', :tooltip => "What's up doc?"
   end
 
@@ -21,21 +22,21 @@ class TestPic < Test::Unit::TestCase
   def test_anchor_swapping
     #swap from one cell to two cell when end_at is specified
     assert(@image.anchor.is_a?(Axlsx::OneCellAnchor))
-    start_at = @image.anchor.from 
+    start_at = @image.anchor.from
     @image.end_at 10,5
     assert(@image.anchor.is_a?(Axlsx::TwoCellAnchor))
     assert_equal(start_at.col, @image.anchor.from.col)
     assert_equal(start_at.row, @image.anchor.from.row)
     assert_equal(10,@image.anchor.to.col)
     assert_equal(5, @image.anchor.to.row)
-  
+
     #swap from two cell to one cell when width or height are specified
     @image.width = 200
     assert(@image.anchor.is_a?(Axlsx::OneCellAnchor))
     assert_equal(start_at.col, @image.anchor.from.col)
     assert_equal(start_at.row, @image.anchor.from.row)
     assert_equal(200, @image.width)
-  
+
   end
   def test_hyperlink
     assert_equal(@image.hyperlink.href, "https://github.com/randym")
@@ -76,6 +77,10 @@ class TestPic < Test::Unit::TestCase
     assert_equal(@image.image_src, @test_img)
   end
 
+  def test_image_src_downcase
+    assert_nothing_raised { @image.image_src = @test_img_up }
+  end
+
   def test_descr
     assert_raise(ArgumentError) { @image.descr = 49 }
     assert_nothing_raised { @image.descr = "test" }
@@ -93,4 +98,10 @@ class TestPic < Test::Unit::TestCase
     assert(errors.empty?, "error free validation")
   end
 
+  def test_to_xml_has_correct_r_id
+    r_id = @image.anchor.drawing.relationships.for(@image).Id
+    doc = Nokogiri::XML(@image.anchor.drawing.to_xml_string)
+    assert_equal r_id, doc.xpath("//a:blip").first["r:embed"]
+  end
+
 end

data/test/drawing/tc_ser_axis.rb

@@ -2,29 +2,30 @@ require 'tc_helper.rb'
 
 class TestSerAxis < Test::Unit::TestCase
   def setup
-    @axis = Axlsx::SerAxis.new 12345, 54321
+    @axis = Axlsx::SerAxis.new
   end
+
   def teardown
   end
 
   def test_options
-    a = Axlsx::SerAxis.new 12345, 54321, :tickLblSkip => 9, :tickMarkSkip => 7
-    assert_equal(a.tickLblSkip, 9)
-    assert_equal(a.tickMarkSkip, 7)
+    a = Axlsx::SerAxis.new(:tick_lbl_skip => 9, :tick_mark_skip => 7)
+    assert_equal(a.tick_lbl_skip, 9)
+    assert_equal(a.tick_mark_skip, 7)
   end
 
 
-  def test_tickLblSkip
-    assert_raise(ArgumentError, "requires valid tickLblSkip") { @axis.tickLblSkip = -1 }
-    assert_nothing_raised("accepts valid tickLblSkip") { @axis.tickLblSkip = 1 }
-    assert_equal(@axis.tickLblSkip, 1)
+  def test_tick_lbl_skip
+    assert_raise(ArgumentError, "requires valid tick_lbl_skip") { @axis.tick_lbl_skip = -1 }
+    assert_nothing_raised("accepts valid tick_lbl_skip") { @axis.tick_lbl_skip = 1 }
+    assert_equal(@axis.tick_lbl_skip, 1)
   end
 
 
-  def test_tickMarkSkip
-    assert_raise(ArgumentError, "requires valid tickMarkSkip") { @axis.tickMarkSkip = :my_eyes }
-    assert_nothing_raised("accepts valid tickMarkSkip") { @axis.tickMarkSkip = 2 }
-    assert_equal(@axis.tickMarkSkip, 2)
+  def test_tick_mark_skip
+    assert_raise(ArgumentError, "requires valid tick_mark_skip") { @axis.tick_mark_skip = :my_eyes }
+    assert_nothing_raised("accepts valid tick_mark_skip") { @axis.tick_mark_skip = 2 }
+    assert_equal(@axis.tick_mark_skip, 2)
   end
 
 end

data/test/drawing/tc_two_cell_anchor.rb

@@ -10,9 +10,6 @@ class TestTwoCellAnchor < Test::Unit::TestCase
     @anchor = chart.graphic_frame.anchor
   end
 
-  def teardown
-  end
-
   def test_initialization
     assert(@anchor.from.col == 0)
     assert(@anchor.from.row == 0)
@@ -20,6 +17,9 @@ class TestTwoCellAnchor < Test::Unit::TestCase
     assert(@anchor.to.row == 10)
   end
 
+  def test_index
+    assert_equal(@anchor.index, @anchor.drawing.anchors.index(@anchor))
+  end
 
   def test_options
     assert_raise(ArgumentError, 'invalid start_at') { @ws.add_chart Axlsx::Chart, :start_at=>"1" }

data/test/drawing/tc_val_axis.rb

@@ -2,23 +2,23 @@ require 'tc_helper.rb'
 
 class TestValAxis < Test::Unit::TestCase
   def setup
-    @axis = Axlsx::ValAxis.new 12345, 54321
+    @axis = Axlsx::ValAxis.new
   end
   def teardown
   end
 
   def test_initialization
-    assert_equal(@axis.crossBetween, :between, "axis crossBetween default incorrect")
+    assert_equal(@axis.cross_between, :between, "axis crossBetween default incorrect")
   end
 
   def test_options
-    a = Axlsx::ValAxis.new 2345, 4321, :crossBetween => :midCat
-    assert_equal(a.crossBetween, :midCat)
+    a = Axlsx::ValAxis.new(:cross_between => :midCat)
+    assert_equal(:midCat, a.cross_between)
   end
 
   def test_crossBetween
-    assert_raise(ArgumentError, "requires valid crossBetween") { @axis.crossBetween = :my_eyes }
-    assert_nothing_raised("accepts valid crossBetween") { @axis.crossBetween = :midCat }
+    assert_raise(ArgumentError, "requires valid crossBetween") { @axis.cross_between = :my_eyes }
+    assert_nothing_raised("accepts valid crossBetween") { @axis.cross_between = :midCat }
   end
 
 end

data/test/drawing/tc_vml_shape.rb

@@ -6,8 +6,8 @@ class TestVmlShape < Test::Unit::TestCase
     p = Axlsx::Package.new
     wb = p.workbook
     @ws = wb.add_worksheet
-    @ws.add_comment :ref => 'A1', :text => 'penut machine', :author => 'crank'
-    @ws.add_comment :ref => 'C3', :text => 'rust bucket', :author => 'PO'
+    @ws.add_comment :ref => 'A1', :text => 'penut machine', :author => 'crank', :visible => true
+    @ws.add_comment :ref => 'C3', :text => 'rust bucket', :author => 'PO', :visible => false
     @comments = @ws.comments
   end
 
@@ -84,11 +84,17 @@ class TestVmlShape < Test::Unit::TestCase
     assert(shape.top_row == 3)
     assert_raise(ArgumentError) { shape.top_row = [] }
   end
-
+  def test_visible
+    shape = @comments.first.vml_shape
+    shape.visible = false
+    assert(shape.visible == false)
+    assert_raise(ArgumentError) { shape.visible = 'foo' }
+  end
   def test_to_xml_string
     str = @comments.vml_drawing.to_xml_string()
     doc = Nokogiri::XML(str)
     assert_equal(doc.xpath("//v:shape").size, 2)
+    assert_equal(1, doc.xpath("//x:Visible").size, 'ClientData/x:Visible element rendering')
     @comments.each do |comment|
       shape = comment.vml_shape
       assert(doc.xpath("//v:shape/x:ClientData/x:Row[text()='#{shape.row}']").size == 1)

data/test/profile.rb

@@ -1,34 +1,24 @@
 #!/usr/bin/env ruby -s
-# -*- coding: utf-8 -*-
-
-# Usage:
-# > ruby test/profile.rb
-# > pprof.rb --gif /tmp/axlsx_noautowidth > /tmp/axlsx_noautowidth.gif
-# > open /tmp/axlsx_noautowidth.gif
 
 $:.unshift "#{File.dirname(__FILE__)}/../lib"
 require 'axlsx'
-require 'csv'
-
-# require 'benchmark'
-require 'perftools'
+require 'ruby-prof'
+#RubyProf.measure_mode = RubyProf::MEMORY
+#
 row = []
+# Taking worst case scenario of all string data
 input = (32..126).to_a.pack('U*').chars.to_a
 20.times { row << input.shuffle.join}
-times = 3000
 
-PerfTools::CpuProfiler.start("/tmp/axlsx_noautowidth") do
+profile = RubyProf.profile do
   p = Axlsx::Package.new
-  p.use_autowidth = false
-  p.use_shared_strings = true
-  wb = p.workbook
-  
-  #A Simple Workbook
-  
-  wb.add_worksheet do |sheet|
-    times.times do
+  p.workbook.add_worksheet do |sheet|
+    10000.times do
       sheet << row
     end
   end
-  p.serialize("example.xlsx")
+  p.to_stream
 end
+
+printer = RubyProf::FlatPrinter.new(profile)
+printer.print(STDOUT, {})