roo 1.13.2 → 2.7.0

data/spec/lib/roo/libreoffice_spec.rb

@@ -2,18 +2,28 @@ require 'spec_helper'
 
 describe Roo::LibreOffice do
   describe '.new' do
-    subject {
+    subject do
       Roo::LibreOffice.new('test/files/numbers1.ods')
-    }
+    end
 
     it 'creates an instance' do
       expect(subject).to be_a(Roo::LibreOffice)
     end
   end
-end
 
-describe Roo::Libreoffice do
-  it 'is an alias of LibreOffice' do
-    expect(Roo::Libreoffice).to eq(Roo::LibreOffice)
+  describe '#sheets' do
+    let(:path) { 'test/files/hidden_sheets.ods' }
+
+    describe 'showing all sheets' do
+      it 'returns the expected result' do
+        expect(Roo::LibreOffice.new(path).sheets).to eq ["HiddenSheet1", "VisibleSheet1", "HiddenSheet2"]
+      end
+    end
+
+    describe 'only showing visible sheets' do
+      it 'returns the expected result' do
+        expect(Roo::LibreOffice.new(path, only_visible_sheets: true).sheets).to eq ["VisibleSheet1"]
+      end
+    end
   end
 end

data/spec/lib/roo/openoffice_spec.rb

@@ -2,20 +2,42 @@ require 'spec_helper'
 
 describe Roo::OpenOffice do
   describe '.new' do
-    subject {
+    subject do
       Roo::OpenOffice.new('test/files/numbers1.ods')
-    }
+    end
 
     it 'creates an instance' do
       expect(subject).to be_a(Roo::OpenOffice)
     end
-  end
 
-  # OpenOffice is an alias of LibreOffice. See libreoffice_spec.
-end
+    context 'for float/integer values' do
+      context 'integer without point' do
+        it { expect(subject.cell(3,"A","Sheet4")).to eq(1234) }
+        it { expect(subject.cell(3,"A","Sheet4")).to be_a(Integer) }
+      end
+
+      context 'float with point' do
+        it { expect(subject.cell(3,"B","Sheet4")).to eq(1234.00) }
+        it { expect(subject.cell(3,"B","Sheet4")).to be_a(Float) }
+      end
+
+      context 'float with point' do
+        it { expect(subject.cell(3,"C","Sheet4")).to eq(1234.12) }
+        it { expect(subject.cell(3,"C","Sheet4")).to be_a(Float) }
+      end
+    end
+
+    context 'file path is a Pathname' do
+      subject do
+        Roo::OpenOffice.new(Pathname.new('test/files/numbers1.ods'))
+      end
+
+      it 'creates an instance' do
+        expect(subject).to be_a(Roo::OpenOffice)
+      end
+    end
 
-describe Roo::Openoffice do
-  it 'is an alias of LibreOffice' do
-    expect(Roo::Openoffice).to eq(Roo::OpenOffice)
   end
+
+  # OpenOffice is an alias of LibreOffice. See libreoffice_spec.
 end

data/spec/lib/roo/spreadsheet_spec.rb

@@ -2,15 +2,34 @@ require 'spec_helper'
 
 describe Roo::Spreadsheet do
   describe '.open' do
+    context 'when the file name includes a space' do
+      let(:filename) { 'great scott.xlsx' }
+
+      it 'loads the proper type' do
+        expect(Roo::Excelx).to receive(:new).with(filename, {})
+        Roo::Spreadsheet.open(filename)
+      end
+    end
+
     context 'when the file extension is uppercase' do
-      let(:filename) { 'file.XLS' }
+      let(:filename) { 'file.XLSX' }
 
       it 'loads the proper type' do
-        expect(Roo::Excel).to receive(:new).with(filename, {})
+        expect(Roo::Excelx).to receive(:new).with(filename, {})
         Roo::Spreadsheet.open(filename)
       end
     end
 
+    context 'for a tempfile' do
+      let(:tempfile) { Tempfile.new('foo.csv') }
+      let(:filename) { tempfile.path }
+
+      it 'loads the proper type' do
+        expect(Roo::CSV).to receive(:new).with(filename, file_warning: :ignore).and_call_original
+        expect(Roo::Spreadsheet.open(tempfile, extension: :csv)).to be_a(Roo::CSV)
+      end
+    end
+
     context 'for a url' do
       context 'that is csv' do
         let(:filename) { 'http://example.com/file.csv?with=params#and=anchor' }
