ruport 0.11.0 → 0.12.0

data/test/sql_split_test.rb

@@ -2,17 +2,18 @@ require "test/unit"
 require "ruport"
 class TestSqlSplit < Test::Unit::TestCase
 	include Ruport
+ 	
+	def test_sql_split_trivial
+		sql = "SELECT * FROM ruport_test"
+		split = Query::SqlSplit.new sql
+		assert_equal( 1, split.size )
+		assert_equal( sql, split.first )
+	end  
 	
-	def test_sql_split1
+	def test_sql_split_complex
 		sql = File.read 'test/samples/ruport_test.sql'
 		split = Query::SqlSplit.new sql
 		assert_equal( 'SELECT * FROM ruport_test', split.last )
 	end
 	
-	def test_sql_split2
-		sql = "SELECT * FROM ruport_test"
-		split = Query::SqlSplit.new sql
-		assert_equal( 1, split.size )
-		assert_equal( sql, split.first )
-	end
 end

data/test/table_test.rb

@@ -9,7 +9,10 @@ class Person < Ruport::Data::Record
     first_name + " " + last_name
   end
 
-end
+end      
+
+
+class DuckRecord < Ruport::Data::Record; end
 
 class TestTable < Test::Unit::TestCase
   def test_constructors
@@ -31,22 +34,10 @@ class TestTable < Test::Unit::TestCase
     
     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 { |t,n| 
-      assert_equal n, t.data }
+    tables.zip([[],[],[a],[b]]).each do |t,n| 
+      assert_equal n, t.data 
+    end
   end    
-  
-  def test_column
-    a = [[1,2,3],[4,5,6]].to_table(%w[a b c])
-    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 = [[1],[2],[3],[4]].to_table
-    assert_equal [1,2,3,4], a.column(0)
-    
-  end
 
   def test_to_group
     a =[[1,2,3],[4,5,6]].to_table(%w[a b c]).to_group("Packrats")
@@ -55,24 +46,7 @@ class TestTable < Test::Unit::TestCase
                                  :name => "Packrats" )
     assert_equal a,b
   end
-  
-  def test_set_column_names
-    a = [[1,2,3],[4,5,6]].to_table
-    
-    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) }    
-    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  
-
+ 
   def test_rows_with
     table = [[1,2,3],[1,3,4],[7,8,9]].to_table(%w[a b c])
     
@@ -82,24 +56,7 @@ class TestTable < Test::Unit::TestCase
     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_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 }
-  end
   
-  def test_append_hash
-    table = [[1,2,3],[4,5,6]].to_table(%w[a b c])
-    table << { "a" => 7, "c" => 9, "b" => 8 }
-    
-    assert_equal [[1,2,3],[4,5,6],[7,8,9]].to_table(%w[a b c]), table
-  end
-
   def test_sigma
     table = [[1,2],[3,4],[5,6]].to_table(%w[col1 col2])
     assert table.respond_to?(:sigma)
@@ -108,19 +65,6 @@ class TestTable < Test::Unit::TestCase
     assert_equal(9,table.sigma("col1"))
     assert_equal(21,table.sigma { |r| r.col1 + r.col2 })
   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], 
-      :data => [[1,2,3],[4,5,6],[7,8,9],[10,11,12]]), combo
-  end
   
   def test_sub_table
     table = [ [1,2,3,4],[5,6,7,9],
@@ -144,7 +88,6 @@ class TestTable < Test::Unit::TestCase
   end
 
   def test_reduce
-
     table = [ [1,2,3,4],[5,6,7,9],
               [10,11,12,13],[14,15,16,17] ].to_table(%w[a b c d])
 
@@ -155,80 +98,7 @@ class TestTable < Test::Unit::TestCase
               [10,11,12,13],[14,15,16,17] ].to_table(%w[a b c d])
     table.reduce(%w[c d a]) { |r| r.a < 10 }
 
