fastcsv 0.0.2 → 0.0.3

data/test/csv/test_table.rb

@@ -0,0 +1,420 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+
+# tc_table.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::Table < TestCSV
+  extend DifferentOFS
+
+  def setup
+    super
+    @rows  = [ FastCSV::Row.new(%w{A B C}, [1, 2, 3]),
+               FastCSV::Row.new(%w{A B C}, [4, 5, 6]),
+               FastCSV::Row.new(%w{A B C}, [7, 8, 9]) ]
+    @table = FastCSV::Table.new(@rows)
+
+    @header_table = FastCSV::Table.new(
+      [FastCSV::Row.new(%w{A B C}, %w{A B C}, true)] + @rows
+    )
+  end
+
+  def test_initialze
+    assert_not_nil(@table)
+    assert_instance_of(FastCSV::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] = FastCSV::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(FastCSV::Row, row) }
+    @table.by_col.each { |tuple| assert_instance_of(Array, tuple) }
+    @table.each { |row| assert_instance_of(FastCSV::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") )
+    assert_equal( csv.lines.to_a[1..-1].join(''),
+                  @table.to_csv(:write_headers => false) )
+
+    # 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(FastCSV::Row.new(%w[A B C], [10, 11, 12]), @table[-1])
+
+    # Row append
+    assert_equal(@table, @table << FastCSV::Row.new(%w[A B C], [13, 14, 15]))
+    assert_equal(FastCSV::Row.new(%w[A B C], [13, 14, 15]), @table[-1])
+  end
+
+  def test_delete_mixed
+    ##################
+    ### 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
+  end
+
+  def test_delete_column
+    ###################
+    ### Column Mode ###
+    ###################
+    @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
+  end
+
+  def test_delete_row
+    ################
+    ### Row Mode ###
+    ################
+    @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_with_blank_rows
+    data = "col1,col2\nra1,ra2\n\nrb1,rb2"
+    table = FastCSV.parse(data, :headers => true)
+    assert_equal(["ra2", nil, "rb2"], table.delete("col2"))
+  end
+
+  def test_delete_if_row
+    ######################
+    ### 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
+  end
+
+  def test_delete_if_column
+    ###################
+    ### Column Mode ###
+    ###################
+    @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
+
+  def test_inspect_encoding_is_ascii_compatible
+    assert( Encoding.compatible?( Encoding.find("US-ASCII"),
+                                  @table.inspect.encoding ),
+            "inspect() was not ASCII compatible." )
+  end
+end

data/test/csv/ts_all.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+
+# ts_all.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 "test/unit"
+
+require "test_csv_parsing"
+require "test_features"
+require "test_interface"
+require "test_csv_writing"
+require "test_data_converters"
+require "test_row"
+require "test_table"
+require "test_headers"
+require "test_encodings"

data/test/runner.rb

@@ -0,0 +1,36 @@
+require "fastcsv"
+require 'rbconfig'
+
+require 'test/unit'
+
+src_testdir = File.dirname(File.realpath(__FILE__))
+$LOAD_PATH << src_testdir
+module Gem
+end
+class Gem::TestCase < MiniTest::Unit::TestCase
+  @@project_dir = File.dirname($LOAD_PATH.last)
+end
+
+ENV["GEM_SKIP"] = ENV["GEM_HOME"] = ENV["GEM_PATH"] = "".freeze
+
+require_relative 'profile_test_all' if ENV.has_key?('RUBY_TEST_ALL_PROFILE')
+
+module Test::Unit
+  module ZombieHunter
+    def after_teardown
+      super
+      assert_empty(Process.waitall)
+    end
+  end
+  class TestCase
+    include ZombieHunter
+  end
+end
+
+begin
+  exit Test::Unit::AutoRunner.run(true, src_testdir)
+rescue NoMemoryError
+  system("cat /proc/meminfo") if File.exist?("/proc/meminfo")
+  system("ps x -opid,args,%cpu,%mem,nlwp,rss,vsz,wchan,stat,start,time,etime,blocked,caught,ignored,pending,f") if File.exist?("/bin/ps")
+  raise
+end

data/test/with_different_ofs.rb

@@ -0,0 +1,17 @@
+module DifferentOFS
+  module WithDifferentOFS
+    def setup
+      super
+      @ofs, $, = $,, "-"
+    end
+    def teardown
+      $, = @ofs
+      super
+    end
+  end
+
+  def self.extended(klass)
+    super(klass)
+    klass.const_set(:DifferentOFS, Class.new(klass).class_eval {include WithDifferentOFS}).name
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastcsv
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Open North
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-12 00:00:00.000000000 Z
+date: 2014-11-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: coveralls
@@ -90,10 +90,12 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".travis.yml"
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
+- TESTS.md
 - USAGE
 - ext/fastcsv/extconf.rb
 - ext/fastcsv/fastcsv.c
@@ -101,9 +103,26 @@ files:
 - fastcsv.gemspec
 - lib/fastcsv.rb
 - spec/fastcsv_spec.rb
+- spec/fixtures/csv.csv
+- spec/fixtures/iso-8859-1-quoted.csv
 - spec/fixtures/iso-8859-1.csv
+- spec/fixtures/utf-8-quoted.csv
 - spec/fixtures/utf-8.csv
 - spec/spec_helper.rb
+- test/csv/base.rb
+- test/csv/line_endings.gz
+- test/csv/test_csv_parsing.rb
+- test/csv/test_csv_writing.rb
+- test/csv/test_data_converters.rb
+- test/csv/test_encodings.rb
+- test/csv/test_features.rb
+- test/csv/test_headers.rb
+- test/csv/test_interface.rb
+- test/csv/test_row.rb
+- test/csv/test_table.rb
+- test/csv/ts_all.rb
+- test/runner.rb
+- test/with_different_ofs.rb
 homepage: http://github.com/opennorth/fastcsv
 licenses:
 - MIT
@@ -130,7 +149,24 @@ specification_version: 4
 summary: A fast Ragel-based CSV parser
 test_files:
 - spec/fastcsv_spec.rb
+- spec/fixtures/csv.csv
+- spec/fixtures/iso-8859-1-quoted.csv
 - spec/fixtures/iso-8859-1.csv
+- spec/fixtures/utf-8-quoted.csv
 - spec/fixtures/utf-8.csv
 - spec/spec_helper.rb
+- test/csv/base.rb
+- test/csv/line_endings.gz
+- test/csv/test_csv_parsing.rb
+- test/csv/test_csv_writing.rb
+- test/csv/test_data_converters.rb
+- test/csv/test_encodings.rb
+- test/csv/test_features.rb
+- test/csv/test_headers.rb
+- test/csv/test_interface.rb
+- test/csv/test_row.rb
+- test/csv/test_table.rb
+- test/csv/ts_all.rb
+- test/runner.rb
+- test/with_different_ofs.rb
 has_rdoc: