tty-prompt 0.10.1 → 0.11.0

data/lib/tty/prompt/question/modifier.rb

@@ -48,6 +48,7 @@ module TTY
         #
         # @api public
         def self.letter_case(mod, value)
+          return value unless value.is_a?(String)
           case mod
           when :up, :upcase, :uppercase
             value.upcase
@@ -73,6 +74,7 @@ module TTY
         #
         # @api public
         def self.whitespace(mod, value)
+          return value unless value.is_a?(String)
           case mod
           when :trim, :strip
             value.strip

data/lib/tty/prompt/question/validation.rb

@@ -5,11 +5,12 @@ module TTY
     class Question
       # A class representing question validation.
       class Validation
-        attr_reader :pattern
-
+       # Available validator names
         VALIDATORS = {
           email: /^[a-z0-9._%+-]+@([a-z0-9-]+\.)+[a-z]{2,6}$/i
-        }
+        }.freeze
+
+        attr_reader :pattern
 
         # Initialize a Validation
         #
@@ -37,7 +38,7 @@ module TTY
           when Regexp
             Regexp.new(pattern.to_s)
           else
-            fail ValidationCoercion, "Wrong type, got #{pattern.class}"
+            raise ValidationCoercion, "Wrong type, got #{pattern.class}"
           end
         end
 

data/lib/tty/prompt/reader.rb

@@ -1,8 +1,11 @@
 # encoding: utf-8
 
 require 'wisper'
-require 'tty/prompt/reader/key_event'
-require 'tty/prompt/reader/mode'
+require 'rbconfig'
+
+require_relative 'reader/key_event'
+require_relative 'reader/console'
+require_relative 'reader/win_console'
 
 module TTY
   # A class responsible for shell prompt interactions.
@@ -14,92 +17,101 @@ module TTY
     # @api private
     class Reader
       include Wisper::Publisher
+
       # Raised when the user hits the interrupt key(Control-C)
       #
       # @api public
       InputInterrupt = Class.new(StandardError)
 
-      attr_reader :mode
-
       attr_reader :input
 
       attr_reader :output
 
-      # Key input constants for decimal codes
+      attr_reader :env
+
+      # Key codes
       CARRIAGE_RETURN = 13
       NEWLINE         = 10
       BACKSPACE       = 127
       DELETE          = 8
 
-      CSI = "\e[".freeze
-
       # Initialize a Reader
       #
       # @api public
-      def initialize(input, output, options = {})
+      def initialize(input = $stdin, output = $stdout, options = {})
         @input     = input
         @output    = output
-        @mode      = Mode.new
         @interrupt = options.fetch(:interrupt) { :error }
+        @env       = options.fetch(:env) { ENV }
+        @console   = windows? ? WinConsole.new(input) : Console.new(input)
       end
 
       # Get input in unbuffered mode.
       #
       # @example
-      #   buffer do
+      #   unbufferred do
       #     ...
       #   end
       #
-      # @return [String]
-      #
       # @api public
-      def buffer(&block)
+      def unbufferred(&block)
         bufferring = output.sync
         # Immediately flush output
         output.sync = true
-        value = block.call if block_given?
+        block[] if block_given?
+      ensure
         output.sync = bufferring
-        value
       end
 
-      # Read a single keypress that may include
-      # 2 or 3 escape characters.
+      # 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 [Boolean] echo
+      # @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(echo = false)
-        buffer do
-          mode.echo(echo) do
-            mode.raw(true) do
-              key = read_char
-              emit_key_event(key) if key
-              handle_interrupt if key == Codes::CTRL_C
-              key
-            end
-          end
-        end
+      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
+        handle_interrupt if char == @console.keys[:ctrl_c]
+        char
       end
+      alias read_char read_keypress
 
-      # Reads single character including invisible multibyte codes
+      # Get input code points
       #
-      # @params [Integer] bytes
-      #   the number of bytes to read
+      # @param [Hash[Symbol]] options
+      # @param [Array[Integer]] codes
       #
-      # @return [String]
+      # @return [Array[Integer]]
       #
-      # @api public
-      def read_char(bytes = 1)
-        chars = input.getc
-        return if chars.nil?
-        while CSI.start_with?(chars) || chars.start_with?(CSI) &&
-              !(64..126).include?(chars.each_codepoint.to_a.last)
-          chars << read_char(bytes + 1)
+      # @api private
+      def get_codes(options = {}, codes = [])
+        opts = { echo: true, raw: false }.merge(options)
+        char = @console.get_char(opts)
+        return if char.nil?
+        codes << char.ord
+
+        condition = proc { |escape|
+          (codes - escape).empty? ||
+          (escape - codes).empty? &&
+          !(64..126).include?(codes.last)
+        }
+
+        while @console.escape_codes.any?(&condition)
+          get_codes(options, codes)
         end
