tty-prompt 0.12.0 → 0.13.0

data/spec/unit/reader/line_spec.rb

@@ -1,110 +0,0 @@
-# encoding: utf-8
-
-RSpec.describe TTY::Prompt::Reader::Line do
-  it "inserts characters in line" do
-    line = described_class.new('aaaaa')
-    line[0] = 'test'
-    expect(line.text).to eq('testaaaaa')
-    line[4..6] = ''
-    expect(line.text).to eq('testaa')
-  end
-
-  it "moves cursor left and right" do
-    line = described_class.new('aaaaa')
-    5.times { line.left }
-    expect(line.cursor).to eq(0)
-    expect(line.start?).to eq(true)
-    line.left(5)
-    expect(line.cursor).to eq(0)
-    line.right(20)
-    expect(line.cursor).to eq(5)
-    expect(line.end?).to eq(true)
-  end
-
-  it "inserts char at start of the line" do
-    line = described_class.new('aaaaa')
-    expect(line.cursor).to eq(5)
-    line[0] = 'b'
-    expect(line.cursor).to eq(1)
-    expect(line.text).to eq('baaaaa')
-    line.insert('b')
-    expect(line.text).to eq('bbaaaaa')
-  end
-
-  it "inserts char at end of the line" do
-    line = described_class.new('aaaaa')
-    expect(line.cursor).to eq(5)
-    line[4] = 'b'
-    expect(line.cursor).to eq(5)
-    expect(line.text).to eq('aaaaab')
-  end
-
-  it "inserts char inside the line" do
-    line = described_class.new('aaaaa')
-    expect(line.cursor).to eq(5)
-    line[2] = 'b'
-    expect(line.cursor).to eq(3)
-    expect(line.text).to eq('aabaaa')
-  end
-
-  it "inserts char outside of the line size" do
-    line = described_class.new('aaaaa')
-    expect(line.cursor).to eq(5)
-    line[10] = 'b'
-    expect(line.cursor).to eq(11)
-    expect(line.text).to eq('aaaaa     b')
-  end
-
-  it "inserts chars on empty string" do
-    line = described_class.new('')
-    expect(line.cursor).to eq(0)
-    line.insert('a')
-    expect(line.cursor).to eq(1)
-    line.insert('b')
-    expect(line.cursor).to eq(2)
-    expect(line.to_s).to eq('ab')
-    line.insert('cc')
-    expect(line.cursor).to eq(4)
-    expect(line.to_s).to eq('abcc')
-  end
-
-  it "inserts characters with #insert call" do
-    line = described_class.new('aaaaa')
-    line.left(2)
-    expect(line.cursor).to eq(3)
-    line.insert(' test ')
-    expect(line.text).to eq('aaa test aa')
-    expect(line.cursor).to eq(9)
-    line.right
-    expect(line.cursor).to eq(10)
-  end
-
-  it "removes char before current cursor position" do
-    line = described_class.new('abcdef')
-    expect(line.cursor).to eq(6)
-    line.remove
-    line.remove
-    expect(line.text).to eq('abcd')
-    expect(line.cursor).to eq(4)
-    line.left
-    line.left
-    line.remove
-    expect(line.text).to eq('acd')
-    expect(line.cursor).to eq(1)
-    line.insert('x')
-    expect(line.text).to eq('axcd')
-  end
-
-  it "deletes char under current cursor position" do
-    line = described_class.new('abcdef')
-    line.left(3)
-    line.delete
-    expect(line.text).to eq('abcef')
-    line.right
-    line.delete
-    expect(line.text).to eq('abce')
-    line.left(4)
-    line.delete
-    expect(line.text).to eq('bce')
-  end
-end

data/spec/unit/reader/publish_keypress_event_spec.rb

@@ -1,94 +0,0 @@
-# encoding: utf-8
-
-RSpec.describe TTY::Prompt::Reader, '#publish_keypress_event' do
-  let(:input)  { StringIO.new }
-  let(:out) { StringIO.new }
-  let(:env)    { { "TTY_TEST" => true } }
-
-  let(:reader) { described_class.new(input, out, env: env) }
-
-  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 \n))
-    expect(answer).to eq("abc\n")
-  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
-
-  it "subscribes to ctrl+X type of event event" do
-    input << ?\C-z
-    input.rewind
-    keys = []
-    reader.on(:keyctrl_z) { |event| keys << "ctrl_z" }
-
-    answer = reader.read_keypress
-    expect(keys).to eq(['ctrl_z'])
-    expect(answer).to eq(?\C-z)
-  end
-end

data/spec/unit/reader/read_keypress_spec.rb

