workbook 0.4.6.0 → 0.4.7

data/test/test_book.rb

@@ -10,16 +10,18 @@ class TestWorkbook < Test::Unit::TestCase
 
   def test_push
     w = Workbook::Book.new nil
+    assert_equal(w.count,1)
     assert_equal([[[]]],w)
     w = Workbook::Book.new
-    assert_equal(w.count,1)
-
     w.push
     assert_equal(w.first.class,Workbook::Sheet)
     w.push
+    assert_equal(w,w.last.book)
     assert_equal(w.count,3)
     s = Workbook::Sheet.new
     w.push s
+    assert_equal(w,w.last.book)
+
     assert_equal(w.last,s)
     w = Workbook::Book.new
     assert_equal(w.sheet.table.class,Workbook::Table)
@@ -34,6 +36,8 @@ class TestWorkbook < Test::Unit::TestCase
     assert_equal(w.sheet, s)
   end
 
+
+
   def test_template
     b = Workbook::Book.new
     raw = "asdf"
@@ -44,6 +48,15 @@ class TestWorkbook < Test::Unit::TestCase
     assert_equal(raw,b.template)
   end
 
+  def test_file_extension
+    b = Workbook::Book.new
+    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')))
+    b = Workbook::Book.new
+    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]]
     assert_equal(Workbook::Sheet, b.first.class)
@@ -67,4 +80,39 @@ class TestWorkbook < Test::Unit::TestCase
     assert_raises(ArgumentError) { Workbook::Book.read("test string here", :ods) }
     assert_raises(ArgumentError) { Workbook::Book.read("test string here", :xlsx) }
   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]])
+
+    # puts b.index b.last
+    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]])
+
+    assert_equal(7, b.count)
+    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)
+    b.pop(3)
+    assert_equal(3, b.count)
+  end
+
+  def test_supported_mime_types
+    assert_equal true, Workbook::SUPPORTED_MIME_TYPES.include?('text/csv')
+  end
 end

data/test/test_cell.rb

@@ -10,7 +10,7 @@ class TestCell < Test::Unit::TestCase
     w = Workbook::Cell.new "asdf"
     assert_equal("asdf",w.value)
 
-    assert_raise(ArgumentError) { w = Workbook::Cell.new :asdf }
+    assert_raise(ArgumentError) { w = Workbook::Cell.new Workbook::Row }
 
     t = Time.now
     w = Workbook::Cell.new t

data/test/test_format.rb

@@ -19,6 +19,14 @@ class TestFormat < Test::Unit::TestCase
 
   end
 
+  def test_available_raws
+    deet = Time.now
+    f = Workbook::Format.new {}
+    assert_equal([], f.available_raws)
+    f.add_raw deet
+    assert_equal([Time], f.available_raws)
+  end
+
   def test_merge
     a = Workbook::Format.new({:background=>:red})
     b = Workbook::Format.new({:background=>:yellow, :color=>:green})

data/test/test_modules_cache.rb

@@ -0,0 +1,68 @@
+# -*- encoding : utf-8 -*-
+require File.join(File.dirname(__FILE__), 'helper')
+
+class TestToCacheClass
+  include Workbook::Modules::Cache
+  def basic_fetch
+    fetch_cache(:a){
+      sleep(0.5)
+      "return"
+    }
+  end
+  def expiring_fetch
+    fetch_cache(:a,Time.now+0.6){
+      sleep(0.5)
+      "return"
+    }
+  end
+end
+
+module Modules
+  class TestTableDiffSort < Test::Unit::TestCase
+    def test_basic_fetch
+      c = TestToCacheClass.new
+      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))
+      c.basic_fetch
+      diff_time = Time.now-start_time
+      assert_equal(true,(diff_time > 0.5 and 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))
+    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))
+      c.basic_fetch
+      diff_time = Time.now-start_time
+      assert_equal(true,(diff_time > 0.5 and 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))
+    end
+    def test_basic_fetch_invalidate_by_expiration
+      c = TestToCacheClass.new
+      start_time = Time.now
+      c.expiring_fetch
+      diff_time = Time.now-start_time
+      assert_equal(true,(diff_time > 0.5 and diff_time < 0.51))
+      c.expiring_fetch
+      diff_time = Time.now-start_time
+      assert_equal(true,(diff_time > 0.5 and diff_time < 0.51))
+      c.expiring_fetch
+      diff_time = Time.now-start_time
+      assert_equal(true,(diff_time > 0.5 and diff_time < 0.51))
+      sleep(0.5)
+      diff_time = Time.now-start_time
+      assert_equal(true,(diff_time > 1 and diff_time < 1.01))
+    end
+
+  end
+end

data/test/test_modules_table_diff_sort.rb