-        chars
+        codes
       end
 
       # Get a single line from STDIN. Each key pressed is echoed
@@ -112,19 +124,28 @@ module TTY
       # @return [String]
       #
       # @api public
-      def read_line(echo = true)
+      def read_line(options = {})
+        opts = { echo: true, raw: false }.merge(options)
         line = ''
-        buffer do
-          mode.echo(echo) do
-            while (char = read_char) && (char_byte = char.unpack('c*')[0]) &&
-                !(char_byte == CARRIAGE_RETURN || char_byte == NEWLINE)
-              emit_key_event(char)
-              if char_byte == BACKSPACE || char_byte == DELETE
-                line = line.slice(-1, 1) unless line.empty?
-              else
-                line << char
-              end
-            end
+        backspaces = 0
+        delete_char = proc { |c| c == BACKSPACE || c == DELETE }
+
+        while (codes = get_codes(opts)) && (code = codes[0])
+          char = codes.pack('U*')
+          trigger_key_event(char)
+
+          if delete_char[code]
+            line.slice!(-1, 1)
+            backspaces -= 1
+          else
+            line << char
+            backspaces = line.size
+          end
+
+          break if (code == CARRIAGE_RETURN || code == NEWLINE)
+
+          if delete_char[code] && opts[:echo]
+            output.print(' ' + (backspaces >= 0 ? "\b" : ''))
           end
         end
         line
@@ -152,18 +173,33 @@ module TTY
         response
       end
 
+      # Expose event broadcasting
+      #
+      # @api public
+      def trigger(event, *args)
+        publish(event, *args)
+      end
+
       # Publish event
       #
-      # @param [String] key
+      # @param [String] char
       #   the key pressed
       #
       # @return [nil]
       #
       # @api public
-      def emit_key_event(key)
-        event = KeyEvent.from(key)
-        publish(:"key#{event.key.name}", event) if event.emit?
-        publish(:keypress, event)
+      def trigger_key_event(char)
+        event = KeyEvent.from(@console.keys, char)
+        trigger(:"key#{event.key.name}", event) if event.trigger?
+        trigger(:keypress, event)
+      end
+
+      # Inspect class name and public attributes
+      # @return [String]
+      #
+      # @api public
+      def inspect
+        "#<#{self.class}: @input=#{input}, @output=#{output}>"
       end
 
       private
@@ -185,6 +221,16 @@ module TTY
           raise InputInterrupt
         end
       end
+
+      # Check if Windowz mode
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def windows?
+        return false if env["TTY_TEST"] == true
+        ::File::ALT_SEPARATOR == "\\"
+      end
     end # Reader
   end # Prompt
 end # TTY

data/lib/tty/prompt/reader/codes.rb

@@ -4,77 +4,117 @@ module TTY
   class Prompt
     class Reader
       module Codes
-        BACKSPACE = "\x7f"
-        DELETE   = "\004"
-        ESCAPE   = "\e"
-        LINEFEED = "\n"
-        RETURN   = "\r"
-        SPACE    = " "
-        TAB      = "\t"
+        def ctrl_keys
+          {
+            ctrl_a: ?\C-a,
+            ctrl_b: ?\C-b,
+            ctrl_c: ?\C-c,
+            ctrl_d: ?\C-d,
+            ctrl_e: ?\C-e,
+            ctrl_f: ?\C-f,
+            ctrl_g: ?\C-g,
+            ctrl_h: ?\C-h,
+            ctrl_i: ?\C-i,
+            ctrl_j: ?\C-j,
+            ctrl_k: ?\C-k,
+            ctrl_l: ?\C-l,
+            ctrl_m: ?\C-m,
+            ctrl_n: ?\C-n,
+            ctrl_o: ?\C-o,
+            ctrl_p: ?\C-p,
+            ctrl_q: ?\C-q,
+            ctrl_r: ?\C-r,
+            ctrl_s: ?\C-s,
+            ctrl_t: ?\C-t,
+            ctrl_u: ?\C-u,
+            ctrl_v: ?\C-v,
+            ctrl_w: ?\C-w,
+            ctrl_x: ?\C-x,
+            ctrl_y: ?\C-y,
+            ctrl_z: ?\C-z
+          }
+        end
+        module_function :ctrl_keys
 
