axlsx-alt 3.0.0

data/test/profile.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby -s
+
+$:.unshift "#{File.dirname(__FILE__)}/../lib"
+require 'axlsx'
+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}
+
+profile = RubyProf.profile do
+  p = Axlsx::Package.new
+  p.workbook.add_worksheet do |sheet|
+    10000.times do
+      sheet << row
+    end
+  end
+  p.to_stream
+end
+
+printer = RubyProf::FlatPrinter.new(profile)
+printer.print(STDOUT, {})

data/test/rels/tc_relationship.rb

@@ -0,0 +1,44 @@
+require 'tc_helper.rb'
+
+class TestRelationships < Test::Unit::TestCase
+  
+  def test_instances_with_different_attributes_have_unique_ids
+    rel_1 = Axlsx::Relationship.new(Object.new, Axlsx::WORKSHEET_R, 'target')
+    rel_2 = Axlsx::Relationship.new(Object.new, Axlsx::COMMENT_R, 'foobar')
+    assert_not_equal rel_1.Id, rel_2.Id
+  end
+  
+  def test_instances_with_same_attributes_share_id
+    source_obj = Object.new
+    instance = Axlsx::Relationship.new(source_obj, Axlsx::WORKSHEET_R, 'target')
+    assert_equal instance.Id, Axlsx::Relationship.new(source_obj, Axlsx::WORKSHEET_R, 'target').Id
+  end
+  
+  def test_target_is_only_considered_for_same_attributes_check_if_target_mode_is_external
+    source_obj = Object.new
+    rel_1 = Axlsx::Relationship.new(source_obj, Axlsx::WORKSHEET_R, 'target')
+    rel_2 = Axlsx::Relationship.new(source_obj, Axlsx::WORKSHEET_R, '../target')
+    assert_equal rel_1.Id, rel_2.Id
+    
+    rel_3 = Axlsx::Relationship.new(source_obj, Axlsx::HYPERLINK_R, 'target', :target_mode => :External)
+    rel_4 = Axlsx::Relationship.new(source_obj, Axlsx::HYPERLINK_R, '../target', :target_mode => :External)
+    assert_not_equal rel_3.Id, rel_4.Id
+  end
+  
+  def test_type
+    assert_raise(ArgumentError) { Axlsx::Relationship.new nil, 'type', 'target' }
+    assert_nothing_raised { Axlsx::Relationship.new nil, Axlsx::WORKSHEET_R, 'target' }
+    assert_nothing_raised { Axlsx::Relationship.new nil, Axlsx::COMMENT_R, 'target' }
+  end
+
+  def test_target_mode
+    assert_raise(ArgumentError) { Axlsx::Relationship.new nil, 'type', 'target', :target_mode => "FISH" }
+    assert_nothing_raised { Axlsx::Relationship.new( nil, Axlsx::WORKSHEET_R, 'target', :target_mode => :External) }
+  end
+
+  def test_ampersand_escaping_in_target
+    r = Axlsx::Relationship.new(nil, Axlsx::HYPERLINK_R, "http://example.com?foo=1&bar=2", :target_mod => :External)
+    doc = Nokogiri::XML(r.to_xml_string)
+    assert_equal(doc.xpath("//Relationship[@Target='http://example.com?foo=1&bar=2']").size, 1)
+  end
+end

data/test/rels/tc_relationships.rb

@@ -0,0 +1,37 @@
+require 'tc_helper.rb'
+
+class TestRelationships < Test::Unit::TestCase
+
+  def test_for
+    source_obj_1, source_obj_2 = Object.new, Object.new
+    rel_1 = Axlsx::Relationship.new(source_obj_1, Axlsx::WORKSHEET_R, "bar")
+    rel_2 = Axlsx::Relationship.new(source_obj_2, Axlsx::WORKSHEET_R, "bar")
+    rels = Axlsx::Relationships.new
+    rels << rel_1 
+    rels << rel_2
+    assert_equal rel_1, rels.for(source_obj_1)
+    assert_equal rel_2, rels.for(source_obj_2)
+  end
+  
+  def test_valid_document
+    @rels = Axlsx::Relationships.new
+    schema = Nokogiri::XML::Schema(File.open(Axlsx::RELS_XSD))
+    doc = Nokogiri::XML(@rels.to_xml_string)
+    errors = []
+    schema.validate(doc).each do |error|
+      puts error.message
+      errors << error
+    end
+
+    @rels << Axlsx::Relationship.new(nil, Axlsx::WORKSHEET_R, "bar")
+    doc = Nokogiri::XML(@rels.to_xml_string)
+    errors = []
+    schema.validate(doc).each do |error|
+      puts error.message
+      errors << error
+    end
+
+    assert(errors.size == 0)
+  end
+
+end

