@shopify/cli 3.69.4 → 3.70.0

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

@@ -1,232 +0,0 @@
-require 'cli/ui'
-require 'stringio'
-
-module CLI
-  module UI
-    module StdoutRouter
-      class << self
-        attr_accessor :duplicate_output_to
-      end
-
-      class Writer
-        def initialize(stream, name)
-          @stream = stream
-          @name = name
-        end
-
-        def write(*args)
-          args = args.map do |str|
-            if auto_frame_inset?
-              str = str.dup # unfreeze
-              str = str.force_encoding(Encoding::UTF_8)
-              apply_line_prefix(str, CLI::UI::Frame.prefix)
-            else
-              @pending_newline = false
-              str
-            end
-          end
-
-          # hook return of false suppresses output.
-          if (hook = Thread.current[:cliui_output_hook])
-            return if hook.call(args.map(&:to_s).join, @name) == false
-          end
-
-          @stream.write_without_cli_ui(*prepend_id(@stream, args))
-          if (dup = StdoutRouter.duplicate_output_to)
-            dup.write(*prepend_id(dup, args))
-          end
-        end
-
-        private
-
-        def prepend_id(stream, args)
-          return args unless prepend_id_for_stream(stream)
-          args.map do |a|
-            next a if a.chomp.empty? # allow new lines to be new lines
-            "[#{Thread.current[:cliui_output_id][:id]}] #{a}"
-          end
-        end
-
-        def prepend_id_for_stream(stream)
-          return false unless Thread.current[:cliui_output_id]
-          return true if Thread.current[:cliui_output_id][:streams].include?(stream)
-          false
-        end
-
-        def auto_frame_inset?
-          !Thread.current[:no_cliui_frame_inset]
-        end
-
-        def apply_line_prefix(str, prefix)
-          return '' if str.empty?
-          prefixed = +''
-          str.force_encoding(Encoding::UTF_8).lines.each do |line|
-            if @pending_newline
-              prefixed << line
-              @pending_newline = false
-            else
-              prefixed << prefix << line
-            end
-          end
-          @pending_newline = !str.end_with?("\n")
-          prefixed
-        end
-      end
-
-      class Capture
-        @m = Mutex.new
-        @active_captures = 0
-        @saved_stdin = nil
-
-        def self.with_stdin_masked
-          @m.synchronize do
-            if @active_captures.zero?
-              @saved_stdin = $stdin
-              $stdin, w = IO.pipe
-              $stdin.close
-              w.close
-            end
-            @active_captures += 1
-          end
-
-          yield
-        ensure
-          @m.synchronize do
-            @active_captures -= 1
-            if @active_captures.zero?
-              $stdin = @saved_stdin
-            end
-          end
-        end
-
-        def initialize(*block_args, with_frame_inset: true, &block)
-          @with_frame_inset = with_frame_inset
-          @block_args = block_args
-          @block = block
-        end
-
-        attr_reader :stdout, :stderr
-
-        def run
-          require 'stringio'
-
-          StdoutRouter.assert_enabled!
-
-          out = StringIO.new
-          err = StringIO.new
-
-          prev_frame_inset = Thread.current[:no_cliui_frame_inset]
-          prev_hook = Thread.current[:cliui_output_hook]
-
-          if Thread.current.respond_to?(:report_on_exception)
-            Thread.current.report_on_exception = false
-          end
-
-          self.class.with_stdin_masked do
-            Thread.current[:no_cliui_frame_inset] = !@with_frame_inset
-            Thread.current[:cliui_output_hook] = ->(data, stream) do
-              case stream
-              when :stdout then out.write(data)
-              when :stderr then err.write(data)
-              else raise
-              end
-              false # suppress writing to terminal
-            end
-
-            begin
-              @block.call(*@block_args)
-            ensure
-              @stdout = out.string
-              @stderr = err.string
-            end
-          end
-        ensure
-          Thread.current[:cliui_output_hook] = prev_hook
-          Thread.current[:no_cliui_frame_inset] = prev_frame_inset
-        end
-      end
-
-      class << self
-        WRITE_WITHOUT_CLI_UI = :write_without_cli_ui
-
-        NotEnabled = Class.new(StandardError)
-
-        def with_id(on_streams:)
-          unless on_streams.is_a?(Array) && on_streams.all? { |s| s.respond_to?(:write) }
-            raise ArgumentError, <<~EOF
-            on_streams must be an array of objects that respond to `write`
-            These do not respond to write
-            #{on_streams.reject { |s| s.respond_to?(:write) }.map.with_index { |s| s.class.to_s }.join("\n")}
-            EOF
-          end
-
-          require 'securerandom'
-          id = format("%05d", rand(10**5))
-          Thread.current[:cliui_output_id] = {
-            id: id,
-            streams: on_streams,
-          }
-          yield(id)
-        ensure
-          Thread.current[:cliui_output_id] = nil
-        end
-
-        def current_id
-          Thread.current[:cliui_output_id]
-        end
-
-        def assert_enabled!
-          raise NotEnabled unless enabled?
-        end
-
-        def with_enabled
-          enable
-          yield
-        ensure
-          disable
-        end
-
-        # TODO: remove this
-        def ensure_activated
-          enable unless enabled?
-        end
-
-        def enable
-          return false if enabled?($stdout) || enabled?($stderr)
-          activate($stdout, :stdout)
-          activate($stderr, :stderr)
-          true
-        end
-
-        def enabled?(stream = $stdout)
-          stream.respond_to?(WRITE_WITHOUT_CLI_UI)
-        end
-
-        def disable
-          return false unless enabled?($stdout) && enabled?($stderr)
-          deactivate($stdout)
-          deactivate($stderr)
-          true
-        end
-
-        private
-
-        def deactivate(stream)
-          sc = stream.singleton_class
-          sc.send(:remove_method, :write)
-          sc.send(:alias_method, :write, WRITE_WITHOUT_CLI_UI)
-        end
-
-        def activate(stream, streamname)
-          writer = StdoutRouter::Writer.new(stream, streamname)
-
-          raise if stream.respond_to?(WRITE_WITHOUT_CLI_UI)
-          stream.singleton_class.send(:alias_method, WRITE_WITHOUT_CLI_UI, :write)
-          stream.define_singleton_method(:write) do |*args|
-            writer.write(*args)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,46 +0,0 @@
-require 'cli/ui'
-require 'io/console'
-
-module CLI
-  module UI
-    module Terminal
-      DEFAULT_WIDTH = 80
-      DEFAULT_HEIGHT = 24
-
-      # Returns the width of the terminal, if possible
-      # Otherwise will return DEFAULT_WIDTH
-      #
-      def self.width
-        winsize[1]
-      end
-
-      # Returns the width of the terminal, if possible
-      # Otherwise, will return DEFAULT_HEIGHT
-      #
-      def self.height
-        winsize[0]
-      end
-
-      def self.winsize
-        @winsize ||= begin
-          winsize = IO.console.winsize
-          setup_winsize_trap
-
-          if winsize.any?(&:zero?)
-            [DEFAULT_HEIGHT, DEFAULT_WIDTH]
-          else
-            winsize
-          end
-        rescue
-          [DEFAULT_HEIGHT, DEFAULT_WIDTH]
-        end
-      end
-
-      def self.setup_winsize_trap
-        @winsize_trap ||= Signal.trap('WINCH') do
-          @winsize = nil
-        end
-      end
-    end
-  end
-end

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

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-require 'cli/ui'
-
-module CLI
-  module UI
-    # Truncater truncates a string to a provided printable width.
-    module Truncater
-      PARSE_ROOT = :root
-      PARSE_ANSI = :ansi
-      PARSE_ESC  = :esc
-      PARSE_ZWJ  = :zwj
-
-      ESC                 = 0x1b
-      LEFT_SQUARE_BRACKET = 0x5b
-      ZWJ                 = 0x200d # emojipedia.org/emoji-zwj-sequences
-      SEMICOLON           = 0x3b
-
-      # EMOJI_RANGE in particular is super inaccurate. This is best-effort.
-      # If you need this to be more accurate, we'll almost certainly accept a
-      # PR improving it.
-      EMOJI_RANGE    = 0x1f300..0x1f5ff
-      NUMERIC_RANGE  = 0x30..0x39
-      LC_ALPHA_RANGE = 0x40..0x5a
-      UC_ALPHA_RANGE = 0x60..0x71
-
-      TRUNCATED = "\x1b[0m…"
-
-      class << self
-        def call(text, printing_width)
-          return text if text.size <= printing_width
-
-          width            = 0
-          mode             = PARSE_ROOT
-          truncation_index = nil
-
-          codepoints = text.codepoints
-          codepoints.each.with_index do |cp, index|
-            case mode
-            when PARSE_ROOT
-              case cp
-              when ESC # non-printable, followed by some more non-printables.
-                mode = PARSE_ESC
-              when ZWJ # non-printable, followed by another non-printable.
-                mode = PARSE_ZWJ
-              else
-                width += width(cp)
-                if width >= printing_width
-                  truncation_index ||= index
-                  # it looks like we could break here but we still want the
-                  # width calculation for the rest of the characters.
-                end
-              end
-            when PARSE_ESC
-              mode = case cp
-              when LEFT_SQUARE_BRACKET
-                PARSE_ANSI
-              else
-                PARSE_ROOT
-              end
-            when PARSE_ANSI
-              # ANSI escape codes preeeetty much have the format of:
-              # \x1b[0-9;]+[A-Za-z]
-              case cp
-              when NUMERIC_RANGE, SEMICOLON
-              when LC_ALPHA_RANGE, UC_ALPHA_RANGE
-                mode = PARSE_ROOT
-              else
-                # unexpected. let's just go back to the root state I guess?
-                mode = PARSE_ROOT
-              end
-            when PARSE_ZWJ
-              # consume any character and consider it as having no width
-              # width(x+ZWJ+y) = width(x).
-              mode = PARSE_ROOT
-            end
-          end
-
-          # Without the `width <= printing_width` check, we truncate
-          # "foo\x1b[0m" for a width of 3, but it should not be truncated.
-          # It's specifically for the case where we decided "Yes, this is the
-          # point at which we'd have to add a truncation!" but it's actually
-          # the end of the string.
-          return text if !truncation_index || width <= printing_width
-
-          codepoints[0...truncation_index].pack("U*") + TRUNCATED
-        end
-
-        private
-
-        def width(printable_codepoint)
-          case printable_codepoint
-          when EMOJI_RANGE
-            2
-          else
-            1
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,5 +0,0 @@
-module CLI
-  module UI
-    VERSION = "1.4.0"
-  end
-end

