workbook 0.8.0 → 0.8.2

data/test/test_row.rb

@@ -1,31 +1,27 @@
-# -*- encoding : utf-8 -*-
-require File.join(File.dirname(__FILE__), 'helper')
-
-class TestRow < Minitest::Test
+# frozen_string_literal: true
 
+require File.join(File.dirname(__FILE__), "helper")
 
+class TestRow < Minitest::Test
   def test_init
     t = Workbook::Table.new
-    r = Workbook::Row.new([1,2,3],t)
-    c1 = Workbook::Cell.new(1)
-    c2 = Workbook::Cell.new(2)
-    c3 = Workbook::Cell.new(3)
-    assert_equal([c1,c2,c3].collect{|c| c.value},r.collect{|c| c.value})
+    r = Workbook::Row.new([1, 2, 3], t)
+    assert_equal([1, 2, 3], r.collect { |c| c.value })
 
-    #t = Workbook::Table.new
+    # t = Workbook::Table.new
     c1 = Workbook::Cell.new(1)
     c2 = Workbook::Cell.new(2)
     c3 = Workbook::Cell.new(3)
 
-    r = Workbook::Row.new([c1,c2,c3])
-
-    assert_equal([c1,c2,c3],r)
+    r = Workbook::Row.new([c1, c2, c3])
 
+    assert_equal([c1, c2, c3], r.cells)
+    assert_equal(Workbook::Row, r.class)
   end
 
   def test_table=
     r = Workbook::Row.new
-    assert_raises(ArgumentError, 'table should be a Workbook::Table (you passed a String)') { r.table = "asdf" }
+    assert_raises(ArgumentError, "table should be a Workbook::Table (you passed a String)") { r.table = "asdf" }
     r.table = nil
     assert_nil(r.table)
     r = Workbook::Row.new
@@ -72,9 +68,9 @@ class TestRow < Minitest::Test
     r1 = Workbook::Row.new
     r1.table = t
     assert_equal(true, r1.no_values?)
-    r1 << Workbook::Cell.new('abcd')
+    r1 << Workbook::Cell.new("abcd")
     assert_equal(false, r1.no_values?)
-    r2 = Workbook::Row.new [nil, '', nil, '', '']
+    r2 = Workbook::Row.new [nil, "", nil, "", ""]
     r2.table = t
     assert_equal(true, r2.no_values?)
   end
@@ -84,39 +80,41 @@ class TestRow < Minitest::Test
     assert_equal([:test, :asdfasd, :asdf_asdf, :asdf2], r1.to_symbols)
     r1 = Workbook::Row.new ["inït", "è-éë"]
     assert_equal([:init, :eee], r1.to_symbols)
-
   end
 
   def test_to_hash
     r1 = Workbook::Row.new ["test", "asdf-asd", "asdf - asdf", "asdf2"]
-    assert_raises(NoMethodError, 'undefined method `header\' for nil:NilClass') { r1.to_hash }
+    assert_raises(NoMethodError, "undefined method `header' for nil:NilClass") { r1.to_hash }
 
     t = Workbook::Table.new
-    r1 = Workbook::Row.new  ["test", "asdf-asd"]
+    r1 = Workbook::Row.new ["test", "asdf-asd"]
     r1.table = t
-    expected = {:test=>Workbook::Cell.new("test"), :asdfasd=>Workbook::Cell.new("asdf-asd")}
+    expected = {test: Workbook::Cell.new("test"), asdfasd: Workbook::Cell.new("asdf-asd")}
     assert_equal(expected, r1.to_hash)
     date = DateTime.now
-    r2 = Workbook::Row.new  [2, date]
+    r2 = Workbook::Row.new [2, date]
     r2.table = t
-    expected = {:test=>Workbook::Cell.new(2), :asdfasd=>Workbook::Cell.new(date)}
+    expected = {test: Workbook::Cell.new(2), asdfasd: Workbook::Cell.new(date)}
     assert_equal(expected, r2.to_hash)
     assert_equal(date, r2[:asdfasd].value)
     assert_equal(date, r2[1].value)
   end
 
-
   def test_to_hash_with_values
     t = Workbook::Table.new
-    r1 = Workbook::Row.new  ["test", "asdf-asd"]
+    r1 = Workbook::Row.new ["test", "asdf-asd"]
     r1.table = t
