cli-ui 1.2.0 → 1.4.0

data/lib/cli/ui/glyph.rb

@@ -5,6 +5,7 @@ module CLI
     class Glyph
       class InvalidGlyphHandle < ArgumentError
         def initialize(handle)
+          super
           @handle = handle
         end
 
@@ -15,7 +16,7 @@ module CLI
         end
       end
 
-      attr_reader :handle, :codepoint, :color, :char, :to_s, :fmt
+      attr_reader :handle, :codepoint, :color, :to_s, :fmt
 
       # Creates a new glyph
       #
@@ -23,35 +24,39 @@ module CLI
       #
       # * +handle+ - The handle in the +MAP+ constant
       # * +codepoint+ - The codepoint used to create the glyph (e.g. +0x2717+ for a ballot X)
+      # * +plain+ - A fallback plain string to be used in case glyphs are disabled
       # * +color+ - What color to output the glyph. Check +CLI::UI::Color+ for options.
       #
-      def initialize(handle, codepoint, color)
+      def initialize(handle, codepoint, plain, color)
         @handle    = handle
         @codepoint = codepoint
         @color     = color
-        @char      = [codepoint].pack('U')
+        @plain     = plain
+        @char      = Array(codepoint).pack('U*')
         @to_s      = color.code + char + Color::RESET.code
         @fmt       = "{{#{color.name}:#{char}}}"
 
         MAP[handle] = self
       end
 
+      # Fetches the actual character(s) to be displayed for a glyph, based on the current OS support
+      #
+      # ==== Returns
+      # Returns the glyph string
+      def char
+        CLI::UI::OS.current.supports_emoji? ? @char : @plain
+      end
+
       # Mapping of glyphs to terminal output
       MAP = {}
-      # YELLOw SMALL STAR (⭑)
-      STAR     = new('*', 0x2b51,  Color::YELLOW)
-      # BLUE MATHEMATICAL SCRIPT SMALL i (𝒾)
-      INFO     = new('i', 0x1d4be, Color::BLUE)
-      # BLUE QUESTION MARK (?)
-      QUESTION = new('?', 0x003f,  Color::BLUE)
-      # GREEN CHECK MARK (✓)
-      CHECK    = new('v', 0x2713,  Color::GREEN)
-      # RED BALLOT X (✗)
-      X        = new('x', 0x2717,  Color::RED)
-      # Bug emoji (🐛)
-      BUG      = new('b', 0x1f41b, Color::WHITE)
-      # RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK (»)
-      CHEVRON  = new('>', 0xbb,    Color::YELLOW)
+      STAR      = new('*', 0x2b51,           '*', Color::YELLOW) # YELLOW SMALL STAR (⭑)
+      INFO      = new('i', 0x1d4be,          'i', Color::BLUE)   # BLUE MATHEMATICAL SCRIPT SMALL i (𝒾)
+      QUESTION  = new('?', 0x003f,           '?', Color::BLUE)   # BLUE QUESTION MARK (?)
+      CHECK     = new('v', 0x2713,           '√', Color::GREEN)  # GREEN CHECK MARK (✓)
+      X         = new('x', 0x2717,           'X', Color::RED)    # RED BALLOT X (✗)
+      BUG       = new('b', 0x1f41b,          '!', Color::WHITE)  # Bug emoji (🐛)
+      CHEVRON   = new('>', 0xbb,             '»', Color::YELLOW) # RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK (»)
+      HOURGLASS = new('H', [0x231b, 0xfe0e], 'H', Color::BLUE)   # HOURGLASS + VARIATION SELECTOR 15 (⌛︎)
 
       # Looks up a glyph by name
       #

data/lib/cli/ui/os.rb

