tty-table 0.1.0

data/spec/unit/properties_spec.rb

@@ -0,0 +1,25 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table, 'properties' do
+  let(:rows) {[['a1', 'a2', 'a3'], ['b1', 'b2', 'c3']] }
+
+  subject(:table) { described_class.new rows }
+
+  it { expect(table.width).to eq(6) }
+
+  it { expect(table.row_size).to eq(2) }
+
+  it { expect(table.column_size).to eq(3) }
+
+  it { expect(table.size).to eq([2,3]) }
+
+  context 'no size' do
+    let(:rows) { []  }
+
+    it { expect(table.row_size).to eq(0) }
+
+    it { expect(table.column_size).to eq(0) }
+  end
+end

data/spec/unit/render_spec.rb

@@ -0,0 +1,63 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table, '#render' do
+  let(:object) { described_class }
+  let(:header) { ['h1', 'h2'] }
+  let(:rows)   { [['a1', 'a2'], ['b1', 'b2']] }
+  let(:color)  { Pastel.new(enabled: true) }
+  let(:basic_renderer)   { TTY::Table::Renderer::Basic }
+  let(:ascii_renderer)   { TTY::Table::Renderer::ASCII }
+
+  subject(:table) { object.new header, rows }
+
+  before { allow(Pastel).to receive(:new).and_return(color) }
+
+  it { is_expected.to respond_to(:render) }
+
+  context 'with block' do
+    it 'allows to modify renderer in a block' do
+      expected = nil
+      block = lambda { |renderer| expected = renderer }
+      table.render(&block)
+      expect(expected).to be_kind_of(basic_renderer)
+    end
+
+    it 'sets renderer as block parameter' do
+      expected = nil
+      block = lambda { |renderer| expected = renderer }
+      table.render(:ascii, &block)
+      expect(expected).to be_kind_of(ascii_renderer)
+    end
+
+    it 'sets parameter on renderer' do
+      result = table.render :ascii do |renderer|
+        renderer.border.style = :red
+      end
+      expect(result).to eq <<-EOS.normalize
+        \e[31m+--+--+\e[0m
+        \e[31m|\e[0mh1\e[31m|\e[0mh2\e[31m|\e[0m
+        \e[31m+--+--+\e[0m
+        \e[31m|\e[0ma1\e[31m|\e[0ma2\e[31m|\e[0m
+        \e[31m|\e[0mb1\e[31m|\e[0mb2\e[31m|\e[0m
+        \e[31m+--+--+\e[0m
+      EOS
+    end
+  end
+
+  context 'with params' do
+    it 'sets params without renderer' do
+      allow(TTY::Table::Renderer).to receive(:render)
+      table.render(:basic)
+      expect(TTY::Table::Renderer).to have_received(:render).
+        with(table, {renderer: :basic})
+    end
+
+    it 'sets params with renderer' do
+      allow(TTY::Table::Renderer).to receive(:render)
+      table.render
+      expect(TTY::Table::Renderer).to have_received(:render).with(table, {})
+    end
+  end
+end

data/spec/unit/render_with_spec.rb

@@ -0,0 +1,106 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table, '#render_with' do
+  let(:header) { ['h1', 'h2', 'h3'] }
+  let(:rows)   { [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3']] }
+  let(:table)  { described_class.new header, rows }
+  let(:color)  { Pastel.new(enabled: true) }
+
+  before { allow(Pastel).to receive(:new).and_return(color) }
+
+  context 'with invalid border class' do
+    it "doesn't inherit from TTY::Table::Border" do
+      expect { table.render_with String }.to raise_error(TTY::Table::TypeError)
+    end
+
+    it "doesn't implement def_border" do
+      klass = Class.new(TTY::Table::Border)
+      expect { table.render_with klass }.
+        to raise_error(TTY::Table::NoImplementationError)
+    end
+  end
+
+  context 'with complete border' do
+    before {
+      class MyBorder < TTY::Table::Border
+        def_border do
+          top          '='
+          top_mid      '*'
+          top_left     '*'
+          top_right    '*'
+          bottom       '='
+          bottom_mid   '*'
+          bottom_left  '*'
+          bottom_right '*'
+          mid          '='
+          mid_mid      '*'
+          mid_left     '*'
+          mid_right    '*'
+          left         '$'
+          center       '$'
+          right        '$'
+        end
+      end
+    }
+
+    it 'displays custom border' do
+      expect(table.render_with(MyBorder)).to eq <<-EOS.normalize
+        *==*==*==*
+        $h1$h2$h3$
+        *==*==*==*
+        $a1$a2$a3$
+        $b1$b2$b3$
+        *==*==*==*
+      EOS
+    end
+  end
+
+  context 'with incomplete border' do
+    before {
+      class MyBorder < TTY::Table::Border
+        def_border do
+          bottom       ' '
+          bottom_mid   '*'
+          bottom_left  '*'
+          bottom_right '*'
+          left         '$'
+          center       '$'
+          right        '$'
+        end
+      end
+    }
+
+    it 'displays border' do
+      expect(table.render_with(MyBorder)).to eq <<-EOS.normalize
+        $h1$h2$h3$
+        $a1$a2$a3$
+        $b1$b2$b3$
+        *  *  *  *
+      EOS
+    end
+  end
+
+  context 'with renderer' do
+    before {
+      class MyBorder < TTY::Table::Border
+        def_border do
+          left  '|'
+          right '|'
+        end
+      end
+    }
+
+    it 'displays border' do
+      result = table.render_with MyBorder do |renderer|
+        renderer.border.style = :red
+      end
+      expect(result).to eq <<-EOS.normalize
+        \e[31m|\e[0mh1h2h3\e[31m|\e[0m
+        \e[31m|\e[0ma1a2a3\e[31m|\e[0m
+        \e[31m|\e[0mb1b2b3\e[31m|\e[0m
+      EOS
+    end
+  end
+end # render_with

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

@@ -0,0 +1,41 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Renderer::ASCII, '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/ascii/padding_spec.rb

@@ -0,0 +1,61 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Renderer::ASCII, '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/ascii/render_spec.rb

@@ -0,0 +1,68 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Renderer::ASCII, '#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 'only rows' 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/ascii/resizing_spec.rb

@@ -0,0 +1,114 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Renderer::ASCII, 'resizing' 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, options) }
+
+  context 'when expanding' do
+    context 'even columns' do
+      let(:options) { {width: 16, resize: true} }
+
+      it 'resizes each column' do
+        expect(renderer.render).to eql <<-EOS.normalize
+        +----+----+----+
+        |h1  |h2  |h3  |
+        +----+----+----+
+        |a1  |a2  |a3  |
+        |b1  |b2  |b3  |
+        +----+----+----+
+        EOS
+      end
+    end
+
+    context 'even columns with extra width' do
+      let(:header)  { ['h1', 'h2', 'h3', 'h4'] }
+      let(:rows)    { [['a1','a2','a3','a4'], ['b1','b2','b3','b4']] }
+      let(:options) { {width: 21, resize: true} }
+
+      it 'resizes each column' do
+        expect(renderer.render).to eql <<-EOS.normalize
+         +----+----+----+----+
+         |h1  |h2  |h3  |h4  |
+         +----+----+----+----+
+         |a1  |a2  |a3  |a4  |
+         |b1  |b2  |b3  |b4  |
+         +----+----+----+----+
+        EOS
+      end
+    end
+
+    context 'uneven columns' do
+      let(:header)  { ['h1', 'h2', 'h3'] }
+      let(:rows)    { [['aaa1', 'aa2', 'aaaaaaa3'], ['b1', 'b2', 'b3']] }
+      let(:options) { {width: 32, resize: true} }
+
+      it 'resizes each column' do
+        expect(renderer.render).to eql <<-EOS.normalize
+        +---------+-------+------------+
+        |h1       |h2     |h3          |
+        +---------+-------+------------+
+        |aaa1     |aa2    |aaaaaaa3    |
+        |b1       |b2     |b3          |
+        +---------+-------+------------+
+        EOS
+      end
+    end
+  end
+
+  context 'when shrinking' do
+    let(:header)  { ['head1', 'head2'] }
+    let(:rows)    { [['aaaa1','aaaa2',], ['bbbb1','bbbb2']] }
+
+    context 'even columns' do
+      let(:options) { {width: 7, resize: true} }
+
+      it 'resizes each column' do
+        expect(renderer.render).to eql <<-EOS.normalize
+         +--+--+
+         |h…|h…|
+         +--+--+
+         |a…|a…|
+         |b…|b…|
+         +--+--+
+        EOS
+      end
+    end
+
+    context 'even columns with extra width' do
+      let(:options) { {width: 8, resize: true} }
+
+      it 'resizes each column' do
+        expect(renderer.render).to eql <<-EOS.normalize
+         +---+--+
+         |he…|h…|
+         +---+--+
+         |aa…|a…|
+         |bb…|b…|
+         +---+--+
+        EOS
+      end
+    end
+
+    context 'uneven columns' do
+      let(:header)  { ['head1', 'head2', 'head3'] }
+      let(:rows)    { [['aaa1', 'aa2', 'aaaaaaa3'], ['b1', 'b2', 'b3']] }
+      let(:options) { {width: 15, resize: true} }
+
+      it 'resizes each column' do
+        expect(renderer.render).to eql <<-EOS.normalize
+         +---+---+-----+
+         |he…|he…|head3|
+         +---+---+-----+
+         |aa…|aa2|aaaa…|
+         |b1 |b2 |b3   |
+         +---+---+-----+
+        EOS
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Renderer::ASCII, '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 }
+
+  context 'when ascii' do
+    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
+end

data/spec/unit/renderer/basic/alignment_spec.rb

@@ -0,0 +1,88 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Renderer::Basic, 'alignment' do
+  let(:header)  { ['h1', 'h2', 'h3'] }
+  let(:rows)    { [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3']] }
+  let(:options) { { column_aligns: column_aligns } }
+  let(:table)   { TTY::Table.new(header, rows) }
+
+  subject(:renderer) { described_class.new table, options }
+
+  context 'with default' do
+    let(:header)        { ['h1', 'h2'] }
+    let(:rows)          { [['aaaaa', 'a'], ['b', 'bbbbb']] }
+    let(:column_aligns) { nil }
+
+    it 'aligns left by default' do
+      expect(renderer.render).to eql <<-EOS.normalize
+        h1    h2   
+        aaaaa a    
+        b     bbbbb
+      EOS
+    end
+  end
+
+  context 'with different headers' do
+    let(:header)        { ['header1', 'head2', 'h3'] }
+    let(:column_aligns) { [:left, :center, :right] }
+
+    it 'aligns headers' do
+      expect(renderer.render).to eql <<-EOS.normalize
+        header1 head2 h3
+        a1       a2   a3
+        b1       b2   b3
+      EOS
+    end
+  end
+
+  context 'with different aligns' do
+    let(:header)         { nil }
+    let(:rows)           { [['aaaaa', 'a'], ['b', 'bbbbb']] }
+    let(:column_aligns)  { [:left, :right] }
+
+    it 'aligns table rows' do
+      expect(renderer.render.to_s).to eql <<-EOS.normalize
+        aaaaa     a
+        b     bbbbb
+      EOS
+    end
+  end
+
+  context 'with individual field aligns' do
+    let(:header)        { ['header1', 'header2', 'header3'] }
+    let(:column_aligns) { [:left, :center, :right] }
+    let(:options)       { {column_aligns: column_aligns} }
+    let(:table) {
+      TTY::Table.new header: header do |t|
+        t << ['a1', 'a2', 'a3']
+        t << ['b1', {value: 'b2', align: :right}, 'b3']
+        t << ['c1', 'c2', {value: 'c3', align: :center}]
+      end
+    }
+
+    it "takes individual fields over global aligns" do
+      expect(renderer.render).to eq <<-EOS.normalize
+        header1 header2 header3
+        a1        a2         a3
+        b1           b2      b3
+        c1        c2      c3   
+      EOS
+    end
+  end
+
+  context 'with aligned header' do
+    let(:rows)    { [['aaaaa1', 'a2', 'aaa3'], ['b1', 'bbbb2', 'bb3']] }
+    let(:header)  {['h1', {:value => 'h2', :align => :right}, {:value => 'h3', :align => :center}] }
+    let(:options) { { renderer: :basic } }
+
+    it "aligns headres" do
+      expect(renderer.render).to eq <<-EOS.normalize
+        h1        h2  h3 
+        aaaaa1 a2    aaa3
+        b1     bbbb2 bb3 
+      EOS
+    end
+  end
+end

data/spec/unit/renderer/basic/coloring_spec.rb

@@ -0,0 +1,46 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Renderer::Basic, 'coloring' do
+  let(:header)   { ['h1', 'h2'] }
+  let(:rows)     { [['a1', 'a2'], ['b1', 'b2']] }
+  let(:clear)    { "\e[0m" }
+  let(:options)  { {filter: filter } }
+  let(:table)    { TTY::Table.new(header, rows) }
+  let(:color)    { Pastel.new(enabled: true) }
+
+  subject(:renderer) { described_class.new(table, options) }
+
+  before { allow(Pastel).to receive(:new).and_return(color) }
+
+  context 'with filter on all fields' do
+    let(:filter) {
+      proc { |val, row, col| color.decorate val, :blue, :on_green }
+    }
+
+    it 'colors all elements' do
+      expect(renderer.render).to eql <<-EOS.normalize
+        \e[34;42mh1#{clear} \e[34;42mh2#{clear}
+        \e[34;42ma1#{clear} \e[34;42ma2#{clear}
+        \e[34;42mb1#{clear} \e[34;42mb2#{clear}
+      EOS
+    end
+  end
+
+  context 'with filter only on header' do
+    let(:filter) {
+      proc { |val, row, col|
+        row.zero? ?  color.decorate(val, :blue, :on_green) : val
+      }
+    }
+
+    it 'colors only header' do
+      expect(renderer.render).to eql <<-EOS.normalize
+        \e[34;42mh1#{clear} \e[34;42mh2#{clear}
+        a1 a2
+        b1 b2
+      EOS
+    end
+  end
+end

data/spec/unit/renderer/basic/extract_column_widths_spec.rb

@@ -0,0 +1,28 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Renderer::Basic, '#column_widths' do
+  let(:rows)   { [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3']] }
+  let(:renderer) { described_class.new(table) }
+
+  subject { renderer.render }
+
+  context 'with rows only' do
+    let(:rows)  { [['a1a', 'a2a2a2'], ['b1b1b', 'b2b2']] }
+    let(:table) { TTY::Table.new rows }
+
+    it 'calculates column widths' do
+      expect(renderer.column_widths).to eq([5,6])
+    end
+  end
+
+  context 'with header' do
+    let(:header) { ['header1', 'head2', 'h3'] }
+    let(:table)  { TTY::Table.new header, rows }
+
+    it 'calcualtes column widths with header' do
+      expect(renderer.column_widths).to eq([7,5,2])
+    end
+  end
+end