tty 0.0.7 → 0.0.8

data/spec/tty/table/field/width_spec.rb

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe TTY::Table::Field, '#width' do
+  let(:object) { described_class }
+
+  subject { object.new value }
+
+  context 'with only value' do
+    let(:value) { 'foo' }
+
+    its(:width) { should == 3 }
+  end
+
+  context 'with hash value' do
+    let(:value) { "foo\nbaar" }
+
+    its(:width) { should == 8 }
+  end
+end

data/spec/tty/table/header/call_spec.rb

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

data/spec/tty/table/header/new_spec.rb

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

data/spec/tty/table/header/set_spec.rb

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

data/spec/tty/table/header/to_ary_spec.rb

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

data/spec/tty/table/header_spec.rb

@@ -0,0 +1,14 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe TTY::Table, '#header' do
+
+  let(:header) { [:header1, :header2] }
+  let(:rows)   { [['a1', 'a2'], ['b1', 'b2']] }
+  let(:object) { described_class }
+
+  subject { object.new header, rows }
+
+  its(:header) { should be_instance_of TTY::Table::Header }
+end

data/spec/tty/table/operation/alignment_set/align_rows_spec.rb

@@ -2,9 +2,16 @@
 
 require 'spec_helper'
 
+def to_field(value)
+ TTY::Table::Field.new(value)
+end
+
 describe TTY::Table::Operation::AlignmentSet, '#align_rows' do
   let(:object)  { described_class.new alignments }
-  let(:rows) { [['a1', 'a2'], ['b1', 'b2']] }
+  let(:rows) {
+    [[to_field('a1'), to_field('a2')],
+     [to_field('b1'), to_field('b2')]]
+  }
 
   subject { object.align_rows rows, :column_widths => widths }
 

data/spec/tty/table/operation/truncation/call_spec.rb

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe TTY::Table::Operation::Truncation, '#call' do
+  let(:object) { described_class.new }
+  let(:text) { '太丸ゴシック体' }
+  let(:row) { [TTY::Table::Field.new(text), TTY::Table::Field.new(text)] }
+
+  context 'without column width' do
+    it "truncates string" do
+      object.call(row)
+      expect(row[0]).to eql(text)
+      expect(row[1]).to eql(text)
+    end
+  end
+
+  context 'with column width ' do
+    let(:column_widths) { [3, 6] }
+
+    it "truncates string" do
+      object.call(row, :column_widths => column_widths)
+      expect(row[0]).to eql('太丸…')
+      expect(row[1]).to eql('太丸ゴシッ…')
+    end
+  end
+end

data/spec/tty/table/operation/wrapped/call_spec.rb

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe TTY::Table::Operation::Wrapped, '#call' do
+  let(:object) { described_class.new }
+  let(:text) { 'ラドクリフ、マラソン五輪代表に1万m出場にも含み' }
+  let(:row) { [TTY::Table::Field.new(text), TTY::Table::Field.new(text)] }
+
+  context 'without column width' do
+    it "doesn't wrap string" do
+      object.call(row)
+      expect(row[0]).to eql(text)
+      expect(row[1]).to eql(text)
+    end
+  end
+
+  context 'with column width' do
+    let(:column_widths) { [12, 14] }
+
+    it "truncates string" do
+      object.call(row, :column_widths => column_widths)
+      expect(row[0]).to eql("ラドクリフ、マラソン五輪\n代表に1万m出場にも含み")
+      expect(row[1]).to eql("ラドクリフ、マラソン五輪代表\nに1万m出場にも含み")
+    end
+  end
+end

data/spec/tty/table/operations/new_spec.rb

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe TTY::Table::Operations, '#new' do
+  let(:object) { described_class }
+  let(:row) { [1,2,3] }
+  let(:table) { TTY::Table.new :rows => [row] }
+  let(:callable) {
+    Class.new do
+      def call(row, options)
+        row.map! { |r| r + 1}
+      end
+    end
+  }
+  let(:instance) { callable.new }
+
+  subject { object.new table }
+
+  before {
+    subject.add_operation(:alignment, instance)
+  }
+
+  it 'stores away operations' do
+    expect(subject.operations[:alignment]).to include(instance)
+  end
+
+  it 'runs selected operations' do
+    subject.run_operations(:alignment, row)
+    expect(row).to eql([2,3,4])
+  end
+end

