fastercsv 0.2.1 → 1.0.0

data/test/tc_features.rb

@@ -28,6 +28,16 @@ class TestFasterCSVFeatures < Test::Unit::TestCase
                  [%Q{"\r\n,"},           ["\r\n,"]],
                  [%Q{"\r\n,",},          ["\r\n,", nil]] ]
   
+  def setup
+    @sample_data = <<-END_DATA.gsub(/^ +/, "")
+    line,1,abc
+    line,2,"def\nghi"
+    
+    line,4,jkl
+    END_DATA
+    @csv = FasterCSV.new(@sample_data)
+  end
+  
   def test_col_sep
     [";", "\t"].each do |sep|
       TEST_CASES.each do |test_case|
@@ -64,22 +74,22 @@ class TestFasterCSVFeatures < Test::Unit::TestCase
   end
   
   def test_lineno
-    sample_data = <<-END_DATA.gsub(/^ +/, "")
-    line,1,abc
-    line,2,"def\nghi"
+    assert_equal(5, @sample_data.to_a.size)
     
-    line,4,jkl
-    END_DATA
-    assert_equal(5, sample_data.to_a.size)
-    
-    csv = FasterCSV.new(sample_data)
     4.times do |line_count|
-      assert_equal(line_count, csv.lineno)
-      assert_not_nil(csv.shift)
-      assert_equal(line_count + 1, csv.lineno)
+      assert_equal(line_count, @csv.lineno)
+      assert_not_nil(@csv.shift)
+      assert_equal(line_count + 1, @csv.lineno)
     end
-    assert_nil(csv.shift)
-    csv.close
+    assert_nil(@csv.shift)
+  end
+  
+  def test_readline
+    test_lineno
+    
+    @csv.rewind
+    
+    test_lineno
   end
   
   def test_unknown_options
@@ -93,6 +103,24 @@ class TestFasterCSVFeatures < Test::Unit::TestCase
     assert_nothing_raised(Exception) do 
       FasterCSV.new(String.new, :col_sep => "|")
     end
+    
+    # failing to reset header behavior on rewind() (reported by Chris Roos)
+    csv = FasterCSV.new( "forename,surname", :headers        => true,
+                                             :return_headers => true )
+    csv.each { |row| assert row.header_row? }
+    csv.rewind
+    csv.each { |row| assert row.header_row? }
+    
+    # 
+    # leading empty fields with multibyte col_sep raises MalformedCSVError
+    # (reported by Dave Burt)
+    # 
+    data = <<-END_DATA.gsub(/^\s+/, "")
+    <=><=>A<=>B<=>C
+    1<=>2<=>3
+    END_DATA
+    parsed = FasterCSV.parse(data, :col_sep => "<=>")
+    assert_equal([[nil, nil, "A", "B", "C"], ["1", "2", "3"]], parsed)
   end
   
   def test_version

data/test/tc_headers.rb

@@ -27,19 +27,19 @@ class TestFasterCSVHeaders < Test::Unit::TestCase
       end
 
       # first data row - skipping headers
-      row = csv.shift
+      row = csv[0]
       assert_not_nil(row)
       assert_instance_of(FasterCSV::Row, row)
       assert_equal([%w{first A}, %w{second B}, %w{third C}], row.to_a)
 
       # second data row
-      row = csv.shift
+      row = csv[1]
       assert_not_nil(row)
       assert_instance_of(FasterCSV::Row, row)
       assert_equal([%w{first 1}, %w{second 2}, %w{third 3}], row.to_a)
 
       # empty
-      assert_nil(csv.shift)
+      assert_nil(csv[2])
     end
   end
   
@@ -51,26 +51,26 @@ class TestFasterCSVHeaders < Test::Unit::TestCase
     end
 
     # first data row - skipping headers
-    row = csv.shift
+    row = csv[0]
     assert_not_nil(row)
     assert_instance_of(FasterCSV::Row, row)
     assert_equal( [[:my, "first"], [:new, "second"], [:headers, "third"]],
                   row.to_a )
 
     # second data row
