workbook 0.4.2 → 0.4.3

data/test/test_book.rb

@@ -7,24 +7,24 @@ class TestWorkbook < Test::Unit::TestCase
     w.push
     assert_equal(2, w.count)
   end
-  
+
   def test_push
     w = Workbook::Book.new nil
     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.count,3)    
+    assert_equal(w.count,3)
     s = Workbook::Sheet.new
     w.push s
     assert_equal(w.last,s)
     w = Workbook::Book.new
     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)]
@@ -33,17 +33,17 @@ class TestWorkbook < Test::Unit::TestCase
     w = Workbook::Book.new s
     assert_equal(w.sheet, s)
   end
-  
+
   def test_template
     b = Workbook::Book.new
     raw = "asdf"
     assert_raise(ArgumentError) { b.template = raw }
     raw = Workbook::Template.new
     b.template = raw
-    
+
     assert_equal(raw,b.template)
   end
-  
+
   def test_parent_child
     b = Workbook::Book.new [[1,2,3],[1,2,3]]
     assert_equal(Workbook::Sheet, b.first.class)
@@ -53,15 +53,15 @@ class TestWorkbook < Test::Unit::TestCase
     assert_equal(Workbook::Row, b.first.table.header.class)
     assert_equal(b,b.first.table.header.table.sheet.book)
   end
-  
+
   def test_text_to_utf8
-    f = File.open("test/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)
     assert_equal("a\tb\tc\td", t.split(/(\n|\r)/).first)
   end
-  
+
   def test_read_bad_filetype
     assert_raises(ArgumentError) { Workbook::Book.read("test string here", :xls) }
     assert_raises(ArgumentError) { Workbook::Book.read("test string here", :ods) }

data/test/test_cell.rb

@@ -3,30 +3,30 @@ require File.join(File.dirname(__FILE__), 'helper')
 
 class TestCell < Test::Unit::TestCase
 
-  
+
   def test_init
     w = Workbook::Cell.new nil
     assert_equal(nil,w.value)
     w = Workbook::Cell.new "asdf"
     assert_equal("asdf",w.value)
-    
+
     assert_raise(ArgumentError) { w = Workbook::Cell.new :asdf }
 
     t = Time.now
     w = Workbook::Cell.new t
     assert_equal(t,w.value)
-    
+
   end
- 
+
   def test_value
     w = Workbook::Cell.new nil
     assert_equal(nil,w.value)
     w.value = "asdf"
     assert_equal("asdf",w.value)
     w.value = Date.new
-    assert_equal(Date.new,w.value) 
+    assert_equal(Date.new,w.value)
   end
-  
+
   def test_comp
     a = Workbook::Cell.new 1
     b = Workbook::Cell.new 2
@@ -53,7 +53,7 @@ class TestCell < Test::Unit::TestCase
     b = Workbook::Cell.new nil
     assert_equal(0, a<=>b)
   end
-  
+
   def test_cloning_as_expected?
     a = Workbook::Cell.new 1
     a.format = Workbook::Format.new({:value=>1})
@@ -65,7 +65,7 @@ class TestCell < Test::Unit::TestCase
     assert_equal(2,a.format[:value])
     assert_equal(2,b.format[:value])
   end
-  
+
   def test_to_sym
     c = Workbook::Cell.new "A - B"
     assert_equal(:a_b, c.to_sym)
@@ -75,12 +75,12 @@ class TestCell < Test::Unit::TestCase
     assert_equal(:a_c_b123, c.to_sym)
 
   end
-  
+
   def test_nil
     c = Workbook::Cell.new nil
     assert_equal(true,c.nil?)
   end
-  
+
   def test_colspan_rowspan
     c = Workbook::Cell.new
     c.colspan = 1
@@ -90,16 +90,16 @@ class TestCell < Test::Unit::TestCase
     c.colspan = nil
     c.rowspan = ""
     assert_equal(nil,c.colspan)
-    assert_equal(nil,c.rowspan)   
+    assert_equal(nil,c.rowspan)
     c.colspan = 3
     c.rowspan = "4"
     assert_equal(3,c.colspan)
     c.rowspan = 0
-    assert_equal(nil,c.rowspan)  
+    assert_equal(nil,c.rowspan)
     assert_equal(3,c.colspan)
     c.colspan = 0
     c.rowspan = 3
-    assert_equal(3,c.rowspan)  
-    assert_equal(nil,c.colspan)    
+    assert_equal(3,c.rowspan)
+    assert_equal(nil,c.colspan)
   end
 end

data/test/test_format.rb

@@ -3,7 +3,7 @@ require File.join(File.dirname(__FILE__), 'helper')
 
 class TestFormat < Test::Unit::TestCase
 
-  
+
   def test_initialize
     f = Workbook::Format.new {}
     assert_equal({},f)
@@ -12,13 +12,13 @@ class TestFormat < Test::Unit::TestCase
     f = Workbook::Format.new({:background=>:red})
     deet = Time.now
     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))
