tty-prompt 0.2.0 → 0.3.0

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

@@ -0,0 +1,85 @@
+# encoding: utf-8
+
+module TTY
+  class Prompt
+    class Question
+      module Checks
+        # Check if modifications are applicable
+        class CheckModifier
+          def self.call(question, value)
+            if !question.modifier.nil? || question.modifier
+              [Modifier.new(question.modifier).apply_to(value)]
+            else
+              [value]
+            end
+          end
+        end
+
+        # Check if value is within range
+        class CheckRange
+          def self.float?(value)
+            !/[-+]?(\d*[.])?\d+/.match(value.to_s).nil?
+          end
+
+          def self.int?(value)
+            !/^[-+]?\d+$/.match(value.to_s).nil?
+          end
+
+          def self.cast(value)
+            if float?(value)
+              value.to_f
+            elsif int?(value)
+              value.to_i
+            else
+              value
+            end
+          end
+
+          def self.call(question, value)
+            if !question.in? ||
+              (question.in? && question.in.include?(cast(value)))
+              [value]
+            else
+              [value, ["Value #{value} is not included in the range #{question.in}"]]
+            end
+          end
+        end
+
+        # Check if input requires validation
+        class CheckValidation
+          def self.call(question, value)
+            if !question.validation? ||
+              (question.validation? &&
+                Validation.new(question.validation).call(value))
+              [value]
+            else
+              [value, ["Your answer is invalid (must match #{question.validation.inspect})"]]
+            end
+          end
+        end
+
+        # Check if default value provided
+        class CheckDefault
+          def self.call(question, value)
+            if value.nil? && question.default?
+              [question.default]
+            else
+              [value]
+            end
+          end
+        end
+
+        # Check if input is required
+        class CheckRequired
+          def self.call(question, value)
+            if question.required? && !question.default? && value.nil?
+              [value, ['No value provided for required']]
+            else
+              [value]
+            end
+          end
+        end
+      end # Checks
+    end # Question
+  end # Prompt
+end # TTY

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

@@ -6,13 +6,12 @@ module TTY
       # A class representing String modifications.
       class Modifier
         attr_reader :modifiers
-        private :modifiers
 
         # Initialize a Modifier
         #
         # @api public
-        def initialize(*modifiers)
-          @modifiers = Array(modifiers)
+        def initialize(modifiers)
+          @modifiers = modifiers
         end
 
         # Change supplied value according to the given string transformation.
@@ -26,8 +25,8 @@ module TTY
         # @api private
         def apply_to(value)
           modifiers.reduce(value) do |result, mod|
-            result = Modifier.letter_case mod, result
-            Modifier.whitespace mod, result
+            result = Modifier.letter_case(mod, result)
+            Modifier.whitespace(mod, result)
           end
         end
 

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

@@ -5,53 +5,47 @@ module TTY
     class Question
       # A class representing question validation.
       class Validation
-        # @api private
-        attr_reader :validation
-        private :validation
+        attr_reader :pattern
+
+        VALIDATORS = {
+          email: /^[a-z0-9._%+-]+@([a-z0-9-]+\.)+[a-z]{2,6}$/i
+        }
 
         # Initialize a Validation
         #
-        # @param [Object] validation
+        # @param [Object] pattern
         #
         # @return [undefined]
         #
         # @api private
-        def initialize(validation = nil)
-          @validation = validation ? coerce(validation) : validation
+        def initialize(pattern)
+          @pattern = coerce(pattern)
         end
 
         # Convert validation into known type.
         #
-        # @param [Object] validation
+        # @param [Object] pattern
         #
-        # @raise [TTY::ValidationCoercion] failed to convert validation
+        # @raise [TTY::ValidationCoercion]
+        #   raised when failed to convert validation
         #
         # @api private
-        def coerce(validation)
-          case validation
-          when Proc
-            validation
-          when Regexp, String
-            Regexp.new(validation.to_s)
+        def coerce(pattern)
+          case pattern
+          when String, Symbol, Proc
+            pattern
+          when Regexp
+            Regexp.new(pattern.to_s)
           else
-            fail ValidationCoercion, "Wrong type, got #{validation.class}"
+            fail ValidationCoercion, "Wrong type, got #{pattern.class}"
           end
         end
 
-        # Check if validation is required
-        #
-        # @return [Boolean]
-        #
-        # @api public
-        def validate?
-          !!validation
-        end
-
         # Test if the input passes the validation
         #
         # @example
