tty-reader 0.1.0 → 0.2.0

data/examples/keypress.rb

@@ -0,0 +1,16 @@
+require_relative '../lib/tty-reader'
+
+reader = TTY::Reader.new
+
+puts "Press a key (or Ctrl-X to exit)"
+
+loop do
+  print "=> "
+  char = reader.read_keypress
+  if ?\C-x == char
+    puts "Exiting..."
+    exit
+  else
+    puts "#{char.inspect} [#{char.ord}] (hex: #{char.ord.to_s(16)})"
+  end
+end

data/examples/line.rb

@@ -0,0 +1,7 @@
+require_relative '../lib/tty-reader'
+
+reader = TTY::Reader.new
+
+answer = reader.read_line(">> ")
+
+puts "answer: #{answer}"

data/examples/multiline.rb

@@ -0,0 +1,7 @@
+require_relative '../lib/tty-reader'
+
+reader = TTY::Reader.new
+
+answer = reader.read_multiline(">> ")
+
+puts "\nanswer: #{answer}"

data/examples/noecho.rb

@@ -0,0 +1,6 @@
+require_relative '../lib/tty-reader'
+
+reader = TTY::Reader.new
+
+answer = reader.read_line('=> ', echo: false)
+puts "Answer: #{answer}"

data/examples/shell.rb

@@ -0,0 +1,12 @@
+require_relative '../lib/tty-reader'
+
+puts "*** TTY::Reader Shell ***"
+puts "Press Ctrl-X to exit"
+
+reader = TTY::Reader.new
+
+reader.on(:keyctrl_x) { puts "Exiting..."; exit }
+
+loop do
+  reader.read_line('=> ')
+end

data/lib/tty/reader.rb

@@ -1,6 +1,8 @@
 # encoding: utf-8
 # frozen_string_literal: true
 
+require 'tty-cursor'
+require 'tty-screen'
 require 'wisper'
 
 require_relative 'reader/history'
@@ -15,7 +17,7 @@ module TTY
   #
   # Used internally to provide key and line reading functionality
   #
-  # @api private
+  # @api public
   class Reader
     include Wisper::Publisher
 
@@ -24,6 +26,15 @@ module TTY
     # @api public
     InputInterrupt = Class.new(StandardError)
 
+    # Check if Windowz mode
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def self.windows?
+      ::File::ALT_SEPARATOR == '\\'
+    end
+
     attr_reader :input
 
     attr_reader :output
@@ -35,11 +46,13 @@ module TTY
 
     attr_reader :console
 
+    attr_reader :cursor
+
     # Key codes
     CARRIAGE_RETURN = 13
     NEWLINE         = 10
-    BACKSPACE       = 127
-    DELETE          = 8
+    BACKSPACE       = 8
+    DELETE          = 127
 
     # Initialize a Reader
     #
@@ -54,18 +67,26 @@ module TTY
     #   disable line history tracking, true by default
     #
     # @api public
-    def initialize(input = $stdin, output = $stdout, options = {})
-      @input     = input
-      @output    = output
+    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.duplicates = false
-        h.exclude = proc { |line| line.strip == '' }
+        h.cycle = @history_cycle
+        h.duplicates = @history_duplicates
+        h.exclude = @history_exclude
       end
       @stop = false # gathering input
+      @cursor = TTY::Cursor
 
       subscribe(self)
     end
@@ -74,7 +95,7 @@ module TTY
     #
     # @api private
     def select_console(input)
-      if windows? && !env['TTY_TEST']
+      if self.class.windows? && !env['TTY_TEST']
         WinConsole.new(input)
       else
         Console.new(input)
@@ -133,14 +154,14 @@ module TTY
     def get_codes(options = {}, codes = [])
       opts = { echo: true, raw: false }.merge(options)
       char = console.get_char(opts)
-      handle_interrupt if char == console.keys[:ctrl_c]
+      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).include?(codes.last)
+        !(64..126).cover?(codes.last)
       }
 
       while console.escape_codes.any?(&condition)
@@ -162,38 +183,44 @@ module TTY
     # @return [String]
     #
     # @api public
-    def read_line(*args)
-      options = args.last.respond_to?(:to_hash) ? args.pop : {}
-      prompt = args.empty? ? '' : args.pop
+    def read_line(prompt = '', **options)
       opts = { echo: true, raw: true }.merge(options)
