workbook 0.8.0 → 0.8.2

data/test/test_book.rb

@@ -1,5 +1,6 @@
-# -*- encoding : utf-8 -*-
-require File.join(File.dirname(__FILE__), 'helper')
+# frozen_string_literal: true
+
+require File.join(File.dirname(__FILE__), "helper")
 
 class TestWorkbook < Minitest::Test
   def test_sheets
@@ -11,32 +12,36 @@ class TestWorkbook < Minitest::Test
   def test_push
     w = Workbook::Book.new nil
     assert_equal(0, w.count)
-    assert_equal([],w)
+    assert_equal(Workbook::Book, w.class)
+
     w = Workbook::Book.new
     w.push
-    assert_equal(w.first.class,Workbook::Sheet)
+    assert_equal(w.first.class, Workbook::Sheet)
+
     w.push
-    assert_equal(w,w.last.book)
+    assert_equal(w, w.last.book)
     assert_equal(2, w.count)
-    s = Workbook::Sheet.new
+
+    s = Workbook::Sheet.new([[1, 2], [3, 4]])
     w.push s
-    assert_equal(w,w.last.book)
+    assert_equal(w, w.last.book)
+
+    assert_equal(w.last, s)
 
-    assert_equal(w.last,s)
     w = Workbook::Book.new
-    assert_equal(w.sheet.table.class,Workbook::Table)
+    assert_equal(w.sheet.table.class, Workbook::Table)
   end
 
   def test_sheet
     w = Workbook::Book.new nil
     s = Workbook::Sheet.new [Workbook::Row.new(Workbook::Table.new)]
-    assert_equal(w.sheet.class,Workbook::Sheet)
+    assert_equal(w.sheet.class, Workbook::Sheet)
     refute_equal(w.sheet, s)
     w = Workbook::Book.new s
     assert_equal(w.sheet, s)
     w = Workbook::Book.new
     s = w.sheet
-    assert_equal([[]], s)
+    assert_equal(Workbook::Sheet, s.class)
   end
 
   def test_template
@@ -46,30 +51,30 @@ class TestWorkbook < Minitest::Test
     raw = Workbook::Template.new
     b.template = raw
 
-    assert_equal(raw,b.template)
+    assert_equal(raw, b.template)
   end
 
   def test_file_extension
     b = Workbook::Book.new
-    assert_equal("aaa",b.file_extension("aaa.aaa"))
+    assert_equal("aaa", b.file_extension("aaa.aaa"))
     b = Workbook::Book.new
-    assert_equal("xlsx",b.file_extension(File.join(File.dirname(__FILE__), 'artifacts/book_with_tabs_and_colours.xlsx')))
+    assert_equal("xlsx", b.file_extension(File.join(File.dirname(__FILE__), "artifacts/book_with_tabs_and_colours.xlsx")))
     b = Workbook::Book.new
-    assert_equal("xlsx",b.file_extension(File.new(File.join(File.dirname(__FILE__), 'artifacts/book_with_tabs_and_colours.xlsx'))))
+    assert_equal("xlsx", b.file_extension(File.new(File.join(File.dirname(__FILE__), "artifacts/book_with_tabs_and_colours.xlsx"))))
   end
 
   def test_parent_child
-    b = Workbook::Book.new [[1,2,3],[1,2,3]]
+    b = Workbook::Book.new [[1, 2, 3], [1, 2, 3]]
     assert_equal(Workbook::Sheet, b.first.class)
-    assert_equal(b,b.first.book)
+    assert_equal(b, b.first.book)
     assert_equal(Workbook::Table, b.first.table.class)
-    assert_equal(b,b.first.table.sheet.book)
+    assert_equal(b, b.first.table.sheet.book)
     assert_equal(Workbook::Row, b.first.table.header.class)
-    assert_equal(b,b.first.table.header.table.sheet.book)
+    assert_equal(b, b.first.table.header.table.sheet.book)
   end
 
   def test_text_to_utf8
