roo 2.7.0 → 2.8.3

data/test/excelx/cell/test_attr_reader_default.rb

@@ -0,0 +1,72 @@
+require "test_helper"
+
+class TestAttrReaderDefault < Minitest::Test
+  def base
+    Roo::Excelx::Cell::Base
+  end
+
+  def boolean
+    Roo::Excelx::Cell::Boolean
+  end
+
+  def class_date
+    Roo::Excelx::Cell::Date
+  end
+
+  def datetime
+    Roo::Excelx::Cell::DateTime
+  end
+
+  def empty
+    Roo::Excelx::Cell::Empty
+  end
+
+  def number
+    Roo::Excelx::Cell::Number
+  end
+
+  def string
+    Roo::Excelx::Cell::String
+  end
+
+  def base_date
+    ::Date.new(1899, 12, 30)
+  end
+
+  def base_timestamp
+    ::Date.new(1899, 12, 30).to_datetime.to_time.to_i
+  end
+
+  def class_time
+    Roo::Excelx::Cell::Time
+  end
+
+  def test_cell_default_values
+    assert_values base.new(nil, nil, [], 1, nil, nil), default_type: :base, :@default_type => nil, style: 1, :@style => nil
+    assert_values boolean.new("1", nil, nil, nil, nil), default_type: :boolean, :@default_type => nil, cell_type: :boolean, :@cell_type => nil
+    assert_values class_date.new("41791", nil, [:numeric_or_formula, "mm-dd-yy"], 6, nil, base_date, nil), default_type: :date, :@default_type => nil
+    assert_values class_time.new("0.521", nil, [:numeric_or_formula, "hh:mm"], 6, nil, base_timestamp, nil), default_type: :time, :@default_type => nil
+    assert_values datetime.new("41791.521", nil, [:numeric_or_formula, "mm-dd-yy hh:mm"], 6, nil, base_timestamp, nil), default_type: :datetime, :@default_type => nil
+    assert_values empty.new(nil), default_type: nil, :@default_type => nil, style: nil, :@style => nil
+    assert_values number.new("42", nil, ["0"], nil, nil, nil), default_type: :float, :@default_type => nil
+    assert_values string.new("1", nil, nil, nil, nil), default_type: :string, :@default_type => nil, cell_type: :string, :@cell_type => nil
+
+    assert_values base.new(nil, nil, [], 2, nil, nil), style: 2, :@style => 2
+  end
+
+  def assert_values(object, value_hash)
+    value_hash.each do |attr_name, expected_value|
+      value = if attr_name.to_s.include?("@")
+                object.instance_variable_defined?(attr_name) ? object.instance_variable_get(attr_name) : nil
+              else
+                object.public_send(attr_name)
+      end
+
+      if expected_value
+        assert_equal expected_value, value
+      else
+        assert_nil value
+      end
+    end
+  end
+end

data/test/excelx/cell/test_base.rb

@@ -25,6 +25,11 @@ class TestRooExcelxCellBase < Minitest::Test
     refute cell.empty?
   end
 
+  def test_presence
+    cell = base.new(value, nil, [], nil, nil, nil)
+    assert_equal cell, cell.presence
+  end
+
   def test_cell_type_is_formula
     formula = true
     cell = base.new(value, formula, [], nil, nil, nil)

data/test/excelx/cell/test_datetime.rb

@@ -2,12 +2,12 @@ require 'test_helper'
 
 class TestRooExcelxCellDateTime < Minitest::Test
   def test_cell_value_is_datetime
-    cell = datetime.new('30000.323212', nil, ['mm-dd-yy'], nil, nil, base_date, nil)
+    cell = datetime.new('30000.323212', nil, ['mm-dd-yy'], nil, nil, base_timestamp, nil)
     assert_kind_of ::DateTime, cell.value
   end
 
   def test_cell_type_is_datetime
-    cell = datetime.new('30000.323212', nil, [], nil, nil, base_date, nil)
+    cell = datetime.new('30000.323212', nil, [], nil, nil, base_timestamp, nil)
     assert_equal :datetime, cell.type
   end
 
@@ -19,7 +19,7 @@ class TestRooExcelxCellDateTime < Minitest::Test
       ['mmm-yy', 'JAN-15'],
       ['m/d/yy h:mm', '1/25/15 8:15']
     ].each do |format, formatted_value|