@@ -22,35 +41,64 @@ describe Roo::Spreadsheet do
       end
     end
 
+    context 'for a windows path' do
+      context 'that is xlsx' do
+        let(:filename) { 'c:\Users\Joe\Desktop\myfile.xlsx' }
+
+        it 'loads the proper type' do
+          expect(Roo::Excelx).to receive(:new).with(filename, {})
+          Roo::Spreadsheet.open(filename)
+        end
+      end
+    end
+
+    context 'for a xlsm file' do
+      let(:filename) { 'macros spreadsheet.xlsm' }
+
+      it 'loads the proper type' do
+        expect(Roo::Excelx).to receive(:new).with(filename, {})
+        Roo::Spreadsheet.open(filename)
+      end
+    end
+
     context 'for a csv file' do
       let(:filename) { 'file.csv' }
-      let(:options) { {csv_options: {col_sep: '"'}} }
+      let(:options) { { csv_options: { col_sep: '"' } } }
 
-      context 'with options' do
-        it 'passes the options through' do
+      context 'with csv_options' do
+        it 'passes the csv_options through' do
           expect(Roo::CSV).to receive(:new).with(filename, options)
           Roo::Spreadsheet.open(filename, options)
         end
       end
     end
 
-    context 'when the file extension' do
+    context 'with a file extension option' do
       let(:filename) { 'file.xls' }
 
-      context "is xls" do
-        let(:options) { { extension: "xls" } }
+      context ':xlsx' do
+        let(:options) { { extension: :xlsx } }
+
+        it 'loads with xls extension options' do
+          expect(Roo::Excelx).to receive(:new).with(filename, options)
+          Roo::Spreadsheet.open(filename, options)
+        end
+      end
+
+      context 'xlsx' do
+        let(:options) { { extension: 'xlsx' } }
 
         it 'loads with xls extension options' do
-          expect(Roo::Excel).to receive(:new).with(filename, options)
+          expect(Roo::Excelx).to receive(:new).with(filename, options)
           Roo::Spreadsheet.open(filename, options)
         end
       end
 
-      context "is .xls" do
-        let(:options) { { extension: ".xls" } }
+      context '.xlsx' do
+        let(:options) { { extension: '.xlsx' } }
 
         it 'loads with .xls extension options' do
-          expect(Roo::Excel).to receive(:new).with(filename, options)
+          expect(Roo::Excelx).to receive(:new).with(filename, options)
           Roo::Spreadsheet.open(filename, options)
         end
       end

