tty-prompt 0.1.0 → 0.2.0

data/spec/unit/question/in_spec.rb

@@ -3,21 +3,24 @@
 require 'spec_helper'
 
 RSpec.describe TTY::Prompt::Question, '#in' do
-  let(:input)  { StringIO.new }
-  let(:output) { StringIO.new }
-  let(:prompt) { TTY::Prompt.new(input, output) }
-
   it 'reads number within range' do
-    input << 8
-    input.rewind
-    q = prompt.ask("How do you like it on scale 1-10").in('1-10')
-    expect(q.read_int).to eql 8
+    prompt = TTY::TestPrompt.new
+    prompt.input << 8
+    prompt.input.rewind
+    answer = prompt.ask("How do you like it on scale 1-10", read: :int) { |q|
+      q.in('1-10')
+    }
+    expect(answer).to eq(8)
   end
 
   it "reads number outside of range" do
-    input << 12
-    input.rewind
-    q = prompt.ask("How do you like it on scale 1-10").in('1-10')
-    expect { q.read_int }.to raise_error(ArgumentError)
+    prompt = TTY::TestPrompt.new
+    prompt.input << 12
+    prompt.input.rewind
+    expect {
+      prompt.ask("How do you like it on scale 1-10", read: :int) { |q|
+        q.in('1-10')
+      }
+    }.to raise_error(ArgumentError)
   end
 end

data/spec/unit/question/initialize_spec.rb

@@ -3,14 +3,9 @@
 require 'spec_helper'
 
 RSpec.describe TTY::Prompt::Question, '#initialize' do
-  let(:input)  { StringIO.new }
-  let(:output) { StringIO.new }
-  let(:prompt) { TTY::Prompt.new(input, output) }
   let(:message) { 'Do you like me?' }
 
-  subject(:question) { described_class.new prompt }
-
-  it { expect(question.required?).to eq(false) }
+  subject(:question) { described_class.new(TTY::TestPrompt.new)}
 
   it { expect(question.echo).to eq(true) }
 

data/spec/unit/question/modify_spec.rb

@@ -3,42 +3,43 @@
 require 'spec_helper'
 
 RSpec.describe TTY::Prompt::Question, '#modify' do
-  let(:input)  { StringIO.new }
-  let(:output) { StringIO.new }
-  let(:prompt)  { TTY::Prompt.new(input, output) }
-
   it 'preserves answer for unkown modification' do
-    input << 'piotr'
-    input.rewind
-    q = prompt.ask("What is your name?").modify(:none)
-    expect(q.read_string).to eql 'piotr'
+    prompt = TTY::TestPrompt.new
+    prompt.input << 'piotr'
+    prompt.input.rewind
+    answer = prompt.ask("What is your name?") { |q| q.modify(:none) }
+    expect(answer).to eq('piotr')
   end
 
   it 'converts to upper case' do
-    input << 'piotr'
-    input.rewind
-    q = prompt.ask("What is your name?").modify(:upcase)
-    expect(q.read_string).to eql 'PIOTR'
+    prompt = TTY::TestPrompt.new
+    prompt.input << 'piotr'
+    prompt.input.rewind
+    answer = prompt.ask("What is your name?") { |q| q.modify(:upcase) }
+    expect(answer).to eq('PIOTR')
   end
 
   it 'trims whitespace' do
-    input << " Some   white\t   space\t \there!   \n"
-    input.rewind
-    q = prompt.ask("Enter some text: ").modify(:trim)
-    expect(q.read_string).to eql "Some   white\t   space\t \there!"
+    prompt = TTY::TestPrompt.new
+    prompt.input << " Some   white\t   space\t \there!   \n"
+    prompt.input.rewind
+    answer = prompt.ask('Enter some text: ') { |q| q.modify(:trim) }
+    expect(answer).to eq("Some   white\t   space\t \there!")
   end
 
   it 'collapses whitespace' do
