shopify-cli 0.9.0

data/vendor/deps/cli-ui/lib/cli/ui/glyph.rb

@@ -0,0 +1,78 @@
+require 'cli/ui'
+
+module CLI
+  module UI
+    class Glyph
+      class InvalidGlyphHandle < ArgumentError
+        def initialize(handle)
+          @handle = handle
+        end
+
+        def message
+          keys = Glyph.available.join(',')
+          "invalid glyph handle: #{@handle} " \
+            "-- must be one of CLI::UI::Glyph.available (#{keys})"
+        end
+      end
+
+      attr_reader :handle, :codepoint, :color, :char, :to_s, :fmt
+
+      # Creates a new glyph
+      #
+      # ==== Attributes
+      #
+      # * +handle+ - The handle in the +MAP+ constant
+      # * +codepoint+ - The codepoint used to create the glyph (e.g. +0x2717+ for a ballot X)
+      # * +color+ - What color to output the glyph. Check +CLI::UI::Color+ for options.
+      #
+      def initialize(handle, codepoint, color)
+        @handle    = handle
+        @codepoint = codepoint
+        @color     = color
+        @char      = [codepoint].pack('U')
+        @to_s      = color.code + char + Color::RESET.code
+        @fmt       = "{{#{color.name}:#{char}}}"
+
+        MAP[handle] = self
+      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)
+
+      # Looks up a glyph by name
+      #
+      # ==== Raises
+      # Raises a InvalidGlyphHandle if the glyph is not available
+      # You likely need to create it with +.new+ or you made a typo
+      #
+      # ==== Returns
+      # Returns a terminal output-capable string
+      #
+      def self.lookup(name)
+        MAP.fetch(name.to_s)
+      rescue KeyError
+        raise InvalidGlyphHandle, name
+      end
+
+      # All available glyphs by name
+      #
+      def self.available
+        MAP.keys
+      end
+    end
+  end
+end

data/vendor/deps/cli-ui/lib/cli/ui/progress.rb

@@ -0,0 +1,88 @@
+require 'cli/ui'
+
+module CLI
+  module UI
+    class Progress
+      # A Cyan filled block
+      FILLED_BAR = "\e[46m"
+      # A bright white block
+      UNFILLED_BAR = "\e[1;47m"
+
+      # Add a progress bar to the terminal output
+      #
+      # https://user-images.githubusercontent.com/3074765/33799794-cc4c940e-dd00-11e7-9bdc-90f77ec9167c.gif
+      #
+      # ==== Example Usage:
+      #
+      # Set the percent to X
+      #   CLI::UI::Progress.progress do |bar|
+      #     bar.tick(set_percent: percent)
+      #   end
+      #
+      # Increase the percent by 1 percent
+      #   CLI::UI::Progress.progress do |bar|
+      #     bar.tick
+      #   end
+      #
+      # Increase the percent by X
+      #   CLI::UI::Progress.progress do |bar|
+      #     bar.tick(percent: 5)
+      #   end
+      def self.progress(width: Terminal.width)
+        bar = Progress.new(width: width)
+        print CLI::UI::ANSI.hide_cursor
+        yield(bar)
+      ensure
+        puts bar.to_s
+        CLI::UI.raw do
+          print(ANSI.show_cursor)
+        end
+      end
+
+      # Initialize a progress bar. Typically used in a +Progress.progress+ block
+      #
+      # ==== Options
+      # One of the follow can be used, but not both together
+      #
+      # * +:width+ - The width of the terminal
+      #
+      def initialize(width: Terminal.width)
+        @percent_done = 0
+        @max_width = width
+      end
+
+      # Set the progress of the bar. Typically used in a +Progress.progress+ block
+      #
+      # ==== Options
+      # One of the follow can be used, but not both together
+      #
+      # * +:percent+ - Increment progress by a specific percent amount
+      # * +:set_percent+ - Set progress to a specific percent
+      #
+      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"
+      end
+
+      # Format the progress bar to be printed to terminal
+      #
+      def to_s
+        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 [
+          FILLED_BAR + ' ' * filled,
+          UNFILLED_BAR + ' ' * unfilled,
+          CLI::UI::Color::RESET.code + suffix
+        ].join
+      end
+    end
+  end
+end