data/spec/lib/roo/utils_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+RSpec.describe ::Roo::Utils do
+  subject { described_class }
+
+  context '#number_to_letter' do
+    described_class::LETTERS.each_with_index do |letter, index|
+      it "should return '#{ letter }' when passed #{ index + 1 }" do
+        expect(described_class.number_to_letter(index + 1)).to eq(letter)
+      end
+    end
+
+    {
+      27 => 'AA', 26*2 => 'AZ', 26*3 => 'BZ', 26**2 + 26 => 'ZZ', 26**2 + 27 => 'AAA',
+      26**3 + 26**2 + 26 => 'ZZZ', 1.0 => 'A', 676 => 'YZ', 677 => 'ZA'
+    }.each do |key, value|
+      it "should return '#{value}' when passed #{key}" do
+        expect(described_class.number_to_letter(key)).to eq(value)
+      end
+    end
+  end
+
+  context '#letter_to_number' do
+    it "should give 1 for 'A' and 'a'" do
+      expect(described_class.letter_to_number('A')).to eq(1)
+      expect(described_class.letter_to_number('a')).to eq(1)
+    end
+
+    it "should give the correct value for 'Z'" do
+      expect(described_class.letter_to_number('Z')).to eq(26)
+    end
+
+    it "should give the correct value for 'AA' regardless of case mixing" do
+      %w(AA aA Aa aa).each do |key|
+        expect(described_class.letter_to_number(key)).to eq(27)
+      end
+    end
+
+    { 'AB' => 28, 'AZ' => 26*2, 'BZ' => 26*3, 'ZZ' => 26**2 + 26 }.each do |key, value|
+      it "should give the correct value for '#{key}'" do
+        expect(described_class.letter_to_number(key)).to eq(value)
+      end
+    end
+  end
+
+  context '.split_coordinate' do
+    it "returns the expected result" do
+      expect(described_class.split_coordinate('A1')).to eq [1, 1]
+      expect(described_class.split_coordinate('B2')).to eq [2, 2]
+      expect(described_class.split_coordinate('R2')).to eq [2, 18]
+      expect(described_class.split_coordinate('AR31')).to eq [31, 18 + 26]
+    end
+  end
+
+  context '.split_coord' do
+    it "returns the expected result" do
+      expect(described_class.split_coord('A1')).to eq ["A", 1]
+      expect(described_class.split_coord('B2')).to eq ["B", 2]
+      expect(described_class.split_coord('R2')).to eq ["R", 2]
+      expect(described_class.split_coord('AR31')).to eq ["AR", 31]
+    end
+
+    it "raises an error when appropriate" do
+      expect { described_class.split_coord('A') }.to raise_error(ArgumentError)
+      expect { described_class.split_coord('2') }.to raise_error(ArgumentError)
+    end
+  end
+
+
+  context '.num_cells_in_range' do
+    it "returns the expected result" do
+      expect(described_class.num_cells_in_range('A1:B2')).to eq 4
+      expect(described_class.num_cells_in_range('B2:E3')).to eq 8
+      expect(described_class.num_cells_in_range('R2:Z10')).to eq 81
+      expect(described_class.num_cells_in_range('AR31:AR32')).to eq 2
+      expect(described_class.num_cells_in_range('A1')).to eq 1
+    end
+
+    it "raises an error when appropriate" do
+      expect { described_class.num_cells_in_range('A1:B1:B2') }.to raise_error(ArgumentError)
+    end
+  end
+
+  context '.load_xml' do
+    it 'returns the expected result' do
+      expect(described_class.load_xml('test/files/sheet1.xml')).to be_a(Nokogiri::XML::Document)
+      expect(described_class.load_xml('test/files/sheet1.xml').
+                 remove_namespaces!.xpath("/worksheet/dimension").map do |dim|
+                  dim.attributes["ref"].value end.first).to eq "A1:B11"
+    end
+  end
+
+  context '.each_element' do
+    it 'returns the expected result' do
+      described_class.each_element('test/files/sheet1.xml', 'dimension') do |dim|
+        expect(dim.attributes["ref"].value).to eq "A1:B11"
+      end
+      rows = []
+      described_class.each_element('test/files/sheet1.xml', 'row') do |row|
+        rows << row
+      end
+      expect(rows.size).to eq 11
+      expect(rows[2].attributes["r"].value).to eq "3"
+    end
+  end
+end

data/spec/spec_helper.rb

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

data/test/all_ss.rb

@@ -1,11 +1,12 @@
-require 'roo'
-Dir.glob("test/files/*.ods").each do |fn|
-	begin
-		oo = Roo::OpenOffice.new fn
-		print File.basename(fn) + " "
-		puts oo.officeversion
-	rescue Zip::ZipError, Errno::ENOENT => e
-		# file is not a real .ods spreadsheet file
-		puts e.message
-	end
-end
+require 'roo'
+
+Dir.glob('test/files/*.ods').each do |fn|
+  begin
+    oo = Roo::OpenOffice.new fn
+    print "#{File.basename(fn)} "
+    puts oo.officeversion
+  rescue Zip::ZipError, Errno::ENOENT => e
+    # file is not a real .ods spreadsheet file
+    puts e.message
+  end
+end

data/test/excelx/cell/test_base.rb

@@ -0,0 +1,63 @@
+require 'test_helper'
+
+class TestRooExcelxCellBase < Minitest::Test
+  def base
+    Roo::Excelx::Cell::Base
+  end
+
+  def value
+    'Hello World'
+  end
+
+  def test_cell_type_is_base
+    cell = base.new(value, nil, [], nil, nil, nil)
+    assert_equal :base, cell.type
+  end
+
+  def test_cell_value
+    cell_value = value
+    cell = base.new(cell_value, nil, [], nil, nil, nil)
+    assert_equal cell_value, cell.cell_value
+  end
+
+  def test_not_empty?
+    cell = base.new(value, nil, [], nil, nil, nil)
+    refute cell.empty?
+  end
+
+  def test_cell_type_is_formula
+    formula = true
+    cell = base.new(value, formula, [], nil, nil, nil)
+    assert_equal :formula, cell.type
+  end
+
+  def test_formula?
+    formula = true
+    cell = base.new(value, formula, [], nil, nil, nil)
+    assert cell.formula?
+  end
+
+  def test_cell_type_is_link
+    link = 'http://example.com'
+    cell = base.new(value, nil, [], nil, link, nil)
+    assert_equal :link, cell.type
+  end
+
+  def test_link?
+    link = 'http://example.com'
+    cell = base.new(value, nil, [], nil, link, nil)
+    assert cell.link?
+  end
+
+  def test_link_value
+    link = 'http://example.com'
+    cell = base.new(value, nil, [], nil, link, nil)
+    assert_equal value, cell.value
+  end
+
+  def test_link_value_href
+    link = 'http://example.com'
+    cell = base.new(value, nil, [], nil, link, nil)
+    assert_equal link, cell.value.href
+  end
+end