-      line = Line.new('')
-      ctrls = console.keys.keys.grep(/ctrl/)
-      clear_line = "\e[2K\e[1G"
+      line = Line.new(prompt, '')
+      screen_width = TTY::Screen.width
 
-      while (codes = unbufferred { get_codes(opts) }) && (code = codes[0])
+      output.print(line.prompt)
+
+      while (codes = get_codes(opts)) && (code = codes[0])
         char = codes.pack('U*')
         trigger_key_event(char)
 
-        if console.keys[:backspace] == char || BACKSPACE == code
-          next if line.start?
-          line.left
-          line.delete
-        elsif console.keys[:delete] == char || DELETE == code
+        break if [:ctrl_d, :ctrl_z].include?(console.keys[char])
+
+        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[:ctrl_d],
-                console.keys[:ctrl_z]].include?(char)
-          break
-        elsif ctrls.include?(console.keys.key(char))
+        elsif console.keys[char].to_s =~ /ctrl_/
           # skip
-        elsif console.keys[:up] == char
-          next unless history_previous?
-          line.replace(history_previous)
-        elsif console.keys[:down] == char
+        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[:left] == char
+        elsif console.keys[char] == :left
           line.left
-        elsif console.keys[:right] == char
+        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"
@@ -202,28 +229,73 @@ module TTY
           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
+
         if opts[:raw] && opts[:echo]
-          output.print(clear_line)
-          output.print(prompt + line.to_s)
+          output.print(line.to_s)
           if char == "\n"
             line.move_to_start
-          elsif !line.end?
-            output.print("\e[#{line.size - line.cursor}D")
+          elsif !line.end? # readjust cursor position
+            output.print(cursor.backward(line.text_size - line.cursor))
           end
         end
 
-        break if (code == CARRIAGE_RETURN || code == NEWLINE)
-
-        if (console.keys[:backspace] == char || BACKSPACE == code) && opts[:echo]
-          if opts[:raw]
-            output.print("\e[1X") unless line.start?
-          else
-            output.print(?\s + (line.start? ? '' :  ?\b))
-          end
+        if [CARRIAGE_RETURN, NEWLINE].include?(code)
+          output.puts unless opts[:echo]
+          break
         end
       end
-      add_to_history(line.to_s.rstrip) if track_history?
-      line.to_s
+      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.
@@ -238,11 +310,11 @@ module TTY
     # @return [Array[String]]
     #
     # @api public
-    def read_multiline(prompt = '')
+    def read_multiline(*args)
       @stop = false
       lines = []
       loop do
-        line = read_line(prompt)
+        line = read_line(*args)
         break if !line || line == ''
         next  if line !~ /\S/ && !@stop
         if block_given?
@@ -335,14 +407,5 @@ module TTY
         raise InputInterrupt
       end
     end
-
-    # Check if Windowz mode
-    #
-    # @return [Boolean]
-    #
-    # @api public
-    def windows?
-      ::File::ALT_SEPARATOR == '\\'
-    end
   end # Reader
 end # TTY

data/lib/tty/reader/console.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 # frozen_string_literal: true
 
-require_relative 'codes'
+require_relative 'keys'
 require_relative 'mode'
 
 module TTY
@@ -27,7 +27,7 @@ module TTY
       def initialize(input)
         @input = input
         @mode  = Mode.new(input)
-        @keys  = Codes.keys
+        @keys  = Keys.ctrl_keys.merge(Keys.keys)
         @escape_codes = [[ESC.ord], CSI.bytes.to_a]
       end
 

data/lib/tty/reader/history.rb

@@ -35,13 +35,17 @@ module TTY
       #   the maximum size for history buffer
       #
       # param [Hash[Symbol]] options
+      # @option options [Boolean] :cycle
+      #   whether or not the history should cycle, false by default
       # @option options [Boolean] :duplicates
       #   whether or not to store duplicates, true by default
+      # @option options [Boolean] :exclude
+      #   a Proc to exclude items from storing in history
       #
       # @api public
-      def initialize(max_size = DEFAULT_SIZE, options = {})
+      def initialize(max_size = DEFAULT_SIZE, **options)
         @max_size   = max_size
-        @index      = 0
+        @index      = nil
         @history    = []
         @duplicates = options.fetch(:duplicates) { true }
         @exclude    = options.fetch(:exclude) { proc {} }

data/lib/tty/reader/key_event.rb

