workbook 0.8.1 → 0.9.0

data/test/test_table.rb

@@ -1,39 +1,41 @@
 # frozen_string_literal: true
 
-# -*- encoding : utf-8 -*-
-require File.join(File.dirname(__FILE__), 'helper')
+require File.join(File.dirname(__FILE__), "helper")
 
-class TestTable< Minitest::Test
+class TestTable < Minitest::Test
   def test_initialize
     t = Workbook::Table.new
-    assert_equal(t,[])
+    assert_equal([], t.rows)
     c = Workbook::Cell.new("celllll")
     t = Workbook::Table.new [[c]]
 
-    assert_equal([[c]],t)
+    assert_equal([[c]], t.rows.map(&:cells))
   end
+
   def test_header
     t = Workbook::Table.new
     assert_nil(t.header)
     t = Workbook::Table.new [[1]]
-    assert_equal(t.header,[1])
-    assert_equal(t.header.class,Workbook::Row)
+    assert_equal(t.header, [1])
+    assert_equal(t.header.class, Workbook::Row)
   end
 
   def test_new_row
     t = Workbook::Table.new
     assert_equal(t.count, 0)
 
-    r = t.new_row [1,2,3,4]
-    assert_equal(r, [1,2,3,4])
+    r = t.new_row [1, 2, 3, 4]
+    assert_equal(r, [1, 2, 3, 4])
     assert_equal(r.class, Workbook::Row)
-    assert_equal(1,t.count)
+    assert_equal(1, t.count)
 
     r = t.new_row
     assert_equal(r.empty?, true)
     assert_equal(r.class, Workbook::Row)
 
     assert_equal(2, t.count)
+
+    assert_equal(r, t.rows.last)
     assert_equal(r, t.last)
 
     r << 2
@@ -43,19 +45,19 @@ class TestTable< Minitest::Test
 
   def test_append_row
     t = Workbook::Table.new
-    row = t.new_row(["a","b"])
+    row = t.new_row(["a", "b"])
     assert_equal(row, t.header)
-    row = Workbook::Row.new([1,2])
+    row = Workbook::Row.new([1, 2])
     assert_nil(row.table)
     t.push(row)
     assert_equal(t, row.table)
-    row = Workbook::Row.new([3,4])
+    row = Workbook::Row.new([3, 4])
     assert_nil(row.table)
     t << row
     assert_equal(t, row.table)
     t = Workbook::Table.new
-    t << [1,2,3,4]
-    assert_equal(Workbook::Row,t.first.class)
+    t << [1, 2, 3, 4]
+    assert_equal(Workbook::Row, t.first.class)
   end
 
   def test_sheet
@@ -72,56 +74,65 @@ class TestTable< Minitest::Test
   end
 
   def test_delete_all
-    w = Workbook::Book.new [["a","b"],[1,2],[3,4]]
+    w = Workbook::Book.new [["a", "b"], [1, 2], [3, 4]]
     t = w.sheet.table
     t.delete_all
-    assert_equal(Workbook::Table,t.class)
-    assert_equal(0,t.count)
+    assert_equal(Workbook::Table, t.class)
+    assert_equal(0, t.count)
   end
 
   def test_clone
-    w = Workbook::Book.new [["a","b"],[1,2],[3,4]]
+    w = Workbook::Book.new [["a", "b"], [1, 2], [3, 4]]
     t = w.sheet.table
-    assert_equal(3,t[2][:a])
+    assert_equal(3, t[2][:a])
     t2 = t.clone
     t2[2][:a] = 5
-    assert_equal(3,t[2][:a])
-    assert_equal(5,t2[2][:a])
+    assert_equal(3, t[2][:a])
+    assert_equal(5, t2[2][:a])
   end
 
   def test_clone_custom_header
-    w = Workbook::Book.new [[nil, nil],["a","b"],[1,2],[3,4]]
+    w = Workbook::Book.new [[nil, nil], ["a", "b"], [1, 2], [3, 4]]
     t = w.sheet.table