-    
+
   end
-  
+
   def test_merge
     a = Workbook::Format.new({:background=>:red})
     b = Workbook::Format.new({:background=>:yellow, :color=>:green})
@@ -26,7 +26,7 @@ class TestFormat < Test::Unit::TestCase
     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})
@@ -34,7 +34,7 @@ class TestFormat < Test::Unit::TestCase
     result = b.clone.merge(a)
     assert_equal({},result.raws)
   end
- 
+
   def test_has_background_color?
     a = Workbook::Format.new
     assert_equal(false,a.has_background_color?)
@@ -46,17 +46,17 @@ class TestFormat < Test::Unit::TestCase
     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)
-    
+
   end
-  
+
   def test_parent_style
     a = Workbook::Format.new({:background_color=>'#ffffff'})
     b = Workbook::Format.new({:color=>'#000'})
@@ -78,7 +78,7 @@ class TestFormat < Test::Unit::TestCase
     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'})

data/test/test_functional.rb

@@ -7,11 +7,11 @@ class TestFunctional < Test::Unit::TestCase
     assert_equal(Workbook::Book, b.class)
     s = b.sheet
     assert_equal(Workbook::Sheet, s.class)
-	  t = s.table
+    t = s.table
     assert_equal(Workbook::Table, t.class)
     s = b.sheet[0] = Workbook::Sheet.new([['a','b'],[1,2],[3,4],[5,6]])
     assert_equal(Workbook::Sheet, s.class)
-    
+
     t = s.table
     assert_equal(Workbook::Table, t.class)
     assert_equal(Workbook::Row, t.first.class)
@@ -20,7 +20,7 @@ class TestFunctional < Test::Unit::TestCase
     assert_equal(false, t.last.header?)
     assert_equal(2,t[1][:b].value)
   end
- 
+
   def test_chapter_Sorting
     b = Workbook::Book.new
     s = b.sheet[0] = Workbook::Sheet.new([['a','b'],[1,2],[3,4],[5,6]])

data/test/test_modules_table_diff_sort.rb

@@ -7,24 +7,24 @@ module Modules
       b = Workbook::Book.new [[1,2,3],[2,2,3],[true,false,true],["asdf","sdf","as"],[time,2,3],[2,2,2],[22,2,3],[1,2,233]]
       t = b.sheet.table
       assert_equal(
-        [ [Workbook::Cell.new(1),Workbook::Cell.new(2),Workbook::Cell.new(3)],
-          [Workbook::Cell.new(1),Workbook::Cell.new(2),Workbook::Cell.new(233)],
-          [Workbook::Cell.new(2),Workbook::Cell.new(2),Workbook::Cell.new(2)],
-          [Workbook::Cell.new(2),Workbook::Cell.new(2),Workbook::Cell.new(3)],
-          [Workbook::Cell.new(22),Workbook::Cell.new(2),Workbook::Cell.new(3)],
-          [Workbook::Cell.new("asdf"),Workbook::Cell.new("sdf"),Workbook::Cell.new("as")],
-          [Workbook::Cell.new(time),Workbook::Cell.new(2),Workbook::Cell.new(3)],
-          [Workbook::Cell.new(true),Workbook::Cell.new(false),Workbook::Cell.new(true)]
-        ],
-          t.sort)
-      
+      [ [Workbook::Cell.new(1),Workbook::Cell.new(2),Workbook::Cell.new(3)],
+        [Workbook::Cell.new(1),Workbook::Cell.new(2),Workbook::Cell.new(233)],
+        [Workbook::Cell.new(2),Workbook::Cell.new(2),Workbook::Cell.new(2)],
+        [Workbook::Cell.new(2),Workbook::Cell.new(2),Workbook::Cell.new(3)],
+        [Workbook::Cell.new(22),Workbook::Cell.new(2),Workbook::Cell.new(3)],
+        [Workbook::Cell.new("asdf"),Workbook::Cell.new("sdf"),Workbook::Cell.new("as")],
+        [Workbook::Cell.new(time),Workbook::Cell.new(2),Workbook::Cell.new(3)],
+        [Workbook::Cell.new(true),Workbook::Cell.new(false),Workbook::Cell.new(true)]
+      ],
+      t.sort)
+
       ba = Workbook::Book.new [['a','b','c','d'],[1,2,3,4],[4,2,3,4],[3,2,3,4]]
       sba = ba.sheet.table.sort
       assert_not_equal(Workbook::Table.new([['a','b','c','d'],[1,2,3,4],[4,2,3,4],[3,2,3,4]]),sba)
       assert_equal(Workbook::Table.new([['a','b','c','d'],[1,2,3,4],[3,2,3,4],[4,2,3,4]]),sba)
