ruport 1.6.3 → 1.7.1

data/test/record_test.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby -w   
 require File.join(File.expand_path(File.dirname(__FILE__)), "helpers")
 
-class TestRecord < Test::Unit::TestCase
+class TestRecord < Minitest::Test
 
   include Ruport::Data
   
@@ -10,13 +10,13 @@ class TestRecord < Test::Unit::TestCase
     @record = Ruport::Data::Record.new [1,2,3,4], :attributes => @attributes 
   end   
   
-  context "when initializing with an array with attributes" do 
+  describe "when initializing with an array with attributes" do
     def specify_key_access_should_work
       assert_equal 1, @record["a"]
       assert_equal 4, @record["d"]
       assert_equal 2, @record.b
       assert_equal 3, @record.c
-      assert_raise(NoMethodError) { @record.f }        
+      assert_raises(NoMethodError) { @record.f }        
     end  
     
     def specify_ordinal_access_should_work
@@ -27,7 +27,7 @@ class TestRecord < Test::Unit::TestCase
     end
   end  
       
-  context "when initializing with an array without attributes" do
+  describe "when initializing with an array without attributes" do
     def specify_ordinal_access_should_work
       record = Ruport::Data::Record.new [1,2,3,4]
       assert_equal 1, record[0]
@@ -37,7 +37,7 @@ class TestRecord < Test::Unit::TestCase
     end 
   end         
   
-  context "when initializing with a hash without attributes" do    
+  describe "when initializing with a hash without attributes" do
     def setup  
       @record = Ruport::Data::Record.new({:a => 1, :b => 2, :c => 3},{})
     end     
@@ -50,7 +50,7 @@ class TestRecord < Test::Unit::TestCase
     end  
   end
   
-  context "when initializing with a hash with attributes" do
+  describe "when initializing with a hash with attributes" do
     def setup
       @record = Record.new({:a => 1, :b => 2, :c => 3 }, 
                            :attributes => [:c,:b,:a])
@@ -94,7 +94,7 @@ class TestRecord < Test::Unit::TestCase
   end
 
   def test_nonexistent_accessor
-    assert_raise NoMethodError do
+    assert_raises NoMethodError do
       @record.e
     end
   end
@@ -112,7 +112,7 @@ class TestRecord < Test::Unit::TestCase
   end
 
   def test_to_hash
-    assert_nothing_raised { @record.to_hash }
+    @record.to_hash
     assert_equal({ "a" => 1, "b" => 2, "c" => 3, "d" => 4 }, @record.to_hash)
   end  
   
@@ -175,10 +175,10 @@ class TestRecord < Test::Unit::TestCase
     assert_equal [1,2,3], r.to_a
     assert_equal %w[a b c], r.attributes
 
-    assert_raise(ArgumentError) { r.dup.reorder "foo" }
-    assert_raise(ArgumentError) { r.dup.reorder 0,5 }
-    assert_nothing_raised { r.dup.reorder 0 }
-    assert_nothing_raised { r.dup.reorder "a","b" }
+    assert_raises(ArgumentError) { r.dup.reorder "foo" }
+    assert_raises(ArgumentError) { r.dup.reorder 0,5 }
+    r.dup.reorder 0
+    r.dup.reorder "a","b"
   end
 
   def test_dup
@@ -290,7 +290,7 @@ class TestRecord < Test::Unit::TestCase
     assert_equal "1,2,3\n", a.to_csv
   end
     
-  context "when rendering records" do   
+  describe "when rendering records" do
     
     def specify_record_as_should_work
       rendered_row = @record.as(:text)
@@ -307,7 +307,7 @@ class TestRecord < Test::Unit::TestCase
       assert_equal("1\t2\t3\t4\n",rendered_row)     
     end                                      
     
-    context "when given bad format names" do
+    describe "when given bad format names" do
       def setup 
         @a = Record.new({ "a" => 1, "b" => 2 }) 
       end

data/test/samples/sales.csv

@@ -0,0 +1,21 @@
+Region,Product,Units Sold
+North,Widget,8
+South,Gadget,2
+East,Gizmo,8
+West,Widget,6
+South,Widget,6
+East,Gadget,5
+West,Gizmo,1
+East,Gadget,1
+West,Widget,4
+West,Gadget,8
+North,Gizmo,2
+South,Gizmo,5
+East,Widget,3
+North,Gadget,1
+South,Gizmo,7
+North,Gizmo,8
+North,Widget,4
+East,Gadget,4
+West,Gizmo,6
+South,Gadget,3

data/test/table_pivot_test.rb

@@ -1,10 +1,10 @@
-#!/usr/bin/env ruby -w   
+#!/usr/bin/env ruby -w
 require File.join(File.expand_path(File.dirname(__FILE__)), "helpers")
 
-class TablePivotSimpleCaseTest < Test::Unit::TestCase
+class TablePivotSimpleCaseTest < Minitest::Test
 
   def setup
-    table = Table('a', 'b', 'c')
+    table = Ruport.Table('a', 'b', 'c')
     table << [1,3,6]
     table << [1,4,7]
     table << [2,3,8]
@@ -17,18 +17,16 @@ class TablePivotSimpleCaseTest < Test::Unit::TestCase
   end
 
   def test_produces_correct_full_table
-    expected = Table("a",3,4) { |t| t << [1,6,7] << [2,8,9] }
+    expected = Ruport.Table("a",3,4) { |t| t << [1,6,7] << [2,8,9] }
     assert_equal(expected, @pivoted)
   end
 
 end
 
-class PivotConvertRowOrderToGroupOrderTest < Test::Unit::TestCase
+class PivotConvertRowOrderToGroupOrderTest < Minitest::Test
 
-  def convert(src)
-    Ruport::Data::Table::Pivot.new(
-      nil, nil, nil, nil
-    ).convert_row_order_to_group_order(src)
+  def convert(row_order)
+    Ruport::Data::Table::Pivot.row_order_to_group_order(row_order)
   end
 
   def setup
@@ -62,10 +60,10 @@ class PivotConvertRowOrderToGroupOrderTest < Test::Unit::TestCase
 
 end
 
-class PivotPreservesOrdering < Test::Unit::TestCase
+class PivotPreservesOrdering < Minitest::Test
 
-  def test_group_column_entries_preserves_order_of_occurrence
-    table = Table('group', 'a', 'b')
+  def test_group_column_preserves_order_of_occurrence
+    table = Ruport.Table('group', 'a', 'b')
     [
       [1, 0, 0],
       [9, 0, 0],
@@ -75,13 +73,13 @@ class PivotPreservesOrdering < Test::Unit::TestCase
       [8, 0, 0],
       [1, 0, 0]
     ].each {|e| table << e}
-    assert_equal([1,9,8], 
+    assert_equal([1,9,8],
        Ruport::Data::Table::Pivot.
-       new(table, 'group', 'a', 'b').group_column_entries)
+       new(table, 'group', 'a', 'b').column)
   end
 
-  def test_resulting_columns_preserve_ordering_of_rows
-    table = Table('group', 'a', 'b', 'c')
+  def test_pivoted_row_preserves_order_of_input_rows
+    table = Ruport.Table('group', 'a', 'b', 'c')
     [
       [200,   1, 2, 1],
       [200,   4, 5, 2],
@@ -93,11 +91,11 @@ class PivotPreservesOrdering < Test::Unit::TestCase
       [1,4,5],
       Ruport::Data::Table::Pivot.new(
         table, 'group', 'a', 'b', :pivot_order => ['c']
-      ).columns_from_pivot)
+      ).row)
   end
 
   def test_preserves_ordering
-    table = Table('group', 'a', 'b', 'c')
+    table = Ruport.Table('group', 'a', 'b', 'c')
     [
       [200,   1, 2, 3],
       [200,   4, 5, 6],
@@ -105,30 +103,76 @@ class PivotPreservesOrdering < Test::Unit::TestCase
       [100,   4,11,12]
     ].each {|e| table << e}
     pivoted = table.pivot('a', :group_by => 'group', :values => 'b')
-    expected = Table("group",1,4) { |t| t << [200,2,5] << [100,8,11] }
+    expected = Ruport.Table("group",1,4) { |t| t << [200,2,5] << [100,8,11] }
     assert_equal(expected, pivoted)
   end
 