-    assert_equal [[3,4,1],[7,9,5]].to_table(%w[c d a]),  
-                 table
-
-  end
-
-  def test_csv_load
-    table = Ruport::Data::Table.load("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 = [%w[1 2 3],%w[4 5 6]].to_table(%w[a b c])
-    
-    # ticket:94
-    table = Ruport::Data::Table.load( "test/samples/data.tsv", 
-                                      :csv_options => { :col_sep => "\t" } )
-    assert_equal expected, table 
-
-
-   expected = ['c','e']
-   
-   table = Ruport::Data::Table.load( "test/samples/data.csv", :csv_options => 
-    { :headers => true, :header_converters => :symbol } ) do |s,r|
-    assert_equal expected.shift, r[:col3]
-   end
-
-   assert_equal [:col1,:col2,:col3], table.column_names
-
-   
-   expected = ['c','e']
-   
-   Ruport::Data::Table.load( "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("test/samples/data.csv", :has_names => false)
-    assert_equal([],table.column_names)
-    assert_equal([%w[col1 col2 col3],%w[a b c],["d",nil,"e"]].to_table, 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 = [%w[1 2 3],%w[4 5 6]].to_table(%w[a b c])
-    
-    table = Ruport::Data::Table.parse( "a\tb\tc\n1\t2\t3\n4\t5\t6\n", 
-                                      :csv_options => { :col_sep => "\t" } )
-    assert_equal expected, table 
-
-    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([%w[a b c],%w[1 2 3], %w[4 5 6]].to_table, 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", 
-                                 :has_names => false) do |s,r|
-      assert_equal expected.shift, r
-      s << r    
-    end
-    assert_equal [%w[a b],%w[1 2],%w[3 4]].to_table, t
+    assert_equal [[3,4,1],[7,9,5]].to_table(%w[c d a]), table
   end
 
   def test_reorder
@@ -253,222 +123,57 @@ class TestTable < Test::Unit::TestCase
                    r.instance_eval{@attributes}.object_id
     }
   end
-
-  def test_add_column
-    
-    a = [[1,2],[3,4],[5,6]].to_table(%w[a b])
-    a.add_column("c")
-    assert_equal [[1,2,nil],[3,4,nil],[5,6,nil]].to_table(%w[a b c]), a
-    
-    a = [[1,2],[3,4],[5,6]].to_table(%w[a b])
-    a.add_column("c",:default => "x")
-    assert_equal [[1,2,'x'],[3,4,'x'],[5,6,'x']].to_table(%w[a b c]), a    
-    
-    b = a.dup
-    b.add_column("x",:before => "b")
-    assert_equal [[1,nil,2,'x'],
-                  [3,nil,4,'x'],
-                  [5,nil,6,'x']].to_table(%w[a x b c]), b 
-                  
-    b = a.dup
-    b.add_column("x",:after => "b")
-    assert_equal [[1,2,nil,'x'],
-                  [3,4,nil,'x'],
-                  [5,6,nil,'x']].to_table(%w[a b x c]), b  
-    
-    
-    a.add_column("d") { |r| r[0]+r[1] }
-    assert_equal( 
-    [ [1,2,'x',3],
-      [3,4,'x',7],
-      [5,6,'x',11] ].to_table(%w[a b c d]), a)
-    
-    a.add_column("x",:position => 1)
-    assert_equal(
-    [ [1,nil,2,'x',3],
-      [3,nil,4,'x',7],
-      [5,nil,6,'x',11] ].to_table(%w[a x b c d]), a)          
-    
-  end        
   
-  def test_add_columns 
-    a = [[1,2],[3,4],[5,6]].to_table(%w[a b])
-    a.add_columns(%w[c d])
-    expected = [ [1,2,nil,nil],
-                 [3,4,nil,nil],
-                 [5,6,nil,nil] ].to_table(%w[a b c d])
-    
-    assert_equal expected, a                  
+  def test_sort_rows_by
+    table = Ruport::Data::Table.new :column_names => %w[a b c]
+    table << [1,2,3] << [6,1,8] << [9,1,4]    
     
-    a = [[1,2],[3,4],[5,6]].to_table(%w[a b])
+    table2 = Ruport::Data::Table.new :column_names => [:a, :b, :c]
+    table2 << [1,2,3] << [6,1,8] << [9,1,4]
+
+    sorted_table_a = Ruport::Data::Table.new :column_names => %w[a b c]
+    sorted_table_a << [1,2,3] << [6,1,8] << [9,1,4]
+
+    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]
     
-    a.add_columns(%w[c d],:after => "a")
+    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] 
     