-    f = File.open(File.join(File.dirname(__FILE__), 'artifacts/excel_different_types.txt'),'r')
+    f = File.open(File.join(File.dirname(__FILE__), "artifacts/excel_different_types.txt"), "r")
     t = f.read
     w = Workbook::Book.new
     t = w.text_to_utf8(t)
@@ -83,37 +88,37 @@ class TestWorkbook < Minitest::Test
   end
 
   def test_push_and_ltlt
-    b = Workbook::Book.new [["a","b"],[1,2]]
-    b.push Workbook::Sheet.new([["a","b"],[2,2]])
-    b.push Workbook::Sheet.new([["a","b"],[3,2]])
-    b << Workbook::Sheet.new([["a","b"],[4,2]])
-    b.push Workbook::Sheet.new([["a","b"],[5,2]])
-    b << Workbook::Sheet.new([["a","b"],[6,2]])
-    b.push Workbook::Sheet.new([["a","b"],[7,2]])
+    b = Workbook::Book.new [["a", "b"], [1, 2]]
+    b.push Workbook::Sheet.new([["a", "b"], [2, 2]])
+    b.push Workbook::Sheet.new([["a", "b"], [3, 2]])
+    b << Workbook::Sheet.new([["a", "b"], [4, 2]])
+    b.push Workbook::Sheet.new([["a", "b"], [5, 2]])
+    b << Workbook::Sheet.new([["a", "b"], [6, 2]])
+    b.push Workbook::Sheet.new([["a", "b"], [7, 2]])
 
     # puts b.index b.last
-    7.times { |time| assert_equal(b,b[0].book) }
+    7.times { |time| assert_equal(b, b[0].book) }
   end
 
   def test_removal_of_sheets_pop_and_delete_at_works_as_expected
-    b = Workbook::Book.new [["a","b"],[1,2]]
-    b.push Workbook::Sheet.new([["a","b"],[2,2]])
-    b.push Workbook::Sheet.new([["a","b"],[3,2]])
-    b << Workbook::Sheet.new([["a","b"],[4,2]])
-    b.push Workbook::Sheet.new([["a","b"],[5,2]])
-    b << Workbook::Sheet.new([["a","b"],[6,2]])
-    b.push Workbook::Sheet.new([["a","b"],[7,2]])
+    b = Workbook::Book.new [["a", "b"], [1, 2]]
+    b.push Workbook::Sheet.new([["a", "b"], [2, 2]])
+    b.push Workbook::Sheet.new([["a", "b"], [3, 2]])
+    b << Workbook::Sheet.new([["a", "b"], [4, 2]])
+    b.push Workbook::Sheet.new([["a", "b"], [5, 2]])
+    b << Workbook::Sheet.new([["a", "b"], [6, 2]])
+    b.push Workbook::Sheet.new([["a", "b"], [7, 2]])
 
     assert_equal(7, b.count)
-    assert_equal(5,b[4][0][1][0].value)
+    assert_equal(5, b[4][0][1][0].value)
     b.delete_at(4)
     assert_equal(6, b.count)
-    assert_equal(6,b[4][0][1][0].value)
+    assert_equal(6, b[4][0][1][0].value)
     b.pop(3)
     assert_equal(3, b.count)
   end
 
   def test_supported_mime_types
-    assert_equal true, Workbook::SUPPORTED_MIME_TYPES.include?('text/csv')
+    assert_equal true, Workbook::SUPPORTED_MIME_TYPES.include?("text/csv")
   end
 end

data/test/test_column.rb

@@ -1,28 +1,27 @@
-# -*- encoding : utf-8 -*-
-require File.join(File.dirname(__FILE__), 'helper')
+# frozen_string_literal: true
 
-class TestColumn < Minitest::Test
+require File.join(File.dirname(__FILE__), "helper")
 
+class TestColumn < Minitest::Test
   def new_table
     Workbook::Table.new([
-        ["a","b","c","d"],
-        [true,3.2,"asdf",1],
-        [true,3.2,"asdf",1],
-        [false,3.2,"asdf",1],
-        [true,3.2,"asdf",1]
-      ])
+      ["a", "b", "c", "d"],
+      [true, 3.2, "asdf", 1],
+      [true, 3.2, "asdf", 1],
+      [false, 3.2, "asdf", 1],
+      [true, 3.1, "asdf", 1]
+    ])
   end
 
   def test_init
     c = Workbook::Column.new
     assert_equal(Workbook::Column, c.class)
