fastercsv 0.1.9 → 0.2.0

data/lib/fastercsv.rb

@@ -0,0 +1,10 @@
+#!/usr/local/bin/ruby -w
+
+# fastercsv.rb
+#
+#  Created by James Edward Gray II on 2006-04-01.
+#  Copyright 2006 Gray Productions. All rights reserved.
+# 
+# This file is just another name for faster_csv.rb.
+
+require "faster_csv"

data/test/tc_csv_parsing.rb

@@ -113,9 +113,52 @@ class TestCSVParsing < Test::Unit::TestCase
     assert_raise(FasterCSV::MalformedCSVError) do
       FasterCSV.parse_line("1,2\r,3", :row_sep => "\n")
     end
+    
+    bad_data = <<-END_DATA.gsub(/^ +/, "")
+    line,1,abc
+    line,2,"def\nghi"
+    
+    line,4,some\rjunk
+    line,5,jkl
+    END_DATA
+    lines = bad_data.to_a
+    assert_equal(6, lines.size)
+    assert_match(/\Aline,4/, lines.find { |l| l =~ /some\rjunk/ })
+    
+    csv = FasterCSV.new(bad_data)
+    begin
+      loop do
+        assert_not_nil(csv.shift)
+        assert_send([csv.lineno, :<, 4])
+      end
+    rescue FasterCSV::MalformedCSVError
+      assert_equal( "Unquoted fields do not allow \\r or \\n (line 4).",
+                    $!.message )
+    end
 
     assert_raise(FasterCSV::MalformedCSVError) do 
       FasterCSV.parse_line('1,2,"3...')
     end
+    
+    bad_data = <<-END_DATA.gsub(/^ +/, "")
+    line,1,abc
+    line,2,"def\nghi"
+    
+    line,4,8'10"
+    line,5,jkl
+    END_DATA
+    lines = bad_data.to_a
+    assert_equal(6, lines.size)
+    assert_match(/\Aline,4/, lines.find { |l| l =~ /8'10"/ })
+    
+    csv = FasterCSV.new(bad_data)
+    begin
+      loop do
+        assert_not_nil(csv.shift)
+        assert_send([csv.lineno, :<, 4])
+      end
+    rescue FasterCSV::MalformedCSVError
+      assert_equal("Unclosed quoted field on line 4.", $!.message)
+    end
   end
 end

data/test/tc_data_converters.rb

@@ -15,6 +15,8 @@ class TestDataConverters < Test::Unit::TestCase
     @parser = FasterCSV.new(@data)
     
     @custom = lambda { |field| field =~ /\A:(\S.*?)\s*\Z/ ? $1.to_sym : field }
+    
+    @win_safe_time_str = Time.now.strftime("%a %b %d %H:%M:%S %Y")
   end
   
   def test_builtin_integer_converter
@@ -43,7 +45,7 @@ class TestDataConverters < Test::Unit::TestCase
 
   def test_builtin_date_converter
     # does convert
-    assert_instance_of(Date, FasterCSV::Converters[:date][Time.now.to_s])
+    assert_instance_of(Date, FasterCSV::Converters[:date][@win_safe_time_str])
 
     # does not convert
     assert_instance_of(String, FasterCSV::Converters[:date]["junk"])
@@ -52,7 +54,7 @@ class TestDataConverters < Test::Unit::TestCase
   def test_builtin_date_time_converter
     # does convert
     assert_instance_of( DateTime,
-                        FasterCSV::Converters[:date_time][Time.now.to_s] )
+                        FasterCSV::Converters[:date_time][@win_safe_time_str] )
 
     # does not convert
     assert_instance_of(String, FasterCSV::Converters[:date_time]["junk"])
@@ -110,8 +112,8 @@ class TestDataConverters < Test::Unit::TestCase
 
   def test_builtin_all_nested_combo_converter
     # setup parser...
-    @data   << ",#{Time.now}"        # add a DateTime field
-    @parser =  FasterCSV.new(@data)  # reset parser
+    @data   << ",#{@win_safe_time_str}"        # add a DateTime field
+    @parser =  FasterCSV.new(@data)            # reset parser
     assert_nothing_raised(Exception) { @parser.convert(:all) }
     
     # and use
@@ -151,6 +153,20 @@ class TestDataConverters < Test::Unit::TestCase
     assert_equal(["Numbers", ":integer", "1", ":float", 3], @parser.shift)
   end
   
+  def test_convert_with_custom_code_using_field_info_header
+    @parser = FasterCSV.new(@data, :headers => %w{one two three four five})
+    
+    # define custom converter that uses field header information...
+    assert_nothing_raised(Exception) do
+      @parser.convert do |field, info|
+        info.header == "three" ? Integer(field) * 100 : field
+      end
+    end
+    
+    # and use
+    assert_equal(["Numbers", ":integer", 100, ":float", "3.015"], @parser.shift.fields)
+  end
+  
   def test_shortcut_interface
     assert_equal( ["Numbers", ":integer", 1, ":float", 3.015],
                   FasterCSV.parse_line(@data, :converters => :numeric) )
@@ -163,4 +179,79 @@ class TestDataConverters < Test::Unit::TestCase
                   FasterCSV.parse_line( @data, :converters => [ :numeric,
                                                                 @custom ] ) )
   end