-    expected = {:test=>"test", :asdfasd=>"asdf-asd"}
+    expected = {test: "test", asdfasd: "asdf-asd"}
     assert_equal(expected, r1.to_hash_with_values)
     date = DateTime.now
-    r2 = Workbook::Row.new  [2, date]
+    r2 = Workbook::Row.new [2, date]
     r2.table = t
-    expected = {:test=>2, :asdfasd=>date}
+    expected = {test: 2, asdfasd: date}
     assert_equal(expected, r2.to_hash_with_values)
+    r3 = Workbook::Row.new [4]
+    r3.table = t
+    expected = {test: 4, asdfasd: nil}
+    assert_equal(expected, r3.to_hash_with_values)
   end
 
   def test_to_hash_cache
@@ -135,47 +133,46 @@ class TestRow < Minitest::Test
   end
 
   def test_compare
-    r1 = Workbook::Row.new  ["test", "asdf-asd"]
-    r2 = Workbook::Row.new  [nil, "asdf-asd"]
-    assert_equal(-1,r1<=>r2)
-    r1 = Workbook::Row.new  [1, "asdf-asd"]
-    r2 = Workbook::Row.new  ["test", "asdf-asd"]
-    assert_equal(-1,r1<=>r2)
-    r1 = Workbook::Row.new  [nil, "asdf-asd"]
-    r2 = Workbook::Row.new  [Time.now, "asdf-asd"]
-    assert_equal(1,r1<=>r2)
-    r1 = Workbook::Row.new  [2, 3]
-    r2 = Workbook::Row.new  [2, nil]
-    assert_equal(-1,r1<=>r2)
-    r1 = Workbook::Row.new  [3, 0]
-    r2 = Workbook::Row.new  [2, 100000]
-    assert_equal(1,r1<=>r2)
-    r1 = Workbook::Row.new  [-10, 3]
-    r2 = Workbook::Row.new  [nil, 5]
-    assert_equal(-1,r1<=>r2)
-
+    r1 = Workbook::Row.new ["test", "asdf-asd"]
+    r2 = Workbook::Row.new [nil, "asdf-asd"]
+    assert_equal(-1, r1 <=> r2)
+    r1 = Workbook::Row.new [1, "asdf-asd"]
+    r2 = Workbook::Row.new ["test", "asdf-asd"]
+    assert_equal(-1, r1 <=> r2)
+    r1 = Workbook::Row.new [nil, "asdf-asd"]
+    r2 = Workbook::Row.new [Time.now, "asdf-asd"]
+    assert_equal(1, r1 <=> r2)
+    r1 = Workbook::Row.new [2, 3]
+    r2 = Workbook::Row.new [2, nil]
+    assert_equal(-1, r1 <=> r2)
+    r1 = Workbook::Row.new [3, 0]
+    r2 = Workbook::Row.new [2, 100000]
+    assert_equal(1, r1 <=> r2)
+    r1 = Workbook::Row.new [-10, 3]
+    r2 = Workbook::Row.new [nil, 5]
+    assert_equal(-1, r1 <=> r2)
   end
 
   def test_find_cells_by_background_color
-    r = Workbook::Row.new  ["test", "asdf-asd"]
-    assert_equal([],r.find_cells_by_background_color)
+    r = Workbook::Row.new ["test", "asdf-asd"]
+    assert_equal([], r.find_cells_by_background_color)
     f = Workbook::Format.new
-    f[:background_color]='#ff00ff'
+    f[:background_color] = "#ff00ff"
     r.first.format = f
-    assert_equal([:test],r.find_cells_by_background_color)
-    assert_equal([],r.find_cells_by_background_color('#ff0000'))
+    assert_equal([:test], r.find_cells_by_background_color)
+    assert_equal([], r.find_cells_by_background_color("#ff0000"))
   end
 
   def test_to_s
     r1 = Workbook::Row.new ["test", "asdf-asd"]
-    assert_equal("test,asdf-asd\n",r1.to_csv)
+    assert_equal("test,asdf-asd\n", r1.to_csv)
   end
 
   def test_clone
     b = Workbook::Book.new
     table = b.sheet.table