@@ -0,0 +1,63 @@
+module CLI
+  module UI
+    module OS
+      # Determines which OS is currently running the UI, to make it easier to
+      # adapt its behaviour to the features of the OS.
+      def self.current
+        @current_os ||= case RUBY_PLATFORM
+        when /darwin/
+          Mac
+        when /linux/
+          Linux
+        when /mingw32/
+          Windows
+        else
+          raise "Could not determine OS from platform #{RUBY_PLATFORM}"
+        end
+      end
+
+      class Mac
+        class << self
+          def supports_emoji?
+            true
+          end
+
+          def supports_color_prompt?
+            true
+          end
+
+          def supports_arrow_keys?
+            true
+          end
+
+          def shift_cursor_on_line_reset?
+            false
+          end
+        end
+      end
+
+      class Linux < Mac
+      end
+
+      class Windows
+        class << self
+          def supports_emoji?
+            false
+          end
+
+          def supports_color_prompt?
+            false
+          end
+
+          def supports_arrow_keys?
+            false
+          end
+
+          def shift_cursor_on_line_reset?
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cli/ui/printer.rb

@@ -0,0 +1,47 @@
+require 'cli/ui'
+
+module CLI
+  module UI
+    class Printer
+      # Print a message to a stream with common utilities.
+      # Allows overriding the color, encoding, and target stream.
+      # By default, it formats the string using CLI:UI and rescues common stream errors.
+      #
+      # ==== Attributes
+      #
+      # * +msg+ - (required) the string to output. Can be frozen.
+      #
+      # ==== Options
+      #
+      # * +:frame_color+ - Override the frame color. Defaults to nil.
+      # * +:to+ - Target stream, like $stdout or $stderr. Can be anything with a puts method. Defaults to $stdout.
+      # * +:encoding+ - Force the output to be in a certain encoding. Defaults to UTF-8.
+      # * +:format+ - Whether to format the string using CLI::UI.fmt. Defaults to true.
+      # * +:graceful+ - Whether to gracefully ignore common I/O errors. Defaults to true.
+      #
+      # ==== Returns
+      # Returns whether the message was successfully printed,
+      # which can be useful if +:graceful+ is set to true.
+      #
+      # ==== Example
+      #
+      #   CLI::UI::Printer.puts('{x} Ouch', stream: $stderr, color: :red)
+      #
+      def self.puts(msg, frame_color: nil, to: $stdout, encoding: Encoding::UTF_8, format: true, graceful: true)
+        msg = (+msg).force_encoding(encoding) if encoding
+        msg = CLI::UI.fmt(msg) if format
+
+        if frame_color
+          CLI::UI::Frame.with_frame_color_override(frame_color) { to.puts(msg) }
+        else
+          to.puts(msg)
+        end
+
+        true
+      rescue Errno::EIO, Errno::EPIPE, IOError => e
+        raise(e) unless graceful
+        false
+      end
+    end
+  end
+end

data/lib/cli/ui/progress.rb

@@ -26,11 +26,11 @@ module CLI
       #
       # Increase the percent by X
       #   CLI::UI::Progress.progress do |bar|
-      #     bar.tick(percent: 5)
+      #     bar.tick(percent: 0.05)
       #   end
       def self.progress(width: Terminal.width)
         bar = Progress.new(width: width)
-        print CLI::UI::ANSI.hide_cursor
+        print(CLI::UI::ANSI.hide_cursor)
         yield(bar)
       ensure
         puts bar.to_s
@@ -59,29 +59,31 @@ module CLI
       # * +:percent+ - Increment progress by a specific percent amount
       # * +:set_percent+ - Set progress to a specific percent
       #
+      # *Note:* The +:percent+ and +:set_percent must be between 0.00 and 1.0
+      #
       def tick(percent: 0.01, set_percent: nil)
         raise ArgumentError, 'percent and set_percent cannot both be specified' if percent != 0.01 && set_percent
         @percent_done += percent
         @percent_done = set_percent if set_percent
         @percent_done = [@percent_done, 1.0].min # Make sure we can't go above 1.0
 
-        print to_s
-        print CLI::UI::ANSI.previous_line + "\n"
+        print(to_s)
+        print(CLI::UI::ANSI.previous_line + "\n")
       end
 
       # Format the progress bar to be printed to terminal
       #
       def to_s
