workbook 0.8.1 → 0.8.2

data/test/test_modules_cell.rb

@@ -1,83 +1,85 @@
 # frozen_string_literal: true
 
-# -*- encoding : utf-8 -*-
-require File.join(File.dirname(__FILE__), 'helper')
+require File.join(File.dirname(__FILE__), "helper")
 
 class TestModulesCell < Minitest::Test
-
-
   def test_init
     w = Workbook::Cell.new nil
     assert_nil(w.value)
     w = Workbook::Cell.new "asdf"
-    assert_equal("asdf",w.value)
+    assert_equal("asdf", w.value)
 
     assert_raises(ArgumentError) { w = Workbook::Cell.new Workbook::Row }
 
     t = Time.now
     w = Workbook::Cell.new t
-    assert_equal(t,w.value)
-
+    assert_equal(t, w.value)
   end
 
   def test_value
     w = Workbook::Cell.new nil
     assert_nil(w.value)
-    w.value = "asdf"
-    assert_equal("asdf",w.value)
-    w.value = Date.new
-    assert_equal(Date.new,w.value)
-    w.value = 1
-    assert_equal(1,w.value)
-    assert(["Integer", "Fixnum"].include?(w.value.class.to_s))
-    w.value = 1.0
-    assert_equal(1.0,w.value)
-    assert_equal(Float,w.value.class)
+
+    {"asdf" => :string, Date.new => :date, 1 => :integer, 1.0 => :float, BigDecimal("1.0") => :decimal}.each do |value, value_type|
+      w.value = value
+      assert_equal(value, w.value)
+      assert_equal(value_type, w.cell_type)
+    end
+    # w.value = "asdf"
+    # assert_equal("asdf", w.value)
+    # w.value = Date.new
+    # assert_equal(Date.new, w.value)
+    # w.value = 1
+    # assert_equal(1, w.value)
+    # assert(["Integer", "Integer"].include?(w.value.class.to_s))
+    # w.value = 1.0
+    # assert_equal(1.0, w.value)
+    # assert_equal(Float, w.value.class)
   end
 
   def test_importance_of_class
     a = Workbook::Cell.new
-    assert_equal(4, a.importance_of_class("a"))
-    assert_equal(5, a.importance_of_class(:a))
+    assert_equal(5, a.importance_of_class("a"))
+    assert_equal(6, a.importance_of_class(:a))
   end
 
   def test_comp
     a = Workbook::Cell.new 1
     b = Workbook::Cell.new 2
-    assert_equal(-1, a<=>b)
+    assert_equal(-1, a <=> b)
     a = Workbook::Cell.new "c"
     b = Workbook::Cell.new "bsdf"
-    assert_equal(1, a<=>b)
+    assert_equal(1, a <=> b)
     a = Workbook::Cell.new "c"
     b = Workbook::Cell.new "c"
-    assert_equal(0, a<=>b)
+    assert_equal(0, a <=> b)
     a = Workbook::Cell.new true
     b = Workbook::Cell.new false
-    assert_equal(-1, a<=>b)
+    assert_equal(-1, a <=> b)
     a = Workbook::Cell.new "true"
     b = Workbook::Cell.new "false"
-    assert_equal(1, a<=>b)
+    assert_equal(1, a <=> b)
     a = Workbook::Cell.new 1
     b = Workbook::Cell.new "a"
-    assert_equal(-1, a<=>b)
+    assert_equal(-1, a <=> b)
     a = Workbook::Cell.new nil
     b = Workbook::Cell.new "a"
-    assert_equal(1, a<=>b)
+    assert_equal(1, a <=> b)
     a = Workbook::Cell.new nil
     b = Workbook::Cell.new nil
-    assert_equal(0, a<=>b)
+    assert_equal(0, a <=> b)
   end
 
   def test_cloning_as_expected?
     a = Workbook::Cell.new 1
-    a.format = Workbook::Format.new({:value=>1})
+    a.format = Workbook::Format.new({value: 1})
     b = a.clone
     b.value = 2
-    b.format[:value]=2
-    assert_equal(1,a.value)
-    assert_equal(2,b.value)
-    assert_equal(2,a.format[:value])
-    assert_equal(2,b.format[:value])
+    b.format[:value] = 2
+    assert_equal(1, a.value)
+    assert_equal(2, b.value)
+    assert_equal(2, a.format[:value])
+    assert_equal(2, b.format[:value])
   end
 
   def test_to_sym