-    input << " Some   white\t   space\t \there!   \n"
-    input.rewind
-    q = prompt.ask("Enter some text: ").modify(:collapse)
-    expect(q.read_string).to eql "Some white space here!"
+    prompt = TTY::TestPrompt.new
+    prompt.input << " Some   white\t   space\t \there!   \n"
+    prompt.input.rewind
+    answer = prompt.ask('Enter some text: ') { |q| q.modify(:collapse) }
+    expect(answer).to eq(' Some white space here! ')
   end
 
   it 'strips and collapses whitespace' do
-    input << " Some   white\t   space\t \there!   \n"
-    input.rewind
-    q = prompt.ask("Enter some text: ").modify(:strip, :collapse)
-    expect(q.read_string).to eql "Some white space here!"
+    prompt = TTY::TestPrompt.new
+    prompt.input << " Some   white\t   space\t \there!   \n"
+    prompt.input.rewind
+    answer = prompt.ask('Enter some text: ') { |q| q.modify(:strip, :collapse) }
+    expect(answer).to eq('Some white space here!')
   end
 end

data/spec/unit/question/required_spec.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Prompt::Question, '#required' do
+  it 'requires value to be present with helper' do
+    prompt = TTY::TestPrompt.new
+    prompt.input << ''
+    prompt.input.rewind
+    expect {
+      prompt.ask('What is your name?') { |q| q.required(true) }
+    }.to raise_error(ArgumentError)
+  end
+
+  it 'requires value to be present with option' do
+    prompt = TTY::TestPrompt.new
+    prompt.input << ''
+    prompt.input.rewind
+    expect {
+      prompt.ask('What is your name?', required: true)
+    }.to raise_error(ArgumentError)
+  end
+
+  it "doesn't require value to be present" do
+    prompt = TTY::TestPrompt.new
+    prompt.input << ''
+    prompt.input.rewind
+    answer = prompt.ask('What is your name?') { |q| q.required(false) }
+    expect(answer).to be_nil
+  end
+end

data/spec/unit/question/validate_spec.rb

@@ -3,28 +3,36 @@
 require 'spec_helper'
 
 RSpec.describe TTY::Prompt::Question, '#validate' do
-  let(:input)  { StringIO.new }
-  let(:output) { StringIO.new }
-  let(:prompt)  { TTY::Prompt.new(input, output) }
-
   it 'fails to validate input' do
-    input << 'piotrmurach'
-    input.rewind
-    q = prompt.ask("What is your username?").validate(/^[^\.]+\.[^\.]+/)
-    expect { q.read_string }.to raise_error(ArgumentError)
+    prompt = TTY::TestPrompt.new
+    prompt.input << 'piotrmurach'
+    prompt.input.rewind
+    expect {
+      prompt.ask('What is your username?') { |q|
+        q.validate(/^[^\.]+\.[^\.]+/)
+      }
+    }.to raise_error(ArgumentError)
   end
 
   it 'validates input with regex' do
-    input << 'piotr.murach'
-    input.rewind
-    q = prompt.ask("What is your username?").validate(/^[^\.]+\.[^\.]+/)
-    expect(q.read_string).to eq('piotr.murach')
+    prompt = TTY::TestPrompt.new
+    prompt.input << 'piotr.murach'
+    prompt.input.rewind
+    answer = prompt.ask('What is your username?') { |q|
+      q.validate(/^[^\.]+\.[^\.]+/)
+    }
+    expect(answer).to eq('piotr.murach')
   end
 
-  it 'validates input in block' do
-    input << 'piotr.murach'
-    input.rewind
-    q = prompt.ask("What is your username?").validate { |arg| arg =~ /^[^\.]+\.[^\.]+/ }
-    expect(q.read_string).to eq('piotr.murach')
+  it 'validates input with proc' do
+    prompt = TTY::TestPrompt.new
+    prompt.input << 'piotr.murach'
+    prompt.input.rewind
+    answer = prompt.ask('What is your username?') { |q|
+      q.validate { |input| input =~ /^[^\.]+\.[^\.]+/ }
+    }
+    expect(answer).to eq('piotr.murach')
   end