-      cell = datetime.new '42029.34375', nil, [format], nil, nil, base_date, nil
+      cell = datetime.new '42029.34375', nil, [format], nil, nil, base_timestamp, nil
       assert_equal formatted_value, cell.formatted_value
     end
   end
@@ -30,7 +30,7 @@ class TestRooExcelxCellDateTime < Minitest::Test
       ['h:mm:ss000 mm/yy', '8:15:00000 01/15'],
       ['mmm yyy', '2015-01-25 08:15:00']
     ].each do |format, formatted_value|
-      cell = datetime.new '42029.34375', nil, [format], nil, nil, base_date, nil
+      cell = datetime.new '42029.34375', nil, [format], nil, nil, base_timestamp, nil
       assert_equal formatted_value, cell.formatted_value
     end
   end
@@ -39,7 +39,7 @@ class TestRooExcelxCellDateTime < Minitest::Test
     Roo::Excelx::Cell::DateTime
   end
 
-  def base_date
-    Date.new(1899, 12, 30)
+  def base_timestamp
+    DateTime.new(1899, 12, 30).to_time.to_i
   end
 end

data/test/excelx/cell/test_empty.rb

@@ -4,4 +4,15 @@ class TestRooExcelxCellEmpty < Minitest::Test
   def empty
     Roo::Excelx::Cell::Empty
   end
+
+  def test_empty?
+    cell = empty.new(nil)
+    assert_same  true, cell.empty?
+  end
+
+  def test_nil_presence
+    cell = empty.new(nil)
+    assert_nil cell.presence
+  end
+
 end

data/test/excelx/cell/test_number.rb

@@ -25,6 +25,11 @@ class TestRooExcelxCellNumber < Minitest::Test
     assert_kind_of(Float, cell.value)
   end
 
+  def test_very_simple_scientific_notation
+    cell = Roo::Excelx::Cell::Number.new '1e6', nil, ['0'], nil, nil, nil
+    assert_kind_of(Float, cell.value)
+  end
+
   def test_percent
     cell = Roo::Excelx::Cell::Number.new '42.1', nil, ['0.00%'], nil, nil, nil
     assert_kind_of(Float, cell.value)
@@ -53,8 +58,12 @@ class TestRooExcelxCellNumber < Minitest::Test
   def test_formats
     [
       ['General', '1042'],
+      ['GENERAL', '1042'],
       ['0', '1042'],
+      ['000000', '001042'],
       ['0.00', '1042.00'],
+      ['0.0000', '1042.0000'],
+      ['0.000000000', '1042.000000000'],
       ['#,##0', '1,042'],
       ['#,##0.00', '1,042.00'],
       ['0%', '104200%'],

data/test/excelx/cell/test_string.rb

@@ -25,4 +25,24 @@ class TestRooExcelxCellString < Minitest::Test
     cell = string.new '0', nil, nil, nil, nil
     assert_equal '0', cell.value
   end
+
+  def test_not_empty?
+    cell = string.new '1', nil, nil, nil, nil
+    assert_equal false, cell.empty?
+  end
+
+  def test_empty?
+    cell = string.new '', nil, nil, nil, nil
+    assert_equal true, cell.empty?
+  end
+
+  def test_presence
+    cell = string.new '1', nil, nil, nil, nil
+    assert_equal cell, cell.presence
+  end
+
+  def test_nil_presence
+    cell = string.new '', nil, nil, nil, nil
+    assert_nil cell.presence
+  end
 end

data/test/excelx/cell/test_time.rb

@@ -5,8 +5,8 @@ class TestRooExcelxCellTime < Minitest::Test
     Roo::Excelx::Cell::Time
   end
 
-  def base_date
-    Date.new(1899, 12, 30)
+  def base_timestamp
+    DateTime.new(1899, 12, 30).to_time.to_i
   end
 
   def test_formatted_value
@@ -18,13 +18,13 @@ class TestRooExcelxCellTime < Minitest::Test
       ['[h]:mm:ss', '[1]:48:09'],
       ['mmss.0', '4809.0'] # Cell::Time always get rounded to the nearest second.
     ].each do |style_format, result|