@@ -91,15 +93,14 @@ class TestModulesCell < Minitest::Test
       "éåšžÌ?" => :easzi?,
       1 => :num1,
       1.0 => :num1_0,
-      'test   ' => :test,
-      'test ' => :test
+      "test   " => :test,
+      "test " => :test
 
     }
-    examples.each do |k,v|
+    examples.each do |k, v|
+      assert_equal(v, Workbook::Cell::value_to_sym(k))
       assert_equal(v, Workbook::Cell.new(k).to_sym)
     end
-
-
   end
 
   def test_nil
@@ -119,32 +120,32 @@ class TestModulesCell < Minitest::Test
     assert_nil(c.rowspan)
     c.colspan = 3
     c.rowspan = "4"
-    assert_equal(3,c.colspan)
+    assert_equal(3, c.colspan)
     c.rowspan = 0
     assert_nil(c.rowspan)
-    assert_equal(3,c.colspan)
+    assert_equal(3, c.colspan)
     c.colspan = 0
     c.rowspan = 3
-    assert_equal(3,c.rowspan)
+    assert_equal(3, c.rowspan)
     assert_nil(c.colspan)
   end
 
   def test_cell_type
-    {1 => :integer, 3.2 => :float, true => :boolean, "asdf" => :string}.each do |k,v|
+    {1 => :integer, 3.2 => :float, true => :boolean, "asdf" => :string}.each do |k, v|
       c = Workbook::Cell.new(k)
-      assert_equal(v,c.cell_type)
+      assert_equal(v, c.cell_type)
     end
   end
 
   def test_index
-    t = Workbook::Table.new [[:a,:b,:c],[1,2,3],[4,5,6]]
+    t = Workbook::Table.new [[:a, :b, :c], [1, 2, 3], [4, 5, 6]]
     assert_equal(2, t[2][2].index)
   end
 
   def test_key
-    t = Workbook::Table.new [[:a,:b,:c],[1,2,3],[4,5,6]]
+    t = Workbook::Table.new [[:a, :b, :c], [1, 2, 3], [4, 5, 6]]
     assert_equal(:c, t[2][2].key)
-    t = Workbook::Table.new [[:d,nil,nil],[:a,:b,:c],[1,2,3],[4,5,6]]
+    t = Workbook::Table.new [[:d, nil, nil], [:a, :b, :c], [1, 2, 3], [4, 5, 6]]
     assert_nil(t[2][2].key)
     assert_equal(:d, t[2][0].key)
     t.header = t[1]

data/test/test_modules_table_diff_sort.rb

@@ -1,85 +1,77 @@
 # frozen_string_literal: true
 
-# -*- encoding : utf-8 -*-
-require File.join(File.dirname(__FILE__), 'helper')
+require File.join(File.dirname(__FILE__), "helper")
 module Modules
   class TestTableDiffSort < Minitest::Test
     def test_sort
       time = Time.now
-      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]]
+      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)
-
-      ba = Workbook::Book.new [['a','b','c','d'],[1,2,3,4],[4,2,3,4],[3,2,3,4]]
+        [[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.rows.map(&:cells)
+      )
+
+      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
-      refute_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)
-
+      refute_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]]
-      tself = ba.sheet.table
-      tother = bb.sheet.table
-
-      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]]
+      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]]
       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]]
+      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
       tother = bb.sheet.table
       align_result = tself.align tother
-      assert_equal("a,b,c,d\n1,2,3,4\n\n3,2,3,4\n5,2,3,4\n",align_result[:self].to_csv)
-      assert_equal("a,b,c,d\n1,2,3,4\n2,2,3,4\n\n5,2,3,4\n",align_result[:other].to_csv)
+      assert_equal("a,b,c,d\n1,2,3,4\n\n3,2,3,4\n5,2,3,4\n", align_result[:self].to_csv)
+      assert_equal("a,b,c,d\n1,2,3,4\n2,2,3,4\n\n5,2,3,4\n", align_result[:other].to_csv)
       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)
