@shopify/cli-kit 3.69.4 → 3.71.0

package/assets/cli-ruby/vendor/deps/cli-ui/lib/cli/ui/prompt.rb

@@ -1,282 +0,0 @@
-# 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 evaluated 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 && !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,
-              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
-        #
-        # ==== 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)
-          if default && !allow_empty
-            raise(ArgumentError, 'conflicting arguments: default enabled but allow_empty is false')
-          end
-
-          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, default: nil, 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?
-          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, default: default)
-
-          # 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, default: nil)
-          InteractiveOptions.call(options, multiple: multiple, default: default)
-        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 }
-          # 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) }
-            raise
-          end
-        end
-      end
-    end
-  end
-end

package/assets/cli-ruby/vendor/deps/cli-ui/lib/cli/ui/spinner/async.rb

@@ -1,40 +0,0 @@
-module CLI
-  module UI
-    module Spinner
-      class Async
-        # Convenience method for +initialize+
-        #
-        def self.start(title)
-          new(title)
-        end
-
-        # Initializes a new asynchronous spinner with no specific end.
-        # Must call +.stop+ to end the spinner
-        #
-        # ==== Attributes
-        #
-        # * +title+ - Title of the spinner to use
-        #
-        # ==== Example Usage:
-        #
-        #   CLI::UI::Spinner::Async.new('Title')
-        #
-        def initialize(title)
-          require 'thread'
-          sg = CLI::UI::Spinner::SpinGroup.new
-          @m = Mutex.new
-          @cv = ConditionVariable.new
-          sg.add(title) { @m.synchronize { @cv.wait(@m) } }
-          @t = Thread.new { sg.wait }
-        end
-
-        # Stops an asynchronous spinner
-        #
-        def stop
-          @m.synchronize { @cv.signal }
-          @t.value
-        end
-      end
-    end
-  end
-end

package/assets/cli-ruby/vendor/deps/cli-ui/lib/cli/ui/spinner/spin_group.rb

