axlsx 1.1.4 → 1.2.0

data/test/util/tc_validators.rb

@@ -8,15 +8,15 @@ class TestValidators < Test::Unit::TestCase
   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' }
+    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 }
+    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|
@@ -70,6 +70,92 @@ class TestValidators < Test::Unit::TestCase
     assert_raise(ArgumentError) { Axlsx.validate_relationship_type "http://some.url" }
     assert_raise(ArgumentError) { Axlsx.validate_relationship_type false }
 
-  end
-end
+    #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" }
 
+    #scale_10_400
+    assert_nothing_raised { Axlsx.validate_scale_10_400 10 }
+    assert_nothing_raised { Axlsx.validate_scale_10_400 100 }
+    assert_nothing_raised { Axlsx.validate_scale_10_400 400 }
+    assert_raise(ArgumentError) { Axlsx.validate_scale_10_400 9 }
+    assert_raise(ArgumentError) { Axlsx.validate_scale_10_400 10.0 }
+    assert_raise(ArgumentError) { Axlsx.validate_scale_10_400 400.1 }
+    assert_raise(ArgumentError) { Axlsx.validate_scale_10_400 "99" }
+    
+    #scale_0_10_400
+    assert_nothing_raised { Axlsx.validate_scale_0_10_400 0 }
+    assert_nothing_raised { Axlsx.validate_scale_0_10_400 10 }
+    assert_nothing_raised { Axlsx.validate_scale_0_10_400 100 }
+    assert_nothing_raised { Axlsx.validate_scale_0_10_400 400 }
+    assert_raise(ArgumentError) { Axlsx.validate_scale_0_10_400 9 }
+    assert_raise(ArgumentError) { Axlsx.validate_scale_0_10_400 10.0 }
+    assert_raise(ArgumentError) { Axlsx.validate_scale_0_10_400 400.1 }
+    assert_raise(ArgumentError) { Axlsx.validate_scale_0_10_400 "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" }
+    
+    #data_validation_error_style
+    [:information, :stop, :warning].each do |sym|
+      assert_nothing_raised { Axlsx.validate_data_validation_error_style sym }
+    end
+    assert_raise(ArgumentError) { Axlsx.validate_data_validation_error_style :other_symbol }
+    assert_raise(ArgumentError) { Axlsx.validate_data_validation_error_style 'warning' }
+    assert_raise(ArgumentError) { Axlsx.validate_data_validation_error_style 0 }
+    
+    #data_validation_operator
+    [:lessThan, :lessThanOrEqual, :equal, :notEqual, :greaterThanOrEqual, :greaterThan, :between, :notBetween].each do |sym|
+      assert_nothing_raised { Axlsx.validate_data_validation_operator sym }
+    end
+    assert_raise(ArgumentError) { Axlsx.validate_data_validation_error_style :other_symbol }
+    assert_raise(ArgumentError) { Axlsx.validate_data_validation_error_style 'lessThan' }
+    assert_raise(ArgumentError) { Axlsx.validate_data_validation_error_style 0 }
+    
+    #data_validation_type
+    [:custom, :data, :decimal, :list, :none, :textLength, :time, :whole].each do |sym|
+      assert_nothing_raised { Axlsx.validate_data_validation_type sym }
+    end
+    assert_raise(ArgumentError) { Axlsx.validate_data_validation_error_style :other_symbol }
+    assert_raise(ArgumentError) { Axlsx.validate_data_validation_error_style 'decimal' }
+    assert_raise(ArgumentError) { Axlsx.validate_data_validation_error_style 0 }
+    
+    #sheet_view_type
+    [:normal, :page_break_preview, :page_layout].each do |sym|
+      assert_nothing_raised { Axlsx.validate_sheet_view_type sym }
+    end
+    assert_raise(ArgumentError) { Axlsx.validate_data_validation_error_style :other_symbol }
+    assert_raise(ArgumentError) { Axlsx.validate_data_validation_error_style 'page_layout' }
+    assert_raise(ArgumentError) { Axlsx.validate_data_validation_error_style 0 }
+    
+    #active_pane_type
+    [:bottom_left, :bottom_right, :top_left, :top_right].each do |sym|
+      assert_nothing_raised { Axlsx.validate_pane_type sym }
+    end
+    assert_raise(ArgumentError) { Axlsx.validate_pane_type :other_symbol }
+    assert_raise(ArgumentError) { Axlsx.validate_pane_type 'bottom_left' }
+    assert_raise(ArgumentError) { Axlsx.validate_pane_type 0 }
+    
+    #split_state_type
+    [:frozen, :frozen_split, :split].each do |sym|
+      assert_nothing_raised { Axlsx.validate_split_state_type sym }
+    end
+    assert_raise(ArgumentError) { Axlsx.validate_split_state_type :other_symbol }
+    assert_raise(ArgumentError) { Axlsx.validate_split_state_type 'frozen_split' }
+    assert_raise(ArgumentError) { Axlsx.validate_split_state_type 0 }
+  end
+end

