axlsx 1.1.4 → 1.1.5

data/test/doc_props/tc_core.rb

@@ -4,6 +4,8 @@ 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')
     @doc = Nokogiri::XML(@core.to_xml_string)
   end
 
@@ -18,7 +20,7 @@ class TestCore < Test::Unit::TestCase
   end
 
   def test_populates_created
-    assert_equal(@doc.xpath('//dcterms:created').text, Time.now.strftime('%Y-%m-%dT%H:%M:%S'), "dcterms:created incorrect")
+    assert_equal(@doc.xpath('//dcterms:created').text, @time, "dcterms:created incorrect")
   end
 
   def test_populates_default_name

data/test/drawing/tc_hyperlink.rb

@@ -66,4 +66,8 @@ class TestHyperlink < Test::Unit::TestCase
     assert_equal(@hyperlink.history, false )
   end
 
+  def test_to_xml_string
+    doc = Nokogiri::XML(@p.workbook.worksheets.first.drawing.to_xml_string)
+    assert(doc.xpath("//a:hlinkClick"))
+  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.drawing.add_chart Axlsx::Line3DChart, :title => "fishery"
-    @series = chart.add_series :data=>[0,1,2], :labels=>["zero", "one", "two"], :title=>"bob"
+    @series = chart.add_series :data=>[0,1,2], :labels=>["zero", "one", "two"], :title=>"bob", :color => "#FF0000"
   end
 
   def test_initialize
@@ -15,6 +15,10 @@ class TestLineSeries < Test::Unit::TestCase
     assert_equal(@series.data.class, Axlsx::NumDataSource)
 
   end
-
+  
+  def test_to_xml_string
+    doc = Nokogiri::XML(@series.to_xml_string)
+    assert(doc.xpath("//srgbClr[@val='#{@series.color}']"))
+  end
   #TODO serialization testing
 end

data/test/drawing/tc_pie_series.rb

@@ -6,7 +6,7 @@ class TestPieSeries < Test::Unit::TestCase
     p = Axlsx::Package.new
     @ws = p.workbook.add_worksheet :name=>"hmmm"
     chart = @ws.drawing.add_chart Axlsx::Pie3DChart, :title => "fishery"
-    @series = chart.add_series :data=>[0,1,2], :labels=>["zero", "one", "two"], :title=>"bob"
+    @series = chart.add_series :data=>[0,1,2], :labels=>["zero", "one", "two"], :title=>"bob", :colors => ["FF0000", "00FF00", "0000FF"]
   end
 
   def test_initialize
@@ -22,6 +22,11 @@ class TestPieSeries < Test::Unit::TestCase
     assert(@series.explosion == 20)
   end
 
+  def test_to_xml_string
+    doc = Nokogiri::XML(@series.to_xml_string)
+    assert(doc.xpath("//srgbClr[@val='#{@series.colors[0]}']"))
+
+  end
   #TODO test unique serialization parts
 
 end

data/test/drawing/tc_vml_drawing.rb

@@ -0,0 +1,25 @@
+require 'tc_helper.rb'
+
+class TestVmlDrawing < Test::Unit::TestCase
+
+  def setup
+    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'
+    @vml_drawing = @ws.comments.vml_drawing
+  end
+
+  def test_initialize
+    assert_raise(ArgumentError) { Axlsx::VmlDrawing.new }
+  end
+
+  def test_to_xml_string
+    str = @vml_drawing.to_xml_string()
+    doc = Nokogiri::XML(str)
+    assert_equal(doc.xpath("//v:shape").size, 2)
+    assert(doc.xpath("//o:idmap[@o:data='#{@ws.index+1}']"))
+  end
+
+end

data/test/drawing/tc_vml_shape.rb

