tty 0.0.5 → 0.0.6

data/spec/tty/shell/question/initialize_spec.rb

@@ -0,0 +1,227 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe TTY::Shell::Question, '#ask' do
+
+  let(:input)  { StringIO.new }
+  let(:output) { StringIO.new }
+  let(:shell) { TTY::Shell.new(input, output) }
+
+  context 'with default' do
+    it 'uses default value' do
+      name = 'Anonymous'
+      q = shell.ask("What is your name?").default(name)
+      answer = q.read
+      expect(answer).to eql name
+    end
+
+    it 'uses default value in block' do
+      name = 'Anonymous'
+      q = shell.ask "What is your name?" do
+        default name
+      end
+      answer = q.read
+      expect(answer).to eql name
+    end
+  end
+
+  context 'with argument' do
+    it 'requires value to be present with helper' do
+      input << ''
+      input.rewind
+      q = shell.ask("What is your name?").argument(:required)
+      expect { q.read }.to raise_error(ArgumentError)
+    end
+
+    it 'requires value to be present with option' do
+      input << ''
+      input.rewind
+      q = shell.ask("What is your name?", :required => true)
+      expect { q.read }.to raise_error(ArgumentError)
+    end
+  end
+
+  context 'with validation' do
+    it 'fails to validate input' do
+      input << 'piotrmurach'
+      input.rewind
+      q = shell.ask("What is your username?").validate(/^[^\.]+\.[^\.]+/)
+      expect { q.read_string }.to raise_error(ArgumentError)
+    end
+
+    it 'validates input with regex' do
+      input << 'piotr.murach'
+      input.rewind
+      q = shell.ask("What is your username?").validate(/^[^\.]+\.[^\.]+/)
+      expect(q.read_string).to eql 'piotr.murach'
+    end
+
+    it 'validates input in block' do
+      input << 'piotr.murach'
+      input.rewind
+      q = shell.ask("What is your username?").validate { |arg| arg =~ /^[^\.]+\.[^\.]+/ }
+      expect(q.read_string).to eql 'piotr.murach'
+    end
+  end
+
+  context 'with valid choice' do
+    let(:cards) { %w[ club diamond spade heart ] }
+
+    it 'reads valid optios with helper' do
+      input << 'club'
+      input.rewind
+      q = shell.ask("What is your card suit sir?").valid(cards)
+      expect(q.read_choice).to eql 'club'
+    end
+
+    it 'reads valid options with option hash' do
+      input << 'club'
+      input.rewind
+      q = shell.ask("What is your card suit sir?", :valid => cards)
+      expect(q.read_choice).to eql 'club'
+    end
+
+    it 'reads invalid option' do
+      input << 'clover'
+      input.rewind
+      q = shell.ask("What is your card suit sir?").valid(cards)
+      expect { q.read_choice }.to raise_error(TTY::InvalidArgument)
+    end
+
+    it 'needs argument' do
+      input << ''
+      input.rewind
+      q = shell.ask("What is your card suit sir?").valid(cards)
+      expect { q.read_choice }.to raise_error(TTY::ArgumentRequired)
+    end
+
+    it 'reads with default' do
+      input << ''
+      input.rewind
+      q = shell.ask("What is your card suit sir?").valid(cards).default('club')
+      expect(q.read_choice).to eql 'club'
+    end
+  end
+
+  context 'with modification' do
+    it 'preserves answer for unkown modification' do
+      input << 'piotr'
+      input.rewind
+      q = shell.ask("What is your name?").modify(:none)
+      expect(q.read_string).to eql 'piotr'
+    end
+
+    it 'converts to upper case' do
+      input << 'piotr'
+      input.rewind
+      q = shell.ask("What is your name?").modify(:upcase)
+      expect(q.read_string).to eql 'PIOTR'
+    end
+
+    it 'trims whitespace' do
+      input << " Some   white\t   space\t \there!   \n"
+      input.rewind
+      q = shell.ask("Enter some text: ").modify(:trim)
+      expect(q.read_string).to eql "Some   white\t   space\t \there!"
+    end
+
+    it 'collapses whitespace' do
+      input << " Some   white\t   space\t \there!   \n"
+      input.rewind
+      q = shell.ask("Enter some text: ").modify(:collapse)
+      expect(q.read_string).to eql " Some white space here! "
+    end
+
+    it 'strips and collapses whitespace' do
+      input << " Some   white\t   space\t \there!   \n"
+      input.rewind
+      q = shell.ask("Enter some text: ").modify(:strip, :collapse)
+      expect(q.read_string).to eql "Some white space here!"
+    end
+  end
+
+  context 'with type' do
+    it 'reads string' do
+      name = "Piotr"
+      input << name
+      input.rewind
+      q = shell.ask("What is your name?")
+      answer = q.read_string
+      expect(answer).to eql name
+    end
+
+    it 'reads integer' do
+      input << 5
+      input.rewind
+      q = shell.ask("What temperature?")
+      answer = q.read_int
+      expect(answer).to eql 5
+    end
+
+    it 'reads float' do
+      input << '6.0'
+      input.rewind
+      q = shell.ask("How tall are you?")
+      answer = q.read_float
+      expect(answer).to eql 6.0
+    end
+
+    it 'fails to read boolean' do
+      input << 'invalid'
+      input.rewind
+      q = shell.ask("Do you read books?")
+      expect { q.read_bool }.to raise_error(ArgumentError)
+    end
+
+    it 'reads negative boolean' do
+      input << 'No'
+      input.rewind
+      q = shell.ask("Do you read books?")
+      answer = q.read_bool
+      expect(answer).to eql false
+    end
+
+    it 'reads positive boolean' do
+      input << 'Yes'
+      input.rewind
+      q = shell.ask("Do you read books?")
+      answer = q.read_bool
+      expect(answer).to eql true
+    end
+  end
+
+  context 'with multiple line' do
+    it 'reads multiple lines' do
+      input << "First line\nSecond line\nThird line"
+      input.rewind
+      q = shell.ask("Provide description?")
+      expect(q.read_multiple).to eql "First line\nSecond line\nThird line"
+    end
+  end
+
+  context 'with email' do
+    it 'reads valid email' do
+      input << "piotr@example.com"
+      input.rewind
+      q = shell.ask("What is your email?")
+      expect(q.read_email).to eql "piotr@example.com"
+    end
+
+    it 'fails to read invalid email' do
+      input << "this will@neverwork"
+      input.rewind
+      q = shell.ask("What is your email?")
+      expect { q.read_email }.to raise_error(TTY::InvalidArgument)
+    end
+
+    it 'asks again' do
+      input << "this will@neverwork\nthis.will@example.com"
+      input.rewind
+      q = shell.ask("What is your email?").on_error(:retry)
+      expect(q.read_email).to eql "this.will@example.com"
+      expect(output.string).to eql "What is your email?\nWhat is your email?\n"
+    end
+  end
+
+end