-    t.header=t[1]
-    assert_equal(3,t[3][:a])
+    t.header = t[1]
+    assert_equal(3, t[3][:a])
     t2 = t.clone
+    assert_equal(1, t2.header_row_index)
+
     t2[3][:a] = 5
-    assert_equal(3,t[3][:a])
-    assert_equal(5,t2[3][:a])
+    assert_equal(3, t[3][:a])
+    assert_equal(5, t2[3][:a])
   end
 
   def test_spreadsheet_style_cell_addressing
-    w = Workbook::Book.new [[nil, nil],["a","b"],[1,2],[3,4]]
+    w = Workbook::Book.new [[nil, nil], ["a", "b"], [1, 2], [3, 4]]
     t = w.sheet.table
     assert_nil(t["A1"].value)
     assert_nil(t["B1"].value)
-    assert_equal("a",t["A2"].value)
-    assert_equal("b",t["B2"].value)
-    assert_equal(1,t["A3"].value)
-    assert_equal(2,t["B3"].value)
-    assert_equal(3,t["A4"].value)
-    assert_equal(4,t["B4"].value)
+    assert_equal("a", t["A2"].value)
+    assert_equal("b", t["B2"].value)
+    assert_equal(1, t["A3"].value)
+    assert_equal(2, t["B3"].value)
+    assert_equal(3, t["A4"].value)
+    assert_equal(4, t["B4"].value)
+    assert_equal(["b", 2, 4], t["B"].map(&:value))
+  end
+
+  def test_column_retrieval_trough_symbol
+    t = Workbook::Book.new([["a", "Andere Kolom"], [1, 2], [3, 4]]).sheet.table
+    assert_equal([1, 3], t[:a].map(&:value))
+    assert_equal([2, 4], t[:andere_kolom].map(&:value))
   end
 
   def test_multirowselect_through_collections
-    w = Workbook::Book.new [["a","b"],[1,2],[3,4]]
+    w = Workbook::Book.new [["a", "b"], [1, 2], [3, 4]]
     t = w.sheet.table
-    assert_equal(Workbook::Table,t[0..2].class)
-    assert_equal(2,t[0..2][1][1])
+    assert_equal(Workbook::Table, t[0..2].class)
+    assert_equal(2, t[0..2][1][1])
   end
 
   def test_table
-    w = Workbook::Book.new [[nil,nil],["a","b"],[1,2],[3,4]]
+    w = Workbook::Book.new [[nil, nil], ["a", "b"], [1, 2], [3, 4]]
     t = w.sheet.table
     w2 = Workbook::Book.new
     w2.sheet.table = t[2..3]
@@ -129,7 +140,7 @@ class TestTable< Minitest::Test
   end
 
   def test_array_style_assignment
-    w = Workbook::Book.new [["a","b"],[1,2],[3,4]]
+    w = Workbook::Book.new [["a", "b"], [1, 2], [3, 4]]
     t = w.sheet.table
     r = t[1].clone
     assert_nil(r.table)
@@ -138,7 +149,7 @@ class TestTable< Minitest::Test
   end
 
   def test_delete_at
-    w = Workbook::Book.new [["a","b"],[1,2],[3,4]]
+    w = Workbook::Book.new [["a", "b"], [1, 2], [3, 4]]
     t = w.sheet.table
     t.delete_at 2
     assert_equal(1, t.last.first.value)
@@ -146,50 +157,61 @@ class TestTable< Minitest::Test
 
   def test_trim!
     t = Workbook::Table.new
-    t << [1,2,3]
-    t << [1,2,nil,nil]
+    t << [1, 2, 3]
+    t << [1, 2, nil, nil]
     t.trim!
-    assert_equal("1,2,3\n1,2,\n",t.to_csv)
+    assert_equal("1,2,3\n1,2,\n", t.to_csv)
     t = Workbook::Table.new