@@ -1,80 +0,0 @@
-# encoding: utf-8
-
-RSpec.describe TTY::Prompt::Reader, '#read_keypress' do
-  let(:input)  { StringIO.new }
-  let(:out)    { StringIO.new }
-  let(:env)    { { "TTY_TEST" => true } }
-
-  it "reads single key press" do
-    reader = described_class.new(input, out, env: env)
-    input << "\e[Aaaaaaa\n"
-    input.rewind
-
-    answer = reader.read_keypress
-
-    expect(answer).to eq("\e[A")
-  end
-
-  it 'reads multibyte key press' do
-    reader = described_class.new(input, out, env: env)
-    input << "ㄱ"
-    input.rewind
-
-    answer = reader.read_keypress
-
-    expect(answer).to eq("ㄱ")
-  end
-
-  context 'when Ctrl+C pressed' do
-    it "defaults to raising InputInterrupt" do
-      reader = described_class.new(input, out, env: env)
-      input << "\x03"
-      input.rewind
-
-      expect {
-        reader.read_keypress
-      }.to raise_error(TTY::Prompt::Reader::InputInterrupt)
-    end
-
-    it "sends interrupt signal when :signal option is chosen" do
-      reader = described_class.new(input, out, interrupt: :signal, env: env)
-      input << "\x03"
-      input.rewind
-
-      allow(Process).to receive(:pid).and_return(666)
-      allow(Process).to receive(:kill)
-      expect(Process).to receive(:kill).with('SIGINT', 666)
-
-      reader.read_keypress
-    end
-
-    it "exits with 130 code when :exit option is chosen" do
-      reader = described_class.new(input, out, interrupt: :exit, env: env)
-      input << "\x03"
-      input.rewind
-
-      expect {
-        reader.read_keypress
-      }.to raise_error(SystemExit)
-    end
-
-    it "evaluates custom handler when proc object is provided" do
-      handler = proc { raise ArgumentError }
-      reader = described_class.new(input, out, interrupt: handler, env: env)
-      input << "\x03"
-      input.rewind
-
-      expect {
-       reader.read_keypress
-      }.to raise_error(ArgumentError)
-    end
-
-    it "skips handler when handler is nil" do
-      reader = described_class.new(input, out, interrupt: :noop, env: env)
-      input << "\x03"
-      input.rewind
-
-      expect(reader.read_keypress).to eq("\x03")
-    end
-  end
-end

data/spec/unit/reader/read_line_spec.rb

@@ -1,68 +0,0 @@
-# encoding: utf-8
-
-RSpec.describe TTY::Prompt::Reader, '#read_line' do
-  let(:input)  { StringIO.new }
-  let(:output) { StringIO.new }
-  let(:env)    { { "TTY_TEST" => true } }
-
-  subject(:reader) { described_class.new(input, output, env: env) }
-
-  it 'masks characters' do
-    input << "password\n"
-    input.rewind
-    answer = reader.read_line(echo: false)
-    expect(answer).to eq("password\n")
-  end
-
-  it "echoes characters back" do
-    input << "password\n"
-    input.rewind
-    answer = reader.read_line
-    expect(answer).to eq("password\n")
-    expect(output.string).to eq([
-      "\e[2K\e[1Gp",
-      "\e[2K\e[1Gpa",
-      "\e[2K\e[1Gpas",
-      "\e[2K\e[1Gpass",
-      "\e[2K\e[1Gpassw",
-      "\e[2K\e[1Gpasswo",
-      "\e[2K\e[1Gpasswor",
-      "\e[2K\e[1Gpassword",
-      "\e[2K\e[1Gpassword\n"
-    ].join)
-  end
-
-  it "doesn't echo characters back" do
-    input << "password\n"
-    input.rewind
-    answer = reader.read_line(echo: false)
-    expect(answer).to eq("password\n")
-    expect(output.string).to eq('')
-  end
-
-  it "displays a prompt before input" do
-    input << "aa\n"
-    input.rewind
-    answer = reader.read_line('>> ')
-    expect(answer).to eq("aa\n")
-    expect(output.string).to eq([
-      "\e[2K\e[1G>> a",
-      "\e[2K\e[1G>> aa",
-      "\e[2K\e[1G>> aa\n"
-    ].join)
-  end
-
-  xit 'deletes characters when backspace pressed' do
-    input << "aa\ba\bcc\n"
-    input.rewind
-    answer = reader.read_line
-    expect(answer).to eq("acc\n")
-  end
-
-  it 'reads multibyte line' do
-    input << "한글"
-    input.rewind
-    answer = reader.read_line
-    expect(answer).to eq("한글")
-  end
-end

data/spec/unit/reader/read_multiline_spec.rb

@@ -1,60 +0,0 @@
-# encoding: utf-8
-
-RSpec.describe TTY::Prompt::Reader, '#read_multiline' do
-  let(:input)  { StringIO.new }
-  let(:output) { StringIO.new }
-  let(:env)    { { "TTY_TEST" => true } }
-
-  subject(:reader) { described_class.new(input, output, env: env) }
-
-  it 'reads no lines' do
-    input << "\C-d"
-    input.rewind
-    answer = reader.read_multiline
-    expect(answer).to eq([])
-  end
-
-  it "reads a line and terminates on Ctrl+d" do
-    input << "Single line\C-d"
-    input.rewind
-    answer = reader.read_multiline
-    expect(answer).to eq(["Single line"])
-  end
-
-  it "reads a line and terminates on Ctrl+z" do
-    input << "Single line\C-z"
-    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\n\C-d"
-    input.rewind
-    answer = reader.read_multiline
-    expect(answer).to eq(["First line\n", "Second line\n", "Third line\n"])
-  end
-
-  it "skips empty lines" do
-    input << "\n\nFirst line\n\n\n\n\nSecond line\C-d"
-    input.rewind
-    answer = reader.read_multiline
-    expect(answer).to eq(["First line\n", "Second line"])
-  end
-
-  it 'reads and yiels every line' do
-    input << "First line\nSecond line\nThird line\C-z"
-    input.rewind
-    lines = []
-    reader.read_multiline { |line| lines << line }
-    expect(lines).to eq(["First line\n", "Second line\n", "Third line"])
-  end
-
-  it 'reads multibyte lines' do
-    input << "국경의 긴 터널을 빠져나오자\n설국이었다.\C-d"
-    input.rewind
-    lines = []
-    reader.read_multiline { |line| lines << line }
-    expect(lines).to eq(["국경의 긴 터널을 빠져나오자\n", '설국이었다.'])
-  end
-end

data/spec/unit/result_spec.rb

@@ -1,40 +0,0 @@
-# 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