tty-prompt 0.2.0 → 0.3.0

data/spec/unit/question/modify_spec.rb

@@ -1,10 +1,10 @@
 # encoding: utf-8
 
-require 'spec_helper'
-
 RSpec.describe TTY::Prompt::Question, '#modify' do
+
+  subject(:prompt) { TTY::TestPrompt.new }
+
   it 'preserves answer for unkown modification' do
-    prompt = TTY::TestPrompt.new
     prompt.input << 'piotr'
     prompt.input.rewind
     answer = prompt.ask("What is your name?") { |q| q.modify(:none) }
@@ -12,7 +12,6 @@ RSpec.describe TTY::Prompt::Question, '#modify' do
   end
 
   it 'converts to upper case' do
-    prompt = TTY::TestPrompt.new
     prompt.input << 'piotr'
     prompt.input.rewind
     answer = prompt.ask("What is your name?") { |q| q.modify(:upcase) }
@@ -20,7 +19,6 @@ RSpec.describe TTY::Prompt::Question, '#modify' do
   end
 
   it 'trims whitespace' do
-    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) }
@@ -28,7 +26,6 @@ RSpec.describe TTY::Prompt::Question, '#modify' do
   end
 
   it 'collapses whitespace' do
-    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) }
@@ -36,7 +33,6 @@ RSpec.describe TTY::Prompt::Question, '#modify' do
   end
 
   it 'strips and collapses whitespace' do
-    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) }

data/spec/unit/question/required_spec.rb

@@ -1,28 +1,34 @@
 # 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 << ''
+
+  subject(:prompt) { TTY::TestPrompt.new }
+
+  it 'requires value to be present' do
+    prompt.input << "Piotr"
     prompt.input.rewind
-    expect {
-      prompt.ask('What is your name?') { |q| q.required(true) }
-    }.to raise_error(ArgumentError)
+    prompt.ask('What is your name?') { |q| q.required(true) }
+    expect(prompt.output.string).to eq([
+      "What is your name? ",
+      "\e[1000D\e[K\e[1A",
+      "\e[1000D\e[K",
+      "What is your name? \e[32mPiotr\e[0m\n"
+    ].join)
   end
 
   it 'requires value to be present with option' do
-    prompt = TTY::TestPrompt.new
-    prompt.input << ''
+    prompt.input << "Piotr"
     prompt.input.rewind
-    expect {
-      prompt.ask('What is your name?', required: true)
-    }.to raise_error(ArgumentError)
+    prompt.ask('What is your name?') { |q| q.required(true) }
+    expect(prompt.output.string).to eq([
+      "What is your name? ",
+      "\e[1000D\e[K\e[1A",
+      "\e[1000D\e[K",
+      "What is your name? \e[32mPiotr\e[0m\n"
+    ].join)
   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) }

data/spec/unit/question/validate_spec.rb

@@ -1,38 +1,39 @@
 # encoding: utf-8
 
-require 'spec_helper'
-
 RSpec.describe TTY::Prompt::Question, '#validate' do
-  it 'fails to validate input' do
-    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
+
+  subject(:prompt) { TTY::TestPrompt.new }
 
   it 'validates input with regex' do
-    prompt = TTY::TestPrompt.new
     prompt.input << 'piotr.murach'
     prompt.input.rewind
-    answer = prompt.ask('What is your username?') { |q|
+    answer = prompt.ask('What is your username?') do |q|
       q.validate(/^[^\.]+\.[^\.]+/)
-    }
+    end
     expect(answer).to eq('piotr.murach')
+    expect(prompt.output.string).to eq([
+      "What is your username? ",
+      "\e[1000D\e[K\e[1A",
+      "\e[1000D\e[K",
+      "What is your username? \e[32mpiotr.murach\e[0m\n"
+    ].join)
   end
 
   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|
+    answer = prompt.ask('What is your username?') do |q|
       q.validate { |input| input =~ /^[^\.]+\.[^\.]+/ }
-    }
+    end
     expect(answer).to eq('piotr.murach')
   end
 
-  it 'understands custom validation like :email'
+  it 'understands custom validation like :email' do
+    prompt.input << 'piotr@example.com'
+    prompt.input.rewind
+    answer = prompt.ask('What is your email?') do |q|
+      q.validate :email
+    end
+    expect(answer).to eq('piotr@example.com')
+  end
 end

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

@@ -1,22 +1,31 @@
 # 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
+    validation = described_class.new(pattern)
     expect(validation.(nil)).to eq(false)
   end
 
   it "validates successfully when the value matches pattern" do