-      
+
     end
-    
+
     def test_align
       ba = Workbook::Book.new [['a','b','c','d'],[1,2,3,4],[4,2,3,4],[3,2,3,4]]
       bb = Workbook::Book.new [['a','b','c','d'],[1,2,3,4],[3,2,3,4],[5,2,3,4]]
@@ -38,9 +38,9 @@ module Modules
       tself = ba.sheet.table
       tother = bb.sheet.table
       align_result = tself.align tother
-      assert_equal("a,b,c,d\n1,2,3,4\n3,2,3,4\n\n5,2,3,4\n",align_result[:other].to_csv)  
-      assert_equal("a,b,c,d\n1,2,3,4\n3,2,3,4\n4,2,3,4\n\n",align_result[:self].to_csv)  
-      
+      assert_equal("a,b,c,d\n1,2,3,4\n3,2,3,4\n\n5,2,3,4\n",align_result[:other].to_csv)
+      assert_equal("a,b,c,d\n1,2,3,4\n3,2,3,4\n4,2,3,4\n\n",align_result[:self].to_csv)
+
       ba = Workbook::Book.new [['a','b','c','d'],[1,2,3,4],[3,2,3,4],[5,2,3,4]]
       bb = Workbook::Book.new [['a','b','c','d'],[1,2,3,4],[2,2,3,4],[5,2,3,4]]
       tself = ba.sheet.table
@@ -51,7 +51,7 @@ module Modules
       align_result = tother.align tself
       assert_equal("a,b,c,d\n1,2,3,4\n\n3,2,3,4\n5,2,3,4\n",align_result[:other].to_csv)
       assert_equal("a,b,c,d\n1,2,3,4\n2,2,3,4\n\n5,2,3,4\n",align_result[:self].to_csv)
-      
+
       tself =  Workbook::Book.new([['a','b','c','d'],[1,2,3,4],[1,3,3,4],          [3,2,3,4],[5,2,3,4]]).sheet.table
       tother = Workbook::Book.new([['a','b','c','d'],[1,2,3,4],          [2,2,3,4],          [5,2,3,4]]).sheet.table
       align_result = tself.align tother
@@ -72,34 +72,34 @@ module Modules
       align_result = tself.align tother
       assert_equal("a,b,c,d\n\n\n\n\n\n10,2,3,4\n45,2,3,4\n49,2,3,4\n",align_result[:self].to_csv)
       assert_equal("a,b,c,d\n1,2,3,4\n1,2,3,4\n1,2,3,4\n2,2,3,4\n5,2,3,4\n\n\n\n",align_result[:other].to_csv)
-          
+
     end
-    
+
     def test_with_nil_header
       a = Workbook::Book.new([['a','b',nil],[1,2,3]])
       b = Workbook::Book.new([['a','b','c'],[1,2,3]])
       c = a.sheet.table.diff b.sheet.table
       assert_equal("a,b,(was: c)\n1,2,(was: 3)\n",c.to_csv)
     end
-    
+
     # def test_diff_file
     #   a = Workbook::Book.open('test/artifacts/private_a_0.xls')
     #   b = Workbook::Book.open('test/artifacts/private_a_0.xls')
     #   y a.sheet.table.diff b.sheet.table
     # end
