tty 0.0.6 → 0.0.7

data/spec/tty/coercer/float/coerce_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe TTY::Coercer::Float, '#coerce' do
+  let(:strict) { true }
+  subject { described_class.coerce(value, strict) }
+
+  context 'with empty' do
+    let(:value) { '' }
+
+    it { expect { subject }.to raise_error(TTY::InvalidArgument) }
+  end
+
+  context 'with 1 as string' do
+    let(:value) { '1' }
+
+    it { expect(subject).to eql 1.0 }
+  end
+
+  context 'with float' do
+    let(:value) { '1.2a' }
+
+    it { expect { subject }.to raise_error(TTY::InvalidArgument) }
+  end
+
+  context 'with float not strict' do
+    let(:value) { '1.2abc'}
+    let(:strict) { false }
+
+    it { expect(subject).to eql 1.2 }
+  end
+
+end

data/spec/tty/coercer/integer/coerce_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe TTY::Coercer::Integer, '#coerce' do
+  let(:strict) { true }
+  subject { described_class.coerce(value, strict) }
+
+  context 'with empty' do
+    let(:value) { '' }
+
+    it { expect { subject }.to raise_error(TTY::InvalidArgument) }
+  end
+
+  context 'with 1 as string' do
+    let(:value) { '1' }
+
+    it { expect(subject).to eql 1 }
+  end
+
+  context 'with float' do
+    let(:value) { 1.2 }
+
+    it { expect { subject }.to raise_error(TTY::InvalidArgument) }
+  end
+
+  context 'with float not strict' do
+    let(:value) { 1.2 }
+    let(:strict) { false }
+
+    it { expect(subject).to eql 1 }
+  end
+
+  context 'with letters not strict' do
+    let(:value) { '1abc' }
+    let(:strict) { false }
+
+    it { expect(subject).to eql 1 }
+  end
+
+end

data/spec/tty/coercer/range/coerce_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe TTY::Coercer::Range, '#coerce' do
+
+  subject { described_class.coerce(value) }
+
+  context 'with empty' do
+    let(:value) { '' }
+
+    it { expect { subject }.to raise_error(TTY::InvalidArgument) }
+  end
+
+  context 'with 1' do
+    let(:value) { '1' }
+
+    it { should == (1..1) }
+  end
+
+  context 'with 1..10' do
+    let(:value) { '1..10' }
+
+    it { should == (1..10) }
+  end
+
+  context 'with 1-10' do
+    let(:value) { '1-10' }
+
+    it { should == (1..10) }
+  end
+
+  context 'with 1,10' do
+    let(:value) { '1,10' }
+
+    it { should == (1..10) }
+  end
+
+  context 'with 1...10' do
+    let(:value) { '1...10'}
+
+    it { should == (1...10) }
+  end
+
+  context 'with -1..10' do
+    let(:value) { '-1..10' }
+
+    it { should == (-1..10) }
+  end
+
+  context 'with 1..-10' do
+    let(:value) { '1..-10' }
+
+    it { should == (1..-10) }
+  end
+
+  context 'with a..z' do
+    let(:value) { 'a..z' }
+
+    it { should == ('a'..'z')}
+  end
+
+  context 'with a-z' do
+    let(:value) { 'a-z' }
+
+    it { should == ('a'..'z')}
+  end
+
+  context 'with A..Z' do
+    let(:value) { 'A..Z' }
+
+    it { should == ('A'..'Z')}
+  end
+
+end # coerce

data/spec/tty/shell/ask_spec.rb

@@ -5,8 +5,10 @@ require 'spec_helper'
 describe TTY::Shell, '#ask' do
   let(:input)  { StringIO.new }
   let(:output) { StringIO.new }
+  let(:prefix) { '' }
+  let(:options) { { :prefix => prefix } }
 
-  subject(:shell) { TTY::Shell.new(input, output) }
+  subject(:shell) { TTY::Shell.new(input, output, options) }
 
   it 'prints message' do
     shell.ask "What is your name?"
@@ -25,6 +27,17 @@ describe TTY::Shell, '#ask' do
     expect(q.read).to eql nil
   end
 
+  context 'with a prompt prefix' do
+    let(:prefix) { ' > ' }
+
+    it "asks a question with '>'" do
+      input << ''
+      input.rewind
+      q = shell.ask "Are you Polish?"
+      expect(output.string).to eql " > Are you Polish?\n"
+    end
+  end
+
   it 'asks a question with block' do
     input << ''
     input.rewind

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

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe TTY::Shell::Question, '#argument' do
+  let(:input)  { StringIO.new }
+  let(:output) { StringIO.new }
+  let(:shell) { TTY::Shell.new(input, output) }
+
+  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
+
+  it "doesn't require value to be present" do
+    input << ''
+    input.rewind
+    q = shell.ask("What is your name?").argument(:optional)
+    expect(q.read).to be_nil
+  end
+end

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

@@ -0,0 +1,16 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe TTY::Shell::Question, '#character' do
+  let(:input)  { StringIO.new }
+  let(:output) { StringIO.new }
+  let(:shell) { TTY::Shell.new(input, output) }
+
+  it 'switches to character input' do
+    input << "abcd"
+    input.rewind
+    q = shell.ask("Which one do you prefer a, b, c or d?").character(true)
+    expect(q.read_string).to eql "abcd"
+  end
+end # character

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

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe TTY::Shell::Question, '#default' do
+  let(:input)  { StringIO.new }
+  let(:output) { StringIO.new }
+  let(:shell) { TTY::Shell.new(input, output) }
+
+  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 # default

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

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe TTY::Shell::Question, '#in' do
+  let(:input)  { StringIO.new }
+  let(:output) { StringIO.new }
+  let(:shell) { TTY::Shell.new(input, output) }
+
+  it 'reads number within range' do
+    input << 8
+    input.rewind
+    q = shell.ask("How do you like it on scale 1-10").in('1-10')
+    expect(q.read_int).to eql 8
+  end
+
+  it "reads number outside of range" do
+    input << 12
+    input.rewind
+    q = shell.ask("How do you like it on scale 1-10").in('1-10')
+    expect { q.read_int }.to raise_error(ArgumentError)
+  end
+end # in

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

@@ -2,226 +2,26 @@
 
 require 'spec_helper'
 
-describe TTY::Shell::Question, '#ask' do
-
+describe TTY::Shell::Question, '#initialize' do
   let(:input)  { StringIO.new }
   let(:output) { StringIO.new }
   let(:shell) { TTY::Shell.new(input, output) }
+  let(:message) { 'Do you like me?' }
 
-  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
+  subject { described_class.new shell }
 
-    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
+  its(:shell)     { should == shell }
 
-    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
+  its(:required)  { should be_false }
 
-    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
+  its(:echo)      { should be_true }
 
-  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
+  its(:mask)      { should be_false }
 
-  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
+  its(:character) { should be_false }
 
-    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
+  its(:modifier)  { should be_kind_of TTY::Shell::Question::Modifier }
 
-    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
+  its(:validation) { should be_kind_of TTY::Shell::Question::Validation }
 
-end
+end # initialize