@@ -0,0 +1,100 @@
+require 'tc_helper.rb'
+
+class TestVmlShape < Test::Unit::TestCase
+
+  def setup
+    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'
+    @comments = @ws.comments
+  end
+
+  def test_initialize
+    assert_raise(ArgumentError) { Axlsx::VmlDrawing.new }
+  end
+
+  def test_row
+    shape = @comments.first.vml_shape
+    assert_equal(shape.row, 0)
+    shape = @comments.last.vml_shape
+    assert_equal(shape.row, 2)
+  end
+
+  def test_column
+    shape = @comments.first.vml_shape
+    assert_equal(shape.column, 0)
+    shape = @comments.last.vml_shape
+    assert_equal(shape.column, 2)
+  end
+
+  def test_left_column
+    shape = @comments.first.vml_shape
+    shape.left_column = 3
+    assert(shape.left_column == 3)
+    assert_raise(ArgumentError) { shape.left_column = [] }
+  end
+
+  def test_left_offset
+    shape = @comments.first.vml_shape
+    shape.left_offset = 3
+    assert(shape.left_offset == 3)
+    assert_raise(ArgumentError) { shape.left_offset = [] }
+  end
+
+  def test_right_column
+    shape = @comments.first.vml_shape
+    shape.right_column = 3
+    assert(shape.right_column == 3)
+    assert_raise(ArgumentError) { shape.right_column = [] }
+  end
+
+  def test_right_offset
+    shape = @comments.first.vml_shape
+    shape.right_offset = 3
+    assert(shape.right_offset == 3)
+    assert_raise(ArgumentError) { shape.right_offset = [] }
+  end
+
+  def test_top_offset
+    shape = @comments.first.vml_shape
+    shape.top_offset = 3
+    assert(shape.top_offset == 3)
+    assert_raise(ArgumentError) { shape.top_offset = [] }
+  end
+
+  def test_bottom_offset
+    shape = @comments.first.vml_shape
+    shape.bottom_offset = 3
+    assert(shape.bottom_offset == 3)
+    assert_raise(ArgumentError) { shape.bottom_offset = [] }
+  end
+
+  def test_bottom_row
+    shape = @comments.first.vml_shape
+    shape.bottom_row = 3
+    assert(shape.bottom_row == 3)
+    assert_raise(ArgumentError) { shape.bottom_row = [] }
+  end
+
+  def test_top_row
+    shape = @comments.first.vml_shape
+    shape.top_row = 3
+    assert(shape.top_row == 3)
+    assert_raise(ArgumentError) { shape.top_row = [] }
+  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)
+    @comments.each do |comment|
+      shape = comment.vml_shape
+      assert(doc.xpath("//v:shape/x:ClientData/x:Row[text()='#{shape.row}']").size == 1)
+      assert(doc.xpath("//v:shape/x:ClientData/x:Column[text()='#{shape.column}']").size == 1)
+      assert(doc.xpath("//v:shape/x:ClientData/x:Anchor[text()='#{shape.left_column}, #{shape.left_offset}, #{shape.top_row}, #{shape.top_offset}, #{shape.right_column}, #{shape.right_offset}, #{shape.bottom_row}, #{shape.bottom_offset}']").size == 1)
+    end
+  end
+
+end

data/test/rels/tc_relationship.rb

@@ -10,6 +10,7 @@ class TestRelationships < Test::Unit::TestCase
   def test_type
     assert_raise(ArgumentError) { Axlsx::Relationship.new 'type', 'target' }
     assert_nothing_raised { Axlsx::Relationship.new Axlsx::WORKSHEET_R, 'target' }
+    assert_nothing_raised { Axlsx::Relationship.new Axlsx::COMMENT_R, 'target' }
   end
 
   def test_target_mode

data/test/stylesheet/tc_gradient_fill.rb

@@ -61,4 +61,12 @@ class TestGradientFill < Test::Unit::TestCase
     assert(@item.stop.size == 1)
     assert(@item.stop.last.is_a?(Axlsx::GradientStop))
   end
+
+  def test_to_xml_string
+    @item.stop << Axlsx::GradientStop.new(Axlsx::Color.new(:rgb => "000000"), 0.5)
+    @item.stop << Axlsx::GradientStop.new(Axlsx::Color.new(:rgb => "FFFFFF"), 0.5)
+    @item.type = :path
+    doc = Nokogiri::XML(@item.to_xml_string)
+    assert(doc.xpath("//color[@rgb='FF000000']"))
+  end
 end

data/test/stylesheet/tc_pattern_fill.rb

