tty-table 0.1.0

data/spec/unit/access_spec.rb

@@ -0,0 +1,86 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table, 'access' do
+  let(:header) { [:head1, :head2] }
+  let(:rows)   { [['a1', 'a2'], ['b1', 'b2']] }
+
+  subject(:table) { TTY::Table.new rows: rows, header: header }
+
+  it { is_expected.to respond_to(:element) }
+
+  it { is_expected.to respond_to(:component) }
+
+  it { is_expected.to respond_to(:at) }
+
+  context 'when array like access' do
+    it { expect(table[0,0]).to eq('a1') }
+
+    it { expect(table[0]).to eq(rows[0]) }
+
+    it { expect(table[5]).to eq(nil) }
+
+    it { expect(table[-1]).to eq(rows[-1]) }
+
+    it { expect(table[5,5]).to eq(nil) }
+
+    it 'raises error for negative indices' do
+      expect { table[-5,-5] }.to raise_error(IndexError)
+    end
+  end
+
+  context '#row' do
+    it 'returns nil for wrong index' do
+      expect(table.row(11)).to be_nil
+    end
+
+    it 'gets row at index' do
+      expect(table.row(1)).to eq(rows[1])
+    end
+
+    it 'yields self for wrong index' do
+      block = lambda { |el| [] << el }
+      expect(table.row(11, &block)).to eq(table)
+    end
+
+    it 'yields row at index' do
+      yields = []
+      expect { table.row(1).each { |el| yields << el } }.to change { yields }.
+        from( [] ).
+        to( rows[1] )
+    end
+  end
+
+  context '#column' do
+    it "gets based on header name" do
+      expect(table.column(:head1)).to eq(['a1', 'b1'])
+    end
+
+    it "yields based on header name" do
+      yielded = []
+      table.column(:head1) { |el| yielded << el }
+      expect(yielded).to eql(['a1', 'b1'])
+    end
+
+    it 'returns nil for wrong index' do
+      expect(table.column(11)).to be_nil
+    end
+
+    it 'gets column at index' do
+      expect(table.column(0)).to eq(['a1', 'b1'])
+    end
+
+    it 'yields self for wrong index' do
+      block = lambda { |el| [] << el }
+      expect(table.column(11, &block)).to eq(table)
+    end
+
+    it 'yields column at index' do
+      yields = []
+      expect { table.column(1).each { |el| yields << el } }.to change { yields }.
+        from( [] ).
+        to( ['a2', 'b2'])
+    end
+  end
+end

data/spec/unit/add_row_spec.rb

@@ -0,0 +1,28 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table, '#<<' do
+  let(:rows) { ['a', 'b', 'c'] }
+  let(:object) { described_class }
+
+  subject(:table) { object[rows] }
+
+  context 'with primitive values' do
+    let(:row) { [1, 2, 3] }
+
+    it 'extracts values correctly' do
+      table << row
+      expect(table.to_a.last).to eql(row)
+    end
+  end
+
+  context 'with complex values' do
+    let(:row) { [1, { value: 2 }, 3] }
+
+    it 'extracts values correctly' do
+      table << row
+      expect(table.to_a.last).to eql([1,2,3])
+    end
+  end
+end

data/spec/unit/border/ascii/rendering_spec.rb

@@ -0,0 +1,90 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Border::ASCII, '#rendering' do
+
+  subject { described_class.new(column_widths) }
+
+  context 'with empty row' do
+    let(:row) { TTY::Table::Row.new([]) }
+    let(:column_widths) { [] }
+
+    it 'draws top line' do
+      expect(subject.top_line).to eq("++")
+    end
+
+    it 'draws middle line' do
+      expect(subject.separator).to eq("++")
+    end
+
+    it 'draw bottom line' do
+      expect(subject.bottom_line).to eq("++")
+    end
+
+    it 'draws row line' do
+      expect(subject.row_line(row)).to eq("||")
+    end
+  end
+
+  context 'with row' do
+    let(:column_widths) { [2,2,2] }
+    let(:row) { TTY::Table::Row.new(['a1', 'a2', 'a3']) }
+
+    it 'draws top line' do
+      expect(subject.top_line).to eq("+--+--+--+")
+    end
+
+    it 'draw middle line' do
+      expect(subject.separator).to eq("+--+--+--+")
+    end
+
+    it 'draw bottom line' do
+      expect(subject.bottom_line).to eq("+--+--+--+")
+    end
+
+    it 'draws row line' do
+      expect(subject.row_line(row)).to eq("|a1|a2|a3|")
+    end
+  end
+
+  context 'with multiline row' do
+    let(:column_widths) { [2,2,2]}
+
+    context 'with mixed data' do
+      let(:row) { TTY::Table::Row.new(["a1\nb1\nc1", 'a2', 'a3']) }
+
+      it 'draws row line' do
+        expect(subject.row_line(row)).to eq <<-EOS.normalize
+          |a1|a2|a3|
+          |b1|  |  |
+          |c1|  |  |
+        EOS
+      end
+    end
+
+    context 'with sparse data' do
+      let(:row) { TTY::Table::Row.new(["a1\n\n", "\na2\n", "\n\na3"]) }
+
+      it 'draws row line' do
+        expect(subject.row_line(row)).to eq <<-EOS.normalize
+          |a1|  |  |
+          |  |a2|  |
+          |  |  |a3|
+        EOS
+      end
+    end
+
+    context 'with empty data' do
+      let(:row) { TTY::Table::Row.new(["\na1\n", "\na2\n", "\na3\n"]) }
+
+      it 'draws row line' do
+        expect(subject.row_line(row)).to eq <<-EOS.normalize
+          |  |  |  |
+          |a1|a2|a3|
+          |  |  |  |
+        EOS
+      end
+    end
+  end
+end