-        suffix = " #{(@percent_done * 100).round(2)}%"
+        suffix = " #{(@percent_done * 100).floor}%".ljust(5)
         workable_width = @max_width - Frame.prefix_width - suffix.size
         filled = [(@percent_done * workable_width.to_f).ceil, 0].max
         unfilled = [workable_width - filled, 0].max
 
-        CLI::UI.resolve_text [
+        CLI::UI.resolve_text([
           FILLED_BAR + ' ' * filled,
           UNFILLED_BAR + ' ' * unfilled,
-          CLI::UI::Color::RESET.code + suffix
-        ].join
+          CLI::UI::Color::RESET.code + suffix,
+        ].join)
       end
     end
   end

data/lib/cli/ui/prompt.rb

@@ -1,3 +1,4 @@
+# coding: utf-8
 require 'cli/ui'
 require 'readline'
 
@@ -30,11 +31,16 @@ module CLI
         # * +:default+ - The default answer to the question (e.g. they just press enter and don't input anything)
         # * +:is_file+ - Tells the input to use file auto-completion (tab completion)
         # * +:allow_empty+ - Allows the answer to be empty
+        # * +:multiple+ - Allow multiple options to be selected
+        # * +:filter_ui+ - Enable option filtering (default: true)
+        # * +:select_ui+ - Enable long-form option selection (default: true)
         #
         # Note:
-        # * +:options+ or providing a +Block+ conflicts with +:default+ and +:is_file+, you cannot set options with either of these keywords
+        # * +:options+ or providing a +Block+ conflicts with +:default+ and +:is_file+,
+        #              you cannot set options with either of these keywords
         # * +:default+ conflicts with +:allow_empty:, you cannot set these together
         # * +:options+ conflicts with providing a +Block+ , you may only set one
+        # * +:multiple+ can only be used with +:options+ or a +Block+; it is ignored, otherwise.
         #
         # ==== Block (optional)
         #
@@ -44,7 +50,7 @@ module CLI
         # ==== Return Value
         #
         # * If a +Block+ was not provided, the selected option or response to the free form question will be returned
-        # * If a +Block+ was provided, the evaluted value of the +Block+ will be returned
+        # * If a +Block+ was provided, the evaluated value of the +Block+ will be returned
         #
         # ==== Example Usage:
         #
@@ -71,18 +77,67 @@ module CLI
         #     handler.option('python') { |selection| selection }
         #   end
         #
-        def ask(question, options: nil, default: nil, is_file: nil, allow_empty: true, multiple: false, &options_proc)
-          if ((options || block_given?) && (default || is_file))
+        def ask(
+          question,
+          options: nil,
+          default: nil,
+          is_file: nil,
+          allow_empty: true,
+          multiple: false,
+          filter_ui: true,
+          select_ui: true,
+          &options_proc
+        )
+          if (options || block_given?) && ((default && !multiple) || is_file)
             raise(ArgumentError, 'conflicting arguments: options provided with default or is_file')
           end
 
+          if options && multiple && default && !(default - options).empty?
+            raise(ArgumentError, 'conflicting arguments: default should only include elements present in options')
+          end
+
           if options || block_given?
-            ask_interactive(question, options, multiple: multiple, &options_proc)
+            ask_interactive(
+              question,
+              options,
+              multiple: multiple,
+              default: default,
+              filter_ui: filter_ui,
+              select_ui: select_ui,
+              &options_proc
+            )
           else
             ask_free_form(question, default, is_file, allow_empty)
           end
         end
 
+        # Asks the user for a single-line answer, without displaying the characters while typing.
+        # Typically used for password prompts
+        #
+        # ==== Return Value
+        #
+        # The password, without a trailing newline.
+        # If the user simply presses "Enter" without typing any password, this will return an empty string.
+        def ask_password(question)
+          require 'io/console'
+
+          CLI::UI.with_frame_color(:blue) do
+            STDOUT.print(CLI::UI.fmt('{{?}} ' + question)) # Do not use puts_question to avoid the new line.
+
+            # noecho interacts poorly with Readline under system Ruby, so do a manual `gets` here.
+            # No fancy Readline integration (like echoing back) is required for a password prompt anyway.
+            password = STDIN.noecho do
+              # Chomp will remove the one new line character added by `gets`, without touching potential extra spaces:
+              # " 123 \n".chomp => " 123 "
+              STDIN.gets.chomp
+            end
+
+            STDOUT.puts # Complete the line
+
+            password
+          end
+        end
+
         # Asks the user a yes/no question.
         # Can use arrows, y/n, numbers (1/2), and vim bindings to control
         #
