fastcsv 0.0.2 → 0.0.3

data/test/csv/test_interface.rb

@@ -0,0 +1,362 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+
+# tc_interface.rb
+#
+#  Created by James Edward Gray II on 2005-10-31.
+#  Copyright 2005 James Edward Gray II. You can redistribute or modify this code
+#  under the terms of Ruby's license.
+
+require_relative "base"
+require "tempfile"
+
+class TestCSV::Interface < TestCSV
+  extend DifferentOFS
+
+  def setup
+    super
+    @tempfile = Tempfile.new(%w"temp .csv")
+    @tempfile.close
+    @path = @tempfile.path
+
+    File.open(@path, "wb") do |file|
+      file << "1,2,3\r\n"
+      file << "4,5\r\n"
+    end
+
+    @expected = [%w{1 2 3}, %w{4 5}]
+  end
+
+  def teardown
+    @tempfile.close(true)
+    super
+  end
+
+  ### Test Read Interface ###
+
+  def test_foreach
+    FastCSV.foreach(@path, col_sep: ",", row_sep: "\r\n") do |row|
+      assert_equal(@expected.shift, row)
+    end
+  end
+
+  def test_foreach_enum
+    FastCSV.foreach(@path, col_sep: ",", row_sep: "\r\n").zip(@expected) do |row, exp|
+      assert_equal(exp, row)
+    end
+  end
+
+  def test_open_and_close
+    csv = FastCSV.open(@path, "r+", col_sep: ",", row_sep: "\r\n")
+    assert_not_nil(csv)
+    assert_instance_of(FastCSV, csv)
+    assert_equal(false, csv.closed?)
+    csv.close
+    assert(csv.closed?)
+
+    ret = FastCSV.open(@path) do |new_csv|
+      csv = new_csv
+      assert_instance_of(FastCSV, new_csv)
+      "Return value."
+    end
+    assert(csv.closed?)
+    assert_equal("Return value.", ret)
+  end
+
+  def test_parse
+    data = File.binread(@path)
+    assert_equal( @expected,
+                  FastCSV.parse(data, col_sep: ",", row_sep: "\r\n") )
+
+    FastCSV.parse(data, col_sep: ",", row_sep: "\r\n") do |row|
+      assert_equal(@expected.shift, row)
+    end
+  end
+
+  def test_parse_line
+    row = FastCSV.parse_line("1,2,3", col_sep: ",")
+    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_parse_line_with_empty_lines
+    assert_equal(nil,       FastCSV.parse_line(""))  # to signal eof
+    assert_equal(Array.new, FastCSV.parse_line("\n1,2,3"))
+  end
+
+  def test_read_and_readlines
+    assert_equal( @expected,
+                  FastCSV.read(@path, col_sep: ",", row_sep: "\r\n") )
+    assert_equal( @expected,
+                  FastCSV.readlines(@path, col_sep: ",", row_sep: "\r\n") )
+
+
+    data = FastCSV.open(@path, col_sep: ",", row_sep: "\r\n") do |csv|
+      csv.read
+    end
+    assert_equal(@expected, data)
+    data = FastCSV.open(@path, col_sep: ",", row_sep: "\r\n") do |csv|
+      csv.readlines
+    end
+    assert_equal(@expected, data)
+  end
+
+  def test_table
+    table = FastCSV.table(@path, col_sep: ",", row_sep: "\r\n")
+    assert_instance_of(FastCSV::Table, table)
+    assert_equal([[:"1", :"2", :"3"], [4, 5, nil]], table.to_a)
+  end
+
+  def test_shift  # aliased as gets() and readline()
+    FastCSV.open(@path, "rb+", col_sep: ",", row_sep: "\r\n") do |csv|
+      assert_equal(@expected.shift, csv.shift)
+      assert_equal(@expected.shift, csv.shift)
+      assert_equal(nil, csv.shift)
+    end
+  end
+
+  def test_enumerators_are_supported
+    FastCSV.open(@path, col_sep: ",", row_sep: "\r\n") do |csv|
+      enum = csv.each
+      assert_instance_of(Enumerator, enum)
+      assert_equal(@expected.shift, enum.next)
+    end
+  end
+
+  ### Test Write Interface ###
+
+  def test_generate
+    str = FastCSV.generate do |csv|  # default empty String
+      assert_instance_of(FastCSV, csv)
+      assert_equal(csv, csv << [1, 2, 3])
+      assert_equal(csv, csv << [4, nil, 5])
+    end
+    assert_not_nil(str)
+    assert_instance_of(String, str)
+    assert_equal("1,2,3\n4,,5\n", str)
+
+    FastCSV.generate(str) do |csv|   # appending to a String
+      assert_equal(csv, csv << ["last", %Q{"row"}])
+    end
+    assert_equal(%Q{1,2,3\n4,,5\nlast,"""row"""\n}, str)
+  end
+
+  def test_generate_line
+    line = FastCSV.generate_line(%w{1 2 3}, col_sep: ",")
+    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_write_header_detection
+    File.unlink(@path)
+
+    headers = %w{a b c}
+    FastCSV.open(@path, "w", headers: true) do |csv|
+      csv << headers
+      csv << %w{1 2 3}
+      assert_equal(headers, csv.instance_variable_get(:@headers))
+    end
+  end
+
+  def test_write_lineno
+    File.unlink(@path)
+
+    FastCSV.open(@path, "w") do |csv|
+      lines = 20
+      lines.times { csv << %w{a b c} }
+      assert_equal(lines, csv.lineno)
+    end
+  end
+
+  def test_write_hash
+    File.unlink(@path)
+
+    lines = [{a: 1, b: 2, c: 3}, {a: 4, b: 5, c: 6}]
+    FastCSV.open( @path, "wb", headers:           true,
+                           header_converters: :symbol ) do |csv|
+      csv << lines.first.keys
+      lines.each { |line| csv << line }
+    end
+    FastCSV.open( @path, "rb", headers:           true,
+                           converters:        :all,
+                           header_converters: :symbol ) do |csv|
+      csv.each { |line| assert_equal(lines.shift, line.to_hash) }
+    end
+  end
+
+  def test_write_hash_with_string_keys
+    File.unlink(@path)
+
+    lines = [{a: 1, b: 2, c: 3}, {a: 4, b: 5, c: 6}]
+    FastCSV.open( @path, "wb", headers: true ) do |csv|
+      csv << lines.first.keys
+      lines.each { |line| csv << line }
+    end
+    FastCSV.open( @path, "rb", headers: true ) do |csv|
+      csv.each do |line|
+        csv.headers.each_with_index do |header, h|
+          keys = line.to_hash.keys
+          assert_instance_of(String, keys[h])
+          assert_same(header, keys[h])
+        end
+      end
+    end
+  end
+
+  def test_write_hash_with_headers_array
+    File.unlink(@path)
+
+    lines = [{a: 1, b: 2, c: 3}, {a: 4, b: 5, c: 6}]
+    FastCSV.open(@path, "wb", headers: [:b, :a, :c]) do |csv|
+      lines.each { |line| csv << line }
+    end
+
+    # test writing fields in the correct order
+    File.open(@path, "rb") do |f|
+      assert_equal("2,1,3", f.gets.strip)
+      assert_equal("5,4,6", f.gets.strip)
+    end
+
+    # test reading FastCSV with headers
+    FastCSV.open( @path, "rb", headers:    [:b, :a, :c],
+                           converters: :all ) do |csv|
+      csv.each { |line| assert_equal(lines.shift, line.to_hash) }
+    end
+  end
+
+  def test_write_hash_with_headers_string
+    File.unlink(@path)
+
+    lines = [{"a" => 1, "b" => 2, "c" => 3}, {"a" => 4, "b" => 5, "c" => 6}]
+    FastCSV.open(@path, "wb", headers: "b,a,c", col_sep: ",") do |csv|
+      lines.each { |line| csv << line }
+    end
+
+    # test writing fields in the correct order
+    File.open(@path, "rb") do |f|
+      assert_equal("2,1,3", f.gets.strip)
+      assert_equal("5,4,6", f.gets.strip)
+    end
+
+    # test reading FastCSV with headers
+    FastCSV.open( @path, "rb", headers:    "b,a,c",
+                           col_sep:    ",",
+                           converters: :all ) do |csv|
+      csv.each { |line| assert_equal(lines.shift, line.to_hash) }
+    end
+  end
+
+  def test_write_headers
+    File.unlink(@path)
+
+    lines = [{"a" => 1, "b" => 2, "c" => 3}, {"a" => 4, "b" => 5, "c" => 6}]
+    FastCSV.open( @path, "wb", headers:       "b,a,c",
+                           write_headers: true,
+                           col_sep:       "," ) do |csv|
+      lines.each { |line| csv << line }
+    end
+
+    # test writing fields in the correct order
+    File.open(@path, "rb") do |f|
+      assert_equal("b,a,c", f.gets.strip)
+      assert_equal("2,1,3", f.gets.strip)
+      assert_equal("5,4,6", f.gets.strip)
+    end
+
+    # test reading FastCSV with headers
+    FastCSV.open( @path, "rb", headers:    true,
+                           col_sep:    ",",
+                           converters: :all ) do |csv|
+      csv.each { |line| assert_equal(lines.shift, line.to_hash) }
+    end
+  end
+
+  def test_append  # aliased add_row() and puts()
+    File.unlink(@path)
+
+    FastCSV.open(@path, "wb", col_sep: ",", row_sep: "\r\n") do |csv|
+      @expected.each { |row| csv << row }
+    end
+
+    test_shift
+
+    # same thing using FastCSV::Row objects
+    File.unlink(@path)
+
+    FastCSV.open(@path, "wb", col_sep: ",", row_sep: "\r\n") do |csv|
+      @expected.each { |row| csv << FastCSV::Row.new(Array.new, row) }
+    end
+
+    test_shift
+  end
+
+  ### Test Read and Write Interface ###
+
+  def test_filter
+    assert_respond_to(FastCSV, :filter)
+
+    expected = [[1, 2, 3], [4, 5]]
+    FastCSV.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
+
+  def test_instance
+    csv = String.new
+
+    first = nil
+    assert_nothing_raised(Exception) do
+      first =  FastCSV.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 =  FastCSV.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, FastCSV.instance.instance_eval { @io })
+    assert_equal(STDOUT, FastCSV { |new_csv| new_csv.instance_eval { @io } })
+  end
+
+  def test_options_are_not_modified
+    opt = {}.freeze
+    assert_nothing_raised {  FastCSV.foreach(@path, opt)       }
+    assert_nothing_raised {  FastCSV.open(@path, opt){}        }
+    assert_nothing_raised {  FastCSV.parse("", opt)            }
+    assert_nothing_raised {  FastCSV.parse_line("", opt)       }
+    assert_nothing_raised {  FastCSV.read(@path, opt)          }
+    assert_nothing_raised {  FastCSV.readlines(@path, opt)     }
+    assert_nothing_raised {  FastCSV.table(@path, opt)         }
+    assert_nothing_raised {  FastCSV.generate(opt){}           }
+    assert_nothing_raised {  FastCSV.generate_line([], opt)    }
+    assert_nothing_raised {  FastCSV.filter("", "", opt){}     }
+    assert_nothing_raised {  FastCSV.instance("", opt)         }
+  end
+end