+
+  it 'understands custom validation like :email'
 end

data/spec/unit/question/validation/call_spec.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Prompt::Question::Validation, '#call' do
+  let(:pattern) { /^[^\.]+\.[^\.]+/ }
+  let(:validation) { described_class.new(pattern) }
+
+  it "validates nil input" do
+    expect(validation.(nil)).to eq(false)
+  end
+
+  it "validates successfully when the value matches pattern" do
+    expect(validation.('piotr.murach')).to eq(true)
+  end
+
+  it "fails validation when not maching pattern" do
+    expect {
+      validation.('piotrmurach')
+    }.to raise_error(TTY::Prompt::InvalidArgument)
+  end
+end

data/spec/unit/response/read_bool_spec.rb

@@ -3,45 +3,56 @@
 require 'spec_helper'
 
 RSpec.describe TTY::Prompt::Question, '#read_bool' do
-  let(:input)  { StringIO.new }
-  let(:output) { StringIO.new }
-  let(:prompt) { TTY::Prompt.new(input, output) }
-
   it 'fails to read boolean' do
-    input << 'invalid'
-    input.rewind
-    q = prompt.ask("Do you read books?")
-    expect { q.read_bool }.to raise_error(Necromancer::ConversionTypeError)
+    prompt = TTY::TestPrompt.new
+    prompt.input << 'invalid'
+    prompt.input.rewind
+    expect {
+      prompt.ask("Do you read books?", read: :bool)
+    }.to raise_error(Necromancer::ConversionTypeError)
+  end
+
+  it "handles default values" do
+    prompt = TTY::TestPrompt.new
+    prompt.input << "\n"
+    prompt.input.rewind
+    response = prompt.ask('Do you read books?', read: :bool, default: true)
+    expect(response).to eql(true)
+    expect(prompt.output.string).to eq('Do you read books?')
   end
 
   it "handles default values" do
-    input << "\n"
-    input.rewind
-    q = prompt.ask("Do you read books?").default(true)
-    expect(q.read_bool).to eql(true)
+    prompt = TTY::TestPrompt.new
+    prompt.input << "\n"
+    prompt.input.rewind
+    response = prompt.ask("Do you read books?") { |q|
+      q.default true
+      q.read :bool
+    }
+    expect(response).to eq(true)
   end
 
   it 'reads negative boolean' do
-    input << 'No'
-    input.rewind
-    q = prompt.ask("Do you read books?")
-    answer = q.read_bool
-    expect(answer).to eql false
+    prompt = TTY::TestPrompt.new
+    prompt.input << 'No'
+    prompt.input.rewind
+    response = prompt.ask('Do you read books?', read: :bool)
+    expect(response).to eq(false)
   end
 
   it 'reads positive boolean' do
-    input << 'Yes'
-    input.rewind
-    q = prompt.ask("Do you read books?")
-    answer = q.read_bool
-    expect(answer).to eql true
+    prompt = TTY::TestPrompt.new
+    prompt.input << 'Yes'
+    prompt.input.rewind
+    response = prompt.ask("Do you read books?", read: :bool)
+    expect(response).to eq(true)
   end
 
   it 'reads single positive boolean' do
-    input << 'y'
-    input.rewind
-    q = prompt.ask("Do you read books?")
-    answer = q.read_bool
-    expect(answer).to eql true
+    prompt = TTY::TestPrompt.new
+    prompt.input << 'y'
+    prompt.input.rewind
+    response = prompt.ask('Do you read books?', read: :bool)
+    expect(response).to eq(true)
   end
 end

data/spec/unit/response/read_char_spec.rb

@@ -3,14 +3,11 @@
 require 'spec_helper'
 
 RSpec.describe TTY::Prompt::Question, '#read_char' do
