fastercsv 0.1.4 → 0.1.6

data/test/tc_csv_parsing.rb

@@ -110,8 +110,8 @@ class TestCSVParsing < Test::Unit::TestCase
   end
   
   def test_malformed_csv
-    assert_raise(FasterCSV::MalformedCSVError) do 
-      FasterCSV.parse_line("1,2\r,3")
+    assert_raise(FasterCSV::MalformedCSVError) do
+      FasterCSV.parse_line("1,2\r,3", :row_sep => "\n")
     end
 
     assert_raise(FasterCSV::MalformedCSVError) do 

data/test/tc_data_converters.rb

@@ -0,0 +1,166 @@
+#!/usr/local/bin/ruby -w
+
+# tc_data_converters.rb
+#
+#  Created by James Edward Gray II on 2005-12-30.
+#  Copyright 2005 Gray Productions. All rights reserved.
+
+require "test/unit"
+
+require "faster_csv"
+
+class TestDataConverters < Test::Unit::TestCase
+  def setup
+    @data   = "Numbers,:integer,1,:float,3.015"
+    @parser = FasterCSV.new(@data)
+    
+    @custom = lambda { |field| field =~ /\A:(\S.*?)\s*\Z/ ? $1.to_sym : field }
+  end
+  
+  def test_builtin_integer_converter
+    # does convert
+    [-5, 1, 10000000000].each do |n|
+      assert_equal(n, FasterCSV::Converters[:integer][n.to_s])
+    end
+    
+    # does not convert
+    (%w{junk 1.0} + [""]).each do |str|
+      assert_equal(str, FasterCSV::Converters[:integer][str])
+    end
+  end
+
+  def test_builtin_float_converter
+    # does convert
+    [-5.1234, 0, 2.3e-11].each do |n|
+      assert_equal(n, FasterCSV::Converters[:float][n.to_s])
+    end
+    
+    # does not convert
+    (%w{junk 1..0 .015F} + [""]).each do |str|
+      assert_equal(str, FasterCSV::Converters[:float][str])
+    end
+  end
+
+  def test_builtin_date_converter
+    # does convert
+    assert_instance_of(Date, FasterCSV::Converters[:date][Time.now.to_s])
+
+    # does not convert
+    assert_instance_of(String, FasterCSV::Converters[:date]["junk"])
+  end
+
+  def test_builtin_date_time_converter
+    # does convert
+    assert_instance_of( DateTime,
+                        FasterCSV::Converters[:date_time][Time.now.to_s] )
+
+    # does not convert
+    assert_instance_of(String, FasterCSV::Converters[:date_time]["junk"])
+  end
+  
+  def test_convert_with_builtin
+    # setup parser...
+    assert(@parser.respond_to?(:convert))
+    assert_nothing_raised(Exception) { @parser.convert(:integer) }
+    
+    # and use
+    assert_equal(["Numbers", ":integer", 1, ":float", "3.015"], @parser.shift)
+    
+    setup  # reset
+    
+    # setup parser...
+    assert_nothing_raised(Exception) { @parser.convert(:float) }
+    
+    # and use
+    assert_equal(["Numbers", ":integer", 1.0, ":float", 3.015], @parser.shift)
+  end
+  
+  def test_convert_order
+    # floats first, then integers...
+    assert_nothing_raised(Exception) do 
+      @parser.convert(:float)
+      @parser.convert(:integer)
+    end
+    
+    # gets us nothing but floats
+    assert_equal( [String, String, Float, String, Float],
+                  @parser.shift.map { |field| field.class } )
+    
+    setup  # reset
+
+    # integers have precendance...
+    assert_nothing_raised(Exception) do 
+      @parser.convert(:integer)
+      @parser.convert(:float)
+    end
+    
+    # gives us proper number conversion
+    assert_equal( [String, String, Fixnum, String, Float],
+                  @parser.shift.map { |field| field.class } )
+  end
+
+  def test_builtin_numeric_combo_converter
+    # setup parser...
+    assert_nothing_raised(Exception) { @parser.convert(:numeric) }
+    
+    # and use
+    assert_equal( [String, String, Fixnum, String, Float],
+                  @parser.shift.map { |field| field.class } )
+  end
+
+  def test_builtin_all_nested_combo_converter
+    # setup parser...
+    @data   << ",#{Time.now}"        # add a DateTime field
+    @parser =  FasterCSV.new(@data)  # reset parser
+    assert_nothing_raised(Exception) { @parser.convert(:all) }
+    
+    # and use
+    assert_equal( [String, String, Fixnum, String, Float, DateTime],
+                  @parser.shift.map { |field| field.class } )
+  end
+  
+  def test_convert_with_custom_code
+    # define custom converter...
+    assert_nothing_raised(Exception) do
+      @parser.convert { |field| field =~ /\A:(\S.*?)\s*\Z/ ? $1.to_sym : field }
+    end
+    
+    # and use
+    assert_equal(["Numbers", :integer, "1", :float, "3.015"], @parser.shift)
+
+    setup  # reset
+
+    # mix built-in and custom...
+    assert_nothing_raised(Exception) { @parser.convert(:numeric) }
+    assert_nothing_raised(Exception) { @parser.convert(&@custom) }
+    
+    # and use
+    assert_equal(["Numbers", :integer, 1, :float, 3.015], @parser.shift)
+  end
+  
+  def test_convert_with_custom_code_using_field_info
+    # define custom converter that uses field information...
+    assert_nothing_raised(Exception) do
+      @parser.convert do |field, info|
+        assert_equal(1, info.line)
+        info.index == 4 ? Float(field).floor : field
+      end
+    end
+    
+    # and use
+    assert_equal(["Numbers", ":integer", "1", ":float", 3], @parser.shift)
+  end
+  
+  def test_shortcut_interface
+    assert_equal( ["Numbers", ":integer", 1, ":float", 3.015],
+                  FasterCSV.parse_line(@data, :converters => :numeric) )
+
+    assert_equal( ["Numbers", ":integer", 1, ":float", 3.015],
+                  FasterCSV.parse_line( @data, :converters => [ :integer,
+                                                                :float ] ) )
+
+    assert_equal( ["Numbers", :integer, 1, :float, 3.015],
+                  FasterCSV.parse_line( @data, :converters => [ :numeric,
+                                                                @custom ] ) )
+  end
+end