-    row = csv.shift
+    row = csv[1]
     assert_not_nil(row)
     assert_instance_of(FasterCSV::Row, row)
     assert_equal([[:my, "A"], [:new, "B"], [:headers, "C"]], row.to_a)
 
     # third data row
-    row = csv.shift
+    row = csv[2]
     assert_not_nil(row)
     assert_instance_of(FasterCSV::Row, row)
     assert_equal([[:my, "1"], [:new, "2"], [:headers, "3"]], row.to_a)
 
     # empty
-    assert_nil(csv.shift)
+    assert_nil(csv[3])
     
     # with return and convert
     assert_nothing_raised(Exception) do
@@ -78,7 +78,7 @@ class TestFasterCSVHeaders < Test::Unit::TestCase
                                    :return_headers    => true,
                                    :header_converters => lambda { |h| h.to_s } )
     end
-    row = csv.shift
+    row = csv[0]
     assert_not_nil(row)
     assert_instance_of(FasterCSV::Row, row)
     assert_equal( [["my", :my], ["new", :new], ["headers", :headers]],
@@ -95,25 +95,25 @@ class TestFasterCSVHeaders < Test::Unit::TestCase
     end
 
     # first data row - skipping headers
-    row = csv.shift
+    row = csv[0]
     assert_not_nil(row)
     assert_instance_of(FasterCSV::Row, row)
     assert_equal([%w{my first}, %w{new second}, %w{headers third}], row.to_a)
 
     # second data row
-    row = csv.shift
+    row = csv[1]
     assert_not_nil(row)
     assert_instance_of(FasterCSV::Row, row)
     assert_equal([%w{my A}, %w{new B}, %w{headers C}], row.to_a)
 
     # third data row
-    row = csv.shift
+    row = csv[2]
     assert_not_nil(row)
     assert_instance_of(FasterCSV::Row, row)
     assert_equal([%w{my 1}, %w{new 2}, %w{headers 3}], row.to_a)
 
     # empty
-    assert_nil(csv.shift)
+    assert_nil(csv[3])
     
     # with return and convert
     assert_nothing_raised(Exception) do
@@ -121,7 +121,7 @@ class TestFasterCSVHeaders < Test::Unit::TestCase
                                    :return_headers    => true,
                                    :header_converters => :symbol )
     end