-    t << [1,2,3]
+    t << [1, 2, 3]
     t << [nil]
-    t << [1,2,nil,nil]
-    t << [nil,nil,nil,nil]
-    t << [nil,nil,nil,nil]
+    t << [1, 2, nil, nil]
+    t << [nil, nil, nil, nil]
+    t << [nil, nil, nil, nil]
     t.trim!
-    assert_equal("1,2,3\n,,\n1,2,\n",t.to_csv)
+    assert_equal("1,2,3\n,,\n1,2,\n", t.to_csv)
   end
+
   def test_performance
     table = Workbook::Table.new
-    headers = 100.times.collect{|a| "header#{a}"}
-    first_row = 100.times.collect{|a| Time.now}
+    headers = 100.times.collect { |a| "header#{a}" }
+    first_row = 100.times.collect { |a| Time.now }
     table << headers.shuffle
     table << first_row
     1000.times do |times|
       row = table[1].clone
       table << row
       headers.each do |a|
-        row[a.to_sym]=Time.now
+        row[a.to_sym] = Time.now
       end
     end
-    last_line = table.count-1
+    last_line = table.count - 1
     delta_start = table[12][0].value - table[2][0].value
-    delta_end = table[last_line][0].value - table[last_line-10][0].value
-    average_run_time = (delta_start+delta_end / 20)
+    delta_end = table[last_line][0].value - table[last_line - 10][0].value
+    average_run_time = (delta_start + delta_end / 20)
     if (delta_end - delta_start) > average_run_time
       puts "Performance issue"
     end
   end
+
   def test_columns
     table = Workbook::Table.new([[]])
-    assert_equal(table.columns,[])
-    table = Workbook::Table.new([[:a,:b],[1,2]])
-    assert_equal(table.columns.count,2)
+    assert_equal(table.columns, [])
+    table = Workbook::Table.new([[:a, :b], [1, 2]])
+    assert_equal(table.columns.count, 2)
   end
+
   def test_dimensions
     table = Workbook::Table.new([[]])
-    assert_equal([0,1],table.dimensions)
-    table = Workbook::Table.new([[:a,:b],[1,2,3,4]])
-    assert_equal([4,2],table.dimensions)
+    assert_equal([0, 1], table.dimensions)
+    table = Workbook::Table.new([[:a, :b], [1, 2, 3, 4]])
+    assert_equal([4, 2], table.dimensions)
+  end
+
+  def test_push
+    table = Workbook::Table.new([["a", 2, 3]])
+    table.push(["b", 2, 3])
+    assert_equal("b", table[1][0].value)
+    table.push(["c", 2, 3], ["d", 2, 3])
+    assert_equal("d", table[3][0].value)
   end
 end

data/test/test_template.rb

@@ -1,41 +1,42 @@
 # frozen_string_literal: true
 
-# -*- encoding : utf-8 -*-
-require File.join(File.dirname(__FILE__), 'helper')
+require File.join(File.dirname(__FILE__), "helper")
 
 class TestTemplate < Minitest::Test
-
   def test_initalize
     t = Workbook::Template.new
-    assert_equal(true,(t.methods.include?(:add_raw) or t.methods.include?("add_raw")))
-    assert_equal(true,(t.methods.include?(:has_raw_for?) or t.methods.include?("has_raw_for?")))
-    assert_equal(true,(t.methods.include?(:raws) or t.methods.include?("raws")))
+    assert_equal(true, (t.methods.include?(:add_raw) || t.methods.include?("add_raw")))
+    assert_equal(true, (t.methods.include?(:has_raw_for?) || t.methods.include?("has_raw_for?")))
+    assert_equal(true, (t.methods.include?(:raws) || t.methods.include?("raws")))
   end
 
   def test_add_raw_and_has_raw_for
     t = Workbook::Template.new
     t.add_raw "asdfsadf"