data/spec/tty/table/options_spec.rb

@@ -6,22 +6,30 @@ describe TTY::Table, 'options' do
   let(:rows)   { [['a1', 'a2'], ['b1', 'b2']] }
   let(:widths) { nil }
   let(:aligns) { [] }
-  let(:object) {
-    described_class.new rows,
+  let(:object) { described_class }
+  let(:options) {
+    {
       :column_widths => widths,
       :column_aligns  => aligns,
       :renderer => :basic
+    }
   }
 
-  subject { object.to_s; object.renderer }
+  subject { object.new rows, options }
 
-  its(:column_widths) { should == [2,2] }
+  its(:header) { should be_nil }
 
-  its(:alignments) { should be_kind_of TTY::Table::Operation::AlignmentSet }
+  its(:rows) { should == rows }
 
-  it 'is empty' do
-    subject.alignments.to_a.should be_empty
-  end
+  its(:border) { should be_kind_of TTY::Table::BorderOptions }
+
+  its(:orientation) { should be_kind_of TTY::Table::Orientation::Horizontal }
+
+  its(:column_widths) { should be_empty }
+
+  its(:column_aligns) { should eql(aligns) }
+
+  it { subject.column_aligns.to_a.should be_empty }
 
   context '#column_widths' do
     let(:widths) { [10, 10] }
@@ -39,7 +47,7 @@ describe TTY::Table, 'options' do
     let(:aligns) { [:center, :center] }
 
     it 'unwraps original array' do
-      subject.alignments.to_a.should == aligns
+      subject.column_aligns.to_a.should == aligns
     end
   end
 end

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

@@ -2,39 +2,86 @@
 
 require 'spec_helper'
 
-describe TTY::Table::Renderer::Basic, 'alignment' do
+describe TTY::Table, 'alignment' do
   let(:header) { ['h1', 'h2', 'h3'] }
-  let(:rows) { [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3']] }
-
-  it 'aligns left by default' do
-    header = ['h1', 'h2']
-    rows = [['aaaaa', 'a'], ['b', 'bbbbb']]
-    table = TTY::Table.new header, rows, :renderer => :basic
-    table.to_s.should == <<-EOS.normalize
-      h1    h2   
-      aaaaa a    
-      b     bbbbb
-    EOS
+  let(:rows)   { [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3']] }
+  let(:options) { { :renderer => :basic, :column_aligns => column_aligns }}
+
+  subject(:table) { described_class.new header, rows, 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
+      table.to_s.should == <<-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
+      table.to_s.should == <<-EOS.normalize
+        header1 head2 h3
+        a1       a2   a3
+        b1       b2   b3
+      EOS
+    end
   end
 
-  it 'aligns table headers' do
-    header = ['header1', 'head2', 'h3']
-    table = TTY::Table.new header, rows, :render => :basic,
-      :column_aligns => [:left, :center, :right]
-    table.to_s.should == <<-EOS.normalize
-      header1 head2 h3
-      a1       a2   a3
-      b1       b2   b3
-    EOS
+  context 'with different aligns' do
+    let(:header) { nil }
+    let(:rows) { [['aaaaa', 'a'], ['b', 'bbbbb']] }
+    let(:column_aligns)  { [:left, :right] }
+
+    it 'aligns table rows' do
+      table.to_s.should == <<-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] }
+
+    it "takes individual fields over global aligns" do
+      options = {:header => header, :column_aligns => column_aligns, :renderer => :basic}
+      table = described_class.new options do |t|
+        t << ['a1', 'a2', 'a3']
+        t << ['b1', {:value => 'b2', :align => :right}, 'b3']
+        t << ['c1', 'c2', {:value => 'c3', :align => :center}]
+      end
+      table.to_s.should == <<-EOS.normalize
+        header1 header2 header3
+        a1        a2         a3
+        b1           b2      b3
+        c1        c2      c3   
+      EOS
+    end
   end
 
-  it 'aligns table rows' do
-    rows = [['aaaaa', 'a'], ['b', 'bbbbb']]
-    table = TTY::Table.new rows, :renderer => :basic,
-                                  :column_aligns => [:left, :right]
-    table.to_s.should == <<-EOS.normalize
-      aaaaa     a
-      b     bbbbb
-    EOS
+  context 'with aligned header' do
+    let(:rows) { [['aaaaa1', 'a2', 'aaa3'], ['b1', 'bbbb2', 'bb3']] }
+
+    it "aligns headres" do
+      header = ['h1', {:value => 'h2', :align => :right}, {:value => 'h3', :align => :center}]
+      options = {:header => header, :renderer => :basic, :rows => rows }
+      table = described_class.new options
+      table.to_s.should == <<-EOS.normalize
+        h1        h2  h3 
+        aaaaa1 a2    aaa3
+        b1     bbbb2 bb3 
+      EOS
+    end
+
   end
 end

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

@@ -0,0 +1,99 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe TTY::Table, 'with separator' do
+  let(:header) { ['h1', 'h2', 'h3'] }
+  let(:rows) { [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3']] }
+
+  subject(:table) { described_class.new header, rows, :renderer => renderer }
+
+  context 'when default' do
+    let(:renderer) { :basic }
+
+    it "sets through hash" do
+      table.border :separator => :each_row
+      expect(table.border.separator).to eql(:each_row)
+    end
+
+    it "sets through attribute" do
+      table.border.separator= :each_row
+      expect(table.border.separator).to eql(:each_row)
+    end
+
+    it "sets through block" do
+      table.border do
+        separator :each_row
+      end
+      expect(table.border.separator).to eql(:each_row)
+    end
+
+    it "renders each row" do
+      table.border.separator= :each_row
+      table.to_s.should == <<-EOS.normalize
+        h1 h2 h3
+
+        a1 a2 a3
+
+        b1 b2 b3
+      EOS
+    end
+  end
+
+  context 'when ascii' do
+    let(:renderer) { :ascii }
+
+    it "renders each row" do
+      table.border.separator= :each_row
+      table.to_s.should == <<-EOS.normalize
+        +--+--+--+
+        |h1|h2|h3|
+        +--+--+--+
+        |a1|a2|a3|
+        +--+--+--+
+        |b1|b2|b3|
+        +--+--+--+
+      EOS
+    end
+
+    context 'with specific separator' do
+      let(:header) { ['h1', 'h2'] }
+      let(:rows) { [['a1', 'a2'], ['b1', 'b2'], ['c1', 'c2']] }
+
+      it 'custom separator' do
+        pending
+        table.border.separator= [2]
+        table.to_s.should == <<-EOS.normalize
+          +--+--+
+          |h1|h2|
+          +--+--+
+          |a1|a2|
+          |b1|b2|
+          +--+--+
+          |c1|c2|
+          +--+--+
+        EOS
+      end
+
+    end
+
+  end
+
+  context 'when unicode' do
+    let(:renderer) { :unicode }
+
+    it "renders each row" do
+      table.border.separator= :each_row
+      table.to_s.should == <<-EOS.normalize
+        ┌──┬──┬──┐
+        │h1│h2│h3│
+        ├──┼──┼──┤
+        │a1│a2│a3│
+        ├──┼──┼──┤
+        │b1│b2│b3│
+        └──┴──┴──┘
+      EOS
+    end
+  end
+
+end

data/spec/tty/table/renderer_spec.rb

@@ -4,6 +4,7 @@ require 'spec_helper'
 
 describe TTY::Table, '#renderer' do
   let(:basic_renderer)   { TTY::Table::Renderer::Basic }
+  let(:ascii_renderer)   { TTY::Table::Renderer::ASCII }
   let(:unicode_renderer) { TTY::Table::Renderer::Unicode }
 
   before do
@@ -25,7 +26,12 @@ describe TTY::Table, '#renderer' do
     table.renderer.should be_kind_of(basic_renderer)
   end
 
-  it 'allows to set instance renderer' do
+  it 'allows to set ascii instance renderer' do
+    table = TTY::Table.new :renderer => :ascii
+    expect(table.renderer).to be_kind_of(ascii_renderer)
+  end
+
+  it 'allows to set unicode instance renderer' do
     table = TTY::Table.new :renderer => :unicode
     table.renderer.should be_kind_of(unicode_renderer)
   end

data/spec/tty/table/renders_with_spec.rb

@@ -7,32 +7,41 @@ describe TTY::Table, '#renders_with' do
   let(:rows) { [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3']] }
   let(:table) { described_class.new header, rows }
 
+  context 'with invalid border class' do
+    it "doesn't inherit from TTY::Table::Border" do
+      expect { table.renders_with String }.to raise_error(TTY::TypeError)
+    end
+
+    it "doesn't implement def_border" do
+      klass = Class.new(TTY::Table::Border)
+      expect { table.renders_with klass }.to raise_error(TTY::NoImplementationError)
+    end
+  end
+
   context 'with complete border' do
-    let(:border_class) {
+    before {
       class MyBorder < TTY::Table::Border
         def_border do
-          {
-            'top'          => '=',
-            'top_mid'      => '*',
-            'top_left'     => '*',
-            'top_right'    => '*',
-            'bottom'       => '=',
-            'bottom_mid'   => '*',
-            'bottom_left'  => '*',
-            'bottom_right' => '*',
-            'mid'          => '=',
-            'mid_mid'      => '*',
-            'mid_left'     => '*',
-            'mid_right'    => '*',
-            'left'         => '$',
-            'right'        => '$'
-          }
+          top          '='
+          top_mid      '*'
+          top_left     '*'
+          top_right    '*'
+          bottom       '='
+          bottom_mid   '*'
+          bottom_left  '*'
+          bottom_right '*'
+          mid          '='
+          mid_mid      '*'
+          mid_left     '*'
+          mid_right    '*'
+          left         '$'
+          center       '$'
+          right        '$'
         end
       end
     }
 
     it 'displays custom border' do
-      border_class
       table.renders_with MyBorder
       table.to_s.should == <<-EOS.normalize
         *==*==*==*
@@ -46,23 +55,21 @@ describe TTY::Table, '#renders_with' do
   end
 
   context 'with incomplete border' do
-    let(:border_class) {
+    before {
       class MyBorder < TTY::Table::Border
         def_border do
-          {
-            'bottom'       => ' ',
-            'bottom_mid'   => '*',
-            'bottom_left'  => '*',
-            'bottom_right' => '*',
-            'left'         => '$',
-            'right'        => '$'
-          }
+          bottom       ' '
+          bottom_mid   '*'
+          bottom_left  '*'
+          bottom_right '*'
+          left         '$'
+          center       '$'
+          right        '$'
         end
       end
     }
 
     it 'displays border' do
-      border_class
       table.renders_with MyBorder
       table.to_s.should == <<-EOS.normalize
         $h1$h2$h3$

data/spec/tty/table/rotate_spec.rb

@@ -64,6 +64,7 @@ describe TTY::Table, '#rotate' do
     it 'rotates the rows and header back' do
       subject.orientation = :vertical
       subject.rotate
+      expect(subject.orientation).to be_a TTY::Table::Orientation::Vertical
       subject.orientation = :horizontal
       expect(subject.rotate.to_a).to eql rows
       expect(subject.header).to eql header

data/spec/tty/table/row/access_spec.rb

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe TTY::Table::Row, '#access' do
+  let(:object) { described_class.new [] }
+
+  before { object[attribute] = value}
+
+  subject { object[attribute] }
+
+  context 'when integer' do
+    let(:attribute) { 0 }
+    let(:value) { 1 }
+
+    it { should == 1 }
+  end
+
+  context 'when symbol' do
+    let(:attribute) { :id }
+    let(:value) { 1 }
+
+    it { should == 1 }
+  end
+end