axlsx 1.0.0

data/test/tc_worksheet.rb~

@@ -0,0 +1,85 @@
+require 'test/unit'
+require 'axlsx.rb'
+
+class TestWorksheet < Test::Unit::TestCase
+  def setup    
+    p = Axlsx::Package.new
+    @ws = p.workbook.add_worksheet
+  end
+
+  def test_pn
+    assert_equal(@ws.pn, "worksheets/sheet1.xml")
+    ws = @ws.workbook.add_worksheet
+    assert_equal(ws.pn, "worksheets/sheet2.xml")
+  end
+
+  def test_rels_pn
+    assert_equal(@ws.rels_pn, "worksheets/_rels/sheet1.xml.rels")
+    ws = @ws.workbook.add_worksheet
+    assert_equal(ws.rels_pn, "worksheets/_rels/sheet2.xml.rels")
+  end
+
+  def test_rId
+    assert_equal(@ws.rId, "rId1")
+    ws = @ws.workbook.add_worksheet
+    assert_equal(ws.rId, "rId2")
+  end
+  
+  def test_index
+    assert_equal(@ws.index, @ws.workbook.worksheets.index(@ws))
+  end
+
+  def test_add_row
+    assert(@ws.rows.empty?, "sheet has no rows by default")
+    r = @ws.add_row([1,2,3])
+    assert_equal(@ws.rows.size, 1, "add_row adds a row")
+    assert_equal(@ws.rows.first, r, "the row returned is the row added")
+  end
+
+  def test_add_chart
+    assert(@ws.workbook.charts.empty?, "the sheet's workbook should not have any charts by default")
+    @ws.add_chart Axlsx::Pie3DChart
+    assert_equal(@ws.workbook.charts.size, 1, "add_chart adds a chart to the workbook")
+  end
+
+  def test_drawing
+    assert @ws.drawing.is_a? Axlsx::Drawing
+  end
+
+  
+  def test_to_xml
+    schema = Nokogiri::XML::Schema(File.open(Axlsx::SML_XSD))
+    doc = Nokogiri::XML(@ws.to_xml)
+    errors = []
+    schema.validate(doc).each do |error|
+      errors.push error
+      puts error.message
+    end
+    assert(errors.empty?, "error free validation")
+  end
+
+  def test_relationships
+    assert(@ws.relationships.empty?, "No Drawing relationship until you add a chart")
+    c = @ws.add_chart Axlsx::Pie3DChart
+    assert_equal(@ws.relationships.size, 1, "adding a chart creates the relationship")
+    c = @ws.add_chart Axlsx::Pie3DChart
+    assert_equal(@ws.relationships.size, 1, "multiple charts still only result in one relationship")
+  end
+
+  
+  def test_update_auto_with_data
+    small = @ws.workbook.styles.add_style(:sz=>2)
+    big = @ws.workbook.styles.add_style(:sz=>10)
+    @ws.add_row ["chasing windmills", "penut"], :style=>small
+    assert(@ws.auto_fit_data.size == 2, "a data item for each column")
+    assert_equal(@ws.auto_fit_data[0], {:sz=>2,:longest=>"chasing windmills"}, "adding a row updates auto_fit_data if the product of the string length and font is greater for the column")
+    @ws.add_row ["mule"], :style=>big
+    assert_equal(@ws.auto_fit_data[0], {:sz=>10,:longest=>"mule"}, "adding a row updates auto_fit_data if the product of the string length and font is greater for the column")
+  end
+
+  def test_auto_width
+    assert(@ws.send(:auto_width, {:sz=>11, :longest=>"fisheries"}) > @ws.send(:auto_width, {:sz=>11, :longest=>"fish"}), "longer strings get a longer auto_width at the same font size")
+    assert(@ws.send(:auto_width, {:sz=>12, :longest=>"fish"}) > @ws.send(:auto_width, {:sz=>11, :longest=>"fish"}), "larger font size gets a longer auto_width using the same text")
+  end
+
+end

data/test/util/tc_simple_typed_list.rb

