rubyXL 1.2.10 → 3.4.33

data/spec/lib/color_spec.rb

@@ -1,14 +1,21 @@
-require 'rubygems'
-require 'rubyXL'
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'rubyXL/convenience_methods/color'
 
 describe RubyXL::Color do
   describe '.validate_color' do
     it 'should return true if a valid hex color without a # is passed' do
-      RubyXL::Color.validate_color('0fbCAd').should == true
+      expect(RubyXL::Color.validate_color('0fbCAd')).to eq(true)
+    end
+
+    it 'should return true if a valid hex color with alpha is passed' do
+      expect(RubyXL::Color.validate_color('01AbCdeF')).to eq(true)
     end
 
     it 'should cause an error if an invalid hex color code or one with a # is passed' do
-      lambda {RubyXL::Color.validate_color('#G')}.should raise_error
+      expect { RubyXL::Color.validate_color('#G') }.to raise_error(RuntimeError)
+      expect { RubyXL::Color.validate_color('1234567') }.to raise_error(RuntimeError)
     end
   end
 end

data/spec/lib/parser_spec.rb

@@ -1,66 +1,118 @@
-require 'rubygems'
-require 'rubyXL'
+# frozen_string_literal: true
+
+require 'English'
+require 'spec_helper'
+require 'tmpdir'
 
 describe RubyXL::Parser do
   before do
-    @workbook = (RubyXL::Workbook.new)
-    @time_str = Time.now.to_s
-    @file = @time_str + '.xlsx'
-    @workbook.write(@file)
-  end
+    @test_sheet_name = 'This is a very long sheet name that should be trimmed ' \
+                       'to 31 characters for compatibility with MS Excel'
+    @workbook = RubyXL::Workbook.new
+    @workbook.add_worksheet('Test Worksheet')
+    @time = Time.at(Time.now.to_i) # Excel only saves times with 1-second precision.
+    @time2 = @time + 123456
 
-  describe '.convert_to_index' do
-    it 'should convert a well-formed Excel index into a pair of array indices' do
-      RubyXL::Parser.convert_to_index('AA1').should == [0, 26]
-    end
+    ws = @workbook.add_worksheet('Escape Test')
+    ws.add_cell(0, 0, '&')
+    ws.add_cell(0, 1, '<')
+    ws.add_cell(0, 2, '>')
+    ws.add_cell(0, 3, '')
 
-    it 'should return [-1, -1] if the Excel index is not well-formed' do
-      RubyXL::Parser.convert_to_index('A1B').should == [-1, -1]
-    end
+    ws.add_cell(1, 0, '&') #TODO# .datatype = RubyXL::Cell::SHARED_STRING
+    ws.add_cell(1, 1, '<') #TODO# .datatype = RubyXL::Cell::SHARED_STRING
+    ws.add_cell(1, 2, '>') #TODO# .datatype = RubyXL::Cell::SHARED_STRING
+    ws.add_cell(1, 3, '')
+
+    ws.add_cell(2, 0, 0)
+    ws.add_cell(2, 1, 12345)
+    ws.add_cell(2, 2, 123.456e78)
+    ws.add_cell(2, 3, 123.456e-78)
+
+    ws.add_cell(3, 0, -0)
+    ws.add_cell(3, 1, -12345)
+    ws.add_cell(3, 2, -123.456e78)
+    ws.add_cell(3, 3, -123.456e-78)
+
+    ws[3][3].set_number_format('#.###')
+
+    @workbook.add_worksheet(@test_sheet_name)
+
+    @workbook.creator = 'test creator'
+    @workbook.modifier = 'test modifier'
+    @workbook.created_at = @time
+    @workbook.modified_at = @time2
+
+    @time_str = Time.now.to_s
+    @file = "rubyXL-#{$PROCESS_ID}-#{DateTime.now.strftime('%Q')}.xlsx"
+    @workbook.write(@file)
   end
 
   describe '.parse' do
     it 'should parse a valid Excel xlsx or xlsm workbook correctly' do
       @workbook2 = RubyXL::Parser.parse(@file)
 
-      @workbook2.worksheets.size.should == @workbook.worksheets.size
-      @workbook2[0].sheet_data.should == @workbook[0].sheet_data
-      @workbook2[0].sheet_name.should == @workbook[0].sheet_name
+      expect(@workbook2).to be_an_instance_of(::RubyXL::Workbook)
+
+      expect(@workbook2.worksheets.size).to eq(@workbook.worksheets.size)
+      @workbook2.worksheets.each_index { |i|
+        expect(@workbook2[i]).to be_an_instance_of(::RubyXL::Worksheet)
+      }
     end
 
     it 'should cause an error if an xlsx or xlsm workbook is not passed' do
