@shopify/cli-kit 3.39.0 → 3.40.1

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

@@ -0,0 +1,84 @@
+require 'cli/ui'
+
+module CLI
+  module UI
+    class Color
+      attr_reader :sgr, :name, :code
+
+      # Creates a new color mapping
+      # Signatures can be found here:
+      # https://en.wikipedia.org/wiki/ANSI_escape_code#Colors
+      #
+      # ==== Attributes
+      #
+      # * +sgr+ - The color signature
+      # * +name+ - The name of the color
+      #
+      def initialize(sgr, name)
+        @sgr  = sgr
+        @code = CLI::UI::ANSI.sgr(sgr)
+        @name = name
+      end
+
+      RED     = new('31', :red)
+      GREEN   = new('32', :green)
+      YELLOW  = new('33', :yellow)
+      # default blue is low-contrast against black in some default terminal color scheme
+      BLUE    = new('94', :blue) # 9x = high-intensity fg color x
+      MAGENTA = new('35', :magenta)
+      CYAN    = new('36', :cyan)
+      RESET   = new('0',  :reset)
+      BOLD    = new('1',  :bold)
+      WHITE   = new('97', :white)
+
+      # 240 is very dark gray; 255 is very light gray. 244 is somewhat dark.
+      GRAY = new('38;5;244', :grey)
+
+      MAP = {
+        red: RED,
+        green: GREEN,
+        yellow: YELLOW,
+        blue: BLUE,
+        magenta: MAGENTA,
+        cyan: CYAN,
+        reset: RESET,
+        bold: BOLD,
+        gray: GRAY,
+      }.freeze
+
+      class InvalidColorName < ArgumentError
+        def initialize(name)
+          super
+          @name = name
+        end
+
+        def message
+          keys = Color.available.map(&:inspect).join(',')
+          "invalid color: #{@name.inspect} " \
+            "-- must be one of CLI::UI::Color.available (#{keys})"
+        end
+      end
+
+      # Looks up a color code by name
+      #
+      # ==== Raises
+      # Raises a InvalidColorName if the color is not available
+      # You likely need to add it to the +MAP+ or you made a typo
+      #
+      # ==== Returns
+      # Returns a color code
+      #
+      def self.lookup(name)
+        MAP.fetch(name)
+      rescue KeyError
+        raise InvalidColorName, name
+      end
+
+      # All available colors by name
+      #
+      def self.available
+        MAP.keys
+      end
+    end
+  end
+end

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

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+require('cli/ui')
+require('strscan')
+
+module CLI
+  module UI
+    class Formatter
+      # Available mappings of formattings
+      # To use any of them, you can use {{<key>:<string>}}
+      # There are presentational (colours and formatters)
+      # and semantic (error, info, command) formatters available
+      #
+      SGR_MAP = {
+        # presentational
+        'red' => '31',
+        'green' => '32',
+        'yellow' => '33',
+        # default blue is low-contrast against black in some default terminal color scheme
+        'blue' => '94', # 9x = high-intensity fg color x
+        'magenta' => '35',
+        'cyan' => '36',
+        'bold' => '1',
+        'italic' => '3',
+        'underline' => '4',
+        'reset' => '0',
+
+        # semantic
+        'error' => '31', # red
+        'success' => '32', # success
+        'warning' => '33', # yellow
+        'info' => '94', # bright blue
+        'command' => '36', # cyan
+      }.freeze
+
+      BEGIN_EXPR = '{{'
+      END_EXPR   = '}}'
+
+      SCAN_WIDGET   = %r[@widget/(?<handle>\w+):(?<args>.*?)}}]
+      SCAN_FUNCNAME = /\w+:/
+      SCAN_GLYPH    = /.}}/
+      SCAN_BODY     = %r{
+        .*?
+        (
+          #{BEGIN_EXPR} |
+          #{END_EXPR}   |
+          \z
+        )
+      }mx
+
+      DISCARD_BRACES = 0..-3
+
+      LITERAL_BRACES = :__literal_braces__
+
+      class FormatError < StandardError
+        attr_accessor :input, :index
+
+        def initialize(message = nil, input = nil, index = nil)
+          super(message)
+          @input = input
+          @index = index
+        end
+      end
+
+      # Initialize a formatter with text.
+      #
+      # ===== Attributes
+      #
+      # * +text+ - the text to format
+      #
+      def initialize(text)
+        @text = text
+      end
+
+      # Format the text using a map.
+      #
+      # ===== Attributes
+      #
+      # * +sgr_map+ - the mapping of the formattings. Defaults to +SGR_MAP+
+      #
+      # ===== Options
+      #
+      # * +:enable_color+ - enable color output? Default is true unless output is redirected
+      #
+      def format(sgr_map = SGR_MAP, enable_color: CLI::UI.enable_color?)
+        @nodes = []
+        stack = parse_body(StringScanner.new(@text))
+        prev_fmt = nil
+        content = @nodes.each_with_object(+'') do |(text, fmt), str|
+          if prev_fmt != fmt && enable_color
+            text = apply_format(text, fmt, sgr_map)
+          end
+          str << text
+          prev_fmt = fmt
+        end
+
+        stack.reject! { |e| e == LITERAL_BRACES }
+
+        return content unless enable_color
+        return content if stack == prev_fmt
+
+        unless stack.empty? && (@nodes.size.zero? || @nodes.last[1].empty?)
+          content << apply_format('', stack, sgr_map)
+        end
+        content
+      end
+
+      private
+
+      def apply_format(text, fmt, sgr_map)
+        sgr = fmt.each_with_object(+'0') do |name, str|
+          next if name == LITERAL_BRACES
+          begin
+            str << ';' << sgr_map.fetch(name)
+          rescue KeyError
+            raise FormatError.new(
+              "invalid format specifier: #{name}",
+              @text,
+              -1
+            )
+          end
+        end
+        CLI::UI::ANSI.sgr(sgr) + text
+      end
+
+      def parse_expr(sc, stack)
+        if (match = sc.scan(SCAN_GLYPH))
+          glyph_handle = match[0]
+          begin
+            glyph = Glyph.lookup(glyph_handle)
+            emit(glyph.char, [glyph.color.name.to_s])
+          rescue Glyph::InvalidGlyphHandle
+            index = sc.pos - 2 # rewind past '}}'
+            raise FormatError.new(
+              "invalid glyph handle at index #{index}: '#{glyph_handle}'",
+              @text,
+              index
+            )
+          end
+        elsif (match = sc.scan(SCAN_WIDGET))
+          match_data = SCAN_WIDGET.match(match) # Regexp.last_match doesn't work here
+          widget_handle = match_data['handle']
+          begin
+            widget = Widgets.lookup(widget_handle)
+            emit(widget.call(match_data['args']), stack)
+          rescue Widgets::InvalidWidgetHandle
+            index = sc.pos - 2 # rewind past '}}'
+            raise(FormatError.new(
+              "invalid widget handle at index #{index}: '#{widget_handle}'",
+              @text, index,
+            ))
+          end
+        elsif (match = sc.scan(SCAN_FUNCNAME))
+          funcname = match.chop
+          stack.push(funcname)
+        else
+          # We read a {{ but it's not apparently Formatter syntax.
+          # We could error, but it's nicer to just pass through as text.
+          # We do kind of assume that the text will probably have balanced
+          # pairs of {{ }} at least.
+          emit('{{', stack)
+          stack.push(LITERAL_BRACES)
+        end
+        parse_body(sc, stack)
+        stack
+      end
+
+      def parse_body(sc, stack = [])
+        match = sc.scan(SCAN_BODY)
+        if match&.end_with?(BEGIN_EXPR)
+          emit(match[DISCARD_BRACES], stack)
+          parse_expr(sc, stack)
+        elsif match&.end_with?(END_EXPR)
+          emit(match[DISCARD_BRACES], stack)
+          if stack.pop == LITERAL_BRACES
+            emit('}}', stack)
+          end
+          parse_body(sc, stack)
+        elsif match
+          emit(match, stack)
+        else
+          emit(sc.rest, stack)
+        end
+        stack
+      end
+
+      def emit(text, stack)
+        return if text.nil? || text.empty?
+        @nodes << [text, stack.reject { |n| n == LITERAL_BRACES }]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+module CLI
+  module UI
+    module Frame
+      module FrameStack
+        COLOR_ENVVAR = 'CLI_FRAME_STACK'
+        STYLE_ENVVAR = 'CLI_STYLE_STACK'
+
+        class StackItem
+          attr_reader :color, :frame_style
+
+          def initialize(color_name, style_name)
+            @color = CLI::UI.resolve_color(color_name)
+            @frame_style = CLI::UI.resolve_style(style_name)
+          end
+        end
+
+        class << self
+          # Fetch all items off the frame stack
+          def items
+            colors = ENV.fetch(COLOR_ENVVAR, '').split(':').map(&:to_sym)
+            styles = ENV.fetch(STYLE_ENVVAR, '').split(':').map(&:to_sym)
+
+            colors.length.times.map do |i|
+              StackItem.new(colors[i], styles[i] || Frame.frame_style)
+            end
+          end
+
+          # Push a new item onto the frame stack.
+          #
+          # Either an item or a :color/:style pair should be pushed onto the stack.
+          #
+          # ==== Attributes
+          #
+          # * +item+ a +StackItem+ to push onto the stack. Defaults to nil
+          #
+          # ==== Options
+          #
+          # * +:color+ the color of the new stack item. Defaults to nil
+          # * +:style+ the style of the new stack item. Defaults to nil
+          #
+          # ==== Raises
+          #
+          # If both an item and a color/style pair are given, raises an +ArgumentError+
+          # If the given item is not a +StackItem+, raises an +ArgumentError+
+          #
+          def push(item = nil, color: nil, style: nil)
+            unless item.nil?
+              unless item.is_a?(StackItem)
+                raise ArgumentError, "item must be a StackItem"
+              end
+
+              unless color.nil? && style.nil?
+                raise ArgumentError, "Must give one of item or color: and style:"
+              end
+            end
+
+            item ||= StackItem.new(color, style)
+
+            curr = items
+            curr << item
+
+            serialize(curr)
+          end
+
+          # Removes and returns the last stack item off the stack
+          def pop
+            curr = items
+            ret = curr.pop
+
+            serialize(curr)
+
+            ret.nil? ? nil : ret
+          end
+
+          private
+
+          # Serializes the item stack into two ENV variables.
+          #
+          # This is done to preserve backward compatibility with earlier versions of cli/ui.
+          # This ensures that any code that relied upon previous stack behavior should continue
+          # to work.
+          def serialize(items)
+            colors = []
+            styles = []
+
+            items.each do |item|
+              colors << item.color.name
+              styles << item.frame_style.name
+            end
+
+            ENV[COLOR_ENVVAR] = colors.join(':')
+            ENV[STYLE_ENVVAR] = styles.join(':')
+          end
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/vendor/deps/cli-ui/lib/cli/ui/frame/frame_style/box.rb