data/test/stylesheet/tc_border.rb

@@ -0,0 +1,37 @@
+require 'tc_helper.rb'
+
+class TestBorder < Test::Unit::TestCase
+  def setup
+    @b = Axlsx::Border.new
+  end
+  def teardown
+  end
+  def test_initialiation
+    assert_equal(@b.diagonalUp, nil)
+    assert_equal(@b.diagonalDown, nil)
+    assert_equal(@b.outline, nil)
+    assert(@b.prs.is_a?(Axlsx::SimpleTypedList))
+  end
+
+  def test_diagonalUp
+    assert_raise(ArgumentError) { @b.diagonalUp = :red }
+    assert_nothing_raised { @b.diagonalUp = true }
+    assert_equal(@b.diagonalUp, true )
+  end
+
+  def test_diagonalDown
+    assert_raise(ArgumentError) { @b.diagonalDown = :red }
+    assert_nothing_raised { @b.diagonalDown = true }
+    assert_equal(@b.diagonalDown, true )
+  end
+
+  def test_outline
+    assert_raise(ArgumentError) { @b.outline = :red }
+    assert_nothing_raised { @b.outline = true }
+    assert_equal(@b.outline, true )
+  end
+
+  def test_prs
+    assert_nothing_raised { @b.prs << Axlsx::BorderPr.new(:name=>:top, :style=>:thin, :color => Axlsx::Color.new(:rgb=>"FF0000FF")) }
+  end
+end

data/test/stylesheet/tc_border_pr.rb

@@ -0,0 +1,32 @@
+require 'tc_helper.rb'
+
+class TestBorderPr < Test::Unit::TestCase
+  def setup
+    @bpr = Axlsx::BorderPr.new
+  end
+  def teardown
+  end
+  def test_initialiation
+    assert_equal(@bpr.color, nil)
+    assert_equal(@bpr.style, nil)
+    assert_equal(@bpr.name, nil)
+  end
+
+  def test_color
+    assert_raise(ArgumentError) { @bpr.color = :red }
+    assert_nothing_raised { @bpr.color = Axlsx::Color.new :rgb=>"FF000000" }
+    assert(@bpr.color.is_a?(Axlsx::Color))
+  end
+
+  def test_style
+    assert_raise(ArgumentError) { @bpr.style = :red }
+    assert_nothing_raised { @bpr.style = :thin }
+    assert_equal(@bpr.style, :thin)
+  end
+
+  def test_name
+    assert_raise(ArgumentError) { @bpr.name = :red }
+    assert_nothing_raised { @bpr.name = :top }
+    assert_equal(@bpr.name, :top)
+  end
+end

data/test/stylesheet/tc_cell_alignment.rb

@@ -0,0 +1,81 @@
+require 'tc_helper.rb'
+
+class TestCellAlignment < Test::Unit::TestCase
+  def setup
+    @item = Axlsx::CellAlignment.new
+  end
+
+  def test_initialiation
+    assert_equal(@item.horizontal, nil)
+    assert_equal(@item.vertical, nil)
+    assert_equal(@item.textRotation, nil)
+    assert_equal(@item.wrapText, nil)
+    assert_equal(@item.indent, nil)
+    assert_equal(@item.relativeIndent, nil)
+    assert_equal(@item.justifyLastLine, nil)
+    assert_equal(@item.shrinkToFit, nil)
+    assert_equal(@item.readingOrder, nil)
+    options =  { :horizontal => :left, :vertical => :top, :textRotation => 3,
+                 :wrapText => true, :indent => 2, :relativeIndent => 5,
+      :justifyLastLine => true, :shrinkToFit => true, :readingOrder => 2 }
+    ca = Axlsx::CellAlignment.new options
+    options.each do |key, value|
+      assert_equal(ca.send(key.to_sym),value)
+    end
+  end
+
+  def test_horizontal
+    assert_raise(ArgumentError) { @item.horizontal = :red }
+    assert_nothing_raised { @item.horizontal = :left }
+    assert_equal(@item.horizontal, :left )
+  end
+
+  def test_vertical
+    assert_raise(ArgumentError) { @item.vertical = :red }
+    assert_nothing_raised { @item.vertical = :top }
+    assert_equal(@item.vertical, :top )
+  end
+
+  def test_textRotation
+    assert_raise(ArgumentError) { @item.textRotation = -1 }
+    assert_nothing_raised { @item.textRotation = 5 }
+    assert_equal(@item.textRotation, 5 )
+  end
+
+  def test_wrapText
+    assert_raise(ArgumentError) { @item.wrapText = -1 }
+    assert_nothing_raised { @item.wrapText = false }
+    assert_equal(@item.wrapText, false )
+  end
+
+  def test_indent
+    assert_raise(ArgumentError) { @item.indent = -1 }
+    assert_nothing_raised { @item.indent = 5 }
+    assert_equal(@item.indent, 5 )
+  end
+
+  def test_relativeIndent
+    assert_raise(ArgumentError) { @item.relativeIndent = :symbol }
+    assert_nothing_raised { @item.relativeIndent = 5 }
+    assert_equal(@item.relativeIndent, 5 )
+  end
+
+  def test_justifyLastLine
+    assert_raise(ArgumentError) { @item.justifyLastLine = -1 }
+    assert_nothing_raised { @item.justifyLastLine = true }
+    assert_equal(@item.justifyLastLine, true )
+  end
+
+  def test_shrinkToFit
+    assert_raise(ArgumentError) { @item.shrinkToFit = -1 }
+    assert_nothing_raised { @item.shrinkToFit = true }
+    assert_equal(@item.shrinkToFit, true )
+  end
+
+  def test_readingOrder
+    assert_raise(ArgumentError) { @item.readingOrder = -1 }
+    assert_nothing_raised { @item.readingOrder = 2 }
+    assert_equal(@item.readingOrder, 2 )
+  end
+
+end

