tty-reader 0.7.0 → 0.8.0

data/spec/unit/line_spec.rb

@@ -1,158 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe TTY::Reader::Line do
-  it "provides access to the prompt" do
-    line = described_class.new('aaa', prompt: '>> ')
-    expect(line.prompt).to eq('>> ')
-    expect(line.text).to eq('aaa')
-    expect(line.size).to eq(6)
-    expect(line.to_s).to eq(">> aaa")
-  end
-
-  it "inserts characters inside a 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('aaaaba')
-  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 in 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')
-    expect(line.cursor).to eq(5)
-
-    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(2)
-    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
-
-  it "replaces current line with new preserving cursor" do
-    line = described_class.new('x' * 6)
-    expect(line.text).to eq('xxxxxx')
-    expect(line.cursor).to eq(6)
-    expect(line.mode).to eq(:edit)
-    expect(line.editing?).to eq(true)
-
-    line.replace('y' * 8)
-    expect(line.text).to eq('y' * 8)
-    expect(line.cursor).to eq(8)
-    expect(line.replacing?).to eq(true)
-
-    line.insert('z')
-    expect(line.text).to eq('y' * 8 + 'z')
-    expect(line.cursor).to eq(9)
-    expect(line.editing?).to eq(true)
-  end
-end

data/spec/unit/publish_keypress_event_spec.rb

@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe TTY::Reader, '#publish_keypress_event' do
-  let(:input) { StringIO.new }
-  let(:out)   { StringIO.new }
-  let(:env)   { { "TTY_TEST" => true } }
-
-  let(:reader) { described_class.new(input: input, output: out, env: env) }
-
-  it "publishes :keypress events" do
-    input << "abc\n"
-    input.rewind
-    chars = []
-    lines = []
-    reader.on(:keypress) { |event| chars << event.value; lines << event.line }
-    answer = reader.read_line
-
-    expect(chars).to eq(%W(a b c \n))
-    expect(lines).to eq(%W(a ab abc abc\n))
-    expect(answer).to eq("abc\n")
-  end
-
-  it "publishes :keyescape events" do
-    input << "a\e"
-    input.rewind
-    keys = []
-    reader.on(:keypress)  { |event| keys << "keypress_#{event.value}"}
-    reader.on(:keyescape) { |event| keys << "keyescape_#{event.value}" }
-
-    answer = reader.read_line
-    expect(keys).to eq(["keypress_a", "keyescape_\e", "keypress_\e"])
-    expect(answer).to eq("a\e")
-  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/read_keypress_spec.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe TTY::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: input, output: 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: input, output: 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: input, output: out, env: env)
-      input << "\x03"
-      input.rewind
-
-      expect {
-        reader.read_keypress
-      }.to raise_error(TTY::Reader::InputInterrupt)
-    end
-
-    it "sends interrupt signal when :signal option is chosen" do
-      reader = described_class.new(
-        input: input,
-        output: 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: input,
-        output: 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: input,
-        output: 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: input,
-        output: out,
-        interrupt: :noop,
-        env: env)
-      input << "\x03"
-      input.rewind
-
-      expect(reader.read_keypress).to eq("\x03")
-    end
-  end
-end

data/spec/unit/read_line_spec.rb

@@ -1,119 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe TTY::Reader, '#read_line' do
-  let(:input)  { StringIO.new }
-  let(:output) { StringIO.new }
-  let(:env)    { { "TTY_TEST" => true } }
-
-  subject(:reader) { described_class.new(input: input, output: 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("\n")
-  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
-
-  it "displays custom input with a prompt" do
-    input << "aa\n"
-    input.rewind
-
-    answer = reader.read_line("> ", value: "xx")
-
-    expect(answer).to eq("xxaa\n")
-    expect(output.string).to eq([
-      "> xx",
-      "\e[2K\e[1G> xxa",
-      "\e[2K\e[1G> xxaa",
-      "\e[2K\e[1G> xxaa\n"
-    ].join)
-  end
-
-  it '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
-
-  it "supports multiline prompts" do
-    allow(TTY::Screen).to receive(:width).and_return(50)
-    prompt = "one\ntwo\nthree"
-    input << "aa\n"
-    input.rewind
-
-    answer = reader.read_line(prompt)
-
-    expect(answer).to eq("aa\n")
-    expect(output.string).to eq([
-      prompt,
-      "\e[2K\e[1G\e[1A" * 2,
-      "\e[2K\e[1G",
-      prompt + "a",
-      "\e[2K\e[1G\e[1A" * 2,
-      "\e[2K\e[1G",
-      prompt + "aa",
-      "\e[2K\e[1G\e[1A" * 2,
-      "\e[2K\e[1G",
-      prompt + "aa\n"
-    ].join)
-  end
-end