@@ -91,14 +146,18 @@ module CLI
         # Confirmation question
         #   CLI::UI::Prompt.confirm('Is the sky blue?')
         #
-        def confirm(question)
-          ask_interactive(question, %w(yes no)) == 'yes'
+        #   CLI::UI::Prompt.confirm('Do a dangerous thing?', default: false)
+        #
+        def confirm(question, default: true)
+          ask_interactive(question, default ? %w(yes no) : %w(no yes), filter_ui: false) == 'yes'
         end
 
         private
 
         def ask_free_form(question, default, is_file, allow_empty)
-          raise(ArgumentError, 'conflicting arguments: default enabled but allow_empty is false') if (default && !allow_empty)
+          if default && !allow_empty
+            raise(ArgumentError, 'conflicting arguments: default enabled but allow_empty is false')
+          end
 
           if default
             puts_question("#{question} (empty = #{default})")
@@ -121,7 +180,7 @@ module CLI
           end
         end
 
-        def ask_interactive(question, options = nil, multiple: false)
+        def ask_interactive(question, options = nil, multiple: false, default: nil, filter_ui: true, select_ui: true)
           raise(ArgumentError, 'conflicting arguments: options and block given') if options && block_given?
 
           options ||= if block_given?
@@ -130,15 +189,23 @@ module CLI
             handler.options
           end
 
-          raise(ArgumentError, 'insufficient options') if options.nil? || options.size < 2
-          instructions = (multiple ? "Toggle options. " : "") + "Choose with ↑ ↓ ⏎"
+          raise(ArgumentError, 'insufficient options') if options.nil? || options.empty?
+          navigate_text = if CLI::UI::OS.current.supports_arrow_keys?
+            "Choose with ↑ ↓ ⏎"
+          else
+            "Navigate up with 'k' and down with 'j', press Enter to select"
+          end
+
+          instructions = (multiple ? "Toggle options. " : "") + navigate_text
+          instructions += ", filter with 'f'" if filter_ui
+          instructions += ", enter option with 'e'" if select_ui && (options.size > 9)
           puts_question("#{question} {{yellow:(#{instructions})}}")
-          resp = interactive_prompt(options, multiple: multiple)
+          resp = interactive_prompt(options, multiple: multiple, default: default)
 
           # Clear the line
-          print ANSI.previous_line + ANSI.clear_to_end_of_line
+          print(ANSI.previous_line + ANSI.clear_to_end_of_line)
           # Force StdoutRouter to prefix
-          print ANSI.previous_line + "\n"
+          print(ANSI.previous_line + "\n")
 
           # reset the question to include the answer
           resp_text = resp
@@ -159,8 +226,8 @@ module CLI
         end
 
         # Useful for stubbing in tests
-        def interactive_prompt(options, multiple: false)
-          InteractiveOptions.call(options, multiple: multiple)
+        def interactive_prompt(options, multiple: false, default: nil)
+          InteractiveOptions.call(options, multiple: multiple, default: default)
         end
 
         def write_default_over_empty_input(default)
@@ -195,10 +262,14 @@ module CLI
           # thread to manage output, but the current strategy feels like a
           # better tradeoff.
           prefix = CLI::UI.with_frame_color(:blue) { CLI::UI::Frame.prefix }
-          prompt = prefix + CLI::UI.fmt('{{blue:> }}{{yellow:')
+          # If a prompt is interrupted on Windows it locks the colour of the terminal from that point on, so we should
+          # not change the colour here.
+          prompt = prefix + CLI::UI.fmt('{{blue:> }}')
+          prompt += CLI::UI::Color::YELLOW.code if CLI::UI::OS.current.supports_color_prompt?
 
           begin
             line = Readline.readline(prompt, true)