@@ -106,7 +106,6 @@ module Modules
       #  ba = [['a','b','c','d'],[1,2,3,4],[3,2,3,4],[3,3,3,4],[4,2,3,4],[]]
       #  bb = [['a','b','c','d'],[1,2,3,4],[3,2,3,4],[3,2,3,4],[],[5,2,3,4]]
       # hence,
-      expected = [['a','b','c','d'],[1,2,3,4],[3,2,3,4],[3,'3 (was: 2)',3,4],[4,2,3,4],['(was: 5)','(was: 2)','(was: 3)','(was: 4)']]
 
       tself = ba.sheet.table
       tother = bb.sheet.table
@@ -115,5 +114,17 @@ module Modules
       assert_equal("a,b,c,d\n1,2,3,4\n3,2,3,4\n3,3 (was: 2),3,4\n4,2,3,4\n(was: 5),(was: 2),(was: 3),(was: 4)\n",diff_result.to_csv)
       diff_result.sheet.book.write_to_xls
     end
+
+    def test_workbook_diff
+      ba = Workbook::Book.new [['a','b','c','d'],[1,2,3,4],[4,2,3,4],[3,2,3,4],[3,3,3,4]]
+      bb = Workbook::Book.new [['a','b','c','d'],[1,2,3,4],[3,2,3,4],[5,2,3,4],[3,2,3,4]]
+      ba << [['e','f','g','h'],[1,2,3,4],[4,2,3,4],[3,2,3,4],[3,3,3,4]]
+      bb << [['e','f','g','h'],[1,2,2,2],[4,2,3,4],[3,2,3,4],[3,3,3,6]]
+      diff_result = ba.diff bb
+
+      assert_equal("a,b,c,d\n1,2,3,4\n3,2,3,4\n3,3 (was: 2),3,4\n4,2,3,4\n(was: 5),(was: 2),(was: 3),(was: 4)\n",diff_result[0][0].to_csv)
+      assert_equal("e,f,g,h\n1,2,3 (was: 2),4 (was: 2)\n3,2,3,4\n3,3,3,4 (was: 6)\n4,2,3,4\n",diff_result[1][0].to_csv)
+
+    end
   end
 end

data/test/test_readers_xls_reader.rb

@@ -58,5 +58,11 @@ module Readers
       end
       assert_equal(true,failed_properly)
     end
+    def test_multi_sheet_opening
+      b = Workbook::Book.open(File.join(File.dirname(__FILE__), 'artifacts/simple_sheet_many_sheets.xls'))
+      raw_xls = b.template.raws[Spreadsheet::Excel::Workbook]
+      assert_equal(["Diff_10", "Diff_9", "Diff_8", "Diff_7", "Diff_6", "Diff_5", "Diff_4", "Diff_3", "Diff_2", "Diff_1"], b.collect{|a| a.name})
+      assert_equal([10, 9, 8, 7, 6, 5, 4, 3, 2, 1], b.collect{|a| a.table[1][0].value})
+    end
   end
 end

data/test/test_readers_xlsx_reader.rb

@@ -9,9 +9,9 @@ module Readers
       assert_equal(90588,w.sheet.table[2][:b].value)
       assert_equal(DateTime.new(2011,11,15),w.sheet.table[3][:d].value)
       # assert_equal("#CCFFCC",w.sheet.table[3][:c].format[:background_color]) #colour compatibility turned off for now...
-      assert_equal(8,w.sheet.table.first[:b].format[:width].round)
-      assert_equal(4,w.sheet.table.first[:a].format[:width].round)
-      assert_equal(25,w.sheet.table.first[:c].format[:width].round)
+      # assert_equal(8,w.sheet.table.first[:b].format[:width].round)
+      # assert_equal(4,w.sheet.table.first[:a].format[:width].round)
+      # assert_equal(25,w.sheet.table.first[:c].format[:width].round)
     end
     def test_open_native_xlsx
       w = Workbook::Book.new
@@ -29,11 +29,12 @@ module Readers
       assert_equal(nil,w.ms_formatting_to_strftime(nil));
       assert_equal(nil,w.ms_formatting_to_strftime(""));
     end
-    def test_monkey_patched_ruby_xl_is_date_format?
-      w = RubyXL::Workbook.new
-      assert_equal(false, w.is_date_format?(nil))
-      assert_equal(false, w.is_date_format?(""))
-      assert_equal(true, w.is_date_format?("D-M-YYY"))
-    end
+
+    # def test_monkey_patched_ruby_xl_is_date_format?
+    #   w = RubyXL::Workbook.new
+    #   assert_equal(false, w.is_date_format?(nil))
+    #   assert_equal(false, w.is_date_format?(""))
+    #   assert_equal(true, w.is_date_format?("D-M-YYY"))
+    # end
   end
 end

data/test/test_row.rb

