tty 0.1.2 → 0.1.3

data/spec/tty/table/renderer/basic/separator_spec.rb

@@ -1,43 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe TTY::Table::Renderer::Basic, '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 default' do
-    it "sets through hash" do
-      renderer.border :separator => :each_row
-      expect(renderer.border.separator).to eql(:each_row)
-    end
-
-    it "sets through attribute" do
-      renderer.border.separator= :each_row
-      expect(renderer.border.separator).to eql(:each_row)
-    end
-
-    it "sets through block" do
-      renderer.border do
-        separator :each_row
-      end
-      expect(renderer.border.separator).to eql(:each_row)
-    end
-
-    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/tty/table/renderer/basic/truncation_spec.rb

@@ -1,35 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe TTY::Table::Renderer::Basic, 'truncation' do
-  let(:header) { ['header1', 'head2', 'h3'] }
-  let(:rows) { [['a1111111', 'a222', 'a3333333'], ['b111', 'b2222222', 'b333333']]}
-  let(:table) { TTY::Table.new header, rows }
-
-  subject(:renderer) { described_class.new(table, options) }
-
-  context 'without column widths' do
-    let(:options) { {} }
-
-    it "doesn't shorten the fields" do
-      expect(renderer.render).to eq <<-EOS.normalize
-        header1  head2    h3      
-        a1111111 a222     a3333333
-        b111     b2222222 b333333 
-      EOS
-    end
-  end
-
-  context 'with column widths' do
-    let(:options) { { column_widths: [3, 5, 7] } }
-
-    it 'shortens the fields' do
-      expect(renderer.render).to eq <<-EOS.normalize
-        he… head2 h3     
-        a1… a222  a33333…
-        b1… b222… b333333
-      EOS
-    end
-  end
-end

data/spec/tty/table/renderer/basic/wrapping_spec.rb

@@ -1,40 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe TTY::Table::Renderer::Basic, 'wrapping' do
-  let(:header) { ['header1', 'head2', 'h3'] }
-  let(:rows) { [['a1111111', 'a222', 'a3333333'], ['b111', 'b2222222', 'b333333']]}
-  let(:table) { TTY::Table.new header, rows }
-
-  subject(:renderer) { described_class.new(table, options) }
-
-  context 'without column widths' do
-    let(:options) { {multiline: true} }
-
-    it 'doesn\'t wrap the fields' do
-      expect(renderer.render).to eq <<-EOS.normalize
-        header1  head2    h3      
-        a1111111 a222     a3333333
-        b111     b2222222 b333333 
-      EOS
-    end
-  end
-
-  context 'with column widths' do
-    let(:options) { { column_widths: [3, 5, 7], multiline: true} }
-
-    it 'wraps the fields' do
-      expect(renderer.render).to eq <<-EOS.normalize
-        hea head2 h3     
-        der              
-        1                
-        a11 a222  a333333
-        111       3      
-        11               
-        b11 b2222 b333333
-        1   222          
-      EOS
-    end
-  end
-end

data/spec/tty/table/renderer/border_spec.rb

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

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

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

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

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

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

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

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

@@ -1,19 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe TTY::Table, '#renderer' do
-  let(:object) { described_class }
-  let(:header) { ['h1', 'h2'] }
-  let(:rows)   { [['a1', 'a2'], ['b1', 'b2']] }
-
-  subject { 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/tty/table/rotate_spec.rb

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

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