-    table << Workbook::Row.new(["a","b"])
-    row = Workbook::Row.new(["1","2"])
+    table << Workbook::Row.new(["a", "b"])
+    row = Workbook::Row.new(["1", "2"])
     table << row
     table << row
     row[1] = Workbook::Cell.new(3)
@@ -187,61 +184,61 @@ class TestRow < Minitest::Test
   def test_clone_has_no_table
     b = Workbook::Book.new
     table = b.sheet.table
-    table << Workbook::Row.new(["a","b"])
-    table << Workbook::Row.new([1,2])
+    table << Workbook::Row.new(["a", "b"])
+    table << Workbook::Row.new([1, 2])
     row = table[1].clone
     assert_nil(row[:a])
     assert_nil(row[:b])
-    assert_equal(1,row[0].value)
-    assert_equal(2,row[1].value)
+    assert_equal(1, row[0].value)
+    assert_equal(2, row[1].value)
   end
 
   def test_push
     b = Workbook::Book.new
     table = b.sheet.table
-    table << Workbook::Row.new(["a","b"])
-    table << Workbook::Row.new([1,2])
-    assert_equal(1,table[1][:a].value)
-    assert_equal(2,table[1][:b].value)
+    table << Workbook::Row.new(["a", "b"])
+    table << Workbook::Row.new([1, 2])
+    assert_equal(1, table[1][:a].value)
+    assert_equal(2, table[1][:b].value)
     b = Workbook::Book.new
     table = b.sheet.table
-    table.push Workbook::Row.new(["a","b"])
-    table.push Workbook::Row.new([1,2])
-    assert_equal(1,table[1][:a].value)
-    assert_equal(2,table[1][:b].value)
+    table.push Workbook::Row.new(["a", "b"])
+    table.push Workbook::Row.new([1, 2])
+    assert_equal(1, table[1][:a].value)
+    assert_equal(2, table[1][:b].value)
   end
 
   def test_assign
     b = Workbook::Book.new
     table = b.sheet.table
-    table.push Workbook::Row.new(["a","b"])
-    table[1] = Workbook::Row.new([1,2])
-    assert_equal(1,table[1][:a].value)
-    assert_equal(2,table[1][:b].value)
+    table.push Workbook::Row.new(["a", "b"])
+    table[1] = Workbook::Row.new([1, 2])
+    assert_equal(1, table[1][:a].value)
+    assert_equal(2, table[1][:b].value)
 
     b = Workbook::Book.new
     table = b.sheet.table
-    table.push Workbook::Row.new(["a","b"])
-    table[1] = [1,2]
-    assert_equal(1,table[1][:a].value)
-    assert_equal(2,table[1][:b].value)
+    table.push Workbook::Row.new(["a", "b"])
+    table[1] = [1, 2]
+    assert_equal(1, table[1][:a].value)
+    assert_equal(2, table[1][:b].value)
   end
 
   def test_preservation_of_format_on_assign
-    row = Workbook::Row.new([1,2])
+    row = Workbook::Row.new([1, 2])
     cellformat = row.first.format
-    cellformat["background"]="#f00"
+    cellformat["background"] = "#f00"
     row[0] = 3
-    assert_equal(3,row[0].value)
-    assert_equal("#f00",row[0].format["background"])
+    assert_equal(3, row[0].value)
+    assert_equal("#f00", row[0].format["background"])
   end
 
   def test_find_by_string
     b = Workbook::Book.new
     table = b.sheet.table
-    table << Workbook::Row.new(["a","b"])
-    row = Workbook::Row.new([],table)
-    row[1]= 12
+    table << Workbook::Row.new(["a", "b"])
+    row = Workbook::Row.new([], table)
+    row[1] = 12
     assert_equal(12, table.last["b"])
     assert_nil(table.last["a"])
   end
@@ -249,9 +246,9 @@ class TestRow < Minitest::Test
   def test_find_by_column_string
     b = Workbook::Book.new
     table = b.sheet.table
-    table << Workbook::Row.new(["b","a"])
-    row = Workbook::Row.new([],table)
-    row[1]= 12
+    table << Workbook::Row.new(["b", "a"])
+    row = Workbook::Row.new([], table)
+    row[1] = 12
     assert_equal(12, table.last["B"])
     assert_nil(table.last["A"])
   end
