tty-prompt 0.11.0 → 0.12.0

data/lib/tty/prompt/multi_list.rb

@@ -76,12 +76,14 @@ module TTY
       # @return [Array[nil,Object]]
       #
       # @api private
-      def render_answer
+      def answer
         @selected.map(&:value)
       end
 
       # Render menu with choices to select from
       #
+      # @return [String]
+      #
       # @api private
       def render_menu
         output = ''

data/lib/tty/prompt/multiline.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+
+require_relative 'question'
+require_relative 'symbols'
+
+module TTY
+  class Prompt
+    # A prompt responsible for multi line user input
+    #
+    # @api private
+    class Multiline < Question
+      HELP = '(Press CTRL-D or CTRL-Z to finish)'.freeze
+
+      def initialize(prompt, options = {})
+        super
+        @help         = options[:help] || self.class::HELP
+        @first_render = true
+        @lines_count  = 0
+
+        @prompt.subscribe(self)
+      end
+
+      # Provide help information
+      #
+      # @return [String]
+      #
+      # @api public
+      def help(value = (not_set = true))
+        return @help if not_set
+        @help = value
+      end
+
+      def read_input
+        @prompt.read_multiline
+      end
+
+      def keyreturn(*)
+        @lines_count += 1
+      end
+      alias keyenter keyreturn
+
+      def render_question
+        header = "#{@prefix}#{message} "
+        if !echo?
+          header
+        elsif @done
+          header += @prompt.decorate("#{@input}", @active_color)
+        elsif @first_render
+          header += @prompt.decorate(help, @help_color)
+          @first_render = false
+        end
+        header += "\n"
+        header
+      end
+
+      def process_input(question)
+        @lines = read_input
+        @input = "#{@lines.first.strip} ..." unless @lines.first.to_s.empty?
+        if Utils.blank?(@input)
+          @input = default? ? default : nil
+        end
+        @evaluator.(@lines)
+      end
+
+      def refresh(lines)
+        size = @lines_count + lines + 1
+        @prompt.clear_lines(size)
+      end
+    end # Multiline
+  end # Prompt
+end # TTY

data/lib/tty/prompt/question.rb

@@ -16,7 +16,12 @@ module TTY
     class Question
       include Checks
 
-      UndefinedSetting = Module.new
+      UndefinedSetting = Class.new do
+        def to_s
+          "undefined"
+        end
+        alias inspect to_s
+      end
 
       # Store question message
       # @api public
@@ -38,7 +43,6 @@ module TTY
         @in         = options.fetch(:in) { UndefinedSetting }
         @modifier   = options.fetch(:modifier) { [] }
         @validation = options.fetch(:validation) { UndefinedSetting }
-        @read       = options.fetch(:read) { UndefinedSetting }
         @convert    = options.fetch(:convert) { UndefinedSetting }
         @active_color = options.fetch(:active_color) { @prompt.active_color }
         @help_color = options.fetch(:help_color) { @prompt.help_color }
@@ -103,22 +107,25 @@ module TTY
       def render
         @errors = []
         until @done
-          lines = render_question
-          result = process_input
+          question = render_question
+          @prompt.print(question)
+          result = process_input(question)
           if result.failure?
             @errors = result.errors
-            render_error(result.errors)
+            @prompt.print(render_error(result.errors))
           else
             @done = true
           end
-          refresh(lines)
+          @prompt.print(refresh(question.lines.count))
         end
-        render_question
+        @prompt.print(render_question)
         convert_result(result.value)
       end
 
       # Render question
       #
+      # @return [String]
+      #
       # @api private
       def render_question
         header = "#{@prefix}#{message} "
@@ -129,17 +136,15 @@ module TTY
         elsif default? && !Utils.blank?(@default)
           header += @prompt.decorate("(#{default})", @help_color) + ' '
         end
-        @prompt.print(header)
-        @prompt.puts if @done
-
-        header.lines.count + (@done ? 1 : 0)
+        header << "\n" if @done
+        header
       end
 
       # Decide how to handle input from user
       #
       # @api private
-      def process_input
-        @input = read_input
+      def process_input(question)
+        @input = read_input(question)
         if Utils.blank?(@input)
           @input = default? ? default : nil
         end
@@ -149,43 +154,43 @@ module TTY
       # Process input
       #
       # @api private