-  def test_preserves_ordering_on_calculated_column
-    table = Table('group', 'a')
+  def test_reorders_a_calculated_column_by_column_name
+    table = Ruport.Table('group', 'a')
     [
       [1, 1], [2, 2], [3, 3]
     ].each {|e| table << e}
     table.add_column('pivotme') {|row| 10 - row.group.to_i}
-    pivoted = table.pivot('pivotme', :group_by => 'group', :values => 'a', 
+    pivoted = table.pivot('pivotme', :group_by => 'group', :values => 'a',
                                      :pivot_order => :name)
     assert_equal(['group', 7, 8, 9], pivoted.column_names)
   end
 
   def test_preserves_ordering_on_calculated_column_with_proc_pivot_order
-    table = Table('group', 'a')
+    table = Ruport.Table('group', 'a')
     [
       [1, 1], [2, 2], [3, 3]
     ].each {|e| table << e}
     table.add_column('pivotme') {|row| 10 - row.group.to_i}
-    pivoted = table.pivot('pivotme', :group_by => 'group', :values => 'a', 
+    pivoted = table.pivot('pivotme', :group_by => 'group', :values => 'a',
                                      :pivot_order => proc {|row, pivot| pivot })
     assert_equal(['group', 7, 8, 9], pivoted.column_names)
   end
 
 end
+
+class TablePivotOperationTest < Minitest::Test
+  def setup
+    @rows = [
+      Ruport::Data::Record.new('Values' => 3),
+      Ruport::Data::Record.new('Values' => 9),
+      Ruport::Data::Record.new('Values' => 4)
+    ]
+  end
+
+  def test_performs_operation_sum
+    sum = Ruport::Data::Table::Pivot::Operations.sum(@rows, 'Values')
+    assert_equal 16, sum
+  end
+
+  def test_performs_operation_first
+    first = Ruport::Data::Table::Pivot::Operations.first(@rows, 'Values')
+    assert_equal 3, first
+  end
+
+  def test_performs_operation_count
+    count = Ruport::Data::Table::Pivot::Operations.count(@rows, 'Values')
+    assert_equal 3, count
+  end
+
+  def test_performs_operation_mean
+    mean = Ruport::Data::Table::Pivot::Operations.mean(@rows, 'Values')
+    assert_equal 5, mean
+  end
+
+  def test_performs_operation_min
+    min = Ruport::Data::Table::Pivot::Operations.min(@rows, 'Values')
+    assert_equal 3, min
+  end
+
+  def test_performs_operation_max
+    max = Ruport::Data::Table::Pivot::Operations.max(@rows, 'Values')
+    assert_equal 9, max
+  end
+
+  def test_invalid_operation_causes_exception
+    assert_raises ArgumentError do
+      Ruport::Data::Table::Pivot.new(nil, nil, nil, nil, :operation => :foo)
+    end
+  end
+end

data/test/table_test.rb

@@ -1,40 +1,39 @@
-#!/usr/bin/env ruby -w 
+#!/usr/bin/env ruby -w
 require File.join(File.expand_path(File.dirname(__FILE__)), "helpers")
-TEST_SAMPLES = File.join(File.expand_path(File.dirname(__FILE__)), "samples")
 
 class Person < Ruport::Data::Record
-  
+
   def name
     first_name + " " + last_name
   end
 
-end      
+end
 
 class DuckRecord < Ruport::Data::Record; end
 
-class TestTable < Test::Unit::TestCase
+class TestTable < Minitest::Test
   def test_constructors
     table  = Ruport::Data::Table.new
 
     table2 = Ruport::Data::Table.new :column_names => %w[a b c]
     table3 = Ruport::Data::Table.new :data => [[1,2,3]]
-    table4 = Ruport::Data::Table.new :column_names => %w[col1 col2 col3], 
+    table4 = Ruport::Data::Table.new :column_names => %w[col1 col2 col3],
                                      :data => [[1,2,3]]
     tables = [table,table2,table3,table4]
 
     tables.zip([[],%w[a b c], [], %w[col1 col2 col3]]).each do |t,n|
       assert_equal n, t.column_names
 
-      t = Table(%w[a b c], :data => [[1,2,3],[4,5,6]])
-      table_from_records = Table(t.column_names, :data => t.data)
+      t = Ruport.Table(%w[a b c], :data => [[1,2,3],[4,5,6]])
+      table_from_records = Ruport.Table(t.column_names, :data => t.data)
     end
-    
+
     a = Ruport::Data::Record.new [1,2,3]
     b = Ruport::Data::Record.new [1,2,3], :attributes => %w[col1 col2 col3]
-    tables.zip([[],[],[a],[b]]).each do |t,n| 
-      assert_equal n, t.data 
+    tables.zip([[],[],[a],[b]]).each do |t,n|
+      assert_equal n, t.data
     end
-  end    
+  end
 
   context "when filtering data" do
 
@@ -46,102 +45,102 @@ class TestTable < Test::Unit::TestCase
       table = Ruport::Data::Table.new(:column_names => %w[a b c],
                                       :data => [[1,2,3],[4,5,6],[7,8,9]],
                                       :filters => [ lambda { |r| r.a % 2 == 1 } ] )
-      assert_equal Table(%w[a b c]) << [1,2,3] << [7,8,9], table
-    end     
-    
-    def specify_filters_should_work_on_csvs        
+      assert_equal Ruport.Table(%w[a b c]) << [1,2,3] << [7,8,9], table
+    end
+
+    def specify_filters_should_work_on_csvs
       only_ids_less_than_3 = lambda { |r| r["id"].to_i < 3 }
-      table = Table(File.join(TEST_SAMPLES,"addressbook.csv"), 
+      table = Ruport.Table(File.join(TEST_SAMPLES,"addressbook.csv"),
                     :filters => [only_ids_less_than_3])
       assert_equal ["1","2"], table.map { |r| r["id"] }
     end
-  end  
-  
+  end
+
   context "when transforming data" do
-    
+
     def setup
-      @data = [[1,2,3],[4,5,6],[7,8,9]] 
+      @data = [[1,2,3],[4,5,6],[7,8,9]]
     end
-    
+
     def specify_transforms_should_modify_table_data
-     
-     stringify_c = lambda { |r| r.c = r.c.to_s } 
+
+     stringify_c = lambda { |r| r.c = r.c.to_s }
      add_two_to_all_int_cols = lambda { |r|
       r.each_with_index do |c,i|
         if Fixnum === c
           r[i] += 2
         end
       end
-        
-     }                                                           
-     
+
+     }
+
      table = Ruport::Data::Table.new(:column_names => %w[a b c],
                                      :data => @data,
                                      :transforms => [stringify_c,
                                                      add_two_to_all_int_cols])
-     assert_equal Table(%w[a b c]) << [3,4,"3"] << [6,7,"6"] << [9,10,"9"],
+     assert_equal Ruport.Table(%w[a b c]) << [3,4,"3"] << [6,7,"6"] << [9,10,"9"],
                   table
-      
-    end 
-    
-    def specify_transforms_should_work_on_csvs  
+
+    end
+
+    def specify_transforms_should_work_on_csvs
       ids_to_i = lambda { |r| r["id"] = r["id"].to_i }
-      table = Table(File.join(TEST_SAMPLES,"addressbook.csv"), 
-                    :filters => [ids_to_i])  
-      assert_equal [1,2,3,4,5], table.map { |r| r["id"] }          
+      table = Ruport.Table(File.join(TEST_SAMPLES,"addressbook.csv"),
+                    :filters => [ids_to_i])
+      assert_equal [1,2,3,4,5], table.map { |r| r["id"] }
     end
   end
 
   def test_to_group
-    a = Table(%w[a b c], :data => [[1,2,3],[4,5,6]]).to_group("Packrats")
+    a = Ruport.Table(%w[a b c], :data => [[1,2,3],[4,5,6]]).to_group("Packrats")
     b = Ruport::Data::Group.new( :data => [[1,2,3],[4,5,6]],
                                  :column_names => %w[a b c],
                                  :name => "Packrats" )
     assert_equal a,b
   end
- 
+
   def test_rows_with
-    table = Table(%w[a b c], :data => [[1,2,3],[1,3,4],[7,8,9]])
-    
+    table = Ruport.Table(%w[a b c], :data => [[1,2,3],[1,3,4],[7,8,9]])
+
     assert_equal([table[0],table[1]],table.rows_with("a" => 1))
     assert_equal([table[1]],table.rows_with("a" => 1, "b" => 3))
     assert_equal([table[0]],table.rows_with(:a => 1, :b => 2))
     assert_equal([table[2]], table.rows_with_b(8))
     assert_equal [table[1]], table.rows_with(%w[a b]) { |a,b| [a,b] == [1,3] }
   end
-  
+
   def test_sigma
-    table = Table(%w[col1 col2], :data => [[1,2],[3,4],[5,6]])
+    table = Ruport.Table(%w[col1 col2], :data => [[1,2],[3,4],[5,6]])
     assert table.respond_to?(:sigma)
     assert table.respond_to?(:sum)
     assert_equal(9,table.sigma(0))
     assert_equal(9,table.sigma("col1"))
     assert_equal(21,table.sigma { |r| r.col1 + r.col2 })
   end
-  
+
   def test_sub_table
-    table = Table(%w[a b c d], 
+    table = Ruport.Table(%w[a b c d],
       :data => [ [1,2,3,4],[5,6,7,9],[10,11,12,13],[14,15,16,17] ])
-   
-    assert_equal Table(%w[b c], :data => [[6,7],[11,12]]), 
-                 table.sub_table(%w[b c],1..-2) 
-                 
-    assert_equal Table(%w[c d a], :data => [[3,4,1],[7,9,5]]),  
-                 table.sub_table(%w[c d a]) { |r| r.a < 10 }    
-                 
-    assert_equal Table(%w[a c], :data => [[1,3],[5,7],[10,12],[14,16]]),  
+
+    assert_equal Ruport.Table(%w[b c], :data => [[6,7],[11,12]]),
+                 table.sub_table(%w[b c],1..-2)
+
+    assert_equal Ruport.Table(%w[c d a], :data => [[3,4,1],[7,9,5]]),
+                 table.sub_table(%w[c d a]) { |r| r.a < 10 }
+
+    assert_equal Ruport.Table(%w[a c], :data => [[1,3],[5,7],[10,12],[14,16]]),
                  table.sub_table(%w[a c])
-     
-    assert_equal Table(%w[a b c d], :data => [[10,11,12,13],[14,15,16,17]]),      
-                 table.sub_table { |r| r.c > 10 }      
-                 
-    assert_equal Table(%w[a b c d], :data => [[10,11,12,13],[14,15,16,17]]),      
-                table.sub_table(2..-1)   
-                  
-  end
-  
+
+    assert_equal Ruport.Table(%w[a b c d], :data => [[10,11,12,13],[14,15,16,17]]),
+                 table.sub_table { |r| r.c > 10 }
+
+    assert_equal Ruport.Table(%w[a b c d], :data => [[10,11,12,13],[14,15,16,17]]),
+                table.sub_table(2..-1)
+
+  end
+
   def test_subtable_records_have_correct_data
-    table = Table(%w[a b c d],
+    table = Ruport.Table(%w[a b c d],
       :data => [ [1,2,3,4],[5,6,7,9],[10,11,12,13],[14,15,16,17] ])
     sub = table.sub_table(%w[b c d]) {|r| r.a == 1 }
     assert_equal({"b"=>2, "c"=>3, "d"=>4}, sub[0].data)
@@ -149,17 +148,17 @@ class TestTable < Test::Unit::TestCase
   end
 
   def test_reduce
-    table = Table(%w[a b c d],
+    table = Ruport.Table(%w[a b c d],
       :data => [ [1,2,3,4],[5,6,7,9],[10,11,12,13],[14,15,16,17] ])
 
     table.reduce(%w[b c],1..-2)
-    assert_equal Table(%w[b c], :data => [[6,7],[11,12]]), table
+    assert_equal Ruport.Table(%w[b c], :data => [[6,7],[11,12]]), table
 
-    table = Table(%w[a b c d],
+    table = Ruport.Table(%w[a b c d],
       :data => [ [1,2,3,4],[5,6,7,9],[10,11,12,13],[14,15,16,17] ])
     table.reduce(%w[c d a]) { |r| r.a < 10 }
 
-    assert_equal Table(%w[c d a], :data => [[3,4,1],[7,9,5]]), table
+    assert_equal Ruport.Table(%w[c d a], :data => [[3,4,1],[7,9,5]]), table
   end
 
   def test_reorder
@@ -169,58 +168,58 @@ class TestTable < Test::Unit::TestCase
     rows = [%w[a c], %w[d e]]
     table.each { |r| assert_equal rows.shift, r.to_a
                      assert_equal %w[col1 col3], r.attributes }
-    a = Table(%w[a b c], :data => [[1,2,3],[4,5,6]]).reorder 2,0
+    a = Ruport.Table(%w[a b c], :data => [[1,2,3],[4,5,6]]).reorder 2,0
     rows = [[3,1],[6,4]]
-    a.each { |r| assert_equal rows.shift, r.to_a 
+    a.each { |r| assert_equal rows.shift, r.to_a
                  assert_equal %w[c a], r.attributes }
     assert_equal %w[c a], a.column_names
 
-    b = Table(%w[a b c], :data => [[1,2,3],[4,5,6]]).reorder(%w[a c])
+    b = Ruport.Table(%w[a b c], :data => [[1,2,3],[4,5,6]]).reorder(%w[a c])
     rows = [[1,3],[4,6]]
-    b.each { |r| 
+    b.each { |r|
       assert_equal rows.shift, r.to_a
-      assert_equal %w[a c], r.attributes 
+      assert_equal %w[a c], r.attributes
       assert_equal b.column_names.object_id,
                    r.instance_eval{@attributes}.object_id
     }
-  end     
-  
-  context "when sorting rows" do 
-    
+  end
+
+  context "when sorting rows" do
+
     def setup
-      @table = Table(%w[a b c]) << [1,2,3] << [6,1,8] << [9,1,4] 
-      @table_with_nils = Table(%w[a b c]) << [1,nil,3] << [9,3,4] << [6,1,8]
+      @table = Ruport.Table(%w[a b c]) << [1,2,3] << [6,1,8] << [9,1,4]
+      @table_with_nils = Ruport.Table(%w[a b c]) << [1,nil,3] << [9,3,4] << [6,1,8]
     end
-    
+
     def specify_should_sort_in_reverse_order_on_descending
-       t = @table.sort_rows_by("a", :order => :descending ) 
-       assert_equal Table(%w[a b c]) << [9,1,4] << [6,1,8] << [1,2,3], t   
-       
-       t = @table.sort_rows_by("c", :order => :descending ) 
-       assert_equal Table(%w[a b c]) << [6,1,8] << [9,1,4] << [1,2,3], t               
-    end  
-    
-    def specify_show_put_rows_with_nil_columns_after_sorted_rows    
+       t = @table.sort_rows_by("a", :order => :descending )
+       assert_equal Ruport.Table(%w[a b c]) << [9,1,4] << [6,1,8] << [1,2,3], t
+
+       t = @table.sort_rows_by("c", :order => :descending )
+       assert_equal Ruport.Table(%w[a b c]) << [6,1,8] << [9,1,4] << [1,2,3], t
+    end
+
+    def specify_show_put_rows_with_nil_columns_after_sorted_rows
        # should not effect when using columns that are all populated
-       t = @table_with_nils.sort_rows_by("a") 
-       assert_equal Table(%w[a b c]) << [1,nil,3] << [6,1,8] << [9,3,4], t 
-       
+       t = @table_with_nils.sort_rows_by("a")
+       assert_equal Ruport.Table(%w[a b c]) << [1,nil,3] << [6,1,8] << [9,3,4], t
+
        t = @table_with_nils.sort_rows_by("b")
-       assert_equal Table(%w[a b c]) << [6,1,8] << [9,3,4] << [1,nil,3], t    
-       
+       assert_equal Ruport.Table(%w[a b c]) << [6,1,8] << [9,3,4] << [1,nil,3], t
+
        t = @table_with_nils.sort_rows_by("b", :order => :descending)
-       assert_equal Table(%w[a b c]) << [1,nil,3] << [9,3,4] << [6,1,8], t
+       assert_equal Ruport.Table(%w[a b c]) << [1,nil,3] << [9,3,4] << [6,1,8], t
     end
-    
+
     def specify_in_place_sort_should_allow_order_by
        @table.sort_rows_by!("a", :order => :descending )
-       assert_equal Table(%w[a b c]) << [9,1,4] << [6,1,8] << [1,2,3], @table
+       assert_equal Ruport.Table(%w[a b c]) << [9,1,4] << [6,1,8] << [1,2,3], @table
     end
-    
+
     def specify_sort_rows_by
       table = Ruport::Data::Table.new :column_names => %w[a b c]
-      table << [1,2,3] << [6,1,8] << [9,1,4]    
-    
+      table << [1,2,3] << [6,1,8] << [9,1,4]
+
       table2 = Ruport::Data::Table.new :column_names => [:a, :b, :c]
       table2 << [1,2,3] << [6,1,8] << [9,1,4]
 
@@ -229,19 +228,19 @@ class TestTable < Test::Unit::TestCase
 
       sorted_table_b = Ruport::Data::Table.new :column_names => %w[a b c]
       sorted_table_b << [6,1,8] << [9,1,4] << [1,2,3]
-    
+
       sorted_table_bc = Ruport::Data::Table.new :column_names => %w[a b c]
-      sorted_table_bc << [9,1,4] << [6,1,8] << [1,2,3] 
-    
+      sorted_table_bc << [9,1,4] << [6,1,8] << [1,2,3]
+
       sorted_table_bs = Ruport::Data::Table.new :column_names => [:a, :b, :c]
       sorted_table_bs << [6,1,8] << [9,1,4] << [1,2,3]
-  
+
       assert_equal sorted_table_a,  table.sort_rows_by {|r| r['a']}
       assert_equal sorted_table_b,  table.sort_rows_by(['b'])
       assert_equal sorted_table_bc, table.sort_rows_by(['b', 'c'])
       assert_equal sorted_table_bs, table2.sort_rows_by(:b)
-    end              
-       
+    end
+
     def specify_sort_rows_by!
       table = Ruport::Data::Table.new :column_names => %w[a b c]
       table << [1,2,3] << [6,1,8] << [9,1,4]
@@ -251,37 +250,68 @@ class TestTable < Test::Unit::TestCase
 
       sorted_table_b = Ruport::Data::Table.new :column_names => %w[a b c]
       sorted_table_b << [6,1,8] << [9,1,4] << [1,2,3]
-    
+
       sorted_table_bc = Ruport::Data::Table.new :column_names => %w[a b c]
       sorted_table_bc << [9,1,4] << [6,1,8] << [1,2,3]
-    
+
       table_a = table.dup
-      table_a.sort_rows_by! { |r| r['a'] }       
-    
+      table_a.sort_rows_by! { |r| r['a'] }
+
       table_b = table.dup
       table_b.sort_rows_by!("b")
-    
+
       table_bc = table.dup
-      table_bc.sort_rows_by!(['b', 'c'])             
-  
+      table_bc.sort_rows_by!(['b', 'c'])
+
       assert_equal sorted_table_a,  table_a
       assert_equal sorted_table_b,  table_b
       assert_equal sorted_table_bc, table_bc
     end
-    
-  end  
+
+  end
+
+  context "when adding rows" do
+    def setup
+      @columns = %w[a b c]
+      @data = [[1,2,3],[4,5,6],[7,8,9]]
+      @table = Ruport::Data::Table.new(:column_names => @columns, :data => @data)
+      @new_row = [-1,-2,-3]
+    end
+
+    def specify_insert_at_the_beginning
+      @table.add_row(@new_row, :position => 0)
+      assert_equal Ruport::Data::Table.new(:column_names => @columns,
+          :data => [@new_row] + @data), @table
+    end
+
+    def specify_insert_in_the_middle
+      @table.add_row(@new_row, :position => 2)
+      assert_equal Ruport::Data::Table.new(:column_names => @columns,
+          :data => [[1,2,3],[4,5,6],[-1,-2,-3],[7,8,9]]), @table
+    end
+
+    def specify_insert_at_the_end
+      @table.add_row(@new_row)
+      assert_equal Ruport::Data::Table.new(:column_names => @columns,
+          :data => @data + [@new_row]), @table
+    end
+
+    def should_return_itself
+      assert_equal @table.object_id, @table.add_row(@new_row).object_id
+    end
+  end
 
   def test_record_class
-    a = Ruport::Data::Table.new( :column_names => %w[first_name last_name c], 
+    a = Ruport::Data::Table.new( :column_names => %w[first_name last_name c],
                                  :data =>[['joe','loop',3],['jim','blue',6]],
                                  :record_class => Person )
-    assert_equal a, Table(%w[first_name last_name c],
+    assert_equal a, Ruport.Table(%w[first_name last_name c],
       :data => [ ['joe','loop',3],['jim','blue',6] ])
     assert_kind_of Person, a[0]
     assert_equal 'joe loop', a[0].name
     assert_equal 'jim blue', a[1].name
 
-    b = Table(%w[first_name last_name], :record_class => Person) do |t|
+    b = Ruport.Table(%w[first_name last_name], :record_class => Person) do |t|
       t << { 'first_name' => 'joe', 'last_name' => 'frasier' }
       t << { 'first_name' => 'brian', 'last_name' => 'black' }
     end
@@ -289,72 +319,71 @@ class TestTable < Test::Unit::TestCase
     b.each { |r| assert_kind_of Person, r }
 
     assert_equal ['joe frasier', 'brian black'], b.map { |r| r.name }
-  end 
+  end
 
   ## BUG Traps -------------------------------------------------
-  
+
   def test_ensure_table_creation_allows_record_coercion
-    table = Table([], :data => [[1,2,3],[4,5,6],[7,8,9]])
-    table_with_names = Table(%w[a b c], :data => [[1,2,3],[4,5,6],[7,8,9]])
-   
+    table = Ruport.Table([], :data => [[1,2,3],[4,5,6],[7,8,9]])
+    table_with_names = Ruport.Table(%w[a b c], :data => [[1,2,3],[4,5,6],[7,8,9]])
+
     a,b,c = nil
-    assert_nothing_raised { a = Table(%w[a b c], :data => table.to_a) }
-    assert_nothing_raised { b = Table(%w[d e f], :data => table.to_a) }
-    assert_nothing_raised { c = Table(table_with_names.column_names,
-      :data => table_with_names.to_a) }
+    a = Ruport.Table(%w[a b c], :data => table.to_a)
+    b = Ruport.Table(%w[d e f], :data => table.to_a)
+    c = Ruport.Table(table_with_names.column_names, :data => table_with_names.to_a)
 
     [a,b,c].each { |t| assert_equal(3,t.length) }
     assert_equal %w[a b c], a.column_names
     a.each { |r|
       assert_equal %w[a b c], r.attributes
-      assert_nothing_raised { r.a; r.b; r.c }
+      r.a; r.b; r.c 
       [r.a,r.b,r.c].each { |i| assert(i.kind_of?(Numeric)) }
     }
     assert_equal %w[d e f], b.column_names
     b.each { |r|
       assert_equal %w[d e f], r.attributes
-      assert_nothing_raised { r.d; r.e; r.f }
+      r.d; r.e; r.f
       [r.d,r.e,r.f].each { |i| assert(i.kind_of?(Numeric)) }
     }
     c.each { |r|
-      assert_nothing_raised { r[0]; r[1]; r[2] }
+      r[0]; r[1]; r[2]
       [r[0],r[1],r[2]].each { |i| assert(i.kind_of?(Numeric)) }
     }
-  end   
-  
+  end
+
   def test_ensure_coerce_sum
-    s = Table([], :data => [["1"],["3"],["5"]])
-    t = Table([], :data => [["1.23"],["1.5"]])
-    
+    s = Ruport.Table([], :data => [["1"],["3"],["5"]])
+    t = Ruport.Table([], :data => [["1.23"],["1.5"]])
+
     assert_equal(9,s.sum(0))
     assert_equal(2.73,t.sum(0))
   end
-  
+
   def test_to_yaml
     require "yaml"
-    a = Table([])
-    assert_nothing_raised { a.to_yaml }
-    a = Table(%w[first_name last_name],:record_class => Person) { |t| 
-      t << %w[joe loop] 
+    a = Ruport.Table([])
+    a.to_yaml
+    a = Ruport.Table(%w[first_name last_name],:record_class => Person) { |t|
+      t << %w[joe loop]
     }
     assert_equal "joe loop", a[0].name
-    assert_nothing_raised { a.to_yaml }
-  end  
-  
+    a.to_yaml 
+  end
+
   def test_ensure_subtable_works_with_unnamed_tables
-     a = Table([], :data => [[1,2,3],[4,5,6]])
-     b = a.sub_table { |r| (r[0] % 2).zero? } 
-     assert_equal Table([], :data => [[4,5,6]]), b
-  end  
-  
+     a = Ruport.Table([], :data => [[1,2,3],[4,5,6]])
+     b = a.sub_table { |r| (r[0] % 2).zero? }
+     assert_equal Ruport.Table([], :data => [[4,5,6]]), b
+  end
+
   def test_ensure_appending_records_works_with_unnamed_tables
-     a = Table([], :data => [[1,2,3],[4,5,6]])
+     a = Ruport.Table([], :data => [[1,2,3],[4,5,6]])
      a << Ruport::Data::Record.new([7,8,9])
-     assert_equal Table([], :data => [[1,2,3],[4,5,6],[7,8,9]]),a
+     assert_equal Ruport.Table([], :data => [[1,2,3],[4,5,6],[7,8,9]]),a
   end
 
   def test_ensure_propagate_record_class
-    a = Table(:record_class => DuckRecord)
+    a = Ruport.Table(:record_class => DuckRecord)
     assert_equal DuckRecord, a.record_class
 
     b = a.dup
@@ -362,270 +391,270 @@ class TestTable < Test::Unit::TestCase
   end
 
   def test_ensure_reorder_raises_on_bad_reorder_use
-    a = Table() << [1,2,3] << [4,5,6]
-    assert_raise(ArgumentError) { a.reorder("a","b","c") }
-    assert_raise(ArgumentError) { a.reorder(%w[a b c]) }
-    assert_raise(ArgumentError) { a.reorder(2,1,0) }
-  end    
+    a = Ruport.Table() << [1,2,3] << [4,5,6]
+    assert_raises(ArgumentError) { a.reorder("a","b","c") }
+    assert_raises(ArgumentError) { a.reorder(%w[a b c]) }
+    assert_raises(ArgumentError) { a.reorder(2,1,0) }
+  end
 
   class MySubClass < Ruport::Data::Table; end
-  
+
   def test_ensure_table_subclasses_render_properly
     a = MySubClass.new
     a << [1,2,3] << [4,5,6]
     assert_equal("1,2,3\n4,5,6\n",a.as(:csv))
   end
 
-end    
+end
 
-class TestTableAppendOperations < Test::Unit::TestCase
-  def test_append_record  
+class TestTableAppendOperations < Minitest::Test
+  def test_append_record
     table = Ruport::Data::Table.new :column_names => %w[a b c]
     table << Ruport::Data::Record.new([1,2,3], :attributes => %w[a b c])
     assert_equal([1,2,3],table[0].to_a)
     assert_equal(%w[a b c],table[0].attributes)
     rec = table[0].dup
     rec.attributes = %w[a b c d]
-    assert_raise(NoMethodError) { table << Object.new }
+    assert_raises(NoMethodError) { table << Object.new }
   end
-  
+
   def test_append_hash
-    table = Table(%w[a b c], :data => [[1,2,3],[4,5,6]])
+    table = Ruport.Table(%w[a b c], :data => [[1,2,3],[4,5,6]])
     table << { "a" => 7, "c" => 9, "b" => 8 }
-    
-    assert_equal Table(%w[a b c], :data => [[1,2,3],[4,5,6],[7,8,9]]), table
+
+    assert_equal Ruport.Table(%w[a b c], :data => [[1,2,3],[4,5,6],[7,8,9]]), table
   end
 
   def test_append_table
     first = Ruport::Data::Table.new :column_names => %w[a b c],
       :data => [[1,2,3],[4,5,6]]
-    
+
     second = Ruport::Data::Table.new :column_names => %w[a b c],
       :data => [[7,8,9],[10,11,12]]
-      
+
     combo = first + second
-    
-    assert_equal Ruport::Data::Table.new(:column_names => %w[a b c], 
+
+    assert_equal Ruport::Data::Table.new(:column_names => %w[a b c],
       :data => [[1,2,3],[4,5,6],[7,8,9],[10,11,12]]), combo
-  end  
-  
+  end
+
   def test_append_chain
     table = Ruport::Data::Table.new :column_names => %w[a b c]
-    table << [1,2,3] << [4,5,6] << [7,8,9] 
+    table << [1,2,3] << [4,5,6] << [7,8,9]
     assert_equal 3, table.length
     assert_equal 5, table[1].b
-  end  
+  end
 end
 
-class TestTableFormattingHooks < Test::Unit::TestCase
-  
+class TestTableFormattingHooks < Minitest::Test
+
   def test_to_hack_takes_args
-    a = Table(%w[hello mr crowley]) << %w[would you like] << %w[one red cat]
-    
+    a = Ruport.Table(%w[hello mr crowley]) << %w[would you like] << %w[one red cat]
+
     assert_equal "would,you,like\none,red,cat\n",
                  a.to_csv(:show_table_headers => false)
-    
+
     assert_equal "would,you,like\none,red,cat\n",
-                 a.to_csv { |r| r.options.show_table_headers = false }    
-                 
+                 a.to_csv { |r| r.options.show_table_headers = false }
+
     assert_equal "would\tyou\tlike\none\tred\tcat\n",
                  a.to_csv(:show_table_headers => false) { |r|
                    r.options.format_options = { :col_sep => "\t" }
                  }
-  end     
-  
+  end
+
   def test_to_hack
-    table = Ruport::Data::Table.new :column_names => %w[a b], 
+    table = Ruport::Data::Table.new :column_names => %w[a b],
                                     :data => [[1,2],[3,4],[5,6]]
     assert_equal("a,b\n1,2\n3,4\n5,6\n",table.to_csv)
     assert_raises(Ruport::Controller::UnknownFormatError) { table.to_nothing }
   end
 
   def test_as_throws_proper_errors
-    a = Table(%w[a b c], :data => [[1,2,3],[4,5,6]])
-    assert_nothing_raised { a.as(:csv) }
-    assert_nothing_raised { a.to_csv }
+    a = Ruport.Table(%w[a b c], :data => [[1,2,3],[4,5,6]])
+    a.as(:csv)
+    a.to_csv 
     assert_raises(Ruport::Controller::UnknownFormatError) { a.as(:nothing) }
     assert_raises(Ruport::Controller::UnknownFormatError) { a.to_nothing }
   end
-    
+
 end
 
-class TestTableColumnOperations < Test::Unit::TestCase
-  
+class TestTableColumnOperations < Minitest::Test
+
   def test_column
-    a = Table(%w[a b c], :data => [[1,2,3],[4,5,6]])
+    a = Ruport.Table(%w[a b c], :data => [[1,2,3],[4,5,6]])
     assert_equal [3,6], a.column(2)
-    assert_equal [2,5], a.column("b") 
-    
-    assert_raise(ArgumentError) { a.column("d") }  
-    assert_raise(ArgumentError) { a.column(42) }
-    
-    a = Table([], :data => [[1],[2],[3],[4]])
-    assert_equal [1,2,3,4], a.column(0)  
+    assert_equal [2,5], a.column("b")
+
+    assert_raises(ArgumentError) { a.column("d") }
+    assert_raises(ArgumentError) { a.column(42) }
+
+    a = Ruport.Table([], :data => [[1],[2],[3],[4]])
+    assert_equal [1,2,3,4], a.column(0)
   end
-    
+
   def test_set_column_names
-    a = Table([], :data => [[1,2,3],[4,5,6]])
-    
+    a = Ruport.Table([], :data => [[1,2,3],[4,5,6]])
+
     assert_equal([],a.column_names)
     assert_equal([[1,2,3],[4,5,6]],a.map { |r| r.to_a } )
-                                                          
+
     a.column_names = %w[a b c]
     assert_equal(%w[a b c],a.column_names)
-    a.each { |r| assert_equal(%w[a b c], r.attributes) }    
+    a.each { |r| assert_equal(%w[a b c], r.attributes) }
     assert_equal([[1,2,3],[4,5,6]],a.map { |r| r.to_a })
-    
+
     a.column_names = %w[d e f]
     assert_equal(%w[d e f],a.column_names)
     a.each { |r| assert_equal(%w[d e f], r.attributes) }
-    assert_equal([[1,2,3],[4,5,6]],a.map { |r| r.to_a })   
-  end   
-  
+    assert_equal([[1,2,3],[4,5,6]],a.map { |r| r.to_a })
+  end
+
   def test_add_column
-     a = Table(%w[a b], :data => [[1,2],[3,4],[5,6]])
+     a = Ruport.Table(%w[a b], :data => [[1,2],[3,4],[5,6]])
      a.add_column("c")
-     assert_equal Table(%w[a b c], :data => [[1,2,nil],[3,4,nil],[5,6,nil]]), a
+     assert_equal Ruport.Table(%w[a b c], :data => [[1,2,nil],[3,4,nil],[5,6,nil]]), a
 
-     a = Table(%w[a b], :data => [[1,2],[3,4],[5,6]])
+     a = Ruport.Table(%w[a b], :data => [[1,2],[3,4],[5,6]])
      a.add_column("c",:default => "x")
-     assert_equal Table(%w[a b c], :data => [[1,2,'x'],[3,4,'x'],[5,6,'x']]), a    
+     assert_equal Ruport.Table(%w[a b c], :data => [[1,2,'x'],[3,4,'x'],[5,6,'x']]), a
 
      b = a.dup
      b.add_column("x",:before => "b")
-     assert_equal Table(%w[a x b c],
-      :data => [[1,nil,2,'x'],[3,nil,4,'x'],[5,nil,6,'x']]), b 
+     assert_equal Ruport.Table(%w[a x b c],
+      :data => [[1,nil,2,'x'],[3,nil,4,'x'],[5,nil,6,'x']]), b
 
      b = a.dup
      b.add_column("x",:after => "b")
-     assert_equal Table(%w[a b x c],
-      :data => [[1,2,nil,'x'],[3,4,nil,'x'],[5,6,nil,'x']]), b  
+     assert_equal Ruport.Table(%w[a b x c],
+      :data => [[1,2,nil,'x'],[3,4,nil,'x'],[5,6,nil,'x']]), b
 
 
      a.add_column("d") { |r| r[0]+r[1] }
-     assert_equal Table(%w[a b c d],
+     assert_equal Ruport.Table(%w[a b c d],
       :data => [ [1,2,'x',3],[3,4,'x',7],[5,6,'x',11] ]), a
 
      a.add_column("x",:position => 1)
-     assert_equal Table(%w[a x b c d],
+     assert_equal Ruport.Table(%w[a x b c d],
       :data => [ [1,nil,2,'x',3],[3,nil,4,'x',7],[5,nil,6,'x',11] ]), a
   end
 
   def test_add_columns
-    a = Table(%w[a b], :data => [[1,2],[3,4],[5,6]])
+    a = Ruport.Table(%w[a b], :data => [[1,2],[3,4],[5,6]])
     a.add_columns(%w[c d])
-    expected = Table(%w[a b c d],
+    expected = Ruport.Table(%w[a b c d],
       :data => [ [1,2,nil,nil],[3,4,nil,nil],[5,6,nil,nil] ])
 
-    assert_equal expected, a                  
+    assert_equal expected, a
 
-    a = Table(%w[a b], :data => [[1,2],[3,4],[5,6]])
+    a = Ruport.Table(%w[a b], :data => [[1,2],[3,4],[5,6]])
 
     a.add_columns(%w[c d],:after => "a")
 
-    expected = Table(%w[a c d b],
-      :data => [ [1,nil,nil,2],[3,nil,nil,4],[5,nil,nil,6], ])                        
+    expected = Ruport.Table(%w[a c d b],
+      :data => [ [1,nil,nil,2],[3,nil,nil,4],[5,nil,nil,6], ])
 
-    assert_equal expected, a                                   
+    assert_equal expected, a
 
     a.add_columns(%w[x f],:before => "a")
 
-    expected = Table(%w[x f a c d b],
+    expected = Ruport.Table(%w[x f a c d b],
       :data => [ [nil,nil,1,nil,nil,2],
                  [nil,nil,3,nil,nil,4],
                  [nil,nil,5,nil,nil,6] ])
 
-    assert_equal expected, a       
+    assert_equal expected, a
 
-    a = Table(%w[a b c], :data => [[1,2,0],[3,4,0],[5,6,0]])  
+    a = Ruport.Table(%w[a b c], :data => [[1,2,0],[3,4,0],[5,6,0]])
 
     a.add_columns(%w[x y],:default => 9, :position => 1)
 
-    expected = Table(%w[a x y b c],
-      :data => [[1,9,9,2,0],[3,9,9,4,0],[5,9,9,6,0]])  
+    expected = Ruport.Table(%w[a x y b c],
+      :data => [[1,9,9,2,0],[3,9,9,4,0],[5,9,9,6,0]])
 
     assert_equal expected, a
 
-    a = Table(%w[a b], :data => [[1,2],[3,4],[5,6]])
+    a = Ruport.Table(%w[a b], :data => [[1,2],[3,4],[5,6]])
     a.add_columns(%w[f x],:default => 0)
 
-    expected = Table(%w[a b f x], :data => [[1,2,0,0],[3,4,0,0],[5,6,0,0]])
+    expected = Ruport.Table(%w[a b f x], :data => [[1,2,0,0],[3,4,0,0],[5,6,0,0]])
     assert_equal expected, a
 
-    assert_raises(RuntimeError) do 
-     a.add_columns(%w[a b]) { } 
+    assert_raises(RuntimeError) do
+     a.add_columns(%w[a b]) { }
     end
   end
 
   def test_remove_column
-    a = Table(%w[a b c]) { |t| t << [1,2,3] << [4,5,6] }
+    a = Ruport.Table(%w[a b c]) { |t| t << [1,2,3] << [4,5,6] }
     b = a.dup
 
     a.remove_column("b")
-    assert_equal Table(%w[a c]) { |t| t << [1,3] << [4,6] }, a        
+    assert_equal Ruport.Table(%w[a c]) { |t| t << [1,3] << [4,6] }, a
 
     b.remove_column(2)
-    assert_equal Table(%w[a b]) { |t| t << [1,2] << [4,5] }, b
-  end    
+    assert_equal Ruport.Table(%w[a b]) { |t| t << [1,2] << [4,5] }, b
+  end
 
   def test_remove_columns
-    a = Table(%w[a b c d]) { |t| t << [1,2,3,4] << [5,6,7,8] }
+    a = Ruport.Table(%w[a b c d]) { |t| t << [1,2,3,4] << [5,6,7,8] }
     b = a.dup
     a.remove_columns("b","d")
-    assert_equal Table(%w[a c]) { |t| t << [1,3] << [5,7] }, a        
+    assert_equal Ruport.Table(%w[a c]) { |t| t << [1,3] << [5,7] }, a
     b.remove_columns(%w[a c])
-    assert_equal Table(%w[b d]) { |t| t << [2,4] << [6,8] }, b
-  end   
+    assert_equal Ruport.Table(%w[b d]) { |t| t << [2,4] << [6,8] }, b
+  end
 
   def test_rename_column
-    a = Table(%w[a b]) { |t| t << [1,2] << [3,4] }
+    a = Ruport.Table(%w[a b]) { |t| t << [1,2] << [3,4] }
     a.rename_column("b","x")
-    assert_equal Table(%w[a x]) { |t| t << [1,2] << [3,4] }, a
-  end     
+    assert_equal Ruport.Table(%w[a x]) { |t| t << [1,2] << [3,4] }, a
+  end
 
   def test_rename_columns
-    a = Table(%w[a b]) { |t| t << [1,2] << [3,4] }
+    a = Ruport.Table(%w[a b]) { |t| t << [1,2] << [3,4] }
     a.rename_columns(%w[a b], %w[x y])
-    assert_equal Table(%w[x y]) { |t| t << [1,2] << [3,4] }, a
+    assert_equal Ruport.Table(%w[x y]) { |t| t << [1,2] << [3,4] }, a
 
-    a = Table(%w[a b]) { |t| t << [1,2] << [3,4] }
+    a = Ruport.Table(%w[a b]) { |t| t << [1,2] << [3,4] }
     a.rename_columns("a"=>"x","b"=>"y")
-    assert_equal Table(%w[x y]) { |t| t << [1,2] << [3,4] }, a
+    assert_equal Ruport.Table(%w[x y]) { |t| t << [1,2] << [3,4] }, a
 
-    a = Table(%w[a b]) { |t| t << [1,2] << [3,4] }
-    assert_raise(ArgumentError) { a.rename_columns(%w[a b], %w[x]) }
+    a = Ruport.Table(%w[a b]) { |t| t << [1,2] << [3,4] }
+    assert_raises(ArgumentError) { a.rename_columns(%w[a b], %w[x]) }
 
-    a = Table(%w[a b c]) { |t| t << [1,2,3] << [4,5,6] }
+    a = Ruport.Table(%w[a b c]) { |t| t << [1,2,3] << [4,5,6] }
     a.rename_columns { |r| r.to_sym }
-    assert_equal(a, Table(:a,:b,:c) { |t| t << [1,2,3] << [4,5,6] })
+    assert_equal(a, Ruport.Table(:a,:b,:c) { |t| t << [1,2,3] << [4,5,6] })
 
-    a = Table(%w[a b c]) { |t| t << [1,2,3] << [4,5,6] }
+    a = Ruport.Table(%w[a b c]) { |t| t << [1,2,3] << [4,5,6] }
     a.rename_columns(%w[a c]) { |r| r.to_sym }
-    assert_equal(a, Table(:a,"b",:c) { |t| t << [1,2,3] << [4,5,6] })  
-  end     
+    assert_equal(a, Ruport.Table(:a,"b",:c) { |t| t << [1,2,3] << [4,5,6] })
+  end
 
   def test_swap_column
-    a = Table(%w[a b]) { |t| t << [1,2] << [3,4] }
+    a = Ruport.Table(%w[a b]) { |t| t << [1,2] << [3,4] }
     a.swap_column("a","b")
-    assert_equal Table(%w[b a]) { |t| t << [2,1] << [4,3] }, a    
+    assert_equal Ruport.Table(%w[b a]) { |t| t << [2,1] << [4,3] }, a
     a.swap_column(1,0)
-    assert_equal  Table(%w[a b]) { |t| t << [1,2] << [3,4] }, a
-  end      
+    assert_equal  Ruport.Table(%w[a b]) { |t| t << [1,2] << [3,4] }, a
+  end
 
   def test_replace_column
-    a = Table(%w[a b c]) { |t| t << [1,2,3] << [4,5,6] }  
+    a = Ruport.Table(%w[a b c]) { |t| t << [1,2,3] << [4,5,6] }
     a.replace_column("b","d") { |r| r.b.to_s }
-    assert_equal Table(%w[a d c]) { |t| t << [1,"2",3] << [4,"5",6] }, a
+    assert_equal Ruport.Table(%w[a d c]) { |t| t << [1,"2",3] << [4,"5",6] }, a
     a.replace_column("d") { |r| r.d.to_i }
-    assert_equal Table(%w[a d c]) { |t| t << [1,2,3] << [4,5,6] }, a
-  end        
-  
-  # --- BUG TRAPS ------------------------------------ 
-  
+    assert_equal Ruport.Table(%w[a d c]) { |t| t << [1,2,3] << [4,5,6] }, a
+  end
+
+  # --- BUG TRAPS ------------------------------------
+
   def test_ensure_setting_column_names_changes_record_attributes
-    table = Ruport::Data::Table.new :column_names => %w[a b c], 
+    table = Ruport::Data::Table.new :column_names => %w[a b c],
       :data => [[1,2,3],[4,5,6]]
-    
+
     assert_equal %w[a b c], table.column_names
     assert_equal %w[a b c], table.data[0].attributes
     assert_equal %w[a b c], table.data[1].attributes
@@ -635,22 +664,22 @@ class TestTableColumnOperations < Test::Unit::TestCase
     assert_equal %w[d e f], table.column_names
     assert_equal %w[d e f], table.data[0].attributes
     assert_equal %w[d e f], table.data[1].attributes
-  end   
-  
+  end
+
   def test_ensure_setting_column_names_later_does_not_break_replace_column
-    a = Table(%w[a b c], :data => [[1,2,3],[4,5,6]])
+    a = Ruport.Table(%w[a b c], :data => [[1,2,3],[4,5,6]])
     a.replace_column("b","q") { |r| r.a + r.c }
     a.column_names = %w[d e f]
-    assert_equal Table(%w[d e f], :data => [[1,4,3],[4,10,6]]), a
+    assert_equal Ruport.Table(%w[d e f], :data => [[1,4,3],[4,10,6]]), a
 
-    a = Table([], :data => [[1,2,3],[4,5,6]])
+    a = Ruport.Table([], :data => [[1,2,3],[4,5,6]])
 
     a.replace_column(1) { |r| r[0] + r[2] }
 
     a.column_names = %w[d e f]
-    assert_equal Table(%w[d e f], :data => [[1,4,3],[4,10,6]]), a
+    assert_equal Ruport.Table(%w[d e f], :data => [[1,4,3],[4,10,6]]), a
 
-    a = Table([], :data => [[1,2,3],[4,5,6]])
+    a = Ruport.Table([], :data => [[1,2,3],[4,5,6]])
 
     a.replace_column(2) { |r| r[0] + 5 }
 
@@ -659,35 +688,35 @@ class TestTableColumnOperations < Test::Unit::TestCase
     a.replace_column("b") { |r| r.a + 4 }
     a.replace_column("b","foo") { |r| r.b + 1 }
 
-    assert_equal Table(%w[a foo c], :data => [[1,6,6],[4,9,9]]), a
-  end 
+    assert_equal Ruport.Table(%w[a foo c], :data => [[1,6,6],[4,9,9]]), a
+  end
 
   def test_ensure_renaming_a_missing_column_fails_silently
-    a = Table(%w[a b c])
-    assert_nothing_raised do
-      a.rename_column("d", "z")
-    end
+    a = Ruport.Table(%w[a b c])
+    
+    a.rename_column("d", "z")
+    
   end
 
-end  
+end
+
+class TestTableFromCSV < Minitest::Test
 
-class TestTableFromCSV < Test::Unit::TestCase
-  
   def test_csv_load
     table = Ruport::Data::Table.load(File.join(TEST_SAMPLES,"data.csv"))
     assert_equal %w[col1 col2 col3], table.column_names
     rows = [%w[a b c],["d",nil,"e"]]
     table.each { |r| assert_equal rows.shift, r.to_a
                      assert_equal %w[col1 col2 col3], r.attributes }
-    expected = Table(%w[a b c], :data => [%w[1 2 3],%w[4 5 6]])
-    
+    expected = Ruport.Table(%w[a b c], :data => [%w[1 2 3],%w[4 5 6]])
+
     # ticket:94
-    table = Ruport::Data::Table.load( File.join(TEST_SAMPLES,"data.tsv"), 
+    table = Ruport::Data::Table.load( File.join(TEST_SAMPLES,"data.tsv"),
                                       :csv_options => { :col_sep => "\t" } )
-    assert_equal expected, table 
+    assert_equal expected, table
 
     expected = ['c','e']
-   
+
     table = Ruport::Data::Table.load( File.join(TEST_SAMPLES,"data.csv"),
       :csv_options => { :headers => true, :header_converters => :symbol }
       ) do |s,r|
@@ -697,60 +726,60 @@ class TestTableFromCSV < Test::Unit::TestCase
     assert_equal [:col1,:col2,:col3], table.column_names
 
     expected = ['c','e']
-   
-    Ruport::Data::Table.load( File.join(TEST_SAMPLES,"data.csv"), 
+
+    Ruport::Data::Table.load( File.join(TEST_SAMPLES,"data.csv"),
                               :records => true ) do |s,r|
       assert_equal expected.shift, r.col3
       assert_kind_of Ruport::Data::Record, r
     end
-     
-    table = Ruport::Data::Table.load( File.join(TEST_SAMPLES, "data.csv"), 
+
+    table = Ruport::Data::Table.load( File.join(TEST_SAMPLES, "data.csv"),
                                      :has_names => false )
     assert_equal([],table.column_names)
-    assert_equal(Table([],
+    assert_equal(Ruport.Table([],
       :data => [%w[col1 col2 col3],%w[a b c],["d",nil,"e"]]), table)
   end
 
   # ticket:76
   def test_parse
-    assert_nothing_raised { 
-      Ruport::Data::Table.parse("a,b,c\n1,2,3\n") 
-    }
     
-    table = Ruport::Data::Table.parse("a,b,c\n1,2,3\n4,5,6\n")
-    expected = Table(%w[a b c], :data => [%w[1 2 3],%w[4 5 6]])
+    Ruport::Data::Table.parse("a,b,c\n1,2,3\n")
     
-    table = Ruport::Data::Table.parse( "a\tb\tc\n1\t2\t3\n4\t5\t6\n", 
+
+    table = Ruport::Data::Table.parse("a,b,c\n1,2,3\n4,5,6\n")
+    expected = Ruport.Table(%w[a b c], :data => [%w[1 2 3],%w[4 5 6]])
+
+    table = Ruport::Data::Table.parse( "a\tb\tc\n1\t2\t3\n4\t5\t6\n",
                                       :csv_options => { :col_sep => "\t" } )
-    assert_equal expected, table 
+    assert_equal expected, table
 
-    table = Ruport::Data::Table.parse( "a,b,c\n1,2,3\n4,5,6\n", 
+    table = Ruport::Data::Table.parse( "a,b,c\n1,2,3\n4,5,6\n",
                                        :has_names => false)
     assert_equal([],table.column_names)
-    assert_equal(Table([], :data => [%w[a b c],%w[1 2 3],%w[4 5 6]]), table)
+    assert_equal(Ruport.Table([], :data => [%w[a b c],%w[1 2 3],%w[4 5 6]]), table)
   end
-  
+
   def test_csv_block_form
     expected = [%w[a b],%w[1 2],%w[3 4]]
-    t = Ruport::Data::Table.send(:get_table_from_csv, 
-                                 :parse, "a,b\n1,2\n3,4", 
+    t = Ruport::Data::Table.send(:get_table_from_csv,
+                                 :parse, "a,b\n1,2\n3,4",
                                  :has_names => false) do |s,r|
       assert_equal expected.shift, r
-      s << r    
+      s << r
     end
-    assert_equal Table([], :data => [%w[a b],%w[1 2],%w[3 4]]), t
-  end         
-  
+    assert_equal Ruport.Table([], :data => [%w[a b],%w[1 2],%w[3 4]]), t
+  end
+
   # - BUG TRAPS --------------------
-  
+
   def test_ensure_using_csv_block_mode_works
     expected = [%w[a b],%w[1 2],%w[3 4]]
     t = Ruport::Data::Table.parse("a,b\n1,2\n3,4",:has_names => false) { |s,r|
       assert_equal expected.shift, r
-      s << r    
+      s << r
       s << r
     }
-    assert_equal Table([],
+    assert_equal Ruport.Table([],
       :data => [%w[a b],%w[a b],%w[1 2], %w[1 2],%w[3 4],%w[3 4]]), t
     x = Ruport::Data::Table.load(File.join(TEST_SAMPLES,"data.csv")) { |s,r|
       assert_kind_of Ruport::Data::Feeder, s
@@ -759,37 +788,37 @@ class TestTableFromCSV < Test::Unit::TestCase
       s << r
     }
     assert_equal 4, x.length
-  end  
-  
+  end
+
   def test_ensure_csv_loading_accepts_table_options
-     a = Table(File.join(TEST_SAMPLES,"addressbook.csv"), 
+     a = Ruport.Table(File.join(TEST_SAMPLES,"addressbook.csv"),
                  :record_class => DuckRecord)
      a.each { |r| assert_kind_of(DuckRecord,r) }
-  end    
-  
+  end
+
   def test_ensure_table_from_csv_accepts_record_class_in_block_usage
-    a = Table(File.join(TEST_SAMPLES,"addressbook.csv"),
+    a = Ruport.Table(File.join(TEST_SAMPLES,"addressbook.csv"),
                 :record_class => DuckRecord, :records => true) do |s,r|
-       assert_kind_of(DuckRecord,r) 
+       assert_kind_of(DuckRecord,r)
     end
   end
-  
+
 end
 
-class TestTableKernelHack < Test::Unit::TestCase
-  
+class TestTableKernelHack < Minitest::Test
+
   def test_simple
     assert_equal Ruport::Data::Table.new(:column_names => %w[a b c]),
-      Table(%w[a b c])
+      Ruport.Table(%w[a b c])
     assert_equal Ruport::Data::Table.new(:column_names => %w[a b c]),
-      Table("a","b","c")
+      Ruport.Table("a","b","c")
     assert_equal Ruport::Data::Table.load(
                  File.join(TEST_SAMPLES,"addressbook.csv")),
-                 Table(File.join(TEST_SAMPLES,"addressbook.csv"))
+                 Ruport.Table(File.join(TEST_SAMPLES,"addressbook.csv"))
     assert_equal Ruport::Data::Table.load(
                    File.join(TEST_SAMPLES,"addressbook.csv"), :has_names => false),
-                 Table(File.join(TEST_SAMPLES,"addressbook.csv"), :has_names => false) 
-    Table("a","b","c") do |t|
+                 Ruport.Table(File.join(TEST_SAMPLES,"addressbook.csv"), :has_names => false)
+    Ruport.Table("a","b","c") do |t|
       t << [1,2,3]
       assert_equal(
         Ruport::Data::Table.new(:column_names => %w[a b c], :data => [[1,2,3]]),
@@ -797,19 +826,19 @@ class TestTableKernelHack < Test::Unit::TestCase
       )
     end
 
-    assert_equal Table("a"), Table(%w[a])
-    assert_equal Table(:a), Table([:a])
+    assert_equal Ruport.Table("a"), Ruport.Table(%w[a])
+    assert_equal Ruport.Table(:a), Ruport.Table([:a])
   end
 
   def test_iterators
-    Table(File.join(TEST_SAMPLES,"addressbook.csv")) do |s,r|
+    Ruport.Table(File.join(TEST_SAMPLES,"addressbook.csv")) do |s,r|
       assert_kind_of(Array,r)
       assert_kind_of(Ruport::Data::Feeder,s)
     end
 
     n = 0
 
-    Table(:string => "a,b,c\n1,2,3\n4,5,6\n") do |s,r|
+    Ruport.Table(:string => "a,b,c\n1,2,3\n4,5,6\n") do |s,r|
       assert_kind_of(Array,r)
       assert_kind_of(Ruport::Data::Feeder,s)
       n += 1
@@ -817,22 +846,22 @@ class TestTableKernelHack < Test::Unit::TestCase
 
     assert_equal 2, n
   end
-  
+
   def test_with_file_arg
-    assert_equal Table(File.join(TEST_SAMPLES,"addressbook.csv")),
-                 Table(:file => File.join(TEST_SAMPLES,"addressbook.csv"))
+    assert_equal Ruport.Table(File.join(TEST_SAMPLES,"addressbook.csv")),
+                 Ruport.Table(:file => File.join(TEST_SAMPLES,"addressbook.csv"))
   end
-   
+
   def test_with_string_arg
     csv_string = "id,name\n1,Inky\n2,Blinky\n3,Clyde"
-     
+
     assert_equal Ruport::Data::Table.parse(csv_string),
-                 Table(:string => csv_string)
+                 Ruport.Table(:string => csv_string)
   end
 
   def test_ensure_table_hack_accepts_normal_constructor_args
     assert_equal Ruport::Data::Table.new(:column_names => %w[a b c]),
-                 Table(:column_names => %w[a b c])
-  end    
-  
+                 Ruport.Table(:column_names => %w[a b c])
+  end
+
 end