@@ -33,5 +33,11 @@ class TestPatternFill < Test::Unit::TestCase
     assert_nothing_raised { @item.patternType = :lightUp }
     assert_equal(@item.patternType, :lightUp)
   end
-
+ 
+  def test_to_xml_string
+    @item = Axlsx::PatternFill.new :bgColor => Axlsx::Color.new(:rgb => "FF0000"), :fgColor => Axlsx::Color.new(:rgb=>"00FF00") 
+    doc = Nokogiri::XML(@item.to_xml_string)
+    assert(doc.xpath('//color[@rgb="FFFF0000"]'))
+    assert(doc.xpath('//color[@rgb="FF00FF00"]'))
+  end
 end

data/test/tc_helper.rb

@@ -1,3 +1,4 @@
 $LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
+require 'cover_me' unless RUBY_VERSION == '1.8.7'
 require 'test/unit'
 require "axlsx.rb"

data/test/tc_package.rb

@@ -4,10 +4,23 @@ class TestPackage < Test::Unit::TestCase
   def setup
     @package = Axlsx::Package.new
     ws = @package.workbook.add_worksheet
+    ws.add_row ['yes', 'we', 'can']
+    ws.add_comment :author => 'bob', :text => 'penny!', :ref => 'A1'
     chart = ws.add_chart Axlsx::Pie3DChart
     chart.add_series :data=>[1,2,3], :labels=>["a", "b", "c"]
     @fname = 'axlsx_test_serialization.xlsx'
+    img = File.expand_path('../../examples/image1.jpeg', __FILE__)
+    ws.add_image(:image_src => img, :noSelect => true, :noMove => true, :hyperlink=>"http://axlsx.blogspot.com") do |image|
+      image.width=720
+      image.height=666
+      image.hyperlink.tooltip = "Labeled Link"
+      image.start_at 2, 2
+    end
+  end
 
+  def test_use_autowidth
+    @package.use_autowidth = false
+    assert(@package.workbook.use_autowidth == false)
   end
 
   def test_core_accessor
@@ -55,10 +68,6 @@ class TestPackage < Test::Unit::TestCase
 
   def test_parts
     p = @package.send(:parts)
-    p.each do |part|
-      #all parts must have :doc, :entry, :schema
-      assert(part.keys.size == 3 && part.keys.reject{ |k| [:doc, :entry, :schema].include? k}.empty?)
-    end
     #all parts have an entry
     assert_equal(p.select{ |part| part[:entry] =~ /_rels\/\.rels/ }.size, 1, "rels missing")
     assert_equal(p.select{ |part| part[:entry] =~ /docProps\/core\.xml/ }.size, 1, "core missing")