-    c = Workbook::Column.new(nil, {:limit=>20,:default=>"asdf", :column_type=>:boolean})
-    c = Workbook::Column.new(Workbook::Table.new, {:limit=>20,:default=>"asdf", :column_type=>:boolean})
+    c = Workbook::Column.new(Workbook::Table.new, {limit: 20, default: "asdf", column_type: :boolean})
     assert_equal(20, c.limit)
     assert_equal(Workbook::Cell.new("asdf"), c.default)
     assert_equal(:boolean, c.column_type)
     assert_raises(ArgumentError) { Workbook::Column.new(true) }
-    assert_raises(ArgumentError) { Workbook::Column.new(nil, {:limit=>20,:default=>"asdf", :column_type=>:bodfolean}) }
+    assert_raises(ArgumentError) { Workbook::Column.new(nil, {limit: 20, default: "asdf", column_type: :bodfolean}) }
   end
 
   def test_table
@@ -40,26 +39,31 @@ class TestColumn < Minitest::Test
 
   def test_column_type
     t = new_table
-    assert_equal([:boolean, :float, :string, :integer], t.columns.collect{|a| a.column_type})
+    assert_equal([:boolean, :float, :string, :integer], t.columns.collect { |a| a.column_type })
     t = new_table
     t.last.last.value = 1.1
-    assert_equal([:boolean, :float, :string, :string], t.columns.collect{|a| a.column_type})
+    assert_equal([:boolean, :float, :string, :string], t.columns.collect { |a| a.column_type })
     t = new_table
     t[2][3] = nil
-    assert_equal([:boolean, :float, :string, :integer], t.columns.collect{|a| a.column_type})
+    assert_equal([:boolean, :float, :string, :integer], t.columns.collect { |a| a.column_type })
     t = new_table
     t[2].delete_at(3)
-    assert_equal([:boolean, :float, :string, :integer], t.columns.collect{|a| a.column_type})
+    assert_equal([:boolean, :float, :string, :integer], t.columns.collect { |a| a.column_type })
   end
 
   def test_alpha_index_to_number_index
-    assert_equal(0,Workbook::Column.alpha_index_to_number_index("A"))
-    assert_equal(2,Workbook::Column.alpha_index_to_number_index("C"))
-    assert_equal(25,Workbook::Column.alpha_index_to_number_index("Z"))
-    assert_equal(26,Workbook::Column.alpha_index_to_number_index("AA"))
-    assert_equal(27,Workbook::Column.alpha_index_to_number_index("AB"))
-    assert_equal(51,Workbook::Column.alpha_index_to_number_index("AZ"))
-    assert_equal(52,Workbook::Column.alpha_index_to_number_index("BA"))
-    assert_equal((27*26)-1,Workbook::Column.alpha_index_to_number_index("ZZ"))
+    assert_equal(0, Workbook::Column.alpha_index_to_number_index("A"))
+    assert_equal(2, Workbook::Column.alpha_index_to_number_index("C"))
+    assert_equal(25, Workbook::Column.alpha_index_to_number_index("Z"))
+    assert_equal(26, Workbook::Column.alpha_index_to_number_index("AA"))
+    assert_equal(27, Workbook::Column.alpha_index_to_number_index("AB"))
+    assert_equal(51, Workbook::Column.alpha_index_to_number_index("AZ"))
+    assert_equal(52, Workbook::Column.alpha_index_to_number_index("BA"))
+    assert_equal((27 * 26) - 1, Workbook::Column.alpha_index_to_number_index("ZZ"))
+  end
+
+  def test_cells
+    assert_equal([3.2,3.2,3.2,3.1], new_table.columns[1].cells.map(&:value))
+    assert_equal([3.2,3.2,3.2,3.1], new_table.columns[1].map(&:value))
   end