data/test/workbook/tc_defined_name.rb

@@ -0,0 +1,41 @@
+require 'tc_helper'
+
+class TestDefinedNames < Test::Unit::TestCase
+  def setup 
+    @dn = Axlsx::DefinedName.new('Sheet1!A1:A1')
+  end
+
+  def test_initialize
+    assert_equal('Sheet1!A1:A1', @dn.formula)
+  end
+  
+  def test_string_attributes
+    Axlsx::DefinedName::STRING_ATTRIBUTES.each do |attr|
+      assert_raise(ArgumentError, 'only strings allowed in string attributes') { @dn.send("#{attr}=", 1) }
+      assert_nothing_raised { @dn.send("#{attr}=", '_xlnm.Sheet_Title') }
+    end
+  end
+
+  def test_boolean_attributes
+   Axlsx::DefinedName::BOOLEAN_ATTRIBUTES.each do |attr|
+      assert_raise(ArgumentError, 'only booleanish allowed in string attributes') { @dn.send("#{attr}=", 'foo') }
+      assert_nothing_raised { @dn.send("#{attr}=", 1) }
+    end
+
+  end
+
+  def test_local_sheet_id
+    assert_raise(ArgumentError, 'local_sheet_id must be an unsigned int') { @dn.local_sheet_id = -1 }
+    assert_nothing_raised { @dn.local_sheet_id = 1 }
+  end
+
+  def test_to_xml_string
+    assert_raise(ArgumentError, 'name is required for serialization') { @dn.to_xml_string }
+    @dn.name = '_xlnm.Print_Titles'
+    @dn.hidden = true
+    doc = Nokogiri::XML(@dn.to_xml_string)
+    assert(doc.xpath("//definedName[@name='_xlnm.Print_Titles']"))
+    assert(doc.xpath("//definedName[@hidden='true']"))
+    assert_equal('Sheet1!A1:A1', doc.xpath('//definedName').text)
+  end
+end

data/test/workbook/tc_workbook.rb

@@ -24,7 +24,10 @@ class TestWorkbook < Test::Unit::TestCase
     assert_equal(Axlsx::Workbook.date1904, @wb.date1904)
   end
 
-
+  def test_add_defined_name
+    @wb.add_defined_name 'Sheet1!1:1', :name => '_xlnm.Print_Titles', :hidden => true
+    assert_equal(1, @wb.defined_names.size)
+  end
 
   def test_shared_strings
     assert_equal(@wb.use_shared_strings, nil)
@@ -72,14 +75,13 @@ class TestWorkbook < Test::Unit::TestCase
     assert(@wb.worksheets.size == 1)
   end
 
-
   def test_to_xml_string_defined_names
     @wb.add_worksheet do |sheet|
       sheet.add_row [1, "two"]
       sheet.auto_filter = "A1:B1"
     end
     doc = Nokogiri::XML(@wb.to_xml_string)
-    assert_equal(doc.xpath('//xmlns:workbook/xmlns:definedNames/xmlns:definedName').inner_text, @wb.worksheets[0].abs_auto_filter)
+    assert_equal(doc.xpath('//xmlns:workbook/xmlns:definedNames/xmlns:definedName').inner_text, @wb.worksheets[0].auto_filter.defined_name)
   end
 
 

data/test/workbook/worksheet/table/tc_table.rb

@@ -25,26 +25,18 @@ class TestTable < Test::Unit::TestCase
 
   end
 
-  def test_charts
-    assert(@ws.drawing.charts.empty?)
-    chart = @ws.add_chart(Axlsx::Pie3DChart, :title=>"bob", :start_at=>[0,0], :end_at=>[1,1])
-    assert_equal(@ws.drawing.charts.last, chart, "add chart is returned")
-    chart = @ws.add_chart(Axlsx::Pie3DChart, :title=>"nancy", :start_at=>[1,5], :end_at=>[5,10])
-    assert_equal(@ws.drawing.charts.last, chart, "add chart is returned")
-  end
-
   def test_pn
