tty-table 0.1.0 → 0.2.0

data/spec/unit/column_set/extract_widths_spec.rb

@@ -3,13 +3,46 @@
 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 }
+  let(:color) { Pastel.new(enabled: true) }
 
   it 'extract widths' do
-    expect(subject.extract_widths).to eql([2,2,2])
+    header = ['h1', 'h2', 'h3']
+    rows   = [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3']]
+    table = TTY::Table.new header, rows
+    column_set = TTY::Table::ColumnSet.new(table)
+    expect(column_set.extract_widths).to eql([2,2,2])
+  end
+
+  it "extracts widths from utf" do
+    header = ['h1', 'うなじ']
+    rows   = [['こんにちは', 'a2'], ['b1','選択']]
+    table  = TTY::Table.new header, rows
+    column_set = TTY::Table::ColumnSet.new(table)
+    expect(column_set.extract_widths).to eql([10,6])
+  end
+
+  it "extracts widths from multiline text" do
+    table = TTY::Table.new
+    table << ["Multi\nLine\nContent", "Text\nthat\nwraps"]
+    table << ["Some\nother\ntext", 'Simple']
+    column_set = TTY::Table::ColumnSet.new(table)
+    expect(column_set.extract_widths).to eq([7,6])
+  end
+
+  it "extracts widths from multiline text" do
+    table = TTY::Table.new
+    table << ["Multi\\nLine\\nContent", "Text\\nthat\\nwraps"]
+    table << ["Some\\nother\\ntext", 'Simple']
+    column_set = TTY::Table::ColumnSet.new(table)
+    expect(column_set.extract_widths).to eq([20, 17])
+  end
+
+  it "extracts widths from ANSI text" do
+    header = [color.green('h1'), 'h2']
+    table = TTY::Table.new header: header
+    table << [color.green.on_blue('a1'), 'a2']
+    table << ['b1', color.red.on_yellow('b2')]
+    column_set = TTY::Table::ColumnSet.new(table)
+    expect(column_set.extract_widths).to eq([2,2])
   end
 end

data/spec/unit/data_spec.rb

@@ -2,13 +2,11 @@
 
 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 }
-
+RSpec.describe TTY::Table, '.data' do
   it 'gets all table data' do
+    header = ['h1', 'h2', 'h3']
+    rows = [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3']]
+    table = described_class.new header, rows
     expect(table.data).to eql([header] + rows)
   end
 end

data/spec/unit/each_spec.rb

@@ -3,39 +3,24 @@
 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 }
+  subject(:table) { described_class.new(header, rows) }
 
-    it { is_expected.to be_instance_of(to_enum.class) }
+  context 'with no block' do
+    it { expect(table.each).to be_instance_of(to_enum.class) }
 
     it 'yields the expected values' do
-      expect(subject.to_a).to eql(table.to_a)
+      expect(table.each.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)
+    it 'yields each row' do
+      yields = []
+      table.each { |row| yields << row }
+      expect(yields).to eql(table.to_a)
     end
   end
 end

data/spec/unit/each_with_index_spec.rb

@@ -3,54 +3,48 @@
 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 'returns enumerable' do
+      table = TTY::Table.new ['h1','h2'], [['a1','a2'],['b1','b2']]
+      expect(table.each_with_index).to be_instance_of(to_enum.class)
+    end
 
     it 'yields the expected values' do
-      expect(subject.to_a).to eql(object.to_a)
+      table = TTY::Table.new ['h1','h2'], [['a1','a2'],['b1','b2']]
+      expect(table.each_with_index.to_a).to eql(table.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 )
+        yields = []
+        table = TTY::Table.new [['a1','a2'],['b1','b2']]
+        expected = [
+          [['a1','a2'], 0],
+          [['b1','b2'], 1]
+        ]
+        expect {
+          table.each_with_index { |row, indx| yields << [row, indx] }
+        }.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 )
+        yields = []
+        table = TTY::Table.new ['h1','h2'], [['a1','a2'],['b1','b2']]
+
+        expected = [
+          [['h1','h2'], 0],
+          [['a1','a2'], 1],
+          [['b1','b2'], 2]
+        ]
+
+        expect {
+          table.each_with_index { |row, indx| yields << [row, indx] }
+        }.to change { yields }.from( [] ).to( expected )
       end
     end
   end

data/spec/unit/field/length_spec.rb

@@ -2,20 +2,34 @@
 
 require 'spec_helper'
 
-RSpec.describe TTY::Table::Field, '#length' do
-  let(:object) { described_class.new value }
+RSpec.describe TTY::Table::Field, '.length' do
+  it "calculates length for nil string" do
+    field = described_class.new(nil)
+    expect(field.length).to eq(0)
+  end
 
-  subject { object.length }
+  it "calculates length for empty string" do
+    field = described_class.new('')
+    expect(field.length).to eq(0)
+  end
 
-  context 'with escaped value' do
-    let(:value) { "Multi\nLine" }
+  it "calculates maximum length for multiline string" do
+    field = described_class.new("Multi\nLine\nContent")
+    expect(field.length).to eq(7)
+  end
 
-    it { is_expected.to eql(5) }
+  it "calculates length for unicode string" do
+    field = described_class.new('こんにちは')
+    expect(field.length).to eq(10)
   end
 
-  context 'with unescaped value' do
-    let(:value) { "Multi\\nLine" }
+  it "calculates length for escaped string" do
+    field = described_class.new("Multi\\nLine")
+    expect(field.length).to eq(11)
+  end
 
-    it { is_expected.to eql(11) }
+  it "calculates length for colored string" do
+    field = described_class.new("\e[32;41mgreen on red\e[0m")
+    expect(field.length).to eq(12)
   end
 end