-        #   Validation.new
-        #   validation.valid?(input) # => true
+        #   Validation.new(/pattern/)
+        #   validation.call(input) # => true
         #
         # @param [Object] input
         #  the input to validate
@@ -60,15 +54,15 @@ module TTY
         #
         # @api public
         def call(input)
-          if validate? && input
-            input = input.to_s
-            if validation.is_a?(Regexp) && validation =~ input
-            elsif validation.is_a?(Proc) && validation.call(input)
-            else fail InvalidArgument, "Invalid input for #{input}"
-            end
-            true
-          else
-            false
+          if pattern.is_a?(String) || pattern.is_a?(Symbol)
+            VALIDATORS.key?(pattern.to_sym)
+            !VALIDATORS[pattern.to_sym].match(input).nil?
+          elsif pattern.is_a?(Regexp)
+            !pattern.match(input).nil?
+          elsif pattern.is_a?(Proc)
+            result = pattern.call(input)
+            result.nil? ? false : result
+          else false
           end
         end
       end # Validation

data/lib/tty/prompt/reader.rb

@@ -1,28 +1,37 @@
 # encoding: utf-8
 
+require 'wisper'
+require 'tty/prompt/reader/key_event'
+require 'tty/prompt/reader/mode'
+
 module TTY
   # A class responsible for shell prompt interactions.
   class Prompt
     # A class responsible for reading character input from STDIN
     class Reader
-      # @api private
-      attr_reader :prompt
-      private :prompt
+      include Wisper::Publisher
 
       attr_reader :mode
 
+      attr_reader :input
+
+      attr_reader :output
+
       # Key input constants for decimal codes
       CARRIAGE_RETURN = 13.freeze
       NEWLINE         = 10.freeze
       BACKSPACE       = 127.freeze
       DELETE          = 8.freeze
 
+      CSI = "\e[".freeze
+
       # Initialize a Reader
       #
       # @api public
-      def initialize(prompt = Prompt.new)
-        @prompt = prompt
-        @mode  = Mode.new
+      def initialize(input, output)
+        @input  = input
+        @output = output
+        @mode   = Mode.new
       end
 
       # Get input in unbuffered mode.
@@ -36,13 +45,11 @@ module TTY
       #
       # @api public
       def buffer(&block)
-        bufferring = prompt.output.sync
+        bufferring = output.sync
         # Immediately flush output
-        prompt.output.sync = true
-
+        output.sync = true
         value = block.call if block_given?
-
-        prompt.output.sync = bufferring
+        output.sync = bufferring
         value
       end
 
@@ -52,11 +59,14 @@ module TTY
       # @return [String]
       #
       # @api public
-      def read_keypress
+      def read_keypress(echo = false)
         buffer do
-          mode.echo(false) do
+          mode.echo(echo) do
             mode.raw(true) do
-              read_char
+              key = read_char
+              publish_keypress_event(key) if key
+              exit 130 if key == Codes::CTRL_C
+              key
             end
           end
         end
@@ -68,78 +78,114 @@ module TTY
       #
       # @api public
       def read_char
-        chars = prompt.input.getc.chr
-        if chars == "\e"
-          chars = prompt.input.read_nonblock(3) rescue chars
-          chars = prompt.input.read_nonblock(2) rescue chars
-          chars = "\e" + chars
+        chars = input.sysread(1)
+        while CSI.start_with?(chars) ||
+              chars.start_with?(CSI) &&
+              !(64..126).include?(chars.each_codepoint.to_a.last)
+          next_char = read_char
+          chars << next_char
         end
         chars
-      rescue
+      rescue EOFError
+        # Finished processing
         chars
       end
 
-      # Get a value from STDIN one key at a time. Each key press is echoed back
-      # to the shell masked with character(if given). The input finishes when
-      # enter key is pressed.
+      # 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] mask
-      #   the character to use as mask
+      # @param [Boolean] echo
+      #   if true echo back characters, output nothing otherwise
       #
       # @return [String]
       #
       # @api public
-      def getc(mask = (not_set = true))
-        value = ''
+      def read_line(echo = true)
+        line = ''
         buffer do
-          begin
-            while (char = prompt.input.getbyte) &&
+          mode.echo(echo) do
+            while (char = input.getbyte) &&
                 !(char == CARRIAGE_RETURN || char == NEWLINE)