data/spec/tty/shell/question/modifier/apply_to_spec.rb

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe TTY::Shell::Question::Modifier, '#apply_to' do
+  let(:instance) { described_class.new modifiers }
+  let(:string) { "Text to be modified"}
+
+  subject { instance.apply_to string }
+
+  context 'when no modifiers specified' do
+    let(:modifiers) { [] }
+
+    it { should == string }
+  end
+
+  context 'when modifiers specified' do
+    let(:modifiers) { [:down, :capitalize] }
+
+    it 'applies letter case modifications' do
+      described_class.should_receive(:letter_case).with(modifiers, string)
+      subject
+    end
+
+    it 'applies whitespace modifications' do
+      described_class.should_receive(:whitespace).with(modifiers, string)
+      subject
+    end
+  end
+end # apply_to

data/spec/tty/shell/question/modifier/letter_case_spec.rb

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe TTY::Shell::Question::Modifier, '#letter_case' do
+  let(:string) { 'text to modify' }
+
+  subject { described_class.letter_case modifier, string}
+
+  context 'when upper case' do
+    let(:modifier) { :up }
+
+    it { should == 'TEXT TO MODIFY' }
+  end
+
+  context 'when lower case' do
+    let(:modifier) { :down }
+
+    it { should == 'text to modify'}
+  end
+
+  context 'when capitalize' do
+    let(:modifier) { :capitalize }
+
+    it { should == 'Text to modify'}
+  end
+end # lettercase

data/spec/tty/shell/question/modifier/whitespace_spec.rb

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe TTY::Shell::Question::Modifier, '#whitespace' do
+  let(:string) { "  text\t \n  to\t   modify\r\n" }
+
+  subject { described_class.whitespace modifier, string}
+
+  context 'when stripping whitespace' do
+    let(:modifier) { :trim }
+
+    it { should == "text\t \n  to\t   modify" }
+  end
+
+  context 'when chomping whitespace' do
+    let(:modifier) { :chomp }
+
+    it { should == "  text\t \n  to\t   modify" }
+  end
+
+  context 'when capitalize' do
+    let(:modifier) { :collapse }
+
+    it { should == " text to modify " }
+  end
+
+  context 'when removing whitespace' do
+    let(:modifier) { :remove }
+
+    it { should == "texttomodify" }
+  end
+end