data/spec/unit/border/new_spec.rb

@@ -0,0 +1,27 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Border, '#new' do
+  let(:row) { [] }
+
+  subject(:instance) { klass.new row }
+
+  context 'when abstract' do
+    let(:klass) { described_class }
+
+    it { expect { instance }.to raise_error(NotImplementedError) }
+  end
+
+  context 'when concrete' do
+    let(:klass) {
+      Class.new do
+        def initialize(row); end
+      end
+    }
+
+    it { expect { instance }.to_not raise_error() }
+
+    it { is_expected.to be_instance_of klass }
+  end
+end

data/spec/unit/border/null/rendering_spec.rb

@@ -0,0 +1,130 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Border::Null, '#rendering' do
+  let(:border) { nil }
+
+  subject { described_class.new column_widths, border }
+
+  context 'with empty row' do
+    let(:row) { TTY::Table::Row.new([]) }
+    let(:column_widths) { [] }
+
+    it 'draws top line' do
+      expect(subject.top_line).to be_nil
+    end
+
+    it 'draws middle line' do
+      expect(subject.separator).to be_nil
+    end
+
+    it 'draw bottom line' do
+      expect(subject.bottom_line).to be_nil
+    end
+
+    it 'draws row line' do
+      expect(subject.row_line(row)).to eq('')
+    end
+  end
+
+  context 'with row' do
+    let(:row) { TTY::Table::Row.new(['a1', 'a2', 'a3']) }
+    let(:column_widths) { [2,2,2] }
+
+    it 'draws top line' do
+      expect(subject.top_line).to be_nil
+    end
+
+    it 'draw middle line' do
+      expect(subject.separator).to be_nil
+    end
+
+    it 'draw bottom line' do
+      expect(subject.bottom_line).to be_nil
+    end
+
+    it 'draws row line' do
+      expect(subject.row_line(row)).to eq('a1 a2 a3')
+    end
+  end
+
+  context 'with multiline row' do
+    let(:column_widths) { [2,2,2] }
+
+    context 'with mixed data' do
+      let(:row) { TTY::Table::Row.new(["a1\nb1\nc1", 'a2', 'a3']) }
+
+      it 'draws row line' do
+        expect(subject.row_line(row)).to eq <<-EOS.normalize
+          a1 a2 a3
+          b1      
+          c1      
+        EOS
+      end
+    end
+
+    context 'with sparse data' do
+      let(:row) { TTY::Table::Row.new(["a1\n\n", "\na2\n", "\n\na3"]) }
+
+      it 'draws row line' do
+        expect(subject.row_line(row)).to eq <<-EOS.chomp
+a1      
+   a2   
+      a3
+        EOS
+      end
+    end
+
+    context 'with empty data' do
+      let(:row) { TTY::Table::Row.new(["\na1\n", "\na2\n", "\na3\n"]) }
+
+      it 'draws row line' do
+        expect(subject.row_line(row)).to eq <<-EOS.chomp
+        
+a1 a2 a3
+        
+        EOS
+      end
+    end
+  end
+
+  context 'with border' do
+    let(:row) { TTY::Table::Row.new(['a1', 'a2', 'a3']) }
+    let(:column_widths) { [2,2,2] }
+    let(:border) { { :characters => {
+      'top'          => '=',
+      'top_mid'      => '=',
+      'top_left'     => '=',
+      'top_right'    => '=',
+      'bottom'       => '=',
+      'bottom_mid'   => '=',
+      'bottom_left'  => '=',
+      'bottom_right' => '=',
+      'mid'          => '=',
+      'mid_mid'      => '=',
+      'mid_left'     => '=',
+      'mid_right'    => '=',
+      'left'         => '=',
+      'center'       => '=',
+      'right'        => '='
+    } } }
+
+
+    it 'draws top line' do
+      expect(subject.top_line).to eql '=========='
+    end
+
+    it 'draws separator line' do
+      expect(subject.separator).to eql '=========='
+    end
+
+    it 'draws bottom line' do
+      expect(subject.bottom_line).to eql '=========='
+    end
+
+    it 'draws row line' do
+      expect(subject.row_line(row)).to eql '=a1=a2=a3='
+    end
+  end
+end

