tabmani 0.0.0

data/test/helper.rb

@@ -0,0 +1,33 @@
+require 'simplecov'
+
+module SimpleCov::Configuration
+  def clean_filters
+    @filters = []
+  end
+end
+
+SimpleCov.configure do
+  clean_filters
+  load_adapter 'test_frameworks'
+end
+
+ENV["COVERAGE"] && SimpleCov.start do
+  add_filter "/.rvm/"
+end
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'tabmani'
+
+class Test::Unit::TestCase
+end

data/test/test_table.rb

@@ -0,0 +1,582 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+require "pp"
+require "helper"
+
+TT = Tabmani::Table
+
+class TC_Table < Test::Unit::TestCase
+
+
+  def setup
+    @t00 = TT.new(matrix: [ %w(a b c), %w(d e f) ])
+    @t01 = TT.new(matrix: [ %w(a), %w(d e ) , %w(g h i) ])
+    matrix = [
+      ['0123', '45', '6789'],
+      ['abcd', 'ef', 'ghij'],
+      ['a   ', 'e ', 'g   '],
+      ['a cd', ' f', 'gh j'],
+      ['abcd', '  ', '    '],
+      ['    ', '  ', ' hij']
+    ]
+    @t01 = TT.new(matrix: matrix)
+  end
+
+  def test_print_size
+    assert_equal(2, TT.print_size('ab'))
+    assert_equal(4, TT.print_size('あい'))
+    assert_equal(6, TT.print_size('abあい'))
+  end
+
+  def test_parse_csv
+    io = StringIO.new
+    io.puts('a,b,c')
+    io.puts('d,e,f')
+    io.rewind
+    results = TT.parse_csv(io)
+    corrects = [ %w(a b c), %w(d e f), ]
+    assert_equal(corrects, results.matrix)
+  end
+
+  def test_parse_separator
+    io = StringIO.new
+    io.puts('a | b | c ')
+    io.puts('d | e | f ')
+    io.rewind
+    results = TT.parse_separator(io, '|')
+    corrects = [
+      ['a ', ' b ', ' c '],
+      ['d ', ' e ', ' f ']
+    ]
+    assert_equal(corrects, results.matrix)
+
+    io = StringIO.new
+    io.puts('a | b | c ')
+    io.puts('d | e | f ')
+    io.rewind
+    results = TT.parse_separator(io, ' ')
+    corrects = [ %w(a | b | c), %w(d | e | f), ]
+    assert_equal(corrects, results.matrix)
+  end
+
+  def test_parse_blanks_separated_value
+    io = StringIO.new
+    io.puts('a  b    c')
+    io.puts('d e f')
+    io.rewind
+    results = TT.parse_blanks_separated_value(io)
+    corrects = [ %w(a b c), %w(d e f), ]
+    assert_equal(corrects, results.matrix)
+
+    io = StringIO.new
+    io.puts('  a  b    c')
+    io.puts('   d e f')
+    io.rewind
+    results = TT.parse_blanks_separated_value(io)
+    corrects = [ ['a','b','c'], ['d', 'e', 'f'] ]
+    assert_equal(corrects, results.matrix)
+    assert_equal(2, results.indent)
+
+    io = StringIO.new
+    io.puts('a b c')
+    io.puts
+    io.puts('d e f')
+    io.rewind
+    results = TT.parse_blanks_separated_value(io)
+    corrects = [ ['a','b','c'], [], ['d', 'e', 'f'] ]
+    assert_equal(corrects, results.matrix)
+  end
+
+  def test_parse_column_based_value
+    io = StringIO.new
+    io.puts('a  b  c')
+    io.puts(' d e f ')
+    io.puts()
+    io.rewind
+    results = TT.parse_column_based_value(io)
+    corrects = [ ['a','b','c'], ['d', 'e', 'f'] ]
+    assert_equal(corrects, results.matrix)
+
+    in_io = StringIO.new
+    in_io.puts '0123 45 6789'
+    in_io.puts 'abcd ef ghij'
+    in_io.puts 'a    e  g   '
+    in_io.puts 'a cd  f gh j'
+    in_io.puts 'abcd        '
+    in_io.puts '         hij'
+    in_io.rewind
+    c01 = TT.parse_column_based_value(in_io)
+    result = c01.matrix
+    correct = [
+      ['0123', '45', '6789'],
+      ['abcd', 'ef', 'ghij'],
+      ['a'   , 'e' , 'g'   ],
+      ['a cd', 'f' , 'gh j'],
+      ['abcd', ''  , ''    ],
+      [''    , ''  , 'hij' ]
+    ]
+    assert_equal(correct, result)
+
+    in_io = StringIO.new
+    in_io.puts '012'
+    in_io.puts 'abcd ef ghij'
+    in_io.puts 'a    e  g   '
+    in_io.puts 'a cd  f gh j'
+    in_io.puts 'abcd        '
+    in_io.puts '         hij'
+    in_io.rewind
+    c01 = TT.parse_column_based_value(in_io)
+    result = c01.matrix
+    correct = [
+      ['012', '', ''],
+      ['abcd', 'ef', 'ghij'],
+      ['a'   , 'e' , 'g'   ],
+      ['a cd', 'f' , 'gh j'],
+      ['abcd', ''  , ''    ],
+      [''    , ''  , 'hij' ]
+    ]
+    assert_equal(correct, result)
+  end
+
+  def test_parse
+    io = StringIO.new
+    io.puts('a,b,c')
+    io.puts('d,e,f')
+    io.rewind
+    results = TT.parse(io: io, style: :csv)
+    corrects = [ %w(a b c), %w(d e f), ]
+    assert_equal(corrects, results.matrix)
+
+    io = StringIO.new
+    io.puts('a  b    c')
+    io.puts('d e f')
+    io.rewind
+    results = TT.parse(io: io, style: :blank)
+    corrects = [ %w(a b c), %w(d e f), ]
+    assert_equal(corrects, results.matrix)
+
+    io = StringIO.new
+    io.puts('a  b  c')
+    io.puts(' d e f ')
+    io.puts()
+    io.rewind
+    results = TT.parse(io: io, style: :column)
+    corrects = [ ['a','b','c'], ['d', 'e', 'f'] ]
+    assert_equal(corrects, results.matrix)
+  end
+
+  def test_dump_csv
+    io = StringIO.new
+    @t00.dump_csv(io: io)
+    io.rewind
+    result = io.read
+    assert_equal("a,b,c\nd,e,f\n", result)
+
+    setup
+    io = StringIO.new
+    @t00.set_title
+    @t00.dump_csv(io: io)
+    io.rewind
+    result = io.read
+    assert_equal("a,b,c\nd,e,f\n", result)
+  end
+
+  def test_dump_column_format
+    t10 = TT.new(matrix: [ ["a", "ab"], ["abc", "a"], ])
+    io = StringIO.new
+    t10.dump_column_format(io: io)
+    io.rewind
+    assert_equal("a   ab\nabc a\n", io.read)
+
+    io = StringIO.new
+    t10.dump_column_format(io: io, separator: '|')
+    io.rewind
+    assert_equal("a  |ab\nabc|a\n", io.read)
+
+    io = StringIO.new
+    t10.dump_column_format(io: io, just: :right)
+    io.rewind
+    assert_equal("  a ab\nabc  a\n", io.read)
+    io.rewind
+
+    io = StringIO.new
+    @t01 = TT.new(matrix:  [ ["abc", "def"], ["あいう", "えおか"], ])
+    @t01.dump_column_format(io: io)
+    io.rewind
+    assert_equal("abc    def\nあいう えおか\n", io.read)
+
+    ## not string
+    io = StringIO.new
+    t12 = TT.new(matrix: [ [0, 1], [2, 3], ])
+    t12.dump_column_format(io: io)
+    io.rewind
+    assert_equal("0 1\n2 3\n", io.read)
+
+    ## indent
+    t10 = TT.new(matrix: [ ["a", "ab"], ["abc", "a"], ], indent: 2)
+    io = StringIO.new
+    t10.dump_column_format(io: io)
+    io.rewind
+    assert_equal("  a   ab\n  abc a\n", io.read)
+
+    ## horizontal line
+    t10 = TT.new(matrix: [ ["a", "ab"], ["abc", "a"], ])
+    t10.add_hline(0)
+    t10.add_hline(2)
+    io = StringIO.new
+    t10.dump_column_format(io: io)
+    io.rewind
+    assert_equal("------\na   ab\nabc a\n------\n", io.read)
+
+    ## title
+    t10 = TT.new(matrix: [ ["a", "ab"], ["abc", "a"], ])
+    t10.set_title
+    io = StringIO.new
+    t10.dump_column_format(io: io)
+    io.rewind
+    assert_equal("a   ab\nabc a\n", io.read)
+  end
+
+  def test_dump_md_simple
+    io = StringIO.new
+    @t00.dump_md_simple(io: io, just: :left)
+    io.rewind
+    assert_equal( ["a b c\n", "- - -\n",  "d e f\n" ], io.readlines)
+    assert_equal( [ %w(a b c), %w(d e f) ], @t00.matrix)
+
+    setup
+    io = StringIO.new
+    @t00.set_title
+    @t00.dump_md_simple(io: io, just: :left)
+    io.rewind
+    assert_equal( ["a b c\n", "- - -\n",  "d e f\n" ], io.readlines)
+    assert_equal( %w(a b c), @t00.titles)
+    assert_equal( [ %w(d e f)], @t00.matrix)
+  end
+
+  def test_dump_tex
+    io = StringIO.new
+    t10 = TT.new(matrix: [ %w(a b c), %w(d e f) , %w(g h i) ])
+    t10.dump_tex(io: io, just: :left)
+    io.rewind
+    corrects = [
+      "\\begin{tabular}{lll}\n",
+      "  \\hline\n",
+      "  a & b & c \\\\\n",
+      "  d & e & f \\\\\n",
+      "  g & h & i \\\\\n",
+      "  \\hline\n",
+      "\\end{tabular}\n"
+    ]
+    assert_equal( corrects, io.readlines)
+    assert_equal( [ %w(a b c), %w(d e f), %w(g h i) ], t10.matrix)
+
+    io = StringIO.new
+    @t01 = TT.new(matrix: [ %w(a), %w(d e ) , %w(g h i) ])
+    @t01.dump_tex(io: io, just: :left)
+    io.rewind
+    corrects = [
+      "\\begin{tabular}{lll}\n",
+      "  \\hline\n",
+      "  a &   &   \\\\\n",
+      "  d & e &   \\\\\n",
+      "  g & h & i \\\\\n",
+      "  \\hline\n",
+      "\\end{tabular}\n"
+    ]
+    assert_equal( corrects, io.readlines)
+    assert_equal( [ %w(a), %w(d e ), %w(g h i) ], @t01.matrix)
+
+    setup
+    io = StringIO.new
+    @t01 = TT.new(matrix: [ %w(a), %w(d e ) , %w(g h i) ])
+    @t01.set_title
+    @t01.dump_tex(io: io, just: :left)
+    io.rewind
+    corrects = [
+      "\\begin{tabular}{lll}\n",
+      "  \\hline\n",
+      "  a &   &   \\\\\n",
+      "  \\hline\n",
+      "  d & e &   \\\\\n",
+      "  g & h & i \\\\\n",
+      "  \\hline\n",
+      "\\end{tabular}\n"
+    ]
+    assert_equal( corrects, io.readlines)
+    assert_equal( %w(a), @t01.titles)
+    assert_equal( [ %w(d e ), %w(g h i) ], @t01.matrix)
+  end
+
+  def test_padding
+    assert_equal( 'abc       ', TT.padding(str: 'abc', width: 10, padding: ' '))
+    assert_equal( 'abc       ', TT.padding(str: 'abc', width: 10, padding: ' ', place: :left))
+    assert_equal( '       abc', TT.padding(str: 'abc', width: 10, padding: ' ', place: :right))
+    assert_equal( '   abc    ', TT.padding(str: 'abc', width: 10, padding: ' ', place: :center))
+  end
+
+  def test_show_keys
+    io = StringIO.new
+    @t01.show_keys(io: io)
+    io.rewind
+    result = io.readlines
+    assert_equal(
+      [ "---- -- ----\n", 
+        "1    2  3\n"
+      ], result
+    )
+
+    t10 = TT.new(matrix: [ %w(a b c), %w(d e f) ], indent: 2)
+    io = StringIO.new
+    t10.show_keys(io: io)
+    io.rewind
+    result = io.readlines
+    assert_equal(
+      [ "  - - -\n", 
+        "  1 2 3\n"
+      ], result
+    )
+  end
+
+  def test_projection_ary
+    text = [
+      '0123 45 6789',
+      'abcd ef ghij',
+      'a    e  g   ',
+      'a cd  f gh j',
+      'abcd        ',
+      '         hij',
+    ]
+
+    results = TT.projection_ary(text)
+    corrects = [true, true, true, true, false,
+                true, true, false,
+                true, true, true, true]
+    assert_equal(corrects, results)
+
+    results = TT.projection_ary([])
+    corrects = []
+    assert_equal(corrects, results)
+  end
+
+  def test_get_ranges
+    results = TT.get_ranges([true, true, true, true, false,
+                            true, true, false,
+                            true, true, true, true]
+                          )
+    corrects = [ 0..3, 5..6, 8..11 ]
+    assert_equal(corrects, results)
+  end
+
+  def test_transpose!
+    ##a b
+    ##d e f
+    ##↓
+    ##a d
+    ##b e
+    ##  f
+    matrix00 = [ %w(a b), %w(d e f) ]
+    t10 = TT.new(matrix: matrix00)
+    t10.transpose!
+    correct = [ ['a', 'd'], ['b', 'e'], ['', 'f'] ]
+    assert_equal(correct, t10.matrix)
+  end
+
+  def test_transpose
+    matrix00 = [ %w(a b), %w(d e f) ]
+    t10 = TT.new(matrix: matrix00)
+    result = t10.transpose
+    correct = [ ['a', 'd'], ['b', 'e'], ['', 'f'] ]
+    assert_equal(matrix00, t10.matrix)
+    assert_equal(correct, result.matrix)
+  end
+
+  def test_filter!
+    @t00.filter!('1', 'a')
+    assert_equal([ %w(a b c)            ], @t00.matrix)
+  end
+
+  def test_filter
+    assert_equal([ %w(a b c)            ], @t00.filter('1', 'a').matrix)
+    assert_equal([ %w(a b c)            ], @t00.filter('2', 'b').matrix)
+    assert_equal([ %w(a b c)            ], @t00.filter('3', 'c').matrix)
+    assert_equal([ %w(d e f)            ], @t00.filter('1', 'd').matrix)
+    assert_equal([ %w(d e f)            ], @t00.filter('2', 'e').matrix)
+    assert_equal([ %w(d e f)            ], @t00.filter('3', 'f').matrix)
+    assert_equal([                      ], @t00.filter('1', ' ').matrix)
+  end
+
+  def test_analyze
+    out_io = StringIO.new
+    @t01.analyze(io: out_io, keys: [])
+    out_io.rewind
+
+    corrects = [
+      "\n",
+      "key head types\n",
+      "1   0123 5\n",
+      "2   45   5\n",
+      "3   6789 6\n",
+    ]
+    assert_equal(corrects, out_io.readlines)
+  end
+
+  def test_max_lengths
+    assert_equal([4, 2, 4], @t01.max_lengths)
+
+    t10 = TT.new(matrix: [ %w(ABC BC), %w(d e ) , %w(g h ij) ])
+    t10.set_title
+    assert_equal([3, 2, 2], t10.max_lengths)
+  end
+
+  def test_add_sum
+    ## key=1
+    io = StringIO.new
+    matrix = [
+      ['1', 'a', 'a'],
+      ['2', 'b', 'a'],
+      ['3', 'c', '1'],
+      ['4', 'd', '2'],
+    ]
+    t11 = TT.new(matrix: matrix)
+    t11.add_sum('1')
+    t11.dump_column_format(io: io)
+    io.rewind
+    results = io.readlines
+    corrects = [
+      "1  a a\n",
+      "2  b a\n",
+      "3  c 1\n",
+      "4  d 2\n",
+      "------\n",
+      "10\n",
+    ]
+    assert_equal(corrects, results)
+
+    ## key=2
+    io = StringIO.new
+    matrix = [
+      ['1', 'a', 'a'],
+      ['2', 'b', 'a'],
+      ['3', 'c', '1'],
+      ['4', 'd', '2'],
+    ]
+    t11 = TT.new(matrix: matrix)
+    t11.add_sum('2')
+    t11.dump_column_format(io: io)
+    io.rewind
+    results = io.readlines
+    corrects = [
+      "1 a a\n",
+      "2 b a\n",
+      "3 c 1\n",
+      "4 d 2\n",
+      "-----\n",
+      "  0\n",
+    ]
+    assert_equal(corrects, results)
+
+    ## key=3
+    io = StringIO.new
+    matrix = [
+      ['1', 'a', 'a'],
+      ['2', 'b', 'a'],
+      ['3', 'c', '1'],
+      ['4', 'd', '2'],
+    ]
+    t11 = TT.new(matrix: matrix)
+    t11.add_sum('3')
+    t11.dump_column_format(io: io)
+    io.rewind
+    results = io.readlines
+    corrects = [
+      "1 a a\n",
+      "2 b a\n",
+      "3 c 1\n",
+      "4 d 2\n",
+      "-----\n",
+      "    3\n",
+    ]
+    assert_equal(corrects, results)
+
+    ## including float
+    io = StringIO.new
+    matrix = [
+      ['1', 'a', 'a'],
+      ['2.0', 'b', 'a'],
+      ['3', 'c', '1'],
+      ['4', 'd', '2'],
+    ]
+    t11 = TT.new(matrix: matrix)
+    t11.add_sum('1')
+    t11.dump_column_format(io: io)
+    io.rewind
+    results = io.readlines
+    corrects = [
+      "1    a a\n",
+      "2.0  b a\n",
+      "3    c 1\n",
+      "4    d 2\n",
+      "--------\n",
+      "10.0\n",
+    ]
+    assert_equal(corrects, results)
+  end
+
+  def test_strip
+    matrix = [
+      ['a ', ' b ', ' c '],
+      ['d ', ' e ', ' f ']
+    ]
+    t10 = TT.new(matrix: matrix)
+    t10.strip
+    corrects = [
+      ['a', 'b', 'c'],
+      ['d', 'e', 'f']
+    ]
+    assert_equal(corrects, t10.matrix)
+  end
+
+  def test_reform
+    matrix = [
+      %w(Ti 1.1  1),
+      %w(Ti 2.2  2),
+      %w(Zn 3.3  1),
+      %w(Zn 4.4  2),
+    ]
+    t10 = TT.new(matrix: matrix)
+    t10.reform('1', '3', '2')
+    correct = [
+      [''  , 'Ti'  , 'Zn' ],
+      ['1' , '1.1' , '3.3'],
+      ['2' , '2.2' , '4.4'],
+    ]
+    assert_equal(correct, t10.matrix)
+
+    matrix = [
+      %w(Ti 1.1  1),
+      %w(Ti 2.2  2),
+      %w(Zn 3.3  1),
+      %w(Zn 4.4  2),
+      %w(Zn 5.5  2),
+    ]
+    t10 = TT.new(matrix: matrix)
+    assert_raise(TT::DuplicateCellError) { t10.reform('1', '3', '2') }
+  end
+
+  def test_set_title
+    @t01.set_title
+    assert_equal( ['0123', '45', '6789'], @t01.titles)
+    matrix = [
+      ['abcd', 'ef', 'ghij'],
+      ['a   ', 'e ', 'g   '],
+      ['a cd', ' f', 'gh j'],
+      ['abcd', '  ', '    '],
+      ['    ', '  ', ' hij']
+    ]
+    @t01 = TT.new(matrix: matrix)
+  end
+
+end
+