@@ -0,0 +1,66 @@
+require 'test/unit'
+require 'axlsx.rb'
+class TestSimpleTypedList < Test::Unit::TestCase
+  def setup 
+    @list = Axlsx::SimpleTypedList.new Fixnum
+  end
+
+  def teardown 
+  end
+
+  def test_type_is_a_class_or_array_of_class
+    assert_nothing_raised { Axlsx::SimpleTypedList.new Integer }
+    assert_nothing_raised { Axlsx::SimpleTypedList.new [Integer,String] }
+    assert_raise(ArgumentError) { Axlsx::SimpleTypedList.new }
+    assert_raise(ArgumentError) { Axlsx::SimpleTypedList.new "1" }
+    assert_raise(ArgumentError) { Axlsx::SimpleTypedList.new [Integer, "Class"] }
+  end
+  
+  def test_indexed_based_assignment
+    #should not allow nil assignment
+    assert_raise(ArgumentError) { @list[0] = nil }
+    assert_raise(ArgumentError) { @list[0] = "1" }
+    assert_nothing_raised { @list[0] = 1 }
+  end
+  
+  def test_concat_assignment
+    assert_raise(ArgumentError) { @list << nil }
+    assert_raise(ArgumentError) { @list << "1" }
+    assert_nothing_raised { @list << 1 }   
+  end
+
+  def test_concat_should_return_index
+    assert( @list.size == 0 )
+    assert( @list << 1 == 0 )
+    assert( @list << 2 == 1 )
+    @list.delete_at 0
+    assert( @list << 3 == 1 )
+    assert( @list.index(2) == 0 )
+  end
+
+  def test_push_should_return_index
+    assert( @list.push(1) == 0 )
+    assert( @list.push(2) == 1 )
+    @list.delete_at 0
+    assert( @list.push(3) == 1 )
+    assert( @list.index(2) == 0 )
+  end
+
+  def test_locking
+    @list.push 1
+    @list.push 2
+    @list.push 3
+    @list.lock
+
+    assert_raise(ArgumentError) { @list.delete 1  }
+    assert_raise(ArgumentError) { @list.delete_at 1 }
+    assert_raise(ArgumentError) { @list.delete_at 2 }
+    @list.push 4
+    assert_nothing_raised { @list.delete_at 3 }
+    @list.unlock
+    #ignore garbage
+    assert_nothing_raised { @list.delete 0 }   
+    assert_nothing_raised { @list.delete 9 }       
+  end
+
+end

data/test/util/tc_validators.rb