+            print(CLI::UI::Color::RESET.code)
             line.to_s.chomp
           rescue Interrupt
             CLI::UI.raw { STDERR.puts('^C' + CLI::UI::Color::RESET.code) }

data/lib/cli/ui/prompt/interactive_options.rb

@@ -1,3 +1,4 @@
+# coding: utf-8
 require 'io/console'
 
 module CLI
@@ -10,6 +11,9 @@ module CLI
         # Prompts the user with options
         # Uses an interactive session to allow the user to pick an answer
         # Can use arrows, y/n, numbers (1/2), and vim bindings to control
+        # For more than 9 options, hitting 'e', ':', or 'G' will enter select
+        # mode allowing the user to type in longer numbers
+        # Pressing 'f' or '/' will allow the user to filter the results
         #
         # https://user-images.githubusercontent.com/3074765/33797984-0ebb5e64-dcdf-11e7-9e7e-7204f279cece.gif
         #
@@ -18,8 +22,8 @@ module CLI
         # Ask an interactive question
         #   CLI::UI::Prompt::InteractiveOptions.call(%w(rails go python))
         #
-        def self.call(options, multiple: false)
-          list = new(options, multiple: multiple)
+        def self.call(options, multiple: false, default: nil)
+          list = new(options, multiple: multiple, default: default)
           selected = list.call
           if multiple
             selected.map { |s| options[s - 1] }
@@ -35,23 +39,35 @@ module CLI
         #
         #   CLI::UI::Prompt::InteractiveOptions.new(%w(rails go python))
         #
-        def initialize(options, multiple: false)
+        def initialize(options, multiple: false, default: nil)
           @options = options
           @active = 1
           @marker = '>'
           @answer = nil
           @state = :root
           @multiple = multiple
+          # Indicate that an extra line (the "metadata" line) is present and
+          # the terminal output should be drawn over when processing user input
+          @displaying_metadata = false
+          @filter = ''
           # 0-indexed array representing if selected
           # @options[0] is selected if @chosen[0]
-          @chosen = Array.new(@options.size) { false } if multiple
+          if multiple
+            @chosen = if default
+              @options.map { |option| default.include?(option) }
+            else
+              Array.new(@options.size) { false }
+            end
+          end
           @redraw = true
+          @presented_options = []
         end
 
         # Calls the +InteractiveOptions+ and asks the question
         # Usually used from +self.call+
         #
         def call
+          calculate_option_line_lengths
           CLI::UI.raw { print(ANSI.hide_cursor) }
           while @answer.nil?
             render_options
@@ -59,6 +75,7 @@ module CLI
             reset_position
           end
           clear_output
+
           @answer
         ensure
           CLI::UI.raw do
@@ -68,46 +85,96 @@ module CLI
 
         private
 
-        def reset_position
+        def calculate_option_line_lengths
+          @terminal_width_at_calculation_time = CLI::UI::Terminal.width
+          # options will be an array of questions but each option can be multi-line
+          # so to get the # of lines, you need to join then split
+
+          # since lines may be longer than the terminal is wide, we need to
+          # determine how many extra lines would be taken up by them
+          max_width = (@terminal_width_at_calculation_time -
+                       @options.count.to_s.size - # Width of the displayed number
+                       5 -                        # Extra characters added during rendering
+                       (@multiple ? 1 : 0)        # Space for the checkbox, if rendered
+                      ).to_f
+
+          @option_lengths = @options.map do |text|
+            width = 1 if text.empty?
+            width ||= text
+              .split("\n")
+              .reject(&:empty?)
+              .map { |l| (CLI::UI.fmt(l, enable_color: false).length / max_width).ceil }
+              .reduce(&:+)
+
+            width
+          end
+        end
+
+        def reset_position(number_of_lines = num_lines)
           # This will put us back at the beginning of the options
           # When we redraw the options, they will be overwritten
           CLI::UI.raw do
-            num_lines.times { print(ANSI.previous_line) }
+            number_of_lines.times { print(ANSI.previous_line) }
           end
         end
 