-      cell = roo_time.new(value, nil, [:numeric_or_formula, style_format], 6, nil, base_date, nil)
+      cell = roo_time.new(value, nil, [:numeric_or_formula, style_format], 6, nil, base_timestamp, nil)
       assert_equal result, cell.formatted_value, "Style=#{style_format} is not properly formatted"
     end
   end
 
   def test_value
-    cell = roo_time.new('0.0751', nil, [:numeric_or_formula, 'h:mm'], 6, nil, base_date, nil)
+    cell = roo_time.new('0.0751', nil, [:numeric_or_formula, 'h:mm'], 6, nil, base_timestamp, nil)
     assert_kind_of Integer, cell.value
   end
 end

data/test/excelx/test_coordinate.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class TestRooExcelxCoordinate < Minitest::Test
+  def row
+    10
+  end
+
+  def column
+    20
+  end
+
+  def coordinate
+    Roo::Excelx::Coordinate.new(row, column)
+  end
+
+  def array
+    [row, column]
+  end
+
+  def test_row
+    assert_same  row, coordinate.row
+  end
+
+  def test_column
+    assert_same  column, coordinate.column
+  end
+
+  def test_frozen?
+    assert coordinate.frozen?
+  end
+
+  def test_equality
+    hash = {}
+    hash[coordinate] = true
+    assert hash.key?(coordinate)
+    assert hash.key?(array)
+  end
+
+  def test_expand
+    r, c = coordinate
+    assert_same row, r
+    assert_same column, c
+  end
+
+  def test_aref
+    assert_same row, coordinate[0]
+    assert_same column, coordinate[1]
+  end
+end

data/test/formatters/test_csv.rb

@@ -44,7 +44,7 @@ class TestRooFormatterCSV < Minitest::Test
   # wird.
   # Besser: Methode um temporaeres Dir. portabel zu bestimmen
   def test_huge_document_to_csv
-    skip unless ENV["LONG_RUN"]
+    skip_long_test
 
     original_csv_path = File.join(TESTDIR, "Bibelbund.csv")
     with_each_spreadsheet(name: "Bibelbund", format: [:openoffice, :excelx]) do |workbook|
@@ -71,7 +71,7 @@ class TestRooFormatterCSV < Minitest::Test
   end
 
   def test_bug_quotes_excelx
-    skip unless ENV["LONG_RUN"]
+    skip_long_test
     # TODO: run this test with a much smaller document
     with_each_spreadsheet(name: "Bibelbund", format: [:openoffice, :excelx]) do |workbook|
       workbook.default_sheet = workbook.sheets.first
@@ -100,6 +100,23 @@ class TestRooFormatterCSV < Minitest::Test
     end
   end
 
+  def test_bug_datetime_offset_change
+    # DO NOT REMOVE Asia/Calcutta
+    [nil, "US/Eastern", "US/Pacific", "Asia/Calcutta"].each do |zone|
+      with_timezone(zone) do
+        with_each_spreadsheet(name: "datetime_timezone_ist_offset_change", format: %i[excelx openoffice libreoffice]) do |workbook|
+          Dir.mktmpdir do |tempdir|
+            datetime_csv_file = File.join(tempdir, "datetime_timezone_ist_offset_change.csv")
+
+            assert workbook.to_csv(datetime_csv_file)
+            assert File.exist?(datetime_csv_file)
+            assert_equal "", file_diff("#{TESTDIR}/so_datetime_timezone_ist_offset_change.csv", datetime_csv_file)
+          end
+        end
+      end
+    end
+  end
+
   def test_true_class
     assert_equal "true", cell_to_csv(1, 1)
   end

data/test/formatters/test_xml.rb

@@ -3,20 +3,23 @@ require "test_helper"
 class TestRooFormatterXML < Minitest::Test
   def test_to_xml
     expected_sheet_count = 5
-    with_each_spreadsheet(name: "numbers1", encoding: "utf8") do |workbook|
+    options = { name: "numbers1", encoding: "utf8" }
+    with_each_spreadsheet(options) do |workbook|
       skip if defined? JRUBY_VERSION
       workbook.to_xml
       sheetname = workbook.sheets.first
       doc = Nokogiri::XML(workbook.to_xml)