-    table = @ws.add_table("A1:D5")
+    @ws.add_table("A1:D5")
     assert_equal(@ws.tables.first.pn, "tables/table1.xml")
   end
 
   def test_rId
-    table = @ws.add_table("A1:D5")
+    @ws.add_table("A1:D5")
     assert_equal(@ws.tables.first.rId, "rId1")
   end
 
   def test_index
-    table = @ws.add_table("A1:D5")
+    @ws.add_table("A1:D5")
     assert_equal(@ws.tables.first.index, @ws.workbook.tables.index(@ws.tables.first))
   end
 

data/test/workbook/worksheet/tc_cell.rb

@@ -33,7 +33,7 @@ class TestCell < Test::Unit::TestCase
     assert_equal(@c.index, @row.cells.index(@c))
   end
 
-  def test_index
+  def test_pos
     assert_equal(@c.pos, [@c.index, @c.row.index])
   end
 
@@ -197,19 +197,17 @@ class TestCell < Test::Unit::TestCase
   end
 
   def test_merge_with_string
-    assert_equal(@c.row.worksheet.merged_cells.size, 0)
     @c.row.add_cell 2
     @c.row.add_cell 3
     @c.merge "A2"
-    assert_equal(@c.row.worksheet.merged_cells.last, "A1:A2")
+    assert_equal(@c.row.worksheet.send(:merged_cells).last, "A1:A2")
   end
 
   def test_merge_with_cell
-    assert_equal(@c.row.worksheet.merged_cells.size, 0)
     @c.row.add_cell 2
     @c.row.add_cell 3
     @c.merge @row.cells.last
-    assert_equal(@c.row.worksheet.merged_cells.last, "A1:C1")
+    assert_equal(@c.row.worksheet.send(:merged_cells).last, "A1:C1")
   end
 
   def test_ssti