data/test/csv/test_row.rb

@@ -0,0 +1,349 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+
+# tc_row.rb
+#
+#  Created by James Edward Gray II on 2005-10-31.
+#  Copyright 2005 James Edward Gray II. You can redistribute or modify this code
+#  under the terms of Ruby's license.
+
+require_relative "base"
+
+class TestCSV::Row < TestCSV
+  extend DifferentOFS
+
+  def setup
+    super
+    @row = FastCSV::Row.new(%w{A B C A A}, [1, 2, 3, 4])
+  end
+
+  def test_initialize
+    # basic
+    row = FastCSV::Row.new(%w{A B C}, [1, 2, 3])
+    assert_not_nil(row)
+    assert_instance_of(FastCSV::Row, row)
+    assert_equal([["A", 1], ["B", 2], ["C", 3]], row.to_a)
+
+    # missing headers
+    row = FastCSV::Row.new(%w{A}, [1, 2, 3])
+    assert_not_nil(row)
+    assert_instance_of(FastCSV::Row, row)
+    assert_equal([["A", 1], [nil, 2], [nil, 3]], row.to_a)
+
+    # missing fields
+    row = FastCSV::Row.new(%w{A B C}, [1, 2])
+    assert_not_nil(row)
+    assert_instance_of(FastCSV::Row, row)
+    assert_equal([["A", 1], ["B", 2], ["C", nil]], row.to_a)
+  end
+
+  def test_row_type
+    # field rows
+    row = FastCSV::Row.new(%w{A B C}, [1, 2, 3])         # implicit
+    assert(!row.header_row?)
+    assert(row.field_row?)
+    row = FastCSV::Row.new(%w{A B C}, [1, 2, 3], false)  # explicit
+    assert(!row.header_row?)
+    assert(row.field_row?)
+
+    # header row
+    row = FastCSV::Row.new(%w{A B C}, [1, 2, 3], true)
+    assert(row.header_row?)
+    assert(!row.field_row?)
+  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_fetch
+    # only by name
+    assert_equal(2, @row.fetch('B'))
+
+    # missing header raises KeyError
+    assert_raise KeyError do
+      @row.fetch('foo')
+    end
+
+    # missing header yields itself to block
+    assert_equal 'bar', @row.fetch('foo') { |header|
+      header == 'foo' ? 'bar' : false }
+
+    # missing header returns the given default value
+    assert_equal 'bar', @row.fetch('foo', 'bar')
+
+    # more than one vararg raises ArgumentError
+    assert_raise ArgumentError do
+      @row.fetch('foo', 'bar', 'baz')
+    end
+  end
+
+  def test_has_key?
+    assert_equal(true, @row.has_key?('B'))
+    assert_equal(false, @row.has_key?('foo'))
+  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]))
+
+    # by header range
+    assert_equal([2, 3], @row.values_at("B".."C"))
+  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, (_, n)| sum + (n || 0) })
+  end
+
+  def test_to_a
+    row = FastCSV::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
+    hash = @row.to_hash
+    assert_equal({"A" => nil, "B" => 2, "C" => 3}, hash)
+    hash.keys.each_with_index do |string_key, h|
+      assert_predicate(string_key, :frozen?)
+      assert_same(string_key, @row.headers[h])
+    end
+  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
+
+  def test_array_delegation
+    assert(!@row.empty?, "Row was empty.")
+
+    assert_equal([@row.headers.size, @row.fields.size].max, @row.size)
+  end
+
+  def test_inspect_shows_header_field_pairs
+    str = @row.inspect
+    @row.each do |header, field|
+      assert( str.include?("#{header.inspect}:#{field.inspect}"),
+              "Header field pair not found." )
+    end
+  end
+
+  def test_inspect_encoding_is_ascii_compatible
+    assert( Encoding.compatible?( Encoding.find("US-ASCII"),
+                                  @row.inspect.encoding ),
+            "inspect() was not ASCII compatible." )
+  end
+
+  def test_inspect_shows_symbol_headers_as_bare_attributes
+    str = FastCSV::Row.new(@row.headers.map { |h| h.to_sym }, @row.fields).inspect
+    @row.each do |header, field|
+      assert( str.include?("#{header}:#{field.inspect}"),
+              "Header field pair not found." )
+    end
+  end
+
+  def test_can_be_compared_with_other_classes
+    assert(FastCSV::Row.new([ ], [ ]) != nil, "The row was nil")
+  end
+end