data/vendor/deps/cli-ui/lib/cli/ui/prompt.rb

@@ -0,0 +1,248 @@
+# coding: utf-8
+require 'cli/ui'
+require 'readline'
+
+module CLI
+  module UI
+    module Prompt
+      autoload :InteractiveOptions,  'cli/ui/prompt/interactive_options'
+      autoload :OptionsHandler,      'cli/ui/prompt/options_handler'
+      private_constant :InteractiveOptions, :OptionsHandler
+
+      class << self
+        # Ask a user a question with either free form answer or a set of answers (multiple choice)
+        # Can use arrows, y/n, numbers (1/2), and vim bindings to control multiple choice selection
+        # Do not use this method for yes/no questions. Use +confirm+
+        #
+        # * Handles free form answers (options are nil)
+        # * Handles default answers for free form text
+        # * Handles file auto completion for file input
+        # * Handles interactively choosing answers using +InteractiveOptions+
+        #
+        # https://user-images.githubusercontent.com/3074765/33799822-47f23302-dd01-11e7-82f3-9072a5a5f611.png
+        #
+        # ==== Attributes
+        #
+        # * +question+ - (required) The question to ask the user
+        #
+        # ==== Options
+        #
+        # * +:options+ - Options that the user may select from. Will use +InteractiveOptions+ to do so.
+        # * +: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
+        # * +: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)
+        #
+        # * A Proc that provides a +OptionsHandler+ and uses the public +:option+ method to add options and their
+        #   respective handlers
+        #
+        # ==== 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
+        #
+        # ==== Example Usage:
+        #
+        # Free form question
+        #   CLI::UI::Prompt.ask('What color is the sky?')
+        #
+        # Free form question with a file answer
+        #   CLI::UI::Prompt.ask('Where is your Gemfile located?', is_file: true)
+        #
+        # Free form question with a default answer
+        #   CLI::UI::Prompt.ask('What color is the sky?', default: 'blue')
+        #
+        # Free form question when the answer can be empty
+        #   CLI::UI::Prompt.ask('What is your opinion on this question?', allow_empty: true)
+        #
+        # Interactive (multiple choice) question
+        #   CLI::UI::Prompt.ask('What kind of project is this?', options: %w(rails go ruby python))
+        #
+        # Interactive (multiple choice) question with defined handlers
+        #   CLI::UI::Prompt.ask('What kind of project is this?') do |handler|
+        #     handler.option('rails')  { |selection| selection }
+        #     handler.option('go')     { |selection| selection }
+        #     handler.option('ruby')   { |selection| selection }
+        #     handler.option('python') { |selection| selection }
+        #   end
+        #
+        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 || is_file))
+            raise(ArgumentError, 'conflicting arguments: options provided with default or is_file')
+          end
+
+          if options || block_given?
+            ask_interactive(question, options, multiple: multiple, 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
+        #
+        # ==== Example Usage:
+        #
+        # Confirmation question
+        #   CLI::UI::Prompt.confirm('Is the sky blue?')
+        #
+        #   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
+            puts_question("#{question} (empty = #{default})")
+          else
+            puts_question(question)
+          end
+
+          # Ask a free form question
+          loop do
+            line = readline(is_file: is_file)
+
+            if line.empty? && default
+              write_default_over_empty_input(default)
+              return default
+            end
+
+            if !line.empty? || allow_empty
+              return line
+            end
+          end
+        end
+
+        def ask_interactive(question, options = nil, multiple: false, filter_ui: true, select_ui: true)
+          raise(ArgumentError, 'conflicting arguments: options and block given') if options && block_given?
+
+          options ||= if block_given?
+            handler = OptionsHandler.new
+            yield handler
+            handler.options
+          end
+
+          raise(ArgumentError, 'insufficient options') if options.nil? || options.empty?
+          instructions = (multiple ? "Toggle options. " : "") + "Choose with ↑ ↓ ⏎"
+          instructions += ", filter with 'f'" if filter_ui
+          instructions += ", enter option with 'e'" if select_ui and options.size > 9
+          puts_question("#{question} {{yellow:(#{instructions})}}")
+          resp = interactive_prompt(options, multiple: multiple)
+
+          # Clear the line
+          print ANSI.previous_line + ANSI.clear_to_end_of_line
+          # Force StdoutRouter to prefix
+          print ANSI.previous_line + "\n"
+
+          # reset the question to include the answer
+          resp_text = resp
+          if multiple
+            resp_text = case resp.size
+            when 0
+              "<nothing>"
+            when 1..2
+              resp.join(" and ")
+            else
+              "#{resp.size} items"
+            end
+          end
+          puts_question("#{question} (You chose: {{italic:#{resp_text}}})")
+
+          return handler.call(resp) if block_given?
+          resp
+        end
+
+        # Useful for stubbing in tests
+        def interactive_prompt(options, multiple: false)
+          InteractiveOptions.call(options, multiple: multiple)
+        end
+
+        def write_default_over_empty_input(default)
+          CLI::UI.raw do
+            STDERR.puts(
+              CLI::UI::ANSI.cursor_up(1) +
+              "\r" +
+              CLI::UI::ANSI.cursor_forward(4) + # TODO: width
+              default +
+              CLI::UI::Color::RESET.code
+            )
+          end
+        end
+
+        def puts_question(str)
+          CLI::UI.with_frame_color(:blue) do
+            STDOUT.puts(CLI::UI.fmt('{{?}} ' + str))
+          end
+        end
+
+        def readline(is_file: false)
+          if is_file
+            Readline.completion_proc = Readline::FILENAME_COMPLETION_PROC
+            Readline.completion_append_character = ""
+          else
+            Readline.completion_proc = proc { |*| nil }
+            Readline.completion_append_character = " "
+          end
+
+          # because Readline is a C library, CLI::UI's hooks into $stdout don't
+          # work. We could work around this by having CLI::UI use a pipe and a
+          # 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:> }}') + CLI::UI::Color::YELLOW.code
+
+          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) }
+            raise
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/deps/cli-ui/lib/cli/ui/prompt/interactive_options.rb

