caxlsx 3.0.0 → 3.1.0

data/test/drawing/tc_pie_series.rb

@@ -20,12 +20,13 @@ class TestPieSeries < Test::Unit::TestCase
     assert_raise(ArgumentError, "require valid explosion") { @series.explosion = :lots }
     assert_nothing_raised("allow valid explosion") { @series.explosion = 20 }
     assert(@series.explosion == 20)
+    # issue 58 - explosion caused to_xml_string to fail - now tested
+    assert_nothing_raised("allow to_xml_string") { @series.to_xml_string }
   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
 

data/test/drawing/tc_series_title.rb

@@ -30,4 +30,25 @@ class TestSeriesTitle < Test::Unit::TestCase
     assert(@title.text == "one")
   end
 
+  def test_to_xml_string_for_special_characters
+    @chart.add_series(title: @title, data: [3, 7], labels: ['A', 'B'])
+
+    @title.text = "&><'\""
+
+    doc = Nokogiri::XML(@chart.to_xml_string)
+    errors = doc.errors
+    assert(errors.empty?, "invalid xml: #{errors.map(&:to_s).join(', ')}")
+  end
+
+  def test_to_xml_string_for_special_characters_in_cell
+    @chart.add_series(title: @title, data: [3, 7], labels: ['A', 'B'])
+
+    cell = @row.cells.first
+    cell.value = "&><'\""
+    @title.cell = cell
+
+    doc = Nokogiri::XML(@chart.to_xml_string)
+    errors = doc.errors
+    assert(errors.empty?, "invalid xml: #{errors.map(&:to_s).join(', ')}")
+  end
 end

data/test/drawing/tc_title.rb

@@ -51,4 +51,20 @@ class TestTitle < Test::Unit::TestCase
     assert_equal(1, doc.xpath('//c:v[text()="one"]').size)
   end
 
+  def test_to_xml_string_for_special_characters
+    @chart.title.text = "&><'\""
+    doc = Nokogiri::XML(@chart.to_xml_string)
+    errors = doc.errors
+    assert(errors.empty?, "invalid xml: #{errors.map(&:to_s).join(', ')}")
+  end
+
+  def test_to_xml_string_for_special_characters_in_cell
+    cell = @row.cells.first
+    cell.value = "&><'\""
+
+    @chart.title.cell = cell
+    doc = Nokogiri::XML(@chart.to_xml_string)
+    errors = doc.errors
+    assert(errors.empty?, "invalid xml: #{errors.map(&:to_s).join(', ')}")
+  end
 end

data/test/rels/tc_relationship.rb

@@ -13,6 +13,14 @@ class TestRelationships < Test::Unit::TestCase
     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_ids_cache_is_thread_safe
+    cache1, cache2 = nil
+    t1 = Thread.new { cache1 = Axlsx::Relationship.ids_cache }
+    t2 = Thread.new { cache2 = Axlsx::Relationship.ids_cache }
+    [t1, t2].each(&:join)
+    assert_not_same(cache1, cache2)
+  end
   
   def test_target_is_only_considered_for_same_attributes_check_if_target_mode_is_external
     source_obj = Object.new

data/test/stylesheet/tc_font.rb

@@ -62,11 +62,23 @@ class TestFont < Test::Unit::TestCase
     assert_equal(@item.i, true)
   end
 
-    # def u=(v) Axlsx::validate_boolean v; @u = v end
+    # def u=(v) Axlsx::validate_cell_u v; @u = v end
   def test_u
     assert_raise(ArgumentError) { @item.u = -7 }
+    assert_nothing_raised { @item.u = :single }
+    assert_equal(@item.u, :single)
+    doc = Nokogiri::XML(@item.to_xml_string)
+    assert(doc.xpath('//u[@val="single"]'))
+  end
+
+  def test_u_backward_compatibility
+    # backward compatibility for true
     assert_nothing_raised { @item.u = true }
-    assert_equal(@item.u, true)
+    assert_equal(@item.u, :single)
+
+    # backward compatibility for false
+    assert_nothing_raised { @item.u = false }
+    assert_equal(@item.u, :none)
   end
 
     # def strike=(v) Axlsx::validate_boolean v; @strike = v end

data/test/stylesheet/tc_styles.rb

@@ -124,7 +124,7 @@ class TestStyles < Test::Unit::TestCase
       :sz => 20,
       :b => 1,
       :i => 1,