-        KEY_UP     = "[A"
-        KEY_DOWN   = "[B"
-        KEY_RIGHT  = "[C"
-        KEY_LEFT   = "[D"
-        KEY_CLEAR  = "[E"
-        KEY_END    = "[F"
-        KEY_HOME   = "[H"
-        KEY_DELETE = "[3"
+        def keys
+          {
+            tab:       "\t",
+            enter:     "\n",
+            return:    "\r",
+            escape:    "\e",
+            space:     " ",
+            backspace: ?\C-?,
+            insert:    "\e[2~",
+            delete:    "\e[3~",
+            page_up:   "\e[5~",
+            page_down: "\e[6~",
 
-        KEY_UP_XTERM     = "OA"
-        KEY_DOWN_XTERM   = "OB"
-        KEY_RIGHT_XTERM  = "OC"
-        KEY_LEFT_XTERM   = "OD"
-        KEY_CLEAR_XTERM  = "OE"
-        KEY_END_XTERM    = "OF"
-        KEY_HOME_XTERM   = "OH"
-        KEY_DELETE_XTERM = "O3"
+            up:     "\e[A",
+            down:   "\e[B",
+            right:  "\e[C",
+            left:   "\e[D",
+            clear:  "\e[E",
+            end:    "\e[F",
+            home:   "\e[H",
 
-        KEY_UP_SHIFT    = "[a"
-        KEY_DOWN_SHIFT  = "[b"
-        KEY_RIGHT_SHIFT = "[c"
-        KEY_LEFT_SHIFT  = "[d"
-        KEY_CLEAR_SHIFT = "[e"
+            f1_xterm: "\eOP",
+            f2_xterm: "\eOQ",
+            f3_xterm: "\eOR",
+            f4_xterm: "\eOS",
 
-        KEY_UP_CTRL    = "0a"
-        KEY_DOWN_CTRL  = "0b"
-        KEY_RIGHT_CTRL = "0c"
-        KEY_LEFT_CTRL  = "0d"
-        KEY_CLEAR_CTRL = "0e"
+            f1:  "\e[11~",
+            f2:  "\e[12~",
+            f3:  "\e[13~",
+            f4:  "\e[14~",
+            f5:  "\e[15~",
+            f6:  "\e[17~",
+            f7:  "\e[18~",
+            f8:  "\e[19~",
+            f9:  "\e[20~",
+            f10: "\e[21~",
+            f11: "\e[23~",
+            f12: "\e[24~"
+          }.merge(ctrl_keys)
+        end
+        module_function :keys
 
-        CTRL_J = "\x0A"
-        CTRL_N = "\x0E"
-        CTRL_K = "\x0B"
-        CTRL_P = "\x10"
-        SIGINT = "\x03"
-        CTRL_C = "\x03"
-        CTRL_H = "\b"
-        CTRL_L = "\f"
+        def win_keys
+          {
+            tab:       "\t",
+            enter:     "\r",
+            return:    "\r",
+            escape:    "\e",
+            space:     " ",
+            backspace: "\b",
+            insert:    [224, 82].pack('U*'),
+            delete:    [224, 83].pack('U*'),
+            page_up:   [224, 73].pack('U*'),
+            page_down: [224, 81].pack('U*'),
 
-        F1_XTERM = "OP"
-        F2_XTERM = "OQ"
-        F3_XTERM = "OR"
-        F4_XTERM = "OS"
+            up:     [224, 72].pack('U*'),
+            down:   [224, 80].pack('U*'),
+            right:  [224, 77].pack('U*'),
+            left:   [224, 75].pack('U*'),
+            clear:  [224, 83].pack('U*'),
+            end:    [224, 79].pack('U*'),
+            home:   [224, 71].pack('U*'),
 
-        F1_GNOME = "[11~"
-        F2_GNOME = "[12~"
-        F3_GNOME = "[13~"
-        F4_GNOME = "[14~"
+            f1:  "\x00;",
+            f2:  "\x00<",
+            f3:  "\x00",
+            f4:  "\x00=",
+            f5:  "\x00?",
+            f6:  "\x00@",
+            f7:  "\x00A",
+            f8:  "\x00B",
+            f9:  "\x00C",
+            f10: "\x00D",
+            f11: "\x00\x85",
+            f12: "\x00\x86"
+          }.merge(ctrl_keys)
+        end
+        module_function :win_keys
 
-        F1_WIN = "[[A"
-        F2_WIN = "[[B"
-        F3_WIN = "[[C"
-        F4_WIN = "[[D"
-        F5_WIN = "[[E"
-
-        F5 =  "[15~"
-        F6 =  "[17~"
-        F7 =  "[18~"
-        F8 =  "[19~"
-        F9 =  "[20~"
-        F10 = "[21~"
-        F11 = "[23~"
-        F12 = "[24~"
       end # Codes
     end # Reader
   end # Prompt