-      all_cells = init_all_cells(workbook, sheetname)
 
       assert_equal expected_sheet_count, doc.xpath("//spreadsheet/sheet").count
 
       doc.xpath("//spreadsheet/sheet").each do |xml_sheet|
-        assert_equal sheetname, xml_sheet.attributes["name"].value
-        xml_sheet.children.each_with_index do |cell, i|
-          next unless cell.attributes["name"]
+        all_cells = init_all_cells(workbook, sheetname)
+        cells = xml_sheet.children.reject(&:text?)
 
+        assert_equal sheetname, xml_sheet["name"]
+        assert_equal all_cells.size, cells.size
+
+        cells.each_with_index do |cell, i|
           expected = [
             all_cells[i][:row],
             all_cells[i][:column],
@@ -24,11 +27,12 @@ class TestRooFormatterXML < Minitest::Test
             all_cells[i][:type],
           ]
           result = [
-            cell.attributes["row"],
-            cell.attributes["column"],
-            cell.content,
-            cell.attributes["type"],
+            cell["row"],
+            cell["column"],
+            cell.text,
+            cell["type"],
           ]
+
           assert_equal expected, result
         end # end of sheet
         sheetname = workbook.sheets[workbook.sheets.index(sheetname) + 1]

data/test/helpers/test_accessing_files.rb

@@ -0,0 +1,60 @@
+# Tests for "Accessing Files" which includes opening and closing files.
+module TestAccesingFiles
+  def test_close
+    with_each_spreadsheet(name: "numbers1") do |oo|
+      next unless (tempdir = oo.instance_variable_get("@tmpdir"))
+      oo.close
+      refute File.exist?(tempdir), "Expected #{tempdir} to be cleaned up"
+    end
+  end
+
+  # NOTE: Ruby 2.4.0 changed the way GC works. The last Roo object created by
+  #       with_each_spreadsheet wasn't getting GC'd until after the process
+  #       ended.
+  #
+  #       That behavior change broke this test. In order to fix it, I forked the
+  #       process and passed the temp directories from the forked process in
+  #       order to check if they were removed properly.
+  def test_finalize
+    skip if defined? JRUBY_VERSION
+
+    read, write = IO.pipe
+    pid = Process.fork do
+      with_each_spreadsheet(name: "numbers1") do |oo|
+        write.puts oo.instance_variable_get("@tmpdir")
+      end
+    end
+
+    Process.wait(pid)
+    write.close
+    tempdirs = read.read.split("\n")
+    read.close
+
+    refute tempdirs.empty?
+    tempdirs.each do |tempdir|
+      refute File.exist?(tempdir), "Expected #{tempdir} to be cleaned up"
+    end
+  end
+
+  def test_cleanup_on_error
+    # NOTE: This test was occasionally failing because when it started running
+    #       other tests would have already added folders to the temp directory,
+    #       polluting the directory. You'd end up in a situation where there
+    #       would be less folders AFTER this ran than originally started.
+    #
+    #       Instead, just use a custom temp directory to test the functionality.
+    ENV["ROO_TMP"] = Dir.tmpdir + "/test_cleanup_on_error"
+    Dir.mkdir(ENV["ROO_TMP"]) unless File.exist?(ENV["ROO_TMP"])
+    expected_dir_contents = Dir.open(ENV["ROO_TMP"]).to_a
+    with_each_spreadsheet(name: "non_existent_file", ignore_errors: true) {}
+
+    assert_equal expected_dir_contents, Dir.open(ENV["ROO_TMP"]).to_a
+    Dir.rmdir ENV["ROO_TMP"] if File.exist?(ENV["ROO_TMP"])
+    ENV.delete "ROO_TMP"
+  end
+
+  def test_name_with_leading_slash
+    xlsx = Roo::Excelx.new(File.join(TESTDIR, "/name_with_leading_slash.xlsx"))
+    assert_equal 1, xlsx.sheets.count
+  end
+end

data/test/helpers/test_comments.rb

