roo 2.6.0 → 2.7.0

data/lib/roo/tempdir.rb

@@ -2,7 +2,7 @@ module Roo
   module Tempdir
     def finalize_tempdirs(object_id)
       if @tempdirs && (dirs_to_remove = @tempdirs[object_id])
-        @tempdirs[object_id] = nil
+        @tempdirs.delete(object_id)
         dirs_to_remove.each do |dir|
           ::FileUtils.remove_entry(dir)
         end
@@ -10,16 +10,11 @@ module Roo
     end
 
     def make_tempdir(object, prefix, root)
-      root ||= ENV['ROO_TMP']
-      # folder is cleaned up in .finalize_tempdirs
+      root ||= ENV["ROO_TMP"]
+      # NOTE: This folder is cleaned up by finalize_tempdirs.
       ::Dir.mktmpdir("#{Roo::TEMP_PREFIX}#{prefix}", root).tap do |tmpdir|
-        @tempdirs ||= {}
-        if @tempdirs[object.object_id]
-          @tempdirs[object.object_id] << tmpdir
-        else
-          @tempdirs[object.object_id] = [tmpdir]
-          ObjectSpace.define_finalizer(object, method(:finalize_tempdirs))
-        end
+        @tempdirs ||= Hash.new { |h, k| h[k] = [] }
+        @tempdirs[object.object_id] << tmpdir
       end
     end
   end

data/lib/roo/version.rb

@@ -1,3 +1,3 @@
 module Roo
-  VERSION = "2.6.0"
+  VERSION = "2.7.0"
 end

data/roo.gemspec

@@ -22,4 +22,5 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency 'rake', '~> 10.1'
   spec.add_development_dependency 'minitest', '~> 5.4', '>= 5.4.3'
+  spec.add_development_dependency 'rack', '~> 1.6', '< 2.0.0'
 end

data/spec/spec_helper.rb

@@ -1,13 +1,9 @@
 require 'simplecov'
 require 'roo'
-require 'vcr'
 require 'helpers'
 
 RSpec.configure do |c|
   c.include Helpers
-end
-
-VCR.configure do |c|
-  c.cassette_library_dir = 'spec/fixtures/vcr_cassettes'
-  c.hook_into :webmock # or :fakeweb
+  c.color = true
+  c.formatter = :documentation
 end

data/test/excelx/cell/test_time.rb

@@ -1,7 +1,7 @@
 require 'test_helper'
 
 class TestRooExcelxCellTime < Minitest::Test
-  def time
+  def roo_time
     Roo::Excelx::Cell::Time
   end
 
@@ -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 = 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_date, nil)
       assert_equal result, cell.formatted_value, "Style=#{style_format} is not properly formatted"
     end
   end
 
   def test_value
-    cell = 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_date, nil)
     assert_kind_of Integer, cell.value
   end
 end

data/test/formatters/test_csv.rb