-      lambda {@workbook2 = RubyXL::Parser.parse(@time_str+".xls")}.should raise_error
+      expect { @workbook2 = RubyXL::Parser.parse('nonexistent_file.tmp') }.to raise_error(Zip::Error)
     end
 
-    it 'should not cause an error if an xlsx or xlsm workbook is not passed but the skip_filename_check option is used' do
-      filename = @time_str
-      FileUtils.cp(@file, filename)
-      
-      lambda {@workbook2 = RubyXL::Parser.parse(filename)}.should raise_error
-      lambda {@workbook2 = RubyXL::Parser.parse(filename, :skip_filename_check => true)}.should_not raise_error
-      
-      File.delete(filename)
+    it 'should construct consistent number formats' do
+      @workbook2 = RubyXL::Parser.parse(@file)
+      expect(@workbook2.stylesheet.number_formats).to be_instance_of(RubyXL::NumberFormats)
+      expect(@workbook2.stylesheet.number_formats.size).to eq(1)
     end
-    
-    it 'should only read the data and not any of the styles (for the sake of speed) when passed true' do
-      @workbook2 = RubyXL::Parser.parse(@file, :data_only => true)
 
-      @workbook2.worksheets.size.should == @workbook.worksheets.size
-      @workbook2[0].sheet_data.should == @workbook[0].sheet_data
-      @workbook2[0].sheet_name.should == @workbook[0].sheet_name
+    it 'should unescape HTML entities properly' do
+      @workbook2 = RubyXL::Parser.parse(@file)
+      expect(@workbook2['Escape Test'][0][0].value).to eq('&')
+      expect(@workbook2['Escape Test'][0][1].value).to eq('<')
+      expect(@workbook2['Escape Test'][0][2].value).to eq('>')
+
+      expect(@workbook2['Escape Test'][1][0].value).to eq('&')
+      expect(@workbook2['Escape Test'][1][1].value).to eq('<')
+      expect(@workbook2['Escape Test'][1][2].value).to eq('>')
     end
 
-    it 'should construct consistent number formats' do
+    it 'should parse Core properties correctly' do
+      @workbook2 = RubyXL::Parser.parse(@file)
+      expect(@workbook2.creator).to eq('test creator')
+      expect(@workbook2.modifier).to eq('test modifier')
+      expect(@workbook2.created_at).to eq(@time)
+      expect(@workbook2.modified_at).to eq(@time2)
+    end
+
+    it 'should trim excessively long sheet names on save' do
       @workbook2 = RubyXL::Parser.parse(@file)
+      expect(@workbook2[@test_sheet_name]).to be_nil
+      expect(@workbook2[@test_sheet_name[0..30]]).not_to be_nil
+    end
+  end
 
-      @workbook2.num_fmts[:numFmt].should be_an(Array)
-      @workbook2.num_fmts[:numFmt].length.should == @workbook2.num_fmts[:attributes][:count]
+  describe 'parse_buffer' do
+    it 'should parse string buffer correctly' do
+      buffer = File.read(@file)
+      expect(buffer).to be_instance_of(String)
+      f = RubyXL::Parser.parse_buffer(buffer)
+      expect(f).to be_instance_of(RubyXL::Workbook)
+    end
+
+    it 'should parse an IO object correctly' do
+      io = File.open(@file)
+      expect(io).to be_instance_of(File)
+      f = RubyXL::Parser.parse_buffer(io)
+      expect(f).to be_instance_of(RubyXL::Workbook)
     end
   end
 
   after do
-    if File.exist?(@file)
-      File.delete(@file)
-    end
+    FileUtils.rm_f(@file)
   end
 end