data/spec/unit/field/width_spec.rb

@@ -18,6 +18,6 @@ RSpec.describe TTY::Table::Field, '#width' do
   context 'with hash value' do
     let(:value) { "foo\nbaar" }
 
-    it { is_expected.to eql(8) }
+    it { is_expected.to eql(7) }
   end
 end

data/spec/unit/filter_spec.rb

@@ -5,16 +5,15 @@ 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
+  subject(:table)  { described_class.new(header, rows) }
+
+  it 'filters fields' do
     expect(table.render do |renderer|
-      renderer.filter = filter
-    end).to eq <<-EOS.normalize
+      renderer.filter = proc do |val, row, col|
+        (col == 1 && row > 0) ? val.capitalize : val
+      end
+    end).to eq unindent(<<-EOS)
       h1 h2 h3
       a1 A2 a3
       b1 B2 b3

data/spec/unit/header/new_spec.rb

@@ -3,23 +3,14 @@
 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 }
+  it "is empty without arguments" do
+    header = TTY::Table::Header.new
+    expect(header).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 }
+  it "isn't empty with attributes" do
+    header = TTY::Table::Header.new [:id, :name, :age]
+    expect(header.to_a).to eq([:id, :name, :age])
   end
 end

data/spec/unit/indentation/indent_spec.rb

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

data/spec/unit/new_spec.rb

@@ -0,0 +1,73 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Table, '#new' do
+  it { is_expected.to be_kind_of(Enumerable) }
+
+  it { is_expected.to be_kind_of(Comparable) }
+
+  context 'with rows only' do
+    it 'allows hash like syntax for rows' do
+      table = TTY::Table[['a1','a2'], ['b1', 'b2']]
+      expect(table.to_a).to eql([['a1','a2'], ['b1', 'b2']])
+    end
+
+    it 'allows for array' do
+      table = TTY::Table.new [['a1','a2'], ['b1','b2']]
+      expect(table.to_a).to eql([['a1','a2'], ['b1','b2']])
+    end
+
+    it 'allows for :rows key' do
+      table = TTY::Table.new rows: [['a1','a2'], ['b1','b2']]
+      expect(table.to_a).to eql([['a1','a2'], ['b1','b2']])
+    end
+
+    it 'allows for rows in a block' do
+      table = TTY::Table.new do |t|
+        t << ['a1', 'a2']
+        t << ['b1', 'b2']
+      end
+      expect(table.to_a).to eql([['a1','a2'],['b1','b2']])
+    end
+
+    it 'allows to add rows after initialization' do
+      table = TTY::Table.new
+      table << ['a1','a2']
+      table << ['b1','b2']
+      expect(table.to_a).to eql([['a1','a2'],['b1','b2']])
+    end
+
+    it 'allows for chaining rows' do
+      table = TTY::Table.new
+      table << ['a1','a2'] << ['b1','b2']
+      expect(table.to_a).to eql([['a1','a2'],['b1','b2']])
+    end
+  end
+
+  context 'with header and rows' do
+    it 'permits header and rows' do
+      table = TTY::Table.new ['h1','h2'], [['a1','a2'],['b1','b2']]
+      expect(table.to_a).to eql([['h1','h2'], ['a1','a2'], ['b1','b2']])
+    end
+
+    it 'permits only header with :header key' do
+      table = TTY::Table.new header: ['h1','h2']
+      expect(table.to_a).to eql([['h1','h2']])
+    end
+  end
+
+  context 'with header and rows as hash' do
+    it 'permits header as key and rows as hash values' do
+      table = TTY::Table.new [{'h1' => ['a1','a2'], 'h2' => ['b1','b2']}]
+      expect(table.to_a).to eql([['h1','h2'], ['a1','a2'], ['b1','b2']])
+    end
+  end
+
+  context 'coercion' do
+    it 'converts row arguments from hash to array' do
+      table = TTY::Table.new rows: {a: 1, b: 2}
+      expect(table.to_a).to eql([[:a,1],[:b,2]])
+    end
+  end
+end

data/spec/unit/operation/{alignment_set → alignment}/call_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-RSpec.describe TTY::Table::Operation::AlignmentSet, '#call' do
+RSpec.describe TTY::Table::Operation::Alignment, '#call' do
   let(:object) { described_class.new alignments, widths }
   let(:value)  { 'a1' }
   let(:field)  { TTY::Table::Field.new(value)}

data/spec/unit/operation/escape/call_spec.rb

@@ -7,10 +7,9 @@ RSpec.describe TTY::Table::Operation::Escape, '#call' do
   let(:text)   { "太丸\nゴシ\tック体\r" }
   let(:field)  { TTY::Table::Field.new(text) }
 
-  subject { object.new }
+  subject(:operation) { object.new }
 
   it 'changes field value' do
-    subject.call(field, 0, 0)
-    expect(field.value).to eql("太丸\\nゴシ\\tック体\\r")
+    expect(operation.call(field, 0, 0)).to eql("太丸\\nゴシ\\tック体\\r")
   end
 end

data/spec/unit/operation/filter/call_spec.rb

@@ -8,10 +8,9 @@ RSpec.describe TTY::Table::Operation::Filter, '#call' do
   let(:filter) { Proc.new { |val, row, col| 'new' } }
   let(:value)  { 'new' }
 
-  subject { object.new(filter) }
+  subject(:operation) { object.new(filter) }
 
   it 'changes field value' do
-    subject.call(field, 0, 0)
-    expect(field.value).to eql(value)
+    expect(operation.call(field, 0, 0)).to eql(value)
   end
 end