tty 0.0.11 → 0.1.0

data/spec/tty/support/fixtures/classes.rb

@@ -1,8 +1,10 @@
-# -*- encoding: utf-8 -*-
+# encoding: utf-8
 
 module TargetSpec
   class Object
-    def output; end
+    def output
+      true
+    end
   end
 end
 

data/spec/tty/system/editor/available_spec.rb

@@ -1,40 +1,40 @@
-# -*- encoding: utf-8 -*-
+# encoding: utf-8
 
 require 'spec_helper'
 
 describe TTY::System::Editor, '#available' do
-  let(:execs) { ['vi', 'emacs'] }
-  let(:editor) { 'sublime' }
+  let(:execs)  { ['vi', 'emacs'] }
+  let(:name) { 'sublime' }
   let(:system) { TTY::System }
 
-  subject { described_class }
+  subject(:editor) { described_class }
 
-  before { subject.stub(:executables).and_return(execs) }
+  before { allow(editor).to receive(:executables).and_return(execs) }
 
   context 'when editor exists' do
     before {
-      system.stub(:exists?).with('vi').and_return(true)
-      system.stub(:exists?).with('emacs').and_return(false)
+      allow(system).to receive(:exists?).with('vi').and_return(true)
+      allow(system).to receive(:exists?).with('emacs').and_return(false)
     }
 
     it 'finds single command' do
-      expect(subject.available).to eql('vi')
+      expect(editor.available).to eql('vi')
     end
   end
 
   context 'when no command exists' do
-    before { system.stub(:exists?).and_return(false) }
+    before { allow(system).to receive(:exists?).and_return(false) }
 
     it "doesn't find command" do
-      expect(subject.available).to be_nil
+      expect(editor.available).to be_nil
     end
   end
 
   context 'when custom command' do
-    before { system.stub(:exists?).with(editor).and_return(true) }
+    before { allow(system).to receive(:exists?).with(name).and_return(true) }
 
     it "takes precedence over other commands" do
-      expect(subject.available(editor)).to eql(editor)
+      expect(editor.available(name)).to eql(name)
     end
   end
 end

data/spec/tty/system/editor/build_spec.rb

@@ -1,25 +1,20 @@
-# -*- encoding: utf-8 -*-
+# encoding: utf-8
 
 require 'spec_helper'
 
 describe TTY::System::Editor, '#build' do
   let(:file) { "/users/piotr/hello world.rb" }
-  let(:editor) { "vim" }
+  let(:name) { "vim" }
   let(:object) { described_class }
 
-  subject { object.new(file) }
+  subject(:editor) { object.new(file) }
 
-  before { object.stub(:command).and_return(editor) }
+  before { allow(object).to receive(:command).and_return(name) }
 
   context 'when on windows' do
     before {
-      TTY::System.stub(:unix?).and_return(false)
-      TTY::System.stub(:windows?).and_return(true)
-    }
-
-    after {
-      TTY::System.unstub(:unix?)
-      TTY::System.unstub(:windows?)
+      allow(TTY::System).to receive(:unix?).and_return(false)
+      allow(TTY::System).to receive(:windows?).and_return(true)
     }
 
     it "doesn't shell escape" do
@@ -28,13 +23,10 @@ describe TTY::System::Editor, '#build' do
   end
 
   context 'when on unix' do
-
-    before { TTY::System.stub(:unix?).and_return(true) }
-
-    after  { TTY::System.unstub(:unix?) }
+    before { allow(TTY::System).to receive(:unix?).and_return(true) }
 
     it 'escapes shell' do
-      expect(subject.build).to eql("vim /users/piotr/hello\\ world.rb")
+      expect(editor.build).to eql("vim /users/piotr/hello\\ world.rb")
     end
   end
 end

data/spec/tty/system/editor/command_spec.rb

@@ -1,4 +1,4 @@
-# -*- encoding: utf-8 -*-
+# encoding: utf-8
 
 require 'spec_helper'
 
@@ -9,8 +9,9 @@ describe TTY::System::Editor, '#command' do
 
   context 'when custom command' do
     it 'searches available commands' do