-  let(:input)  { StringIO.new }
-  let(:output) { StringIO.new }
-  let(:prompt) { TTY::Prompt.new(input, output) }
-
   it 'reads single character' do
-    input << "abcde"
-    input.rewind
-    q = prompt.ask("What is your favourite letter?")
-    expect(q.read_char).to eql "a"
+    prompt = TTY::TestPrompt.new
+    prompt.input << "abcde"
+    prompt.input.rewind
+    response = prompt.ask("What is your favourite letter?", read: :char)
+    expect(response).to eq('a')
   end
 end

data/spec/unit/response/read_date_spec.rb

@@ -3,18 +3,14 @@
 require 'spec_helper'
 
 RSpec.describe TTY::Prompt::Question, '#read_date' do
-  let(:input)  { StringIO.new }
-  let(:output) { StringIO.new }
-  let(:prompt) { TTY::Prompt.new(input, output) }
-
   it 'reads date' do
-    input << "20th April 1887"
-    input.rewind
-    q = prompt.ask("When were your born?")
-    answer = q.read_date
-    expect(answer).to be_kind_of Date
-    expect(answer.day).to eql 20
-    expect(answer.month).to eql 4
-    expect(answer.year).to eql 1887
+    prompt = TTY::TestPrompt.new
+    prompt.input << "20th April 1887"
+    prompt.input.rewind
+    response = prompt.ask("When were your born?", read: :date)
+    expect(response).to be_kind_of(Date)
+    expect(response.day).to eq(20)
+    expect(response.month).to eq(4)
+    expect(response.year).to eq(1887)
   end
 end

data/spec/unit/response/read_email_spec.rb

@@ -3,40 +3,43 @@
 require 'spec_helper'
 
 RSpec.describe TTY::Prompt::Question, '#read_email' do
-  let(:input)  { StringIO.new }
-  let(:output) { StringIO.new }
-  let(:prompt) { TTY::Prompt.new(input, output) }
-
   context 'with valid email' do
     it 'reads empty' do
-      input << ""
-      input.rewind
-      q = prompt.ask("What is your email?")
-      expect(q.read_email).to eql(nil)
+      prompt = TTY::TestPrompt.new
+      prompt.input << ""
+      prompt.input.rewind
+      response = prompt.ask("What is your email?", read: :email)
+      expect(response).to eql(nil)
     end
 
     it 'reads valid email' do
-      input << "piotr@example.com"
-      input.rewind
-      q = prompt.ask("What is your email?")
-      expect(q.read_email).to eql "piotr@example.com"
+      prompt = TTY::TestPrompt.new
+      prompt.input << "piotr@example.com"
+      prompt.input.rewind
+      response = prompt.ask('What is your email?', read: :email)
+      expect(response).to eq('piotr@example.com')
     end
   end
 
   context 'with invalid email' do
     it 'fails to read invalid email' do
-      input << "this will@neverwork"
-      input.rewind
-      q = prompt.ask("What is your email?")
-      expect { q.read_email }.to raise_error(TTY::Prompt::InvalidArgument)
+      prompt = TTY::TestPrompt.new
+      prompt.input << "this will@neverwork"
+      prompt.input.rewind
+      expect {
+        prompt.ask("What is your email?", read: :email)
+      }.to raise_error(TTY::Prompt::InvalidArgument)
     end
 
-    it 'reads invalid and asks again' do
-      input << "this will@neverwork\nthis.will@example.com"
-      input.rewind
-      q = prompt.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"
+    xit 'reads invalid and asks again' do
+      prompt = TTY::TestPrompt.new
+      prompt.input << "this will@neverwork\nthis.will@example.com"
+      prompt.input.rewind
+      response = prompt.ask("What is your email?", read: :email) do |q|
+        q.on_error :retry
+      end
+      expect(response).to eq('this.will@example.com')
+      expect(prompt.output.string).to eq("What is your email?\nWhat is your email?")
     end
   end
 end

