b2b2dot0-fastercsv 1.4.1

data/test/tc_serialization.rb

@@ -0,0 +1,154 @@
+#!/usr/local/bin/ruby -w
+
+# tc_serialization.rb
+#
+#  Created by James Edward Gray II on 2006-03-28.
+#  Copyright 2006 Gray Productions. All rights reserved.
+
+require "test/unit"
+
+require "faster_csv"
+
+# An example of how to provide custom CSV serialization.
+class Hash
+  def self.csv_load( meta, headers, fields )
+    self[*headers.zip(fields).flatten.map { |e| eval(e) }]
+  end
+  
+  def csv_headers
+    keys.map { |key| key.inspect }
+  end
+  
+  def csv_dump( headers )
+    headers.map { |header| fetch(eval(header)).inspect }
+  end
+end
+
+class TestSerialization < Test::Unit::TestCase
+  
+  ### Classes Used to Test Serialization ###
+  
+  class ReadOnlyName
+    def initialize( first, last )
+      @first, @last = first, last
+    end
+
+    attr_reader :first, :last
+    
+    def ==( other )
+      %w{first last}.all? { |att| send(att) == other.send(att) }
+    end
+  end
+
+  Name = Struct.new(:first, :last)
+  
+  class FullName < Name
+    def initialize( first, last, suffix = nil )
+      super(first, last)
+      
+      @suffix = suffix
+    end
+    
+    attr_accessor :suffix
+    
+    def ==( other )
+      %w{first last suffix}.all? { |att| send(att) == other.send(att) }
+    end
+  end
+  
+  ### Tests ###
+
+  def test_class_dump
+    @names = [ %w{James Gray},
+              %w{Dana Gray},
+              %w{Greg Brown} ].map do |first, last|
+      ReadOnlyName.new(first, last)
+    end
+    
+    assert_nothing_raised(Exception) do 
+      @data = FasterCSV.dump(@names)
+    end
+    assert_equal(<<-END_CLASS_DUMP.gsub(/^\s*/, ""), @data)
+    class,TestSerialization::ReadOnlyName
+    @first,@last
+    James,Gray
+    Dana,Gray
+    Greg,Brown
+    END_CLASS_DUMP
+  end
+  
+  def test_struct_dump
+    @names = [ %w{James Gray},
+              %w{Dana Gray},
+              %w{Greg Brown} ].map do |first, last|
+      Name.new(first, last)
+    end
+    
+    assert_nothing_raised(Exception) do 
+      @data = FasterCSV.dump(@names)
+    end
+    assert_equal(<<-END_STRUCT_DUMP.gsub(/^\s*/, ""), @data)
+    class,TestSerialization::Name
+    first=,last=
+    James,Gray
+    Dana,Gray
+    Greg,Brown
+    END_STRUCT_DUMP
+  end
+  
+  def test_inherited_struct_dump
+    @names = [ %w{James Gray II},
+              %w{Dana Gray},
+              %w{Greg Brown} ].map do |first, last, suffix|
+      FullName.new(first, last, suffix)
+    end
+    
+    assert_nothing_raised(Exception) do 
+      @data = FasterCSV.dump(@names)
+    end
+    assert_equal(<<-END_STRUCT_DUMP.gsub(/^\s*/, ""), @data)
+    class,TestSerialization::FullName
+    @suffix,first=,last=
+    II,James,Gray
+    ,Dana,Gray
+    ,Greg,Brown
+    END_STRUCT_DUMP
+  end
+  
+  def test_load
+    %w{ test_class_dump
+        test_struct_dump
+        test_inherited_struct_dump }.each do |test|
+      send(test)
+      FasterCSV.load(@data).each do |loaded|
+        assert_instance_of(@names.first.class, loaded)
+        assert_equal(@names.shift, loaded)
+      end
+    end
+  end
+  
+  def test_io
+    test_class_dump
+    
+    data_file = File.join(File.dirname(__FILE__), "temp_test_data.csv")
+    FasterCSV.dump(@names, File.open(data_file, "w"))
+    
+    assert(File.exist?(data_file))
+    assert_equal(<<-END_IO_DUMP.gsub(/^\s*/, ""), File.read(data_file))
+    class,TestSerialization::ReadOnlyName
+    @first,@last
+    James,Gray
+    Dana,Gray
+    Greg,Brown
+    END_IO_DUMP
+    
+    assert_equal(@names, FasterCSV.load(File.open(data_file)))
+    
+    File.unlink(data_file)
+  end
+  
+  def test_custom_dump_and_load
+    obj = {1 => "simple", :test => Hash}
+    assert_equal(obj, FasterCSV.load(FasterCSV.dump([obj])).first)
+  end
+end

data/test/tc_speed.rb

@@ -0,0 +1,65 @@
+#!/usr/local/bin/ruby -w
+
+# tc_speed.rb
+#
+#  Created by James Edward Gray II on 2005-11-14.
+#  Copyright 2005 Gray Productions. All rights reserved.
+
+require "test/unit"
+require "timeout"
+
+require "faster_csv"
+require "csv"
+
+class TestFasterCSVSpeed < Test::Unit::TestCase
+  PATH     = File.join(File.dirname(__FILE__), "test_data.csv")
+  BIG_DATA = "123456789\n" * 1024
+  
+  def test_that_we_are_doing_the_same_work
+    FasterCSV.open(PATH) do |csv|
+      CSV.foreach(PATH) do |row|
+        assert_equal(row, csv.shift)
+      end
+    end
+  end
+  
+  def test_speed_vs_csv
+    csv_time = Time.now
+    CSV.foreach(PATH) do |row|
+      # do nothing, we're just timing a read...
+    end
+    csv_time = Time.now - csv_time
+
+    faster_csv_time = Time.now
+    FasterCSV.foreach(PATH) do |row|
+      # do nothing, we're just timing a read...
+    end
+    faster_csv_time = Time.now - faster_csv_time
+    
+    assert(faster_csv_time < csv_time / 3)
+  end
+  
+  def test_the_parse_fails_fast_when_it_can_for_unquoted_fields
+    assert_parse_errors_out('valid,fields,bad start"' + BIG_DATA)
+  end
+  
+  def test_the_parse_fails_fast_when_it_can_for_unescaped_quotes
+    assert_parse_errors_out('valid,fields,"bad start"unescaped' + BIG_DATA)
+  end
+  
+  def test_field_size_limit_controls_lookahead
+    assert_parse_errors_out( 'valid,fields,"' + BIG_DATA + '"',
+                             :field_size_limit => 2048 )
+  end
+  
+  private
+  
+  def assert_parse_errors_out(*args)
+    assert_raise(FasterCSV::MalformedCSVError) do
+      Timeout.timeout(0.2) do
+        FasterCSV.parse(*args)
+        fail("Parse didn't error out")
+      end
+    end
+  end
+end

data/test/tc_table.rb

@@ -0,0 +1,400 @@
+#!/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
+  
+  def test_array_delegation
+    assert(!@table.empty?, "Table was empty.")
+    
+    assert_equal(@rows.size, @table.size)
+  end
+  
+  def test_inspect_shows_current_mode
+    str = @table.inspect
+    assert(str.include?("mode:#{@table.mode}"), "Mode not shown.")
+    
+    @table.by_col!
+    str = @table.inspect
+    assert(str.include?("mode:#{@table.mode}"), "Mode not shown.")
+  end
+end