-      subject.should_receive(:available).with(editor)
+      allow(subject).to receive(:available)
       subject.command(editor)
+      expect(subject).to have_received(:available).with(editor)
     end
   end
 end

data/spec/tty/system/editor/executables_spec.rb

@@ -1,4 +1,4 @@
-# -*- encoding: utf-8 -*-
+# encoding: utf-8
 
 require 'spec_helper'
 
@@ -7,7 +7,7 @@ describe TTY::System::Editor, '#executables' do
 
   subject { object.executables }
 
-  it { should be_an Array }
+  it { is_expected.to be_an Array }
 
-  it { should include('vi') }
+  it { is_expected.to include('vi') }
 end

data/spec/tty/system/editor/invoke_spec.rb

@@ -1,38 +1,34 @@
-# -*- encoding: utf-8 -*-
+# encoding: utf-8
 
 require 'spec_helper'
 
 describe TTY::System::Editor, '#invoke' do
   let(:file) { "hello.rb" }
-  let(:editor) { "vim" }
+  let(:name) { "vim" }
   let(:object) { described_class }
 
-  subject { object.new(file) }
+  subject(:editor) { object.new(file) }
 
   before {
-    object.stub(:command).and_return(editor)
-    TTY::System.stub(:unix?).and_return(true)
-  }
-
-  after {
-    TTY::System.unstub(:unix?)
+    allow(object).to receive(:command).and_return(name)
+    allow(TTY::System).to receive(:unix?).and_return(true)
   }
 
   context 'when invokes' do
-    before { subject.stub(:system).and_return(true) }
+    before { allow(editor).to receive(:system).and_return(true) }
 
     it 'executes editor command' do
-      subject.should_receive(:system).with(editor, file)
-      subject.invoke
+      editor.invoke
+      expect(editor).to have_received(:system).with(name, file)
     end
   end
 
   context 'when fails to invoke' do
 
-    before { subject.stub(:system).and_return(false) }
+    before { allow(editor).to receive(:system).and_return(false) }
 
     it 'raises an error' do
-      expect { subject.invoke }.to raise_error(TTY::CommandInvocationError)
+      expect { editor.invoke }.to raise_error(TTY::CommandInvocationError)
     end
   end
 end

data/spec/tty/system/editor/open_spec.rb

@@ -1,27 +1,29 @@
-# -*- encoding: utf-8 -*-
+# encoding: utf-8
 
 require 'spec_helper'
 
 describe TTY::System::Editor, '#open' do
   let(:file) { "hello.rb" }
 
-  subject { described_class }
+  subject(:editor) { described_class }
 
   context 'when no editor' do
-    before { subject.stub(:command).and_return(nil) }
+    before { allow(editor).to receive(:command).and_return(nil) }
 
     it 'raises error' do
-      expect { subject.open(file) }.to raise_error(TTY::CommandInvocationError)
+      expect {
+        editor.open(file)
+      }.to raise_error(TTY::CommandInvocationError)
     end
   end
 
   context 'when editor'  do
-    before { subject.stub(:command).and_return('vim') }
+    before { allow(editor).to receive(:command).and_return('vim') }
 
     it 'invokes editor' do
       invocable = double(:invocable, :invoke => nil)
-      subject.should_receive(:new).with(file).and_return(invocable)
-      subject.open(file)
+      expect(subject).to receive(:new).with(file).and_return(invocable)
+      editor.open(file)
     end
   end
 end

data/spec/tty/system/platform_spec.rb

@@ -1,27 +1,46 @@
-# -*- encoding: utf-8 -*-
+# encoding: utf-8
 
 require 'spec_helper'
 
 describe TTY::System, '#platform' do
-  subject { described_class }
+  subject(:system) { described_class }
 
-  it { should respond_to(:windows?) }
+  it { is_expected.to respond_to(:windows?) }
 
-  it { should respond_to(:unix?) }
+  it { is_expected.to respond_to(:unix?) }
 
-  it { should respond_to(:which) }
+  it { is_expected.to respond_to(:which) }
 
-  it { should respond_to(:exists?) }
+  it { is_expected.to respond_to(:exists?) }
 