@@ -0,0 +1,119 @@
+require "test_helper"
+
+class TestRooFormatterCSV < Minitest::Test
+  def test_date_time_to_csv
+    with_each_spreadsheet(name: "time-test") do |workbook|
+      Dir.mktmpdir do |tempdir|
+        csv_output = File.join(tempdir, "time_test.csv")
+        assert workbook.to_csv(csv_output)
+        assert File.exist?(csv_output)
+        assert_equal "", `diff --strip-trailing-cr #{TESTDIR}/time-test.csv #{csv_output}`
+        # --strip-trailing-cr is needed because the test-file use 0A and
+        # the test on an windows box generates 0D 0A as line endings
+      end
+    end
+  end
+
+  def test_boolean_to_csv
+    with_each_spreadsheet(name: "boolean") do |workbook|
+      Dir.mktmpdir do |tempdir|
+        csv_output = File.join(tempdir,"boolean.csv")
+        assert workbook.to_csv(csv_output)
+        assert File.exist?(csv_output)
+        assert_equal "", `diff --strip-trailing-cr #{TESTDIR}/boolean.csv #{csv_output}`
+        # --strip-trailing-cr is needed because the test-file use 0A and
+        # the test on an windows box generates 0D 0A as line endings
+      end
+    end
+  end
+
+  def test_link_to_csv
+    with_each_spreadsheet(name: "link", format: :excelx) do |workbook|
+      Dir.mktmpdir do |tempdir|
+        csv_output = File.join(tempdir, "link.csv")
+        assert workbook.to_csv(csv_output)
+        assert File.exist?(csv_output)
+        assert_equal "", `diff --strip-trailing-cr #{TESTDIR}/link.csv #{csv_output}`
+        # --strip-trailing-cr is needed because the test-file use 0A and
+        # the test on an windows box generates 0D 0A as line endings
+      end
+    end
+  end
+
+  # "/tmp/xxxx" darf man unter Windows nicht verwenden, weil das nicht erkannt
+  # wird.
+  # Besser: Methode um temporaeres Dir. portabel zu bestimmen
+  def test_huge_document_to_csv
+    skip unless ENV["LONG_RUN"]
+
+    original_csv_path = File.join(TESTDIR, "Bibelbund.csv")
+    with_each_spreadsheet(name: "Bibelbund", format: [:openoffice, :excelx]) do |workbook|
+      Dir.mktmpdir do |tempdir|
+        new_csv_path = File.join(tempdir, "Bibelbund.csv")
+        assert_equal "Tagebuch des Sekret\303\244rs.    Letzte Tagung 15./16.11.75 Schweiz", workbook.cell(45, "A")
+        assert_equal "Tagebuch des Sekret\303\244rs.  Nachrichten aus Chile", workbook.cell(46, "A")
+        assert_equal "Tagebuch aus Chile  Juli 1977", workbook.cell(55, "A")
+        assert workbook.to_csv(new_csv_path)
+        assert File.exist?(new_csv_path)
+        assert FileUtils.identical?(original_csv_path, new_csv_path), "error in class #{workbook.class}"
+      end
+    end
+  end
+
+  def test_bug_empty_sheet
+    with_each_spreadsheet(name: "formula", format: [:openoffice, :excelx]) do |workbook|
+      workbook.default_sheet = "Sheet3" # is an empty sheet
+      Dir.mktmpdir do |tempdir|
+        workbook.to_csv(File.join(tempdir, "emptysheet.csv"))
+        assert_equal "", `cat #{File.join(tempdir, "emptysheet.csv")}`
+      end
+    end
+  end
+
+  def test_bug_quotes_excelx
+    skip unless ENV["LONG_RUN"]
+    # 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
+      assert_equal(
+        'Einflüsse der neuen Theologie in "de gereformeerde Kerken van Nederland"',
+        workbook.cell("A", 76)
+      )
+      workbook.to_csv("csv#{$$}")
+      assert_equal(
+        'Einflüsse der neuen Theologie in "de gereformeerde Kerken van Nederland"',
+        workbook.cell("A", 78)
+      )
+      File.delete_if_exist("csv#{$$}")
+    end
+  end
+
+  def test_bug_datetime_to_csv
+    with_each_spreadsheet(name: "datetime") do |workbook|
+      Dir.mktmpdir do |tempdir|
+        datetime_csv_file = File.join(tempdir, "datetime.csv")
+
+        assert workbook.to_csv(datetime_csv_file)
+        assert File.exist?(datetime_csv_file)
+        assert_equal "", file_diff("#{TESTDIR}/so_datetime.csv", datetime_csv_file)
+      end
+    end
+  end
+
+  def test_true_class
+    assert_equal "true", cell_to_csv(1, 1)
+  end
+
+  def test_false_class
+    assert_equal "false", cell_to_csv(2, 1)
+  end
+
+  def test_date_class
+    assert_equal "2017-01-01", cell_to_csv(3, 1)
+  end
+
+  def cell_to_csv(row, col)
+    filename = File.join(TESTDIR, "formula_cell_types.xlsx")
+    Roo::Spreadsheet.open(filename).send("cell_to_csv", row, col, "Sheet1")
+  end
+end

