tty-table 0.1.0

data/spec/unit/initialize_spec.rb

@@ -0,0 +1,88 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table, '#initialize' do
+  let(:header) { ['Header1', 'Header2'] }
+  let(:rows)   { [['a1', 'a2'], ['b1', 'b2']] }
+
+  it { is_expected.to be_kind_of(Enumerable) }
+
+  it { is_expected.to be_kind_of(Comparable) }
+
+  it { expect(Enumerable === subject).to eq(true) }
+
+  context 'with rows only' do
+    it 'initializes with rows as arguments' do
+      table = TTY::Table[*rows]
+      expect(table.to_a).to eql(rows)
+    end
+
+    it 'initializes with rows' do
+      table = TTY::Table.new rows
+      expect(table.to_a).to eql(rows)
+    end
+
+    it 'initializes table rows as an option' do
+      table = TTY::Table.new rows: rows
+      expect(table.to_a).to eq(rows)
+    end
+
+    it 'initializes table rows in a block with param' do
+      table = TTY::Table.new do |t|
+        t << rows[0]
+        t << rows[1]
+      end
+      expect(table.to_a).to eq(rows)
+    end
+
+    it 'initializes table and adds rows' do
+      table = TTY::Table.new
+      table << rows[0]
+      table << rows[1]
+      expect(table.to_a).to eq(rows)
+    end
+
+    it 'chains rows' do
+      table = TTY::Table.new
+      table << rows[0] << rows[1]
+      expect(table.to_a).to eq(rows)
+    end
+
+    context 'with data as hash' do
+      let(:data) { [ {'Header1' => ['a1','a2'], 'Header2' => ['b1', 'b2'] }] }
+
+      it 'extracts rows' do
+        table = TTY::Table.new data
+        expect(table.to_a).to include rows[0]
+        expect(table.to_a).to include rows[1]
+      end
+
+      it 'extracts header' do
+        table = TTY::Table.new data
+        expect(table.header).to include header[0]
+        expect(table.header).to include header[1]
+      end
+    end
+  end
+
+  context 'with header and rows' do
+    it 'initializes header as an option' do
+      table = TTY::Table.new header: header
+      expect(table.header).to eql(header)
+    end
+
+    it 'initializes table rows as an argument' do
+      table = TTY::Table.new header, rows
+      expect(table.header).to eql(header)
+      expect(table.rows).to eql(rows)
+    end
+  end
+
+  context 'coercion' do
+    it 'converts row arguments from hash to array' do
+      table = TTY::Table.new rows: {a: 1, b: 2}
+      expect(table.to_a).to include [:a, 1 ]
+    end
+  end
+end

data/spec/unit/operation/alignment_set/call_spec.rb

@@ -0,0 +1,39 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Operation::AlignmentSet, '#call' do
+  let(:object) { described_class.new alignments, widths }
+  let(:value)  { 'a1' }
+  let(:field)  { TTY::Table::Field.new(value)}
+
+  subject { object.call(field, 0, 0) }
+
+  context 'aligned with column widths and no alignments' do
+    let(:alignments) { [] }
+    let(:widths) { [4, 4] }
+
+    it { is_expected.to eq("#{value}  ") }
+  end
+
+  context 'aligned with column widths and alignments' do
+    let(:alignments) { [:right, :left] }
+    let(:widths)     { [4, 4] }
+
+    it { is_expected.to eq("  #{value}") }
+  end
+
+  context 'aligned with no column widths and no alignments' do
+    let(:alignments) { [] }
+    let(:widths)     { [] }
+
+    it { is_expected.to eq("#{value}") }
+  end
+
+  context 'aligned with no column widths and alignments' do
+    let(:alignments) { [:right, :left] }
+    let(:widths)     { [] }
+
+    it { is_expected.to eq("#{value}") }
+  end
+end

data/spec/unit/operation/alignment_set/each_spec.rb

@@ -0,0 +1,17 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Operation::AlignmentSet, '#each' do
+  let(:alignments) { [:left, :center, :right] }
+  let(:yields)     { [] }
+  let(:object)     { described_class.new alignments }
+
+  subject { object.each { |alignment| yields << alignment } }
+
+  it 'yields each alignment' do
+    expect { subject }.to change { yields.dup }.
+      from([]).
+      to(alignments)
+  end
+end

data/spec/unit/operation/alignment_set/new_spec.rb

@@ -0,0 +1,27 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Operation::AlignmentSet, '#new' do
+  let(:object) { described_class }
+
+  subject { object.new(argument) }
+
+  context 'with no argument' do
+    let(:argument) { [] }
+
+    it { is_expected.to be_kind_of(Enumerable) }
+
+    it { is_expected.to be_instance_of(object) }
+
+    it { expect(subject.alignments).to eq([]) }
+  end
+
+  context 'with argument' do
+    let(:argument) { [:center, :left] }
+
+    it { is_expected.to be_instance_of(object) }
+
+    it { expect(subject.alignments).to eq(argument) }
+  end
+end

