#!/usr/local/bin/ruby -w

# tc_table.rb
#
#  Created by James Edward Gray II on 2006-02-24.
#  Copyright 2012 Gray Productions. All rights reserved.

require "test/unit"

require "faster_csv"

class TestFasterCSVTable < Test::Unit::TestCase
  def setup
    @rows  = [ FasterCSV::Row.new(%w{A B C}, [1, 2, 3]),
               FasterCSV::Row.new(%w{A B C}, [4, 5, 6]),
               FasterCSV::Row.new(%w{A B C}, [7, 8, 9]) ]
    @table = FasterCSV::Table.new(@rows)

    @header_table = FasterCSV::Table.new(
      [FasterCSV::Row.new(%w{A B C}, %w{A B C}, true)] + @rows
    )
  end

  def test_initialze
    assert_not_nil(@table)
    assert_instance_of(FasterCSV::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] = FasterCSV::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(FasterCSV::Row, row) }
    @table.by_col.each { |tuple| assert_instance_of(Array, tuple) }
    @table.each { |row| assert_instance_of(FasterCSV::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.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(FasterCSV::Row.new(%w[A B C], [10, 11, 12]), @table[-1])
    
    # Row append
    assert_equal(@table, @table << FasterCSV::Row.new(%w[A B C], [13, 14, 15]))
    assert_equal(FasterCSV::Row.new(%w[A B C], [13, 14, 15]), @table[-1])
  end
  
  def test_delete
    ##################
    ### 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
    
    ###################
    ### Column Mode ###
    ###################
    setup
    @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
    
    ################
    ### Row Mode ###
    ################
    setup
    @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 = FasterCSV.parse(data, :headers => true)
    assert_equal(["ra2", nil, "rb2"], table.delete("col2"))
  end
  
  def test_delete_if
    ######################
    ### 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
    
    ###################
    ### Column Mode ###
    ###################
    setup
    @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
end