-      def read_input
-        case @read
-        when :keypress
-          @prompt.read_keypress
-        when :multiline
-          @prompt.read_multiline.each(&:chomp!)
-        else
-          @prompt.read_line(echo: echo).chomp
-        end
+      def read_input(question)
+        @prompt.read_line(question, echo: echo).chomp
       end
 
       # Handle error condition
       #
+      # @return [String]
+      #
       # @api private
       def render_error(errors)
-        errors.each do |err|
+        errors.reduce('') do |acc, err|
           newline = (@echo ? '' : "\n")
-          @prompt.print(newline + @prompt.decorate('>>', :red) + ' ' + err)
+          acc << newline + @prompt.decorate('>>', :red) + ' ' + err
+          acc
         end
       end
 
       # Determine area of the screen to clear
       #
-      # @param [Array[String]] errors
+      # @param [Integer] lines
+      #   number of lines to clear
+      #
+      # @return [String]
       #
       # @api private
       def refresh(lines)
+        output = ''
         if @done
           if @errors.count.zero? && @echo
-            @prompt.print(@prompt.cursor.up(lines))
+            output << @prompt.cursor.up(lines)
           else
             lines += @errors.count
           end
         else
-          @prompt.print(@prompt.cursor.up(lines))
+          output << @prompt.cursor.up(lines)
         end
-        @prompt.print(@prompt.clear_lines(lines))
+        output + @prompt.clear_lines(lines)
       end
 
       # Convert value to expected type
@@ -201,13 +206,6 @@ module TTY
         end
       end
 
-      # Set reader type
-      #
-      # @api public
-      def read(value)
-        @read = value
-      end
-
       # Specify answer conversion
       #
       # @api public

data/lib/tty/prompt/reader.rb

@@ -3,6 +3,8 @@
 require 'wisper'
 require 'rbconfig'
 
+require_relative 'reader/history'
+require_relative 'reader/line'
 require_relative 'reader/key_event'
 require_relative 'reader/console'
 require_relative 'reader/win_console'
@@ -29,6 +31,11 @@ module TTY
 
       attr_reader :env
 
+      attr_reader :track_history
+      alias track_history? track_history
+
+      attr_reader :console
+
       # Key codes
       CARRIAGE_RETURN = 13
       NEWLINE         = 10
@@ -37,13 +44,42 @@ module TTY
 
       # 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(input = $stdin, output = $stdout, options = {})
         @input     = input
         @output    = output
         @interrupt = options.fetch(:interrupt) { :error }
         @env       = options.fetch(:env) { ENV }
-        @console   = windows? ? WinConsole.new(input) : Console.new(input)
+        @track_history = options.fetch(:track_history) { true }
+        @console   = select_console(input)
+        @history   = History.new do |h|
+          h.duplicates = false
+          h.exclude = proc { |line| line.strip == '' }
+        end
+        @stop = false # gathering input
+
+        subscribe(self)
+      end
+
+      # Select appropriate console
+      #
+      # @api private
+      def select_console(input)
+        if windows? && !env['TTY_TEST']
+          WinConsole.new(input)
+        else
+          Console.new(input)
+        end
       end
 
       # Get input in unbuffered mode.
@@ -83,7 +119,7 @@ module TTY
         char  = codes ? codes.pack('U*') : nil
 
         trigger_key_event(char) if char
-        handle_interrupt if char == @console.keys[:ctrl_c]
+        handle_interrupt if char == console.keys[:ctrl_c]
         char
       end
       alias read_char read_keypress
@@ -98,7 +134,7 @@ module TTY
       # @api private
       def get_codes(options = {}, codes = [])
         opts = { echo: true, raw: false }.merge(options)
-        char = @console.get_char(opts)
+        char = console.get_char(opts)
         return if char.nil?
         codes << char.ord
 
@@ -108,7 +144,7 @@ module TTY
           !(64..126).include?(codes.last)
         }
 
-        while @console.escape_codes.any?(&condition)
+        while console.escape_codes.any?(&condition)
           get_codes(options, codes)
         end
         codes
@@ -118,60 +154,110 @@ module TTY
       # back to the shell. The input terminates when enter or
       # return key is pressed.
       #
+      # @param [String] prompt
+      #   the prompt to display before input
+      #
       # @param [Boolean] echo
       #   if true echo back characters, output nothing otherwise
       #
       # @return [String]
       #
       # @api public