data/test/formatters/test_matrix.rb

@@ -0,0 +1,76 @@
+require "test_helper"
+require "matrix"
+
+class TestRooFormatterMatrix < Minitest::Test
+  def test_matrix
+    expected_result = Matrix[
+      [1.0, 2.0, 3.0],
+      [4.0, 5.0, 6.0],
+      [7.0, 8.0, 9.0]
+    ]
+    with_each_spreadsheet(name: "matrix", format: :openoffice) do |workbook|
+      workbook.default_sheet = workbook.sheets.first
+      assert_equal expected_result, workbook.to_matrix
+    end
+  end
+
+  def test_matrix_selected_range
+    expected_result = Matrix[
+      [1.0, 2.0, 3.0],
+      [4.0, 5.0, 6.0],
+      [7.0, 8.0, 9.0]
+    ]
+    with_each_spreadsheet(name: "matrix", format: :openoffice) do |workbook|
+      workbook.default_sheet = "Sheet2"
+      assert_equal expected_result, workbook.to_matrix(3, 4, 5, 6)
+    end
+  end
+
+  def test_matrix_all_nil
+    expected_result = Matrix[
+      [nil, nil, nil],
+      [nil, nil, nil],
+      [nil, nil, nil]
+    ]
+    with_each_spreadsheet(name: "matrix", format: :openoffice) do |workbook|
+      workbook.default_sheet = "Sheet2"
+      assert_equal expected_result, workbook.to_matrix(10, 10, 12, 12)
+    end
+  end
+
+  def test_matrix_values_and_nil
+    expected_result = Matrix[
+      [1.0, nil, 3.0],
+      [4.0, 5.0, 6.0],
+      [7.0, 8.0, nil]
+    ]
+    with_each_spreadsheet(name: "matrix", format: :openoffice) do |workbook|
+      workbook.default_sheet = "Sheet3"
+      assert_equal expected_result, workbook.to_matrix(1, 1, 3, 3)
+    end
+  end
+
+  def test_matrix_specifying_sheet
+    expected_result = Matrix[
+      [1.0, nil, 3.0],
+      [4.0, 5.0, 6.0],
+      [7.0, 8.0, nil]
+    ]
+    with_each_spreadsheet(name: "matrix", format: :openoffice) do |workbook|
+      workbook.default_sheet = workbook.sheets.first
+      assert_equal expected_result, workbook.to_matrix(nil, nil, nil, nil, "Sheet3")
+    end
+  end
+
+  # #to_matrix of an empty sheet should return an empty matrix and not result in
+  # an error message
+  # 2011-06-25
+  def test_bug_to_matrix_empty_sheet
+    options = { name: "emptysheets", format: [:openoffice, :excelx] }
+    with_each_spreadsheet(options) do |workbook|
+      workbook.default_sheet = workbook.sheets.first
+      workbook.to_matrix
+      assert_equal(Matrix.empty(0, 0), workbook.to_matrix)
+    end
+  end
+end

data/test/formatters/test_xml.rb