-    row = csv.shift
+    row = csv[0]
     assert_not_nil(row)
     assert_instance_of(FasterCSV::Row, row)
     assert_equal( [[:my, "my"], [:new, "new"], [:headers, "headers"]],
@@ -138,7 +138,7 @@ class TestFasterCSVHeaders < Test::Unit::TestCase
     end
 
     # header row
-    row = csv.shift
+    row = csv[0]
     assert_not_nil(row)
     assert_instance_of(FasterCSV::Row, row)
     assert_equal( [%w{first first}, %w{second second}, %w{third third}],
@@ -147,7 +147,7 @@ class TestFasterCSVHeaders < Test::Unit::TestCase
     assert(!row.field_row?)
 
     # first data row - skipping headers
-    row = csv.shift
+    row = csv[1]
     assert_not_nil(row)
     assert_instance_of(FasterCSV::Row, row)
     assert_equal([%w{first A}, %w{second B}, %w{third C}], row.to_a)
@@ -155,7 +155,7 @@ class TestFasterCSVHeaders < Test::Unit::TestCase
     assert(row.field_row?)
 
     # second data row
-    row = csv.shift
+    row = csv[2]
     assert_not_nil(row)
     assert_instance_of(FasterCSV::Row, row)
     assert_equal([%w{first 1}, %w{second 2}, %w{third 3}], row.to_a)
@@ -163,7 +163,7 @@ class TestFasterCSVHeaders < Test::Unit::TestCase
     assert(row.field_row?)
 
     # empty
-    assert_nil(csv.shift)
+    assert_nil(csv[3])
   end
   
   def test_converters
@@ -177,9 +177,9 @@ class TestFasterCSVHeaders < Test::Unit::TestCase
     csv = FasterCSV.parse( data, :headers        => true,
                                  :return_headers => true,
                                  :converters     => :numeric )
-    assert_equal([%w{1 1}, %w{2 2}, %w{3 3}], csv.shift.to_a)
-    assert_equal([["1", 1], ["2", 2], ["3", 3]], csv.shift.to_a)
-    assert_nil(csv.shift)
+    assert_equal([%w{1 1}, %w{2 2}, %w{3 3}], csv[0].to_a)
+    assert_equal([["1", 1], ["2", 2], ["3", 3]], csv[1].to_a)
+    assert_nil(csv[2])
     
     # header converters do affect headers (only)
     assert_nothing_raised(Exception) do 
@@ -188,23 +188,23 @@ class TestFasterCSVHeaders < Test::Unit::TestCase
                                    :converters        => :numeric,
                                    :header_converters => :symbol )
     end
-    assert_equal([[:"1", "1"], [:"2", "2"], [:"3", "3"]], csv.shift.to_a)
-    assert_equal([[:"1", 1], [:"2", 2], [:"3", 3]], csv.shift.to_a)
-    assert_nil(csv.shift)
+    assert_equal([[:"1", "1"], [:"2", "2"], [:"3", "3"]], csv[0].to_a)
+    assert_equal([[:"1", 1], [:"2", 2], [:"3", 3]], csv[1].to_a)
+    assert_nil(csv[2])
   end
   
   def test_builtin_downcase_converter
     csv = FasterCSV.parse( "One,TWO Three", :headers           => true,
                                             :return_headers    => true,
                                             :header_converters => :downcase )
-    assert_equal(%w{one two\ three}, csv.shift.headers)
+    assert_equal(%w{one two\ three}, csv.headers)
   end
   
   def test_builtin_symbol_converter
     csv = FasterCSV.parse( "One,TWO Three", :headers           => true,
                                             :return_headers    => true,
                                             :header_converters => :symbol )
-    assert_equal([:one, :two_three], csv.shift.headers)
+    assert_equal([:one, :two_three], csv.headers)
   end
   
   def test_custom_converter
@@ -213,6 +213,15 @@ class TestFasterCSVHeaders < Test::Unit::TestCase
                                  :headers           => true,
                                  :return_headers    => true,
                                  :header_converters => converter )
-    assert_equal(%w{One TWO_Three}, csv.shift.headers)
+    assert_equal(%w{One TWO_Three}, csv.headers)
+  end
+  
+  def test_table_support
+    csv = nil
+    assert_nothing_raised(Exception) do 
+      csv = FasterCSV.parse(@data, :headers => true)
+    end
+    
+    assert_instance_of(FasterCSV::Table, csv)
   end
 end

data/test/tc_row.rb

@@ -195,6 +195,9 @@ class TestFasterCSVRow < Test::Unit::TestCase
     
     # with minimum indices
     assert_equal([2, 3, 4], @row.fields("B", "C", ["A", 3]))
+    
+    # by header range
+    assert_equal([2, 3], @row.values_at("B".."C"))
   end
   
   def test_index

data/test/tc_table.rb

