tty-table 0.11.0 → 0.12.0

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

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe TTY::Table::Renderer::Basic, 'coloring' do
-  let(:clear)    { "\e[0m" }
-  let(:color)    { Pastel.new(enabled: true) }
-
-  before { allow(Pastel).to receive(:new).and_return(color) }
-
-  context 'when border ' do
-    it "doesn't color" do
-      table = TTY::Table.new header: ['header1', 'header2']
-      table << ['a1', 'a2']
-      table << ['b1', 'b2']
-      renderer = described_class.new(table)
-      renderer.border = {style: :green}
-
-      expect(renderer.render).to eql unindent(<<-EOS)
-        header1 header2
-        a1      a2     
-        b1      b2     
-      EOS
-    end
-  end
-
-  context 'when content' do
-    it "colors individual field" do
-      header = [color.green('header1'), 'header2']
-      table = TTY::Table.new header: header
-      table << [color.green.on_blue('a1'), 'a2']
-      table << ['b1', color.red.on_yellow('b2')]
-      renderer = described_class.new(table)
-
-      expect(renderer.render).to eq unindent(<<-EOS)
-        #{color.green('header1')} header2
-        #{color.green.on_blue('a1')}      a2     
-        b1      #{color.red.on_yellow('b2')}     
-      EOS
-    end
-
-    it "colors multiline content" do
-      header = [color.yellow("Multi\nHeader"), 'header2']
-      table = TTY::Table.new header: header
-      table << [color.green.on_blue("Multi\nLine\nContent"), 'a2']
-      table << ['b1', color.red.on_yellow("Multi\nLine\nContent")]
-      renderer = described_class.new(table, multiline: true)
-
-      expect(renderer.render).to eq unindent(<<-EOS)
-        #{color.yellow('Multi  ')} header2
-        #{color.yellow('Header')}         
-        #{color.green.on_blue('Multi  ')} a2     
-        #{color.green.on_blue('Line   ')}        
-        #{color.green.on_blue('Content')}        
-        b1      #{color.red.on_yellow("Multi  ")}
-                #{color.red.on_yellow("Line   ")}
-                #{color.red.on_yellow("Content")}
-      EOS
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-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

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

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.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 unindent(<<-EOS)
-          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 unindent(<<-EOS)
-          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 unindent(<<-EOS)
-        a1 A2 a3
-        b1 B2 b3
-      EOS
-    end
-  end
-end

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

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.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/unit/renderer/basic/multiline_spec.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe TTY::Table::Renderer::Basic, 'multiline content' do
-  context 'with escaping' do
-    it "renders multiline as single line" do
-      rows = [ ["First", '1'], ["Multiline\nContent", '2'], ["Third", '3']]
-      table = TTY::Table.new rows
-      renderer = described_class.new(table, multiline: false)
-      expect(renderer.render).to eq unindent(<<-EOS)
-        First              1
-        Multiline\\nContent 2
-        Third              3
-      EOS
-    end
-
-    it "truncates multiline content" do
-      rows = [ ["First", '1'], ["Multiline\nContent", '2'], ["Third", '3']]
-      table = TTY::Table.new rows
-      renderer = described_class.new(table, multiline: false, column_widths: [8,1])
-      expect(renderer.render).to eq unindent(<<-EOS)
-        First    1
-        Multil…  2
-        Third    3
-      EOS
-    end
-  end
-
-  context 'without escaping' do
-    it "renders every line" do
-      rows = [["First", '1'],
-              ["Multi\nLine\nContent", '2'],
-              ["Third", "Multi\nLine"]]
-      table = TTY::Table.new rows
-      renderer = described_class.new(table, multiline: true)
-      expect(renderer.render).to eq unindent(<<-EOS)
-        First   1    
-        Multi   2    
-        Line         
-        Content      
-        Third   Multi
-                Line 
-      EOS
-    end
-
-    it "renders multiline with column widths" do
-      rows = [["First", '1'], ["Multi\nLine\nContent", '2'], ["Third", '3']]
-      table = TTY::Table.new rows
-      renderer = described_class.new(table, multiline: true, column_widths: [8,1])
-      expect(renderer.render).to eq unindent(<<-EOS)
-        First    1
-        Multi    2
-        Line      
-        Content   
-        Third    3
-      EOS
-    end
-
-    it 'wraps multi line' do
-      rows = [["First", '1'], ["Multi\nLine\nContent", '2'], ["Third", '3']]
-      table = TTY::Table.new rows
-      renderer = described_class.new(table, multiline: true, column_widths: [5,1])
-      expect(renderer.render).to eq unindent(<<-EOS)
-        First 1
-        Multi 2
-        Line   
-        Conte  
-        nt     
-        Third 3
-      EOS
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.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::Table::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/unit/renderer/basic/options_spec.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.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(:alignments) { [] }
-  let(:options) {
-    {
-      column_widths: widths,
-      alignments: alignments,
-      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.alignments.to_a).to eql(alignments) }
-
-  it { expect(renderer.alignments.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::Table::InvalidArgument)
-    }
-  end
-
-  context '#alignments' do
-    let(:alignments) { [:center, :center] }
-
-    it 'unwraps original array' do
-      expect(renderer.alignments.to_a).to eq(alignments)
-    end
-  end
-end

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

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.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]} }
-
-    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]} }
-
-    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 multiline content padding" do
-    it "pads around fields" do
-      padding = [1,2,1,2]
-      table = TTY::Table.new header: ['header1', 'header2']
-      table << ["a1\na1\na1",'a2']
-      table << ["b1","b2\nb2"]
-      renderer = TTY::Table::Renderer::Basic.new(table, padding: padding, multiline: true)
-      expect(renderer.render).to eql <<-EOS.chomp
-                       
-  header1     header2  
-                       
-                       
-  a1          a2       
-  a1                   
-  a1                   
-                       
-                       
-  b1          b2       
-              b2       
-                       
-      EOS
-    end
-  end
-end

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

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.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 unindent(<<-EOS)
-        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 unindent(<<-EOS)
-        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 unindent(<<-EOS)
-        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 unindent(<<-EOS)
-        header1 header2 header3
-        a1      a2      a3     
-        b1      b2      b3     
-      EOS
-    end
-  end
-end