@@ -0,0 +1,74 @@
+require "test_helper"
+
+class TestRooFormatterXML < Minitest::Test
+  def test_to_xml
+    expected_sheet_count = 5
+    with_each_spreadsheet(name: "numbers1", encoding: "utf8") 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"]
+
+          expected = [
+            all_cells[i][:row],
+            all_cells[i][:column],
+            all_cells[i][:content],
+            all_cells[i][:type],
+          ]
+          result = [
+            cell.attributes["row"],
+            cell.attributes["column"],
+            cell.content,
+            cell.attributes["type"],
+          ]
+          assert_equal expected, result
+        end # end of sheet
+        sheetname = workbook.sheets[workbook.sheets.index(sheetname) + 1]
+      end
+    end
+  end
+
+  def test_bug_to_xml_with_empty_sheets
+    with_each_spreadsheet(name: "emptysheets", format: [:openoffice, :excelx]) do |workbook|
+      workbook.sheets.each do |sheet|
+        assert_nil workbook.first_row, "first_row not nil in sheet #{sheet}"
+        assert_nil workbook.last_row, "last_row not nil in sheet #{sheet}"
+        assert_nil workbook.first_column, "first_column not nil in sheet #{sheet}"
+        assert_nil workbook.last_column, "last_column not nil in sheet #{sheet}"
+        assert_nil workbook.first_row(sheet), "first_row not nil in sheet #{sheet}"
+        assert_nil workbook.last_row(sheet), "last_row not nil in sheet #{sheet}"
+        assert_nil workbook.first_column(sheet), "first_column not nil in sheet #{sheet}"
+        assert_nil workbook.last_column(sheet), "last_column not nil in sheet #{sheet}"
+      end
+      workbook.to_xml
+    end
+  end
+
+  # Erstellt eine Liste aller Zellen im Spreadsheet. Dies ist nötig, weil ein einfacher
+  # Textvergleich des XML-Outputs nicht funktioniert, da xml-builder die Attribute
+  # nicht immer in der gleichen Reihenfolge erzeugt.
+  def init_all_cells(workbook, sheet)
+    all = []
+    workbook.first_row(sheet).upto(workbook.last_row(sheet)) do |row|
+      workbook.first_column(sheet).upto(workbook.last_column(sheet)) do |col|
+        next if workbook.empty?(row, col, sheet)
+
+        all << {
+          row: row.to_s,
+          column: col.to_s,
+          content: workbook.cell(row, col, sheet).to_s,
+          type: workbook.celltype(row, col, sheet).to_s,
+        }
+      end
+    end
+    all
+  end
+end

data/test/formatters/test_yaml.rb

@@ -0,0 +1,20 @@
+require "test_helper"
+
+class TestRooFormatterYAML < Minitest::Test
+  def test_date_time_yaml
+    name = "time-test"
+    expected = File.open(TESTDIR + "/expected_results/#{name}.yml").read
+    with_each_spreadsheet(name: name) do |workbook|
+      assert_equal expected, workbook.to_yaml
+    end
+  end
+
+  def test_bug_to_yaml_empty_sheet
+    formats = [:openoffice, :excelx]
+    with_each_spreadsheet(name: "emptysheets", format: formats) do |workbook|
+      workbook.default_sheet = workbook.sheets.first
+      workbook.to_yaml
+      assert_equal "", workbook.to_yaml
+    end
+  end
+end

data/test/roo/test_csv.rb

@@ -0,0 +1,52 @@
+require 'test_helper'
+
+class TestRooCSV < Minitest::Test
+  def test_sheets
+    file = filename("numbers1")
+    workbook = roo_class.new(File.join(TESTDIR, file))
+    assert_equal ["default"], workbook.sheets
+    assert_raises(RangeError) { workbook.default_sheet = "no_sheet" }
+    assert_raises(TypeError)  { workbook.default_sheet = [1, 2, 3] }
+    workbook.sheets.each do |sh|
+      workbook.default_sheet = sh
+      assert_equal sh, workbook.default_sheet
+    end
+  end
+
+  def test_nil_rows_and_lines_csv
+    # x_123
+    oo = Roo::CSV.new(File.join(TESTDIR,'Bibelbund.csv'))
+    oo.default_sheet = oo.sheets.first
+    assert_equal 1, oo.first_row
+    assert_equal 3735, oo.last_row
+    assert_equal 1, oo.first_column
+    assert_equal 8, oo.last_column
+  end
+
+  def test_empty_csv
+    # x_123
+    oo = Roo::CSV.new(File.join(TESTDIR,'emptysheets.csv'))
+    oo.default_sheet = oo.sheets.first
+    assert_equal 1, oo.first_row
+    assert_equal 1, oo.last_row
+    assert_equal 1, oo.first_column
+    assert_equal 1, oo.last_column
+  end
+
+  def test_csv_parsing_with_headers
+    return unless CSV
+    headers = ["TITEL", "VERFASSER", "OBJEKT", "NUMMER", "SEITE", "INTERNET", "PC", "KENNUNG"]
+
+    oo = Roo::Spreadsheet.open(File.join(TESTDIR, "Bibelbund.csv"))
+    parsed = oo.parse(headers: true)
+    assert_equal headers, parsed[1].keys
+  end
+
+  def roo_class
+    Roo::CSV
+  end
+
+  def filename(name)
+    "#{name}.csv"
+  end
+end