data/spec/unit/response/read_multiple_spec.rb

@@ -2,22 +2,20 @@
 
 require 'spec_helper'
 
-RSpec.describe TTY::Prompt::Question, '#read_multiple' do
-  let(:input)  { StringIO.new }
-  let(:output) { StringIO.new }
-  let(:prompt) { TTY::Prompt.new(input, output) }
-
+RSpec.describe TTY::Prompt::Question, '#read_multiline' do
   it 'reads multiple lines' do
-    input << "First line\nSecond line\nThird line"
-    input.rewind
-    q = prompt.ask("Provide description?")
-    expect(q.read_multiple).to eq("First line\nSecond line\nThird line")
+    prompt = TTY::TestPrompt.new
+    prompt.input << "First line\nSecond line\nThird line"
+    prompt.input.rewind
+    answer = prompt.ask("Provide description?", read: :multiline)
+    expect(answer).to eq("First line\nSecond line\nThird line")
   end
 
   it 'terminates on empty lines' do
-    input << "First line\n\nSecond line"
-    input.rewind
-    q = prompt.ask("Provide description?")
-    expect(q.read_multiple).to eq("First line\n")
+    prompt = TTY::TestPrompt.new
+    prompt.input << "First line\n\nSecond line"
+    prompt.input.rewind
+    answer = prompt.ask("Provide description?")
+    expect(answer).to eq("First line\n")
   end
 end

data/spec/unit/response/read_number_spec.rb

@@ -3,26 +3,22 @@
 require 'spec_helper'
 
 RSpec.describe TTY::Prompt::Question, '#read_numbers' do
-  let(:input)  { StringIO.new }
-  let(:output) { StringIO.new }
-  let(:prompt) { TTY::Prompt.new(input, output) }
-
   it 'reads integer' do
-    input << 35
-    input.rewind
-    q = prompt.ask("What temperature?")
-    answer = q.read_int
-    expect(answer).to be_kind_of Integer
-    expect(answer).to eql 35
+    prompt = TTY::TestPrompt.new
+    prompt.input << 35
+    prompt.input.rewind
+    answer = prompt.ask("What temperature?", read: :int)
+    expect(answer).to be_a(Integer)
+    expect(answer).to eq(35)
   end
 
   it 'reads float' do
+    prompt = TTY::TestPrompt.new
     number = 6.666
-    input << number
-    input.rewind
-    q = prompt.ask("How tall are you?")
-    answer = q.read_float
-    expect(answer).to be_kind_of Float
-    expect(answer).to eql number
+    prompt.input << number
+    prompt.input.rewind
+    answer = prompt.ask('How tall are you?', read: :float)
+    expect(answer).to be_a(Float)
+    expect(answer).to eq(number)
   end
 end

data/spec/unit/response/read_range_spec.rb

@@ -3,24 +3,21 @@
 require 'spec_helper'
 
 RSpec.describe TTY::Prompt::Question, '#read_range' do
-  let(:input)  { StringIO.new }
-  let(:output) { StringIO.new }
-  let(:prompt)  { TTY::Prompt.new(input, output) }
-
   it 'converts with valid range' do
-    input << "20-30"
-    input.rewind
-    response = prompt.ask("Which age group?").read_range
-
-    expect(response).to be_kind_of Range
-    expect(response).to eql (20..30)
+    prompt = TTY::TestPrompt.new
+    prompt.input << "20-30"
+    prompt.input.rewind
+    answer = prompt.ask("Which age group?", read: :range)
+    expect(answer).to be_a(Range)
+    expect(answer).to eq(20..30)
   end
 
   it "fails to convert to range" do
