tty 0.1.2 → 0.1.3

data/spec/tty/table/padder/parse_spec.rb

@@ -1,45 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-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/tty/table/padder/to_s_spec.rb

@@ -1,14 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-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/tty/table/padding_spec.rb

@@ -1,120 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-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

data/spec/tty/table/properties_spec.rb

@@ -1,25 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-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/tty/table/render_spec.rb

@@ -1,63 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-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/tty/table/render_with_spec.rb

@@ -1,106 +0,0 @@
-# encoding: 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::TypeError)
-    end
-
-    it "doesn't implement def_border" do
-      klass = Class.new(TTY::Table::Border)
-      expect { table.render_with klass }.
-        to raise_error(TTY::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/tty/table/renderer/ascii/indentation_spec.rb

@@ -1,41 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-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/tty/table/renderer/ascii/padding_spec.rb

@@ -1,61 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-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/tty/table/renderer/ascii/render_spec.rb

@@ -1,68 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-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/tty/table/renderer/ascii/resizing_spec.rb

@@ -1,114 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-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/tty/table/renderer/ascii/separator_spec.rb

@@ -1,28 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-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