@@ -1,263 +0,0 @@
-module CLI
-  module UI
-    module Spinner
-      class SpinGroup
-        # Initializes a new spin group
-        # This lets you add +Task+ objects to the group to multi-thread work
-        #
-        # ==== Options
-        #
-        # * +:auto_debrief+ - Automatically debrief exceptions? Default to true
-        #
-        # ==== Example Usage
-        #
-        #  spin_group = CLI::UI::SpinGroup.new
-        #  spin_group.add('Title')   { |spinner| sleep 3.0 }
-        #  spin_group.add('Title 2') { |spinner| sleep 3.0; spinner.update_title('New Title'); sleep 3.0 }
-        #  spin_group.wait
-        #
-        # Output:
-        #
-        # https://user-images.githubusercontent.com/3074765/33798558-c452fa26-dce8-11e7-9e90-b4b34df21a46.gif
-        #
-        def initialize(auto_debrief: true)
-          @m = Mutex.new
-          @consumed_lines = 0
-          @tasks = []
-          @auto_debrief = auto_debrief
-          @start = Time.new
-        end
-
-        class Task
-          attr_reader :title, :exception, :success, :stdout, :stderr
-
-          # Initializes a new Task
-          # This is managed entirely internally by +SpinGroup+
-          #
-          # ==== Attributes
-          #
-          # * +title+ - Title of the task
-          # * +block+ - Block for the task, will be provided with an instance of the spinner
-          #
-          def initialize(title, &block)
-            @title = title
-            @always_full_render = title =~ Formatter::SCAN_WIDGET
-            @thread = Thread.new do
-              cap = CLI::UI::StdoutRouter::Capture.new(self, with_frame_inset: false, &block)
-              begin
-                cap.run
-              ensure
-                @stdout = cap.stdout
-                @stderr = cap.stderr
-              end
-            end
-
-            @m = Mutex.new
-            @force_full_render = false
-            @done = false
-            @exception = nil
-            @success   = false
-          end
-
-          # Checks if a task is finished
-          #
-          def check
-            return true if @done
-            return false if @thread.alive?
-
-            @done = true
-            begin
-              status = @thread.join.status
-              @success = (status == false)
-              @success = false if @thread.value == TASK_FAILED
-            rescue => exc
-              @exception = exc
-              @success = false
-            end
-
-            @done
-          end
-
-          # Re-renders the task if required:
-          #
-          # We try to be as lazy as possible in re-rendering the full line. The
-          # spinner rune will change on each render for the most part, but the
-          # body text will rarely have changed. If the body text *has* changed,
-          # we set @force_full_render.
-          #
-          # Further, if the title string includes any CLI::UI::Widgets, we
-          # assume that it may change from render to render, since those
-          # evaluate more dynamically than the rest of our format codes, which
-          # are just text formatters. This is controlled by @always_full_render.
-          #
-          # ==== Attributes
-          #
-          # * +index+ - index of the task
-          # * +force+ - force rerender of the task
-          # * +width+ - current terminal width to format for
-          #
-          def render(index, force = true, width: CLI::UI::Terminal.width)
-            @m.synchronize do
-              if force || @always_full_render || @force_full_render
-                full_render(index, width)
-              else
-                partial_render(index)
-              end
-            ensure
-              @force_full_render = false
-            end
-          end
-
-          # Update the spinner title
-          #
-          # ==== Attributes
-          #
-          # * +title+ - title to change the spinner to
-          #
-          def update_title(new_title)
-            @m.synchronize do
-              @always_full_render = new_title =~ Formatter::SCAN_WIDGET
-              @title = new_title
-              @force_full_render = true
-            end
-          end
-
-          private
-
-          def full_render(index, terminal_width)
-            prefix = inset +
-              glyph(index) +
-              CLI::UI::Color::RESET.code +
-              ' '
-
-            truncation_width = terminal_width - CLI::UI::ANSI.printing_width(prefix)
-
-            prefix +
-              CLI::UI.resolve_text(title, truncate_to: truncation_width) +
-              "\e[K"
-          end
-
-          def partial_render(index)
-            CLI::UI::ANSI.cursor_forward(inset_width) + glyph(index) + CLI::UI::Color::RESET.code
-          end
-
-          def glyph(index)
-            if @done
-              @success ? CLI::UI::Glyph::CHECK.to_s : CLI::UI::Glyph::X.to_s
-            else
-              GLYPHS[index]
-            end
-          end
-
-          def inset
-            @inset ||= CLI::UI::Frame.prefix
-          end
-
-          def inset_width
-            @inset_width ||= CLI::UI::ANSI.printing_width(inset)
-          end
-        end
-
-        # Add a new task
-        #
-        # ==== Attributes
-        #
-        # * +title+ - Title of the task
-        # * +block+ - Block for the task, will be provided with an instance of the spinner
-        #
-        # ==== Example Usage:
-        #   spin_group = CLI::UI::SpinGroup.new
-        #   spin_group.add('Title') { |spinner| sleep 1.0 }
-        #   spin_group.wait
-        #
-        def add(title, &block)
-          @m.synchronize do
-            @tasks << Task.new(title, &block)
-          end
-        end
-
-        # Tells the group you're done adding tasks and to wait for all of them to finish
-        #
-        # ==== Example Usage:
-        #   spin_group = CLI::UI::SpinGroup.new
-        #   spin_group.add('Title') { |spinner| sleep 1.0 }
-        #   spin_group.wait
-        #
-        def wait
-          idx = 0
-
-          loop do
-            all_done = true
-
-            width = CLI::UI::Terminal.width
-
-            @m.synchronize do
-              CLI::UI.raw do
-                @tasks.each.with_index do |task, int_index|
-                  nat_index = int_index + 1
-                  task_done = task.check
-                  all_done = false unless task_done
-
-                  if nat_index > @consumed_lines
-                    print(task.render(idx, true, width: width) + "\n")
-                    @consumed_lines += 1
-                  else
-                    offset = @consumed_lines - int_index
-                    move_to = CLI::UI::ANSI.cursor_up(offset) + "\r"
-                    move_from = "\r" + CLI::UI::ANSI.cursor_down(offset)
-
-                    print(move_to + task.render(idx, idx.zero?, width: width) + move_from)
-                  end
-                end
-              end
-            end
-
-            break if all_done
-
-            idx = (idx + 1) % GLYPHS.size
-            Spinner.index = idx
-            sleep(PERIOD)
-          end
-
-          if @auto_debrief
-            debrief
-          else
-            @m.synchronize do
-              @tasks.all?(&:success)
-            end
-          end
-        end
-
-        # Debriefs failed tasks is +auto_debrief+ is true
-        #
-        def debrief
-          @m.synchronize do
-            @tasks.each do |task|
-              next if task.success
-
-              e = task.exception
-              out = task.stdout
-              err = task.stderr
-
-              CLI::UI::Frame.open('Task Failed: ' + task.title, color: :red, timing: Time.new - @start) do
-                if e
-                  puts "#{e.class}: #{e.message}"
-                  puts "\tfrom #{e.backtrace.join("\n\tfrom ")}"
-                end
-
-                CLI::UI::Frame.divider('STDOUT')
-                out = "(empty)" if out.nil? || out.strip.empty?
-                puts out
-
-                CLI::UI::Frame.divider('STDERR')
-                err = "(empty)" if err.nil? || err.strip.empty?
-                puts err
-              end
-            end
-            @tasks.all?(&:success)
-          end
-        end
-      end
-    end
-  end
-end