-      :u => 1,
+      :u => :single,
       :strike => 1,
       :outline => 1,
       :shadow => 1,
@@ -232,4 +232,30 @@ class TestStyles < Test::Unit::TestCase
     style = @styles.add_style :bg_color=>"FF000000", :fg_color=>"FFFFFFFF", :sz=>13, :alignment=>{:horizontal=>:left}, :border=>{:style => :thin, :color => "FFFF0000"}, :hidden=>true, :locked=>true, :type => :dxf
     assert_equal(1, style, "returns the second dxfId")
   end
+
+  def test_valid_document_with_font_options
+    font_options = {
+      :fg_color => "FF050505",
+      :sz => 20,
+      :b => 1,
+      :i => 1,
+      :u => :single,
+      :strike => 1,
+      :outline => 1,
+      :shadow => 1,
+      :charset => 9,
+      :family => 1,
+      :font_name => "woot font"
+    }
+    @styles.add_style font_options
+
+    schema = Nokogiri::XML::Schema(File.open(Axlsx::SML_XSD))
+    doc = Nokogiri::XML(@styles.to_xml_string)
+    errors = []
+    schema.validate(doc).each do |error|
+      errors.push error
+      puts error.message
+    end
+    assert(errors.size == 0)
+  end
 end

data/test/tc_axlsx.rb

@@ -24,8 +24,14 @@ class TestAxlsx < Test::Unit::TestCase
 
 
   def test_trust_input_can_be_set_to_true
+    # Class variables like this are not reset between test runs, so we have
+    # to save and restore the original value manually.
+    old = Axlsx.trust_input
+
     Axlsx.trust_input = true
     assert_equal true, Axlsx.trust_input
+
+    Axlsx.trust_input = old
   end
   def test_cell_range_relative
     p = Axlsx::Package.new

data/test/tc_helper.rb

@@ -8,5 +8,3 @@ end
 require 'test/unit'
 require "timecop"
 require "axlsx.rb"
-# MIME detection for Microsoft Office 2007+ formats
-require 'mimemagic/overlay'

data/test/tc_package.rb

@@ -65,7 +65,7 @@ class TestPackage < Test::Unit::TestCase
     end
 
     @fname = 'axlsx_test_serialization.xlsx'