@@ -1,6 +1,8 @@
 # encoding: utf-8
 # frozen_string_literal: true
 
+require_relative 'keys'
+
 module TTY
   class Reader
     # Responsible for meta-data information about key pressed
@@ -27,16 +29,9 @@ module TTY
       # @api public
       def self.from(keys, char)
         key = Key.new
-        ctrls = keys.keys.grep(/ctrl/)
+        key.name = (name = keys[char]) ? name : :ignore
 
         case char
-        when keys[:return] then key.name = :return
-        when keys[:enter]  then key.name = :enter
-        when keys[:tab]    then key.name = :tab
-        when keys[:backspace] then key.name = :backspace
-        when keys[:delete] then key.name = :delete
-        when keys[:space]  then key.name = :space
-        when keys[:escape] then key.name = :escape
         when proc { |c| c =~ /^[a-z]{1}$/ }
           key.name = :alpha
         when proc { |c| c =~ /^[A-Z]{1}$/ }
@@ -44,34 +39,8 @@ module TTY
           key.shift = true
         when proc { |c| c =~ /^\d+$/ }
           key.name = :num
-        # arrows
-        when keys[:up]    then key.name = :up
-        when keys[:down]  then key.name = :down
-        when keys[:left]  then key.name = :left
-        when keys[:right] then key.name = :right
-        # editing
-        when keys[:clear] then key.name = :clear
-        when keys[:end]   then key.name = :end
-        when keys[:home]  then key.name = :home
-        when keys[:insert]    then key.name = :insert
-        when keys[:page_up]   then key.name = :page_up
-        when keys[:page_down] then key.name = :page_down
-        when proc { |cs| ctrls.any? { |name| keys[name] == cs } }
-          key.name = keys.key(char)
+        when proc { |cs| !Keys.ctrl_keys[cs].nil? }
           key.ctrl = true
-        # f1 - f12
-        when keys[:f1], keys[:f1_xterm] then key.name = :f1
-        when keys[:f2], keys[:f2_xterm] then key.name = :f2
-        when keys[:f3], keys[:f3_xterm] then key.name = :f3
-        when keys[:f4], keys[:f4_xterm] then key.name = :f4
-        when keys[:f5] then key.name = :f5
-        when keys[:f6] then key.name = :f6
-        when keys[:f7] then key.name = :f7
-        when keys[:f8] then key.name = :f8
-        when keys[:f9] then key.name = :f9
-        when keys[:f10] then key.name = :f10
-        when keys[:f11] then key.name = :f11
-        when keys[:f12] then key.name = :f12
         end
 
         new(char, key)

data/lib/tty/reader/keys.rb