-        def clear_output
+        def clear_output(number_of_lines = num_lines)
           CLI::UI.raw do
             # Write over all lines with whitespace
-            num_lines.times { puts(' ' * CLI::UI::Terminal.width) }
+            number_of_lines.times { puts(' ' * CLI::UI::Terminal.width) }
           end
-          reset_position
+          reset_position(number_of_lines)
+
+          # Update if metadata is being displayed
+          # This must be done _after_ the output is cleared or it won't draw over
+          # the entire output
+          @displaying_metadata = display_metadata?
+        end
+
+        # Don't use this in place of +@displaying_metadata+, this updates too
+        # quickly to be useful when drawing to the screen.
+        def display_metadata?
+          filtering? || selecting? || has_filter?
         end
 
         def num_lines
-          options = presented_options.map(&:first)
-          # @options will be an array of questions but each option can be multi-line
-          # so to get the # of lines, you need to join then split
+          calculate_option_line_lengths if terminal_width_changed?
 
-          # empty_option_count is needed since empty option titles are omitted
-          # from the line count when reject(&:empty?) is called
+          option_length = presented_options.reduce(0) do |total_length, (_, option_number)|
+            # Handle continuation markers and "Done" option when multiple is true
+            next total_length + 1 if option_number.nil? || option_number.zero?
+            total_length + @option_lengths[option_number - 1]
+          end
+
+          option_length + (@displaying_metadata ? 1 : 0)
+        end
 
-          empty_option_count = options.count(&:empty?)
-          joined_options = options.join("\n")
-          joined_options.split("\n").reject(&:empty?).size + empty_option_count
+        def terminal_width_changed?
+          @terminal_width_at_calculation_time != CLI::UI::Terminal.width
         end
 
         ESC = "\e"
+        BACKSPACE = "\u007F"
+        CTRL_C = "\u0003"
+        CTRL_D = "\u0004"
 
         def up
-          min_pos = @multiple ? 0 : 1
-          @active = @active - 1 >= min_pos ? @active - 1 : @options.length
+          active_index = @filtered_options.index { |_, num| num == @active } || 0
+
+          previous_visible = @filtered_options[active_index - 1]
+          previous_visible ||= @filtered_options.last
+
+          @active = previous_visible ? previous_visible.last : -1
           @redraw = true
         end
 
         def down
-          min_pos = @multiple ? 0 : 1
-          @active = @active + 1 <= @options.length ? @active + 1 : min_pos
+          active_index = @filtered_options.index { |_, num| num == @active } || 0
+
+          next_visible = @filtered_options[active_index + 1]
+          next_visible ||= @filtered_options.first
+
+          @active = next_visible ? next_visible.last : -1
           @redraw = true
         end
 
@@ -141,7 +208,36 @@ module CLI
           @redraw = true
         end
 
+        def build_selection(char)
+          @active = (@active.to_s + char).to_i
+          @redraw = true
+        end
+
+        def chop_selection
+          @active = @active.to_s.chop.to_i
+          @redraw = true
+        end
+
+        def update_search(char)
+          @redraw = true
+
+          # Control+D or Backspace on empty search closes search
+          if (char == CTRL_D) || (@filter.empty? && (char == BACKSPACE))
+            @filter = ''
+            @state = :root
+            return
+          end
+
+          if char == BACKSPACE
+            @filter.chop!
+          else
+            @filter += char
+          end
+        end
+
         def select_current
+          # Prevent selection of invisible options
+          return unless presented_options.any? { |_, num| num == @active }
           select_n(@active)
         end
 
@@ -150,40 +246,93 @@ module CLI
           wait_for_user_input until @redraw
         end
 
-        # rubocop:disable Style/WhenThen,Layout/SpaceBeforeSemicolon
+        # rubocop:disable Style/WhenThen,Layout/SpaceBeforeSemicolon,Style/Semicolon
         def wait_for_user_input
           char = read_char
+          @last_char = char
+
+          case char
+          when :timeout ; raise Interrupt # Timeout, use interrupt to simulate
+          when CTRL_C   ; raise Interrupt
+          end
+
+          max_digit = [@options.size, 9].min.to_s
           case @state
           when :root
             case char