-    expected = [ [1,nil,nil,2],
-                 [3,nil,nil,4],
-                 [5,nil,nil,6], ].to_table(%w[a c d b])                        
+    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 expected, a                                   
-    
-    a.add_columns(%w[x f],:before => "a")
-    
-    expected = [ [nil,nil,1,nil,nil,2],
-                 [nil,nil,3,nil,nil,4],
-                 [nil,nil,5,nil,nil,6] ].to_table(%w[x f a c d b])
-                                         
-    assert_equal expected, a       
-    
-    a = [[1,2,0],[3,4,0],[5,6,0]].to_table(%w[a b c])  
-    
-    a.add_columns(%w[x y],:default => 9, :position => 1)
-    
-    expected = [[1,9,9,2,0],[3,9,9,4,0],[5,9,9,6,0]].to_table(%w[a x y b c])  
-    
-    assert_equal expected, a
-    
-    a = [[1,2],[3,4],[5,6]].to_table(%w[a b])
-    a.add_columns(%w[f x],:default => 0)
+    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              
+  
+  def test_sort_rows_by!
+    table = Ruport::Data::Table.new :column_names => %w[a b c]
+    table << [1,2,3] << [6,1,8] << [9,1,4]
+
+    sorted_table_a = Ruport::Data::Table.new :column_names => %w[a b c]
+    sorted_table_a << [1,2,3] << [6,1,8] << [9,1,4]
+
+    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]
     
-    expected = [[1,2,0,0],[3,4,0,0],[5,6,0,0]].to_table(%w[a b f x])
-    assert_equal expected, a
+    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]
     
-    assert_raises(RuntimeError) do 
-      a.add_columns(%w[a b]) { } 
-    end
+    table_a = table.dup
+    table_a.sort_rows_by! { |r| r['a'] }       
     
-     
+    table_b = table.dup
+    table_b.sort_rows_by!("b")
     
-  end
+    table_bc = table.dup
+    table_bc.sort_rows_by!(['b', 'c'])             
   
-  def test_remove_column
-    a = 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        
-    
-    b.remove_column(2)
-    assert_equal 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] }
-    b = a.dup
-    a.remove_columns("b","d")
-    assert_equal 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   
-  
-  def test_rename_column
-    a = 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     
-
-  
-  def test_rename_columns
-    a = 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
-
-    a = 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
-
-    a = Table(%w[a b]) { |t| t << [1,2] << [3,4] }
-    assert_raise(ArgumentError) { a.rename_columns(%w[a b], %w[x]) }
-
-    a = 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] })
-
-    a = 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     
-  
-  def test_swap_column
-   a = 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    
-   a.swap_column(1,0)
-   assert_equal  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.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
-   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
-  
-  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] 
-    assert_equal 3, table.length
-    assert_equal 5, table[1].b
-  end
-
-  def test_to_hack
-    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::Renderer::UnknownFormatError) { table.to_nothing }
-  end
-  
-  
-  def test_sort_rows_by
-    table = Ruport::Data::Table.new :column_names => %w[a b c]
-    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]
-
-    sorted_table_a = Ruport::Data::Table.new :column_names => %w[a b c]
-    sorted_table_a << [1,2,3] << [6,1,8] << [9,1,4]
-
-    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_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              
-  
-  def test_sort_rows_by!
-    table = Ruport::Data::Table.new :column_names => %w[a b c]
-    table << [1,2,3] << [6,1,8] << [9,1,4]
-
-    sorted_table_a = Ruport::Data::Table.new :column_names => %w[a b c]
-    sorted_table_a << [1,2,3] << [6,1,8] << [9,1,4]
-
-    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_b = table.dup
-    table_b.sort_rows_by!("b")
-    
-    table_bc = table.dup
-    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
+    assert_equal sorted_table_a,  table_a
+    assert_equal sorted_table_b,  table_b
+    assert_equal sorted_table_bc, table_bc
   end
 
   def test_array_hack