-    
+
     # def test_sort_by
     #   b = Workbook::Book.new [['a','b','c','d'],[1,2,3,4],[4,2,3,3],[3,2,3,2]]
     #   y b.sheet.table.sort_by{|r| r[:d]}
     # end
-    
+
     def test_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]]
       # Start:
       # ba = [['a','b','c','d'],[1,2,3,4],[4,2,3,4],[3,2,3,4],[3,3,3,4]]
       # bb = [['a','b','c','d'],[1,2,3,4],[3,2,3,4],[5,2,3,4],[3,2,3,4]]
-      # As it starts out with sorting, it is basically a comparison between            
+      # As it starts out with sorting, it is basically a comparison between
       #  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]]
       # then it aligns:
@@ -107,7 +107,7 @@ module Modules
       #  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
       diff_result = tself.diff tother

data/test/test_modules_type_parser.rb

@@ -4,32 +4,32 @@ module Modules
   class TestTypeParser < Test::Unit::TestCase
     def examples
       {"2312"=>2312,
-       "12-12-2012"=>Date.new(2012,12,12),
-       "12-12-2012 12:24"=>DateTime.new(2012,12,12,12,24),
-       "2012-12-12 12:24"=>DateTime.new(2012,12,12,12,24),
-       "2011-05-19T15_37_49 - 52349.xml"=>"2011-05-19T15_37_49 - 52349.xml",
-       "20-2-2012 20:52"=>DateTime.new(2012,2,20,20,52),
-       "1-11-2011"=>Date.new(2011,11,1),
-       "12/12/2012"=>Date.new(2012,12,12),
-       "12/23/1980"=>Date.new(1980,12,23), #TODO: should probably depend on locale, see: http://bugs.ruby-lang.org/issues/634#note-10
-       "jA"=>"jA",
-       "n"=>"n",
-       "12 bomen"=>"12 bomen",
-       "12 bomenasdfasdfsadf"=>"12 bomenasdfasdfsadf",
-       ""=>nil,
-       " "=>nil,
-       "mailto:sadf@asdf.as"=>"sadf@asdf.as",
-       "012-3456789"=>"012-3456789",
-       "TRUE"=>true
-       }
+        "12-12-2012"=>Date.new(2012,12,12),
+        "12-12-2012 12:24"=>DateTime.new(2012,12,12,12,24),
+        "2012-12-12 12:24"=>DateTime.new(2012,12,12,12,24),
+        "2011-05-19T15_37_49 - 52349.xml"=>"2011-05-19T15_37_49 - 52349.xml",
+        "20-2-2012 20:52"=>DateTime.new(2012,2,20,20,52),
+        "1-11-2011"=>Date.new(2011,11,1),
+        "12/12/2012"=>Date.new(2012,12,12),
+        "12/23/1980"=>Date.new(1980,12,23), #TODO: should probably depend on locale, see: http://bugs.ruby-lang.org/issues/634#note-10
+        "jA"=>"jA",
+        "n"=>"n",
+        "12 bomen"=>"12 bomen",
+        "12 bomenasdfasdfsadf"=>"12 bomenasdfasdfsadf",
+        ""=>nil,
+        " "=>nil,
+        "mailto:sadf@asdf.as"=>"sadf@asdf.as",
+        "012-3456789"=>"012-3456789",
+        "TRUE"=>true
+      }
     end
-    
+
     def test_parse
       examples.each do |k,v|
         assert_equal(v,Workbook::Cell.new(k).parse({:detect_date=>true}))
       end
     end
-    
+
     def test_custom_parse
       customparsers = [proc{|v| "#{v}2" }]
       examples.each do |k,v|
@@ -43,19 +43,19 @@ module Modules
       c.value = "v"
       assert_equal("v2",c.parse)
     end
-    
+
     def test_parse!
       r= Workbook::Row.new
-      r[0] = Workbook::Cell.new "xls_cell"    
-      r[0].parse!    
+      r[0] = Workbook::Cell.new "xls_cell"
+      r[0].parse!
       assert_equal("xls_cell",r[0].value)
-      r[1] = Workbook::Cell.new ""    
-      r[1].parse!    
+      r[1] = Workbook::Cell.new ""
+      r[1].parse!
       assert_equal(nil,r[1].value)
     end