-    img = File.expand_path('../../examples/image1.jpeg', __FILE__)
+    img = File.expand_path('../fixtures/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
@@ -73,12 +73,12 @@ class TestPackage < Test::Unit::TestCase
       image.start_at 5, 5
       image.end_at 10, 10
     end
-    ws.add_image :image_src => File.expand_path('../../examples/image1.gif', __FILE__) do |image|
+    ws.add_image :image_src => File.expand_path('../fixtures/image1.gif', __FILE__) do |image|
       image.start_at 0, 20
       image.width=360
       image.height=333
     end
-    ws.add_image :image_src => File.expand_path('../../examples/image1.png', __FILE__) do |image|
+    ws.add_image :image_src => File.expand_path('../fixtures/image1.png', __FILE__) do |image|
       image.start_at 9, 20
       image.width = 180
       image.height = 167
@@ -127,18 +127,85 @@ class TestPackage < Test::Unit::TestCase
   end
 
   def test_serialization
-    assert_nothing_raised do
-      begin
-        @package.serialize(@fname)
-        zf = Zip::File.open(@fname)
-        @package.send(:parts).each{ |part| zf.get_entry(part[:entry]) }
-        File.delete(@fname)
-      rescue Errno::EACCES
-        puts "WARNING:: test_serialization requires write access."
-      end
+    @package.serialize(@fname)
+    assert_zip_file_matches_package(@fname, @package)
+    assert_created_with_rubyzip(@fname, @package)
+    File.delete(@fname)
+  end
+
+  def test_serialization_with_zip_command
+    @package.serialize(@fname, zip_command: "zip")
+    assert_zip_file_matches_package(@fname, @package)
+    assert_created_with_zip_command(@fname, @package)
+    File.delete(@fname)
+  end
+
+  def test_serialization_with_zip_command_and_absolute_path
+    fname = "#{Dir.tmpdir}/#{@fname}"
+    @package.serialize(fname, zip_command: "zip")
+    assert_zip_file_matches_package(fname, @package)
+    assert_created_with_zip_command(fname, @package)
+    File.delete(fname)
+  end
+
+  def test_serialization_with_invalid_zip_command
+    assert_raises Axlsx::ZipCommand::ZipError do
+      @package.serialize(@fname, zip_command: "invalid_zip")
     end
   end
 
+  def assert_zip_file_matches_package(fname, package)
+    zf = Zip::File.open(fname)
+    package.send(:parts).each{ |part| zf.get_entry(part[:entry]) }
+  end
+
+  def assert_created_with_rubyzip(fname, package)
+    assert_equal 2098, get_mtime(fname, package).year, "XLSX files created with RubyZip have 2098 as the file mtime"
+  end
+
+  def assert_created_with_zip_command(fname, package)
+    assert_equal Time.now.utc.year, get_mtime(fname, package).year, "XLSX files created with a zip command have the current year as the file mtime"
+  end
+
+  def get_mtime(fname, package)
+    zf = Zip::File.open(fname)
+    part = package.send(:parts).first
+    entry = zf.get_entry(part[:entry])
+    entry.mtime.utc
+  end
+
+  def test_serialization_with_deprecated_argument
+    warnings = capture_warnings do
+      @package.serialize(@fname, false)
+    end
+    assert_equal 1, warnings.size
+    assert_includes warnings.first, "confirm_valid as a boolean is deprecated"
+    File.delete(@fname)
+  end
+
+  def test_serialization_with_deprecated_three_arguments
+    warnings = capture_warnings do
+      @package.serialize(@fname, true, zip_command: "zip")
+    end
+    assert_zip_file_matches_package(@fname, @package)
+    assert_created_with_zip_command(@fname, @package)
+    assert_equal 2, warnings.size
+    assert_includes warnings.first, "with 3 arguments is deprecated"
+    File.delete(@fname)
+  end
+
+  def capture_warnings(&block)
+    original_warn = Kernel.instance_method(:warn)
+    warnings = []
+    Kernel.send(:define_method, :warn) { |string| warnings << string }
+    block.call
+    original_verbose = $VERBOSE
+    $VERBOSE = nil
+    Kernel.send(:define_method, :warn, original_warn)
+    $VERBOSE = original_verbose
+    warnings
+  end
+
   # See comment for Package#zip_entry_for_part
   def test_serialization_creates_identical_files_at_any_time_if_created_at_is_set
     @package.core.created = Time.now
@@ -161,7 +228,7 @@ class TestPackage < Test::Unit::TestCase
   end
 
   def test_serialization_creates_files_with_excel_mime_type
-    assert_equal(MimeMagic.by_magic(@package.to_stream).type,
+    assert_equal(Marcel::MimeType.for(@package.to_stream),
                  'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
   end
 
@@ -236,6 +303,8 @@ class TestPackage < Test::Unit::TestCase
     # this is just a roundabout guess for a package as it is build now
     # in testing.
     assert(stream.size > 80000)
+    # Cached ids should be cleared
+    assert(Axlsx::Relationship.ids_cache.empty?)
   end
 
   def test_encrypt

data/test/util/tc_mime_type_utils.rb

@@ -1,7 +1,7 @@
 require 'tc_helper.rb'
 class TestMimeTypeUtils < Test::Unit::TestCase
   def setup
-    @test_img = File.dirname(__FILE__) + "/../../examples/image1.jpeg"
+    @test_img = File.dirname(__FILE__) + "/../fixtures/image1.jpeg"
   end
 
   def teardown

data/test/util/tc_validators.rb

@@ -127,7 +127,7 @@ class TestValidators < Test::Unit::TestCase
     assert_raise(ArgumentError) { Axlsx.validate_data_validation_error_style 0 }
 
     #data_validation_type
-    [:custom, :data, :decimal, :list, :none, :textLength, :time, :whole].each do |sym|
+    [:custom, :data, :decimal, :list, :none, :textLength, :date, :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 }

data/test/workbook/worksheet/tc_cell.rb

@@ -8,7 +8,7 @@ class TestCell < Test::Unit::TestCase
     @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
+    @c = @row.add_cell 1, :type=>:float, :style=>1, :escape_formulas=>true
     data = (0..26).map { |index| index }
     @ws.add_row data
     @cAA = @ws["AA2"]
@@ -19,6 +19,7 @@ class TestCell < Test::Unit::TestCase
     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")
+    assert_equal(@c.escape_formulas, true, "escape formulas option is applied")
   end
 
   def test_style_date_data
@@ -60,7 +61,7 @@ class TestCell < Test::Unit::TestCase
   def test_autowidth
     style = @c.row.worksheet.workbook.styles.add_style({:alignment => {:horizontal => :center, :vertical => :center, :wrap_text => true}}  )
     @c.style = style
-    assert_equal(@c.autowidth, 5.5)
+    assert_in_delta(6.6, @c.autowidth, 0.01)
   end
 
   def test_time
@@ -70,6 +71,13 @@ class TestCell < Test::Unit::TestCase
     assert_equal(@c.value, now.to_time)
   end
 
+  def test_date
+    @c.type = :date
+    now = Time.now
+    @c.value = now
+    assert_equal(@c.value, now.to_date)
+  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}
@@ -99,6 +107,12 @@ class TestCell < Test::Unit::TestCase
 
   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, "1e1"), :float)
