axlsx 1.0.12 → 1.0.13

data/test/util/tc_validators.rb

@@ -1,76 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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_range_requires__valid_sheet
-    ws = @wb.add_worksheet :name=>'fish'
-    ws.add_row [1,2,3]
-    ws.add_row [4,5,6]
-    assert_raise(ArgumentError, "no sheet name part") { @wb["A1:C2"]}
-    assert_equal @wb['fish!A1:C2'].size, 6
-  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

@@ -1,179 +0,0 @@
-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_style_date_data
-    c = Axlsx::Cell.new(@c.row, Time.now)
-    assert_equal(Axlsx::STYLE_DATE, c.style)
-  end
-
-  def test_index
-    assert_equal(@c.index, @row.cells.index(@c))
-  end
-
-  def test_index
-    assert_equal(@c.pos, [@c.index, @c.row.index])
-  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=@c.row.worksheet.workbook.styles.cellXfs.size }
-    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
-
-  def test_color
-    assert_raise(ArgumentError) { @c.color = -1.1 }
-    assert_nothing_raised { @c.color = "FF00FF00" }
-    assert_equal(@c.color.rgb, "FF00FF00")
-  end
-
-  def test_scheme
-    assert_raise(ArgumentError) { @c.scheme = -1.1 }
-    assert_nothing_raised { @c.scheme = :major }
-    assert_equal(@c.scheme, :major)
-  end
-
-  def test_vertAlign
-    assert_raise(ArgumentError) { @c.vertAlign = -1.1 }
-    assert_nothing_raised { @c.vertAlign = :baseline }
-    assert_equal(@c.vertAlign, :baseline)
-  end
-
-  def test_sz
-    assert_raise(ArgumentError) { @c.sz = -1.1 }
-    assert_nothing_raised { @c.sz = 12 }
-    assert_equal(@c.sz, 12)
-  end
-
-  def test_extend
-    assert_raise(ArgumentError) { @c.extend = -1.1 }
-    assert_nothing_raised { @c.extend = false }
-    assert_equal(@c.extend, false)
-  end
-
-  def test_condense
-    assert_raise(ArgumentError) { @c.condense = -1.1 }
-    assert_nothing_raised { @c.condense = false }
-    assert_equal(@c.condense, false)
-  end
-
-  def test_shadow
-    assert_raise(ArgumentError) { @c.shadow = -1.1 }
-    assert_nothing_raised { @c.shadow = false }
-    assert_equal(@c.shadow, false)
-  end
-
-  def test_outline
-    assert_raise(ArgumentError) { @c.outline = -1.1 }
-    assert_nothing_raised { @c.outline = false }
-    assert_equal(@c.outline, false)
-  end
-
-  def test_strike
-    assert_raise(ArgumentError) { @c.strike = -1.1 }
-    assert_nothing_raised { @c.strike = false }
-    assert_equal(@c.strike, false)
-  end
-
-  def test_u
-    assert_raise(ArgumentError) { @c.u = -1.1 }
-    assert_nothing_raised { @c.u = false }
-    assert_equal(@c.u, false)
-  end
-
-  def test_i
-    assert_raise(ArgumentError) { @c.i = -1.1 }
-    assert_nothing_raised { @c.i = false }
-    assert_equal(@c.i, false)
-  end
-
-  def test_rFont
-    assert_raise(ArgumentError) { @c.font_name = -1.1 }
-    assert_nothing_raised { @c.font_name = "Arial" }
-    assert_equal(@c.font_name, "Arial")
-  end
-
-  def test_charset
-    assert_raise(ArgumentError) { @c.charset = -1.1 }
-    assert_nothing_raised { @c.charset = 1 }
-    assert_equal(@c.charset, 1)
-  end
-
-  def test_family
-    assert_raise(ArgumentError) { @c.family = -1.1 }
-    assert_nothing_raised { @c.family = "Who knows!" }
-    assert_equal(@c.family, "Who knows!")
-  end
-
-  def test_b
-    assert_raise(ArgumentError) { @c.b = -1.1 }
-    assert_nothing_raised { @c.b = false }
-    assert_equal(@c.b, false)
-  end
-
-
-end

data/test/workbook/worksheet/tc_row.rb

@@ -1,36 +0,0 @@
-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_style
-    r = @ws.add_row([1,2,3,4,5])
-    r.style=1
-    r.cells.each { |c| assert_equal(c.style,1) }    
-  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 [1,2,3], :style=>0, :types=>:integer
-    assert_equal(r.cells.size, 3)
-  end
-end

data/test/workbook/worksheet/tc_worksheet.rb

@@ -1,138 +0,0 @@
-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_referencing
-    @ws.add_row [1, 2, 3]
-    @ws.add_row [4, 5, 6]
-    range = @ws["A1:C2"]
-    assert_equal(range.size, 6)
-    assert_equal(range.first, @ws.rows.first.cells.first)
-    assert_equal(range.last, @ws.rows.last.cells.last)    
-  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_col_style
-    @ws.add_row [1,2,3,4]
-    @ws.add_row [1,2,3,4]
-    @ws.add_row [1,2,3,4]
-    @ws.add_row [1,2,3,4]
-    @ws.col_style( (1..2), 1, :row_offset=>1)
-    @ws.rows[(1..-1)].each do | r | 
-      assert_equal(r.cells[1].style, 1)
-      assert_equal(r.cells[2].style, 1)
-    end
-    assert_equal(@ws.rows.first.cells[1].style, 0)
-    assert_equal(@ws.rows.first.cells[0].style, 0)
-  end
-
-  def test_cols
-    @ws.add_row [1,2,3,4]
-    @ws.add_row [1,2,3,4]
-    @ws.add_row [1,2,3,4]
-    @ws.add_row [1,2,3,4]
-    c = @ws.cols[1]
-    assert_equal(c.size, 4)    
-    assert_equal(c[0].value, 2)
-  end
-
-  def test_row_style
-    @ws.add_row [1,2,3,4]
-    @ws.add_row [1,2,3,4]
-    @ws.add_row [1,2,3,4]
-    @ws.add_row [1,2,3,4]
-    @ws.row_style 1, 1, :col_offset=>1
-    @ws.rows[1].cells[(1..-1)].each do | c | 
-      assert_equal(c.style, 1)
-    end
-    assert_equal(@ws.rows[1].cells[0].style, 0)
-    assert_equal(@ws.rows[2].cells[1].style, 0)
-  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_name_unique
-    assert_raise(ArgumentError, "worksheet name must be unique") { n = @ws.name; @ws.workbook.add_worksheet(:name=> @ws) }
-  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