-    
+
     def test_once_failing_files
-      w = Workbook::Book.open("test/artifacts/failing_import1.xls") # TRUE wasn't parsed properly
+      w = Workbook::Book.open(File.join(File.dirname(__FILE__), 'artifacts/failing_import1.xls')) # TRUE wasn't parsed properly
     end
   end
 end

data/test/test_readers_csv_reader.rb

@@ -4,13 +4,13 @@ module Readers
   class TestCsvWriter < Test::Unit::TestCase
     def test_open
       w = Workbook::Book.new
-      w.open 'test/artifacts/simple_csv.csv'
+      w.open 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([:a,:b,:c,:d],w.sheet.table.header.to_symbols)
       assert_equal(3,w.sheet.table[2][:b].value)
       assert_equal("asdf",w.sheet.table[3][:a].value)
@@ -18,7 +18,7 @@ module Readers
     end
     def test_excel_csv_open
       w = Workbook::Book.new
-      w.open("test/artifacts/simple_excel_csv.csv")
+      w.open File.join(File.dirname(__FILE__), 'artifacts/simple_excel_csv.csv')
       # reads
       #   a;b;c
       #   1-1-2001;23;1
@@ -37,13 +37,13 @@ module Readers
     end
     def test_excel_standardized_open
       w = Workbook::Book.new
-      w.open("test/artifacts/excel_different_types.csv")
+      w.open File.join(File.dirname(__FILE__), 'artifacts/excel_different_types.csv')
       # reads
       #   a,b,c,d
       # 2012-02-22,2014-12-27,2012-11-23,2012-11-12T04:20:00+00:00
       # c,222.0,,0027-12-14T05:21:00+00:00
       # 2012-01-22T11:00:00+00:00,42000.0,"goh, idd",ls
-      
+
       assert_equal([:a,:b,:c, :d],w.sheet.table.header.to_symbols)
       assert_equal(Date.new(2012,2,22),w.sheet.table[1][:a].value)
       assert_equal("c",w.sheet.table[2][:a].value)
@@ -52,14 +52,14 @@ module Readers
       assert_equal(nil,w.sheet.table[2][:c].value)
     end
     def test_class_read_string
-      s = File.read 'test/artifacts/simple_csv.csv'
+      s = File.read File.join(File.dirname(__FILE__), 'artifacts/simple_csv.csv')
       w = Workbook::Book.read( s, :csv )
       # reads
       #       a,b,c,d
       #       1,2,3,4
       #       5,3,2,1
       #       "asdf",123,12,2001-02-02
-      #       
+      #
       assert_equal([:a,:b,:c,:d],w.sheet.table.header.to_symbols)
       assert_equal(3,w.sheet.table[2][:b].value)
       assert_equal("asdf",w.sheet.table[3][:a].value)
@@ -67,14 +67,14 @@ module Readers
     end
     def test_instance_read_string
       w = Workbook::Book.new
-      s = File.read 'test/artifacts/simple_csv.csv'
+      s = File.read File.join(File.dirname(__FILE__), 'artifacts/simple_csv.csv')
       w.read( s, :csv )
       # reads
       #       a,b,c,d
       #       1,2,3,4
       #       5,3,2,1
       #       "asdf",123,12,2001-02-02
-      #       
+      #
       assert_equal([:a,:b,:c,:d],w.sheet.table.header.to_symbols)
       assert_equal(3,w.sheet.table[2][:b].value)
       assert_equal("asdf",w.sheet.table[3][:a].value)
@@ -82,14 +82,14 @@ module Readers
     end
     def test_instance_read_stringio
       w = Workbook::Book.new
-      sio = StringIO.new(File.read 'test/artifacts/simple_csv.csv')
+      sio = StringIO.new(File.read File.join(File.dirname(__FILE__), 'artifacts/simple_csv.csv'))
       w.read( sio, :csv )
       # reads
       #       a,b,c,d
       #       1,2,3,4
       #       5,3,2,1
       #       "asdf",123,12,2001-02-02
-      #       
+      #
       assert_equal([:a,:b,:c,:d],w.sheet.table.header.to_symbols)
       assert_equal(3,w.sheet.table[2][:b].value)
       assert_equal("asdf",w.sheet.table[3][:a].value)