@@ -259,15 +256,15 @@ class TestRow < Minitest::Test
   def test_row_hash_index_string_assignment
     b = Workbook::Book.new
     table = b.sheet.table
-    table << Workbook::Row.new(["a","b","d"])
-    row = Workbook::Row.new([],table)
-    row[1]= 12
+    table << Workbook::Row.new(["a", "b", "d"])
+    row = Workbook::Row.new([], table)
+    row[1] = 12
     assert_equal(12, table.last.last.value)
-    row[:b]= 15
+    row[:b] = 15
     assert_equal(15, table.last.last.value)
-    row["b"]= 18
+    row["b"] = 18
     assert_equal(18, table.last.last.value)
-    row["C"]= 2
+    row["C"] = 2
     assert_equal(2, table.last[2].value)
   end
 
@@ -338,7 +335,6 @@ class TestRow < Minitest::Test
     d = a.trim
     assert_equal(b, a)
     assert_equal(c, d)
-
   end
 
   def test_add
@@ -348,40 +344,42 @@ class TestRow < Minitest::Test
     a << "asdf"
     a << 2.2
     a.push(5)
-    assert_equal(1,a[0].value)
-    assert_equal(2,a[1].value)
-    assert_equal("asdf",a[2].value)
-    assert_equal(2.2,a[3].value)
-    assert_equal(5,a[4].value)
+    assert_equal(1, a[0].value)
+    assert_equal(2, a[1].value)
+    assert_equal("asdf", a[2].value)
+    assert_equal(2.2, a[3].value)
+    assert_equal(5, a[4].value)
   end
 
   def test_plus
-    header = Workbook::Row.new([:a,:b])
+    header = Workbook::Row.new([:a, :b])
     a = Workbook::Row.new
     table = Workbook::Table.new
     table << header
     table << a
     assert_equal(table, a.table)
-    assert_equal(Workbook::Row, (a + [1,1]).class )
-    assert_equal([1,1],(a + [1,1]).to_a )
-    assert_equal(Workbook::Cell,(a + [1,1])[0].class )
-    a += [1,1]
-    assert_equal([1,1],a.to_a )
-    assert_equal(Workbook::Row, a.class )
+    assert_equal(Workbook::Row, (a + [1, 1]).class)
+    assert_equal([1, 1], (a + [1, 1]).to_a)
+    assert_equal(Workbook::Cell, (a + [1, 1])[0].class)
+    a += [1, 1]
+    assert_equal([1, 1], a.to_a)
+    assert_equal(Workbook::Row, a.class)
     assert_nil(a.table)
-    assert_equal(Workbook::Cell,a[0].class)
+    assert_equal(Workbook::Cell, a[0].class)
   end
 
   def test_concat
-    header = Workbook::Row.new([:a,:b])
+    header = Workbook::Row.new([:a, :b])
     a = Workbook::Row.new
     table = Workbook::Table.new
     table << header
     table << a
-    a.concat [1,1]
-    assert_equal([1,1],a.to_a )
-    assert_equal(Workbook::Row, a.class )
+
+    a.concat [1, 1]
+
+    assert_equal([1, 1], a.to_a)
+    assert_equal(Workbook::Row, a.class)
     assert_equal(table, a.table)
-    assert_equal(Workbook::Cell,a[0].class)
+    assert_equal(Workbook::Cell, a[0].class)
   end
 end

data/test/test_sheet.rb

@@ -1,36 +1,41 @@
-# -*- 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_init
-    w = Workbook::Sheet.new nil
-    assert_equal([[]],w)
-    assert_equal(w.count,1)
-    w = Workbook::Sheet.new
-    assert_equal([Workbook::Table.new],w)
-    assert_equal(w.count,1)
+    s = Workbook::Sheet.new nil
+    assert_equal(Workbook::Sheet, s.class)
+    assert_equal(s.count, 1)
+
+    s = Workbook::Sheet.new
+    assert_equal(Workbook::Sheet, s.class)
+    assert_equal(s.count, 1)
+
     t = Workbook::Table.new []
-    w = Workbook::Sheet.new t
-    assert_equal([t],w)
-    assert_equal(w.count,1)
+    s = Workbook::Sheet.new t
+    assert_equal(Workbook::Sheet, s.class)
+    assert_equal(t, s.table)
+    assert_equal(s.count, 1)
   end
 
   def test_table
     w = Workbook::Sheet.new nil