data/test/excelx/cell/test_boolean.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+
+class TestRooExcelxCellNumber < Minitest::Test
+  def boolean
+    Roo::Excelx::Cell::Boolean
+  end
+
+  def test_formatted_value
+    cell = boolean.new '1', nil, nil, nil, nil
+    assert_equal 'TRUE', cell.formatted_value
+
+    cell = boolean.new '0', nil, nil, nil, nil
+    assert_equal 'FALSE', cell.formatted_value
+  end
+
+  def test_to_s
+    cell = boolean.new '1', nil, nil, nil, nil
+    assert_equal 'TRUE', cell.to_s
+
+    cell = boolean.new '0', nil, nil, nil, nil
+    assert_equal 'FALSE', cell.to_s
+  end
+
+  def test_cell_value
+    cell = boolean.new '1', nil, nil, nil, nil
+    assert_equal '1', cell.cell_value
+  end
+
+  def test_value
+    cell = boolean.new '1', nil, nil, nil, nil
+    assert_equal true, cell.value
+
+    cell = boolean.new '0', nil, nil, nil, nil
+    assert_equal false, cell.value
+  end
+end

data/test/excelx/cell/test_date.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+
+class TestRooExcelxCellDate < Minitest::Test
+  def date_cell
+    Roo::Excelx::Cell::Date
+  end
+
+  def base_date
+    ::Date.new(1899, 12, 30)
+  end
+
+  def base_date_1904
+    ::Date.new(1904, 01, 01)
+  end
+
+  def test_handles_1904_base_date
+    cell = date_cell.new('41791', nil, [:numeric_or_formula, 'mm-dd-yy'], 6, nil, base_date_1904, nil)
+    assert_equal ::Date.new(2018, 06, 02), cell.value
+  end
+
+  def test_formatted_value
+    cell = date_cell.new('41791', nil, [:numeric_or_formula, 'mm-dd-yy'], 6, nil, base_date, nil)
+    assert_equal '06-01-14', cell.formatted_value
+
+    cell = date_cell.new('41791', nil, [:numeric_or_formula, 'yyyy-mm-dd'], 6, nil, base_date, nil)
+    assert_equal '2014-06-01', cell.formatted_value
+  end
+
+  def test_value_is_date
+    cell = date_cell.new('41791', nil, [:numeric_or_formula, 'mm-dd-yy'], 6, nil, base_date, nil)
+    assert_kind_of ::Date, cell.value
+  end
+
+  def test_value
+    cell = date_cell.new('41791', nil, [:numeric_or_formula, 'mm-dd-yy'], 6, nil, base_date, nil)
+    assert_equal ::Date.new(2014, 06, 01), cell.value
+  end
+end

data/test/excelx/cell/test_datetime.rb

