rw_fastercsv 1.5.6

data/test/tc_encodings.rb

@@ -0,0 +1,23 @@
+#!/usr/local/bin/ruby -w
+
+# tc_encodings.rb
+#
+#  Created by Michael Reinsch.
+#  Copyright (c) 2008 Ubiquitous Business Technology, Inc.
+
+require "test/unit"
+
+require "faster_csv"
+
+class TestEncodings < Test::Unit::TestCase
+  def test_with_shift_jis_encoding
+    $KCODE = 'u'  # make sure $KCODE != Shift_JIS
+    # this test data will not work with UTF-8 encoding
+    shift_jis_data = [ "82D082E782AA82C82094E0",
+                       "82D082E7826082AA825C",
+                       "82D082E7826082AA82C8" ].map { |f| [f].pack("H*") }
+    fields = FCSV.parse_line( shift_jis_data.map { |f| %Q{"#{f}"} }.join(","),
+                              :encoding => "s" )
+    assert_equal(shift_jis_data, fields)
+  end
+end

data/test/tc_features.rb

@@ -0,0 +1,212 @@
+#!/usr/local/bin/ruby -w
+
+# tc_features.rb
+#
+#  Created by James Edward Gray II on 2005-11-14.
+#  Copyright 2005 Gray Productions. All rights reserved.
+
+require "test/unit"
+require "zlib"
+
+require "faster_csv"
+
+class TestFasterCSVFeatures < Test::Unit::TestCase
+  TEST_CASES = [ [%Q{a,b},               ["a", "b"]],
+                 [%Q{a,"""b"""},         ["a", "\"b\""]],
+                 [%Q{a,"""b"},           ["a", "\"b"]],
+                 [%Q{a,"b"""},           ["a", "b\""]],
+                 [%Q{a,"\nb"""},         ["a", "\nb\""]],
+                 [%Q{a,"""\nb"},         ["a", "\"\nb"]],
+                 [%Q{a,"""\nb\n"""},     ["a", "\"\nb\n\""]],
+                 [%Q{a,"""\nb\n""",\nc}, ["a", "\"\nb\n\"", nil]],
+                 [%Q{a,,,},              ["a", nil, nil, nil]],
+                 [%Q{,},                 [nil, nil]],
+                 [%Q{"",""},             ["", ""]],
+                 [%Q{""""},              ["\""]],
+                 [%Q{"""",""},           ["\"",""]],
+                 [%Q{,""},               [nil,""]],
+                 [%Q{,"\r"},             [nil,"\r"]],
+                 [%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|
+        assert_equal( test_case.last.map { |t| t.tr(",", sep) unless t.nil? },
+                      FasterCSV.parse_line( test_case.first.tr(",", sep),
+                                            :col_sep => sep ) )
+      end
+    end
+    assert_equal( [",,,", nil],
+                  FasterCSV.parse_line(",,,;", :col_sep => ";") )
+  end
+  
+  def test_row_sep
+    assert_raise(FasterCSV::MalformedCSVError) do
+        FasterCSV.parse_line("1,2,3\n,4,5\r\n", :row_sep => "\r\n")
+    end
+    assert_equal( ["1", "2", "3\n", "4", "5"],
+                  FasterCSV.parse_line( %Q{1,2,"3\n",4,5\r\n},
+                                        :row_sep => "\r\n") )
+  end
+  
+  def test_quote_char
+    TEST_CASES.each do |test_case|
+      assert_equal( test_case.last.map { |t| t.tr('"', "'") unless t.nil? },
+                    FasterCSV.parse_line( test_case.first.tr('"', "'"),
+                                          :quote_char => "'" ) )
+    end
+  end
+  
+  def test_row_sep_auto_discovery
+    ["\r\n", "\n", "\r"].each do |line_end|
+      data       = "1,2,3#{line_end}4,5#{line_end}"
+      discovered = FasterCSV.new(data).instance_eval { @row_sep }
+      assert_equal(line_end, discovered)
+    end
+    
+    assert_equal("\n", FasterCSV.new("\n\r\n\r").instance_eval { @row_sep })
+    
+    assert_equal($/, FasterCSV.new("").instance_eval { @row_sep })
+    
+    assert_equal($/, FasterCSV.new(STDERR).instance_eval { @row_sep })
+  end
+  
+  def test_lineno
+    assert_equal(5, @sample_data.to_a.size)
+    
+    4.times do |line_count|
+      assert_equal(line_count, @csv.lineno)
+      assert_not_nil(@csv.shift)
+      assert_equal(line_count + 1, @csv.lineno)
+    end
+    assert_nil(@csv.shift)
+  end
+  
+  def test_readline
+    test_lineno
+    
+    @csv.rewind
+    
+    test_lineno
+  end
+  
+  def test_unknown_options
+    assert_raise(ArgumentError) do 
+      FasterCSV.new(String.new, :unknown => :error)
+    end
+  end
+  
+  def test_skip_blanks
+    assert_equal(4, @csv.to_a.size)
+
+    @csv  = FasterCSV.new(@sample_data, :skip_blanks => true)
+    
+    count = 0
+    @csv.each do |row|
+      count += 1
+      assert_equal("line", row.first)
+    end
+    assert_equal(3, count)
+  end
+  
+  # reported by Kev Jackson
+  def test_failing_to_escape_col_sep_bug_fix
+    assert_nothing_raised(Exception) do 
+      FasterCSV.new(String.new, :col_sep => "|")
+    end
+  end
+  
+  # reported by Chris Roos
+  def test_failing_to_reset_headers_in_rewind_bug_fix
+    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? }
+  end
+  
+  # reported by Dave Burt
+  def test_leading_empty_fields_with_multibyte_col_sep_bug_fix
+    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_gzip_reader_bug_fix
+    zipped = nil
+    assert_nothing_raised(NoMethodError) do
+      zipped = FasterCSV.new(
+                 Zlib::GzipReader.open(
+                   File.join(File.dirname(__FILE__), "line_endings.gz")
+                 )
+               )
+    end
+    assert_equal("\r\n", zipped.instance_eval { @row_sep })
+  end
+  
+  def test_gzip_writer_bug_fix
+    file   = File.join(File.dirname(__FILE__), "temp.gz")
+    zipped = nil
+    assert_nothing_raised(NoMethodError) do
+      zipped = FasterCSV.new(Zlib::GzipWriter.open(file))
+    end
+    zipped << %w[one two three]
+    zipped << [1, 2, 3]
+    zipped.close
+    
+    assert( Zlib::GzipReader.open(file) { |f| f.read }.
+                             include?($INPUT_RECORD_SEPARATOR),
+            "@row_sep did not default" )
+    File.unlink(file)
+  end
+  
+  def test_inspect_is_smart_about_io_types
+    str = FasterCSV.new("string,data").inspect
+    assert(str.include?("io_type:StringIO"), "IO type not detected.")
+
+    str = FasterCSV.new($stderr).inspect
+    assert(str.include?("io_type:$stderr"), "IO type not detected.")
+
+    str = FasterCSV.open( File.join( File.dirname(__FILE__),
+                                     "test_data.csv" ) ) { |csv| csv.inspect }
+    assert(str.include?("io_type:File"), "IO type not detected.")
+  end
+  
+  def test_inspect_shows_key_attributes
+    str = @csv.inspect
+    %w[lineno col_sep row_sep quote_char].each do |attr_name|
+      assert_match(/\b#{attr_name}:[^\s>]+/, str)
+    end
+  end
+  
+  def test_inspect_shows_headers_when_available
+    FasterCSV.open( File.join( File.dirname(__FILE__),
+                                     "test_data.csv" ),
+                    :headers => true ) do |csv|
+      assert(csv.inspect.include?("headers:true"), "Header hint not shown.")
+      csv.shift # load headers
+      assert_match(/headers:\[[^\]]+\]/, csv.inspect)
+    end
+  end
+  
+  def test_version
+    assert_not_nil(FasterCSV::VERSION)
+    assert_instance_of(String, FasterCSV::VERSION)
+    assert(FasterCSV::VERSION.frozen?)
+    assert_match(/\A\d\.\d\.\d\Z/, FasterCSV::VERSION)
+  end
+end

data/test/tc_headers.rb

@@ -0,0 +1,277 @@
+#!/usr/local/bin/ruby -w
+
+# tc_headers.rb
+#
+#  Created by James Edward Gray II on 2006-02-25.
+#  Copyright 2006 Gray Productions. All rights reserved.
+
+require "test/unit"
+
+require "faster_csv"
+
+class TestFasterCSVHeaders < Test::Unit::TestCase
+  def setup
+    @data = <<-END_CSV.gsub(/^\s+/, "")
+    first,second,third
+    A,B,C
+    1,2,3
+    END_CSV
+  end
+  
+  def test_first_row
+    [:first_row, true].each do |setting|  # two names for the same setting
+      # activate headers
+      csv = nil
+      assert_nothing_raised(Exception) do 
+        csv = FasterCSV.parse(@data, :headers => setting)
+      end
+
+      # first data row - skipping headers
+      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[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[2])
+    end
+  end
+  
+  def test_array_of_headers
+    # activate headers
+    csv = nil
+    assert_nothing_raised(Exception) do 
+      csv = FasterCSV.parse(@data, :headers => [:my, :new, :headers])
+    end
+
+    # first data row - skipping headers
+    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[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[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[3])
+    
+    # with return and convert
+    assert_nothing_raised(Exception) do
+      csv = FasterCSV.parse(@data, :headers           => [:my, :new, :headers],
+                                   :return_headers    => true,
+                                   :header_converters => lambda { |h| h.to_s } )
+    end
+    row = csv[0]
+    assert_not_nil(row)
+    assert_instance_of(FasterCSV::Row, row)
+    assert_equal( [["my", :my], ["new", :new], ["headers", :headers]],
+                  row.to_a )
+    assert(row.header_row?)
+    assert(!row.field_row?)
+  end
+  
+  def test_csv_header_string
+    # activate headers
+    csv = nil
+    assert_nothing_raised(Exception) do 
+      csv = FasterCSV.parse(@data, :headers => "my,new,headers")
+    end
+
+    # first data row - skipping headers
+    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[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[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[3])
+    
+    # with return and convert
+    assert_nothing_raised(Exception) do
+      csv = FasterCSV.parse(@data, :headers           => "my,new,headers",
+                                   :return_headers    => true,
+                                   :header_converters => :symbol )
+    end
+    row = csv[0]
+    assert_not_nil(row)
+    assert_instance_of(FasterCSV::Row, row)
+    assert_equal( [[:my, "my"], [:new, "new"], [:headers, "headers"]],
+                  row.to_a )
+    assert(row.header_row?)
+    assert(!row.field_row?)
+  end
+  
+  def test_csv_header_string_inherits_separators
+    # parse with custom col_sep
+    csv = nil
+    assert_nothing_raised(Exception) do 
+      csv = FasterCSV.parse( @data.tr(",", "|"), :col_sep => "|",
+                                                 :headers => "my|new|headers" )
+    end
+
+    # verify headers were recognized
+    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)
+  end
+  
+  def test_return_headers
+    # activate headers and request they are returned
+    csv = nil
+    assert_nothing_raised(Exception) do
+      csv = FasterCSV.parse(@data, :headers => true, :return_headers => true)
+    end
+
+    # header row
+    row = csv[0]
+    assert_not_nil(row)
+    assert_instance_of(FasterCSV::Row, row)
+    assert_equal( [%w{first first}, %w{second second}, %w{third third}],
+                  row.to_a )
+    assert(row.header_row?)
+    assert(!row.field_row?)
+
+    # first data row - skipping headers
+    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)
+    assert(!row.header_row?)
+    assert(row.field_row?)
+
+    # second data row
+    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)
+    assert(!row.header_row?)
+    assert(row.field_row?)
+
+    # empty
+    assert_nil(csv[3])
+  end
+  
+  def test_converters
+    # create test data where headers and fields look alike
+    data = <<-END_MATCHING_CSV.gsub(/^\s+/, "")
+    1,2,3
+    1,2,3
+    END_MATCHING_CSV
+    
+    # normal converters do not affect headers
+    csv = FasterCSV.parse( data, :headers        => true,
+                                 :return_headers => true,
+                                 :converters     => :numeric )
+    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 
+      csv = FasterCSV.parse( data, :headers           => true,
+                                   :return_headers    => true,
+                                   :converters        => :numeric,
+                                   :header_converters => :symbol )
+    end
+    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.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.headers)
+  end
+  
+  def test_custom_converter
+    converter = lambda { |header| header.tr(" ", "_") }
+    csv       = FasterCSV.parse( "One,TWO Three",
+                                 :headers           => true,
+                                 :return_headers    => true,
+                                 :header_converters => converter )
+    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
+  
+  def test_skip_blanks
+    @data = <<-END_CSV.gsub(/^ +/, "")
+    
+
+    A,B,C
+    
+    1,2,3
+    
+    
+    
+    END_CSV
+    
+    expected = [%w[1 2 3]]
+    FasterCSV.parse(@data, :headers => true, :skip_blanks => true) do |row|
+      assert_equal(expected.shift, row.fields)
+    end
+    
+    expected = [%w[A B C], %w[1 2 3]]
+    FasterCSV.parse( @data,
+                     :headers        => true,
+                     :return_headers => true, 
+                     :skip_blanks    => true ) do |row|
+      assert_equal(expected.shift, row.fields)
+    end
+  end
+  
+  def test_blank_row_bug_fix
+    @data += "\n#{@data}"  # add a blank row
+    
+    # ensure that everything returned is a Row object
+    FasterCSV.parse(@data, :headers => true) do |row|
+      assert_instance_of(FasterCSV::Row, row)
+    end
+  end
+end