-  it { should respond_to(:editor) }
+  it { is_expected.to respond_to(:editor) }
 
-  it 'checks if windows' do
-    RbConfig::CONFIG.stub(:[]).with('host_os').and_return 'windows'
-    subject.windows?.should be_true
+  context 'windows?' do
+    it 'is on windows' do
+      allow(RbConfig::CONFIG).to receive(:[]).with('host_os').and_return('windows')
+      expect(system.windows?).to eq(true)
+    end
+
+    it 'is on windows ignoring case' do
+      allow(RbConfig::CONFIG).to receive(:[]).with('host_os').and_return('Windows')
+      expect(system.windows?).to eq(true)
+    end
+
+    it 'is not on windows' do
+      allow(RbConfig::CONFIG).to receive(:[]).with('host_os').and_return('unknown')
+      expect(system.windows?).to eq(false)
+    end
   end
 
-  it 'checks if unix' do
-    RbConfig::CONFIG.stub(:[]).with('host_os').and_return 'darwin'
-    subject.unix?.should be_true
+  context 'unix?' do
+    it 'checks if unix' do
+      allow(RbConfig::CONFIG).to receive(:[]).with('host_os').and_return('darwin')
+      expect(system.unix?).to eq(true)
+    end
+
+    it 'checks if unix' do
+      allow(RbConfig::CONFIG).to receive(:[]).with('host_os').and_return('unknown')
+      expect(system.unix?).to eq(false)
+    end
   end
 end

data/spec/tty/system/which/which_spec.rb

@@ -1,4 +1,4 @@
-# -*- encoding: utf-8 -*-
+# encoding: utf-8
 
 require 'spec_helper'
 
@@ -12,17 +12,17 @@ describe TTY::System::Which, '#which' do
     let(:command)  { 'ruby' }
 
     before {
-      ENV.stub(:[]).with('PATHEXT').and_return(nil)
-      ENV.stub(:[]).with('PATH').and_return(path)
+      allow(ENV).to receive(:[]).with('PATHEXT').and_return(nil)
+      allow(ENV).to receive(:[]).with('PATH').and_return(path)
     }
 
     it 'finds command' do
-      File.stub(:executable?) { true }
+      allow(File).to receive(:executable?) { true }
       expect(subject.which).to eql "/usr/local/bin/ruby"
     end
 
     it "doesn't find command" do
-      File.stub(:executable?) { false }
+      allow(File).to receive(:executable?) { false }
       expect(subject.which).to be_nil
     end
   end
@@ -31,17 +31,17 @@ describe TTY::System::Which, '#which' do
     let(:command) { 'ruby' }
 
     before {
-      ENV.stub(:[]).with('PATHEXT').and_return(extension)
-      ENV.stub(:[]).with('PATH').and_return(path)
+      allow(ENV).to receive(:[]).with('PATHEXT').and_return(extension)
+      allow(ENV).to receive(:[]).with('PATH').and_return(path)
     }
 
     it 'finds command' do
-      File.stub(:executable?) { true }
+      allow(File).to receive(:executable?) { true }
       expect(subject.which).to eql "/usr/local/bin/ruby.bat"
     end
 
     it "doesn't find command" do
-      File.stub(:executable?) { false }
+      allow(File).to receive(:executable?) { false }
       expect(subject.which).to be_nil
     end
   end

data/spec/tty/system/which_spec.rb

@@ -1,4 +1,4 @@
-# -*- encoding: utf-8 -*-
+# encoding: utf-8
 
 require 'spec_helper'
 
@@ -6,10 +6,10 @@ describe TTY::System, '#which' do
   let(:command) { 'ruby' }
   let(:which)   { double(:which, :which => command) }
 
-  subject { described_class }
+  subject(:system) { described_class }
 
   it 'seeks system command' do
-    TTY::System::Which.should_receive(:new).with(command).and_return(which)
-    expect(subject.which(command)).to eql(command)
+    allow(TTY::System::Which).to receive(:new).with(command).and_return(which)
+    expect(system.which(command)).to eql(command)
   end
 end

data/spec/tty/table/access_spec.rb

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