+  
+  def test_unconverted_fields
+    [ [ @data,
+        ["Numbers", :integer, 1, :float, 3.015],
+        %w{Numbers :integer 1 :float 3.015} ],
+      ["\n", Array.new, Array.new] ].each do |test, fields, unconverted|
+      row = nil
+      assert_nothing_raised(Exception) do 
+        row = FasterCSV.parse_line( test,
+                                    :converters         => [:numeric, @custom],
+                                    :unconverted_fields => true )
+      end
+      assert_not_nil(row)
+      assert_equal(fields, row)
+      assert_respond_to(row, :unconverted_fields)
+      assert_equal(unconverted, row.unconverted_fields)
+    end
+
+    data = <<-END_CSV.gsub(/^\s+/, "")
+    first,second,third
+    1,2,3
+    END_CSV
+    row = nil
+    assert_nothing_raised(Exception) do 
+      row = FasterCSV.parse_line( data,
+                                  :converters         => :numeric,
+                                  :unconverted_fields => true,
+                                  :headers            => :first_row )
+    end
+    assert_not_nil(row)
+    assert_equal([["first", 1], ["second", 2], ["third", 3]], row.to_a)
+    assert_respond_to(row, :unconverted_fields)
+    assert_equal(%w{1 2 3}, row.unconverted_fields)
+
+    assert_nothing_raised(Exception) do 
+      row = FasterCSV.parse_line( data,
+                                  :converters         => :numeric,
+                                  :unconverted_fields => true,
+                                  :headers            => :first_row,
+                                  :return_headers     => true )
+    end
+    assert_not_nil(row)
+    assert_equal( [%w{first first}, %w{second second}, %w{third third}],
+                  row.to_a )
+    assert_respond_to(row, :unconverted_fields)
+    assert_equal(%w{first second third}, row.unconverted_fields)
+
+    assert_nothing_raised(Exception) do 
+      row = FasterCSV.parse_line( data,
+                                  :converters         => :numeric,
+                                  :unconverted_fields => true,
+                                  :headers            => :first_row,
+                                  :return_headers     => true,
+                                  :header_converters  => :symbol )
+    end
+    assert_not_nil(row)
+    assert_equal( [[:first, "first"], [:second, "second"], [:third, "third"]],
+                  row.to_a )
+    assert_respond_to(row, :unconverted_fields)
+    assert_equal(%w{first second third}, row.unconverted_fields)
+
+    assert_nothing_raised(Exception) do 
+      row = FasterCSV.parse_line( data,
+                                  :converters         => :numeric,
+                                  :unconverted_fields => true,
+                                  :headers            => %w{my new headers},
+                                  :return_headers     => true,
+                                  :header_converters  => :symbol )
+    end
+    assert_not_nil(row)
+    assert_equal( [[:my, "my"], [:new, "new"], [:headers, "headers"]],
+                  row.to_a )
+    assert_respond_to(row, :unconverted_fields)
+    assert_equal(Array.new, row.unconverted_fields)
+  end
 end

data/test/tc_features.rb

@@ -63,6 +63,25 @@ class TestFasterCSVFeatures < Test::Unit::TestCase
     assert_equal($/, FasterCSV.new(STDERR).instance_eval { @row_sep })
   end
   
+  def test_lineno
+    sample_data = <<-END_DATA.gsub(/^ +/, "")
+    line,1,abc
+    line,2,"def\nghi"
+    
+    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)
+    end
+    assert_nil(csv.shift)
+    csv.close
+  end
+  
   def test_unknown_options
     assert_raise(ArgumentError) do 
       FasterCSV.new(String.new, :unknown => :error)