-end
+end

data/test/test_format.rb

@@ -1,32 +1,29 @@
-# -*- encoding : utf-8 -*-
-require File.join(File.dirname(__FILE__), 'helper')
-
-class TestFormat < Minitest::Test
+# frozen_string_literal: true
 
+require File.join(File.dirname(__FILE__), "helper")
 
+class TestFormat < Minitest::Test
   def test_initialize
     f = Workbook::Format.new {}
-    assert_equal({},f)
-    f = Workbook::Format.new({:background=>:red})
-    assert_equal({:background=>:red},f)
-    f = Workbook::Format.new({:background=>:red})
+    assert_equal({}, f)
+    f = Workbook::Format.new({background: :red})
+    assert_equal({background: :red}, f)
+    f = Workbook::Format.new({background: :red})
     deet = Time.now
-    assert_equal(false,f.has_raw_for?(Time))
+    assert_equal(false, f.has_raw_for?(Time))
 
     f.add_raw deet
-    assert_equal(deet,f.raws[Time])
-    assert_equal(true,f.has_raw_for?(Time))
-
+    assert_equal(deet, f.raws[Time])
+    assert_equal(true, f.has_raw_for?(Time))
   end
 
   def test_derived_type
     f = Workbook::Format.new {}
     assert_nil(f.derived_type)
     f = Workbook::Format.new numberformat: "%m/%e/%y h:%m"
-    assert_equal(:time,f.derived_type)
+    assert_equal(:time, f.derived_type)
     f = Workbook::Format.new numberformat: "%m/%e/%y"
-    assert_equal(:date,f.derived_type)
-
+    assert_equal(:date, f.derived_type)
   end
 
   def test_available_raws
@@ -38,80 +35,81 @@ class TestFormat < Minitest::Test
   end
 
   def test_merge
-    a = Workbook::Format.new({:background=>:red})
-    b = Workbook::Format.new({:background=>:yellow, :color=>:green})
+    a = Workbook::Format.new({background: :red})
+    b = Workbook::Format.new({background: :yellow, color: :green})
     result = b.clone.merge(a)
-    assert_equal({:background=>:red, :color=>:green},result)
-    assert_equal(true,result.is_a?(Workbook::Format))
+    assert_equal({background: :red, color: :green}, result)
+    assert_equal(true, result.is_a?(Workbook::Format))
   end
 
   def test_remove_raw_on_merge
-    a = Workbook::Format.new({:background=>:red})
-    b = Workbook::Format.new({:background=>:yellow, :color=>:green})
+    a = Workbook::Format.new({background: :red})
+    b = Workbook::Format.new({background: :yellow, color: :green})
     b.add_raw Date.new
     result = b.clone.merge(a)
-    assert_equal({},result.raws)
+    assert_equal({}, result.raws)
   end
 
   def test_has_background_color?
     a = Workbook::Format.new
-    assert_equal(false,a.has_background_color?)
-    a = Workbook::Format.new({:background_color=>'#ff0000'})
-    assert_equal(true,a.has_background_color?)
-    assert_equal(false,a.has_background_color?('#00ff00'))
-    a = Workbook::Format.new({:background_color=>'#ffffff'})
-    assert_equal(false,a.has_background_color?)
-    a = Workbook::Format.new({:background_color=>'#FFFFFf'})
-    assert_equal(false,a.has_background_color?)
-
-
+    assert_equal(false, a.has_background_color?)
+    a = Workbook::Format.new({background_color: "#ff0000"})
+    assert_equal(true, a.has_background_color?)
+    assert_equal(false, a.has_background_color?("#00ff00"))
+    a = Workbook::Format.new({background_color: "#ffffff"})
+    assert_equal(false, a.has_background_color?)
+    a = Workbook::Format.new({background_color: "#FFFFFf"})
+    assert_equal(false, a.has_background_color?)
   end
 
   def test_to_css