@@ -0,0 +1,45 @@
+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)
+    assert_kind_of ::DateTime, cell.value
+  end
+
+  def test_cell_type_is_datetime
+    cell = datetime.new('30000.323212', nil, [], nil, nil, base_date, nil)
+    assert_equal :datetime, cell.type
+  end
+
+  def test_standard_formatted_value
+    [
+      ['mm-dd-yy', '01-25-15'],
+      ['d-mmm-yy', '25-JAN-15'],
+      ['d-mmm ', '25-JAN'],
+      ['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
+      assert_equal formatted_value, cell.formatted_value
+    end
+  end
+
+  def test_custom_formatted_value
+    [
+      ['yyyy/mm/dd hh:mm:ss', '2015/01/25 08:15:00'],
+      ['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
+      assert_equal formatted_value, cell.formatted_value
+    end
+  end
+
+  def datetime
+    Roo::Excelx::Cell::DateTime
+  end
+
+  def base_date
+    Date.new(1899, 12, 30)
+  end
+end

data/test/excelx/cell/test_empty.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+class TestRooExcelxCellEmpty < Minitest::Test
+  def empty
+    Roo::Excelx::Cell::Empty
+  end
+end

data/test/excelx/cell/test_number.rb

@@ -0,0 +1,74 @@
+require 'test_helper'
+
+class TestRooExcelxCellNumber < Minitest::Test
+  def number
+    Roo::Excelx::Cell::Number
+  end
+
+  def test_float
+    cell = Roo::Excelx::Cell::Number.new '42.1', nil, ['General'], nil, nil, nil
+    assert_kind_of(Float, cell.value)
+  end
+
+  def test_integer
+    cell = Roo::Excelx::Cell::Number.new '42', nil, ['0'], nil, nil, nil
+    assert_kind_of(Integer, cell.value)
+  end
+
+  def test_scientific_notation
+    cell = Roo::Excelx::Cell::Number.new '1.2E-3', nil, ['0'], nil, nil, nil
+    assert_kind_of(Float, cell.value)
+  end
+
+  def test_simple_scientific_notation
+    cell = Roo::Excelx::Cell::Number.new '1E-3', 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)
+  end
+
+  def test_formats_with_negative_numbers
+    [
+      ['#,##0 ;(#,##0)', '(1,042)'],
+      ['#,##0 ;[Red](#,##0)', '[Red](1,042)'],
+      ['#,##0.00;(#,##0.00)', '(1,042.00)'],
+      ['#,##0.00;[Red](#,##0.00)', '[Red](1,042.00)']
+    ].each do |style_format, result|
+      cell = Roo::Excelx::Cell::Number.new '-1042', nil, [style_format], nil, nil, nil
+      assert_equal result, cell.formatted_value, "Style=#{style_format}"
+    end
+  end
+
+  def test_numbers_with_cell_errors
+    Roo::Excelx::ERROR_VALUES.each do |error|
+      cell = Roo::Excelx::Cell::Number.new error, nil, ['General'], nil, nil, nil
+      assert_equal error, cell.value
+      assert_equal error, cell.formatted_value
+    end
+  end
+
+  def test_formats
+    [
+      ['General', '1042'],
+      ['0', '1042'],
+      ['0.00', '1042.00'],
+      ['#,##0', '1,042'],
+      ['#,##0.00', '1,042.00'],
+      ['0%', '104200%'],
+      ['0.00%', '104200.00%'],
+      ['0.00E+00', '1.04E+03'],
+      ['#,##0 ;(#,##0)', '1,042'],
+      ['#,##0 ;[Red](#,##0)', '1,042'],
+      ['#,##0.00;(#,##0.00)', '1,042.00'],
+      ['#,##0.00;[Red](#,##0.00)', '1,042.00'],
+      ['##0.0E+0', '1.0E+03'],
+      ['@', '1042']
+    ].each do |style_format, result|
+      cell = Roo::Excelx::Cell::Number.new '1042', nil, [style_format], nil, nil, nil
+      assert_equal result, cell.formatted_value, "Style=#{style_format}"
+    end
+  end
+end

data/test/excelx/cell/test_string.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+class TestRooExcelxCellString < Minitest::Test
+  def string
+    Roo::Excelx::Cell::String
+  end
+
+
+  def test_formatted_value
+    cell = string.new '1', nil, nil, nil, nil
+    assert_equal '1', cell.formatted_value
+  end
+
+  def test_to_s
+    cell = string.new '0', nil, nil, nil, nil
+    assert_equal '0', cell.to_s
+  end
+
+  def test_cell_value
+    cell = string.new '1', nil, nil, nil, nil
+    assert_equal '1', cell.cell_value
+  end
+
+  def test_value
+    cell = string.new '0', nil, nil, nil, nil
+    assert_equal '0', cell.value
+  end
+end

data/test/excelx/cell/test_time.rb

@@ -0,0 +1,30 @@
+require 'test_helper'
+
+class TestRooExcelxCellTime < Minitest::Test
+  def roo_time
+    Roo::Excelx::Cell::Time
+  end
+
+  def base_date
+    Date.new(1899, 12, 30)
+  end
+
+  def test_formatted_value
+    value = '0.0751' # 6488.64 seconds, or 1:48:08.64
+    [
+      ['h:mm', '1:48'],
+      ['h:mm:ss', '1:48:09'],
+      ['mm:ss', '48:09'],
+      ['[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)
+      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)
+    assert_kind_of Integer, cell.value
+  end
+end