tty-table 0.1.0

data/spec/unit/columns/widths_spec.rb

@@ -0,0 +1,35 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Columns, 'column widths' do
+  let(:header) { ['h1', 'h2', 'h3', 'h4'] }
+  let(:rows)   { [['a1', 'a2', 'a3', 'a4'], ['b1', 'b2', 'b3', 'b4']] }
+  let(:table)  { TTY::Table.new(header, rows) }
+
+  subject { described_class.new(renderer) }
+
+  context 'with basic renderer' do
+    let(:renderer) { TTY::Table::Renderer::Basic.new(table) }
+
+    it 'calculates columns natural width' do
+      expect(subject.natural_width).to eq(11)
+    end
+
+    it 'calculates miminimum columns width' do
+      expect(subject.minimum_width).to eq(7)
+    end
+  end
+
+  context 'with ascii renderer' do
+    let(:renderer) { TTY::Table::Renderer::ASCII.new(table) }
+
+    it 'calculates columns natural width' do
+      expect(subject.natural_width).to eq(13)
+    end
+
+    it 'calculates miminimum columns width' do
+      expect(subject.minimum_width).to eq(9)
+    end
+  end
+end

data/spec/unit/data_spec.rb

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

data/spec/unit/each_spec.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table, '#each' do
+  let(:table) { described_class.new header, rows }
+  let(:header) { ['Header1'] }
+  let(:rows)   { [['a1'], ['b1']] }
+  let(:field)  { TTY::Table::Field }
+
+  context 'with no block' do
+    subject { table.each }
+
+    it { is_expected.to be_instance_of(to_enum.class) }
+
+    it 'yields the expected values' do
+      expect(subject.to_a).to eql(table.to_a)
+    end
+  end
+
+  context 'with block' do
+    let(:yields) { [] }
+
+    subject { table.each { |row| yields << row } }
+
+    it 'yields header and rows' do
+      subject
+      expect(yields.first).to be_instance_of(TTY::Table::Header)
+      expect(yields.last).to be_instance_of(TTY::Table::Row)
+    end
+
+    it 'yields header and rows with expected attributes' do
+      subject
+      expect(yields).to eql(table.data)
+    end
+
+    xit 'yields each row' do
+      expect { subject }.to change { yields }.from([]).to(table.data)
+    end
+  end
+end

data/spec/unit/each_with_index_spec.rb

@@ -0,0 +1,57 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table, '.each_with_index' do
+  let(:header) { ['Header1', 'Header2'] }
+  let(:rows)   { [['a1', 'a2'], ['b1', 'b2']] }
+  let(:field)  { TTY::Table::Field }
+
+  let(:object) { described_class.new header, rows }
+
+  context 'with no block' do
+    subject { object.each_with_index }
+
+    it { is_expected.to be_instance_of(to_enum.class) }
+
+    it 'yields the expected values' do
+      expect(subject.to_a).to eql(object.to_a)
+    end
+  end
+
+  context 'with block' do
+    let(:yields) { [] }
+
+    subject { object.each_with_index { |el, row, col| yields << [el, row, col]}}
+
+    context 'without header' do
+      let(:header) { nil }
+
+      let(:expected) {
+        [ [field.new('a1'), 0, 0], [field.new('a2'), 0, 1],
+          [field.new('b1'), 1, 0], [field.new('b2'), 1, 1] ]
+      }
+
+      it "yields rows with expected data" do
+        expect { subject }.to change { yields }.
+          from( [] ).
+          to( expected )
+      end
+    end
+
+    context 'with header' do
+
+      let(:expected) {
+        [ [field.new('Header1'), 0, 0], [field.new('Header2'), 0, 1],
+          [field.new('a1'), 1, 0], [field.new('a2'), 1, 1],
+          [field.new('b1'), 2, 0], [field.new('b2'), 2, 1] ]
+      }
+
+      it "yields header and rows with expected data" do
+        expect { subject }.to change { yields }.
+          from( [] ).
+          to( expected )
+      end
+    end
+  end
+end

data/spec/unit/empty_spec.rb

@@ -0,0 +1,23 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table, '#empty?' do
+  let(:header) { ['Header1', 'Header2'] }
+  let(:object) { described_class.new header, rows }
+
+  subject { object.empty? }
+
+  context 'with rows containing no entries' do
+    let(:rows) { [] }
+
+    it { is_expected.to eq(true) }
+  end
+
+  context 'with rows containing an entry' do
+    let(:rows) { [['a1']] }
+
+    it { is_expected.to eq(false) }
+  end
+end
+

data/spec/unit/eql_spec.rb

