tty-table 0.1.0

data/spec/unit/renderer/border_spec.rb

@@ -0,0 +1,104 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Renderer, '#border' do
+  let(:header) { ['h1', 'h2', 'h3'] }
+  let(:rows)   { [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3']] }
+  let(:border) { nil }
+
+  let(:table) { TTY::Table.new(header, rows) }
+
+  subject(:renderer) { described_class.select(type).new(table) }
+
+  context 'when basic renderer' do
+    let(:type)   { :basic }
+    let(:border) { {characters: {'top' => '-'}, style: :red} }
+
+    it 'specifies border in hash' do
+      renderer.border(border)
+      expect(renderer.border.characters['top']).to eql('-')
+    end
+
+    it 'specifies border in characters attribute' do
+      renderer.border.characters = {'top' => '*'}
+      expect(renderer.border.characters['top']).to eql('*')
+    end
+
+    it 'specifies border in block' do
+      renderer.border do
+        mid          '='
+        mid_mid      ' '
+      end
+
+      expect(renderer.render).to eq <<-EOS.normalize
+        h1 h2 h3
+        == == ==
+        a1 a2 a3
+        b1 b2 b3
+      EOS
+    end
+  end
+
+  context 'when ascii renderer' do
+    let(:type) { :ascii }
+
+    it 'specifies border in block' do
+      renderer.border do
+        mid          '='
+        mid_mid      '='
+        mid_left     '='
+        mid_right    '='
+      end
+
+      expect(renderer.render).to eq <<-EOS.normalize
+        +--+--+--+
+        |h1|h2|h3|
+        ==========
+        |a1|a2|a3|
+        |b1|b2|b3|
+        +--+--+--+
+      EOS
+    end
+
+    it 'specifies border as hash' do
+      renderer.border({characters: {
+        'mid'       => '=',
+        'mid_mid'   => '=',
+        'mid_left'  => '=',
+        'mid_right' => '=',
+      }})
+
+      expect(renderer.render).to eq <<-EOS.normalize
+        +--+--+--+
+        |h1|h2|h3|
+        ==========
+        |a1|a2|a3|
+        |b1|b2|b3|
+        +--+--+--+
+      EOS
+    end
+  end
+
+  context 'when unicode renderer' do
+    let(:type) { :unicode }
+
+    it 'specifies border in block' do
+      renderer.border do
+        mid          '='
+        mid_mid      '='
+        mid_left     '='
+        mid_right    '='
+      end
+
+      expect(renderer.render).to eq <<-EOS.normalize
+        ┌──┬──┬──┐
+        │h1│h2│h3│
+        ==========
+        │a1│a2│a3│
+        │b1│b2│b3│
+        └──┴──┴──┘
+      EOS
+    end
+  end
+end # border

data/spec/unit/renderer/render_spec.rb

@@ -0,0 +1,36 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Renderer, '#render' do
+  let(:header) { ['h1', 'h2', 'h3'] }
+  let(:rows)   { [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3']] }
+  let(:table)  { TTY::Table.new(header, rows) }
+
+  subject { described_class.render(table, {}, &block) }
+
+  context 'when default' do
+    let(:renderer)       { double(:renderer).as_null_object }
+    let(:renderer_class) { double(:renderer_class).as_null_object }
+    let(:yielded)        { [] }
+    let(:block)          { proc { |render| yielded << render } }
+
+    before { allow(described_class).to receive(:select).and_return(renderer_class) }
+
+    it 'creates renderer' do
+      subject
+      expect(renderer_class).to have_received(:new).with(table, {})
+    end
+
+    it 'yields renderer' do
+      allow(renderer_class).to receive(:new).and_return(renderer)
+      expect { subject }.to change { yielded}.from([]).to([renderer])
+    end
+
+    it 'calls render' do
+      allow(renderer_class).to receive(:new).and_return(renderer)
+      subject
+      expect(renderer).to have_received(:render)
+    end
+  end
+end

data/spec/unit/renderer/select_spec.rb

@@ -0,0 +1,22 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Renderer, '#select' do
+  let(:klass)    { ::Class.new }
+  let(:instance) { described_class }
+
+  subject { instance.select(renderer) }
+
+  context 'with basic' do
+    let(:renderer) { :basic }
+
+    it { is_expected.to be(TTY::Table::Renderer::Basic) }
+  end
+
+  context 'with unicode' do
+    let(:renderer) { :unicode }
+
+    it { is_expected.to be(TTY::Table::Renderer::Unicode) }
+  end
+end

data/spec/unit/renderer/style_spec.rb

@@ -0,0 +1,72 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Renderer, 'with style' do
+  let(:header) { ['h1', 'h2', 'h3'] }
+  let(:rows)   { [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3']] }
+  let(:table)  { TTY::Table.new(header, rows) }
+  let(:color)  { Pastel.new(enabled: true) }
+
+  subject(:renderer) { described_class.select(type).new(table) }
+
+  before { allow(Pastel).to receive(:new).and_return(color) }
+
+  context 'when basic renderer' do
+    let(:type) { :basic }
+
+    it "sets through hash" do
+      renderer.border(style: :red)
+      expect(renderer.border.style).to eql(:red)
+    end
+
+    it "sets through attribute" do
+      renderer.border.style = :red
+      expect(renderer.border.style).to eql :red
+    end
+
+    it "renders without color" do
+      expect(renderer.render).to eq <<-EOS.normalize
+        h1 h2 h3
+        a1 a2 a3
+        b1 b2 b3
+      EOS
+    end
+  end
+
+  context 'when ascii renderer' do
+    let(:type)  { :ascii }
+    let(:red)   { "\e[31m" }
+    let(:clear) { "\e[0m" }
+
+    it "renders border in color" do
+      renderer.border.style= :red
+      expect(renderer.render).to eq <<-EOS.normalize
+        #{red}+--+--+--+#{clear}
+        #{red}|#{clear}h1#{red}|#{clear}h2#{red}|#{clear}h3#{red}|#{clear}
+        #{red}+--+--+--+#{clear}
+        #{red}|#{clear}a1#{red}|#{clear}a2#{red}|#{clear}a3#{red}|#{clear}
+        #{red}|#{clear}b1#{red}|#{clear}b2#{red}|#{clear}b3#{red}|#{clear}
+        #{red}+--+--+--+#{clear}
+      EOS
+    end
+  end
+
+  context 'when unicode renderer' do
+    let(:type)  { :unicode }
+    let(:red)   { "\e[31m" }
+    let(:clear) { "\e[0m" }
+
+    it "renders each row" do
+      renderer.border.style= :red
+      expect(renderer.render).to eq <<-EOS.normalize
+        #{red}┌──┬──┬──┐#{clear}
+        #{red}│#{clear}h1#{red}│#{clear}h2#{red}│#{clear}h3#{red}│#{clear}
+        #{red}├──┼──┼──┤#{clear}
+        #{red}│#{clear}a1#{red}│#{clear}a2#{red}│#{clear}a3#{red}│#{clear}
+        #{red}│#{clear}b1#{red}│#{clear}b2#{red}│#{clear}b3#{red}│#{clear}
+        #{red}└──┴──┴──┘#{clear}
+      EOS
+    end
+  end
+end

data/spec/unit/renderer/unicode/indentation_spec.rb

@@ -0,0 +1,41 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Renderer::Unicode, 'indentation' do
+  let(:header)  { ['h1', 'h2', 'h3'] }
+  let(:rows)    { [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3']] }
+  let(:table)   { TTY::Table.new(header, rows) }
+  let(:indent)  { 2 }
+  let(:options) { {indent: indent } }
+
+  subject(:renderer) { described_class.new(table, options)}
+
+  context 'when default' do
+    it 'indents by value' do
+      expect(renderer.render).to eql <<-EOS.chomp
+  ┌──┬──┬──┐
+  │h1│h2│h3│
+  ├──┼──┼──┤
+  │a1│a2│a3│
+  │b1│b2│b3│
+  └──┴──┴──┘
+      EOS
+    end
+  end
+
+  context 'when each row' do
+    it 'indents by value' do
+      renderer.border.separator = :each_row
+      expect(renderer.render).to eql <<-EOS.chomp
+  ┌──┬──┬──┐
+  │h1│h2│h3│
+  ├──┼──┼──┤
+  │a1│a2│a3│
+  ├──┼──┼──┤
+  │b1│b2│b3│
+  └──┴──┴──┘
+      EOS
+    end
+  end
+end

data/spec/unit/renderer/unicode/padding_spec.rb

@@ -0,0 +1,61 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Renderer::Unicode, 'padding' do
+  let(:header) { ['Field', 'Type', 'Null', 'Key', 'Default', 'Extra'] }
+  let(:rows)   { [['id', 'int(11)', 'YES', 'nil', 'NULL', '']] }
+  let(:table)  { TTY::Table.new(header, rows) }
+
+  subject(:renderer) { described_class.new(table, options) }
+
+  context 'with left & right padding' do
+    let(:options) { {padding: [0,1,0,1]} }
+
+    it 'pads each field' do
+      expect(renderer.render).to eql <<-EOS.chomp
+┌───────┬─────────┬──────┬─────┬─────────┬───────┐
+│ Field │ Type    │ Null │ Key │ Default │ Extra │
+├───────┼─────────┼──────┼─────┼─────────┼───────┤
+│ id    │ int(11) │ YES  │ nil │ NULL    │       │
+└───────┴─────────┴──────┴─────┴─────────┴───────┘
+      EOS
+    end
+  end
+
+  context 'with top & bottom padding' do
+    let(:options) { {padding: [1,0,1,0], multiline: true} }
+
+    it 'pads each field' do
+      expect(renderer.render).to eql <<-EOS.chomp
+┌─────┬───────┬────┬───┬───────┬─────┐
+│     │       │    │   │       │     │
+│Field│Type   │Null│Key│Default│Extra│
+│     │       │    │   │       │     │
+├─────┼───────┼────┼───┼───────┼─────┤
+│     │       │    │   │       │     │
+│id   │int(11)│YES │nil│NULL   │     │
+│     │       │    │   │       │     │
+└─────┴───────┴────┴───┴───────┴─────┘
+      EOS
+    end
+  end
+
+  context 'with full padding' do
+    let(:options) { {padding: [1,1,1,1], multiline: true} }
+
+    it 'pads each field' do
+      expect(renderer.render).to eql <<-EOS.chomp
+┌───────┬─────────┬──────┬─────┬─────────┬───────┐
+│       │         │      │     │         │       │
+│ Field │ Type    │ Null │ Key │ Default │ Extra │
+│       │         │      │     │         │       │
+├───────┼─────────┼──────┼─────┼─────────┼───────┤
+│       │         │      │     │         │       │
+│ id    │ int(11) │ YES  │ nil │ NULL    │       │
+│       │         │      │     │         │       │
+└───────┴─────────┴──────┴─────┴─────────┴───────┘
+      EOS
+    end
+  end
+end

data/spec/unit/renderer/unicode/render_spec.rb

@@ -0,0 +1,68 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Renderer::Unicode, '#render' do
+  let(:header) { ['h1', 'h2', 'h3'] }
+  let(:rows) { [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3']] }
+  let(:table) { TTY::Table.new header, rows }
+
+  subject(:renderer) { described_class.new(table) }
+
+  context 'with rows only' do
+    let(:table) { TTY::Table.new rows }
+
+    it 'display table rows' do
+      expect(renderer.render).to eq <<-EOS.normalize
+        ┌──┬──┬──┐
+        │a1│a2│a3│
+        │b1│b2│b3│
+        └──┴──┴──┘
+      EOS
+    end
+  end
+
+  context 'with header' do
+    it 'displays table with header' do
+      expect(renderer.render).to eq <<-EOS.normalize
+        ┌──┬──┬──┐
+        │h1│h2│h3│
+        ├──┼──┼──┤
+        │a1│a2│a3│
+        │b1│b2│b3│
+        └──┴──┴──┘
+      EOS
+    end
+  end
+
+  context 'with short header' do
+    let(:header) { ['h1', 'h2'] }
+    let(:rows)   { [['aaa1', 'a2'], ['b1', 'bb1']] }
+
+    it 'displays table according to widths' do
+      expect(renderer.render).to eq <<-EOS.normalize
+        ┌────┬───┐
+        │h1  │h2 │
+        ├────┼───┤
+        │aaa1│a2 │
+        │b1  │bb1│
+        └────┴───┘
+      EOS
+    end
+  end
+
+  context 'with long header' do
+    let(:header) { ['header1', 'header2', 'header3'] }
+
+    it 'header greater than row sizes' do
+      expect(renderer.render).to eq <<-EOS.normalize
+        ┌───────┬───────┬───────┐
+        │header1│header2│header3│
+        ├───────┼───────┼───────┤
+        │a1     │a2     │a3     │
+        │b1     │b2     │b3     │
+        └───────┴───────┴───────┘
+      EOS
+    end
+  end
+end

data/spec/unit/renderer/unicode/separator_spec.rb

@@ -0,0 +1,26 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Renderer::Unicode, 'with separator' do
+  let(:header) { ['h1', 'h2', 'h3'] }
+  let(:rows)   { [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3']] }
+  let(:table)  { TTY::Table.new(header, rows) }
+
+  let(:object) { described_class.new table }
+
+  subject(:renderer) { object }
+
+  it "renders each row" do
+    renderer.border.separator= :each_row
+    expect(renderer.render).to eq <<-EOS.normalize
+      ┌──┬──┬──┐
+      │h1│h2│h3│
+      ├──┼──┼──┤
+      │a1│a2│a3│
+      ├──┼──┼──┤
+      │b1│b2│b3│
+      └──┴──┴──┘
+    EOS
+  end
+end

data/spec/unit/renderer_spec.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table, '#renderer' do
+  let(:object) { described_class }
+  let(:header) { ['h1', 'h2'] }
+  let(:rows)   { [['a1', 'a2'], ['b1', 'b2']] }
+
+  subject(:table) { object.new(header, rows).renderer }
+
+  it 'creates new renderer' do
+    expect(subject).to be_kind_of(TTY::Table::Renderer::Basic)
+  end
+
+  it 'chains calls on renderer' do
+    expect(subject.render).to eql("h1 h2\na1 a2\nb1 b2")
+  end
+end

data/spec/unit/rotate_spec.rb

@@ -0,0 +1,86 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table, '#rotate' do
+  let(:header) { ['h1', 'h2', 'h3'] }
+  let(:rows) { [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3']] }
+
+  subject(:table) { described_class.new(header, rows) }
+
+  before { table.orientation = :horizontal }
+
+  context 'with default' do
+    context 'without header' do
+      let(:header) { nil }
+
+      it 'preserves orientation' do
+        expect(table.header).to be_nil
+        expect(table.rotate.to_a).to eql rows
+      end
+    end
+
+    context 'with header' do
+      it 'preserves orientation' do
+        expect(table.rotate.to_a).to eql [header] + rows
+      end
+    end
+  end
+
+  context 'with no header' do
+    let(:header) { nil }
+
+    it 'rotates the rows' do
+      table.orientation = :vertical
+      expect(table.rotate.to_a).to eql [
+        ['1', 'a1'],
+        ['2', 'a2'],
+        ['3', 'a3'],
+        ['1', 'b1'],
+        ['2', 'b2'],
+        ['3', 'b3'],
+      ]
+      expect(table.header).to be_nil
+    end
+
+    it 'rotates the rows back' do
+      table.orientation = :vertical
+      table.rotate
+      table.orientation = :horizontal
+      expect(table.rotate.to_a).to eql rows
+      expect(table.header).to eql header
+    end
+
+    it 'roates the output' do
+      expect(table.to_s).to eq("a1 a2 a3\nb1 b2 b3")
+      table.orientation = :vertical
+      table.rotate
+      expect(table.to_s).to eq("1 a1\n2 a2\n3 a3\n1 b1\n2 b2\n3 b3")
+    end
+  end
+
+  context 'with header' do
+    it 'rotates the rows and merges header' do
+      table.orientation = :vertical
+      expect(table.rotate.to_a).to eql [
+        ['h1', 'a1'],
+        ['h2', 'a2'],
+        ['h3', 'a3'],
+        ['h1', 'b1'],
+        ['h2', 'b2'],
+        ['h3', 'b3'],
+      ]
+      expect(table.header).to be_empty
+    end
+
+    it 'rotates the rows and header back' do
+      table.orientation = :vertical
+      table.rotate
+      expect(table.orientation).to be_a TTY::Table::Orientation::Vertical
+
+      table.orientation = :horizontal
+      expect(table.rotate.to_a).to eql [header] + rows
+      expect(table.header).to eql header
+    end
+  end
+end

data/spec/unit/row/access_spec.rb

@@ -0,0 +1,25 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Row, '#access' do
+  let(:object) { described_class.new [] }
+
+  before { object[attribute] = value}
+
+  subject { object[attribute] }
+
+  context 'when integer' do
+    let(:attribute) { 0 }
+    let(:value) { 1 }
+
+    it { is_expected.to eq(1) }
+  end
+
+  context 'when symbol' do
+    let(:attribute) { :id }
+    let(:value) { 1 }
+
+    it { is_expected.to eq(1) }
+  end
+end

data/spec/unit/row/call_spec.rb

@@ -0,0 +1,45 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Row, '#call' do
+  let(:object) { described_class.new(data) }
+
+  subject { object[attribute] }
+
+  context 'when integer' do
+    let(:data) { ['a', 'b'] }
+
+    let(:attribute) { 1 }
+
+    it { is_expected.to eql('b') }
+  end
+
+  context 'when symbol' do
+    let(:data) { {:id => 1} }
+
+    context 'when hash access' do
+      let(:attribute) { :id }
+
+      it { is_expected.to eql(1) }
+    end
+
+    context 'when array access' do
+      let(:attribute) { 0 }
+
+      it { is_expected.to eql(1) }
+    end
+  end
+
+  context 'when unkown attribute' do
+    let(:data) { {:id => 1} }
+
+    let(:attribute) { :other }
+
+    specify {
+      expect {
+        subject
+      }.to raise_error(TTY::Table::UnknownAttributeError)
+    }
+  end
+end

data/spec/unit/row/data_spec.rb

@@ -0,0 +1,26 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Row, '#data' do
+  let(:object) { described_class.new data, header }
+  let(:data) { ['a'] }
+
+  subject { object.to_hash }
+
+  context 'without attributes' do
+    let(:header) { nil }
+
+    it { is_expected.to be_instance_of(Hash) }
+
+    it { is_expected.to eql(0 => 'a') }
+  end
+
+  context 'with attributes' do
+    let(:header) { [:id] }
+
+    it { is_expected.to be_instance_of(Hash) }
+
+    it { is_expected.to eql(id: 'a') }
+  end
+end

data/spec/unit/row/each_spec.rb

@@ -0,0 +1,31 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Row, '#new' do
+  let(:yields) { [] }
+  let(:value)  { 'a1' }
+  let(:header) { ['Header1']}
+  let(:row)    { [ value ] }
+  let(:object) { described_class.new row, header }
+
+  context 'with block' do
+    subject { object.each { |field| yields << field } }
+
+    it 'yields only fields' do
+      subject
+      yields.each { |field| expect(field).to be_instance_of(value.class) }
+    end
+
+    it 'yields rows with expected attributes' do
+      subject
+      yields.each { |field| expect(field).to eql(value) }
+    end
+
+    it 'yields each row' do
+      expect { subject }.to change { yields }.
+        from( [] ).
+        to( yields )
+    end
+  end
+end