tty 0.1.2 → 0.1.3

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

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

@@ -1,46 +0,0 @@
-# encoding: 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/tty/table/renderer/basic/extract_column_widths_spec.rb

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

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

@@ -1,53 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe TTY::Table::Renderer::Basic, 'filter' 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, {filter: filter}) }
-
-  context 'with header' do
-    context 'filtering only rows' do
-      let(:filter) { Proc.new { |val, row, col|
-          (col == 1 and row > 0) ? val.capitalize : val
-        }
-      }
-
-      it 'filters only rows' do
-        expect(renderer.render).to eq <<-EOS.normalize
-          h1 h2 h3
-          a1 A2 a3
-          b1 B2 b3
-        EOS
-      end
-    end
-
-    context 'filtering header and rows' do
-      let(:filter) { Proc.new { |val, row, col| col == 1 ? val.capitalize : val }}
-
-      it 'filters only rows' do
-        expect(renderer.render).to eq <<-EOS.normalize
-          h1 H2 h3
-          a1 A2 a3
-          b1 B2 b3
-        EOS
-      end
-    end
-  end
-
-  context 'without header' do
-    let(:header) { nil }
-
-    let(:filter) { Proc.new { |val, row, col| col == 1 ?  val.capitalize : val } }
-
-    it 'filters only rows' do
-      expect(renderer.render).to eq <<-EOS.normalize
-        a1 A2 a3
-        b1 B2 b3
-      EOS
-    end
-  end
-end

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