@@ -0,0 +1,34 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table, '#eql?' do
+  let(:rows)   { [['a1', 'a2'], ['b1', 'b2']] }
+  let(:object) { described_class.new rows }
+
+  subject { object.eql?(other) }
+
+  describe '#inspect' do
+    it { expect(object.inspect).to match /#<TTY::Table/ }
+  end
+
+  context 'with the same object' do
+    let(:other) { object }
+
+    it { is_expected.to eql(true) }
+
+    it 'is symmetric' do
+      is_expected.to eql(other.eql?(object))
+    end
+  end
+
+  context 'with an equivalent object' do
+    let(:other) { object.dup }
+
+    it { is_expected.to eql(true) }
+
+    it 'is symmetric' do
+      is_expected.to eql(other.eql?(object))
+    end
+  end
+end

data/spec/unit/field/equality_spec.rb

@@ -0,0 +1,51 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Field, '#==' do
+  let(:value)  { '1' }
+  let(:object) { described_class.new(value) }
+
+  subject { object == other }
+
+  context 'with the same object' do
+    let(:other) { object }
+
+    it { is_expected.to eql(true) }
+
+    it 'is symmetric' do
+      is_expected.to eql(other == object)
+    end
+  end
+
+  context 'with an equivalent object' do
+    let(:other) { object.dup }
+
+    it { is_expected.to eql(true) }
+
+    it 'is symmetric' do
+      is_expected.to eql(other == object)
+    end
+  end
+
+  context 'with an equivalent object of subclass' do
+    let(:other) { Class.new(described_class).new(value) }
+
+    it { is_expected.to eq(true) }
+
+    it 'is symmetric' do
+      is_expected.not_to eql(other == object)
+    end
+  end
+
+  context 'with an object having a different value' do
+    let(:other_value) { '2' }
+    let(:other)       { described_class.new(other_value) }
+
+    it { is_expected.to eql(false) }
+
+    it 'is symmetric' do
+      is_expected.to eql(other == object)
+    end
+  end
+end

data/spec/unit/field/length_spec.rb

@@ -0,0 +1,21 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Field, '#length' do
+  let(:object) { described_class.new value }
+
+  subject { object.length }
+
+  context 'with escaped value' do
+    let(:value) { "Multi\nLine" }
+
+    it { is_expected.to eql(5) }
+  end
+
+  context 'with unescaped value' do
+    let(:value) { "Multi\\nLine" }
+
+    it { is_expected.to eql(11) }
+  end
+end

data/spec/unit/field/lines_spec.rb

@@ -0,0 +1,21 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Field, '#lines' do
+  let(:object) { described_class.new value }
+
+  subject { object.lines }
+
+  context 'with escaped value' do
+    let(:value) { "Multi\nLine" }
+
+    it { is_expected.to eql(["Multi", "Line"]) }
+  end
+
+  context 'with unescaped value' do
+    let(:value) { "Multi\\nLine" }
+
+    it { is_expected.to eql(["Multi\\nLine"]) }
+  end
+end

data/spec/unit/field/new_spec.rb

@@ -0,0 +1,29 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Field, '#new' do
+  let(:object) { described_class }
+
+  subject { object.new value }
+
+  context 'with only value' do
+    let(:value) { 'foo' }
+
+    it { is_expected.to be_instance_of(object) }
+
+    it { expect(subject.value).to  eql(value) }
+
+    it { expect(subject.height).to eql(1) }
+  end
+
+  context 'with hash value' do
+    let(:value) { { :value => 'foo' } }
+
+    it { is_expected.to be_instance_of(object) }
+
+    it { expect(subject.value).to eql('foo') }
+
+    it { expect(subject.height).to eql(1) }
+  end
+end

data/spec/unit/field/width_spec.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Field, '#width' do
+  let(:object) { described_class }
+
+  let(:instance) { object.new(value) }
+
+  subject { instance.width }
+
+  context 'with only value' do
+    let(:value) { 'foo' }
+
+    it { is_expected.to eql(3) }
+  end
+
+  context 'with hash value' do
+    let(:value) { "foo\nbaar" }
+
+    it { is_expected.to eql(8) }
+  end
+end

data/spec/unit/filter_spec.rb

@@ -0,0 +1,23 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table, '#filter' do
+  let(:header) { ['h1', 'h2', 'h3'] }
+  let(:rows)   { [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3']] }
+  let(:table)  { described_class.new(header, rows) }
+  let(:filter) { Proc.new { |val, row, col|
+      (col == 1 and row > 0) ? val.capitalize : val
+    }
+  }
+
+  it 'filters rows' do
+    expect(table.render do |renderer|
+      renderer.filter = filter
+    end).to eq <<-EOS.normalize
+      h1 h2 h3
+      a1 A2 a3
+      b1 B2 b3
+    EOS
+  end
+end

data/spec/unit/header/call_spec.rb

@@ -0,0 +1,30 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Header, '#call' do
+  let(:object) { described_class.new(attributes) }
+  let(:attributes) { [:id, :name, :age] }
+
+  subject { object[attribute] }
+
+  context 'with a known attribute' do
+    context 'when symbol' do
+      let(:attribute) { :age }
+
+      it { is_expected.to eq(2) }
+    end
+
+    context 'when integer' do
+      let(:attribute) { 1 }
+
+      it { is_expected.to eq(:name) }
+    end
+  end
+
+  context 'with an unknown attribute' do
+    let(:attribute) { :mine }
+
+    it { expect { subject }.to raise_error(TTY::Table::UnknownAttributeError, "the header 'mine' is unknown")}
+  end
+end

data/spec/unit/header/color_spec.rb

@@ -0,0 +1,19 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Header, 'color' do
+
+  context 'when default' do
+
+  end
+
+  context 'when ascii' do
+    let(:renderer) { :ascii }
+    let(:red)      { "\e[31m" }
+    let(:clear)    { "\e[0m" }
+
+    xit 'renders header background in color' do
+    end
+  end
+end

data/spec/unit/header/equality_spec.rb

@@ -0,0 +1,51 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Header, '#==' do
+  let(:attributes) { [:id, :name] }
+  let(:object) { described_class.new(attributes) }
+
+  subject { object == other }
+
+  context 'with the same object' do
+    let(:other) { object }
+
+    it { is_expected.to eql(true) }
+
+    it 'is symmetric' do
+      is_expected.to eql(other == object)
+    end
+  end
+
+  context 'with an equivalent object' do
+    let(:other) { object.dup }
+
+    it { is_expected.to eql(true) }
+
+    it 'is symmetric' do
+      is_expected.to eql(other == object)
+    end
+  end
+
+  context 'with an equivalent object of subclass' do
+    let(:other) { Class.new(described_class).new(attributes) }
+
+    it { is_expected.to eql(true) }
+
+    it 'is symmetric' do
+      is_expected.to eql(other == object)
+    end
+  end
+
+  context 'with an object having different attributes' do
+    let(:other_attributes) { [:text] }
+    let(:other) { described_class.new(other_attributes) }
+
+    it { is_expected.to eql(false) }
+
+    it 'is symmetric' do
+      is_expected.to eql(other == object)
+    end
+  end
+end

data/spec/unit/header/height_spec.rb

@@ -0,0 +1,27 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Header, '#height' do
+  let(:object) { described_class.new header }
+
+  subject { object.height }
+
+  context 'single row' do
+    let(:header) { ['h1', 'h1'] }
+
+    it { expect(subject).to eql(1) }
+  end
+
+  context 'non escaped multiline' do
+    let(:header) { ["h1\nh1\nh1", 'h2'] }
+
+    it { expect(subject).to eql(3)}
+  end
+
+  context 'escaped multiline' do
+    let(:header) { ["h1\\h1\\h1", 'h2'] }
+
+    it { expect(subject).to eql(1) }
+  end
+end

data/spec/unit/header/new_spec.rb

@@ -0,0 +1,25 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Header, '#new' do
+  let(:object) { described_class }
+
+  context 'with no arguments' do
+    subject { object.new }
+
+    it { is_expected.to be_instance_of(object) }
+
+    it { is_expected.to be_empty }
+  end
+
+  context 'with attributes' do
+    subject { object.new(attributes) }
+
+    let(:attributes) { ['id', 'name', 'age'] }
+
+    it { is_expected.to be_instance_of(object) }
+
+    it { is_expected == attributes }
+  end
+end

data/spec/unit/header/set_spec.rb

@@ -0,0 +1,20 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Header, '#set' do
+  let(:object) { described_class }
+  let(:attributes) { [:id, :name, :age] }
+
+  subject(:header) { object.new }
+
+  it 'sets the value' do
+    header[0] = :id
+    expect(header[0]).to eql(:id)
+  end
+
+  it 'gets the value' do
+    head = object.new [{value: :id}]
+    expect(head[0]).to eq(:id)
+  end
+end

data/spec/unit/header/to_ary_spec.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Header, '#to_ary' do
+  let(:object)     { described_class.new(attributes) }
+  let(:attributes) { [:id, :name, :age] }
+
+  subject { object.to_ary }
+
+  it { is_expected.to be_instance_of(Array) }
+
+  it { is_expected.to eq(attributes) }
+end

data/spec/unit/header_spec.rb

@@ -0,0 +1,13 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table, '#header' do
+  let(:header) { [:header1, :header2] }
+  let(:rows)   { [['a1', 'a2'], ['b1', 'b2']] }
+  let(:object) { described_class }
+
+  subject(:table) { object.new header, rows }
+
+  it { expect(table.header).to be_instance_of(TTY::Table::Header) }
+end

data/spec/unit/indentation/insert_indent_spec.rb

@@ -0,0 +1,27 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table::Indentation, '#insert_indent' do
+  let(:indent) { 2 }
+  let(:renderer) { double(:renderer, indent: indent) }
+  let(:object)  { described_class.new(renderer) }
+
+  subject { object.insert_indent(part) }
+
+  context 'when enumerable' do
+    let(:part) { ['line1'] }
+
+    it 'inserts indentation for each element' do
+      expect(subject[0]).to eql('  line1')
+    end
+  end
+
+  context 'when string' do
+    let(:part) { 'line1' }
+
+    it 'inserts indentation' do
+      expect(subject).to eql('  line1')
+    end
+  end
+end