+    validation = described_class.new(pattern)
     expect(validation.('piotr.murach')).to eq(true)
   end
 
+  it "validates with a proc" do
+    pat = proc { |input| !pattern.match(input).nil? }
+    validation = described_class.new(pat)
+    expect(validation.call('piotr.murach')).to eq(true)
+  end
+
+  it "validates with custom name" do
+    validation = described_class.new(:email)
+    expect(validation.call('piotr@example.com')).to eq(true)
+  end
+
   it "fails validation when not maching pattern" do
-    expect {
-      validation.('piotrmurach')
-    }.to raise_error(TTY::Prompt::InvalidArgument)
+    validation = described_class.new(pattern)
+    expect(validation.('piotrmurach')).to eq(false)
   end
 end

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

@@ -1,24 +1,30 @@
 # encoding: utf-8
 
-require 'spec_helper'
-
 RSpec.describe TTY::Prompt::Question::Validation, '#coerce' do
   let(:instance) { described_class.new }
 
-  it "coerces into proc" do
-    validation = lambda { "^[^\.]+\.[^\.]+" }
-    expect(instance.coerce(validation)).to be_kind_of(Proc)
+  it "coerces lambda into proc" do
+    pattern = lambda { "^[^\.]+\.[^\.]+" }
+    validation = described_class.new(pattern)
+    expect(validation.pattern).to be_a(Proc)
+  end
+
+  it "doesn't coerce symbols" do
+    pattern = :email
+    validation =described_class.new(pattern)
+    expect(validation.pattern).to eq(:email)
   end
 
-  it "cources into regex" do
-    validation = "^[^\.]+\.[^\.]+"
-    expect(instance.coerce(validation)).to be_kind_of(Regexp)
+  it "coerces into regex" do
+    pattern = /^[^\.]+\.[^\.]+/
+    validation = described_class.new(pattern)
+    expect(validation.pattern).to be_a(Regexp)
   end
 
-  it "fails to coerce validation" do
-    validation = Object.new
+  it "fails to coerce pattern into validation" do
+    pattern = Object.new
     expect {
-      instance.coerce(validation)
+      described_class.new(pattern)
     }.to raise_error(TTY::Prompt::ValidationCoercion)
   end
 end

data/spec/unit/reader/publish_keypress_event_spec.rb

@@ -0,0 +1,81 @@
+# encoding: utf-8
+
+RSpec.describe TTY::Prompt::Reader, '#publish_keypress_event' do
+  let(:input)  { StringIO.new }
+  let(:out) { StringIO.new }
+  let(:reader) { described_class.new(input, out) }
+
+  it "publishes :keypress events" do
+    input << "abc\n"
+    input.rewind
+    chars = []
+    reader.on(:keypress) { |event| chars << event.value }
+    answer = reader.read_line
+    expect(chars).to eq(%w(a b c))
+    expect(answer).to eq("abc")
+  end
+
+  it "publishes :keyup for read_keypress" do
+    input << "\e[Aaa"
+    input.rewind
+    keys = []
+    reader.on(:keypress) { |event| keys << "keypress_#{event.value}" }
+    reader.on(:keyup)    { |event| keys << "keyup_#{event.value}" }
+    reader.on(:keydown)  { |event| keys << "keydown_#{event.value}" }
+
+    answer = reader.read_keypress
+    expect(keys).to eq(["keyup_\e[A", "keypress_\e[A"])
+    expect(answer).to eq("\e[A")
+  end
+
+  it "publishes :keydown event for read_keypress" do
+    input << "\e[Baa"
+    input.rewind
+    keys = []
+    reader.on(:keypress) { |event| keys << "keypress_#{event.value}" }
+    reader.on(:keyup)    { |event| keys << "keyup_#{event.value}" }
+    reader.on(:keydown)  { |event| keys << "keydown_#{event.value}" }
+
+    answer = reader.read_keypress
+    expect(keys).to eq(["keydown_\e[B", "keypress_\e[B"])
+    expect(answer).to eq("\e[B")
+  end
+
+  it "publishes :keynum event" do
+    input << "5aa"
+    input.rewind
+    keys = []
+    reader.on(:keypress) { |event| keys << "keypress_#{event.value}" }
+    reader.on(:keyup)    { |event| keys << "keyup_#{event.value}" }
+    reader.on(:keynum)   { |event| keys << "keynum_#{event.value}" }
+
+    answer = reader.read_keypress
+    expect(keys).to eq(["keynum_5", "keypress_5"])
+    expect(answer).to eq("5")
+  end
+
+  it "publishes :keyreturn event" do
+    input << "\r"
+    input.rewind
+    keys = []
+    reader.on(:keypress)  { |event| keys << "keypress" }
+    reader.on(:keyup)     { |event| keys << "keyup" }
+    reader.on(:keyreturn) { |event| keys << "keyreturn" }
+
+    answer = reader.read_keypress
+    expect(keys).to eq(["keyreturn", "keypress"])
+    expect(answer).to eq("\r")
+  end
+
+  it "subscribes to multiple events" do
+    input << "\n"
+    input.rewind
+    keys = []
+    reader.on(:keyenter) { |event| keys << "keyenter" }
+          .on(:keypress) { |event| keys << "keypress" }
+
+    answer = reader.read_keypress
+    expect(keys).to eq(["keyenter", "keypress"])
+    expect(answer).to eq("\n")
+  end
+end