data/spec/tty/shell/question/validation/coerce_spec.rb

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe TTY::Shell::Question::Validation, '#coerce' do
+  let(:validation) { "^[^\.]+\.[^\.]+" }
+  let(:instance) { described_class.new }
+
+  subject { instance.coerce validation }
+
+  it { should be_kind_of Regexp }
+
+  context 'when proc' do
+   let(:validation) { lambda { "^[^\.]+\.[^\.]+" } }
+
+    it { should be_kind_of Proc }
+  end
+
+  context 'when unkown type' do
+    let(:validation) { Object.new }
+
+    it { expect { subject }.to raise_error(TTY::ValidationCoercion) }
+  end
+
+end

data/spec/tty/shell/question/validation/valid_value_spec.rb

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe TTY::Shell::Question::Validation, '#valid_value?' do
+  let(:validation) { /^[^\.]+\.[^\.]+/ }
+  let(:instance) { described_class.new validation }
+
+  subject { instance.valid_value?(value) }
+
+  context '' do
+    let(:value) { nil }
+
+    it { should be_false }
+  end
+
+  context 'when the value matches validation' do
+    let(:value) { 'piotr.murach' }
+
+    it { should be_nil }
+  end
+
+  context 'when the value is not matching validation' do
+    let(:value)  { 'piotrmurach' }
+
+    it { expect { subject }.to raise_error(TTY::InvalidArgument) }
+  end
+end

data/spec/tty/shell/say_spec.rb

@@ -0,0 +1,64 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe TTY::Shell, '#say' do
+  let(:input)  { StringIO.new }
+  let(:output) { StringIO.new }
+
+  subject(:shell) { TTY::Shell.new(input, output) }
+
+  after { output.rewind }
+
+  it 'prints an empty message' do
+    shell.say ""
+    expect(output.string).to eql ""
+  end
+
+  context 'with new line' do
+    it 'prints a message with newline' do
+      shell.say "Hell yeah!\n"
+      expect(output.string).to eql "Hell yeah!\n"
+    end
+
+    it 'prints a message with implicit newline' do
+      shell.say "Hell yeah!\n"
+      expect(output.string).to eql "Hell yeah!\n"
+    end
+
+    it 'prints a message with newline within text' do
+      shell.say "Hell\n yeah!"
+      expect(output.string).to eql "Hell\n yeah!\n"
+    end
+
+    it 'prints a message with newline within text and blank space' do
+      shell.say "Hell\n yeah! "
+      expect(output.string).to eql "Hell\n yeah! "
+    end
+
+    it 'prints a message without newline' do
+      shell.say "Hell yeah!", :newline => false
+      expect(output.string).to eql "Hell yeah!"
+    end
+  end
+
+  context 'with tab or space' do
+    it 'prints ' do
+      shell.say "Hell yeah!\t"
+      expect(output.string).to eql "Hell yeah!\t"
+    end
+  end
+
+  context 'with color' do
+    it 'prints message with ansi color' do
+      shell.say "Hell yeah!", :color => :green
+      expect(output.string).to eql "\e[32mHell yeah!\e[0m\n"
+    end
+
+    it 'prints message with ansi color without newline' do
+      shell.say "Hell yeah! ", :color => :green
+      expect(output.string).to eql "\e[32mHell yeah! \e[0m"
+    end
+  end
+
+end # say

data/spec/tty/shell/statement/initialize_spec.rb

@@ -0,0 +1,15 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe TTY::Shell::Statement, '#new' do
+  let(:input)  { StringIO.new }
+  let(:output) { StringIO.new }
+  let(:shell) { TTY::Shell.new(input, output) }
+
+  subject(:statement) { described_class.new }
+
+  its(:newline) { should be_true }
+
+  its(:color) { should be_nil }
+end