@@ -0,0 +1,76 @@
+require 'test/unit'
+require 'axlsx.rb'
+class TestValidators < Test::Unit::TestCase
+  def setup    
+  end
+  def teardown
+  end
+  
+  def test_validators
+    #unsigned_int
+    assert_nothing_raised { Axlsx.validate_unsigned_int 1 }
+    assert_nothing_raised { Axlsx.validate_unsigned_int +1 }
+    assert_raise(ArgumentError) { Axlsx.validate_unsigned_int -1 }
+    assert_raise(ArgumentError) { Axlsx.validate_unsigned_int '1' }
+    
+    #int
+    assert_nothing_raised { Axlsx.validate_int 1 }
+    assert_nothing_raised { Axlsx.validate_int -1 }
+    assert_raise(ArgumentError) { Axlsx.validate_int 'a' }
+    assert_raise(ArgumentError) { Axlsx.validate_int Array }
+ 
+    #boolean (as 0 or 1, :true, :false, true, false, or "true," "false")
+    [0,1,:true, :false, true, false, "true", "false"].each do |v|
+      assert_nothing_raised { Axlsx.validate_boolean 0 }
+    end
+    assert_raise(ArgumentError) { Axlsx.validate_boolean 2 }
+    
+    #string
+    assert_nothing_raised { Axlsx.validate_string "1" }
+    assert_raise(ArgumentError) { Axlsx.validate_string 2 }
+    assert_raise(ArgumentError) { Axlsx.validate_string false }
+
+    #float
+    assert_nothing_raised { Axlsx.validate_float 1.0 }
+    assert_raise(ArgumentError) { Axlsx.validate_float 2 }
+    assert_raise(ArgumentError) { Axlsx.validate_float false }
+
+    #pattern_type
+    assert_nothing_raised { Axlsx.validate_pattern_type :none }
+    assert_raise(ArgumentError) { Axlsx.validate_pattern_type "none" }
+    assert_raise(ArgumentError) { Axlsx.validate_pattern_type "crazy_pattern" }
+    assert_raise(ArgumentError) { Axlsx.validate_pattern_type false }
+
+    #gradient_type
+    assert_nothing_raised { Axlsx.validate_gradient_type :path }
+    assert_raise(ArgumentError) { Axlsx.validate_gradient_type nil }
+    assert_raise(ArgumentError) { Axlsx.validate_gradient_type "fractal" }
+    assert_raise(ArgumentError) { Axlsx.validate_gradient_type false }
+
+    #horizontal alignment
+    assert_nothing_raised { Axlsx.validate_horizontal_alignment :general }
+    assert_raise(ArgumentError) { Axlsx.validate_horizontal_alignment nil }
+    assert_raise(ArgumentError) { Axlsx.validate_horizontal_alignment "wavy" }
+    assert_raise(ArgumentError) { Axlsx.validate_horizontal_alignment false }
+
+    #vertical alignment
+    assert_nothing_raised { Axlsx.validate_vertical_alignment :top }
+    assert_raise(ArgumentError) { Axlsx.validate_vertical_alignment nil }
+    assert_raise(ArgumentError) { Axlsx.validate_vertical_alignment "dynamic" }
+    assert_raise(ArgumentError) { Axlsx.validate_vertical_alignment false }
+
+    #contentType
+    assert_nothing_raised { Axlsx.validate_content_type Axlsx::WORKBOOK_CT }
+    assert_raise(ArgumentError) { Axlsx.validate_content_type nil }
+    assert_raise(ArgumentError) { Axlsx.validate_content_type "http://some.url" }
+    assert_raise(ArgumentError) { Axlsx.validate_content_type false }
+ 
+    #relationshipType
+    assert_nothing_raised { Axlsx.validate_relationship_type Axlsx::WORKBOOK_R }
+    assert_raise(ArgumentError) { Axlsx.validate_relationship_type nil }
+    assert_raise(ArgumentError) { Axlsx.validate_relationship_type "http://some.url" }
+    assert_raise(ArgumentError) { Axlsx.validate_relationship_type false }
+
+  end
+end
+

data/test/workbook/tc_workbook.rb

@@ -0,0 +1,53 @@
+require 'test/unit'
+require 'axlsx.rb'
+
+class TestWorkbook < Test::Unit::TestCase
+  def setup    
+    p = Axlsx::Package.new
+    @wb = p.workbook    
+  end
+
+  def teardown
+  end
+
+  def test_date1904
+    assert_equal(Axlsx::Workbook.date1904, @wb.date1904)
+    @wb.date1904 = :false
+    assert_equal(Axlsx::Workbook.date1904, @wb.date1904)
+    Axlsx::Workbook.date1904 = :true
+    assert_equal(Axlsx::Workbook.date1904, @wb.date1904)
+  end
+
+  def test_add_worksheet
+    assert(@wb.worksheets.empty?, "worbook has no worksheets by default")
+    ws = @wb.add_worksheet(:name=>"bob")
+    assert_equal(@wb.worksheets.size, 1, "add_worksheet adds a worksheet!")
+    assert_equal(@wb.worksheets.first, ws, "the worksheet returned is the worksheet added")
+    assert_equal(ws.name, "bob", "name option gets passed to worksheet")
+  end
+  def test_relationships
+    #current relationship size is 1 due to style relation
+    assert(@wb.relationships.size == 1)
+    @wb.add_worksheet
+    assert(@wb.relationships.size == 2)
+  end
+
+  def test_to_xml
+    schema = Nokogiri::XML::Schema(File.open(Axlsx::SML_XSD))
+    doc = Nokogiri::XML(@wb.to_xml)
+    errors = []
+    schema.validate(doc).each do |error|
+      errors.push error
+      puts error.message
+    end
+    assert(errors.empty?, "error free validation")
+  end
+
+  def test_to_xml_adds_worksheet_when_worksheets_is_empty
+    assert(@wb.worksheets.empty?)
+    @wb.to_xml
+    assert(@wb.worksheets.size == 1)
+  end
+
+
+end