package/dist/assets/cli-ruby/vendor/deps/cli-ui/lib/cli/ui/widgets/base.rb

@@ -1,27 +0,0 @@
-require('cli/ui')
-
-module CLI
-  module UI
-    module Widgets
-      class Base
-        def self.call(argstring)
-          new(argstring).render
-        end
-
-        def initialize(argstring)
-          pat = self.class.argparse_pattern
-          unless (@match_data = pat.match(argstring))
-            raise(Widgets::InvalidWidgetArguments.new(argstring, pat))
-          end
-          @match_data.names.each do |name|
-            instance_variable_set(:"@#{name}", @match_data[name])
-          end
-        end
-
-        def self.argparse_pattern
-          const_get(:ARGPARSE_PATTERN)
-        end
-      end
-    end
-  end
-end

package/dist/assets/cli-ruby/vendor/deps/cli-ui/lib/cli/ui/widgets/status.rb

@@ -1,61 +0,0 @@
-# frozen-string-literal: true
-require('cli/ui')
-
-module CLI
-  module UI
-    module Widgets
-      class Status < Widgets::Base
-        ARGPARSE_PATTERN = %r{
-          \A (?<succeeded> \d+)
-          :  (?<failed>    \d+)
-          :  (?<working>   \d+)
-          :  (?<pending>   \d+) \z
-        }x # e.g. "1:23:3:404"
-        OPEN  = Color::RESET.code + Color::BOLD.code + '[' + Color::RESET.code
-        CLOSE = Color::RESET.code + Color::BOLD.code + ']' + Color::RESET.code
-        ARROW = Color::RESET.code + Color::GRAY.code + '◂' + Color::RESET.code
-        COMMA = Color::RESET.code + Color::GRAY.code + ',' + Color::RESET.code
-
-        SPINNER_STOPPED = '⠿'
-        EMPTY_SET = '∅'
-
-        def render
-          if zero?(@succeeded) && zero?(@failed) && zero?(@working) && zero?(@pending)
-            Color::RESET.code + Color::BOLD.code + EMPTY_SET + Color::RESET.code
-          else
-            #   [          0✓            ,         2✗          ◂         3⠼           ◂         4⌛︎           ]
-            "#{OPEN}#{succeeded_part}#{COMMA}#{failed_part}#{ARROW}#{working_part}#{ARROW}#{pending_part}#{CLOSE}"
-          end
-        end
-
-        private
-
-        def zero?(num_str)
-          num_str == '0'
-        end
-
-        def colorize_if_nonzero(num_str, rune, color)
-          color = Color::GRAY if zero?(num_str)
-          color.code + num_str + rune
-        end
-
-        def succeeded_part
-          colorize_if_nonzero(@succeeded, Glyph::CHECK.char, Color::GREEN)
-        end
-
-        def failed_part
-          colorize_if_nonzero(@failed, Glyph::X.char, Color::RED)
-        end
-
-        def working_part
-          rune = zero?(@working) ? SPINNER_STOPPED : Spinner.current_rune
-          colorize_if_nonzero(@working, rune, Color::BLUE)
-        end
-
-        def pending_part
-          colorize_if_nonzero(@pending, Glyph::HOURGLASS.char, Color::WHITE)
-        end
-      end
-    end
-  end
-end

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