data/spec/unit/operation/alignment_set/to_ary_spec.rb

@@ -0,0 +1,14 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Operation::AlignmentSet, '#to_ary' do
+  let(:argument) { [:center, :left] }
+  let(:object)   { described_class.new argument }
+
+  subject { object.to_ary }
+
+  it { is_expected.to be_instance_of(Array) }
+
+  it { is_expected.to eq(argument) }
+end

data/spec/unit/operation/escape/call_spec.rb

@@ -0,0 +1,16 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Operation::Escape, '#call' do
+  let(:object) { described_class }
+  let(:text)   { "太丸\nゴシ\tック体\r" }
+  let(:field)  { TTY::Table::Field.new(text) }
+
+  subject { object.new }
+
+  it 'changes field value' do
+    subject.call(field, 0, 0)
+    expect(field.value).to eql("太丸\\nゴシ\\tック体\\r")
+  end
+end

data/spec/unit/operation/filter/call_spec.rb

@@ -0,0 +1,17 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Operation::Filter, '#call' do
+  let(:object) { described_class }
+  let(:field)  { TTY::Table::Field.new('a1') }
+  let(:filter) { Proc.new { |val, row, col| 'new' } }
+  let(:value)  { 'new' }
+
+  subject { object.new(filter) }
+
+  it 'changes field value' do
+    subject.call(field, 0, 0)
+    expect(field.value).to eql(value)
+  end
+end

data/spec/unit/operation/truncation/call_spec.rb

@@ -0,0 +1,32 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Operation::Truncation, '#call' do
+  let(:object) { described_class.new column_widths }
+  let(:text)   { '太丸ゴシック体' }
+  let(:field)  { TTY::Table::Field.new(text) }
+
+  context 'without column width' do
+    let(:column_widths) { [] }
+
+    it "truncates string" do
+      object.call(field, 0, 0)
+      expect(field.value).to eql(text)
+    end
+  end
+
+  context 'with column width ' do
+    let(:column_widths) { [3, 6] }
+
+    it "truncates string for 0 column" do
+      object.call(field, 0, 0)
+      expect(field.value).to eql('太丸…')
+    end
+
+    it "truncates string for 1 column" do
+      object.call(field, 0, 1)
+      expect(field.value).to eql('太丸ゴシッ…')
+    end
+  end
+end

data/spec/unit/operation/wrapped/call_spec.rb

@@ -0,0 +1,33 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Operation::Wrapped, '#call' do
+  let(:padding) { TTY::Table::Padder.parse }
+  let(:object) { described_class.new(column_widths, padding) }
+  let(:text)   { 'ラドクリフ、マラソン五輪代表に1万m出場にも含み' }
+  let(:field)  { TTY::Table::Field.new(text) }
+
+  context 'without column width' do
+    let(:column_widths) { [] }
+
+    it "doesn't wrap string" do
+      object.call(field, 0, 0)
+      expect(field.value).to eql(text)
+    end
+  end
+
+  context 'with column width' do
+    let(:column_widths) { [12, 14] }
+
+    it "wraps string for 0 column" do
+      object.call(field, 0, 0)
+      expect(field.value).to eql("ラドクリフ、マラソン五輪\n代表に1万m出場にも含み")
+    end
+
+    it "wraps string for 1 column" do
+      object.call(field, 0, 1)
+      expect(field.value).to eql("ラドクリフ、マラソン五輪代表\nに1万m出場にも含み")
+    end
+  end
+end

data/spec/unit/operations/new_spec.rb

@@ -0,0 +1,30 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Operations, '#new' do
+  let(:object) { described_class }
+  let(:row)    { [1,2,3] }
+  let(:table)  { TTY::Table.new :rows => [row] }
+  let(:callable) {
+    Class.new do
+      def call(val, row, col)
+        val.value= val.value + 1
+      end
+    end
+  }
+  let(:instance) { callable.new }
+
+  subject { object.new table }
+
+  before { subject.add(:alignment, instance) }
+
+  it 'stores away operations' do
+    expect(subject.operations[:alignment]).to include(instance)
+  end
+
+  it 'runs selected operations' do
+    subject.run_operations(:alignment)
+    expect(table.data[0]).to eql([2,3,4])
+  end
+end

data/spec/unit/options/access_spec.rb

@@ -0,0 +1,14 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+# describe TTY::Table::Options, 'options' do
+#   let(:object) { described_class }
+# 
+#   subject { described_class.new({'a' => 1, :b => 2}) }
+# 
+#   it '' do
+#     pending
+#     expect(subject[:a]).to eql(1)
+#   end
+# end

data/spec/unit/options_spec.rb