@@ -0,0 +1,43 @@
+module TestComments
+  def test_comment
+    options = { name: "comments", format: [:openoffice, :libreoffice, :excelx] }
+    with_each_spreadsheet(options) do |oo|
+      assert_equal "Kommentar fuer B4", oo.comment("b", 4)
+      assert_equal "Kommentar fuer B5", oo.comment("b", 5)
+    end
+  end
+
+  def test_no_comment
+    options = { name: "comments", format: [:openoffice, :excelx] }
+    with_each_spreadsheet(options) do |oo|
+      # There are no comments at the second sheet.
+      assert_nil oo.comment("b", 4, oo.sheets[1])
+    end
+  end
+
+  def test_comments
+    options = { name: "comments", format: [:openoffice, :libreoffice, :excelx] }
+    expexted_comments = [
+      [4, 2, "Kommentar fuer B4"],
+      [5, 2, "Kommentar fuer B5"],
+    ]
+
+    with_each_spreadsheet(options) do |oo|
+      assert_equal expexted_comments, oo.comments(oo.sheets.first), "comments error in class #{oo.class}"
+    end
+  end
+
+  def test_empty_sheet_comments
+    options = { name: "emptysheets", format: [:openoffice, :excelx] }
+    with_each_spreadsheet(options) do |oo|
+      assert_equal [], oo.comments, "An empty sheet's formulas should be an empty array"
+    end
+  end
+
+  def test_comments_from_google_sheet_exported_as_xlsx
+    expected_comments = [[1, 1, "this is a comment\n\t-Steven Daniels"]]
+    with_each_spreadsheet(name: "comments-google", format: [:excelx]) do |oo|
+      assert_equal expected_comments, oo.comments(oo.sheets.first), "comments error in class #{oo.class}"
+    end
+  end
+end

data/test/helpers/test_formulas.rb

@@ -0,0 +1,9 @@
+module TestFormulas
+  def test_empty_sheet_formulas
+    options = { name: "emptysheets", format: [:openoffice, :excelx] }
+    with_each_spreadsheet(options) do |oo|
+      oo.default_sheet = oo.sheets.first
+      assert_equal [], oo.formulas, "An empty sheet's formulas should be an empty array"
+    end
+  end
+end

data/test/helpers/test_labels.rb

@@ -0,0 +1,103 @@
+module TestLabels
+  def test_labels
+    options = { name: "named_cells", format: [:openoffice, :excelx, :libreoffice] }
+    expected_labels = [
+      ["anton", [5, 3, "Sheet1"]],
+      ["berta", [4, 2, "Sheet1"]],
+      ["caesar", [7, 2, "Sheet1"]],
+    ]
+    with_each_spreadsheet(options) do |oo|
+      assert_equal expected_labels, oo.labels, "error with labels array in class #{oo.class}"
+    end
+  end
+
+  def test_labeled_cells
+    options = { name: "named_cells", format: [:openoffice, :excelx, :libreoffice] }
+    with_each_spreadsheet(options) do |oo|
+      oo.default_sheet = oo.sheets.first
+      begin
+        row, col = oo.label("anton")
+      rescue ArgumentError
+        puts "labels error at #{oo.class}"
+        raise
+      end
+      assert_equal 5, row
+      assert_equal 3, col
+
+      row, col = oo.label("anton")
+      assert_equal "Anton", oo.cell(row, col)
+
+      row, col = oo.label("berta")
+      assert_equal "Bertha", oo.cell(row, col)
+
+      row, col = oo.label("caesar")
+      assert_equal "Cäsar", oo.cell(row, col)
+
+      row, col = oo.label("never")
+      assert_nil row
+      assert_nil col
+
+      row, col, sheet = oo.label("anton")
+      assert_equal 5, row
+      assert_equal 3, col
+      assert_equal "Sheet1", sheet
+
+      assert_equal "Anton", oo.anton
+      assert_raises(NoMethodError) do
+        row, col = oo.never
+      end
+
+      # Reihenfolge row, col,sheet analog zu #label
+      expected_labels = [
+        ["anton", [5, 3, "Sheet1"]],
+        ["berta", [4, 2, "Sheet1"]],
+        ["caesar", [7, 2, "Sheet1"]],
+      ]
+      assert_equal expected_labels, oo.labels, "error with labels array in class #{oo.class}"
+    end
+  end
+
+  def test_label
+    options = { name: "named_cells", format: [:openoffice, :excelx, :libreoffice] }
+    with_each_spreadsheet(options) do |oo|
+      begin
+        row, col = oo.label("anton")
+      rescue ArgumentError
+        puts "labels error at #{oo.class}"
+        raise
+      end
+
+      assert_equal 5, row, "error with label in class #{oo.class}"
+      assert_equal 3, col, "error with label in class #{oo.class}"
+
+      row, col = oo.label("anton")
+      assert_equal "Anton", oo.cell(row, col), "error with label in class #{oo.class}"
+
+      row, col = oo.label("berta")
+      assert_equal "Bertha", oo.cell(row, col), "error with label in class #{oo.class}"
+
+      row, col = oo.label("caesar")
+      assert_equal "Cäsar", oo.cell(row, col), "error with label in class #{oo.class}"
+
+      row, col = oo.label("never")
+      assert_nil row
+      assert_nil col
+
+      row, col, sheet = oo.label("anton")
+      assert_equal 5, row
+      assert_equal 3, col
+      assert_equal "Sheet1", sheet
+    end
+  end
+
+  def test_method_missing_anton
+    options = { name: "named_cells", format: [:openoffice, :excelx, :libreoffice] }
+    with_each_spreadsheet(options) do |oo|
+      # oo.default_sheet = oo.sheets.first
+      assert_equal "Anton", oo.anton
+      assert_raises(NoMethodError) do
+        oo.never
+      end
+    end
+  end
+end