@@ -75,4 +94,11 @@ class TestFasterCSVFeatures < Test::Unit::TestCase
       FasterCSV.new(String.new, :col_sep => "|")
     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

@@ -43,6 +43,93 @@ class TestFasterCSVHeaders < Test::Unit::TestCase
     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.shift
+    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
+    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
+    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)
+    
+    # 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.shift
+    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.shift
+    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
+    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
+    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)
+    
+    # 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.shift
+    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_return_headers
     # activate headers and request they are returned
     csv = nil

data/test/tc_interface.rb

@@ -163,4 +163,86 @@ class TestFasterCSVInterface < Test::Unit::TestCase
     end
     assert_equal("2,4,6,\"Added\r\"\n8,10,\"Added\r\"\n", result)
   end
+  
+  def test_instance
+    csv = String.new
+    
+    first = nil
+    assert_nothing_raised(Exception) do 
+      first =  FasterCSV.instance(csv, :col_sep => ";")
+      first << %w{a b c}
+    end
+    
+    assert_equal("a;b;c\n", csv)
+    
+    second = nil
+    assert_nothing_raised(Exception) do 
+      second =  FasterCSV.instance(csv, :col_sep => ";")
+      second << [1, 2, 3]
+    end
+    
+    assert_equal(first.object_id, second.object_id)
+    assert_equal("a;b;c\n1;2;3\n", csv)
+    
+    # shortcuts
+    assert_equal(STDOUT, FasterCSV.instance.instance_eval { @io })
+    assert_equal(STDOUT, FasterCSV { |csv| csv.instance_eval { @io } })
+    assert_equal(STDOUT, FCSV.instance.instance_eval { @io })
+    assert_equal(STDOUT, FCSV { |csv| csv.instance_eval { @io } })
+  end
+  
+  ### Test Alternate Interface ###
+  
+  def test_csv_interface
+    require "csv"
+    data      = ["Number", 42, "Tricky Field", 'This has embedded "quotes"!']
+    data_file = File.join(File.dirname(__FILE__), "temp_csv_data.csv")
+    CSV.open(data_file, "w") { |f| 10.times { f << data } }
+    csv   = CSV.generate_line(data)
+    tests = { :foreach       => Array.new,
+              :generate_line => csv,
+              :open          => Array.new,
+              :parse         => CSV.parse(csv),
+              :parse_w_block => Array.new,
+              :parse_line    => CSV.parse_line(csv),
+              :readlines     => CSV.readlines(data_file) }
+    CSV.foreach(data_file) { |row| tests[:foreach] << row }
+    CSV.open(data_file, "r") { |row| tests[:open] << row }
+    CSV.parse(([csv] * 3).join("\n")) { |row| tests[:parse_w_block] << row }
+    Object.send(:remove_const, :CSV)
+    
+    assert_nothing_raised(Exception) do 
+      FasterCSV.build_csv_interface
+    end
+    
+    %w{ foreach
+        generate_line
+        open
+        parse
+        parse_line
+        readlines }.each do |meth|
+      assert_respond_to(::CSV, meth)
+    end
+    
+    faster_csv = Array.new
+    CSV.foreach(data_file) { |row| faster_csv << row }
+    assert_equal(tests[:foreach], faster_csv)
+    assert_equal(tests[:generate_line], CSV.generate_line(data))
+    faster_csv.clear
+    CSV.open(data_file, "r") { |row| faster_csv << row }
+    assert_equal(tests[:open], faster_csv)
+    comp_file = data_file.sub("_csv_data", "_faster_csv_data")
+    CSV.open(comp_file, "w") { |f| 10.times { f << data } }
+    assert_equal(File.read(data_file), File.read(comp_file))
+    assert_equal(tests[:parse], CSV.parse(csv))
+    faster_csv.clear
+    CSV.parse(([csv] * 3).join("\n")) { |row| faster_csv << row }
+    assert_equal(tests[:parse_w_block], faster_csv)
+    assert_equal(tests[:parse_line], CSV.parse_line(csv))
+    assert_equal(tests[:readlines], CSV.readlines(data_file))
+    
+    Object.send(:remove_const, :CSV)
+    load "csv.rb"
+    [data_file, comp_file].each { |file| File.unlink(file) }
+  end
 end

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