tty 0.0.7 → 0.0.8

data/lib/tty.rb

@@ -16,6 +16,7 @@ require 'tty/text'
 require 'tty/vector'
 require 'tty/shell'
 require 'tty/coercer'
+require 'tty/logger'
 
 require 'tty/coercer/range'
 require 'tty/coercer/integer'
@@ -34,10 +35,19 @@ require 'tty/terminal/color'
 require 'tty/terminal/echo'
 require 'tty/terminal/home'
 
+require 'tty/system/which'
+
 require 'tty/text/wrapping'
 require 'tty/text/truncation'
 
+require 'tty/table/field'
+require 'tty/table/header'
+require 'tty/table/row'
+require 'tty/table/options'
+
 require 'tty/table/border'
+require 'tty/table/border_dsl'
+require 'tty/table/border_options'
 require 'tty/table/border/unicode'
 require 'tty/table/border/ascii'
 require 'tty/table/border/null'
@@ -47,6 +57,7 @@ require 'tty/table/orientation'
 require 'tty/table/orientation/horizontal'
 require 'tty/table/orientation/vertical'
 
+require 'tty/table/operations'
 require 'tty/table/operation/alignment_set'
 require 'tty/table/operation/alignment'
 require 'tty/table/operation/truncation'
@@ -57,6 +68,9 @@ module TTY
   # Raised when the argument type is different from expected
   class TypeError < ArgumentError; end
 
+  # Raised when the operation is not implemented
+  class NoImplementationError < NotImplementedError; end
+
   # Raised when the required argument is not supplied
   class ArgumentRequired < ArgumentError; end
 
@@ -72,6 +86,13 @@ module TTY
   # Raised when the passed in validation argument is of wrong type
   class ValidationCoercion < TypeError; end
 
+  # Raised when the attribute is unknown
+  class UnknownAttributeError < IndexError; end
+
+
+  # An empty array used as a default value
+  EMPTY_ARRAY = Array.new.freeze
+
   class << self
 
     # Return terminal instance

data/spec/tty/logger/new_spec.rb

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe TTY::Logger, '#new' do
+  let(:object) { described_class }
+  let(:output) { StringIO.new }
+
+  subject { object.new options }
+
+  context 'when default' do
+    let(:options) { {:namespace => ''} }
+
+    its(:level) { should eql object::ALL }
+
+    its(:output) { should eql $stderr }
+
+    its(:timestamp_format) { should eql '%Y-%m-%d %T' }
+  end
+
+  context 'when custom' do
+    let(:options) { {
+      :namespace => 'tty::color',
+      :level => 2,
+      :output => output,
+      :timestamp_format => "%dd" } }
+
+    its(:namespace) { should eql 'tty::color' }
+
+    its(:level) { should eql 2 }
+
+    its(:output) { should eql output }
+
+    its(:timestamp_format) { should eql '%dd' }
+  end
+end

data/spec/tty/logger/valid_level_spec.rb

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe TTY::Logger, '#valid_level' do
+  let(:object) { described_class }
+
+  subject { object.valid_level?(level) }
+
+  context 'when level is nil' do
+    let(:level) { nil }
+
+    it { should be_false }
+  end
+
+  context 'when level is non numeric' do
+    let(:level) { 'a' }
+
+    it { should be_false }
+  end
+
+  context 'when level is not a valid number' do
+    let(:level) { -1 }
+
+    it { should be_false }
+  end
+
+  context 'when level is valid number' do
+    let(:level) { 0 }
+
+    it { should be_true }
+  end
+end

data/spec/tty/system/platform_spec.rb

@@ -9,6 +9,8 @@ describe TTY::System, '#platform' do
 
   it { should respond_to(:unix?) }
 
+  it { should respond_to(:which) }
+
   it 'checks if windows' do
     RbConfig::CONFIG.stub(:[]).with('host_os').and_return 'windows'
     subject.windows?.should be_true
@@ -18,4 +20,10 @@ describe TTY::System, '#platform' do
     RbConfig::CONFIG.stub(:[]).with('host_os').and_return 'darwin'
     subject.unix?.should be_true
   end
+
+  it 'delegates to which' do
+    command = 'ruby'
+    TTY::System::Which.should_receive(:new).with(command)
+    subject.which(command)
+  end
 end

data/spec/tty/system/which_spec.rb