data/spec/unit/border/options/from_spec.rb

@@ -0,0 +1,38 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::BorderOptions, '#from' do
+
+  subject(:options) { described_class.from object }
+
+  context 'when empty hash' do
+    let(:object) { {} }
+
+    it { expect(options.style).to be_nil }
+
+    it { expect(options.separator).to be_nil }
+  end
+
+  context 'when hash' do
+    let(:object) { { style: :red, separator: :none } }
+
+    it { expect(options).to be_kind_of(described_class) }
+
+    it { expect(options.style).to eql :red }
+
+    it { expect(options.separator).to eql :none }
+
+    it { expect(options.characters).to eql({}) }
+  end
+
+  context 'when other BorderOptions' do
+    let(:object) { described_class.new(nil, nil, :blue) }
+
+    it { expect(options).to eql object }
+
+    it { expect(options.characters).to eql({}) }
+
+    it { expect(options.style).to eql :blue }
+  end
+end # from

data/spec/unit/border/options/new_spec.rb

@@ -0,0 +1,14 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::BorderOptions, '.new' do
+
+  subject(:options) { described_class.new }
+
+  it { expect(subject.characters).to eql({}) }
+
+  it { expect(subject.separator).to be_nil }
+
+  it { expect(subject.style).to  be_nil }
+end # new

data/spec/unit/border/unicode/rendering_spec.rb

@@ -0,0 +1,63 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Border::Unicode, '#rendering' do
+
+  subject { described_class.new(column_widths) }
+
+  context 'with empty row' do
+    let(:row) { TTY::Table::Row.new([]) }
+    let(:column_widths) { [] }
+
+    it 'draws top line' do
+      expect(subject.top_line).to eq("┌┐")
+    end
+
+    it 'draws middle line' do
+      expect(subject.separator).to eq("├┤")
+    end
+
+    it 'draw bottom line' do
+      expect(subject.bottom_line).to eq("└┘")
+    end
+
+    it 'draws row line' do
+      expect(subject.row_line(row)).to eq("││")
+    end
+  end
+
+  context 'with row' do
+    let(:row) { TTY::Table::Row.new(['a1', 'a2', 'a3']) }
+    let(:column_widths) { [2,2,2] }
+
+    it 'draws top line' do
+      expect(subject.top_line).to eq("┌──┬──┬──┐")
+    end
+
+    it 'draw middle line' do
+      expect(subject.separator).to eq("├──┼──┼──┤")
+    end
+
+    it 'draw bottom line' do
+      expect(subject.bottom_line).to eq("└──┴──┴──┘")
+    end
+
+    it 'draws row line' do
+      expect(subject.row_line(row)).to eq("│a1│a2│a3│")
+    end
+  end
+
+  context 'with multiline row' do
+    let(:row) { TTY::Table::Row.new(["a1\nb1\nc1", 'a2', 'a3']) }
+    let(:column_widths) { [2,2,2] }
+
+    it 'draws row line' do
+      expect(subject.row_line(row)).to eq <<-EOS.normalize
+        │a1│a2│a3│
+        │b1│  │  │
+        │c1│  │  │
+      EOS
+    end
+  end
+end

data/spec/unit/border_options/new_spec.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::BorderOptions do
+
+  subject { described_class.new(options) }
+
+  context 'with characters' do
+    let(:options) { {top: '**'} }
+
+    it { expect(subject.characters).to eq({top:'**'}) }
+  end
+
+  context 'without characters' do
+    let(:options) { nil }
+
+    it { expect(subject.characters).to eq({}) }
+  end
+end

data/spec/unit/border_options/update_spec.rb

@@ -0,0 +1,18 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::BorderOptions, '.update' do
+
+  let(:object) { described_class.new }
+
+  let(:params) { {characters: {top: '*'}, separator: '|', style: :red} }
+
+  subject { object.update(params) }
+
+  it 'sets properties from hash object' do
+    expect(subject.characters).to eq({top: '*'})
+    expect(subject.separator).to eq('|')
+    expect(subject.style).to eq(:red)
+  end
+end