-    assert_equal(false,t.has_raw_for?(Integer))
-    assert_equal(true,t.has_raw_for?(String))
+    assert_equal(false, t.has_raw_for?(Integer))
+    assert_equal(true, t.has_raw_for?(String))
   end
+
   def test_raws
     t = Workbook::Template.new
     t.add_raw "asdfsadf"
-    assert_equal({String=>"asdfsadf"}, t.raws)
+    assert_equal({String => "asdfsadf"}, t.raws)
   end
+
   def test_set_default_formats!
     t = Workbook::Template.new
     t.set_default_formats!
-    assert_equal({font_weight: "bold"},t.formats[:header][:default])
+    assert_equal({font_weight: "bold"}, t.formats[:header][:default])
   end
+
   def test_add_formats
     t = Workbook::Template.new
-    t.add_format Workbook::Format.new({font:"Arial"})
-    t.add_format Workbook::Format.new({font:"Times"})
-    assert_equal(2,t.formats.keys.count)
-    named_format = Workbook::Format.new({font:"Times"})
+    t.add_format Workbook::Format.new({font: "Arial"})
+    t.add_format Workbook::Format.new({font: "Times"})
+    assert_equal(2, t.formats.keys.count)
+    named_format = Workbook::Format.new({font: "Times"})
     named_format.name = 1
     t.add_format named_format
-    assert_equal(2,t.formats.keys.count)
+    assert_equal(2, t.formats.keys.count)
   end
 end

data/test/test_types_date.rb

@@ -1,16 +1,14 @@
 # frozen_string_literal: true
 
-# -*- encoding : utf-8 -*-
-require File.join(File.dirname(__FILE__), 'helper')
+require File.join(File.dirname(__FILE__), "helper")
 
 class TestTypesDate < Minitest::Test
   def test_init
-    w = Workbook::Types::Date.new(2001,2,2)
+    w = Workbook::Types::Date.new(2001, 2, 2)
     assert_equal(Workbook::Types::Date, w.class)
-    assert_equal(Date.new(2001,2,2),w)
-    assert_equal(Date.new(2001,2,2),w.value)
+    assert_equal(Date.new(2001, 2, 2), w)
+    assert_equal(Date.new(2001, 2, 2), w.value)
     assert_equal(true, w.is_a?(Date))
     assert_equal(true, w.is_a?(Workbook::Modules::Cell))
-
   end
 end

data/test/test_writers_csv_writer.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require File.join(File.dirname(__FILE__), "helper")
+module Readers
+  class TestCsvWriter < Minitest::Test
+    def test_to_csv
+      w = Workbook::Book.new
+      w.import File.join(File.dirname(__FILE__), "artifacts/simple_csv.csv")
+      # reads
+      #       a,b,c,d
+      #       1,2,3,4
+      #       5,3,2,1
+      #       "asdf",123,12,2001-02-02
+      #
+      assert_equal("untitled document.csv", w.sheet.table.write_to_csv)
+      csv_result = File.read("untitled document.csv").split("\n")
+      csv_original = File.read(File.join(File.dirname(__FILE__), "artifacts/simple_csv.csv")).split("\n")
+      assert_equal(csv_original[0], csv_result[0])
+      assert_equal(csv_original[1], csv_result[1])
+      assert_equal(csv_original[2], csv_result[2])
+      assert_equal(csv_original[3], csv_result[3])
+    end
+  end
+end

data/test/test_writers_html_writer.rb

@@ -1,75 +1,76 @@
 # frozen_string_literal: true
 
-# -*- encoding : utf-8 -*-
-require File.join(File.dirname(__FILE__), 'helper')
+require File.join(File.dirname(__FILE__), "helper")
 
 module Writers
   class TestHtmlWriter < Minitest::Test
     def test_to_html
