lotrd 0.1.4 → 0.1.5

data/vendor/cache/ruby/2.6.0/gems/tty-reader-0.8.0/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Piotr Murach
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/vendor/cache/ruby/2.6.0/gems/tty-reader-0.8.0/README.md

@@ -0,0 +1,401 @@
+<div align="center">
+  <a href="https://piotrmurach.github.io/tty" target="_blank"><img width="130" src="https://cdn.rawgit.com/piotrmurach/tty/master/images/tty.png" alt="tty logo" /></a>
+</div>
+
+# TTY::Reader [![Gitter](https://badges.gitter.im/Join%20Chat.svg)][gitter]
+
+[![Gem Version](https://badge.fury.io/rb/tty-reader.svg)][gem]
+[![Build Status](https://secure.travis-ci.org/piotrmurach/tty-reader.svg?branch=master)][travis]
+[![Build status](https://ci.appveyor.com/api/projects/status/cj4owy2vlty2q1ko?svg=true)][appveyor]
+[![Maintainability](https://api.codeclimate.com/v1/badges/2f68d5e8ecc271bda820/maintainability)][codeclimate]
+[![Coverage Status](https://coveralls.io/repos/github/piotrmurach/tty-reader/badge.svg)][coverage]
+[![Inline docs](http://inch-ci.org/github/piotrmurach/tty-reader.svg?branch=master)][inchpages]
+
+[gitter]: https://gitter.im/piotrmurach/tty
+[gem]: http://badge.fury.io/rb/tty-reader
+[travis]: http://travis-ci.org/piotrmurach/tty-reader
+[appveyor]: https://ci.appveyor.com/project/piotrmurach/tty-reader
+[codeclimate]: https://codeclimate.com/github/piotrmurach/tty-reader/maintainability
+[coverage]: https://coveralls.io/github/piotrmurach/tty-reader
+[inchpages]: http://inch-ci.org/github/piotrmurach/tty-reader
+
+> A pure Ruby library that provides 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.
+
+**TTY::Reader** provides independent reader component for [TTY](https://github.com/piotrmurach/tty) toolkit.
+
+![](assets/shell.gif)
+
+## Compatibility
+
+The `tty-reader` is not compatible with the GNU Readline and doesn't aim to be. It originated from [tty-prompt](https://github.com/piotrmurach/tty-prompt) project to provide flexibility, independence from underlying operating system and Ruby like API interface for creating different prompts.
+
+`TTY::Reader` forges its own path to provide features necessary for building line editing in terminal applications!
+
+## Features
+
+* Pure Ruby
+* Reading [single keypress](#21-read_keypress)
+* [Line editing](#22-read_line)
+* Reading [multiline input](#23-read_multiline)
+* Ability to [register](#24-on) for keystroke events
+* Track input [history](#32-track_history)
+* No global state
+* Works on Linux, OS X, FreeBSD and Windows
+* Supports Ruby versions `>= 2.0.0` & JRuby
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'tty-reader'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install tty-reader
+
+* [1. Usage](#1-usage)
+* [2. API](#2-api)
+  * [2.1 read_keypress](#21-read_keypress)
+  * [2.2 read_line](#22-read_line)
+  * [2.3 read_multiline](#23-read_multiline)
+  * [2.4 on](#24-on)
+  * [2.5 subscribe](#25-subscribe)
+  * [2.6 unsubscribe](#26-unsubscribe)
+  * [2.7 trigger](#27-trigger)
+  * [2.8 supported events](#28-supported-events)
+* [3. Configuration](#3-configuration)
+  * [3.1 :interrupt](#31-interrupt)
+  * [3.2 :track_history](#32-track_history)
+  * [3.3 :history_cycle](#33-history_cycle)
+  * [3.4 :history_duplicates](#34-history_duplicates)
+  * [3.5 :history_exclude](#35-history_exclude)
+
+## Usage
+
+In just a few lines you can recreate IRB prompt.
+
+Initialize the reader:
+
+```ruby
+reader = TTY::Reader.new
+```
+
+Then register to listen for key events, in this case listen for `Ctrl-X` or `Esc` keys to exit:
+
+```ruby
+reader.on(:keyctrl_x, :keyescape) do
+  puts "Exiting..."
+  exit
+end
+```
+
+Finally, keep asking user for line input with a `=>` as a prompt:
+
+```ruby
+loop do
+  reader.read_line('=> ')
+end
+```
+
+## API
+
+### 2.1 read_keypress
+
+To read a single key stroke from the user use `read_char` or `read_keypress`:
+
+```ruby
+reader.read_char
+reader.read_keypress
+reader.read_keypress(nonblock: true)
+```
+
+### 2.2 read_line
+
+By default `read_line` works in `raw mode` which means it behaves like a line editor that allows you to edit each character, respond to `control characters` such as `Control-A` to `Control-B` or navigate through history.
+
+For example, to read a single line terminated by a new line character use `read_line` like so:
+
+```ruby
+reader.read_line
+```
+
+If you wish for the keystrokes to be interpreted by the terminal instead, use so called `cooked` mode by providing the `:raw` option set to `false`:
+
+```ruby
+reader.read_line(raw: false)
+```
+
+Any non-interpreted characters received are written back to terminal, however you can stop this by using `:echo` option set to `false`:
+
+```ruby
+reader.read_line(echo: false)
+```
+
+You can also provide a line prefix displayed before input by passing it as a first argument:
+
+```ruby
+reader.read_line(">> ")
+# >>
+```
+
+To pre-populate the line content for editing use `:value` option:
+
+```ruby
+reader.read_line("> ", value: "edit me")
+# > edit me
+```
+
+### 2.3 read_multiline
+
+By default `read_multiline` works in `raw mode` which means it behaves like a multiline editor that allows you to edit each character, respond to `control characters` such as `Control-A` to `Control-B` or navigate through history.
+
+For example, to read more than one line terminated by `Ctrl+d` or `Ctrl+z` use `read_multiline`:
+
+```ruby
+reader.read_multiline
+# => [ "line1", "line2", ... ]
+```
+
+If you wish for the keystrokes to be interpreted by the terminal instead, use so called `cooked` mode by providing the `:raw` option set to `false`:
+
+```ruby
+reader.read_line(raw: false)
+```
+
+You can also provide a line prefix displayed before input by passing a string as a first argument:
+
+```ruby
+reader.read_multiline(">> ")
+```
+
+### 2.4 on
+
+You can register to listen on a key pressed events. This can be done by calling `on` with a event name(s):
+
+```ruby
+reader.on(:keypress) { |event| .... }
+```
+
+or listen for multiple events:
+
+```ruby
+reader.on(:keyctrl_x, :keyescape) { |event| ... }
+```
+
+The `KeyEvent` object is yielded to a block whenever a particular key event fires. The event responds to:
+
+* `key`   - key pressed
+* `value` - value of the key pressed
+* `line`  - the content of the currently edited line, empty otherwise
+
+The `value` returns the actual key pressed and the `line` the content for the currently edited line or is empty.
+
+The `key` is an object that responds to following messages:
+
+* `name`  - the name of the event such as :up, :down, letter or digit
+* `meta`  - true if event is non-standard key associated
+* `shift` - true if shift has been pressed with the key
+* `ctrl`  - true if ctrl has been pressed with the key
+
+For example, to add listen to vim like navigation keys, one would do the following:
+
+```ruby
+reader.on(:keypress) do |event|
+  if event.value == 'j'
+    ...
+  end
+
+  if event.value == 'k'
+    ...
+  end
+end
+```
+
+You can subscribe to more than one event:
+
+```ruby
+prompt.on(:keypress) { |key| ... }
+      .on(:keydown)  { |key| ... }
+```
+
+### 2.5 subscribe
+
+You can subscribe any object to listen for the emitted [key events](#27-supported-events) using the `subscribe` message. The listener would need to implement a method for every event it wishes to receive.
+
+For example, if a `MyListener` class wishes to only listen for `keypress` event:
+
+```ruby
+class MyListener
+  def keypress(event)
+    ...
+  end
+end
+```
+
+Then subscribing is done:
+
+```ruby
+reader.subscribe(MyListener.new)
+```
+
+Alternatively, `subscribe` allows you to listen to events only for the duration of block execution like so:
+
+```ruby
+reader.subscribe(MyListener) do
+  ...
+end
+```
+
+### 2.6 unsubscribe
+
+You can unsubscribe any object from listening to the key events using the `unsubscribe` message:
+
+```ruby
+reader.unsubscribe(my_listener)
+```
+
+### 2.7 trigger
+
+The signature for triggering key events is `trigger(event, args...)`. The first argument is a [key event name](#27-supported-events) followed by any number of actual values related to the event being triggered.
+
+For example, to trigger `:keydown` event do:
+
+```ruby
+reader.trigger(:keydown)
+```
+
+To add vim bindings for line editing you could discern between alphanumeric inputs like so:
+
+```ruby
+reader.on(:keypress) do |event|
+  if event.value == 'j'
+    reader.trigger(:keydown)
+  end
+  if evevnt.value == 'k'
+    reader.trigger(:keyup)
+  end
+end
+```
+
+### 2.8 supported events
+
+The available key events for character input are:
+
+* `:keypress`
+* `:keyenter`
+* `:keyreturn`
+* `:keytab`
+* `:keybackspace`
+* `:keyspace`
+* `:keyescape`
+* `:keydelete`
+* `:keyalpha`
+* `:keynum`
+
+The navigation related key events are:
+
+* `:keydown`
+* `:keyup`
+* `:keyleft`
+* `:keyright`
+* `:keyhome`
+* `:keyend`
+* `:keyclear`
+
+The specific `ctrl` key events:
+
+* `:keyctrl_a`
+* `:keyctrl_b`
+* ...
+* `:keyctrl_z`
+
+The key events for functional keys `f*` are:
+
+* `:keyf1`
+* `:keyf2`
+* ...
+* `:keyf24`
+
+## 3. Configuration
+
+### 3.1. `:interrupt`
+
+By default `InputInterrupt` error will be raised when the user hits the interrupt key(Control-C). However, you can customise this behaviour by passing the `:interrupt` option. The available options are:
+
+* `:signal` - sends interrupt signal
+* `:exit` - exists with status code
+* `:noop` - skips handler
+* custom proc
+
+For example, to send interrupt signal do:
+
+```ruby
+reader = TTY::Reader.new(interrupt: :signal)
+```
+
+### 3.2. `:track_history`
+
+The `read_line` and `read_multiline` provide history buffer that tracks all the lines entered during `TTY::Reader.new` interactions. The history buffer provides previous or next lines when user presses up/down arrows respectively. However, if you wish to disable this behaviour use `:track_history` option like so:
+
+```ruby
+reader = TTY::Reader.new(track_history: false)
+```
+
+### 3.3. `:history_cycle`
+
+This option determines whether the history buffer allows for infinite navigation. By default it is set to `false`. You can change this:
+
+```ruby
+reader = TTY::Reader.new(history_cycle: true)
+```
+
+### 3.4. `:history_duplicates`
+
+This option controls whether duplicate lines are stored in history. By default set to `true`. You can change this:
+
+```ruby
+reader = TTY::Reader.new(history_duplicates: false)
+```
+
+### 3.5. `:history_exclude`
+
+This option allows you to exclude lines from being stored in history. It accepts a `Proc` with a line as a first argument. By default it is set to exclude empty lines. To change this:
+
+```ruby
+reader = TTY::Reader.new(history_exclude: ->(line) { ... })
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/piotrmurach/tty-reader. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+1. Clone the project on GitHub
+2. Create a feature branch
+3. Submit a Pull Request
+
+Important notes:
+- **All new features must include test coverage.** At a bare minimum, unit tests are required. It is preferred if you include acceptance tests as well.
+- **The tests must be be idempotent.** Any test run should produce the same result when run over and over.
+- **All new features must include source code & readme documentation** Any new method you add should include yarddoc style documentation with clearly specified parameter and return types.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the TTY::Reader project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/piotrmurach/tty-reader/blob/master/CODE_OF_CONDUCT.md).
+
+## Copyright
+
+Copyright (c) 2017 Piotr Murach. See LICENSE for further details.

data/vendor/cache/ruby/2.6.0/gems/tty-reader-0.8.0/lib/tty-reader.rb

@@ -0,0 +1 @@
+require_relative 'tty/reader'

data/vendor/cache/ruby/2.6.0/gems/tty-reader-0.8.0/lib/tty/reader.rb

@@ -0,0 +1,458 @@
+# frozen_string_literal: true
+
+require "tty-cursor"
+require "tty-screen"
+require "wisper"
+
+require_relative "reader/history"
+require_relative "reader/line"
+require_relative "reader/key_event"
+require_relative "reader/console"
+require_relative "reader/win_console"
+require_relative "reader/version"
+
+module TTY
+  # A class responsible for reading character input from STDIN
+  #
+  # Used internally to provide key and line reading functionality
+  #
+  # @api public
+  class Reader
+    include Wisper::Publisher
+
+    # Raised when the user hits the interrupt key(Control-C)
+    #
+    # @api public
+    InputInterrupt = Class.new(Interrupt)
+
+    # Check if Windowz mode
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def self.windows?
+      ::File::ALT_SEPARATOR == "\\"
+    end
+
+    attr_reader :input
+
+    attr_reader :output
+
+    attr_reader :env
+
+    attr_reader :track_history
+    alias track_history? track_history
+
+    attr_reader :console
+
+    attr_reader :cursor
+
+    # Key codes
+    CARRIAGE_RETURN = 13
+    NEWLINE         = 10
+    BACKSPACE       = 8
+    DELETE          = 127
+
+    # Initialize a Reader
+    #
+    # @param [IO] input
+    #   the input stream
+    # @param [IO] output
+    #   the output stream
+    # @param [Hash] options
+    # @option options [Symbol] :interrupt
+    #   handling of Ctrl+C key out of :signal, :exit, :noop
+    # @option options [Boolean] :track_history
+    #   disable line history tracking, true by default
+    #
+    # @api public
+    def initialize(**options)
+      @input     = options.fetch(:input) { $stdin }
+      @output    = options.fetch(:output) { $stdout }
+      @interrupt = options.fetch(:interrupt) { :error }
+      @env       = options.fetch(:env) { ENV }
+
+      @track_history = options.fetch(:track_history) { true }
+      @history_cycle = options.fetch(:history_cycle) { false }
+      exclude_proc   = ->(line) { line.strip == "" }
+      @history_exclude    = options.fetch(:history_exclude) { exclude_proc }
+      @history_duplicates = options.fetch(:history_duplicates) { false }
+
+      @console   = select_console(input)
+      @history   = History.new do |h|
+        h.cycle = @history_cycle
+        h.duplicates = @history_duplicates
+        h.exclude = @history_exclude
+      end
+      @stop = false # gathering input
+      @cursor = TTY::Cursor
+
+      subscribe(self)
+    end
+
+    alias old_subcribe subscribe
+
+    # Subscribe to receive key events
+    #
+    # @example
+    #   reader.subscribe(MyListener.new)
+    #
+    # @return [self|yield]
+    #
+    # @api public
+    def subscribe(listener, options = {})
+      old_subcribe(listener, options)
+      object = self
+      if block_given?
+        object = yield
+        unsubscribe(listener)
+      end
+      object
+    end
+
+    # Unsubscribe from receiving key events
+    #
+    # @example
+    #   reader.unsubscribe(my_listener)
+    #
+    # @return [void]
+    #
+    # @api public
+    def unsubscribe(listener)
+      registry = send(:local_registrations)
+      registry.each do |object|
+        if object.listener.equal?(listener)
+          registry.delete(object)
+        end
+      end
+    end
+
+    # Select appropriate console
+    #
+    # @api private
+    def select_console(input)
+      if self.class.windows? && !env["TTY_TEST"]
+        WinConsole.new(input)
+      else
+        Console.new(input)
+      end
+    end
+
+    # Get input in unbuffered mode.
+    #
+    # @example
+    #   unbufferred do
+    #     ...
+    #   end
+    #
+    # @api public
+    def unbufferred(&block)
+      bufferring = output.sync
+      # Immediately flush output
+      output.sync = true
+      block[] if block_given?
+    ensure
+      output.sync = bufferring
+    end
+
+    # Read a keypress  including invisible multibyte codes
+    # and return a character as a string.
+    # Nothing is echoed to the console. This call will block for a
+    # single keypress, but will not wait for Enter to be pressed.
+    #
+    # @param [Hash[Symbol]] options
+    # @option options [Boolean] echo
+    #   whether to echo chars back or not, defaults to false
+    # @option options [Boolean] raw
+    #   whenther raw mode enabled, defaults to true
+    #
+    # @return [String]
+    #
+    # @api public
+    def read_keypress(options = {})
+      opts  = { echo: false, raw: true }.merge(options)
+      codes = unbufferred { get_codes(opts) }
+      char  = codes ? codes.pack("U*") : nil
+
+      trigger_key_event(char) if char
+      char
+    end
+    alias read_char read_keypress
+
+    # Get input code points
+    #
+    # @param [Hash[Symbol]] options
+    # @param [Array[Integer]] codes
+    #
+    # @return [Array[Integer]]
+    #
+    # @api private
+    def get_codes(options = {}, codes = [])
+      opts = { echo: true, raw: false }.merge(options)
+      char = console.get_char(opts)
+      handle_interrupt if console.keys[char] == :ctrl_c
+      return if char.nil?
+      codes << char.ord
+
+      condition = proc { |escape|
+        (codes - escape).empty? ||
+        (escape - codes).empty? &&
+        !(64..126).cover?(codes.last)
+      }
+
+      while console.escape_codes.any?(&condition)
+        char_codes = get_codes(options.merge(nonblock: true), codes)
+        break if char_codes.nil?
+      end
+
+      codes
+    end
+
+    # Get a single line from STDIN. Each key pressed is echoed
+    # back to the shell. The input terminates when enter or
+    # return key is pressed.
+    #
+    # @param [String] prompt
+    #   the prompt to display before input
+    #
+    # @param [String] value
+    #   the value to pre-populate line with
+    #
+    # @param [Boolean] echo
+    #   if true echo back characters, output nothing otherwise
+    #
+    # @return [String]
+    #
+    # @api public
+    def read_line(prompt = "", **options)
+      opts = { echo: true, raw: true }.merge(options)
+      value = options.fetch(:value, "")
+      line = Line.new(value, prompt: prompt)
+      screen_width = TTY::Screen.width
+
+      output.print(line)
+
+      while (codes = get_codes(opts)) && (code = codes[0])
+        char = codes.pack("U*")
+
+        if [:ctrl_d, :ctrl_z].include?(console.keys[char])
+          trigger_key_event(char, line: line.to_s)
+          break
+        end
+
+        if opts[:raw] && opts[:echo]
+          clear_display(line, screen_width)
+        end
+
+        if console.keys[char] == :backspace || BACKSPACE == code
+          if !line.start?
+            line.left
+            line.delete
+          end
+        elsif console.keys[char] == :delete || DELETE == code
+          line.delete
+        elsif console.keys[char].to_s =~ /ctrl_/
+          # skip
+        elsif console.keys[char] == :up
+          line.replace(history_previous) if history_previous?
+        elsif console.keys[char] == :down
+          line.replace(history_next? ? history_next : "")
+        elsif console.keys[char] == :left
+          line.left
+        elsif console.keys[char] == :right
+          line.right
+        elsif console.keys[char] == :home
+          line.move_to_start
+        elsif console.keys[char] == :end
+          line.move_to_end
+        else
+          if opts[:raw] && code == CARRIAGE_RETURN
+            char = "\n"
+            line.move_to_end
+          end
+          line.insert(char)
+        end
+
+        if (console.keys[char] == :backspace || BACKSPACE == code) && opts[:echo]
+          if opts[:raw]
+            output.print("\e[1X") unless line.start?
+          else
+            output.print(?\s + (line.start? ? "" : ?\b))
+          end
+        end
+
+        # trigger before line is printed to allow for line changes
+        trigger_key_event(char, line: line.to_s)
+
+        if opts[:raw] && opts[:echo]
+          output.print(line.to_s)
+          if char == "\n"
+            line.move_to_start
+          elsif !line.end? # readjust cursor position
+            output.print(cursor.backward(line.text_size - line.cursor))
+          end
+        end
+
+        if [CARRIAGE_RETURN, NEWLINE].include?(code)
+          output.puts unless opts[:echo]
+          break
+        end
+      end
+      if track_history? && opts[:echo]
+        add_to_history(line.text.rstrip)
+      end
+      line.text
+    end
+
+    # Clear display for the current line input
+    #
+    # Handles clearing input that is longer than the current
+    # terminal width which allows copy & pasting long strings.
+    #
+    # @param [Line] line
+    #   the line to display
+    # @param [Number] screen_width
+    #   the terminal screen width
+    #
+    # @api private
+    def clear_display(line, screen_width)
+      total_lines  = count_screen_lines(line.size, screen_width)
+      current_line = count_screen_lines(line.prompt_size + line.cursor, screen_width)
+      lines_down = total_lines - current_line
+
+      output.print(cursor.down(lines_down)) unless lines_down.zero?
+      output.print(cursor.clear_lines(total_lines))
+    end
+
+    # Count the number of screen lines given line takes up in terminal
+    #
+    # @param [Integer] line_or_size
+    #   the current line or its length
+    # @param [Integer] screen_width
+    #   the width of terminal screen
+    #
+    # @return [Integer]
+    #
+    # @api public
+    def count_screen_lines(line_or_size, screen_width = TTY::Screen.width)
+      line_size = if line_or_size.is_a?(Integer)
+                    line_or_size
+                  else
+                    Line.sanitize(line_or_size).size
+                  end
+      # new character + we don't want to add new line on screen_width
+      new_chars = self.class.windows? ? -1 : 1
+      1 + [0, (line_size - new_chars) / screen_width].max
+    end
+
+    # Read multiple lines and return them in an array.
+    # Skip empty lines in the returned lines array.
+    # The input gathering is terminated by Ctrl+d or Ctrl+z.
+    #
+    # @param [String] prompt
+    #   the prompt displayed before the input
+    #
+    # @yield [String] line
+    #
+    # @return [Array[String]]
+    #
+    # @api public
+    def read_multiline(*args)
+      @stop = false
+      lines = []
+      loop do
+        line = read_line(*args)
+        break if !line || line == ""
+        next  if line !~ /\S/ && !@stop
+        if block_given?
+          yield(line) unless line.to_s.empty?
+        else
+          lines << line unless line.to_s.empty?
+        end
+        break if @stop
+      end
+      lines
+    end
+    alias read_lines read_multiline
+
+    # Expose event broadcasting
+    #
+    # @api public
+    def trigger(event, *args)
+      publish(event, *args)
+    end
+
+    # Capture Ctrl+d and Ctrl+z key events
+    #
+    # @api private
+    def keyctrl_d(*)
+      @stop = true
+    end
+    alias keyctrl_z keyctrl_d
+
+    def add_to_history(line)
+      @history.push(line)
+    end
+
+    def history_next?
+      @history.next?
+    end
+
+    def history_next
+      @history.next
+      @history.get
+    end
+
+    def history_previous?
+      @history.previous?
+    end
+
+    def history_previous
+      line = @history.get
+      @history.previous
+      line
+    end
+
+    # Inspect class name and public attributes
+    # @return [String]
+    #
+    # @api public
+    def inspect
+      "#<#{self.class}: @input=#{input}, @output=#{output}>"
+    end
+
+    private
+
+    # Publish event
+    #
+    # @param [String] char
+    #   the key pressed
+    #
+    # @return [nil]
+    #
+    # @api private
+    def trigger_key_event(char, line: "")
+      event = KeyEvent.from(console.keys, char, line)
+      trigger(:"key#{event.key.name}", event) if event.trigger?
+      trigger(:keypress, event)
+    end
+
+    # Handle input interrupt based on provided value
+    #
+    # @api private
+    def handle_interrupt
+      case @interrupt
+      when :signal
+        Process.kill("SIGINT", Process.pid)
+      when :exit
+        exit(130)
+      when Proc
+        @interrupt.call
+      when :noop
+        return
+      else
+        raise InputInterrupt
+      end
+    end
+  end # Reader
+end # TTY