data/test/workbook/worksheet/tc_cell.rb

@@ -0,0 +1,78 @@
+require 'test/unit'
+require 'axlsx.rb'
+
+class TestCell < Test::Unit::TestCase
+
+  def setup
+    p = Axlsx::Package.new
+    @ws = p.workbook.add_worksheet :name=>"hmmm"
+    p.workbook.styles.add_style :sz=>20
+    @row = @ws.add_row
+    @c = @row.add_cell 1, :type=>:float, :style=>1
+  end
+  
+  def test_initialize
+    assert_equal(@row.cells.last, @c, "the cell was added to the row")
+    assert_equal(@c.type, :float, "type option is applied")
+    assert_equal(@c.style, 1, "style option is applied")
+    assert_equal(@c.value, 1.0, "type option is applied and value is casted")
+  end
+
+  def test_index
+    assert_equal(@c.index, @row.cells.index(@c))
+  end
+
+  def test_r
+    assert_equal(@c.r, "A1", "calculate cell reference")
+  end
+
+  def test_r_abs
+    assert_equal(@c.r_abs,"$A$1", "calculate absolute cell reference")
+  end
+
+  def test_style
+    assert_raise(ArgumentError, "must reject invalid style indexes") { @c.style=3 }
+    assert_nothing_raised("must allow valid style index changes") {@c.style=1} 
+    assert_equal(@c.style, 1)
+  end
+
+  def test_type
+    assert_raise(ArgumentError, "type must be :string, :integer, :float, :time") { @c.type = :array }
+    assert_nothing_raised("type can be changed") { @c.type = :string }
+    assert_equal(@c.value, "1.0", "changing type casts the value")
+    
+    assert_equal(@row.add_cell(Time.now).type, :time, 'time should be time')
+  end
+
+  def test_value
+    assert_raise(ArgumentError, "type must be :string, :integer, :float, :time") { @c.type = :array }
+    assert_nothing_raised("type can be changed") { @c.type = :string }
+    assert_equal(@c.value, "1.0", "changing type casts the value")
+  end
+
+  def test_col_ref
+    assert_equal(@c.send(:col_ref), "A")
+  end
+
+  def test_cell_type_from_value
+    assert_equal(@c.send(:cell_type_from_value, 1.0), :float)
+    assert_equal(@c.send(:cell_type_from_value, 1), :integer)
+    assert_equal(@c.send(:cell_type_from_value, Time.now), :time)
+    assert_equal(@c.send(:cell_type_from_value, []), :string)
+    assert_equal(@c.send(:cell_type_from_value, "d"), :string)
+    assert_equal(@c.send(:cell_type_from_value, nil), :string)
+    assert_equal(@c.send(:cell_type_from_value, -1), :integer)
+  end
+
+  def test_cast_value    
+    @c.type = :string
+    assert_equal(@c.send(:cast_value, 1.0), "1.0")
+    @c.type = :integer
+    assert_equal(@c.send(:cast_value, 1.0), 1)
+    @c.type = :float
+    assert_equal(@c.send(:cast_value, "1.0"), 1.0)
+    @c.type = :string
+    assert_equal(@c.send(:cast_value, nil), "")
+
+  end
+end

data/test/workbook/worksheet/tc_row.rb

@@ -0,0 +1,30 @@
+require 'test/unit'
+require 'axlsx.rb'
+
+class TestRow < Test::Unit::TestCase
+
+  def setup
+    p = Axlsx::Package.new
+    @ws = p.workbook.add_worksheet :name=>"hmmm"
+    @row = @ws.add_row
+  end
+  
+  def test_initialize
+    assert(@row.cells.empty?, "no cells by default")
+    assert_equal(@row.worksheet, @ws, "has a reference to the worksheet")
+  end
+
+  def test_index
+    assert_equal(@row.index, @row.worksheet.rows.index(@row))
+  end
+
+  def test_add_cell
+    c = @row.add_cell(1)
+    assert_equal(@row.cells.last, c)
+  end
+
+  def test_array_to_cells
+    r = @ws.add_row :values=>[1,2,3], :style=>0, :types=>:integer
+    assert_equal(r.cells.size, 3)
+  end
+end