package/assets/cli-ruby/vendor/deps/cli-ui/lib/cli/ui/spinner.rb

@@ -1,66 +0,0 @@
-# frozen-string-literal: true
-require 'cli/ui'
-
-module CLI
-  module UI
-    module Spinner
-      autoload :Async,      'cli/ui/spinner/async'
-      autoload :SpinGroup,  'cli/ui/spinner/spin_group'
-
-      PERIOD = 0.1 # seconds
-      TASK_FAILED = :task_failed
-
-      RUNES = CLI::UI::OS.current.supports_emoji? ? %w(⠋ ⠙ ⠹ ⠸ ⠼ ⠴ ⠦ ⠧ ⠇ ⠏).freeze : %w(\\ | / - \\ | / -).freeze
-
-      colors = [CLI::UI::Color::CYAN.code] * (RUNES.size / 2).ceil +
-        [CLI::UI::Color::MAGENTA.code] * (RUNES.size / 2).to_i
-      GLYPHS = colors.zip(RUNES).map(&:join)
-
-      class << self
-        attr_accessor(:index)
-
-        # We use this from CLI::UI::Widgets::Status to render an additional
-        # spinner next to the "working" element. While this global state looks
-        # a bit repulsive at first, it's worth realizing that:
-        #
-        # * It's managed by the SpinGroup#wait method, not individual tasks; and
-        # * It would be complete insanity to run two separate but concurrent SpinGroups.
-        #
-        # While it would be possible to stitch through some connection between
-        # the SpinGroup and the Widgets included in its title, this is simpler
-        # in practice and seems unlikely to cause issues in practice.
-        def current_rune
-          RUNES[index || 0]
-        end
-      end
-
-      # Adds a single spinner
-      # 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
-      #
-      # https://user-images.githubusercontent.com/3074765/33798295-d94fd822-dce3-11e7-819b-43e5502d490e.gif
-      #
-      # ==== Attributes
-      #
-      # * +title+ - Title of the spinner to use
-      #
-      # ==== Options
-      #
-      # * +:auto_debrief+ - Automatically debrief exceptions? Default to true
-      #
-      # ==== Block
-      #
-      # * *spinner+ - Instance of the spinner. Can call +update_title+ to update the user of changes
-      #
-      # ==== Example Usage:
-      #
-      #   CLI::UI::Spinner.spin('Title') { sleep 1.0 }
-      #
-      def self.spin(title, auto_debrief: true, &block)
-        sg = SpinGroup.new(auto_debrief: auto_debrief)
-        sg.add(title, &block)
-        sg.wait
-      end
-    end
-  end
-end