@@ -0,0 +1,166 @@
+module CLI
+  module UI
+    module Frame
+      module FrameStyle
+        module Box
+          extend FrameStyle
+
+          VERTICAL    = '┃'
+          HORIZONTAL  = '━'
+          DIVIDER     = '┣'
+          TOP_LEFT    = '┏'
+          BOTTOM_LEFT = '┗'
+
+          class << self
+            def name
+              'box'
+            end
+
+            def prefix
+              VERTICAL
+            end
+
+            # Draws the "Open" line for this frame style
+            #
+            # ==== Attributes
+            #
+            # * +text+ - (required) the text/title to output in the frame
+            #
+            # ==== Options
+            #
+            # * +:color+ - (required) The color of the frame.
+            #
+            # ==== Output:
+            #
+            #   ┏━━ Open ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+            #
+            def open(text, color:)
+              edge(text, color: color, first: TOP_LEFT)
+            end
+
+            # Draws a "divider" line for the current frame style
+            #
+            # ==== Attributes
+            #
+            # * +text+ - (required) the text/title to output in the frame
+            #
+            # ==== Options
+            #
+            # * +:color+ - (required) The color of the frame.
+            #
+            # ==== Output:
+            #
+            #   ┣━━ Divider ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+            #
+            def divider(text, color:)
+              edge(text, color: color, first: DIVIDER)
+            end
+
+            # Draws the "Close" line for this frame style
+            #
+            # ==== Attributes
+            #
+            # * +text+ - (required) the text/title to output in the frame
+            #
+            # ==== Options
+            #
+            # * +:color+ - (required) The color of the frame.
+            # * +:right_text+ - Text to print at the right of the line. Defaults to nil
+            #
+            # ==== Output:
+            #
+            #   ┗━━ Close ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+            #
+            def close(text, color:, right_text: nil)
+              edge(text, color: color, right_text: right_text, first: BOTTOM_LEFT)
+            end
+
+            private
+
+            def edge(text, color:, first:, right_text: nil)
+              color = CLI::UI.resolve_color(color)
+
+              preamble = +''
+
+              preamble << color.code << first << (HORIZONTAL * 2)
+
+              text ||= ''
+              unless text.empty?
+                preamble << ' ' << CLI::UI.resolve_text("{{#{color.name}:#{text}}}") << ' '
+              end
+
+              termwidth = CLI::UI::Terminal.width
+
+              suffix = +''
+
+              if right_text
+                suffix << ' ' << right_text << ' '
+              end
+
+              preamble_width = CLI::UI::ANSI.printing_width(preamble)
+              preamble_start = Frame.prefix_width
+              # If prefix_width is non-zero, we need to subtract the width of
+              # the final space, since we're going to write over it.
+              preamble_start -= 1 unless preamble_start.zero?
+              preamble_end = preamble_start + preamble_width
+
+              suffix_width = CLI::UI::ANSI.printing_width(suffix)
+              suffix_end   = termwidth - 2
+              suffix_start = suffix_end - suffix_width
+
+              if preamble_end > suffix_start
+                suffix = ''
+                # if preamble_end > termwidth
+                # we *could* truncate it, but let's just let it overflow to the
+                # next line and call it poor usage of this API.
+              end
+
+              o = +''
+
+              # Shopify's CI system supports terminal emulation, but not some of
+              # the fancier features that we normally use to draw frames
+              # extra-reliably, so we fall back to a less foolproof strategy. This
+              # is probably better in general for cases with impoverished terminal
+              # emulators and no active user.
+              unless [0, '', nil].include?(ENV['CI'])
+                linewidth = [0, termwidth - (preamble_end + suffix_width + 1)].max
+
+                o << color.code << preamble
+                o << color.code << (HORIZONTAL * linewidth)
+                o << color.code << suffix
+                o << CLI::UI::Color::RESET.code << "\n"
+                return o
+              end
+
+              # Jumping around the line can cause some unwanted flashes
+              o << CLI::UI::ANSI.hide_cursor
+
+              # reset to column 1 so that things like ^C don't ruin formatting
+              o << "\r"
+
+              # This code will print out a full line with the given preamble and
+              # suffix, as exemplified below.
+              #
+              # preamble_start                         suffix_start
+              # |                 preamble_end         |            suffix_end
+              # |                 |                    |            | termwidth
+              # |                 |                    |            | |
+              # V                 V                    V            V V
+              # --- Preamble text --------------------- suffix text --
+              o << color.code
+              o << print_at_x(preamble_start, HORIZONTAL * (termwidth - preamble_start)) # draw a full line
+              o << print_at_x(preamble_start, preamble)
+              o << color.code
+              o << print_at_x(suffix_start, suffix)
+              o << CLI::UI::Color::RESET.code
+              o << CLI::UI::ANSI.show_cursor
+              o << "\n"
+
+              o
+            end
+          end
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/vendor/deps/cli-ui/lib/cli/ui/frame/frame_style/bracket.rb