-      def read_line(options = {})
-        opts = { echo: true, raw: false }.merge(options)
-        line = ''
-        backspaces = 0
-        delete_char = proc { |c| c == BACKSPACE || c == DELETE }
+      def read_line(*args)
+        options = args.last.respond_to?(:to_hash) ? args.pop : {}
+        prompt = args.empty? ? '' : args.pop
+        opts = { echo: true, raw: true }.merge(options)
+        line = Line.new('')
+        ctrls = console.keys.keys.grep(/ctrl/)
+        clear_line = "\e[2K\e[1G"
 
-        while (codes = get_codes(opts)) && (code = codes[0])
+        while (codes = unbufferred { get_codes(opts) }) && (code = codes[0])
           char = codes.pack('U*')
           trigger_key_event(char)
 
-          if delete_char[code]
-            line.slice!(-1, 1)
-            backspaces -= 1
+          if console.keys[:backspace] == char || BACKSPACE == code
+            next if line.start?
+            line.left
+            line.delete
+          elsif console.keys[:delete] == char || DELETE == code
+            line.delete
+          elsif [console.keys[:ctrl_d],
+                 console.keys[:ctrl_z]].include?(char)
+            break
+          elsif console.keys[:ctrl_c] == char
+            handle_interrupt
+          elsif ctrls.include?(console.keys.key(char))
+            # skip
+          elsif console.keys[:up] == char
+            next unless history_previous?
+            line.replace(history_previous)
+          elsif console.keys[:down] == char
+            line.replace(history_next? ? history_next : '')
+          elsif console.keys[:left] == char
+            line.left
+          elsif console.keys[:right] == char
+            line.right
           else
-            line << char
-            backspaces = line.size
+            if opts[:raw] && code == CARRIAGE_RETURN
+              char = "\n"
+              line.move_to_end
+            end
+            line.insert(char)
+          end
+
+          if opts[:raw] && opts[:echo]
+            output.print(clear_line)
+            output.print(prompt + line.to_s)
+            if char == "\n"
+              line.move_to_start
+            elsif !line.end?
+              output.print("\e[#{line.size - line.cursor}D")
+            end
           end
 
           break if (code == CARRIAGE_RETURN || code == NEWLINE)
 
-          if delete_char[code] && opts[:echo]
-            output.print(' ' + (backspaces >= 0 ? "\b" : ''))
+          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
           end
         end
-        line
+        add_to_history(line.to_s.rstrip) if track_history?
+        line.to_s
       end
 
-      # Read multiple lines and terminate when empty line is submitted.
+      # 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
-        response = []
+      def read_multiline(prompt = '')
+        @stop = false
+        lines = []
         loop do
-          line = read_line
+          line = read_line(prompt)
           break if !line || line == ''
-          next  if line !~ /\S/
+          next  if line !~ /\S/ && !@stop
           if block_given?
-            yield(line)
+            yield(line) unless line.to_s.empty?
           else
-            response << line
+            lines << line unless line.to_s.empty?
           end
+          break if @stop
         end
-        response
+        lines
       end
+      alias read_lines read_multiline
 
       # Expose event broadcasting
       #
@@ -180,18 +266,35 @@ module TTY
         publish(event, *args)
       end
 
-      # Publish event
+      # Capture Ctrl+d and Ctrl+z key events
       #
-      # @param [String] char
-      #   the key pressed
-      #
-      # @return [nil]
-      #
-      # @api public
-      def trigger_key_event(char)
-        event = KeyEvent.from(@console.keys, char)
-        trigger(:"key#{event.key.name}", event) if event.trigger?
-        trigger(:keypress, event)
+      # @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
@@ -204,6 +307,20 @@ module TTY
 
       private
 
+      # Publish event
+      #
+      # @param [String] char
+      #   the key pressed
+      #
+      # @return [nil]
+      #
+      # @api private
+      def trigger_key_event(char)
+        event = KeyEvent.from(console.keys, char)
+        trigger(:"key#{event.key.name}", event) if event.trigger?
+        trigger(:keypress, event)
+      end
+
       # Handle input interrupt based on provided value
       #
       # @api private
@@ -228,7 +345,6 @@ module TTY
       #
       # @api public
       def windows?
-        return false if env["TTY_TEST"] == true
         ::File::ALT_SEPARATOR == "\\"
       end
     end # Reader