-    input << "abcd"
-    input.rewind
+    prompt = TTY::TestPrompt.new
+    prompt.input << "abcd"
+    prompt.input.rewind
     expect {
-      prompt.ask("Which age group?").read_range
+      prompt.ask('Which age group?', read: :range)
     }.to raise_error(Necromancer::ConversionTypeError)
   end
 end

data/spec/unit/response/read_spec.rb

@@ -3,66 +3,67 @@
 require 'spec_helper'
 
 RSpec.describe TTY::Prompt::Question, '#read' do
-  let(:input)  { StringIO.new }
-  let(:output) { StringIO.new }
-  let(:prompt) { TTY::Prompt.new(input, output) }
-
   context 'with no mask' do
     it 'asks with echo on' do
-      input << "password"
-      input.rewind
-      q = prompt.ask("What is your password: ").echo(true)
-      expect(q.read).to eql("password")
-      expect(output.string).to eql('What is your password: ')
-      expect(q.mask?).to eq(false)
+      prompt = TTY::TestPrompt.new
+      prompt.input << "password"
+      prompt.input.rewind
+      answer = prompt.ask("What is your password: ") { |q| q.echo(true) }
+      expect(answer).to eql("password")
+      expect(prompt.output.string).to eql('What is your password: ')
     end
 
     it 'asks with echo off' do
-      input << "password"
-      input.rewind
-      q = prompt.ask("What is your password: ").echo(false)
-      expect(q.read).to eql("password")
-      expect(output.string).to eql('What is your password: ')
-      expect(q.mask?).to eq(false)
+      prompt = TTY::TestPrompt.new
+      prompt.input << "password"
+      prompt.input.rewind
+      answer = prompt.ask("What is your password: ") { |q| q.echo(false) }
+      expect(answer).to eql("password")
+      expect(prompt.output.string).to eql('What is your password: ')
     end
   end
 
   context 'with mask' do
     it 'masks output with character' do
-      input << "password\n"
-      input.rewind
-      q = prompt.ask("What is your password: ").mask('*')
-      expect(q.read).to eql("password")
-      expect(output.string).to eql('What is your password: ********')
-      expect(q.mask?).to eq(true)
+      prompt = TTY::TestPrompt.new
+      prompt.input << "password\n"
+      prompt.input.rewind
+      answer = prompt.ask("What is your password: ") { |q| q.mask('*') }
+      expect(answer).to eql("password")
+      expect(prompt.output.string).to eql('What is your password: ********')
     end
 
     it 'ignores mask if echo is off' do
-      input << "password"
-      input.rewind
-      q = prompt.ask("What is your password: ").echo(false).mask('*')
-      expect(q.read).to eql("password")
-      expect(output.string).to eql('What is your password: ')
-      expect(q.mask?).to eq(true)
+      prompt = TTY::TestPrompt.new
+      prompt.input << "password"
+      prompt.input.rewind
+      answer = prompt.ask('What is your password: ') do |q|
+        q.echo false
+        q.mask '*'
+      end
+      expect(answer).to eql("password")
+      expect(prompt.output.string).to eql('What is your password: ')
     end
   end
 
   context 'with mask and echo as options' do
     it 'asks with options' do
-      input << "password"
-      input.rewind
-      q = prompt.ask("What is your password: ", echo: false, mask: '*')
-      expect(q.read).to eq("password")
+      prompt = TTY::TestPrompt.new
+      prompt.input << "password"
+      prompt.input.rewind
+      answer = prompt.ask("What is your password: ", echo: false, mask: '*')
+      expect(answer).to eq("password")
     end
 
     it 'asks with block' do
-      input << "password"
-      input.rewind
-      q = prompt.ask "What is your password: " do
-        echo  false
-        mask '*'
+      prompt = TTY::TestPrompt.new
+      prompt.input << "password"
+      prompt.input.rewind
+      answer = prompt.ask "What is your password: " do |q|
+        q.echo  false
+        q.mask '*'
       end
-      expect(q.read).to eq("password")
+      expect(answer).to eq("password")
     end
   end
 end