+      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
+      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
-      assert_equal("a,b,c,d\n1,2,3,4\n1,3,3,4\n\n3,2,3,4\n5,2,3,4\n",align_result[:self].to_csv)
-      assert_equal("a,b,c,d\n1,2,3,4\n\n2,2,3,4\n\n5,2,3,4\n",align_result[:other].to_csv)
-      tself = Workbook::Book.new( [['a','b','c','d'],[1,2,3,4],                              [3,2,3,4],[5,2,3,4]]).sheet.table
-      tother = Workbook::Book.new([['a','b','c','d'],[1,2,3,4],[1,2,3,4],[1,2,3,4],[2,2,3,4],          [5,2,3,4]]).sheet.table
+      assert_equal("a,b,c,d\n1,2,3,4\n1,3,3,4\n\n3,2,3,4\n5,2,3,4\n", align_result[:self].to_csv)
+      assert_equal("a,b,c,d\n1,2,3,4\n\n2,2,3,4\n\n5,2,3,4\n", align_result[:other].to_csv)
+      tself = Workbook::Book.new([["a", "b", "c", "d"], [1, 2, 3, 4], [3, 2, 3, 4], [5, 2, 3, 4]]).sheet.table
+      tother = Workbook::Book.new([["a", "b", "c", "d"], [1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4], [2, 2, 3, 4], [5, 2, 3, 4]]).sheet.table
       align_result = tself.align tother
-      assert_equal("a,b,c,d\n1,2,3,4\n\n\n\n3,2,3,4\n5,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\n\n5,2,3,4\n",align_result[:other].to_csv)
-      tself = Workbook::Book.new([['a','b','c','d'],[9,2,3,4],[3,2,3,4],[5,2,3,4]]).sheet.table
-      tother = Workbook::Book.new([['a','b','c','d'],[1,2,3,4],[1,2,3,4],[1,2,3,4],[2,2,3,4],[5,2,3,4]]).sheet.table
+      assert_equal("a,b,c,d\n1,2,3,4\n\n\n\n3,2,3,4\n5,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\n\n5,2,3,4\n", align_result[:other].to_csv)
+      tself = Workbook::Book.new([["a", "b", "c", "d"], [9, 2, 3, 4], [3, 2, 3, 4], [5, 2, 3, 4]]).sheet.table
+      tother = Workbook::Book.new([["a", "b", "c", "d"], [1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4], [2, 2, 3, 4], [5, 2, 3, 4]]).sheet.table
       align_result = tself.align tother
-      assert_equal("a,b,c,d\n\n\n\n\n3,2,3,4\n5,2,3,4\n9,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\n\n5,2,3,4\n\n",align_result[:other].to_csv)
-      tself = Workbook::Book.new([['a','b','c','d'],[49,2,3,4],[10,2,3,4],[45,2,3,4]]).sheet.table
-      tother = Workbook::Book.new([['a','b','c','d'],[1,2,3,4],[1,2,3,4],[1,2,3,4],[2,2,3,4],[5,2,3,4]]).sheet.table
+      assert_equal("a,b,c,d\n\n\n\n\n3,2,3,4\n5,2,3,4\n9,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\n\n5,2,3,4\n\n", align_result[:other].to_csv)
+      tself = Workbook::Book.new([["a", "b", "c", "d"], [49, 2, 3, 4], [10, 2, 3, 4], [45, 2, 3, 4]]).sheet.table
+      tother = Workbook::Book.new([["a", "b", "c", "d"], [1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4], [2, 2, 3, 4], [5, 2, 3, 4]]).sheet.table
       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)
-
+      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]])
+      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)
+      assert_equal("a,b,(was: c)\n1,2,(was: 3)\n", c.to_csv)
     end
 
     # def test_diff_file
@@ -94,8 +86,8 @@ module Modules
     # 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]]
+      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]]
@@ -110,21 +102,20 @@ module Modules
       tself = ba.sheet.table
       tother = bb.sheet.table
       diff_result = tself.diff tother
-      assert_equal('a',diff_result.sheet.table.header[0].value)
-      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)
+      assert_equal("a", diff_result.sheet.table.header[0].value)
+      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]]
+      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)
-
+      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_modules_type_parser.rb

@@ -1,68 +1,98 @@
 # frozen_string_literal: true
 
