tty-reader 0.4.0 → 0.5.0

data/spec/unit/publish_keypress_event_spec.rb

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

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

@@ -0,0 +1,69 @@
+# 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 '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/read_multiline_spec.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+RSpec.describe TTY::Reader, '#read_multiline' 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 '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
+
+  it 'reads lines with a prompt' do
+    input << "1\n2\n3\C-d"
+    input.rewind
+    reader.read_multiline(">> ")
+    expect(output.string).to eq([
+      ">> ",
+      "\e[2K\e[1G>> 1",
+      "\e[2K\e[1G>> 1\n",
+      ">> ",
+      "\e[2K\e[1G>> 2",
+      "\e[2K\e[1G>> 2\n",
+      ">> ",
+      "\e[2K\e[1G>> 3",
+    ].join)
+  end
+end

data/spec/unit/subscribe_spec.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+RSpec.describe TTY::Reader, '#subscribe' do
+  let(:input)  { StringIO.new }
+  let(:output) { StringIO.new }
+  let(:env)    { { "TTY_TEST" => true } }
+
+  it "subscribes to receive events" do
+    stub_const("Context", Class.new do
+      def initialize(events)
+        @events = events
+      end
+
+      def keypress(event)
+        @events << [:keypress, event.value]
+      end
+    end)
+
+    reader = TTY::Reader.new(input: input, output: output, env: env)
+    events = []
+    context = Context.new(events)
+    reader.subscribe(context)
+
+    input << "aa\n"
+    input.rewind
+    answer = reader.read_line
+
+    expect(answer).to eq("aa\n")
+    expect(events).to eq([
+      [:keypress, "a"],
+      [:keypress, "a"],
+      [:keypress, "\n"]
+    ])
+
+    events.clear
+
+    reader.unsubscribe(context)
+
+    input.rewind
+    answer = reader.read_line
+    expect(events).to eq([])
+  end
+
+  it "subscribes to listen to events only in a block" do
+    stub_const("Context", Class.new do
+      def initialize(events)
+        @events = events
+      end
+
+      def keypress(event)
+        @events << [:keypress, event.value]
+      end
+    end)
+
+    reader = TTY::Reader.new(input: input, output: output, env: env)
+    events = []
+    context = Context.new(events)
+
+    input << "aa\nbb\n"
+    input.rewind
+
+    reader.subscribe(context) do
+      reader.read_line
+    end
+    answer = reader.read_line
+
+    expect(answer).to eq("bb\n")
+    expect(events).to eq([
+      [:keypress, "a"],
+      [:keypress, "a"],
+      [:keypress, "\n"]
+    ])
+  end
+end

data/tty-reader.gemspec

@@ -1,4 +1,3 @@
-# encoding: utf-8
 lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "tty/reader/version"
@@ -9,11 +8,13 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Piotr Murach"]
   spec.email         = [""]
   spec.summary       = %q{A set of methods for processing keyboard input in character, line and multiline modes.}
-  spec.description   = %q{A set of methods for processing keyboard input in character, line and multiline modes. In addition it maintains history of entered input with an ability to recall and re-edit those inputs and register to listen for keystrokes.}
+  spec.description   = %q{A set of methods for processing keyboard input in character, line and multiline modes. It maintains history of entered input with an ability to recall and re-edit those inputs. It lets you register to listen for keystroke events and trigger custom key events yourself.}
   spec.homepage      = "https://piotrmurach.github.io/tty"
   spec.license       = "MIT"
 
-  spec.files         = Dir["README.md", "LICENSE.txt", "Rakefile", "lib/**/*.rb", "bin/**", "examples/**/*.rb", "tasks/**", "tty-reader.gemspec"]
+  spec.files         = Dir['{lib,spec,examples,benchmarks}/**/*.rb']
+  spec.files        += Dir['{bin,tasks}/*', 'tty-reader.gemspec']
+  spec.files        += Dir['README.md', 'CHANGELOG.md', 'LICENSE.txt', 'Rakefile']
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]