data/test/workbook/worksheet/tc_worksheet.rb

@@ -0,0 +1,85 @@
+require 'test/unit'
+require 'axlsx.rb'
+
+class TestWorksheet < Test::Unit::TestCase
+  def setup    
+    p = Axlsx::Package.new
+    @ws = p.workbook.add_worksheet
+  end
+
+  def test_pn
+    assert_equal(@ws.pn, "worksheets/sheet1.xml")
+    ws = @ws.workbook.add_worksheet
+    assert_equal(ws.pn, "worksheets/sheet2.xml")
+  end
+
+  def test_rels_pn
+    assert_equal(@ws.rels_pn, "worksheets/_rels/sheet1.xml.rels")
+    ws = @ws.workbook.add_worksheet
+    assert_equal(ws.rels_pn, "worksheets/_rels/sheet2.xml.rels")
+  end
+
+  def test_rId
+    assert_equal(@ws.rId, "rId1")
+    ws = @ws.workbook.add_worksheet
+    assert_equal(ws.rId, "rId2")
+  end
+  
+  def test_index
+    assert_equal(@ws.index, @ws.workbook.worksheets.index(@ws))
+  end
+
+  def test_add_row
+    assert(@ws.rows.empty?, "sheet has no rows by default")
+    r = @ws.add_row(:values=>[1,2,3])
+    assert_equal(@ws.rows.size, 1, "add_row adds a row")
+    assert_equal(@ws.rows.first, r, "the row returned is the row added")
+  end
+
+  def test_add_chart
+    assert(@ws.workbook.charts.empty?, "the sheet's workbook should not have any charts by default")
+    @ws.add_chart Axlsx::Pie3DChart
+    assert_equal(@ws.workbook.charts.size, 1, "add_chart adds a chart to the workbook")
+  end
+
+  def test_drawing
+    assert @ws.drawing.is_a? Axlsx::Drawing
+  end
+
+  
+  def test_to_xml
+    schema = Nokogiri::XML::Schema(File.open(Axlsx::SML_XSD))
+    doc = Nokogiri::XML(@ws.to_xml)
+    errors = []
+    schema.validate(doc).each do |error|
+      errors.push error
+      puts error.message
+    end
+    assert(errors.empty?, "error free validation")
+  end
+
+  def test_relationships
+    assert(@ws.relationships.empty?, "No Drawing relationship until you add a chart")
+    c = @ws.add_chart Axlsx::Pie3DChart
+    assert_equal(@ws.relationships.size, 1, "adding a chart creates the relationship")
+    c = @ws.add_chart Axlsx::Pie3DChart
+    assert_equal(@ws.relationships.size, 1, "multiple charts still only result in one relationship")
+  end
+
+  
+  def test_update_auto_with_data
+    small = @ws.workbook.styles.add_style(:sz=>2)
+    big = @ws.workbook.styles.add_style(:sz=>10)
+    @ws.add_row :values=>["chasing windmills", "penut"], :style=>small
+    assert(@ws.auto_fit_data.size == 2, "a data item for each column")
+    assert_equal(@ws.auto_fit_data[0], {:sz=>2,:longest=>"chasing windmills"}, "adding a row updates auto_fit_data if the product of the string length and font is greater for the column")
+    @ws.add_row :values=> ["mule"], :style=>big
+    assert_equal(@ws.auto_fit_data[0], {:sz=>10,:longest=>"mule"}, "adding a row updates auto_fit_data if the product of the string length and font is greater for the column")
+  end
+
+  def test_auto_width
+    assert(@ws.send(:auto_width, {:sz=>11, :longest=>"fisheries"}) > @ws.send(:auto_width, {:sz=>11, :longest=>"fish"}), "longer strings get a longer auto_width at the same font size")
+    assert(@ws.send(:auto_width, {:sz=>12, :longest=>"fish"}) > @ws.send(:auto_width, {:sz=>11, :longest=>"fish"}), "larger font size gets a longer auto_width using the same text")
+  end
+
+end