@@ -104,7 +104,7 @@ class TestRow < Test::Unit::TestCase
     assert_equal(date, r2[:asdfasd].value)
     assert_equal(date, r2[1].value)
   end
-  
+
 
   def test_to_hash_with_values
     t = Workbook::Table.new
@@ -118,7 +118,7 @@ class TestRow < Test::Unit::TestCase
     expected = {:test=>2, :asdfasd=>date}
     assert_equal(expected, r2.to_hash_with_values)
   end
-  
+
   def test_to_hash_cache
     t = Workbook::Table.new
     t << ["test", "asdf-asd"]
@@ -129,9 +129,9 @@ class TestRow < Test::Unit::TestCase
     assert_equal(3, r[:test].value)
     assert_equal(3, r[:test].value)
     t.last[:test] = nil
-    assert_equal(nil, r[:test].value)  
+    assert_equal(nil, r[:test].value)
     r[:test] = 5
-    assert_equal(5, r[:test].value)    
+    assert_equal(5, r[:test].value)
   end
 
   def test_compare
@@ -217,14 +217,14 @@ class TestRow < Test::Unit::TestCase
     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)    
-    
+    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)  
+    assert_equal(2,table[1][:b].value)
   end
 
   def test_preservation_of_format_on_assign
@@ -236,7 +236,18 @@ class TestRow < Test::Unit::TestCase
     assert_equal("#f00",row[0].format["background"])
   end
 
-  def test_row_hash_index_assignment
+  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
+    assert_equal(12, table.last["b"])
+    assert_equal(nil, table.last["a"])
+
+  end
+
+  def test_row_hash_index_string_assignment
     b = Workbook::Book.new
     table = b.sheet.table
     table << Workbook::Row.new(["a","b"])
@@ -245,6 +256,8 @@ class TestRow < Test::Unit::TestCase
     assert_equal(12, table.last.last.value)
     row[:b]= 15
     assert_equal(15, table.last.last.value)
+    row["b"]= 18
+    assert_equal(18, table.last.last.value)
   end
 
   def test_trim!
@@ -316,4 +329,48 @@ class TestRow < Test::Unit::TestCase
     assert_equal(c, d)
 
   end
+
+  def test_add
+    a = Workbook::Row.new
+    a << 1
+    a << 2
+    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)
+  end
+
+  def test_plus
+    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(nil, a.table)
+    assert_equal(Workbook::Cell,a[0].class)
+  end
+
+  def test_concat
+    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 )
+    assert_equal(table, a.table)
+    assert_equal(Workbook::Cell,a[0].class)
+  end
 end

data/test/test_sheet.rb

@@ -74,4 +74,12 @@ class TestWorkbook < Test::Unit::TestCase
     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]])
+
+    # puts b.index b.last
+    assert_equal(["Sheet 1", "Sheet 2", "Sheet 3"], b.collect{|a| a.name})
+  end
 end

data/test/test_table.rb

@@ -121,8 +121,37 @@ class TestTable< Test::Unit::TestCase
     assert_equal(27,t.alpha_index_to_number_index("AB"))
     assert_equal(51,t.alpha_index_to_number_index("AZ"))
     assert_equal(52,t.alpha_index_to_number_index("BA"))
+    assert_equal((27*26)-1,t.alpha_index_to_number_index("ZZ"))
   end
 
+  def test_multirowselect_through_collections
+    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])
+  end
+
+  def test_table
+    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]
+    assert_equal("1,2\n3,4\n", w2.sheet.table.to_csv)
+  end
+  def test_array_style_assignment
+    w = Workbook::Book.new [["a","b"],[1,2],[3,4]]
+    t = w.sheet.table
+    r = t[1].clone
+    assert_equal(nil, r.table)
+    t[2] = r
+    assert_equal(t, r.table)
+  end
+  def test_delete_at
+    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)
+  end
   def test_trim!
     t = Workbook::Table.new
     t << [1,2,3]
@@ -138,4 +167,23 @@ class TestTable< Test::Unit::TestCase
     t.trim!
     assert_equal("1,2,3\n,,\n1,2,\n",t.to_csv)
   end
+  def test_performance
+    table = Workbook::Table.new
+    headers = 1000.times.collect{|a| "header#{a}"}
+    first_row = 1000.times.collect{|a| Time.now}
+    table << headers.shuffle
+    table << first_row
+    100.times do |times|
+      row = table[1].clone
+      table << row
+      headers.each do |a|
+        row[a.to_sym]=Time.now
+      end
+    end
+    last_line = table.count-1
+    first_few_lines = table[12][0].value - table[2][0].value
+    last_few_lines = table[last_line][0].value - table[last_line-10][0].value
+    # puts [first_few_lines,last_few_lines].join(" vs ")
+    assert_equal(true, first_few_lines*1.10 > last_few_lines) # 10% slower is acceptable
+  end
 end