data/test/tc_features.rb

@@ -49,6 +49,24 @@ class TestFasterCSVFeatures < Test::Unit::TestCase
                                         :row_sep => "\r\n") )
   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 })
+  end
+  
+  def test_unknown_options
+    assert_raise(ArgumentError) do 
+      FasterCSV.new(String.new, :unknown => :error)
+    end
+  end
+  
   def test_bug_fixes
     # failing to escape <tt>:col_sep</tt> (reported by Kev Jackson)
     assert_nothing_raised(Exception) do 

data/test/tc_headers.rb

@@ -0,0 +1,125 @@
+#!/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.shift
+      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
+      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)
+    end
+  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.shift
+    assert_not_nil(row)
+    assert_instance_of(FasterCSV::Row, row)
+    assert_equal( [%w{first first}, %w{second second}, %w{third third}],
+                  row.to_a )
+
+    # first data row - skipping headers
+    row = csv.shift
+    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
+    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)
+  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.shift.to_a)
+    assert_equal([["1", 1], ["2", 2], ["3", 3]], csv.shift.to_a)
+    assert_nil(csv.shift)
+    
+    # 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.shift.to_a)
+    assert_equal([[:"1", 1], [:"2", 2], [:"3", 3]], csv.shift.to_a)
+    assert_nil(csv.shift)
+  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)
+  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)
+  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.shift.headers)
+  end
+end

data/test/tc_interface.rb

@@ -64,6 +64,12 @@ class TestFasterCSVInterface < Test::Unit::TestCase
     assert_not_nil(row)
     assert_instance_of(Array, row)
     assert_equal(%w{1 2 3}, row)
+    
+    # shortcut interface
+    row = "1;2;3".parse_csv(:col_sep => ";")
+    assert_not_nil(row)
+    assert_instance_of(Array, row)
+    assert_equal(%w{1 2 3}, row)
   end
   
   def test_read_and_readlines
@@ -115,6 +121,12 @@ class TestFasterCSVInterface < Test::Unit::TestCase
     assert_not_nil(line)
     assert_instance_of(String, line)
     assert_equal("1;2;3\n", line)
+    
+    # shortcut interface
+    line = %w{1 2 3}.to_csv(:col_sep => ";")
+    assert_not_nil(line)
+    assert_instance_of(String, line)
+    assert_equal("1;2;3\n", line)
   end
   
   def test_append  # aliased add_row() and puts()
@@ -126,4 +138,20 @@ class TestFasterCSVInterface < Test::Unit::TestCase
 
     test_shift
   end