@@ -0,0 +1,41 @@
+
+require 'spec_helper'
+
+describe TTY::System::Which, '#which' do
+  let(:path) { "/usr/local/bin:/usr/local/git/bin" }
+  let(:extension) { '.bat' }
+
+  context 'without extension' do
+    before {
+      ENV.stub(:[]).with('PATHEXT').and_return(nil)
+      ENV.stub(:[]).with('PATH').and_return(path)
+    }
+
+    it 'finds command' do
+      File.stub(:executable?) { true }
+      expect(subject.which("ruby")).to eql "/usr/local/bin/ruby"
+    end
+
+    it "doesn't find command" do
+      File.stub(:executable?) { false }
+      expect(subject.which("ruby")).to be_nil
+    end
+  end
+
+  context 'with extension' do
+    before {
+      ENV.stub(:[]).with('PATHEXT').and_return(extension)
+      ENV.stub(:[]).with('PATH').and_return(path)
+    }
+
+    it 'finds command' do
+      File.stub(:executable?) { true }
+      expect(subject.which("ruby")).to eql "/usr/local/bin/ruby.bat"
+    end
+
+    it "doesn't find command" do
+      File.stub(:executable?) { false }
+      expect(subject.which("ruby")).to be_nil
+    end
+  end
+end

data/spec/tty/table/access_spec.rb

@@ -3,8 +3,9 @@
 require 'spec_helper'
 
 describe TTY::Table, 'access' do
+  let(:header) { [:head1, :head2] }
   let(:rows) { [['a1', 'a2'], ['b1', 'b2']] }
-  subject { TTY::Table.new :rows => rows }
+  subject { TTY::Table.new :rows => rows, :header => header }
 
   it { should respond_to(:element) }
 
@@ -49,6 +50,16 @@ describe TTY::Table, 'access' do
   end
 
   context '#column' do
+    it "gets based on header name" do
+      subject.column(:head1).should eql ['a1', 'b1']
+    end
+
+    it "yields based on header name" do
+      yielded = []
+      subject.column(:head1) { |el| yielded << el }
+      expect(yielded).to eql(['a1', 'b1'])
+    end
+
     it 'returns nil for wrong index' do
       subject.column(11).should be_nil
     end

data/spec/tty/table/add_row_spec.rb

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+
+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/tty/table/border/new_spec.rb

@@ -3,18 +3,23 @@
 require 'spec_helper'
 
 describe TTY::Table::Border, '#new' do
-  subject { klass.new }
+  let(:row) { [] }
+  subject(:instance) { klass.new row }
 
   context 'when abstract' do
     let(:klass) { described_class }
 
-    specify { expect { subject }.to raise_error(NotImplementedError) }
+    specify { expect { instance }.to raise_error(NotImplementedError) }
   end
 
   context 'when concrete' do
-    let(:klass) { Class.new }
+    let(:klass) {
+      Class.new do
+        def initialize(row); end
+      end
+    }
 
-    specify { expect {subject }.to_not raise_error(NotImplementedError) }
+    specify { expect { instance }.to_not raise_error(NotImplementedError) }
 
     it { should be_instance_of klass }
   end

data/spec/tty/table/border/null/rendering_spec.rb

@@ -3,8 +3,9 @@
 require 'spec_helper'
 
 describe TTY::Table::Border::Null, '#rendering' do
+  let(:border) { nil }
 
-  subject { described_class.new row }
+  subject { described_class.new row, border }
 
   context 'with empty row' do
     let(:row) { [] }
@@ -46,4 +47,41 @@ describe TTY::Table::Border::Null, '#rendering' do
     end
   end
 
+  context 'with border' do
+    let(:row) { ['a1', 'a2', 'a3'] }
+    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).to eql '=a1=a2=a3='
+    end
+  end
+
 end

data/spec/tty/table/border/options/from_spec.rb

@@ -0,0 +1,39 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+
+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/tty/table/border/options/new_spec.rb

@@ -0,0 +1,15 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe TTY::Table::BorderOptions, '.new' do
+
+  subject(:options) { described_class.new }
+
+  its(:characters) { should eql({}) }
+
+  its(:separator) { should be_nil }
+
+  its(:style) { should be_nil }
+
+end # new

data/spec/tty/table/border/style_spec.rb