@@ -0,0 +1,25 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table, 'options' do
+  let(:rows)   { [['a1', 'a2'], ['b1', 'b2']] }
+  let(:widths) { nil }
+  let(:aligns) { [] }
+  let(:object) { described_class }
+  let(:options) {
+    {
+      column_widths: widths,
+      column_aligns: aligns,
+      renderer: :basic
+    }
+  }
+
+  subject(:table) { object.new rows, options }
+
+  it { expect(table.header).to be_nil }
+
+  it { expect(table.rows).to eq(rows) }
+
+  it { expect(table.orientation).to be_kind_of TTY::Table::Orientation::Horizontal }
+end

data/spec/unit/orientation_spec.rb

@@ -0,0 +1,145 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table, 'orientation' do
+  let(:header) { ['h1', 'h2', 'h3'] }
+  let(:rows) { [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3']] }
+  let(:options) { { :orientation => orientation } }
+
+  subject { described_class.new(header, rows, options) }
+
+  context 'when illegal option' do
+    let(:orientation) { :accross }
+
+    it { expect { subject }.to raise_error(TTY::Table::InvalidOrientationError) }
+  end
+
+  context 'when horizontal' do
+    let(:orientation) { :horizontal }
+
+    it { expect(subject.orientation).to be_kind_of TTY::Table::Orientation }
+
+    it { expect(subject.orientation.name).to eql(:horizontal) }
+
+    it { expect(subject.header).to eql(header) }
+
+    it 'preserves original rows' do
+      expect(subject.to_a).to eql(subject.data)
+    end
+
+    context 'without border' do
+      it 'displays table' do
+        expect(subject.to_s).to eq <<-EOS.normalize
+          h1 h2 h3
+          a1 a2 a3
+          b1 b2 b3
+        EOS
+      end
+    end
+
+    context 'with border' do
+      let(:renderer) { :ascii }
+
+      it 'diplays table' do
+        expect(subject.render(renderer)).to eq <<-EOS.normalize
+         +--+--+--+
+         |h1|h2|h3|
+         +--+--+--+
+         |a1|a2|a3|
+         |b1|b2|b3|
+         +--+--+--+
+        EOS
+      end
+    end
+  end
+
+  context 'when vertical' do
+    let(:orientation) { :vertical }
+
+    it { expect(subject.orientation).to be_kind_of TTY::Table::Orientation }
+
+    it { expect(subject.orientation.name).to eql :vertical }
+
+    it { expect(subject.header).to be_empty }
+
+    context 'with header' do
+      it 'rotates original rows' do
+        rotated_rows = [['h1','a1'],['h2','a2'],['h3','a3'], ['h1','b1'],['h2','b2'],['h3','b3']]
+        expect(subject.to_a).to eql rotated_rows
+      end
+
+      context 'without border' do
+        it 'displays table' do
+          expect(subject.to_s).to eq <<-EOS.normalize
+            h1 a1
+            h2 a2
+            h3 a3
+            h1 b1
+            h2 b2
+            h3 b3
+          EOS
+        end
+      end
+
+      context 'with border' do
+        let(:renderer) { :ascii }
+
+        it 'diplays table' do
+          expect(subject.render(renderer)).to eq <<-EOS.normalize
+          +--+--+
+          |h1|a1|
+          |h2|a2|
+          |h3|a3|
+          |h1|b1|
+          |h2|b2|
+          |h3|b3|
+          +--+--+
+          EOS
+        end
+      end
+    end
+
+    context 'without header' do
+      let(:header) { nil }
+
+      it 'rotates original rows' do
+        rotated_rows = [
+          ['1','a1'],['2','a2'],['3','a3'],
+          ['1','b1'],['2','b2'],['3','b3']
+        ]
+        expect(subject.to_a).to eql rotated_rows
+      end
+
+      context 'without border' do
+        it 'displays table' do
+          expect(subject.to_s).to eq <<-EOS.normalize
+            1 a1
+            2 a2
+            3 a3
+            1 b1
+            2 b2
+            3 b3
+          EOS
+        end
+      end
+
+      context 'with border' do
+        let(:renderer) { :ascii }
+
+        it 'diplays table' do
+          expect(subject.render(renderer)).to eq <<-EOS.normalize
+          +-+--+
+          |1|a1|
+          |2|a2|
+          |3|a3|
+          |1|b1|
+          |2|b2|
+          |3|b3|
+          +-+--+
+          EOS
+        end
+      end
+    end
+  end
+end # orientation

data/spec/unit/padder/parse_spec.rb

@@ -0,0 +1,45 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Padder, '#parse' do
+  let(:object) { described_class }
+
+  subject { object.parse(value).padding }
+
+  context 'when self' do
+    let(:value) { described_class.new([]) }
+
+    it { expect(subject).to eq([]) }
+  end
+
+  context 'when number' do
+    let(:value) { 5 }
+
+    it { expect(subject).to eq([5,5,5,5]) }
+  end
+
+  context 'when nil' do
+    let(:value) { nil }
+
+    it { expect(subject).to eq([]) }
+  end
+
+  context 'when 2-element array' do
+    let(:value) { [2,3] }
+
+    it { expect(subject).to eq([2,3,2,3]) }
+  end
+
+  context 'when 4-element array' do
+    let(:value) { [1,2,3,4] }
+
+    it { expect(subject).to eq([1,2,3,4]) }
+  end
+
+  context 'when unkown' do
+    let(:value) { :unkown }
+
+    it { expect { subject }.to raise_error }
+  end
+end

data/spec/unit/padder/to_s_spec.rb

@@ -0,0 +1,14 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Padder, '.to_s' do
+  let(:object) { described_class }
+  let(:value)  { [1,2,3,4] }
+
+  subject { object.parse(value) }
+
+  it 'prints string representation' do
+    expect(subject.to_s).to eq('#<TTY::Table::Padder padding=[1, 2, 3, 4]>')
+  end
+end

data/spec/unit/padding_spec.rb

@@ -0,0 +1,120 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table, 'padding' do
+  let(:header) { ['h1', 'h2', 'h3'] }
+  let(:rows)   { [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3']] }
+  let(:table)  { described_class.new(header, rows) }
+
+  it 'sets specific padding' do
+    expect(table.render(:ascii) { |renderer|
+      renderer.multiline = true
+      renderer.padding.right = 2
+      renderer.padding.top  = 1
+    }).to eq <<-EOS.normalize
+      +----+----+----+
+      |    |    |    |
+      |h1  |h2  |h3  |
+      +----+----+----+
+      |    |    |    |
+      |a1  |a2  |a3  |
+      |    |    |    |
+      |b1  |b2  |b3  |
+      +----+----+----+
+    EOS
+  end
+
+  it 'sets padding for all' do
+    expect(table.render(:ascii) { |renderer|
+      renderer.multiline = true
+      renderer.padding= [1,2,1,2]
+    }).to eq <<-EOS.normalize
+      +------+------+------+
+      |      |      |      |
+      |  h1  |  h2  |  h3  |
+      |      |      |      |
+      +------+------+------+
+      |      |      |      |
+      |  a1  |  a2  |  a3  |
+      |      |      |      |
+      |      |      |      |
+      |  b1  |  b2  |  b3  |
+      |      |      |      |
+      +------+------+------+
+    EOS
+  end
+
+  context 'with column width' do
+    let(:column_widths) { [4,4,4] }
+
+    it 'sets padding for all' do
+      expect(table.render(:ascii) { |renderer|
+        renderer.column_widths = column_widths
+        renderer.multiline = true
+        renderer.padding= [1,2,1,2]
+      }).to eq <<-EOS.normalize
+        +--------+--------+--------+
+        |        |        |        |
+        |  h1    |  h2    |  h3    |
+        |        |        |        |
+        +--------+--------+--------+
+        |        |        |        |
+        |  a1    |  a2    |  a3    |
+        |        |        |        |
+        |        |        |        |
+        |  b1    |  b2    |  b3    |
+        |        |        |        |
+        +--------+--------+--------+
+      EOS
+    end
+  end
+
+  context 'with multi line text' do
+    let(:header) { ['head1', 'head2'] }
+    let(:rows)   { [["Multi\nLine\nContent", "Text\nthat\nwraps",],
+                    ["Some\nother\ntext", 'Simple']] }
+
+    context 'when wrapped' do
+      it 'sets padding for all' do
+        expect(table.render(:ascii) { |renderer|
+          renderer.multiline = true
+          renderer.padding= [1,2,1,2]
+        }).to eq <<-EOS.normalize
+          +-----------+----------+
+          |           |          |
+          |  head1    |  head2   |
+          |           |          |
+          +-----------+----------+
+          |           |          |
+          |  Multi    |  Text    |
+          |  Line     |  that    |
+          |  Content  |  wraps   |
+          |           |          |
+          |           |          |
+          |  Some     |  Simple  |
+          |  other    |          |
+          |  text     |          |
+          |           |          |
+          +-----------+----------+
+        EOS
+      end
+    end
+
+    context 'when escaped' do
+      it 'sets padding for all' do
+        expect(table.render(:ascii) { |renderer|
+          renderer.multiline = false
+          renderer.padding= [0,2,0,2]
+        }).to eq <<-EOS.normalize
+          +------------------------+---------------------+
+          |  head1                 |  head2              |
+          +------------------------+---------------------+
+          |  Multi\\nLine\\nContent  |  Text\\nthat\\nwraps  |
+          |  Some\\nother\\ntext     |  Simple             |
+          +------------------------+---------------------+
+        EOS
+      end
+    end
+  end
+end