+  
+  ### Test Read and Write Interface ###
+  
+  def test_filter
+    assert_respond_to(FasterCSV, :filter)
+    
+    expected = [[1, 2, 3], [4, 5]]
+    FasterCSV.filter( "1;2;3\n4;5\n", (result = String.new),
+                      :in_col_sep => ";", :out_col_sep => ",",
+                      :converters => :all ) do |row|
+      assert_equal(row, expected.shift)
+      row.map! { |n| n * 2 }
+      row << "Added\r"
+    end
+    assert_equal("2,4,6,\"Added\r\"\n8,10,\"Added\r\"\n", result)
+  end
 end

data/test/tc_row.rb

@@ -0,0 +1,264 @@
+#!/usr/local/bin/ruby -w
+
+# tc_row.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 TestFasterCSVRow < Test::Unit::TestCase
+  def setup
+    @row = FasterCSV::Row.new(%w{A B C A A}, [1, 2, 3, 4])
+  end
+  
+  def test_initialize
+    # basic
+    row = FasterCSV::Row.new(%w{A B C}, [1, 2, 3])
+    assert_not_nil(row)
+    assert_instance_of(FasterCSV::Row, row)
+    assert_equal([["A", 1], ["B", 2], ["C", 3]], row.to_a)
+    
+    # missing headers
+    row = FasterCSV::Row.new(%w{A}, [1, 2, 3])
+    assert_not_nil(row)
+    assert_instance_of(FasterCSV::Row, row)
+    assert_equal([["A", 1], [nil, 2], [nil, 3]], row.to_a)
+    
+    # missing fields
+    row = FasterCSV::Row.new(%w{A B C}, [1, 2])
+    assert_not_nil(row)
+    assert_instance_of(FasterCSV::Row, row)
+    assert_equal([["A", 1], ["B", 2], ["C", nil]], row.to_a)
+  end
+  
+  def test_headers
+    assert_equal(%w{A B C A A}, @row.headers)
+  end
+  
+  def test_field
+    # by name
+    assert_equal(2, @row.field("B"))
+    assert_equal(2, @row["B"])  # alias
+
+    # by index
+    assert_equal(3, @row.field(2))
+    
+    # missing
+    assert_nil(@row.field("Missing"))
+    assert_nil(@row.field(10))
+    
+    # minimum index
+    assert_equal(1, @row.field("A"))
+    assert_equal(1, @row.field("A", 0))
+    assert_equal(4, @row.field("A", 1))
+    assert_equal(4, @row.field("A", 2))
+    assert_equal(4, @row.field("A", 3))
+    assert_equal(nil, @row.field("A", 4))
+    assert_equal(nil, @row.field("A", 5))
+  end
+  
+  def test_set_field
+    # set field by name
+    assert_equal(100, @row["A"] = 100)
+    
+    # set field by index
+    assert_equal(300, @row[3] = 300)
+    
+    # set field by name and minimum index
+    assert_equal([:a, :b, :c], @row["A", 4] = [:a, :b, :c])
+    
+    # verify the changes
+    assert_equal( [ ["A", 100],
+                    ["B", 2],
+                    ["C", 3],
+                    ["A", 300],
+                    ["A", [:a, :b, :c]] ], @row.to_a )
+    
+    # assigning an index past the end
+    assert_equal("End", @row[10] = "End")
+    assert_equal( [ ["A", 100],
+                    ["B", 2],
+                    ["C", 3],
+                    ["A", 300],
+                    ["A", [:a, :b, :c]],
+                    [nil, nil],
+                    [nil, nil],
+                    [nil, nil],
+                    [nil, nil],
+                    [nil, nil],
+                    [nil, "End"] ], @row.to_a )
+    
+    # assigning a new field by header
+    assert_equal("New", @row[:new] = "New")
+    assert_equal( [ ["A", 100],
+                    ["B", 2],
+                    ["C", 3],
+                    ["A", 300],
+                    ["A", [:a, :b, :c]],
+                    [nil, nil],
+                    [nil, nil],
+                    [nil, nil],
+                    [nil, nil],
+                    [nil, nil],
+                    [nil, "End"],
+                    [:new, "New"] ], @row.to_a )
+  end
+  
+  def test_append
+    # add a value
+    assert_equal(@row, @row << "Value")
+    assert_equal( [ ["A", 1],
+                    ["B", 2],
+                    ["C", 3],
+                    ["A", 4],
+                    ["A", nil],
+                    [nil, "Value"] ], @row.to_a )
+    
+    # add a pair
+    assert_equal(@row, @row << %w{Header Field})
+    assert_equal( [ ["A", 1],
+                    ["B", 2],
+                    ["C", 3],
+                    ["A", 4],
+                    ["A", nil],
+                    [nil, "Value"],
+                    %w{Header Field} ], @row.to_a )
+    
+    # a pair with Hash syntax
+    assert_equal(@row, @row << {:key => :value})
+    assert_equal( [ ["A", 1],
+                    ["B", 2],
+                    ["C", 3],
+                    ["A", 4],
+                    ["A", nil],
+                    [nil, "Value"],
+                    %w{Header Field},
+                    [:key, :value] ], @row.to_a )
+    
+    # multiple fields at once
+    assert_equal(@row, @row.push(100, 200, [:last, 300]))
+    assert_equal( [ ["A", 1],
+                    ["B", 2],
+                    ["C", 3],
+                    ["A", 4],
+                    ["A", nil],
+                    [nil, "Value"],
+                    %w{Header Field},
+                    [:key, :value],
+                    [nil, 100],
+                    [nil, 200],
+                    [:last, 300] ], @row.to_a )
+  end
+  
+  def test_delete
+    # by index
+    assert_equal(["B", 2], @row.delete(1))
+
+    # by header
+    assert_equal(["C", 3], @row.delete("C"))
+    
+    # using a block
+    assert_equal(@row, @row.delete_if { |h, f| h == "A" and not f.nil? })
+    assert_equal([["A", nil]], @row.to_a)
+  end
+  
+  def test_fields
+    # all fields
+    assert_equal([1, 2, 3, 4, nil], @row.fields)
+    
+    # by header
+    assert_equal([1, 3], @row.fields("A", "C"))
+    
+    # by index
+    assert_equal([2, 3, nil], @row.fields(1, 2, 10))
+    
+    # by both
+    assert_equal([2, 3, 4], @row.fields("B", "C", 3))
+    
+    # with minimum indices
+    assert_equal([2, 3, 4], @row.fields("B", "C", ["A", 3]))
+  end
+  
+  def test_index
+    # basic usage
+    assert_equal(0, @row.index("A"))
+    assert_equal(1, @row.index("B"))
+    assert_equal(2, @row.index("C"))
+    assert_equal(nil, @row.index("Z"))
+
+    # with minimum index
+    assert_equal(0, @row.index("A"))
+    assert_equal(0, @row.index("A", 0))
+    assert_equal(3, @row.index("A", 1))
+    assert_equal(3, @row.index("A", 2))
+    assert_equal(3, @row.index("A", 3))
+    assert_equal(4, @row.index("A", 4))
+    assert_equal(nil, @row.index("A", 5))
+  end
+  
+  def test_queries
+    # headers
+    assert(@row.header?("A"))
+    assert(@row.header?("C"))
+    assert(!@row.header?("Z"))
+    assert(@row.include?("A"))  # alias
+    
+    # fields
+    assert(@row.field?(4))
+    assert(@row.field?(nil))
+    assert(!@row.field?(10))
+  end
+  
+  def test_each
+    # array style
+    ary = @row.to_a
+    @row.each do |pair|
+      assert_equal(ary.first.first, pair.first)
+      assert_equal(ary.shift.last, pair.last)
+    end
+    
+    # hash style
+    ary = @row.to_a
+    @row.each do |header, field|
+      assert_equal(ary.first.first, header)
+      assert_equal(ary.shift.last, field)
+    end
+    
+    # verify that we can chain the call
+    assert_equal(@row, @row.each { })
+  end
+  
+  def test_enumerable
+    assert_equal( [["A", 1], ["A", 4], ["A", nil]],
+                  @row.select { |pair| pair.first == "A" } )
+    
+    assert_equal(10, @row.inject(0) { |sum, (header, n)| sum + (n || 0) })
+  end
+  
+  def test_to_a
+    row = FasterCSV::Row.new(%w{A B C}, [1, 2, 3]).to_a
+    assert_instance_of(Array, row)
+    row.each do |pair|
+      assert_instance_of(Array, pair)
+      assert_equal(2, pair.size)
+    end
+    assert_equal([["A", 1], ["B", 2], ["C", 3]], row)
+  end
+  
+  def test_to_hash
+    assert_equal({"A" => nil, "B" => 2, "C" => 3}, @row.to_hash)
+  end
+  
+  def test_to_csv
+    # normal conversion
+    assert_equal("1,2,3,4,\n", @row.to_csv)
+    assert_equal("1,2,3,4,\n", @row.to_s)  # alias
+    
+    # with options
+    assert_equal( "1|2|3|4|\r\n",
+                  @row.to_csv(:col_sep => "|", :row_sep => "\r\n") )
+  end
+end