@@ -0,0 +1,165 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module TTY
+  class Reader
+    # Mapping of escape codes to keys
+    module Keys
+      def ctrl_keys
+        {
+          ?\C-a => :ctrl_a,
+          ?\C-b => :ctrl_b,
+          ?\C-c => :ctrl_c,
+          ?\C-d => :ctrl_d,
+          ?\C-e => :ctrl_e,
+          ?\C-f => :ctrl_f,
+          ?\C-g => :ctrl_g,
+          ?\C-h => :ctrl_h, # identical to '\b'
+          ?\C-i => :ctrl_i, # identical to '\t'
+          ?\C-j => :ctrl_j, # identical to '\n'
+          ?\C-k => :ctrl_k,
+          ?\C-l => :ctrl_l,
+          ?\C-m => :ctrl_m, # identical to '\r'
+          ?\C-n => :ctrl_n,
+          ?\C-o => :ctrl_o,
+          ?\C-p => :ctrl_p,
+          ?\C-q => :ctrl_q,
+          ?\C-r => :ctrl_r,
+          ?\C-s => :ctrl_s,
+          ?\C-t => :ctrl_t,
+          ?\C-u => :ctrl_u,
+          ?\C-v => :ctrl_v,
+          ?\C-w => :ctrl_w,
+          ?\C-x => :ctrl_x,
+          ?\C-y => :ctrl_y,
+          ?\C-z => :ctrl_z,
+          ?\C-@ => :ctrl_space,
+          ?\C-| => :ctrl_backslash, # both Ctrl-| & Ctrl-\
+          ?\C-] => :ctrl_square_close,
+          "\e[1;5A" => :ctrl_up,
+          "\e[1;5B" => :ctrl_down,
+          "\e[1;5C" => :ctrl_right,
+          "\e[1;5D" => :ctrl_left
+        }
+      end
+      module_function :ctrl_keys
+
+      def keys
+        {
+          "\t" => :tab,
+          "\n" => :enter,
+          "\r" => :return,
+          "\e" => :escape,
+          " "  => :space,
+          "\x7F"  => :backspace,
+          "\e[1~" => :home,
+          "\e[2~" => :insert,
+          "\e[3~" => :delete,
+          "\e[3;2~" => :shift_delete,
+          "\e[3;5~" => :ctrl_delete,
+          "\e[4~" => :end,
+          "\e[5~" => :page_up,
+          "\e[6~" => :page_down,
+          "\e[7~" => :home, # xrvt
+          "\e[8~" => :end, # xrvt
+
+          "\e[A" => :up,
+          "\e[B" => :down,
+          "\e[C" => :right,
+          "\e[D" => :left,
+          "\e[E" => :clear,
+          "\e[H" => :home,
+          "\eOH" => :home,
+          "\e[F" => :end,
+          "\eOF" => :end,
+          "\e[Z" => :back_tab, # shift + tab
+
+          "\eOP" => :f1,
+          "\eOQ" => :f2,
+          "\eOR" => :f3,
+          "\eOS" => :f4,
+          "\e[[A" => :f1, # linux
+          "\e[[B" => :f2, # linux
+          "\e[[C" => :f3, # linux
+          "\e[[D" => :f4, # linux
+          "\e[[E" => :f5, # linux
+          "\e[11~" => :f1, # rxvt-unicode
+          "\e[12~" => :f2, # rxvt-unicode
+          "\e[13~" => :f3, # rxvt-unicode
+          "\e[14~" => :f4, # rxvt-unicode
+          "\e[15~" => :f5,
+          "\e[17~" => :f6,
+          "\e[18~" => :f7,
+          "\e[19~" => :f8,
+          "\e[20~" => :f9,
+          "\e[21~" => :f10,
+          "\e[23~" => :f11,
+          "\e[24~" => :f12,
+          "\e[25~" => :f13,
+          "\e[26~" => :f14,
+          "\e[28~" => :f15,
+          "\e[29~" => :f16,
+          "\e[31~" => :f17,
+          "\e[32~" => :f18,
+          "\e[33~" => :f19,
+          "\e[34~" => :f20,
+          # xterm
+          "\e[1;2P" => :f13,
+          "\e[2;2Q" => :f14,
+          "\e[1;2S"  => :f16,
+          "\e[15;2~" => :f17,
+          "\e[17;2~" => :f18,
+          "\e[18;2~" => :f19,
+          "\e[19;2~" => :f20,
+          "\e[20;2~" => :f21,
+          "\e[21;2~" => :f22,
+          "\e[23;2~" => :f23,
+          "\e[24;2~" => :f24,
+
+          "\eOA" => :up,
+          "\eOB" => :down,
+          "\eOC" => :right,
+          "\eOD" => :left
+        }
+      end
+      module_function :keys
+
+      def win_keys
+        {
+          "\t" => :tab,
+          "\n" => :enter,
+          "\r" => :return,
+          "\e" => :escape,
+          " "  => :space,
+          "\b" => :backspace,
+          [224, 71].pack('U*') => :home,
+          [224, 79].pack('U*') => :end,
+          [224, 82].pack('U*') => :insert,
+          [224, 83].pack('U*') => :delete,
+          [224, 73].pack('U*') => :page_up,
+          [224, 81].pack('U*') => :page_down,
+
+          [224, 72].pack('U*') => :up,
+          [224, 80].pack('U*') => :down,
+          [224, 77].pack('U*') => :right,
+          [224, 75].pack('U*') => :left,
+          [224, 83].pack('U*') => :clear,
+
+          "\x00;" => :f1,
+          "\x00<" => :f2,
+          "\x00"  => :f3,
+          "\x00=" => :f4,
+          "\x00?" => :f5,
+          "\x00@" => :f6,
+          "\x00A" => :f7,
+          "\x00B" => :f8,
+          "\x00C" => :f9,
+          "\x00D" => :f10,
+          "\x00\x85" => :f11,
+          "\x00\x86" => :f12
+        }
+      end
+      module_function :win_keys
+    end # Keys
+  end # Reader
+end # TTY