@@ -506,49 +211,9 @@ class TestTable < Test::Unit::TestCase
                  b.map { |r| r.name }
 
   end 
-  
-  def test_to_hack_takes_args
-    a = 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.show_table_headers = false }    
-                 
-    assert_equal "would\tyou\tlike\none\tred\tcat\n",
-                 a.to_csv(:show_table_headers => false) { |r|
-                   r.format_options = { :col_sep => "\t" }
-                 }
-      
-  end
-
-  def test_as_throws_proper_errors
-    a = [[1,2,3],[4,5,6]].to_table(%w[a b c])
-    assert_nothing_raised { a.as(:csv) }
-    assert_nothing_raised { a.to_csv }
-    assert_raises(Ruport::Renderer::UnknownFormatError) { a.as(:nothing) }
-    assert_raises(Ruport::Renderer::UnknownFormatError) { a.to_nothing }
-  end
-
 
   ## BUG Traps -------------------------------------------------
   
-  def test_ensure_setting_column_names_changes_record_attributes
-    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
-
-    table.column_names = %w[d e f]
-
-    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    
-  
   def test_ensure_table_creation_allows_record_coercion
     table = [[1,2,3],[4,5,6],[7,8,9]].to_table
     table_with_names = [[1,2,3],[4,5,6],[7,8,9]].to_table(%w[a b c])
@@ -577,24 +242,6 @@ class TestTable < Test::Unit::TestCase
     }
   end   
   
-  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
-    }
-    assert_equal [%w[a b],%w[a b],%w[1 2], %w[1 2],
-                  %w[3 4],%w[3 4]].to_table, t
-    x = Ruport::Data::Table.load("test/samples/data.csv") { |s,r|
-      assert_kind_of Ruport::Data::Table, s
-      assert_kind_of Array, r
-      s << r
-      s << r
-    }
-    assert_equal 4, x.length
-  end
-  
   def test_ensure_coerce_sum
     s = [["1"],["3"],["5"] ].to_table
     t = [["1.23"],["1.5"]].to_table
@@ -625,6 +272,300 @@ class TestTable < Test::Unit::TestCase
      assert_equal [[1,2,3],[4,5,6],[7,8,9]].to_table,a
   end
 