data/test/stylesheet/tc_cell_protection.rb

@@ -0,0 +1,29 @@
+require 'tc_helper.rb'
+
+class TestCellProtection < Test::Unit::TestCase
+
+  def setup
+    @item = Axlsx::CellProtection.new
+  end
+
+  def teardown
+  end
+
+  def test_initialiation
+    assert_equal(@item.hidden, nil)
+    assert_equal(@item.locked, nil)
+  end
+
+  def test_hidden
+    assert_raise(ArgumentError) { @item.hidden = -1 }
+    assert_nothing_raised { @item.hidden = false }
+    assert_equal(@item.hidden, false )
+  end
+
+  def test_locked
+    assert_raise(ArgumentError) { @item.locked = -1 }
+    assert_nothing_raised { @item.locked = false }
+    assert_equal(@item.locked, false )
+  end
+
+end

data/test/stylesheet/tc_cell_style.rb

@@ -0,0 +1,57 @@
+require 'tc_helper.rb'
+
+class TestCellStyle < Test::Unit::TestCase
+
+  def setup
+    @item = Axlsx::CellStyle.new
+  end
+
+  def teardown
+  end
+
+  def test_initialiation
+    assert_equal(@item.name, nil)
+    assert_equal(@item.xfId, nil)
+    assert_equal(@item.builtinId, nil)
+    assert_equal(@item.iLevel, nil)
+    assert_equal(@item.hidden, nil)
+    assert_equal(@item.customBuiltin, nil)
+  end
+
+  def test_name
+    assert_raise(ArgumentError) { @item.name = -1 }
+    assert_nothing_raised { @item.name = "stylin" }
+    assert_equal(@item.name, "stylin" )
+  end
+
+  def test_xfId
+    assert_raise(ArgumentError) { @item.xfId = -1 }
+    assert_nothing_raised { @item.xfId = 5 }
+    assert_equal(@item.xfId, 5 )
+  end
+
+  def test_builtinId
+    assert_raise(ArgumentError) { @item.builtinId = -1 }
+    assert_nothing_raised { @item.builtinId = 5 }
+    assert_equal(@item.builtinId, 5 )
+  end
+
+  def test_iLevel
+    assert_raise(ArgumentError) { @item.iLevel = -1 }
+    assert_nothing_raised { @item.iLevel = 5 }
+    assert_equal(@item.iLevel, 5 )
+  end
+
+  def test_hidden
+    assert_raise(ArgumentError) { @item.hidden = -1 }
+    assert_nothing_raised { @item.hidden = true }
+    assert_equal(@item.hidden, true )
+  end
+
+  def test_customBuiltin
+    assert_raise(ArgumentError) { @item.customBuiltin = -1 }
+    assert_nothing_raised { @item.customBuiltin = true }
+    assert_equal(@item.customBuiltin, true )
+  end
+
+end

data/test/stylesheet/tc_color.rb