@@ -244,9 +242,35 @@ 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_with_run
+    @c.b = true
+    @c.type = :string
+    @c.value = "a"
+    @c.font_name = 'arial'
+    @c.color = 'FF0000'
+    c_xml = Nokogiri::XML(@c.to_xml_string(1,1))
+    assert(c_xml.xpath("//b"))
+  end
+  def test_to_xml_string_formula
+    p = Axlsx::Package.new
+    ws = p.workbook.add_worksheet do |sheet|
+      sheet.add_row ["=IF(2+2=4,4,5)"]
+    end
+    doc = Nokogiri::XML(ws.to_xml_string)
+    assert(doc.xpath("//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)"]
+    @ws.add_row [Time.now, Date.today, true, 1, 1.0, "text", "=sum(A1:A2)"]
     schema = Nokogiri::XML::Schema(File.open(Axlsx::SML_XSD))
     doc = Nokogiri::XML(@ws.to_xml_string)
     errors = []

data/test/workbook/worksheet/tc_col.rb

@@ -6,6 +6,13 @@ class TestCol < Test::Unit::TestCase
     @col = Axlsx::Col.new 1, 1
   end
 
+  def test_initialize
+    options = { :width => 12, :collapsed => true, :hidden => true, :outlineLevel => 1, :phonetic => true, :style => 1} 
+
+    col = Axlsx::Col.new 0, 0, options
+    options.each{ |key, value| assert_equal(col.send(key.to_sym), value) }
+  end
+
   def test_min_max_required
     assert_raise(ArgumentError, 'min and max must be specified when creating a new column') { Axlsx::Col.new }
     assert_raise(ArgumentError, 'min and max must be specified when creating a new column') { Axlsx::Col.new nil, nil }
@@ -53,6 +60,8 @@ class TestCol < Test::Unit::TestCase
 
   def test_style
     assert_equal(@col.style, nil)
+    @col.style = 1
+    assert_equal(@col.style, 1)
     #TODO check that the style specified is actually in the styles xfs collection
   end
 

data/test/workbook/worksheet/tc_comment.rb

@@ -0,0 +1,57 @@
+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
+    pos = Axlsx::name_to_indices(@c1.ref)
+    assert(@c1.vml_shape.is_a?(Axlsx::VmlShape))
+    assert(@c1.vml_shape.column == pos[0])
+    assert(@c1.vml_shape.row == pos[1])
+    assert(@c1.vml_shape.row == pos[1])
+    assert_equal(pos[0], @c1.vml_shape.left_column)
+    assert(@c1.vml_shape.top_row == pos[1])
+    assert_equal(pos[0] + 2 , @c1.vml_shape.right_column)
+    assert(@c1.vml_shape.bottom_row == pos[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,57 @@
+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)
+    schema = Nokogiri::XML::Schema(File.open(Axlsx::SML_XSD))
+    errors = []
+    schema.validate(doc).each do |error|
+      errors << error
+    end
+    assert_equal(0, errors.length)
+
+    # 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
+
+

data/test/workbook/worksheet/tc_conditional_formatting.rb

@@ -15,6 +15,50 @@ class TestConditionalFormatting < Test::Unit::TestCase
     assert_equal("AA1:AB100", optioned.sqref)
     assert_equal([1, 2], optioned.rules)
   end
+  def test_add_as_rule
+
+    color_scale = Axlsx::ColorScale.new do |cs|
+      cs.colors.first.rgb = "FFDFDFDF"
+      cs.colors.last.rgb = "FF00FF00"
+      cs.value_objects.first.type = :percentile
+      cs.value_objects.first.val = 5
+    end
+
+    data_bar = Axlsx::DataBar.new :color => "FFFF0000"
+    icon_set = Axlsx::IconSet.new :iconSet => "5Rating"
+    cfr = Axlsx::ConditionalFormattingRule.new( { :type => :containsText, :text => "TRUE",
+                                                      :dxfId => 0, :priority => 1,
+                                                      :formula => 'NOT(ISERROR(SEARCH("FALSE",AB1)))',
+                                                      :color_scale => color_scale,
+                                                      :data_bar => data_bar,
+                                                      :icon_set => icon_set})
+
+    assert(cfr.data_bar.is_a?(Axlsx::DataBar))
+    assert(cfr.icon_set.is_a?(Axlsx::IconSet))
+    assert(cfr.color_scale.is_a?(Axlsx::ColorScale))
+    cfs = @ws.add_conditional_formatting( "B2:B2", [cfr])
+    doc = Nokogiri::XML.parse(cfs.last.to_xml_string)
+    assert_equal(1, doc.xpath(".//conditionalFormatting[@sqref='B2:B2']//cfRule[@type='containsText'][@dxfId=0][@priority=1]").size)
+    assert doc.xpath(".//conditionalFormatting//cfRule[@type='containsText'][@dxfId=0][@priority=1]//formula='NOT(ISERROR(SEARCH(\"FALSE\",AB1)))'")
+
+    cfs.last.rules.last.type = :colorScale
+    doc = Nokogiri::XML.parse(cfs.last.to_xml_string)
+    assert_equal(doc.xpath(".//conditionalFormatting//cfRule//colorScale//cfvo").size, 2)
+    assert_equal(doc.xpath(".//conditionalFormatting//cfRule//colorScale//color").size, 2)
+
+    cfs.last.rules.last.type = :dataBar
+    doc = Nokogiri::XML.parse(cfs.last.to_xml_string)
+    assert_equal(doc.xpath(".//conditionalFormatting//cfRule//dataBar").size, 1)
+    assert_equal(doc.xpath(".//conditionalFormatting//cfRule//dataBar//cfvo").size, 2)
+    assert_equal(doc.xpath(".//conditionalFormatting//cfRule//dataBar//color[@rgb='FFFF0000']").size, 1)
+
+    cfs.last.rules.last.type = :iconSet
+    doc = Nokogiri::XML.parse(cfs.last.to_xml_string)
+    assert_equal(doc.xpath(".//conditionalFormatting//cfRule//iconSet//cfvo").size, 3)
+    assert_equal(doc.xpath(".//conditionalFormatting//cfRule//iconSet[@iconSet='5Rating']").size, 1)
+
+  end
+
 
   def test_add_as_hash
 

data/test/workbook/worksheet/tc_data_bar.rb

@@ -23,7 +23,7 @@ class TestDataBar < Test::Unit::TestCase
     assert_equal(@data_bar.maxLength, 0)
   end
 
-  def test_maxLength
+  def test_showValue
     assert_raise(ArgumentError) { @data_bar.showValue = :invalid_type }
     assert_nothing_raised { @data_bar.showValue =  false}
     assert_equal(@data_bar.showValue, false)