+  def test_ensure_propagate_record_class
+    a = Table(:record_class => DuckRecord)
+    assert_equal DuckRecord, a.record_class
+
+    b = a.dup
+    assert_equal DuckRecord, b.record_class
+  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    
+
+  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    
+
+class TestTableAppendOperations < Test::Unit::TestCase
+  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 }
+  end
+  
+  def test_append_hash
+    table = [[1,2,3],[4,5,6]].to_table(%w[a b c])
+    table << { "a" => 7, "c" => 9, "b" => 8 }
+    
+    assert_equal [[1,2,3],[4,5,6],[7,8,9]].to_table(%w[a b c]), 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], 
+      :data => [[1,2,3],[4,5,6],[7,8,9],[10,11,12]]), combo
+  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] 
+    assert_equal 3, table.length
+    assert_equal 5, table[1].b
+  end  
+end
+
+class TestTableFormattingHooks < Test::Unit::TestCase
+  
+  def test_to_hack_takes_args
+    a = 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.show_table_headers = false }    
+                 
+    assert_equal "would\tyou\tlike\none\tred\tcat\n",
+                 a.to_csv(:show_table_headers => false) { |r|
+                   r.format_options = { :col_sep => "\t" }
+                 }
+      
+  end     
+  
+  def test_to_hack
+    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::Renderer::UnknownFormatError) { table.to_nothing }
+  end
+
+  def test_as_throws_proper_errors
+    a = [[1,2,3],[4,5,6]].to_table(%w[a b c])
+    assert_nothing_raised { a.as(:csv) }
+    assert_nothing_raised { a.to_csv }
+    assert_raises(Ruport::Renderer::UnknownFormatError) { a.as(:nothing) }
+    assert_raises(Ruport::Renderer::UnknownFormatError) { a.to_nothing }
+  end
+    
+end
+
+class TestTableColumnOperations < Test::Unit::TestCase
+  
+  def test_column
+    a = [[1,2,3],[4,5,6]].to_table(%w[a b c])
+    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 = [[1],[2],[3],[4]].to_table
+    assert_equal [1,2,3,4], a.column(0)  
+  end
+    
+  def test_set_column_names
+    a = [[1,2,3],[4,5,6]].to_table
+    
+    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) }    
+    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   
+  
+  def test_add_column
+
+     a = [[1,2],[3,4],[5,6]].to_table(%w[a b])
+     a.add_column("c")
+     assert_equal [[1,2,nil],[3,4,nil],[5,6,nil]].to_table(%w[a b c]), a
+
+     a = [[1,2],[3,4],[5,6]].to_table(%w[a b])
+     a.add_column("c",:default => "x")
+     assert_equal [[1,2,'x'],[3,4,'x'],[5,6,'x']].to_table(%w[a b c]), a    
+
+     b = a.dup
+     b.add_column("x",:before => "b")
+     assert_equal [[1,nil,2,'x'],
+                   [3,nil,4,'x'],
+                   [5,nil,6,'x']].to_table(%w[a x b c]), b 
+
+     b = a.dup
+     b.add_column("x",:after => "b")
+     assert_equal [[1,2,nil,'x'],
+                   [3,4,nil,'x'],
+                   [5,6,nil,'x']].to_table(%w[a b x c]), b  
+
+
+     a.add_column("d") { |r| r[0]+r[1] }
+     assert_equal( 
+     [ [1,2,'x',3],
+       [3,4,'x',7],
+       [5,6,'x',11] ].to_table(%w[a b c d]), a)
+
+     a.add_column("x",:position => 1)
+     assert_equal(
+     [ [1,nil,2,'x',3],
+       [3,nil,4,'x',7],
+       [5,nil,6,'x',11] ].to_table(%w[a x b c d]), a)          
+
+  end        
+
+  def test_add_columns 
+    a = [[1,2],[3,4],[5,6]].to_table(%w[a b])
+    a.add_columns(%w[c d])
+    expected = [ [1,2,nil,nil],
+                 [3,4,nil,nil],
+                 [5,6,nil,nil] ].to_table(%w[a b c d])
+
+    assert_equal expected, a                  
+
+    a = [[1,2],[3,4],[5,6]].to_table(%w[a b])
+
+    a.add_columns(%w[c d],:after => "a")
+
+    expected = [ [1,nil,nil,2],
+                 [3,nil,nil,4],
+                 [5,nil,nil,6], ].to_table(%w[a c d b])                        
+
+    assert_equal expected, a                                   
+
+    a.add_columns(%w[x f],:before => "a")
+
+    expected = [ [nil,nil,1,nil,nil,2],
+                 [nil,nil,3,nil,nil,4],
+                 [nil,nil,5,nil,nil,6] ].to_table(%w[x f a c d b])
+
+    assert_equal expected, a       
+
+    a = [[1,2,0],[3,4,0],[5,6,0]].to_table(%w[a b c])  
+
+    a.add_columns(%w[x y],:default => 9, :position => 1)
+
+    expected = [[1,9,9,2,0],[3,9,9,4,0],[5,9,9,6,0]].to_table(%w[a x y b c])  
+
+    assert_equal expected, a
+
+    a = [[1,2],[3,4],[5,6]].to_table(%w[a b])
+    a.add_columns(%w[f x],:default => 0)
+
+    expected = [[1,2,0,0],[3,4,0,0],[5,6,0,0]].to_table(%w[a b f x])
+    assert_equal expected, a
+
+    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] }
+    b = a.dup
+
+    a.remove_column("b")
+    assert_equal 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    
+
+  def test_remove_columns
+    a = 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        
+    b.remove_columns(%w[a c])
+    assert_equal 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.rename_column("b","x")
+    assert_equal 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.rename_columns(%w[a b], %w[x y])
+    assert_equal Table(%w[x y]) { |t| t << [1,2] << [3,4] }, a
+
+    a = 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
+
+    a = Table(%w[a b]) { |t| t << [1,2] << [3,4] }
+    assert_raise(ArgumentError) { a.rename_columns(%w[a b], %w[x]) }
+
+    a = 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] })
+
+    a = 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     
+
+  def test_swap_column
+    a = 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    
+    a.swap_column(1,0)
+    assert_equal  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.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
+    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 ------------------------------------ 
+  
+  def test_ensure_setting_column_names_changes_record_attributes
+    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
+
+    table.column_names = %w[d e f]
+
+    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   
+  
   def test_ensure_setting_column_names_later_does_not_break_replace_column
     a = [[1,2,3],[4,5,6]].to_table(%w[a b c])
     a.replace_column("b","q") { |r| r.a + r.c }