@@ -72,9 +81,11 @@ class TestPackage < Test::Unit::TestCase
     assert_equal(p.select{ |part| part[:entry] =~ /xl\/charts\/chart\d\.xml/ }.size, @package.workbook.charts.size, "one or more charts missing")
     assert_equal(p.select{ |part| part[:entry] =~ /xl\/worksheets\/sheet\d\.xml/ }.size, @package.workbook.worksheets.size, "one or more sheet missing")
     assert_equal(p.select{ |part| part[:entry] =~ /xl\/worksheets\/_rels\/sheet\d\.xml\.rels/ }.size, @package.workbook.worksheets.size, "one or more sheet rels missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /xl\/comments\d\.xml/ }.size, @package.workbook.worksheets.size, "one or more sheet rels missing")
+
 
     #no mystery parts
-    assert_equal(p.size, 12)
+    assert_equal(p.size, 15)
 
   end
 

data/test/util/tc_validators.rb

@@ -70,6 +70,35 @@ class TestValidators < Test::Unit::TestCase
     assert_raise(ArgumentError) { Axlsx.validate_relationship_type "http://some.url" }
     assert_raise(ArgumentError) { Axlsx.validate_relationship_type false }
 
+    #number_with_unit
+    assert_nothing_raised { Axlsx.validate_number_with_unit "210mm" }
+    assert_nothing_raised { Axlsx.validate_number_with_unit "8.5in" }
+    assert_nothing_raised { Axlsx.validate_number_with_unit "29.7cm" }
+    assert_nothing_raised { Axlsx.validate_number_with_unit "120pt" }
+    assert_nothing_raised { Axlsx.validate_number_with_unit "0pc" }
+    assert_nothing_raised { Axlsx.validate_number_with_unit "12.34pi" }
+    assert_raise(ArgumentError) { Axlsx.validate_number_with_unit nil }
+    assert_raise(ArgumentError) { Axlsx.validate_number_with_unit "210" }
+    assert_raise(ArgumentError) { Axlsx.validate_number_with_unit 210 }
+    assert_raise(ArgumentError) { Axlsx.validate_number_with_unit "mm" }
+    assert_raise(ArgumentError) { Axlsx.validate_number_with_unit "-29cm" }
+
+    #page_scale
+    assert_nothing_raised { Axlsx.validate_page_scale 10 }
+    assert_nothing_raised { Axlsx.validate_page_scale 100 }
+    assert_nothing_raised { Axlsx.validate_page_scale 400 }
+    assert_raise(ArgumentError) { Axlsx.validate_page_scale 9 }
+    assert_raise(ArgumentError) { Axlsx.validate_page_scale 10.0 }
+    assert_raise(ArgumentError) { Axlsx.validate_page_scale 400.1 }
+    assert_raise(ArgumentError) { Axlsx.validate_page_scale "99" }
+
+    #page_orientation
+    assert_nothing_raised { Axlsx.validate_page_orientation :default }
+    assert_nothing_raised { Axlsx.validate_page_orientation :landscape }
+    assert_nothing_raised { Axlsx.validate_page_orientation :portrait }
+    assert_raise(ArgumentError) { Axlsx.validate_page_orientation nil }
+    assert_raise(ArgumentError) { Axlsx.validate_page_orientation 1 }
+    assert_raise(ArgumentError) { Axlsx.validate_page_orientation "landscape" }
   end
 end
 

data/test/workbook/worksheet/tc_cell.rb

@@ -244,6 +244,23 @@ class TestCell < Test::Unit::TestCase
     c_xml = Nokogiri::XML(@c.to_xml_string(1,1))
     assert_equal(c_xml.xpath("/c[@s=1]").size, 1)
   end
+
+  def test_to_xml_string_nil
+    @c.value = nil
+    c_xml = Nokogiri::XML(@c.to_xml_string(1,1))
+    assert_equal(c_xml.xpath("/c[@s=1]").size, 1)
+  end
+
+  def test_to_xml_string_formula
+    p = Axlsx::Package.new
+    ws = p.workbook.add_worksheet do |ws|
+      ws.add_row ["=IF(2+2=4,4,5)"]
+    end
+    doc = Nokogiri::XML(ws.to_xml_string)
+    assert("//f[text()=['IF(2+2=4,4,5)']")
+
+  end
+
   def test_to_xml
     # TODO This could use some much more stringent testing related to the xml content generated!
     row = @ws.add_row [Time.now, Date.today, true, 1, 1.0, "text", "=sum(A1:A2)"]

data/test/workbook/worksheet/tc_comment.rb

@@ -0,0 +1,56 @@
+require 'tc_helper.rb'
+
+class TestComment < Test::Unit::TestCase
+  def setup
+    p = Axlsx::Package.new
+    wb = p.workbook
+    @ws = wb.add_worksheet
+    @c1 = @ws.add_comment :ref => 'A1', :text => 'penut machine', :author => 'crank'
+    @c2 = @ws.add_comment :ref => 'C3', :text => 'rust bucket', :author => 'PO'
+  end
+
+  def test_initailize
+    assert_raise(ArgumentError) { Axlsx::Comment.new }
+  end
+
+  def test_author
+    assert(@c1.author == 'crank')
+    assert(@c2.author == 'PO')
+  end
+
+  def test_text
+    assert(@c1.text == 'penut machine')
+    assert(@c2.text == 'rust bucket')
+  end
+
+  def test_author_index
+    assert_equal(@c1.author_index, 1)
+    assert_equal(@c2.author_index, 0)
+  end
+
+  def test_ref
+    assert(@c1.ref == 'A1')
+    assert(@c2.ref == 'C3')
+  end
+
+  def test_vml_shape
+    assert(@c1.vml_shape.is_a?(Axlsx::VmlShape))
+    assert(@c1.vml_shape.column == Axlsx::name_to_indices(@c1.ref)[0])
+    assert(@c1.vml_shape.row == Axlsx::name_to_indices(@c1.ref)[1])
+    assert(@c1.vml_shape.row == Axlsx::name_to_indices(@c1.ref)[1])
+    assert(@c1.vml_shape.left_column == Axlsx::name_to_indices(@c1.ref)[1]+1)
+    assert(@c1.vml_shape.top_row == Axlsx::name_to_indices(@c1.ref)[1])
+    assert(@c1.vml_shape.right_column == Axlsx::name_to_indices(@c1.ref)[0]+4)
+    assert(@c1.vml_shape.bottom_row == Axlsx::name_to_indices(@c1.ref)[1]+4)
+  end
+
+  def to_xml_string
+    doc = Nokogiri::XML(@c1.to_xml_string)
+    assert_equal(doc.xpath("//comment[@ref='#{@c1.ref}']").size, 1)
+    assert_equal(doc.xpath("//comment[@authorId='#{@c1.author_index.to}']").size, 1)
+    assert_equal(doc.xpath("//t[text()='#{@c1.author}']").size, 1)
+    assert_equal(doc.xpath("//t[text()='#{@c1.text}']").size, 1)
+  end
+
+end
+

data/test/workbook/worksheet/tc_comments.rb

@@ -0,0 +1,50 @@
+require 'tc_helper.rb'
+
+class TestComments < Test::Unit::TestCase
+  def setup
+    p = Axlsx::Package.new
+    wb = p.workbook
+    @ws = wb.add_worksheet
+    @c1 = @ws.add_comment :ref => 'A1', :text => 'penut machine', :author => 'crank'
+    @c2 = @ws.add_comment :ref => 'C3', :text => 'rust bucket', :author => 'PO'
+  end
+
+  def test_initialize
+    assert_raise(ArgumentError) { Axlsx::Comments.new }
+    assert(@ws.comments.vml_drawing.is_a?(Axlsx::VmlDrawing))
+  end
+
+  def test_add_comment
+    assert_equal(@ws.comments.size, 2)
+    assert_raise(ArgumentError) { @ws.comments.add_comment() }
+    assert_raise(ArgumentError) { @ws.comments.add_comment(:text => 'Yes We Can', :ref => 'A1') }
+    assert_raise(ArgumentError) { @ws.comments.add_comment(:author => 'bob', :ref => 'A1') }
+    assert_raise(ArgumentError) { @ws.comments.add_comment(:author => 'bob', :text => 'Yes We Can')}
+    assert_nothing_raised { @ws.comments.add_comment(:author => 'bob', :text => 'Yes We Can', :ref => 'A1') }
+    assert_equal(@ws.comments.size, 3)
+  end
+  def test_authors
+    assert_equal(@ws.comments.authors.size, @ws.comments.size)
+    @ws.add_comment(:text => 'Yes We Can!', :author => :bob, :ref => 'F1')
+    assert_equal(@ws.comments.authors.size, 3)
+    @ws.add_comment(:text => 'Yes We Can!', :author => :bob, :ref => 'F1')
+    assert_equal(@ws.comments.authors.size, 3, 'only unique authors are returned') 
+  end
+  def test_pn
+    assert_equal(@ws.comments.pn, Axlsx::COMMENT_PN % (@ws.index+1).to_s)
+  end
+
+  def test_index
+    assert_equal(@ws.index, @ws.comments.index)
+  end
+  def test_to_xml_string
+    doc = Nokogiri::XML(@ws.comments.to_xml_string)
+    # puts doc.xpath("comments").to_xml
+    # TODO figure out why these xpath expressions dont work!
+    # assert(doc.xpath("//comments"))
+    # assert_equal(doc.xpath("//xmlns:author").size, @ws.comments.authors.size)
+    # assert_equal(doc.xpath("//comment").size, @ws.comments.size)
+  end
+end
+
+