@@ -0,0 +1,472 @@
+# coding: utf-8
+require 'io/console'
+
+module CLI
+  module UI
+    module Prompt
+      class InteractiveOptions
+        DONE = "Done"
+        CHECKBOX_ICON = { false => "☐", true => "☑" }
+
+        # 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
+        #
+        # ==== Example Usage:
+        #
+        # Ask an interactive question
+        #   CLI::UI::Prompt::InteractiveOptions.call(%w(rails go python))
+        #
+        def self.call(options, multiple: false)
+          list = new(options, multiple: multiple)
+          selected = list.call
+          if multiple
+            selected.map { |s| options[s - 1] }
+          else
+            options[selected - 1]
+          end
+        end
+
+        # Initializes a new +InteractiveOptions+
+        # Usually called from +self.call+
+        #
+        # ==== Example Usage:
+        #
+        #   CLI::UI::Prompt::InteractiveOptions.new(%w(rails go python))
+        #
+        def initialize(options, multiple: false)
+          @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
+          @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
+            process_input_until_redraw_required
+            reset_position
+          end
+          clear_output
+
+          @answer
+        ensure
+          CLI::UI.raw do
+            print(ANSI.show_cursor)
+          end
+        end
+
+        private
+
+        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| (l.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
+            number_of_lines.times { print(ANSI.previous_line) }
+          end
+        end
+
+        def clear_output(number_of_lines=num_lines)
+          CLI::UI.raw do
+            # Write over all lines with whitespace
+            number_of_lines.times { puts(' ' * CLI::UI::Terminal.width) }
+          end
+          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? or selecting? or has_filter?
+        end
+
+        def num_lines
+          calculate_option_line_lengths if terminal_width_changed?
+
+          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? or option_number.zero?
+            total_length + @option_lengths[option_number - 1]
+          end
+
+          option_length + (@displaying_metadata ? 1 : 0)
+        end
+
+        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
+          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
+          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
+
+        # n is 1-indexed selection
+        # n == 0 if "Done" was selected in @multiple mode
+        def select_n(n)
+          if @multiple
+            if n == 0
+              @answer = []
+              @chosen.each_with_index do |selected, i|
+                @answer << i + 1 if selected
+              end
+            else
+              @active = n
+              @chosen[n - 1] = !@chosen[n - 1]
+            end
+          elsif n == 0
+            # Ignore pressing "0" when not in multiple mode
+          else
+            @active = n
+            @answer = n
+          end
+          @redraw = true
+        end
+
+        def select_bool(char)
+          return unless (@options - %w(yes no)).empty?
+          opt = @options.detect { |o| o.start_with?(char) }
+          @active = @options.index(opt) + 1
+          @answer = @options.index(opt) + 1
+          @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 or (@filter.empty? and 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
+
+        def process_input_until_redraw_required
+          @redraw = false
+          wait_for_user_input until @redraw
+        end
+
+        # rubocop:disable Style/WhenThen,Layout/SpaceBeforeSemicolon
+        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
+
+          case @state
+          when :root
+            case char
+            when ESC                       ; @state = :esc
+            when 'k'                       ; up
+            when 'j'                       ; down
+            when 'e', ':', 'G'             ; start_line_select
+            when 'f', '/'                  ; start_filter
+            when ('0'..@options.size.to_s) ; 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
+            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 '['      ; @state = :esc_bracket
+            else          ; raise Interrupt # unhandled escape sequence.
+            end
+          when :esc_bracket
+            @state = has_filter? ? :filter : :root
+            case char
+            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
+            getc ? getc.chr : :timeout
+          end
+        rescue IOError
+          "\e"
+        end
+
+        def raw_tty!
+          if ENV['TEST'] || !$stdin.tty?
+            yield
+          else
+            $stdin.raw { yield }
+          end
+        end
+
+        def presented_options(recalculate: false)
+          return @presented_options unless recalculate
+
+          @presented_options = @options.zip(1..Float::INFINITY)
+          if has_filter?
+            @presented_options.select! { |option,_| option.downcase.include?(@filter.downcase) }
+          end
+
+          # Used for selection purposes
+          @filtered_options = @presented_options.dup
+
+          @presented_options.unshift([DONE, 0]) if @multiple
+
+          ensure_visible_is_active if has_filter?
+
+          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
+              ensure_last_item_is_continuation_marker
+              @presented_options.delete_at(-2)
+            else
+              # selection is closer to bottom than top, so trim a row from the top
+              ensure_first_item_is_continuation_marker
+              @presented_options.delete_at(1)
+            end
+          end
+
+          @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
+          @presented_options.count - index_of_active_option
+        end
+
+        def distance_from_start_to_selection
+          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
+          @presented_options.push(["...", nil]) if @presented_options.last.last
+        end
+
+        def ensure_first_item_is_continuation_marker
+          @presented_options.unshift(["...", nil]) if @presented_options.first.last
+        end
+
+        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
+
+          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? or 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]
+
+            padding = ' ' * (max_num_length - num.to_s.length)
+            message = "  #{num}#{num ? '.' : ' '}#{padding}"
+
+            format = "%s"
+            # If multiple, bold only selected. If not multiple, bold everything
+            format = "{{bold:#{format}}}" if !@multiple || is_chosen
+            format = "{{cyan:#{format}}}" if @multiple && is_chosen && num != @active
+            format = " #{format}"
+
+            message += sprintf(format, CHECKBOX_ICON[is_chosen]) if @multiple && num && num > 0
+            message += format_choice(format, choice)
+
+            if num == @active
+
+              color = (filtering? or 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)
+            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| sprintf(format, l) + eol }
+          lines.join("\n")
+        end
+      end
+    end
+  end
+end