-      #jruby and ruby's output differ a bit... both produce valid results though
+      # jruby and ruby's output differ a bit... both produce valid results though
       # match = Workbook::Book.new.to_html.match(/<table \/>/) ? true : false #jruby
       # puts Workbook::Book.new.to_html
       # match = (Workbook::Book.new.to_html.match(/<table><thead><\/thead><tbody><\/tbody><\/table>/) ? true : false) if match == false #ruby
       # assert_equal(true, match)
-      html = Workbook::Book.new([['a','b'],[1,2],[3,4]]).to_html
-      match = html.match(/<table><\/table>/) ? true : false
-      assert_equal(false, match)
-      match = html.match(/<td>1<\/td>/) ? true : false
-      assert_equal(true, match)
-      match = html.match(/<th class=\"a\" data-key=\"a\">a<\/th>/) ? true : false
-      assert_equal(true, match)
+      html = Workbook::Book.new([["a", "b"], [1, 2], [3, 4]]).to_html
+
+      assert_match(/<td>1<\/td>/, html)
+      assert_match(/<th class="a" data-key="a">a<\/th>/, html)
     end
+
     def test_to_html_format_names
-      b = Workbook::Book.new([['a','b'],[1,2],[3,4]])
+      b = Workbook::Book.new([["a", "b"], [1, 2], [3, 4]])
       c = b[0][0][0][0]
-      c.format.name="testname"
+      c.format.name = "testname"
       c = b[0][0][1][0]
-      c.format.name="testname"
+      c.format.name = "testname"
+
       html = b.to_html
-      match = html.match(/<th class=\"testname a\" data-key=\"a\">a<\/th>/) ? true : false
-      assert_equal(true, match)
-      match = html.match(/<td class=\"testname\">1<\/td>/) ? true : false
-      assert_equal(true, match)
+
+      assert_match(/<th class="testname a" data-key="a">a<\/th>/, html)
+      assert_match(/<td class="testname">1<\/td>/, html)
     end
+
     def test_build_cell_options
-      b = Workbook::Book.new([['a','b'],[1,2],[3,4]])
-      result = b.sheet.table.build_cell_options(b.sheet.table.first.first,{data: {a:"a"}})
-      assert("a",result["data-a"])
+      b = Workbook::Book.new([["a", "b"], [1, 2], [3, 4]])
+      result = b.sheet.table.build_cell_options(b.sheet.table.first.first, {data: {a: "a"}})
+
+      assert_equal("a", result[:"data-a"])
     end
+
     def test_to_html_css
-      b = Workbook::Book.new([['a','b'],[1,2],[3,4]])
+      b = Workbook::Book.new([["a", "b"], [1, 2], [3, 4]])
       c = b[0][0][0][0]
-      c.format[:background]="#f00"
+      c.format[:background] = "#f00"
       c = b[0][0][1][0]
-      c.format[:background]="#ff0"
+      c.format[:background] = "#ff0"
+
       html = b.to_html
-      match = html.match(/<th class=\"a\" data-key=\"a\">a<\/th>/) ? true : false
-      assert_equal(true, match)
-      match = html.match(/<td>1<\/td>/) ? true : false
-      assert_equal(true, match)
-      html = b.to_html({:style_with_inline_css=>true})
-      match = html.match(/<th class=\"a\" data-key=\"a\" style=\"background: #f00\">a<\/th>/) ? true : false
-      assert_equal(true, match)
-      match = html.match(/<td style="background: #ff0">1<\/td>/) ? true : false
-      assert_equal(true, match)
+      assert_match(/<th class="a" data-key="a">a<\/th>/, html)
+      assert_match(/<td>1<\/td>/, html)
+
+      html = b.to_html({style_with_inline_css: true})
+      assert_match(/<th class="a" data-key="a" style="background: #f00">a<\/th>/, html)
+      assert_match(/<td style="background: #ff0">1<\/td>/, html)
     end
+
     def test_sheet_and_table_names
-      b = Workbook::Book.new([['a','b'],[1,2],[3,4]])
+      b = Workbook::Book.new([["a", "b"], [1, 2], [3, 4]])
       b.sheet.name = "Sheet name"
       b.sheet.table.name = "Table name"
+
       html = b.to_html
-      assert_equal(true, (html.match(/<h1>Sheet name<\/h1>/) ? true : false) )
-      assert_equal(true, (html.match(/<h2>Table name<\/h2>/) ? true : false) )
+
+      assert_match(/<h1>Sheet name<\/h1>/, html)
+      assert_match(/<h2>Table name<\/h2>/, html)
     end
+
     def test_col_and_rowspans
       w = Workbook::Book.new
-      w.import File.join(File.dirname(__FILE__), 'artifacts/sheet_with_combined_cells.ods')
+      w.import File.join(File.dirname(__FILE__), "artifacts/sheet_with_combined_cells.ods")
       html = w.to_html
-      assert_equal(true, (html.match(/rowspan="2">15 nov 11 15 nov 11/) ? true : false) )
-      if RUBY_VERSION >= "1.9"
-        assert_equal(true, (html.match(/colspan="2" rowspan="2">13 mrt 12 15 mrt 12 13 mrt 12 15 mrt 12/) ? true : false) )
-        assert_equal(true, (html.match(/colspan="2">14 90589/) ? true : false) )
-      end
+      assert_match(/rowspan="2">15 nov 11 15 nov 11/, html)
+
+      assert_match(/colspan="2" rowspan="2">13 mrt 12 15 mrt 12 13 mrt 12 15 mrt 12/, html)
+      assert_match(/colspan="2">14 90589/, html)
     end
   end
 end

data/test/test_writers_json_writer.rb

@@ -1,21 +1,28 @@
 # frozen_string_literal: true
 
-# -*- encoding : utf-8 -*-
-require File.join(File.dirname(__FILE__), 'helper')
+require File.join(File.dirname(__FILE__), "helper")
 
 module Writers
   class TestJsonWriter < Minitest::Test
     def test_to_array_of_hashes_with_values
-      assert_equal([],Workbook::Table.new.to_array_of_hashes_with_values)
-      assert_equal([],Workbook::Table.new([["a","b"]]).to_array_of_hashes_with_values)
-      assert_equal([{:a=>1,:b=>2},{:a=>Date.new(2012,1,1),:b=>nil}],
-        Workbook::Table.new([["a","b"],[1,2],[Date.new(2012,1,1),nil]]).to_array_of_hashes_with_values)
+      assert_equal([], Workbook::Table.new.to_array_of_hashes_with_values)
+      assert_equal([], Workbook::Table.new([["a", "b"]]).to_array_of_hashes_with_values)
+      assert_equal([{a: 1, b: 2}, {a: Date.new(2012, 1, 1), b: nil}],
+        Workbook::Table.new([["a", "b"], [1, 2], [Date.new(2012, 1, 1), nil]]).to_array_of_hashes_with_values)
     end
+
     def test_to_json
-      assert_equal("[]",Workbook::Table.new.to_json)
-      assert_equal("[]",Workbook::Table.new([["a","b"]]).to_json)
+      assert_equal("[]", Workbook::Table.new.to_json)
+      assert_equal("[]", Workbook::Table.new([["a", "b"]]).to_json)
       assert_equal("[{\"a\":1,\"b\":2},{\"a\":\"2012-01-01\",\"b\":null}]",
-        Workbook::Table.new([["a","b"],[1,2],[Date.new(2012,1,1),nil]]).to_json)
+        Workbook::Table.new([["a", "b"], [1, 2], [Date.new(2012, 1, 1), nil]]).to_json)
+    end
+
+    def test_write_to_json
+      filename = Workbook::Table.new([["a", "b"], [1, 2], [Date.new(2012, 1, 1), nil]]).write_to_json("json_test.json")
+      json_written = File.read(filename)
+      assert_equal("[{\"a\":1,\"b\":2},{\"a\":\"2012-01-01\",\"b\":null}]",json_written)
+
     end
   end
 end