-    a = Workbook::Format.new({:background_color=>'#ffffff'})
-    assert_equal("background: #ffffff",a.to_css)
-    a = Workbook::Format.new({:background_color=>'#fffdff', :color=>:red})
-    assert_equal("background: #fffdff; color: red",a.to_css)
-
+    a = Workbook::Format.new({background_color: "#ffffff"})
+    assert_equal("background: #ffffff", a.to_css)
+    a = Workbook::Format.new({background_color: "#fffdff", color: :red})
+    assert_equal("background: #fffdff; color: red", a.to_css)
   end
 
   def test_parent_style
-    a = Workbook::Format.new({:background_color=>'#ffffff'})
-    b = Workbook::Format.new({:color=>'#000'})
+    a = Workbook::Format.new({background_color: "#ffffff"})
+    b = Workbook::Format.new({color: "#000"})
     a.parent = b
     assert_equal(b, a.parent)
   end
+
   def test_parent_style_flattened_properties
-    a = Workbook::Format.new({:background_color=>'#ffffff'})
-    b = Workbook::Format.new({:color=>'#000'})
+    a = Workbook::Format.new({background_color: "#ffffff"})
+    b = Workbook::Format.new({color: "#000"})
     a.parent = b
-    assert_equal(Workbook::Format.new({:color=>'#000',:background_color=>'#ffffff'}), a.flattened)
-    c = Workbook::Format.new({:color=>'#f00'})
+    assert_equal(Workbook::Format.new({color: "#000", background_color: "#ffffff"}), a.flattened)
+    c = Workbook::Format.new({color: "#f00"})
     c.parent = a
-    assert_equal(Workbook::Format.new({:color=>'#f00',:background_color=>'#ffffff'}), c.flattened)
+    assert_equal(Workbook::Format.new({color: "#f00", background_color: "#ffffff"}), c.flattened)
   end
+
   def test_formats
-    a = Workbook::Format.new({:background_color=>'#ffffff'})
-    b = Workbook::Format.new({:color=>'#000'})
-    c = Workbook::Format.new({:color=>'#f00'})
+    a = Workbook::Format.new({background_color: "#ffffff"})
+    b = Workbook::Format.new({color: "#000"})
+    c = Workbook::Format.new({color: "#f00"})
     a.parent = b
     c.parent = a
-    assert_equal([b,a,c], c.formats)
+    assert_equal([b, a, c], c.formats)
   end
+
   def test_parent_style_to_css
-    a = Workbook::Format.new({:background_color=>'#ffffff'})
-    b = Workbook::Format.new({:color=>'#000'})
-    c = Workbook::Format.new({:color=>'#f00'})
+    a = Workbook::Format.new({background_color: "#ffffff"})
+    b = Workbook::Format.new({color: "#000"})
+    c = Workbook::Format.new({color: "#f00"})
     a.parent = b
     c.parent = a
     assert_equal("background: #ffffff; color: #f00", c.to_css)
   end
+
   def test_all_names
-    a = Workbook::Format.new({:background_color=>'#ffffff'}, "a")
-    b = Workbook::Format.new({:color=>'#000'},"b")
-    c = Workbook::Format.new({:color=>'#f00'},"c")
+    a = Workbook::Format.new({background_color: "#ffffff"}, "a")
+    b = Workbook::Format.new({color: "#000"}, "b")
+    c = Workbook::Format.new({color: "#f00"}, "c")
     a.parent = b
     c.parent = a
-    assert_equal(["b","a","c"],c.all_names)
+    assert_equal(["b", "a", "c"], c.all_names)
   end
 end

data/test/test_functional.rb

@@ -1,15 +1,16 @@
-# -*- encoding : utf-8 -*-
-require File.join(File.dirname(__FILE__), 'helper')
+# frozen_string_literal: true
+
+require File.join(File.dirname(__FILE__), "helper")
 
 class TestFunctional < Minitest::Test
-  def test_chapter_Initializing
+  def test_chapter_initializing
     b = Workbook::Book.new
     assert_equal(Workbook::Book, b.class)
     s = b.sheet
     assert_equal(Workbook::Sheet, s.class)
     t = s.table
     assert_equal(Workbook::Table, t.class)