@@ -648,22 +589,103 @@ class TestTable < Test::Unit::TestCase
     a.replace_column("b","foo") { |r| r.b + 1 }
 
     assert_equal [[1,6,6],[4,9,9]].to_table(%w[a foo c]), a
-  end
+  end 
 
-  def test_ensure_propagate_record_class
-    a = Table(:record_class => DuckRecord)
-    assert_equal DuckRecord, a.record_class
+end  
 
-    b = a.dup
-    assert_equal DuckRecord, b.record_class
+class TestTableFromCSV < Test::Unit::TestCase
+  
+  def test_csv_load
+    table = Ruport::Data::Table.load("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 = [%w[1 2 3],%w[4 5 6]].to_table(%w[a b c])
+    
+    # ticket:94
+    table = Ruport::Data::Table.load( "test/samples/data.tsv", 
+                                      :csv_options => { :col_sep => "\t" } )
+    assert_equal expected, table 
+
+
+   expected = ['c','e']
+   
+   table = Ruport::Data::Table.load( "test/samples/data.csv", :csv_options => 
+    { :headers => true, :header_converters => :symbol } ) do |s,r|
+    assert_equal expected.shift, r[:col3]
+   end
+
+   assert_equal [:col1,:col2,:col3], table.column_names
+
+   
+   expected = ['c','e']
+   
+   Ruport::Data::Table.load( "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( "test/samples/data.csv", 
+                                     :has_names => false )
+   assert_equal([],table.column_names)
+   assert_equal([%w[col1 col2 col3],%w[a b c],["d",nil,"e"]].to_table, table)
+    
   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    
+  # 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 = [%w[1 2 3],%w[4 5 6]].to_table(%w[a b c])
+    
+    table = Ruport::Data::Table.parse( "a\tb\tc\n1\t2\t3\n4\t5\t6\n", 
+                                      :csv_options => { :col_sep => "\t" } )
+    assert_equal expected, table 
+
+    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([%w[a b c],%w[1 2 3], %w[4 5 6]].to_table, 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", 
+                                 :has_names => false) do |s,r|
+      assert_equal expected.shift, r
+      s << r    
+    end
+    assert_equal [%w[a b],%w[1 2],%w[3 4]].to_table, 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
+    }
+    assert_equal [%w[a b],%w[a b],%w[1 2], %w[1 2],
+                  %w[3 4],%w[3 4]].to_table, t
+    x = Ruport::Data::Table.load("test/samples/data.csv") { |s,r|
+      assert_kind_of Ruport::Data::Table, s
+      assert_kind_of Array, r
+      s << r
+      s << r
+    }
+    assert_equal 4, x.length
+  end  
   
   def test_ensure_csv_loading_accepts_table_options
      a = Table("test/samples/addressbook.csv",:record_class => DuckRecord)
@@ -676,19 +698,9 @@ class TestTable < Test::Unit::TestCase
        assert_kind_of(DuckRecord,r) 
     end
   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
 
-class DuckRecord < Ruport::Data::Record; end
-
 class TestTableKernelHack < Test::Unit::TestCase
   
   def test_simple