data/test/helpers/test_sheets.rb

@@ -0,0 +1,55 @@
+# NOTE: Putting these tests into modules in order to share them across different
+#       test classes, i.e. both TestRooExcelx and TestRooOpenOffice should run
+#       sheet related tests.
+#
+#       This will allow me to reuse these test cases when I add new classes for
+#       Roo's future API.
+# Sheet related tests
+module TestSheets
+  def test_sheets
+    sheet_names = ["Tabelle1", "Name of Sheet 2", "Sheet3", "Sheet4", "Sheet5"]
+    with_each_spreadsheet(name: "numbers1") do |oo|
+      assert_equal sheet_names, oo.sheets
+      assert_raises(RangeError) { oo.default_sheet = "no_sheet" }
+      assert_raises(TypeError)  { oo.default_sheet = [1, 2, 3] }
+      oo.sheets.each do |sheet_name|
+        oo.default_sheet = sheet_name
+        assert_equal sheet_name, oo.default_sheet
+      end
+    end
+  end
+
+  def test_sheetname
+    bad_sheet_name = "non existing sheet name"
+    with_each_spreadsheet(name: "numbers1") do |oo|
+      oo.default_sheet = "Name of Sheet 2"
+      assert_equal "I am sheet 2", oo.cell("C", 5)
+      assert_raises(RangeError) { oo.default_sheet = bad_sheet_name }
+      assert_raises(RangeError) { oo.default_sheet = bad_sheet_name }
+      assert_raises(RangeError) { oo.cell("C", 5, bad_sheet_name) }
+      assert_raises(RangeError) { oo.celltype("C", 5, bad_sheet_name) }
+      assert_raises(RangeError) { oo.empty?("C", 5, bad_sheet_name) }
+      assert_raises(RangeError) { oo.formula?("C", 5, bad_sheet_name) }
+      assert_raises(RangeError) { oo.formula("C", 5, bad_sheet_name) }
+      assert_raises(RangeError) { oo.set("C", 5, 42, bad_sheet_name) }
+      assert_raises(RangeError) { oo.formulas(bad_sheet_name) }
+      assert_raises(RangeError) { oo.to_yaml({}, 1, 1, 1, 1, bad_sheet_name) }
+    end
+  end
+
+  def test_info_doesnt_set_default_sheet
+    sheet_name = "Sheet3"
+    with_each_spreadsheet(name: "numbers1") do |oo|
+      oo.default_sheet = sheet_name
+      oo.info
+      assert_equal sheet_name, oo.default_sheet
+    end
+  end
+
+  def test_bug_numbered_sheet_names
+    options = { name: "bug-numbered-sheet-names", format: :excelx }
+    with_each_spreadsheet(options) do |oo|
+      oo.each_with_pagename {}
+    end
+  end
+end