@@ -0,0 +1,70 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe TTY::Table, 'with style' 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 :style => :red
+      expect(table.border.style).to eql :red
+    end
+
+    it "sets through attribute" do
+      table.border.style = :red
+      expect(table.border.style).to eql :red
+    end
+
+    it "renders without color" do
+      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 }
+    let(:red) { "\e[31m" }
+    let(:clear) { "\e[0m" }
+
+    it "renders border in color" do
+      table.border.style= :red
+
+      table.to_s.should == <<-EOS.normalize
+        #{red}+--+--+--+#{clear}
+        #{red}|#{clear}h1#{red}|#{clear}h2#{red}|#{clear}h3#{red}|#{clear}
+        #{red}+--+--+--+#{clear}
+        #{red}|#{clear}a1#{red}|#{clear}a2#{red}|#{clear}a3#{red}|#{clear}
+        #{red}|#{clear}b1#{red}|#{clear}b2#{red}|#{clear}b3#{red}|#{clear}
+        #{red}+--+--+--+#{clear}
+      EOS
+    end
+  end
+
+  context 'when unicode' do
+    let(:renderer) { :unicode }
+    let(:red) { "\e[31m" }
+    let(:clear) { "\e[0m" }
+
+    it "renders each row" do
+      table.border.style= :red
+      table.to_s.should == <<-EOS.normalize
+        #{red}┌──┬──┬──┐#{clear}
+        #{red}│#{clear}h1#{red}│#{clear}h2#{red}│#{clear}h3#{red}│#{clear}
+        #{red}├──┼──┼──┤#{clear}
+        #{red}│#{clear}a1#{red}│#{clear}a2#{red}│#{clear}a3#{red}│#{clear}
+        #{red}│#{clear}b1#{red}│#{clear}b2#{red}│#{clear}b3#{red}│#{clear}
+        #{red}└──┴──┴──┘#{clear}
+      EOS
+    end
+  end
+
+end

data/spec/tty/table/border_spec.rb

@@ -0,0 +1,107 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe TTY::Table, '#border' do
+  let(:header) { ['h1', 'h2', 'h3'] }
+  let(:rows) { [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3']] }
+  let(:border) { nil }
+
+  subject(:table) { described_class.new header, rows, :renderer => renderer, :border => border }
+
+  context 'when default' do
+    let(:renderer) { :basic }
+    let(:border) { { :characters => {'top' => '-'}, :style => :red } }
+
+    it 'specifies border at initialization' do
+      expect(table.border.style).to eql(:red)
+    end
+
+    it 'specifies border in hash' do
+      table.border border
+      expect(table.border.characters['top']).to eql('-')
+    end
+
+    it 'specifies border in characters attribute' do
+      table.border.characters = {'top' => '-'}
+      expect(table.border.characters['top']).to eql('-')
+    end
+
+    it 'specifies border in block' do
+      table.border do
+        mid          '='
+        mid_mid      ' '
+      end
+
+      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 'specifies border in block' do
+      table.border do
+        mid          '='
+        mid_mid      '='
+        mid_left     '='
+        mid_right    '='
+      end
+
+      table.to_s.should == <<-EOS.normalize
+        +--+--+--+
+        |h1|h2|h3|
+        ==========
+        |a1|a2|a3|
+        |b1|b2|b3|
+        +--+--+--+
+      EOS
+    end
+
+    it 'specifies border as hash' do
+      table.border({ :characters => {
+        'mid'       => '=',
+        'mid_mid'   => '=',
+        'mid_left'  => '=',
+        'mid_right' => '=',
+      }})
+
+      table.to_s.should == <<-EOS.normalize
+        +--+--+--+
+        |h1|h2|h3|
+        ==========
+        |a1|a2|a3|
+        |b1|b2|b3|
+        +--+--+--+
+      EOS
+    end
+  end
+
+  context 'when unicode' do
+    let(:renderer) { :unicode }
+
+    it 'specifies border in block' do
+      table.border do
+        mid          '='
+        mid_mid      '='
+        mid_left     '='
+        mid_right    '='
+      end
+
+      table.to_s.should == <<-EOS.normalize
+        ┌──┬──┬──┐
+        │h1│h2│h3│
+        ==========
+        │a1│a2│a3│
+        │b1│b2│b3│
+        └──┴──┴──┘
+      EOS
+    end
+  end
+
+end # border

data/spec/tty/table/each_with_index_spec.rb

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

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

@@ -0,0 +1,51 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+
+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 { should be_true }
+
+    it 'is symmetric' do
+      should eql(other == object)
+    end
+  end
+
+  context 'with an equivalent object' do
+    let(:other) { object.dup }
+
+    it { should be_true }
+
+    it 'is symmetric' do
+      should eql(other == object)
+    end
+  end
+
+  context 'with an equivalent object of subclass' do
+    let(:other) { Class.new(described_class).new(value) }
+
+    it { should be_true }
+
+    it 'is symmetric' do
+      should 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 { should be_false }
+
+    it 'is symmetric' do
+      should eql(other == object)
+    end
+  end
+end

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

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