data/spec/unit/reader/read_keypress_spec.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+RSpec.describe TTY::Prompt::Reader, '#read_keypress' do
+  let(:input)  { StringIO.new }
+  let(:out) { StringIO.new }
+  let(:reader) { described_class.new(input, out) }
+
+  it "reads single key press" do
+    input << "\e[Aaaaaaa\n"
+    input.rewind
+    answer = reader.read_keypress
+    expect(answer).to eq("\e[A")
+  end
+
+  it "stops reading when ctrl-c pressed" do
+    input << "\x03"
+    input.rewind
+    expect {
+      reader.read_keypress
+    }.to raise_error(SystemExit)
+  end
+end

data/spec/unit/reader/read_line_spec.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+RSpec.describe TTY::Prompt::Reader, '#read_line' do
+  let(:input)  { StringIO.new }
+  let(:output) { StringIO.new }
+
+  subject(:reader) { described_class.new(input, output) }
+
+  it 'masks characters' do
+    mask = '*'
+    input << "password\n"
+    input.rewind
+    answer = reader.read_line(mask)
+    expect(answer).to eq("password")
+  end
+
+  it "echoes characters back" do
+    input << "password\n"
+    input.rewind
+    answer = reader.read_line
+    expect(answer).to eq("password")
+    expect(output.string).to eq("")
+  end
+
+  it 'deletes characters when backspace pressed' do
+    input << "aa\ba\bcc"
+    input.rewind
+    answer = reader.read_line
+    expect(answer).to eq('acc')
+  end
+end

data/spec/unit/reader/read_multiline_spec.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+RSpec.describe TTY::Prompt::Reader, '#read_multiline' do
+  let(:input)  { StringIO.new }
+  let(:output) { StringIO.new }
+
+  subject(:reader) { described_class.new(input, output) }
+
+  it 'reads no lines' do
+    input << ''
+    input.rewind
+    answer = reader.read_multiline
+    expect(answer).to eq([])
+  end
+
+  it "reads a line" do
+    input << "Single line"
+    input.rewind
+    answer = reader.read_multiline
+    expect(answer).to eq(['Single line'])
+  end
+
+  it 'reads few lines' do
+    input << "First line\nSecond line\nThird line"
+    input.rewind
+    answer = reader.read_multiline
+    expect(answer).to eq(['First line', 'Second line', 'Third line'])
+  end
+
+  it 'reads and yiels every line' do
+    input << "First line\nSecond line\nThird line"
+    input.rewind
+    lines = []
+    reader.read_multiline { |line| lines << line }
+    expect(lines).to eq(['First line', 'Second line', 'Third line'])
+  end
+end

data/spec/unit/result_spec.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+RSpec.describe TTY::Prompt::Result do
+  it "checks value to be invalid" do
+    question = double(:question)
+    result = TTY::Prompt::Result.new(question, nil)
+
+    answer = result.with { |quest, value|
+      if value.nil?
+        [value, ["`#{value}` provided cannot be empty"]]
+      else
+        value
+      end
+    }
+    expect(answer).to be_a(TTY::Prompt::Result::Failure)
+    expect(answer.success?).to eq(false)
+    expect(answer.errors).to eq(["`` provided cannot be empty"])
+  end
+
+  it "checks value to be valid" do
+    question = double(:question)
+    result = TTY::Prompt::Result.new(question, 'Piotr')
+
+    CheckRequired = Class.new do
+      def self.call(quest, value)
+        if value.nil?
+          [value, ["`#{value}` provided cannot be empty"]]
+        else
+          value
+        end
+      end
+    end
+
+    answer = result.with(CheckRequired)
+    expect(answer).to be_a(TTY::Prompt::Result::Success)
+    expect(answer.success?).to eq(true)
+    expect(answer.value).to eq('Piotr')
+    expect(answer.errors).to eq([])
+  end
+end