data/spec/lib/reference_spec.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe RubyXL::Reference do
+  describe '.ind2ref' do
+    it "should correctly return the 'Excel Style' description of cells when given a row/column number" do
+      expect(RubyXL::Reference.ind2ref(0, 26)).to eq('AA1')
+      expect(RubyXL::Reference.ind2ref(99, 0)).to eq('A100')
+      expect(RubyXL::Reference.ind2ref(0, 26)).to eq('AA1')
+      expect(RubyXL::Reference.ind2ref(0, 51)).to eq('AZ1')
+      expect(RubyXL::Reference.ind2ref(0, 52)).to eq('BA1')
+      expect(RubyXL::Reference.ind2ref(0, 77)).to eq('BZ1')
+      expect(RubyXL::Reference.ind2ref(0, 78)).to eq('CA1')
+      expect(RubyXL::Reference.ind2ref(0, 16383)).to eq('XFD1')
+    end
+
+    it "should correctly convert back and forth between 'Excel Style' and index style cell references" do
+      0.upto(16383) do |n|
+        expect(RubyXL::Reference.ref2ind(RubyXL::Reference.ind2ref(n, 16383 - n))).to eq([ n, 16383 - n ])
+      end
+    end
+  end
+
+  describe '.valid?' do
+    it 'should return true for valid references' do
+      expect(RubyXL::Reference.new('C23').valid?).to be true
+    end
+
+    it 'should return false for invalid references' do
+      expect(RubyXL::Reference.new('C2A').valid?).to be false
+    end
+  end
+
+  describe '.ref2ind' do
+    it 'should return [-1, -1] if the Excel index is not well-formed' do
+      expect(RubyXL::Reference.ref2ind('A1B')).to eq([-1, -1])
+    end
+  end
+
+  describe '.new' do
+    it 'should take a string parameter' do
+      new_ref = RubyXL::Reference.new('C23')
+      expect(new_ref.single_cell?).to be true
+      expect(new_ref.to_s).to eq 'C23'
+    end
+
+    it 'should take 2 coordinate parameters' do
+      new_ref = RubyXL::Reference.new(11, 22)
+      expect(new_ref.single_cell?).to be true
+      expect(new_ref.to_s).to eq 'W12'
+    end
+
+    it 'should take 4 coordinate parameters' do
+      new_ref = RubyXL::Reference.new(11, 22, 33, 44)
+      expect(new_ref.single_cell?).to be false
+      expect(new_ref.to_s).to eq 'AH12:AS23'
+    end
+
+    it 'should take named parameters' do
+      expect(RubyXL::Reference.new(row_from: 44, row_to: 33, col_from: 22, col_to: 11).to_s).to eq('W45:L34')
+    end
+  end
+end

data/spec/lib/rgb_color_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'rubyXL/convenience_methods/color'
+
+describe RubyXL::RgbColor do
+  describe '.to_s' do
+    it 'should properly translate RGB color to string' do
+      rgb_color = RubyXL::RgbColor.new
+
+      rgb_color.r = 1
+      rgb_color.g = 2
+      rgb_color.b = 255
+
+      expect(rgb_color.to_s).to eq('0102ff')
+    end
+
+    it 'should properly translate RGB color with alpha value to string' do
+      rgb_color = RubyXL::RgbColor.new
+
+      rgb_color.r = 11
+      rgb_color.g = 22
+      rgb_color.b = 33
+      rgb_color.a = 255
+
+      expect(rgb_color.to_s).to eq('0b1621ff')
+    end
+  end
+end

data/spec/lib/stylesheet_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe RubyXL::NumberFormat do
+  describe '.is_date_format?' do
+    it 'should return true if number format = dd// yy// mm' do
+      expect(RubyXL::NumberFormat.new(:num_fmt_id => 1, :format_code => 'dd// yy// mm').is_date_format?).to eq(true)
+    end
+
+    it 'should return true if number format = DD// YY// MM (uppercase)' do
+      expect(RubyXL::NumberFormat.new(:num_fmt_id => 1, :format_code => 'DD// YY// MM').is_date_format?).to eq(true)
+    end
+
+    it 'should return false if number format = @' do
+      expect(RubyXL::NumberFormat.new(:num_fmt_id => 1, :format_code => '@').is_date_format?).to eq(false)
+      expect(RubyXL::NumberFormat.new(:num_fmt_id => 1, :format_code => 'general').is_date_format?).to eq(false)
+      expect(RubyXL::NumberFormat.new(:num_fmt_id => 1, :format_code => '0.00e+00').is_date_format?).to eq(false)
+    end
+
+    it 'should properly detect date formats amongst default ones' do
+      all_formats = RubyXL::NumberFormats::DEFAULT_NUMBER_FORMATS
+      id_list = all_formats.collect { |fmt| fmt.num_fmt_id if fmt.is_date_format? }.compact.sort
+      expect(id_list).to eq([14, 15, 16, 17, 18, 19, 20, 21, 22, 45, 46, 47])
+    end
+  end
+end

