roo 1.13.2 → 2.10.1

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/strict_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Roo::Excelx do
+  subject { Roo::Excelx.new('test/files/strict.xlsx') }
+
+  example '#sheets' do
+    expect(subject.sheets).to eq %w(Sheet1 Sheet2)
+  end
+
+  example '#sheet' do
+    expect(subject.sheet('Sheet1')).to be_a(Roo::Excelx)
+  end
+
+  example '#cell' do
+    expect(subject.cell(1, 1)).to eq 'Sheet 1'
+    expect(subject.cell(1, 1, 'Sheet2')).to eq 'Sheet 2'
+  end
+
+  example '#row' do
+    expect(subject.row(1)).to eq ['Sheet 1']
+    expect(subject.row(1, 'Sheet2')).to eq ['Sheet 2']
+  end
+
+  example '#first_row' do
+    expect(subject.first_row).to eq 1
+    expect(subject.first_row('Sheet2')).to eq 1
+  end
+
+  example '#last_row' do
+    expect(subject.last_row).to eq 1
+    expect(subject.last_row('Sheet2')).to eq 1
+  end
+
+  example '#first_column' do
+    expect(subject.first_column).to eq 1
+    expect(subject.first_column('Sheet2')).to eq 1
+  end
+
+  example '#last_column' do
+    expect(subject.last_column).to eq 1
+    expect(subject.last_column('Sheet2')).to eq 1
+  end
+end

data/spec/lib/roo/utils_spec.rb

@@ -0,0 +1,119 @@
+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 '.extract_coordinate' do
+    it "returns the expected result" do
+      expect(described_class.extract_coordinate('A1')).to eq [1, 1]
+      expect(described_class.extract_coordinate('B2')).to eq [2, 2]
+      expect(described_class.extract_coordinate('R2')).to eq [2, 18]
+      expect(described_class.extract_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 '.coordinates_in_range' do
+    it "returns the expected result" do
+      expect(described_class.coordinates_in_range('').to_a).to eq []
+      expect(described_class.coordinates_in_range('B2').to_a).to eq [[2, 2]]
+      expect(described_class.coordinates_in_range('D2:G3').to_a).to eq [[2, 4], [2, 5], [2, 6], [2, 7], [3, 4], [3, 5], [3, 6], [3, 7]]
+      expect(described_class.coordinates_in_range('G3:D2').to_a).to eq []
+    end
+
+    it "raises an error when appropriate" do
+      expect { described_class.coordinates_in_range('D2:G3:I5').to_a }.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["ref"] 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["ref"]).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]["r"]).to eq "3"
+    end
+  end
+end

data/spec/lib/roo/weak_instance_cache_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+if RUBY_PLATFORM == "java"
+  require 'java'
+  java_import 'java.lang.System'
+end
+
+describe Roo::Helpers::WeakInstanceCache do
+  let(:klass) do
+    Class.new do
+      include Roo::Helpers::WeakInstanceCache
+
+      def memoized_data
+        instance_cache(:@memoized_data) do
+          "Some Costly Operation #{rand(1000)}" * 1_000
+        end
+      end
+    end
+  end
+
+  subject do
+    klass.new
+  end
+
+  it 'should be lazy' do
+    expect(subject.instance_variables).to_not include(:@memoized_data)
+    data = subject.memoized_data
+    expect(subject.instance_variables).to include(:@memoized_data)
+  end
+
+
+  it 'should be memoized' do
+    data = subject.memoized_data
+    expect(subject.memoized_data).to equal(data)
+  end
+
+  it 'should recalculate after GC' do
+    expect(subject.instance_variables).to_not include(:@memoized_data)
+    GC.disable
+    subject.memoized_data && nil
+    expect(subject.instance_variables).to include(:@memoized_data)
+
+    force_gc
+    expect(subject.instance_variables).to_not include(:@memoized_data)
+    GC.disable
+    subject.memoized_data && nil
+    expect(subject.instance_variables).to include(:@memoized_data)
+  end
+
+  it 'must remove instance variable' do
+    expect(subject.instance_variables).to_not include(:@memoized_data)
+    GC.disable
+    subject.memoized_data && nil
+    expect(subject.instance_variables).to include(:@memoized_data)
+
+    force_gc
+    expect(subject.instance_variables).to_not include(:@memoized_data)
+  end
+
+  context '#inspect must not raise' do
+    it 'before calculation' do
+      expect{subject.inspect}.to_not raise_error
+    end
+    it 'after calculation' do
+      GC.disable
+      subject.memoized_data && nil
+      expect{subject.inspect}.to_not raise_error
+      expect(subject.inspect).to include("Some Costly Operation")
+      force_gc
+    end
+    it 'after GC' do
+      subject.memoized_data && nil
+      force_gc
+      expect(subject.instance_variables).to_not include(:@memoized_data)
+      expect{subject.inspect}.to_not raise_error
+      expect(subject.inspect).to_not include("Some Costly Operation")
+    end
+  end
+
+  if RUBY_PLATFORM == "java"
+    def force_gc
+      System.gc
+      sleep(0.1)
+    end
+  else
+    def force_gc
+      GC.start(full_mark: true, immediate_sweep: true)
+      sleep(0.1)
+      GC.start(full_mark: true, immediate_sweep: true)
+    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 if ENV["USE_REPORTERS"]
 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_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

@@ -0,0 +1,68 @@
+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_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)
+    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