-    assert_equal([],w.table)
+    assert_equal(Workbook::Table.new([]), w.table)
     t = Workbook::Table.new []
     w = Workbook::Sheet.new t
-    assert_equal(w.table,t)
+    assert_equal(w.table, t)
   end
 
   def test_table_assignment
     t = Workbook::Table.new []
     s = Workbook::Sheet.new t
-    assert_equal(s.table,t)
-    data = [["a","b"],[1,2]]
-    s.table=data
-    assert_equal("a",s.table["A1"].value)
-    assert_equal(2,s.table["B2"].value)
+    assert_equal(s.table, t)
+
+    data = [["a", "b"], [1, 2]]
+    s.table = data
+    assert_equal("a", s.table["A1"].value)
+    assert_equal(2, s.table["B2"].value)
   end
 
   def test_book
@@ -42,45 +47,48 @@ class TestWorkbook < Minitest::Test
   end
 
   def test_clone
-    w = Workbook::Book.new [["a","b"],[1,2],[3,4]]
+    w = Workbook::Book.new [["a", "b"], [1, 2], [3, 4]]
     s = w.sheet
-    assert_equal(3,s.table[2][:a])
+
+    assert_equal(3, s.table[2][:a])
+
     s2 = s.clone
+
     s2.table[2][:a] = 5
-    assert_equal(3,s.table[2][:a])
-    assert_equal(5,s2.table[2][:a])
+    assert_equal(3, s.table[2][:a])
+    assert_equal(5, s2.table[2][:a])
   end
 
   def test_create_or_open_table_at
     s = Workbook::Sheet.new
-    table0=s.create_or_open_table_at(0)
+    table0 = s.create_or_open_table_at(0)
     assert_equal(Workbook::Table, table0.class)
     assert_equal(s, table0.sheet)
-    table1=s.create_or_open_table_at(1)
+    table1 = s.create_or_open_table_at(1)
     assert_equal(Workbook::Table, table1.class)
     assert_equal(s, table1.sheet)
-    table1<<Workbook::Row.new([1,2,3,4])
+    table1 << Workbook::Row.new([1, 2, 3, 4])
     assert_equal(false, table1 == table0)
   end
+
   def test_profile_speed
-    w = Workbook::Book.new [["a","b"],[1,2],[3,4],[1,2],[3,4],[1,2],[3,4],[1,2],[3,4],[1,2],[3,4],[1,2],[3,4],[1,2],[3,4],[1,2],[3,4],[1,2],[3,4],[1,2],[3,4],[1,2],[3,4],[1,2],[3,4],[1,2],[3,4],[1,2],[3,4],[1,2],[3,4],[1,2],[3,4],[1,2],[3,4],[1,2],[3,4]]
-    require 'ruby-prof'
+    w = Workbook::Book.new [["a", "b"], [1, 2], [3, 4], [1, 2], [3, 4], [1, 2], [3, 4], [1, 2], [3, 4], [1, 2], [3, 4], [1, 2], [3, 4], [1, 2], [3, 4], [1, 2], [3, 4], [1, 2], [3, 4], [1, 2], [3, 4], [1, 2], [3, 4], [1, 2], [3, 4], [1, 2], [3, 4], [1, 2], [3, 4], [1, 2], [3, 4], [1, 2], [3, 4], [1, 2], [3, 4], [1, 2], [3, 4]]
+    require "ruby-prof"
     RubyProf.start
     w.sheet.table.each do |row|
-       row[:a].value
+      row[:a].value
     end
     result = RubyProf.stop
     printer = RubyProf::MultiPrinter.new(result)
-    printer.print(:path => ".", :profile => "profile")
-
+    printer.print(path: ".", profile: "profile")
   end
+
   def test_name
-    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::Book.new [["a", "b"], [1, 2]]
+    b.push Workbook::Sheet.new([["a", "b"], [2, 2]])
+    b.push Workbook::Sheet.new([["a", "b"], [3, 2]])
 
     # puts b.index b.last
-    assert_equal(["Sheet 1", "Sheet 2", "Sheet 3"], b.collect{|a| a.name})
+    assert_equal(["Sheet 1", "Sheet 2", "Sheet 3"], b.collect { |a| a.name })
   end
-
 end