-            when :timeout                  ; raise Interrupt # Timeout, use interrupt to simulate
-            when ESC                       ; @state = :esc
-            when 'k'                       ; up
-            when 'j'                       ; down
-            when '0'                       ; select_n(char.to_i)
-            when ('1'..@options.size.to_s) ; select_n(char.to_i)
-            when 'y', 'n'                  ; select_bool(char)
-            when " ", "\r", "\n"           ; select_current  # <enter>
-            when "\u0003"                  ; raise Interrupt # Ctrl-c
+            when ESC              ; @state = :esc
+            when 'k'              ; up
+            when 'j'              ; down
+            when 'e', ':', 'G'    ; start_line_select
+            when 'f', '/'         ; start_filter
+            when ('0'..max_digit) ; select_n(char.to_i)
+            when 'y', 'n'         ; select_bool(char)
+            when " ", "\r", "\n"  ; select_current # <enter>
+            end
+          when :filter
+            case char
+            when ESC        ; @state = :esc
+            when "\r", "\n" ; select_current
+            when "\b"       ; update_search(BACKSPACE) # Happens on Windows
+            else            ; update_search(char)
+            end
+          when :line_select
+            case char
+            when ESC             ; @state = :esc
+            when 'k'             ; up   ; @state = :root
+            when 'j'             ; down ; @state = :root
+            when 'e', ':', 'G', 'q' ; stop_line_select
+            when '0'..'9'        ; build_selection(char)
+            when BACKSPACE       ; chop_selection # Pop last input on backspace
+            when ' ', "\r", "\n" ; select_current
             end
           when :esc
             case char
-            when :timeout ; raise Interrupt # Timeout, use interrupt to simulate
             when '['      ; @state = :esc_bracket
             else          ; raise Interrupt # unhandled escape sequence.
             end
           when :esc_bracket
-            @state = :root
+            @state = has_filter? ? :filter : :root
             case char
-            when :timeout ; raise Interrupt # Timeout, use interrupt to simulate
             when 'A'      ; up
             when 'B'      ; down
+            when 'C'      ; # Ignore right key
+            when 'D'      ; # Ignore left key
             else          ; raise Interrupt # unhandled escape sequence.
             end
           end
         end
         # rubocop:enable Style/WhenThen,Layout/SpaceBeforeSemicolon
 
+        def selecting?
+          @state == :line_select
+        end
+
+        def filtering?
+          @state == :filter
+        end
+
+        def has_filter?
+          !@filter.empty?
+        end
+
+        def start_filter
+          @state = :filter
+          @redraw = true
+        end
+
+        def start_line_select
+          @state  = :line_select
+          @active = 0
+          @redraw = true
+        end
+
+        def stop_line_select
+          @state = :root
+          @active = 1 if @active.zero?
+          @redraw = true
+        end
+
         def read_char
           raw_tty! do
             getc = $stdin.getc
@@ -205,9 +354,29 @@ module CLI
           return @presented_options unless recalculate
 
           @presented_options = @options.zip(1..Float::INFINITY)
-          @presented_options.unshift([DONE, 0]) if @multiple
+          if has_filter?
+            @presented_options.select! { |option, _| option.downcase.include?(@filter.downcase) }
+          end
 
-          while num_lines > max_options
+          # Used for selection purposes
+          @presented_options.push([DONE, 0]) if @multiple
+          @filtered_options = @presented_options.dup
+
+          ensure_visible_is_active if has_filter?
+
+          # Must have more lines before the selection than we can display
+          if distance_from_start_to_selection > max_lines
+            @presented_options.shift(distance_from_start_to_selection - max_lines)
+            ensure_first_item_is_continuation_marker
+          end
+
+          # Must have more lines after the selection than we can display
+          if distance_from_selection_to_end > max_lines
+            @presented_options.pop(distance_from_selection_to_end - max_lines)
+            ensure_last_item_is_continuation_marker
+          end
+
+          while num_lines > max_lines
             # try to keep the selection centered in the window:
             if distance_from_selection_to_end > distance_from_start_to_selection
               # selection is closer to top than bottom, so trim a row from the bottom