data/spec/lib/text_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe RubyXL::Text do
+  describe '.to_s' do
+    it 'should not crash processing UNICODE data' do
+      bytes = [ 114, 39, 95, 120, 48, 48, 56, 48, 95, 226, 132, 162, 115,
+                32, 103, 105, 114, 108, 102, 114, 105, 101, 110, 100,
+                39, 95, 120, 48, 48, 56, 48, 95, 226, 132, 162, 115, 32, 104, 111]
+
+      t = RubyXL::Text.new(:value => bytes.pack('c*').force_encoding('UTF-8'))
+
+      str = t.to_s
+
+      expect(str).to be
+    end
+
+    it 'should not escape valid XML extended UNICODE characters' do
+      t = RubyXL::Text.new(:value => "\u{10000}\u{10FFFF}")
+
+      xml = t.write_xml[%r{<t>[^<]+</t>}]
+
+      expect(xml).to eq("<t>\u{10000}\u{10FFFF}</t>")
+    end
+  end
+end

data/spec/lib/workbook_spec.rb

@@ -1,51 +1,197 @@
-require 'rubygems'
-require 'rubyXL'
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'rubyXL/convenience_methods/workbook'
 
 describe RubyXL::Workbook do
   before do
     @workbook  = RubyXL::Workbook.new
-    @worksheet = RubyXL::Worksheet.new(@workbook)
-    @workbook.worksheets << @worksheet
-    (0..10).each do |i|
-      (0..10).each do |j|
+    @worksheet = @workbook.add_worksheet('Test Worksheet')
+
+    11.times do |i|
+      11.times do |j|
         @worksheet.add_cell(i, j, "#{i}:#{j}")
       end
     end
+
     @cell = @worksheet[0][0]
   end
 
-  describe '.write' do
-    #method not conducive to unit tests
+  describe '.new' do
+    it 'should automatically create a blank worksheet named "Sheet1"' do
+      expect(@workbook[0]).not_to be_nil
+      expect(@workbook[0].sheet_name).to eq('Sheet1')
+    end
   end
 
-  describe '.get_style' do
-    it 'should return the cell_xfs object based on the passed in style index (string or number)' do
-      @workbook.get_style('0').should == @workbook.cell_xfs[:xf][0]
+  describe '[]' do
+    it 'should properly locate worksheet by index' do
+      expect(@workbook[1]).not_to be_nil
+      expect(@workbook[1].sheet_name).to eq('Test Worksheet')
     end
 
-    it 'should return nil if index out of range or string is passed in' do
-      @workbook.get_style('20000').should be_nil
+    it 'should properly locate worksheet by name' do
+      expect(@workbook['Test Worksheet']).not_to be_nil
+      expect(@workbook['Test Worksheet'].sheet_name).to eq('Test Worksheet')
     end
   end
 
-  describe '.get_style_attributes' do
-    it 'should return the attributes of the style object when passed the style object itself' do
-      @workbook.get_style_attributes(@workbook.get_style(0)).should == @workbook.cell_xfs[:xf][0][:attributes]
-    end
-
-    it 'should cause an error if nil is passed' do
-      lambda {@workbook.get_style_attributes(nil)}.should raise_error
+  describe '.add_worksheet' do
+    it 'when not given a name, it should automatically pick a name "SheetX" that is not taken yet' do
+      expect(@workbook['Sheet2']).to be_nil
+      @workbook.add_worksheet
+      expect(@workbook['Sheet2']).not_to be_nil
+      expect(@workbook['Sheet2'].sheet_name).to eq('Sheet2')
     end
   end
 
   describe '.get_fill_color' do
     it 'should return the fill color of a particular style attribute' do
       @cell.change_fill('000000')
-      @workbook.get_fill_color(@workbook.get_style_attributes(@workbook.get_style(@cell.style_index))).should == '000000'
+      expect(@workbook.get_fill_color(@workbook.cell_xfs[@cell.style_index])).to eq('000000')
     end
 
     it 'should return white (ffffff) if no fill color is specified in style' do
