tty-prompt 0.16.1 → 0.17.0

data/spec/unit/collect_spec.rb

@@ -0,0 +1,96 @@
+# encoding: utf-8
+
+RSpec.describe TTY::Prompt, '#collect' do
+
+  subject(:prompt) { TTY::TestPrompt.new }
+
+  def collect(&block)
+    prompt = subject
+    count = 0
+
+    result = prompt.collect do
+      while prompt.yes?("continue?")
+        instance_eval(&block)
+        count += 1
+      end
+    end
+
+    result[:count] = count
+    result
+  end
+
+  context "when receiving multiple answers" do
+    let(:colors) { %w(red blue yellow) }
+
+    before do
+      subject.input << "y\r" + colors.join("\ry\r") + "\rn\r"
+      subject.input.rewind
+    end
+
+    it "collects as a list if values method used in chain" do
+      result = collect { key(:colors).values.ask("color:") }
+      expect(result[:count]).to eq(3)
+      expect(result[:colors]).to eq(colors)
+    end
+
+    it "collects as a list if values method used in chain with block" do
+      result = collect do
+        key(:colors).values { key(:name).ask("color:") }
+      end
+      expect(result[:count]).to eq(3)
+      expect(result[:colors]).to eq(colors.map { |c| { name: c } })
+    end
+
+    context "with multiple keys" do
+      let(:colors) { ["red\rblue", "yellow\rgreen"] }
+      let(:expected_pairs) do
+        colors.map { |s| Hash[%i(hot cold).zip(s.split("\r"))] }
+      end
+
+      it "collects into the appropriate keys" do
+        result = collect do
+          key(:pairs).values do
+            key(:hot).ask("color:")
+            key(:cold).ask("color:")
+          end
+        end
+
+        expect(result[:count]).to eq(2)
+        expect(result[:pairs]).to eq(expected_pairs)
+      end
+    end
+
+    it "overrides a non-array key on multiple answers" do
+      result = collect { key(:colors).ask("color:") }
+      expect(result[:colors]).to eq(colors.last)
+      expect(result[:count]).to eq(3)
+    end
+  end
+
+  it "collects more than one answer" do
+    prompt.input << "Piotr\r30\rStreet\rCity\r123\r"
+    prompt.input.rewind
+
+    result = prompt.collect do
+      key(:name).ask('Name?')
+
+      key(:age).ask('Age?', convert: :int)
+
+      key(:address) do
+        key(:street).ask('Street?', required: true)
+        key(:city).ask('City?')
+        key(:zip).ask('Zip?', validate: /\A\d{3}\Z/)
+      end
+    end
+
+    expect(result).to include({
+      name: 'Piotr',
+      age: 30,
+      address: {
+        street: 'Street',
+        city: 'City',
+        zip: '123'
+      }
+    })
+  end
+end

data/spec/unit/converters/convert_bool_spec.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+RSpec.describe TTY::Prompt::Question, 'convert bool' do
+
+  subject(:prompt) { TTY::TestPrompt.new}
+
+  it 'fails to convert boolean' do
+    prompt.input << 'invalid'
+    prompt.input.rewind
+    expect {
+      prompt.ask("Do you read books?", convert: :bool)
+    }.to raise_error(TTY::Prompt::ConversionError)
+  end
+
+  it "handles default values" do
+    prompt.input << "\n"
+    prompt.input.rewind
+    response = prompt.ask('Do you read books?', convert: :bool, default: true)
+    expect(response).to eql(true)
+    expect(prompt.output.string).to eq([
+      "Do you read books? \e[90m(true)\e[0m ",
+      "\e[2K\e[1GDo you read books? \e[90m(true)\e[0m \n",
+      "\e[1A\e[2K\e[1G",
+      "Do you read books? \e[32mtrue\e[0m\n"
+    ].join)
+  end
+
+  it "handles default values" do
+    prompt.input << "\n"
+    prompt.input.rewind
+    response = prompt.ask("Do you read books?") { |q|
+      q.default true
+      q.convert :bool
+    }
+    expect(response).to eq(true)
+  end
+
+  it 'converts negative boolean' do
+    prompt.input << 'No'
+    prompt.input.rewind
+    response = prompt.ask('Do you read books?', convert: :bool)
+    expect(response).to eq(false)
+  end
+
+  it 'converts positive boolean' do
+    prompt.input << 'Yes'
+    prompt.input.rewind
+    response = prompt.ask("Do you read books?", convert: :bool)
+    expect(response).to eq(true)
+  end
+
+  it 'converts single positive boolean' do
+    prompt.input << 'y'
+    prompt.input.rewind
+    response = prompt.ask('Do you read books?', convert: :bool)
+    expect(response).to eq(true)
+  end
+end