-    s = b.sheet[0] = Workbook::Sheet.new([['a','b'],[1,2],[3,4],[5,6]])
+    s = b.sheet[0] = Workbook::Sheet.new([["a", "b"], [1, 2], [3, 4], [5, 6]])
     assert_equal(Workbook::Sheet, s.class)
 
     t = s.table
@@ -18,14 +19,14 @@ class TestFunctional < Minitest::Test
     assert_equal(Workbook::Cell, t.first.first.class)
     assert_equal(true, t.header.header?)
     assert_equal(false, t.last.header?)
-    assert_equal(2,t[1][:b].value)
+    assert_equal(2, t[1][:b].value)
   end
 
-  def test_chapter_Sorting
+  def test_chapter_sorting
     # b = Workbook::Book.new
     # s = b.sheet[0] = Workbook::Sheet.new([['a','b'],[1,2],[3,4],[5,6]])
     # t = s.table
-    #t.sort_by {|r| r[:b]}
-    #p t.inspect
+    # t.sort_by {|r| r[:b]}
+    # p t.inspect
   end
 end

data/test/test_modules_cache.rb

@@ -1,16 +1,18 @@
-# -*- encoding : utf-8 -*-
-require File.join(File.dirname(__FILE__), 'helper')
+# frozen_string_literal: true
+
+require File.join(File.dirname(__FILE__), "helper")
 
 class TestToCacheClass
   include Workbook::Modules::Cache
   def basic_fetch
-    fetch_cache(:a){
+    fetch_cache(:a) {
       sleep(0.5)
       "return"
     }
   end
+
   def expiring_fetch
-    fetch_cache(:a,Time.now+0.6){
+    fetch_cache(:a, Time.now + 0.6) {
       sleep(0.5)
       "return"
     }
@@ -24,29 +26,31 @@ module Modules
       c.debug_cache = false
       start_time = Time.now
       c.basic_fetch
-      diff_time = Time.now-start_time
-      assert_equal(true,(diff_time > 0.5 and diff_time < 0.51))
+      diff_time = Time.now - start_time
+      assert_equal(true, ((diff_time > 0.5) && (diff_time < 0.51)))
       c.basic_fetch
-      diff_time = Time.now-start_time
-      assert_equal(true,(diff_time > 0.5 and diff_time < 0.51))
+      diff_time = Time.now - start_time
+      assert_equal(true, ((diff_time > 0.5) && (diff_time < 0.51)))
       c.basic_fetch
-      diff_time = Time.now-start_time
-      assert_equal(true,(diff_time > 0.5 and diff_time < 0.51))
+      diff_time = Time.now - start_time
+      assert_equal(true, ((diff_time > 0.5) && (diff_time < 0.51)))
     end
+
     def test_basic_fetch_invalidate_cache!
       c = TestToCacheClass.new
       start_time = Time.now
       c.basic_fetch
-      diff_time = Time.now-start_time
-      assert_equal(true,(diff_time > 0.5 and diff_time < 0.51))
+      diff_time = Time.now - start_time
+      assert_equal(true, ((diff_time > 0.5) && (diff_time < 0.51)))
       c.basic_fetch
-      diff_time = Time.now-start_time
-      assert_equal(true,(diff_time > 0.5 and diff_time < 0.51))
+      diff_time = Time.now - start_time
+      assert_equal(true, ((diff_time > 0.5) && (diff_time < 0.51)))
       c.invalidate_cache!
       c.basic_fetch
-      diff_time = Time.now-start_time
-      assert_equal(true,(diff_time > 1 and diff_time < 1.01))
+      diff_time = Time.now - start_time
+      assert_equal(true, ((diff_time > 1) && (diff_time < 1.01)))
     end
+
     def test_basic_fetch_invalidate_by_expiration
       # c = TestToCacheClass.new
       # start_time = Time.now
@@ -63,6 +67,5 @@ module Modules
       # diff_time = Time.now-start_time
       # assert_equal(true,(diff_time > 1 and diff_time < 1.01))
     end
-
   end
 end