+    assert_equal(@c.send(:cell_type_from_value, "1e#{Float::MAX_10_EXP}"), :float)
+    assert_equal(@c.send(:cell_type_from_value, "1e#{Float::MAX_10_EXP + 1}"), :string)
+    assert_equal(@c.send(:cell_type_from_value, "1e-1"), :float)
+    assert_equal(@c.send(:cell_type_from_value, "1e#{Float::MIN_10_EXP}"), :float)
+    assert_equal(@c.send(:cell_type_from_value, "1e#{Float::MIN_10_EXP - 1}"), :string)
     assert_equal(@c.send(:cell_type_from_value, 1), :integer)
     assert_equal(@c.send(:cell_type_from_value, Date.today), :date)
     assert_equal(@c.send(:cell_type_from_value, Time.now), :time)
@@ -113,6 +127,31 @@ class TestCell < Test::Unit::TestCase
     assert_equal(:iso_8601, @c.send(:cell_type_from_value, '2008-08-30T01:45:36.123+09:00'))
   end
 
+  def test_cell_type_from_value_looks_like_number_but_is_not
+    mimic_number = Class.new do
+      def initialize(to_s_value)
+        @to_s_value = to_s_value
+      end
+
+      def to_s
+        @to_s_value
+      end
+    end
+
+    number_strings = [
+      '1',
+      '1234567890',
+      '1.0',
+      '1e1',
+      '0',
+      "1e#{Float::MIN_10_EXP}"
+    ]
+
+    number_strings.each do |number_string|
+      assert_equal(@c.send(:cell_type_from_value, mimic_number.new(number_string)), :string)
+    end
+  end
+
   def test_cast_value
     @c.type = :string
     assert_equal(@c.send(:cast_value, 1.0), "1.0")
@@ -321,6 +360,33 @@ class TestCell < Test::Unit::TestCase
     assert(doc.xpath("//f[text()='IF(2+2=4,4,5)']").any?)
   end
 
+  def test_to_xml_string_formula_escaped
+    p = Axlsx::Package.new
+    ws = p.workbook.add_worksheet do |sheet|
+      sheet.add_row ["=IF(2+2=4,4,5)"], escape_formulas: true
+    end
+    doc = Nokogiri::XML(ws.to_xml_string)
+    doc.remove_namespaces!
+    assert(doc.xpath("//t[text()='=IF(2+2=4,4,5)']").any?)
+  end
+
+  def test_to_xml_string_formula_escape_array_parameter
+    p = Axlsx::Package.new
+    ws = p.workbook.add_worksheet do |sheet|
+      sheet.add_row [
+        "=IF(2+2=4,4,5)",
+        "=IF(13+13=4,4,5)",
+        "=IF(99+99=4,4,5)"
+      ], escape_formulas: [true, false, true]
+    end
+    doc = Nokogiri::XML(ws.to_xml_string)
+    doc.remove_namespaces!
+
+    assert(doc.xpath("//t[text()='=IF(2+2=4,4,5)']").any?)
+    assert(doc.xpath("//f[text()='IF(13+13=4,4,5)']").any?)
+    assert(doc.xpath("//t[text()='=IF(99+99=4,4,5)']").any?)
+  end
+
   def test_to_xml_string_array_formula
     p = Axlsx::Package.new
     ws = p.workbook.add_worksheet do |sheet|