@@ -0,0 +1,43 @@
+require 'tc_helper.rb'
+
+class TestColor < Test::Unit::TestCase
+
+  def setup
+    @item = Axlsx::Color.new
+  end
+
+  def teardown
+  end
+
+  def test_initialiation
+    assert_equal(@item.auto, nil)
+    assert_equal(@item.rgb, "FF000000")
+    assert_equal(@item.tint, nil)
+  end
+
+  def test_auto
+    assert_raise(ArgumentError) { @item.auto = -1 }
+    assert_nothing_raised { @item.auto = true }
+    assert_equal(@item.auto, true )
+  end
+
+  def test_rgb
+    assert_raise(ArgumentError) { @item.rgb = -1 }
+    assert_nothing_raised { @item.rgb = "FF00FF00" }
+    assert_equal(@item.rgb, "FF00FF00" )
+  end
+
+  def test_rgb_writer_doesnt_mutate_its_argument
+    my_rgb = 'ff00ff00'
+    @item.rgb = my_rgb
+    assert_equal 'ff00ff00', my_rgb
+  end
+
+  def test_tint
+    assert_raise(ArgumentError) { @item.tint = -1 }
+    assert_nothing_raised { @item.tint = -1.0 }
+    assert_equal(@item.tint, -1.0 )
+  end
+
+
+end

data/test/stylesheet/tc_dxf.rb

@@ -0,0 +1,81 @@
+require 'tc_helper.rb'
+
+class TestDxf < Test::Unit::TestCase
+
+  def setup
+    @item = Axlsx::Dxf.new
+    @styles = Axlsx::Styles.new    
+  end
+
+  def teardown
+  end
+
+  def test_initialiation
+    assert_equal(@item.alignment, nil)
+    assert_equal(@item.protection, nil)
+    assert_equal(@item.numFmt, nil)
+    assert_equal(@item.font, nil)
+    assert_equal(@item.fill, nil)
+    assert_equal(@item.border, nil)
+  end
+
+  def test_alignment
+    assert_raise(ArgumentError) { @item.alignment = -1.1 }
+    assert_nothing_raised { @item.alignment = Axlsx::CellAlignment.new }
+    assert(@item.alignment.is_a?(Axlsx::CellAlignment))
+  end
+
+  def test_protection
+    assert_raise(ArgumentError) { @item.protection = -1.1 }
+    assert_nothing_raised { @item.protection = Axlsx::CellProtection.new }
+    assert(@item.protection.is_a?(Axlsx::CellProtection))
+  end
+
+  def test_numFmt
+    assert_raise(ArgumentError) { @item.numFmt = 1 }
+    assert_nothing_raised { @item.numFmt = Axlsx::NumFmt.new }
+    assert @item.numFmt.is_a? Axlsx::NumFmt
+  end
+
+  def test_fill
+    assert_raise(ArgumentError) { @item.fill =  1 }
+    assert_nothing_raised { @item.fill = Axlsx::Fill.new(Axlsx::PatternFill.new(:patternType =>:solid, :fgColor=> Axlsx::Color.new(:rgb => "FF000000"))) }
+    assert @item.fill.is_a? Axlsx::Fill
+  end
+
+  def test_font
+    assert_raise(ArgumentError) { @item.font = 1 }
+    assert_nothing_raised { @item.font = Axlsx::Font.new }
+    assert @item.font.is_a? Axlsx::Font 
+  end
+
+  def test_border
+    assert_raise(ArgumentError) { @item.border = 1 }
+    assert_nothing_raised { @item.border = Axlsx::Border.new }
+    assert @item.border.is_a? Axlsx::Border
+  end
+
+  def test_to_xml
+    @item.border = Axlsx::Border.new
+    doc = Nokogiri::XML.parse(@item.to_xml_string)
+    assert_equal(1, doc.xpath(".//dxf//border").size)
+    assert_equal(0, doc.xpath(".//dxf//font").size)    
+  end
+
+  def test_many_options_xml
+    @item.border = Axlsx::Border.new
+    @item.alignment = Axlsx::CellAlignment.new
+    @item.fill = Axlsx::Fill.new(Axlsx::PatternFill.new(:patternType =>:solid, :fgColor=> Axlsx::Color.new(:rgb => "FF000000")))
+    @item.font = Axlsx::Font.new
+    @item.protection = Axlsx::CellProtection.new
+    @item.numFmt = Axlsx::NumFmt.new
+    
+    doc = Nokogiri::XML.parse(@item.to_xml_string)
+    assert_equal(1, doc.xpath(".//dxf//fill//patternFill[@patternType='solid']//fgColor[@rgb='FF000000']").size)
+    assert_equal(1, doc.xpath(".//dxf//font").size)
+    assert_equal(1, doc.xpath(".//dxf//protection").size)
+    assert_equal(1, doc.xpath(".//dxf//numFmt[@numFmtId='0'][@formatCode='']").size)
+    assert_equal(1, doc.xpath(".//dxf//alignment").size)
+    assert_equal(1, doc.xpath(".//dxf//border").size)    
+  end
+end