@@ -1,77 +0,0 @@
-require('cli/ui')
-
-module CLI
-  module UI
-    # Widgets are formatter objects with more custom implementations than the
-    # other features, which all center around formatting text with colours,
-    # etc.
-    #
-    # If you want to extend CLI::UI with your own widgets, you may want to do
-    # something like this:
-    #
-    #   require('cli/ui')
-    #   class MyWidget < CLI::UI::Widgets::Base
-    #     # ...
-    #   end
-    #   CLI::UI::Widgets.register('my-widget') { MyWidget }
-    #   puts(CLI::UI.fmt("{{@widget/my-widget:args}}"))
-    module Widgets
-      MAP = {}
-
-      autoload(:Base, 'cli/ui/widgets/base')
-
-      def self.register(name, &cb)
-        MAP[name] = cb
-      end
-
-      autoload(:Status, 'cli/ui/widgets/status')
-      register('status') { Widgets::Status }
-
-      # Looks up a widget by handle
-      #
-      # ==== Raises
-      # Raises InvalidWidgetHandle if the widget is not available.
-      #
-      # ==== Returns
-      # A callable widget, to be invoked like `.call(argstring)`
-      #
-      def self.lookup(handle)
-        MAP.fetch(handle.to_s).call
-      rescue KeyError, NameError
-        raise(InvalidWidgetHandle, handle)
-      end
-
-      # All available widgets by name
-      #
-      def self.available
-        MAP.keys
-      end
-
-      class InvalidWidgetHandle < ArgumentError
-        def initialize(handle)
-          super
-          @handle = handle
-        end
-
-        def message
-          keys = Widget.available.join(',')
-          "invalid widget handle: #{@handle} " \
-            "-- must be one of CLI::UI::Widgets.available (#{keys})"
-        end
-      end
-
-      class InvalidWidgetArguments < ArgumentError
-        def initialize(argstring, pattern)
-          super
-          @argstring = argstring
-          @pattern   = pattern
-        end
-
-        def message
-          "invalid widget arguments: #{@argstring} " \
-            "-- must match pattern: #{@pattern.inspect}"
-        end
-      end
-    end
-  end
-end

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