data/spec/unit/column_set/extract_widths_spec.rb

@@ -0,0 +1,15 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::ColumnSet, '#extract_widths' do
+  let(:header) { ['h1', 'h2', 'h3'] }
+  let(:rows)   { [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3']] }
+  let(:table)  { TTY::Table.new header, rows }
+
+  subject { described_class.new table }
+
+  it 'extract widths' do
+    expect(subject.extract_widths).to eql([2,2,2])
+  end
+end

data/spec/unit/column_set/total_width_spec.rb

@@ -0,0 +1,15 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::ColumnSet, '#extract_widths!' do
+  let(:header) { ['h1', 'h2', 'h3'] }
+  let(:rows)   { [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3']] }
+  let(:table)  { TTY::Table.new header, rows }
+
+  subject { described_class.new table }
+
+  it 'extract widths' do
+    expect(subject.total_width).to eql(6)
+  end
+end

data/spec/unit/column_set/widths_from_spec.rb

@@ -0,0 +1,51 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::ColumnSet, '#widths_from' do
+  let(:header) { ['h1', 'h2', 'h3'] }
+  let(:rows)   { [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3']] }
+  let(:table)  { TTY::Table.new header, rows }
+
+  subject { described_class.widths_from(table, column_widths) }
+
+  context 'when empty array' do
+    let(:column_widths) { [] }
+
+    it 'raises an error' do
+      expect { subject }.to raise_error(TTY::Table::InvalidArgument)
+    end
+  end
+
+  context 'when invalid size array' do
+    let(:column_widths) { [3,3] }
+
+    it 'raises an error' do
+      expect { subject }.to raise_error(TTY::Table::InvalidArgument)
+    end
+  end
+
+  context 'when valid array' do
+    let(:column_widths) { [3,3,3] }
+
+    it 'converts into numbers' do
+      expect(subject).to eql(column_widths)
+    end
+  end
+
+  context 'when nil' do
+    let(:column_widths) { nil }
+
+    it 'extracts widths' do
+      expect(subject).to eql([2,2,2])
+    end
+  end
+
+  context 'when numeric' do
+    let(:column_widths) { 5 }
+
+    it 'generates widths' do
+      expect(subject).to eql([5,5,5])
+    end
+  end
+end

data/spec/unit/columns/enforce_spec.rb

@@ -0,0 +1,67 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Columns, '#enforce' do
+  let(:header) { ['h1', 'h2', 'h3', 'h4'] }
+  let(:rows)   { [['a1', 'a2', 'a3', 'a4'], ['b1', 'b2', 'b3', 'b4']] }
+  let(:table)  { TTY::Table.new(header, rows) }
+  let(:object) { described_class.new(renderer) }
+
+  subject { object.enforce }
+
+  context 'with width contraint' do
+    let(:renderer) { TTY::Table::Renderer::Basic.new(table, options) }
+    let(:options) { { width: 5 }}
+
+    it 'raises error when table width is too small' do
+      expect { subject }.to raise_error(TTY::Table::ResizeError)
+    end
+  end
+
+  context 'with width contraint matching natural width' do
+    let(:renderer) { TTY::Table::Renderer::Basic.new(table, options) }
+    let(:options) { { width: 11, resize: true }}
+
+    it 'raises error when table width is too small' do
+      expect(object).to receive(:expand)
+      subject
+    end
+  end
+
+  context 'with table larger than allowed width' do
+    let(:renderer) { TTY::Table::Renderer::Basic.new(table, options) }
+
+    context 'with resize' do
+      let(:options) { { width: 8, resize: true } }
+
+      it 'calls shrink' do
+        expect(object).to receive(:shrink)
+        subject
+      end
+    end
+
+    context 'without resize' do
+      let(:options) { { width: 8, resize: false }}
+
+      it 'changes table orientation to vertical' do
+        allow(Kernel).to receive(:warn)
+        expect(renderer.column_widths).to eql([2,2,2,2])
+        expect(renderer.table.orientation.name).to eql(:horizontal)
+        subject
+        expect(renderer.column_widths).to eq([2,2])
+        expect(renderer.table.orientation.name).to eql(:vertical)
+      end
+    end
+  end
+
+  context 'with table less than allowed width' do
+    let(:renderer) { TTY::Table::Renderer::Basic.new(table, options) }
+    let(:options)  { { width: 15 }}
+
+    it "doesn't change original widths" do
+      allow(Kernel).to receive(:warn)
+      expect(renderer.column_widths).to eq([2,2,2,2])
+    end
+  end
+end