data/spec/unit/converters/convert_char_spec.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+RSpec.describe TTY::Prompt::Question, 'convert char' do
+  it 'reads single character' do
+    prompt = TTY::TestPrompt.new
+    prompt.input << "abcde"
+    prompt.input.rewind
+    response = prompt.ask("What is your favourite letter?", convert: :char)
+    expect(response).to eq('a')
+  end
+end

data/spec/unit/converters/convert_custom_spec.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+RSpec.describe TTY::Prompt::Question, 'convert custom' do
+
+  subject(:prompt) { TTY::TestPrompt.new }
+
+  it 'converts response with custom conversion' do
+    prompt.input << "one,two,three\n"
+    prompt.input.rewind
+    conversion = proc { |input| input.split(/,\s*/) }
+    answer = prompt.ask('Ingredients? (comma sep list)', convert: conversion)
+    expect(answer).to eq(['one','two','three'])
+  end
+end

data/spec/unit/converters/convert_date_spec.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+RSpec.describe TTY::Prompt::Question, 'convert date' do
+
+  subject(:prompt) { TTY::TestPrompt.new}
+
+  it 'fails to convert date' do
+    prompt.input << 'invalid'
+    prompt.input.rewind
+    expect {
+      prompt.ask("When were you born?", convert: :date)
+    }.to raise_error(TTY::Prompt::ConversionError)
+  end
+
+  it 'converts date' do
+    prompt.input << "20th April 1887"
+    prompt.input.rewind
+    response = prompt.ask("When were your born?", convert: :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
+
+  it "converts datetime" do
+    prompt.input << "20th April 1887"
+    prompt.input.rewind
+    response = prompt.ask("When were your born?", convert: :datetime)
+    expect(response).to be_kind_of(DateTime)
+    expect(response.day).to eq(20)
+    expect(response.month).to eq(4)
+    expect(response.year).to eq(1887)
+  end
+end

data/spec/unit/converters/convert_file_spec.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+RSpec.describe TTY::Prompt::Question, 'convert file' do
+  it "converts to file" do
+    ::File.write('test.txt', 'foobar')
+
+    prompt = TTY::TestPrompt.new
+    prompt.input << "test.txt"
+    prompt.input.rewind
+
+    answer = prompt.ask("Which file to open?", convert: :file)
+
+    expect(::File.basename(answer)).to eq('test.txt')
+    expect(::File.read(answer)).to eq('foobar')
+
+    ::File.unlink('test.txt') unless Gem.win_platform?
+  end
+end

data/spec/unit/converters/convert_number_spec.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+RSpec.describe TTY::Prompt::Question, 'convert numbers' do
+
+  subject(:prompt) { TTY::TestPrompt.new }
+
+  it 'fails to convert integer' do
+    prompt.input << 'invalid'
+    prompt.input.rewind
+    expect {
+      prompt.ask("What temparture?", convert: :int)
+    }.to raise_error(TTY::Prompt::ConversionError)
+  end
+
+  it 'converts integer' do
+    prompt.input << 35
+    prompt.input.rewind
+    answer = prompt.ask("What temperature?", convert: :int)
+    expect(answer).to be_a(Integer)
+    expect(answer).to eq(35)
+  end
+
+  it 'fails to convert float' do
+    prompt.input << 'invalid'
+    prompt.input.rewind
+    expect {
+      prompt.ask("How tall are you?", convert: :float)
+    }.to raise_error(TTY::Prompt::ConversionError)
+  end
+
+  it 'converts float' do
+    number = 6.666
+    prompt.input << number
+    prompt.input.rewind
+    answer = prompt.ask('How tall are you?', convert: :float)
+    expect(answer).to be_a(Float)
+    expect(answer).to eq(number)
+  end
+end

data/spec/unit/converters/convert_path_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+RSpec.describe TTY::Prompt::Question, 'convert path' do
+  subject(:prompt) { TTY::TestPrompt.new }
+
+  it "converts pathname" do
+    path = Pathname.new(::File.join(Dir.pwd, 'spec/unit'))
+    prompt.input << "spec/unit"
+    prompt.input.rewind
+
+    answer = prompt.ask('File location?', convert: :path)
+
+    expect(answer).to eql(path)
+  end
+end

data/spec/unit/converters/convert_range_spec.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+RSpec.describe TTY::Prompt::Question, 'convert range' do
+
+  subject(:prompt) { TTY::TestPrompt.new}
+
+  it 'converts with valid range' do
+    prompt.input << "20-30"
+    prompt.input.rewind
+    answer = prompt.ask("Which age group?", convert: :range)
+    expect(answer).to be_a(Range)
+    expect(answer).to eq(20..30)
+  end
+
+  it "fails to convert to range" do
+    prompt.input << "abcd"
+    prompt.input.rewind
+    expect {
+      prompt.ask('Which age group?', convert: :range)
+    }.to raise_error(TTY::Prompt::ConversionError)
+  end
+end

data/spec/unit/converters/convert_regex_spec.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+RSpec.describe TTY::Prompt::Question, 'convert regexp' do
+  it "converts regex" do
+    prompt = TTY::TestPrompt.new
+    prompt.input << "[a-z]*"
+    prompt.input.rewind
+    answer = prompt.ask("Regex?", convert: :regexp)
+    expect(answer).to be_a(Regexp)
+    expect(answer).to eq(/[a-z]*/)
+  end
+end

data/spec/unit/converters/convert_string_spec.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+RSpec.describe TTY::Prompt::Question, 'convert string' do
+  it 'converts string' do
+    prompt = TTY::TestPrompt.new
+    prompt.input << 'Piotr'
+    prompt.input.rewind
+    answer = prompt.ask("What is your name?", convert: :string)
+    expect(answer).to be_a(String)
+    expect(answer).to eq('Piotr')
+  end
+
+  it "converts symbol" do
+    prompt = TTY::TestPrompt.new
+    prompt.input << 'Piotr'
+    prompt.input.rewind
+    answer = prompt.ask("What is your name?", convert: :symbol)
+    expect(answer).to be_a(Symbol)
+    expect(answer).to eq(:Piotr)
+  end
+end

data/spec/unit/converters/on_error_spec.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+RSpec.describe TTY::Prompt::Converters do
+  it "enforces block argument" do
+    expect {
+      TTY::Prompt::Converters.on_error
+    }.to raise_error(ArgumentError, 'You need to provide a block argument.')
+  end
+end

data/spec/unit/distance/distance_spec.rb

@@ -0,0 +1,73 @@
+# coding: utf-8
+
+RSpec.describe TTY::Prompt::Distance, '.distance' do
+  let(:object) { described_class.new }
+
+  subject(:distance) { object.distance(*strings) }
+
+  context 'when nil' do
+    let(:strings) { [nil, nil] }
+
+    it { is_expected.to eql(0) }
+  end
+
+  context 'when empty' do
+    let(:strings) { ['', ''] }
+
+    it { is_expected.to eql(0) }
+  end
+
+  context 'with one non empty' do
+    let(:strings) { ['abc', ''] }
+
+    it { is_expected.to eql(3) }
+  end
+
+  context 'when single char' do
+    let(:strings) { ['a', 'abc'] }
+
+    it { is_expected.to eql(2) }
+  end
+
+  context 'when similar' do
+    let(:strings) { ['abc', 'abc'] }
+
+    it { is_expected.to eql(0) }
+  end
+
+  context 'when similar' do
+    let(:strings) { ['abc', 'acb'] }
+
+    it { is_expected.to eql(1) }
+  end
+
+  context 'when end similar' do
+    let(:strings) { ['saturday', 'sunday'] }
+
+    it { is_expected.to eql(3) }
+  end
+
+  context 'when contain similar' do
+    let(:strings) { ['which', 'witch'] }
+
+    it { is_expected.to eql(2) }
+  end
+
+  context 'when prefix' do
+    let(:strings) { ['sta', 'status'] }
+
+    it { is_expected.to eql(3) }
+  end
+
+  context 'when similar' do
+    let(:strings) { ['smellyfish','jellyfish'] }
+
+    it { is_expected.to eql(2) }
+  end
+
+  context 'when unicode' do
+    let(:strings) { ['マラソン五輪代表', 'ララソン五輪代表'] }
+
+    it { is_expected.to eql(1) }
+  end
+end

data/spec/unit/enum_paginator_spec.rb

@@ -0,0 +1,75 @@
+# encoding: utf-8
+
+RSpec.describe TTY::Prompt::EnumPaginator, '#paginate' do
+  it "ignores per_page when equal items " do
+    list = %w(a b c d)
+    paginator = described_class.new({per_page: 4})
+
+    expect(paginator.paginate(list, 1).to_a).to eq([
+      ['a',0],['b',1],['c',2],['d',3]])
+  end
+
+  it "ignores per_page when less items " do
+    list = %w(a b c d)
+    paginator = described_class.new({per_page: 5})
+
+    expect(paginator.paginate(list, 1).to_a).to eq([
+      ['a',0],['b',1],['c',2],['d',3]])
+  end
+
+  it "paginates items matching per_page count" do
+    list = %w(a b c d e f)
+    paginator = described_class.new({per_page: 3})
+
+    expect(paginator.paginate(list, 1).to_a).to eq([['a',0], ['b',1], ['c',2]])
+    expect(paginator.paginate(list, 2).to_a).to eq([['a',0], ['b',1], ['c',2]])
+    expect(paginator.paginate(list, 3).to_a).to eq([['a',0], ['b',1], ['c',2]])
+    expect(paginator.paginate(list, 4).to_a).to eq([['d',3], ['e',4], ['f',5]])
+    expect(paginator.paginate(list, 5).to_a).to eq([['d',3], ['e',4], ['f',5]])
+    expect(paginator.paginate(list, 6).to_a).to eq([['d',3], ['e',4], ['f',5]])
+    expect(paginator.paginate(list, 7).to_a).to eq([['d',3], ['e',4], ['f',5]])
+  end
+
+  it "paginates items not matching per_page count" do
+    list = %w(a b c d e f g)
+    paginator = described_class.new({per_page: 3})
+
+    expect(paginator.paginate(list, 1).to_a).to eq([['a',0], ['b',1], ['c',2]])
+    expect(paginator.paginate(list, 2).to_a).to eq([['a',0], ['b',1], ['c',2]])
+    expect(paginator.paginate(list, 3).to_a).to eq([['a',0], ['b',1], ['c',2]])
+    expect(paginator.paginate(list, 4).to_a).to eq([['d',3], ['e',4], ['f',5]])
+    expect(paginator.paginate(list, 5).to_a).to eq([['d',3], ['e',4], ['f',5]])
+    expect(paginator.paginate(list, 6).to_a).to eq([['d',3], ['e',4], ['f',5]])
+    expect(paginator.paginate(list, 7).to_a).to eq([['g',6]])
+    expect(paginator.paginate(list, 8).to_a).to eq([['g',6]])
+  end
+
+  it "finds maximum index for current selection" do
+    list = %w(a b c d e f g)
+    paginator = described_class.new({per_page: 3, default: 0})
+
+    paginator.paginate(list, 4)
+    expect(paginator.max_index).to eq(5)
+    paginator.paginate(list, 5)
+    expect(paginator.max_index).to eq(5)
+    paginator.paginate(list, 7)
+    expect(paginator.max_index).to eq(8)
+  end
+
+  it "starts with default selection" do
+    list = %w(a b c d e f g)
+    paginator = described_class.new({per_page: 3, default: 3})
+
+    expect(paginator.paginate(list, 4).to_a).to eq([['d',3], ['e',4], ['f',5]])
+  end
+
+  it "doesn't accept invalid pagination" do
+    list = %w(a b c d e f g)
+
+    paginator = described_class.new({per_page: 0})
+
+    expect {
+      paginator.paginate(list, 4)
+    }.to raise_error(TTY::Prompt::InvalidArgument, /per_page must be > 0/)
+  end
+end