@@ -223,14 +392,22 @@ module CLI
           @presented_options
         end
 
+        def ensure_visible_is_active
+          unless presented_options.any? { |_, num| num == @active }
+            @active = presented_options.first&.last.to_i
+          end
+        end
+
         def distance_from_selection_to_end
-          last_visible_option_number = @presented_options[-1].last || @presented_options[-2].last
-          last_visible_option_number - @active
+          @presented_options.count - index_of_active_option
         end
 
         def distance_from_start_to_selection
-          first_visible_option_number = @presented_options[0].last || @presented_options[1].last
-          @active - first_visible_option_number
+          index_of_active_option
+        end
+
+        def index_of_active_option
+          @presented_options.index { |_, num| num == @active }.to_i
         end
 
         def ensure_last_item_is_continuation_marker
@@ -241,15 +418,39 @@ module CLI
           @presented_options.unshift(["...", nil]) if @presented_options.first.last
         end
 
-        def max_options
-          @max_options ||= CLI::UI::Terminal.height - 2 # Keeps a one line question visible
+        def max_lines
+          CLI::UI::Terminal.height - (@displaying_metadata ? 3 : 2) # Keeps a one line question visible
         end
 
         def render_options
+          previously_displayed_lines = num_lines
+
+          @displaying_metadata = display_metadata?
+
+          options = presented_options(recalculate: true)
+
+          clear_output(previously_displayed_lines) if previously_displayed_lines > num_lines
+
           max_num_length = (@options.size + 1).to_s.length
 
-          presented_options(recalculate: true).each do |choice, num|
-            is_chosen = @multiple && num && @chosen[num - 1]
+          metadata_text = if selecting?
+            select_text = @active
+            select_text = '{{info:e, q, or up/down anytime to exit}}' if @active == 0
+            "Select: #{select_text}"
+          elsif filtering? || has_filter?
+            filter_text = @filter
+            filter_text = '{{info:Ctrl-D anytime or Backspace now to exit}}' if @filter.empty?
+            "Filter: #{filter_text}"
+          end
+
+          if metadata_text
+            CLI::UI.with_frame_color(:blue) do
+              puts CLI::UI.fmt("  {{green:#{metadata_text}}}#{ANSI.clear_to_end_of_line}")
+            end
+          end
+
+          options.each do |choice, num|
+            is_chosen = @multiple && num && @chosen[num - 1] && num != 0
 
             padding = ' ' * (max_num_length - num.to_s.length)
             message = "  #{num}#{num ? '.' : ' '}#{padding}"
@@ -260,20 +461,30 @@ module CLI
             format = "{{cyan:#{format}}}" if @multiple && is_chosen && num != @active
             format = " #{format}"
 
-            message += sprintf(format, CHECKBOX_ICON[is_chosen]) if @multiple && num && num > 0
-            message += choice.split("\n").map { |l| sprintf(format, l) }.join("\n")
+            message += format(format, CHECKBOX_ICON[is_chosen]) if @multiple && num && num > 0
+            message += format_choice(format, choice)
 
             if num == @active
-              message = message.split("\n").map.with_index do |l, idx|
-                idx == 0 ? "{{blue:> #{l.strip}}}" : "{{blue:>#{l.strip}}}"
-              end.join("\n")
+
+              color = filtering? || selecting? ? 'green' : 'blue'
+              message = message.split("\n").map { |l| "{{#{color}:> #{l.strip}}}" }.join("\n")
             end
 
             CLI::UI.with_frame_color(:blue) do
-              puts CLI::UI.fmt(message) + CLI::UI::ANSI.clear_to_end_of_line
+              puts CLI::UI.fmt(message)
             end
           end
         end
+
+        def format_choice(format, choice)
+          eol = CLI::UI::ANSI.clear_to_end_of_line
+          lines = choice.split("\n")
+
+          return eol if lines.empty? # Handle blank options
+
+          lines.map! { |l| format(format, l) + eol }
+          lines.join("\n")
+        end
       end
     end
   end