-              value = handle_char value, char, not_set, mask
+              publish_keypress_event(convert_byte(char))
+              line = handle_char(line, char)
             end
-          ensure
-            mode.echo_on
           end
         end
-        value
+        line
+      end
+
+      # Read multiple lines and terminate when empty line is submitted.
+      #
+      # @yield [String] line
+      #
+      # @return [Array[String]]
+      #
+      # @api public
+      def read_multiline
+        response = []
+        loop do
+          line = read_line
+          break if !line || line == ''
+          next  if line !~ /\S/
+          if block_given?
+            yield(line)
+          else
+            response << line
+          end
+        end
+        response
       end
 
-      # Get a value from STDIN using line input.
+      # Publish event
+      #
+      # @param [String] key
+      #   the key pressed
+      #
+      # @return [nil]
       #
       # @api public
-      def gets
-        prompt.input.gets
+      def publish_keypress_event(char)
+        event = KeyEvent.from(char)
+        event_name = parse_key_event(event)
+        publish(event_name, event) unless event_name.nil?
+        publish(:keypress, event)
       end
 
-      # Reads at maximum +maxlen+ characters.
+      # Interpret the key and provide event name
       #
-      # @param [Integer] maxlen
+      # @return [Symbol]
       #
       # @api public
-      def readpartial(maxlen)
-        prompt.input.readpartial(maxlen)
+      def parse_key_event(event)
+        return if event.key.nil?
+        permitted_events = %w(up down left right space return enter num)
+        return unless permitted_events.include?("#{event.key.name}")
+        :"key#{event.key.name}"
       end
 
       private
 
-      # Handle single character by appending to or removing from output
+      trap('SIGINT') { exit 130 }
+
+      # Convert byte to unicode character
+      #
+      # @return [String]
       #
       # @api private
-      def handle_char(value, char, not_set, mask)
-        if char == BACKSPACE || char == DELETE
-          value.slice!(-1, 1) unless value.empty?
-        else
-          print_char char, not_set, mask
-          value << char
-        end
-        value
+      def convert_byte(byte)
+        Array(byte).pack('U*')
       end
 
-      # Print out character back to shell STDOUT
+      # Handle single character by appending to or removing from output
       #
       # @api private
-      def print_char(char, not_set, mask)
-        prompt.output.putc((not_set || !mask) ? char : mask)
+      def handle_char(line, char)
+        if char == BACKSPACE || char == DELETE
+          line.empty? ? line : line.slice(-1, 1)
+        else
+          line << char
+        end
       end
     end # Reader
   end # Prompt

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

@@ -0,0 +1,63 @@
+# encoding: utf-8
+
+module TTY
+  class Prompt
+    class Reader
+      module Codes
+        BACKSPACE = "\177"
+        DELETE   = "\004"
+        ESCAPE   = "\e"
+        LINEFEED = "\n"
+        RETURN   = "\r"
+        SPACE    = " "
+        TAB      = "\t"
+
+        KEY_UP     = "\e[A"
+        KEY_DOWN   = "\e[B"
+        KEY_RIGHT  = "\e[C"
+        KEY_LEFT   = "\e[D"
+        KEY_CLEAR  = "\e[E"
+        KEY_END    = "\e[F"
+        KEY_HOME   = "\e[H"
+        KEY_DELETE = "\e[3"
+
+        KEY_UP_ALT     = "\eOA"
+        KEY_DOWN_ALT   = "\eOB"
+        KEY_RIGHT_ALT  = "\eOC"
+        KEY_LEFT_ALT   = "\eOD"
+        KEY_CLEAR_ALT  = "\eOE"
+        KEY_END_ALT    = "\eOF"
+        KEY_HOME_ALT   = "\eOH"
+        KEY_DELETE_ALT = "\eO3"
+
+        CTRL_J = "\x0A"
+        CTRL_N = "\x0E"
+        CTRL_K = "\x0B"
+        CTRL_P = "\x10"
+        SIGINT = "\x03"
+        CTRL_C = "\x03"
+        CTRL_H = "\b"
+        CTRL_L = "\f"
+
+        F1 = "\eOP"
+        F2 = "\eOQ"
+        F3 = "\eOR"
+        F4 = "\eOS"
+
+        F1_ALT = "\e[11~"
+        F2_ALT = "\e[12~"
+        F3_ALT = "\e[13~"
+        F4_ALT = "\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~"
+      end # Codes
+    end # Reader
+  end # Prompt
+end # TTY