-      @workbook.get_fill_color(@workbook.get_style_attributes(@workbook.get_style(@cell.style_index))).should == 'ffffff'
+      expect(@workbook.get_fill_color(@workbook.cell_xfs[@cell.style_index])).to eq('ffffff')
+    end
+  end
+
+  describe '.application' do
+    it 'should contain default application string' do
+      expect(@workbook.application).to eq(RubyXL::Workbook::APPLICATION)
+    end
+
+    it 'should set application properly' do
+      @workbook.application = 'TEST APPLICATION'
+      expect(@workbook.application).to eq('TEST APPLICATION')
+    end
+  end
+
+  describe '.company' do
+    it 'should have default company empty' do
+      expect(@workbook.company).to eq('')
+    end
+
+    it 'should set company properly' do
+      @workbook.company = 'TEST COMPANY'
+      expect(@workbook.company).to eq('TEST COMPANY')
+    end
+  end
+
+  describe '.appversion' do
+    it 'should contain default appversion' do
+      expect(@workbook.appversion).to eq(RubyXL::Workbook::APPVERSION)
+    end
+
+    it 'should set appversion properly' do
+      @workbook.appversion = '12.34'
+      expect(@workbook.appversion).to eq('12.34')
+    end
+  end
+
+  describe '.creator' do
+    it 'should contain default creator' do
+      expect(@workbook.creator).to be_nil
+    end
+
+    it 'should set creator properly' do
+      @workbook.creator = 'CREATOR'
+      expect(@workbook.creator).to eq('CREATOR')
+    end
+  end
+
+  describe '.modifier' do
+    it 'should contain default modifier' do
+      expect(@workbook.modifier).to be_nil
+    end
+
+    it 'should set modifier properly' do
+      @workbook.modifier = 'MODIFIER'
+      expect(@workbook.modifier).to eq('MODIFIER')
+    end
+  end
+
+  describe '.created_at' do
+    it 'should contain current time by default' do
+      expect(@workbook.created_at).to be_a_kind_of(Time)
+    end
+
+    it 'should set modifier properly' do
+      dt = Time.at(Time.now.to_i) # Strip time of microseconds
+      @workbook.created_at = dt
+      expect(@workbook.created_at.to_time).to eq(dt)
+    end
+  end
+
+  describe '.created_at' do
+    it 'should contain current time by default' do
+      expect(@workbook.modified_at).to be_a_kind_of(Time)
+    end
+
+    it 'should set modifier properly' do
+      dt = Time.at(Time.now.to_i) # Strip time of microseconds
+      @workbook.modified_at = dt
+      expect(@workbook.modified_at.to_time).to eq(dt)
+    end
+  end
+
+  describe '.title' do
+    it 'should contain default title' do
+      expect(@workbook.title).to be_nil
+    end
+
+    it 'should set title properly' do
+      @workbook.title = 'TITLE'
+      expect(@workbook.title).to eq('TITLE')
+    end
+  end
+
+  describe '.stream' do
+    it 'It should not be confused by missing sheet_id' do
+      workbook = RubyXL::Workbook.new
+      workbook[0].sheet_id = 1
+      workbook.add_worksheet('Sheet2')
+      workbook.stream
+    end
+
+    it 'should raise error if bad characters are present in worksheet name' do
+      workbook = RubyXL::Workbook.new
+      workbook[0].sheet_name = 'Sheet007'
+      expect{ workbook.stream }.to_not raise_error
+
+      '\\/*[]:?'.each_char { |char|
+        workbook = RubyXL::Workbook.new
+        workbook[0].sheet_name = "Sheet#{char}007"
+        expect{ workbook.stream }.to raise_error(RuntimeError)
+      }
+    end
+  end
+
+  describe '.collect_related_objects' do
+    it 'should not save shared strings if there are none' do
+      wb = RubyXL::Workbook.new
+      expect(wb.root.collect_related_objects.map(&:class).include?(::RubyXL::SharedStringsTable)).to be false
+      Zip::File.open_buffer(wb.stream) { |zf|
+        expect(zf.entries.any? { |e| e.name =~ /sharedstrings/i }).to be false
+      }
+
+      wb.shared_strings_container.add('test')
+      expect(wb.root.collect_related_objects.map(&:class).include?(::RubyXL::SharedStringsTable)).to be true
+      Zip::File.open_buffer(wb.stream) { |zf|
+        expect(zf.entries.any? { |e| e.name =~ /sharedstrings/i }).to be true
+      }
+    end
+  end
+
+  describe 'defined names' do
+    it 'should add and access defined names properly' do
+      wb = RubyXL::Workbook.new
+      wb.define_new_name('TEST', 'Sheet1!$A$2')
+
+      wb2 = RubyXL::Parser.parse_buffer(wb.stream)
+      expect(wb2.get_defined_name('TEST')).to_not be_nil
+      expect(wb2.get_defined_name('TEST').reference).to eq('Sheet1!$A$2')
+      expect(wb2.get_defined_name('TEST2')).to be_nil
     end
   end
 end