@@ -0,0 +1,385 @@
+#!/usr/local/bin/ruby -w
+
+# tc_table.rb
+#
+#  Created by James Edward Gray II on 2006-02-24.
+#  Copyright 2006 Gray Productions. All rights reserved.
+
+require "test/unit"
+
+require "faster_csv"
+
+class TestFasterCSVTable < Test::Unit::TestCase
+  def setup
+    @rows  = [ FasterCSV::Row.new(%w{A B C}, [1, 2, 3]),
+               FasterCSV::Row.new(%w{A B C}, [4, 5, 6]),
+               FasterCSV::Row.new(%w{A B C}, [7, 8, 9]) ]
+    @table = FasterCSV::Table.new(@rows)
+
+    @header_table = FasterCSV::Table.new(
+      [FasterCSV::Row.new(%w{A B C}, %w{A B C}, true)] + @rows
+    )
+  end
+
+  def test_initialze
+    assert_not_nil(@table)
+    assert_instance_of(FasterCSV::Table, @table)
+  end
+  
+  def test_modes
+    assert_equal(:col_or_row, @table.mode)
+    
+    # non-destructive changes, intended for one shot calls
+    cols = @table.by_col
+    assert_equal(:col_or_row, @table.mode)
+    assert_equal(:col, cols.mode)
+    assert_equal(@table, cols)
+    
+    rows = @table.by_row
+    assert_equal(:col_or_row, @table.mode)
+    assert_equal(:row, rows.mode)
+    assert_equal(@table, rows)
+    
+    # destructive mode changing calls
+    assert_equal(@table, @table.by_row!)
+    assert_equal(:row, @table.mode)
+    assert_equal(@table, @table.by_col_or_row!)
+    assert_equal(:col_or_row, @table.mode)
+  end
+  
+  def test_headers
+    assert_equal(@rows.first.headers, @table.headers)
+  end
+  
+  def test_index
+    ##################
+    ### Mixed Mode ###
+    ##################
+    # by row
+    @rows.each_index { |i| assert_equal(@rows[i], @table[i]) }
+    assert_equal(nil, @table[100])  # empty row
+    
+    # by col
+    @rows.first.headers.each do |header|
+      assert_equal(@rows.map { |row| row[header] }, @table[header])
+    end
+    assert_equal([nil] * @rows.size, @table["Z"])  # empty col
+    
+    # by cell, row then col
+    assert_equal(2, @table[0][1])
+    assert_equal(6, @table[1]["C"])
+    
+    # by cell, col then row
+    assert_equal(5, @table["B"][1])
+    assert_equal(9, @table["C"][2])
+    
+    # with headers (by col)
+    assert_equal(["B", 2, 5, 8], @header_table["B"])
+    
+    ###################
+    ### Column Mode ###
+    ###################
+    @table.by_col!
+    
+    assert_equal([2, 5, 8], @table[1])
+    assert_equal([2, 5, 8], @table["B"])
+    
+    ################
+    ### Row Mode ###
+    ################
+    @table.by_row!
+    
+    assert_equal(@rows[1], @table[1])
+    assert_raise(TypeError) { @table["B"] }
+    
+    ############################
+    ### One Shot Mode Change ###
+    ############################
+    assert_equal(@rows[1], @table[1])
+    assert_equal([2, 5, 8], @table.by_col[1])
+    assert_equal(@rows[1], @table[1])
+  end
+  
+  def test_set_row_or_column
+    ##################
+    ### Mixed Mode ###
+    ##################
+    # set row
+    @table[2] = [10, 11, 12]
+    assert_equal([%w[A B C], [1, 2, 3], [4, 5, 6], [10, 11, 12]], @table.to_a)
+
+    @table[3] = FasterCSV::Row.new(%w[A B C], [13, 14, 15])
+    assert_equal( [%w[A B C], [1, 2, 3], [4, 5, 6], [10, 11, 12], [13, 14, 15]],
+                  @table.to_a )
+    
+    # set col
+    @table["Type"] = "data"
+    assert_equal( [ %w[A B C Type],
+                    [1, 2, 3, "data"],
+                    [4, 5, 6, "data"],
+                    [10, 11, 12, "data"],
+                    [13, 14, 15, "data"] ],
+                  @table.to_a )
+
+    @table["Index"] = [1, 2, 3]
+    assert_equal( [ %w[A B C Type Index],
+                    [1, 2, 3, "data", 1],
+                    [4, 5, 6, "data", 2],
+                    [10, 11, 12, "data", 3],
+                    [13, 14, 15, "data", nil] ],
+                  @table.to_a )
+
+    @table["B"] = [100, 200]
+    assert_equal( [ %w[A B C Type Index],
+                    [1, 100, 3, "data", 1],
+                    [4, 200, 6, "data", 2],
+                    [10, nil, 12, "data", 3],
+                    [13, nil, 15, "data", nil] ],
+                  @table.to_a )
+
+    # verify resulting table
+    assert_equal(<<-END_RESULT.gsub(/^\s+/, ""), @table.to_csv)
+    A,B,C,Type,Index
+    1,100,3,data,1
+    4,200,6,data,2
+    10,,12,data,3
+    13,,15,data,
+    END_RESULT
+    
+    # with headers
+    @header_table["Type"] = "data"
+    assert_equal(%w[Type data data data], @header_table["Type"])
+
+    ###################
+    ### Column Mode ###
+    ###################
+    @table.by_col!
+    
+    @table[1] = [2, 5, 11, 14]
+    assert_equal( [ %w[A B C Type Index],
+                    [1, 2, 3, "data", 1],
+                    [4, 5, 6, "data", 2],
+                    [10, 11, 12, "data", 3],
+                    [13, 14, 15, "data", nil] ],
+                  @table.to_a )
+    
+    @table["Extra"] = "new stuff"
+    assert_equal( [ %w[A B C Type Index Extra],
+                    [1, 2, 3, "data", 1, "new stuff"],
+                    [4, 5, 6, "data", 2, "new stuff"],
+                    [10, 11, 12, "data", 3, "new stuff"],
+                    [13, 14, 15, "data", nil, "new stuff"] ],
+                  @table.to_a )
+
+    ################
+    ### Row Mode ###
+    ################
+    @table.by_row!
+    
+    @table[1] = (1..6).to_a
+    assert_equal( [ %w[A B C Type Index Extra],
+                    [1, 2, 3, "data", 1, "new stuff"],
+                    [1, 2, 3, 4, 5, 6],
+                    [10, 11, 12, "data", 3, "new stuff"],
+                    [13, 14, 15, "data", nil, "new stuff"] ],
+                  @table.to_a )
+    
+    assert_raise(TypeError) { @table["Extra"] = nil }
+  end
+  
+  def test_each
+    ######################
+    ### Mixed/Row Mode ###
+    ######################
+    i = 0
+    @table.each do |row|
+      assert_equal(@rows[i], row)
+      i += 1
+    end
+
+    # verify that we can chain the call
+    assert_equal(@table, @table.each { })
+    
+    ###################
+    ### Column Mode ###
+    ###################
+    @table.by_col!
+    
+    headers = @table.headers
+    @table.each do |header, column|
+      assert_equal(headers.shift, header)
+      assert_equal(@table[header], column)
+    end
+    
+    ############################
+    ### One Shot Mode Change ###
+    ############################
+    @table.by_col_or_row!
+    
+    @table.each { |row| assert_instance_of(FasterCSV::Row, row) }
+    @table.by_col.each { |tuple| assert_instance_of(Array, tuple) }
+    @table.each { |row| assert_instance_of(FasterCSV::Row, row) }
+  end
+  
+  def test_enumerable
+    assert_equal( @rows.values_at(0, 2),
+                  @table.select { |row| (row["B"] % 2).zero? } )
+    
+    assert_equal(@rows[1], @table.find { |row| row["C"] > 5 })
+  end
+  
+  def test_to_a
+    assert_equal([%w[A B C], [1, 2, 3], [4, 5, 6], [7, 8, 9]], @table.to_a)
+    
+    # with headers
+    assert_equal( [%w[A B C], [1, 2, 3], [4, 5, 6], [7, 8, 9]],
+                  @header_table.to_a )
+  end
+  
+  def test_to_csv
+    csv = <<-END_CSV.gsub(/^\s+/, "")
+    A,B,C
+    1,2,3
+    4,5,6
+    7,8,9
+    END_CSV
+    
+    # normal conversion
+    assert_equal(csv, @table.to_csv)
+    assert_equal(csv, @table.to_s)  # alias
+    
+    # with options
+    assert_equal( csv.gsub(",", "|").gsub("\n", "\r\n"),
+                  @table.to_csv(:col_sep => "|", :row_sep => "\r\n") )
+
+    # with headers
+    assert_equal(csv, @header_table.to_csv)
+  end
+  
+  def test_append
+    # verify that we can chain the call
+    assert_equal(@table, @table << [10, 11, 12])
+    
+    # Array append
+    assert_equal(FasterCSV::Row.new(%w[A B C], [10, 11, 12]), @table[-1])
+    
+    # Row append
+    assert_equal(@table, @table << FasterCSV::Row.new(%w[A B C], [13, 14, 15]))
+    assert_equal(FasterCSV::Row.new(%w[A B C], [13, 14, 15]), @table[-1])
+  end
+  
+  def test_delete
+    ##################
+    ### Mixed Mode ###
+    ##################
+    # delete a row
+    assert_equal(@rows[1], @table.delete(1))
+    
+    # delete a col
+    assert_equal(@rows.map { |row| row["A"] }, @table.delete("A"))
+    
+    # verify resulting table
+    assert_equal(<<-END_RESULT.gsub(/^\s+/, ""), @table.to_csv)
+    B,C
+    2,3
+    8,9
+    END_RESULT
+    
+    ###################
+    ### Column Mode ###
+    ###################
+    setup
+    @table.by_col!
+
+    assert_equal(@rows.map { |row| row[0] }, @table.delete(0))
+    assert_equal(@rows.map { |row| row["C"] }, @table.delete("C"))
+    
+    # verify resulting table
+    assert_equal(<<-END_RESULT.gsub(/^\s+/, ""), @table.to_csv)
+    B
+    2
+    5
+    8
+    END_RESULT
+    
+    ################
+    ### Row Mode ###
+    ################
+    setup
+    @table.by_row!
+
+    assert_equal(@rows[1], @table.delete(1))
+    assert_raise(TypeError) { @table.delete("C") }
+    
+    # verify resulting table
+    assert_equal(<<-END_RESULT.gsub(/^\s+/, ""), @table.to_csv)
+    A,B,C
+    1,2,3
+    7,8,9
+    END_RESULT
+  end
+  
+  def test_delete_if
+    ######################
+    ### Mixed/Row Mode ###
+    ######################
+    # verify that we can chain the call
+    assert_equal(@table, @table.delete_if { |row| (row["B"] % 2).zero? })
+
+    # verify resulting table
+    assert_equal(<<-END_RESULT.gsub(/^\s+/, ""), @table.to_csv)
+    A,B,C
+    4,5,6
+    END_RESULT
+    
+    ###################
+    ### Column Mode ###
+    ###################
+    setup
+    @table.by_col!
+    
+    assert_equal(@table, @table.delete_if { |h, v| h > "A" })
+    assert_equal(<<-END_RESULT.gsub(/^\s+/, ""), @table.to_csv)
+    A
+    1
+    4
+    7
+    END_RESULT
+  end
+  
+  def test_values_at
+    ##################
+    ### Mixed Mode ###
+    ##################
+    # rows
+    assert_equal(@rows.values_at(0, 2), @table.values_at(0, 2))
+    assert_equal(@rows.values_at(1..2), @table.values_at(1..2))
+    
+    # cols
+    assert_equal([[1, 3], [4, 6], [7, 9]], @table.values_at("A", "C"))
+    assert_equal([[2, 3], [5, 6], [8, 9]], @table.values_at("B".."C"))
+    
+    ###################
+    ### Column Mode ###
+    ###################
+    @table.by_col!
+    
+    assert_equal([[1, 3], [4, 6], [7, 9]], @table.values_at(0, 2))
+    assert_equal([[1, 3], [4, 6], [7, 9]], @table.values_at("A", "C"))
+    
+    ################
+    ### Row Mode ###
+    ################
+    @table.by_row!
+    
+    assert_equal(@rows.values_at(0, 2), @table.values_at(0, 2))
+    assert_raise(TypeError) { @table.values_at("A", "C") }
+    
+    ############################
+    ### One Shot Mode Change ###
+    ############################
+    assert_equal(@rows.values_at(0, 2), @table.values_at(0, 2))
+    assert_equal([[1, 3], [4, 6], [7, 9]], @table.by_col.values_at(0, 2))
+    assert_equal(@rows.values_at(0, 2), @table.values_at(0, 2))
+  end
+end