@@ -1,56 +0,0 @@
-# coding: utf-8
-require 'cli/ui'
-require 'cli/ui/frame/frame_stack'
-require 'cli/ui/frame/frame_style'
-
-module CLI
-  module UI
-    class Wrap
-      def initialize(input)
-        @input = input
-      end
-
-      def wrap
-        max_width = Terminal.width - Frame.prefix_width
-        width = 0
-        final = []
-        # Create an alternation of format codes of parameter lengths 1-20, since + and {1,n} not allowed in lookbehind
-        format_codes = (1..20).map { |n| /\x1b\[[\d;]{#{n}}m/ }.join('|')
-        codes = ''
-        @input.split(/(?=\s|\x1b\[[\d;]+m|\r)|(?<=\s|#{format_codes})/).each do |token|
-          case token
-          when '\x1B[0?m'
-            codes = ''
-            final << token
-          when /\x1b\[[\d;]+m/
-            codes += token # Track in use format codes so that they are resent after frame coloring
-            final << token
-          when "\n"
-            final << "\n#{codes}"
-            width = 0
-          when /\s/
-            token_width = ANSI.printing_width(token)
-            if width + token_width <= max_width
-              final << token
-              width += token_width
-            else
-              final << "\n#{codes}"
-              width = 0
-            end
-          else
-            token_width = ANSI.printing_width(token)
-            if width + token_width <= max_width
-              final << token
-              width += token_width
-            else
-              final << "\n#{codes}"
-              final << token
-              width = token_width
-            end
-          end
-        end
-        final.join
-      end
-    end
-  end
-end