@@ -1,48 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe TTY::Table::Renderer::Basic, 'indentation' do
-  let(:header)  { ['h1', 'h2', 'h3'] }
-  let(:rows)    { [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3']] }
-  let(:table)   { TTY::Table.new(header, rows) }
-  let(:options) { {indent: indent } }
-
-  subject(:renderer) { described_class.new(table, options)}
-
-  context 'when default' do
-    let(:indent) { 0 }
-
-    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 custom' do
-    let(:indent) { 2 }
-
-    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 changed' do
-    let(:indent) { 2 }
-    let(:header) { ['h1', 'h2'] }
-    let(:rows)   { [['a1', 'a2']] }
-
-    it 'changes indentation and reuses renderer' do
-      expect(renderer.render).to eq("  h1 h2\n  a1 a2")
-      renderer.indent = 1
-      expect(renderer.render).to eq(" h1 h2\n a1 a2")
-    end
-  end
-end

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

@@ -1,135 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe TTY::Table::Renderer::Basic, 'with multiline content' do
-  let(:header) { nil }
-  let(:object) { described_class }
-  let(:table) { TTY::Table.new header, rows }
-
-  subject(:renderer) { object.new table }
-
-  context 'with escaping' do
-    let(:rows) { [ ["First", '1'], ["Multiline\nContent", '2'], ["Third", '3']] }
-
-    context 'without border' do
-      it "renders single line" do
-        expect(table.render(multiline: false)).to eq <<-EOS.normalize
-          First              1
-          Multiline\\nContent 2
-          Third              3
-        EOS
-      end
-    end
-
-    context 'with column widths' do
-      it "renders single line" do
-        expect(table.render(multiline: false, column_widths: [8,1])).to eq <<-EOS.normalize
-          First    1
-          Multili… 2
-          Third    3
-        EOS
-      end
-    end
-
-    context 'with border' do
-      it "renders single line" do
-        expect(table.render(:ascii, multiline: false)).to eq <<-EOS.normalize
-         +------------------+-+
-         |First             |1|
-         |Multiline\\nContent|2|
-         |Third             |3|
-         +------------------+-+
-        EOS
-      end
-    end
-
-    context 'with header' do
-      let(:header) { ["Multi\nHeader", "header2"] }
-
-      it "renders header" do
-        expect(table.render(:ascii, multiline: false)).to eq <<-EOS.normalize
-         +------------------+-------+
-         |Multi\\nHeader     |header2|
-         +------------------+-------+
-         |First             |1      |
-         |Multiline\\nContent|2      |
-         |Third             |3      |
-         +------------------+-------+
-        EOS
-      end
-    end
-  end
-
-  context 'without escaping' do
-    let(:rows) { [ ["First", '1'], ["Multi\nLine\nContent", '2'], ["Third", '3']] }
-
-    context 'without border' do
-      it "renders every line" do
-        expect(table.render(multiline: true)).to eq <<-EOS.normalize
-          First   1
-          Multi   2
-          Line     
-          Content  
-          Third   3
-        EOS
-      end
-    end
-
-    context 'with column widths' do
-      it "renders multiline" do
-        expect(table.render(multiline: true, column_widths: [8,1])).to eq <<-EOS.normalize
-          First    1
-          Multi    2
-          Line      
-          Content   
-          Third    3
-        EOS
-      end
-
-      it 'wraps multi line' do
-        expect(table.render(multiline: true, column_widths: [5,1])).to eq <<-EOS.normalize
-          First 1
-          Multi 2
-          Line   
-          Conte  
-          nt     
-          Third 3
-        EOS
-      end
-    end
-
-    context 'with border' do
-      it "renders every line" do
-        expect(table.render(:ascii, multiline: true)).to eq <<-EOS.normalize
-         +-------+-+
-         |First  |1|
-         |Multi  |2|
-         |Line   | |
-         |Content| |
-         |Third  |3|
-         +-------+-+
-        EOS
-      end
-    end
-
-    context 'with header' do
-      let(:header) { ["Multi\nHeader", "header2"] }
-
-      it "renders header" do
-        expect(table.render(:ascii, multiline: true)).to eq <<-EOS.normalize
-         +-------+-------+
-         |Multi  |header2|
-         |Header |       |
-         +-------+-------+
-         |First  |1      |
-         |Multi  |2      |
-         |Line   |       |
-         |Content|       |
-         |Third  |3      |
-         +-------+-------+
-        EOS
-      end
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe TTY::Table::Renderer::Basic, '.new' do
-  let(:header) { ['h1'] }
-  let(:rows)   { [['a1']] }
-
-  subject(:renderer) { described_class }
-
-  context 'without table' do
-    let(:table) { nil }
-
-    it { expect { renderer.new(table) }.to raise_error(TTY::ArgumentRequired) }
-  end
-
-  context 'with table' do
-    let(:table)  { TTY::Table.new(header, rows) }
-
-    it { expect { renderer.new(table) }.not_to raise_error }
-  end
-end

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

@@ -1,48 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe TTY::Table::Renderer::Basic, 'options' do
-  let(:rows)   { [['a1', 'a2'], ['b1', 'b2']] }
-  let(:object) { described_class }
-  let(:table)  { TTY::Table.new(rows) }
-  let(:widths) { nil }
-  let(:aligns) { [] }
-  let(:options) {
-    {
-      :column_widths => widths,
-      :column_aligns  => aligns,
-      :renderer => :basic
-    }
-  }
-
-  subject(:renderer) { object.new table, options }
-
-  it { expect(renderer.border).to be_kind_of(TTY::Table::BorderOptions) }
-
-  it { expect(renderer.column_widths).to eql([2,2]) }
-
-  it { expect(renderer.column_aligns).to eql(aligns) }
-
-  it { expect(renderer.column_aligns.to_a).to be_empty }
-
-  context '#column_widths' do
-    let(:widths) { [10, 10] }
-
-    it { expect(renderer.column_widths).to eq(widths) }
-  end
-
-  context '#column_widths empty' do
-    let(:widths) { [] }
-
-    it { expect { renderer.column_widths }.to raise_error(TTY::InvalidArgument) }
-  end
-
-  context '#column_aligns' do
-    let(:aligns) { [:center, :center] }
-
-    it 'unwraps original array' do
-      expect(renderer.column_aligns.to_a).to eq(aligns)
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe TTY::Table::Renderer::Basic, '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/basic/render_spec.rb

@@ -1,57 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe TTY::Table::Renderer::Basic, '#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' do
-    let(:table) { TTY::Table.new rows }
-
-    it 'displays table without styling' do
-      expect(renderer.render).to eq <<-EOS.normalize
-        a1 a2 a3
-        b1 b2 b3
-      EOS
-    end
-  end
-
-  context 'with header and rows' 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/basic/resizing_spec.rb

@@ -1,96 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe TTY::Table::Renderer::Basic, '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
-          he… he…
-          aa… aa…
-          bb… bb…
-        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
-          hea… he…
-          aaa… aa…
-          bbb… bb…
-        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
-          hea… he… head3 
-          aaa1 aa2 aaaaa…
-          b1   b2  b3    
-        EOS
-      end
-    end
-  end
-end