data/test/roo/test_excelx.rb

@@ -0,0 +1,186 @@
+require "test_helper"
+
+class TestRooExcelx < Minitest::Test
+  def test_download_uri_with_invalid_host
+    assert_raises(RuntimeError) do
+      Roo::Excelx.new("http://example.com/file.xlsx")
+    end
+  end
+
+  def test_download_uri_with_query_string
+    file = filename("simple_spreadsheet")
+    port = 12_344
+    url = "#{local_server(port)}/#{file}?query-param=value"
+
+    start_local_server(file, port) do
+      spreadsheet = roo_class.new(url)
+      assert_equal "Task 1", spreadsheet.cell("f", 4)
+    end
+  end
+
+  def test_should_raise_file_not_found_error
+    assert_raises(IOError) do
+      Roo::Excelx.new(File.join("testnichtvorhanden", "Bibelbund.xlsx"))
+    end
+  end
+
+  def test_file_warning_default
+    assert_raises(TypeError) { Roo::Excelx.new(File.join(TESTDIR, "numbers1.ods")) }
+    assert_raises(TypeError) { Roo::Excelx.new(File.join(TESTDIR, "numbers1.xls")) }
+  end
+
+  def test_file_warning_error
+    %w(ods xls).each do |extension|
+      assert_raises(TypeError) do
+        options = { packed: false, file_warning: :error }
+        Roo::Excelx.new(File.join(TESTDIR, "numbers1. #{extension}"), options)
+      end
+    end
+  end
+
+  def test_file_warning_warning
+    options = { packed: false, file_warning: :warning }
+    assert_raises(ArgumentError) do
+      Roo::Excelx.new(File.join(TESTDIR, "numbers1.ods"), options)
+    end
+  end
+
+  def test_file_warning_ignore
+    options = { packed: false, file_warning: :ignore }
+    sheet = Roo::Excelx.new(File.join(TESTDIR, "type_excelx.ods"), options)
+    assert sheet, "Should not throw an error"
+  end
+
+  def test_bug_xlsx_reference_cell
+    # NOTE: If cell A contains a string and cell B references cell A.  When
+    #       reading the value of cell B, the result will be "0.0" instead of the
+    #       value of cell A.
+    #
+    # Before this test case, the following code:
+    #
+    # spreadsheet = Roo::Excelx.new("formula_string_error.xlsx")
+    # spreadsheet.default_sheet = "sheet1"
+    # p "A: #{spreadsheet.cell(1, 1)}" #=> "A: TestString"
+    # p "B: #{spreadsheet.cell(2, 1)}" #=> "B: 0.0"
+    #
+    # where the expected result is
+    # "A: TestString"
+    # "B: TestString"
+    xlsx = Roo::Excelx.new(File.join(TESTDIR, "formula_string_error.xlsx"))
+    assert_equal "Teststring", xlsx.cell("a", 1)
+    assert_equal "Teststring", xlsx.cell("a", 2)
+  end
+
+  def test_parsing_xslx_from_numbers
+    xlsx = Roo::Excelx.new(File.join(TESTDIR, "numbers-export.xlsx"))
+
+    xlsx.default_sheet = xlsx.sheets.first
+    assert_equal "Sheet 1", xlsx.cell("a", 1)
+
+    # Another buggy behavior of Numbers 3.1: if a warkbook has more than a
+    # single sheet, all sheets except the first one will have an extra row and
+    # column added to the beginning. That's why we assert against cell B2 and
+    # not A1
+    xlsx.default_sheet = xlsx.sheets.last
+    assert_equal "Sheet 2", xlsx.cell("b", 2)
+  end
+
+  def assert_cell_range_values(sheet, row_range, column_range, is_merged_range, expected_value)
+    row_range.each do |row|
+      column_range.each do |col|
+        value = sheet.cell(col, row)
+        if is_merged_range.call(row, col)
+          assert_equal expected_value, value
+        else
+          assert_nil value
+        end
+      end
+    end
+  end
+
+  def test_expand_merged_range
+    options = { expand_merged_ranges: true }
+    xlsx = Roo::Excelx.new(File.join(TESTDIR, "merged_ranges.xlsx"), options)
+
+    [
+      {
+        rows: (3..7),
+        columns: ("a".."b"),
+        conditional: ->(row, col) { row > 3 && row < 7 && col == "a" },
+        expected_value: "vertical1"
+      },
+      {
+        rows: (3..11),
+        columns: ("f".."h"),
+        conditional: ->(row, col) { row > 3 && row < 11 && col == "g" },
+        expected_value: "vertical2"
+      },
+      {
+        rows: (3..5),
+        columns: ("b".."f"),
+        conditional: ->(row, col) { row == 4 && col > "b" && col < "f" },
+        expected_value: "horizontal"
+      },
+      {
+        rows: (8..13),
+        columns: ("a".."e"),
+        conditional: ->(row, col) { row > 8 && row < 13 && col > "a" && col < "e" },
+        expected_value: "block"
+      }
+    ].each do |data|
+      rows, cols, conditional, expected_value = data.values
+      assert_cell_range_values(xlsx, rows, cols, conditional, expected_value)
+    end
+  end
+
+  def test_noexpand_merged_range
+    xlsx = Roo::Excelx.new(File.join(TESTDIR, "merged_ranges.xlsx"))
+
+    [
+      {
+        rows: (3..7),
+        columns: ("a".."b"),
+        conditional: ->(row, col) { row == 4 && col == "a" },
+        expected_value: "vertical1"
+      },
+      {
+        rows: (3..11),
+        columns: ("f".."h"),
+        conditional: ->(row, col) { row == 4 && col == "g" },
+        expected_value: "vertical2"
+      },
+      {
+        rows: (3..5),
+        columns: ("b".."f"),
+        conditional: ->(row, col) { row == 4 && col == "c" },
+        expected_value: "horizontal"
+      },
+      {
+        rows: (8..13),
+        columns: ("a".."e"),
+        conditional: ->(row, col) { row == 9 && col == "b" },
+        expected_value: "block"
+      }
+    ].each do |data|
+      rows, cols, conditional, expected_value = data.values
+      assert_cell_range_values(xlsx, rows, cols, conditional, expected_value)
+    end
+  end
+
+  def test_open_stream
+    file = filename(:numbers1)
+    file_contents = File.read File.join(TESTDIR, file), encoding: "BINARY"
+    stream = StringIO.new(file_contents)
+    xlsx = Roo::Excelx.new(stream)
+    expected_sheet_names = ["Tabelle1", "Name of Sheet 2", "Sheet3", "Sheet4", "Sheet5"]
+    assert_equal expected_sheet_names, xlsx.sheets
+  end
+
+  def roo_class
+    Roo::Excelx
+  end
+
+  def filename(name)
+    "#{name}.xlsx"
+  end
+end