data/spec/tty/shell/warn_spec.rb

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe TTY::Shell, '#warn' do
+  let(:input)  { StringIO.new }
+  let(:output) { StringIO.new }
+
+  subject(:shell) { TTY::Shell.new(input, output) }
+
+  after { output.rewind }
+
+  it 'displays one message' do
+    shell.warn "Careful young apprentice!"
+    expect(output.string).to eql "\e[33mCareful young apprentice!\e[0m\n"
+  end
+
+  it 'displays many messages' do
+    shell.warn "Careful there!", "It's dangerous!"
+    expect(output.string).to eql "\e[33mCareful there!\e[0m\n\e[33mIt's dangerous!\e[0m\n"
+  end
+
+  it 'displays message with option' do
+    shell.warn "Careful young apprentice!", :newline => false
+    expect(output.string).to eql "\e[33mCareful young apprentice!\e[0m"
+  end
+
+end # warn

data/spec/tty/table/renderer_spec.rb

@@ -8,7 +8,6 @@ describe TTY::Table, '#renderer' do
 
   before do
     TTY::Table.renderer = basic_renderer
-    TTY::Color.stub(:color?).and_return false
   end
 
   after do

data/spec/tty/terminal/color/code_spec.rb

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe TTY::Terminal::Color, '#code' do
+  let(:string) { "This is a \e[1m\e[34mbold blue text\e[0m" }
+
+  it 'finds single code' do
+    subject.code(:black).should == ["\e[30m"]
+  end
+
+  it 'finds more than one code' do
+    subject.code(:black, :green).should == ["\e[30m", "\e[32m"]
+  end
+
+  it "doesn't find code" do
+    expect { subject.code(:unkown) }.to raise_error(ArgumentError)
+  end
+end

data/spec/tty/terminal/color/remove_spec.rb

@@ -0,0 +1,12 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe TTY::Terminal::Color, '#remove' do
+  let(:string) { "This is a \e[1m\e[34mbold blue text\e[0m" }
+
+  it 'remove color from string' do
+    subject.remove(string).should == "This is a bold blue text"
+  end
+
+end

data/spec/tty/terminal/color/set_spec.rb

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe TTY::Terminal::Color, '#set' do
+  let(:string) { 'string' }
+
+  it 'applies green text to string' do
+    subject.set(string, :green).should == "\e[32m#{string}\e[0m"
+  end
+
+  it 'applies red text background to string' do
+    subject.set(string, :on_red).should == "\e[41m#{string}\e[0m"
+  end
+
+  it 'applies style and color to string' do
+    text = subject.set(string, :bold, :green)
+    text.should == "\e[1m\e[32m#{string}\e[0m"
+  end
+
+  it 'applies style, color and background to string' do
+    text = subject.set(string, :bold, :green, :on_blue)
+    text.should == "\e[1m\e[32m\e[44m#{string}\e[0m"
+  end
+
+  it 'errors for unkown color' do
+    expect { subject.set(string, :crimson) }.to raise_error(ArgumentError)
+  end
+
+end

data/spec/tty/terminal/color_spec.rb

@@ -0,0 +1,15 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe TTY::Terminal, '#color' do
+
+  it { should respond_to(:color) }
+
+  its(:color) { should be_kind_of TTY::Terminal::Color}
+
+  it 'delegates color handling' do
+    string = 'text'
+    subject.color.set(string, :red).should == "\e[31m#{string}\e[0m"
+  end
+end

data/spec/tty/terminal/home_spec.rb

@@ -0,0 +1,37 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe TTY::Terminal, '#home' do
+
+  before { ENV.stub!(:[]) }
+
+  subject(:terminal) { described_class.new.home }
+
+  after { terminal.instance_variable_set(:@home, nil) }
+
+  it 'expands user home path if HOME environemnt not set' do
+    File.stub!(:expand_path).and_return('/home/user')
+    expect(terminal).to eql('/home/user')
+  end
+
+  it 'defaults to user HOME environment' do
+    ENV.stub!(:[]).with('HOME').and_return('/home/user')
+    expect(terminal).to eq('/home/user')
+  end
+
+  context 'when failed to expand' do
+    before { File.should_receive(:expand_path).and_raise(RuntimeError) }
+
+    it 'returns C:/ on windows' do
+      TTY::System.stub(:windows?).and_return true
+      expect(terminal).to eql("C:/")
+    end
+
+    it 'returns root on unix' do
+      TTY::System.stub(:windows?).and_return false
+      expect(terminal).to eql("/")
+    end
+  end
+
+end

data/tasks/metrics/reek.rake

@@ -7,7 +7,5 @@ begin
     end
   end
 rescue LoadError
-  task :reek do
-    warn "Reek is not available. In order to run reek, you must: gem install reek"
-  end
+  warn "Reek is not available. In order to run reek, you must: gem install reek"
 end