-# -*- encoding : utf-8 -*-
-require File.join(File.dirname(__FILE__), 'helper')
+require File.join(File.dirname(__FILE__), "helper")
 module Modules
   class TestTypeParser < Minitest::Test
     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),
+        "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),
+        "2012-12-12T12: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",
-        ""=>nil,
-        " "=> nil,
-        "12 bomen"=>"12 bomen",
-        "12 bomenasdfasdfsadf"=>"12 bomenasdfasdfsadf",
-        "mailto:sadf@asdf.as"=>"sadf@asdf.as",
-        "012-3456789"=>"012-3456789",
-        "TRUE"=>true
+        "jA" => "jA",
+        "n" => "n",
+        "" => nil,
+        " " => nil,
+        "12 bomen" => "12 bomen",
+        "12 bomenasdfasdfsadf" => "12 bomenasdfasdfsadf",
+        "mailto:sadf@asdf.as" => "sadf@asdf.as",
+        "012-3456789" => "012-3456789",
+        "TRUE" => true
       }
     end
 
     def test_parse
-      examples.each do |k,v|
-        if v == nil
-          assert_nil(Workbook::Cell.new(k).parse({:detect_date => true}))
+      examples.each do |k, v|
+        if v.nil?
+          assert_nil(Workbook::Cell.new(k).parse({detect_date: true}))
         else
-          assert_equal(v, Workbook::Cell.new(k).parse({:detect_date => true}))
+          assert_equal(v, Workbook::Cell.new(k).parse({detect_date: true}))
         end
       end
     end
 
     def test_custom_parse
-      customparsers = [proc{|v| "#{v}2" }]
-      examples.each do |k,v|
+      customparsers = [proc { |v| "#{v}2" }]
+      examples.each do |k, v|
         c = Workbook::Cell.new(k)
         c.string_parsers = customparsers
-        refute_equal(v,c.parse)
+        refute_equal(v, c.parse)
       end
       c = Workbook::Cell.new("233")
       c.string_parsers = customparsers
-      assert_equal("2332",c.parse)
+      assert_equal("2332", c.parse)
       c.value = "v"
-      assert_equal("v2",c.parse)
+      assert_equal("v2", c.parse)
+    end
+
+    def test_american_date_format
+      c = Workbook::Cell.new("01-11-2012")
+      c.string_parsers << :string_american_date_converter
+      assert_equal(Date.new(2012, 1, 11), c.parse)
+      c = Workbook::Cell.new("12-31-2012")
+      c.string_parsers << :string_american_date_converter
+      assert_equal(Date.new(2012, 12, 31), c.parse)
+      c = Workbook::Cell.new("12/31/2012")
+      c.string_parsers << :string_american_date_converter
+      assert_equal(Date.new(2012, 12, 31), c.parse)
+      c = Workbook::Cell.new("12/1/2012")
+      c.string_parsers << :string_american_date_converter
+      assert_equal(Date.new(2012, 12, 1), c.parse)
+    end
+
+    def test_non_american_date_format
+      c = Workbook::Cell.new("01-11-2012")
+      c.string_parsers << :string_non_american_date_converter
+      assert_equal(Date.new(2012, 11, 1), c.parse)
+      c = Workbook::Cell.new("31/12/2012")
+      c.string_parsers << :string_non_american_date_converter
+      assert_equal(Date.new(2012, 12, 31), c.parse)
+      c = Workbook::Cell.new("31.12.2012")
+      c.string_parsers << :string_non_american_date_converter
+      assert_equal(Date.new(2012, 12, 31), c.parse)
+      c = Workbook::Cell.new("12-1-2012")
+      c.string_parsers << :string_non_american_date_converter
+      assert_equal(Date.new(2012, 1, 12), c.parse)
     end
 
     def test_parse!
-      r= Workbook::Row.new
+      r = Workbook::Row.new
       r[0] = Workbook::Cell.new "xls_cell"
       r[0].parse!
-      assert_equal("xls_cell",r[0].value)
+      assert_equal("xls_cell", r[0].value)
       r[1] = Workbook::Cell.new ""
       r[1].parse!
       assert_nil(r[1].value)
     end
 
     def test_once_failing_files
-      w = Workbook::Book.open(File.join(File.dirname(__FILE__), '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
       assert_equal(Workbook::Book, w.class)
     end
   end