@@ -0,0 +1,139 @@
+module CLI
+  module UI
+    module Frame
+      module FrameStyle
+        module Bracket
+          extend FrameStyle
+
+          VERTICAL    = '┃'
+          HORIZONTAL  = '━'
+          DIVIDER     = '┣'
+          TOP_LEFT    = '┏'
+          BOTTOM_LEFT = '┗'
+
+          class << self
+            def name
+              'bracket'
+            end
+
+            def prefix
+              VERTICAL
+            end
+
+            # Draws the "Open" line for this frame style
+            #
+            # ==== Attributes
+            #
+            # * +text+ - (required) the text/title to output in the frame
+            #
+            # ==== Options
+            #
+            # * +:color+ - (required) The color of the frame.
+            #
+            # ==== Output
+            #
+            #   ┏━━ Open
+            #
+            def open(text, color:)
+              edge(text, color: color, first: TOP_LEFT)
+            end
+
+            # Draws a "divider" line for the current frame style
+            #
+            # ==== Attributes
+            #
+            # * +text+ - (required) the text/title to output in the frame
+            #
+            # ==== Options
+            #
+            # * +:color+ - (required) The color of the frame.
+            #
+            # ==== Output:
+            #
+            #   ┣━━ Divider
+            #
+            def divider(text, color:)
+              edge(text, color: color, first: DIVIDER)
+            end
+
+            # Draws the "Close" line for this frame style
+            #
+            # ==== Attributes
+            #
+            # * +text+ - (required) the text/title to output in the frame
+            #
+            # ==== Options
+            #
+            # * +:color+ - (required) The color of the frame.
+            # * +:right_text+ - Text to print at the right of the line. Defaults to nil
+            #
+            # ==== Output:
+            #
+            #   ┗━━ Close
+            #
+            def close(text, color:, right_text: nil)
+              edge(text, color: color, right_text: right_text, first: BOTTOM_LEFT)
+            end
+
+            private
+
+            def edge(text, color:, first:, right_text: nil)
+              color = CLI::UI.resolve_color(color)
+
+              preamble = +''
+
+              preamble << color.code << first << (HORIZONTAL * 2)
+
+              text ||= ''
+              unless text.empty?
+                preamble << ' ' << CLI::UI.resolve_text("{{#{color.name}:#{text}}}") << ' '
+              end
+
+              suffix = +''
+
+              if right_text
+                suffix << ' ' << right_text << ' '
+              end
+
+              o = +''
+
+              # Shopify's CI system supports terminal emulation, but not some of
+              # the fancier features that we normally use to draw frames
+              # extra-reliably, so we fall back to a less foolproof strategy. This
+              # is probably better in general for cases with impoverished terminal
+              # emulators and no active user.
+              unless [0, '', nil].include?(ENV['CI'])
+                o << color.code << preamble
+                o << color.code << suffix
+                o << CLI::UI::Color::RESET.code
+                o << "\n"
+
+                return o
+              end
+
+              preamble_start = Frame.prefix_width
+
+              # If prefix_width is non-zero, we need to subtract the width of
+              # the final space, since we're going to write over it.
+              preamble_start -= 1 unless preamble_start.zero?
+
+              # Prefix_width includes the width of the terminal space, which we
+              # want to remove.  The clamping is done to avoid a negative
+              # preamble start which can occur for the first frame.
+              o << CLI::UI::ANSI.hide_cursor
+
+              # reset to column 1 so that things like ^C don't ruin formatting
+              o << "\r"
+              o << color.code
+              o << print_at_x(preamble_start, preamble + color.code + suffix)
+              o << CLI::UI::Color::RESET.code
+              o << "\n"
+
+              o
+            end
+          end
+        end
+      end
+    end
+  end
+end