@shopify/cli-kit 3.39.0 → 3.40.1

package/assets/cli-ruby/vendor/deps/cli-kit/lib/cli/kit/system.rb

@@ -0,0 +1,243 @@
+require 'cli/kit'
+
+require 'open3'
+require 'English'
+
+module CLI
+  module Kit
+    module System
+      SUDO_PROMPT = CLI::UI.fmt("{{info:(sudo)}} Password: ")
+      class << self
+        # Ask for sudo access with a message explaning the need for it
+        # Will make subsequent commands capable of running with sudo for a period of time
+        #
+        # #### Parameters
+        # - `msg`: A message telling the user why sudo is needed
+        #
+        # #### Usage
+        # `ctx.sudo_reason("We need to do a thing")`
+        #
+        def sudo_reason(msg)
+          # See if sudo has a cached password
+          %x(env SUDO_ASKPASS=/usr/bin/false sudo -A true)
+          return if $CHILD_STATUS.success?
+          CLI::UI.with_frame_color(:blue) do
+            puts(CLI::UI.fmt("{{i}} #{msg}"))
+          end
+        end
+
+        # Execute a command in the user's environment
+        # This is meant to be largely equivalent to backticks, only with the env passed in.
+        # Captures the results of the command without output to the console
+        #
+        # #### Parameters
+        # - `*a`: A splat of arguments evaluated as a command. (e.g. `'rm', folder` is equivalent to `rm #{folder}`)
+        # - `sudo`: If truthy, run this command with sudo. If String, pass to `sudo_reason`
+        # - `env`: process environment with which to execute this command
+        # - `**kwargs`: additional arguments to pass to Open3.capture2
+        #
+        # #### Returns
+        # - `output`: output (STDOUT) of the command execution
+        # - `status`: boolean success status of the command execution
+        #
+        # #### Usage
+        # `out, stat = CLI::Kit::System.capture2('ls', 'a_folder')`
+        #
+        def capture2(*a, sudo: false, env: ENV, **kwargs)
+          delegate_open3(*a, sudo: sudo, env: env, method: :capture2, **kwargs)
+        end
+
+        # Execute a command in the user's environment
+        # This is meant to be largely equivalent to backticks, only with the env passed in.
+        # Captures the results of the command without output to the console
+        #
+        # #### Parameters
+        # - `*a`: A splat of arguments evaluated as a command. (e.g. `'rm', folder` is equivalent to `rm #{folder}`)
+        # - `sudo`: If truthy, run this command with sudo. If String, pass to `sudo_reason`
+        # - `env`: process environment with which to execute this command
+        # - `**kwargs`: additional arguments to pass to Open3.capture2e
+        #
+        # #### Returns
+        # - `output`: output (STDOUT merged with STDERR) of the command execution
+        # - `status`: boolean success status of the command execution
+        #
+        # #### Usage
+        # `out_and_err, stat = CLI::Kit::System.capture2e('ls', 'a_folder')`
+        #
+        def capture2e(*a, sudo: false, env: ENV, **kwargs)
+          delegate_open3(*a, sudo: sudo, env: env, method: :capture2e, **kwargs)
+        end
+
+        # Execute a command in the user's environment
+        # This is meant to be largely equivalent to backticks, only with the env passed in.
+        # Captures the results of the command without output to the console
+        #
+        # #### Parameters
+        # - `*a`: A splat of arguments evaluated as a command. (e.g. `'rm', folder` is equivalent to `rm #{folder}`)
+        # - `sudo`: If truthy, run this command with sudo. If String, pass to `sudo_reason`
+        # - `env`: process environment with which to execute this command
+        # - `**kwargs`: additional arguments to pass to Open3.capture3
+        #
+        # #### Returns
+        # - `output`: STDOUT of the command execution
+        # - `error`: STDERR of the command execution
+        # - `status`: boolean success status of the command execution
+        #
+        # #### Usage
+        # `out, err, stat = CLI::Kit::System.capture3('ls', 'a_folder')`
+        #
+        def capture3(*a, sudo: false, env: ENV, **kwargs)
+          delegate_open3(*a, sudo: sudo, env: env, method: :capture3, **kwargs)
+        end
+
+        def popen2(*a, sudo: false, env: ENV, **kwargs, &block)
+          delegate_open3(*a, sudo: sudo, env: env, method: :popen2, **kwargs, &block)
+        end
+
+        def popen2e(*a, sudo: false, env: ENV, **kwargs, &block)
+          delegate_open3(*a, sudo: sudo, env: env, method: :popen2e, **kwargs, &block)
+        end
+
+        def popen3(*a, sudo: false, env: ENV, **kwargs, &block)
+          delegate_open3(*a, sudo: sudo, env: env, method: :popen3, **kwargs, &block)
+        end
+
+        # Execute a command in the user's environment
+        # Outputs result of the command without capturing it
+        #
+        # #### Parameters
+        # - `*a`: A splat of arguments evaluated as a command. (e.g. `'rm', folder` is equivalent to `rm #{folder}`)
+        # - `sudo`: If truthy, run this command with sudo. If String, pass to `sudo_reason`
+        # - `env`: process environment with which to execute this command
+        # - `**kwargs`: additional keyword arguments to pass to Process.spawn
+        #
+        # #### Returns
+        # - `status`: The `Process:Status` result for the command execution
+        #
+        # #### Usage
+        # `stat = CLI::Kit::System.system('ls', 'a_folder')`
+        #
+        def system(*a, sudo: false, env: ENV, **kwargs)
+          a = apply_sudo(*a, sudo)
+
+          out_r, out_w = IO.pipe
+          err_r, err_w = IO.pipe
+          in_stream = STDIN.closed? ? :close : STDIN
+          pid = Process.spawn(env, *resolve_path(a, env), 0 => in_stream, :out => out_w, :err => err_w, **kwargs)
+          out_w.close
+          err_w.close
+
+          handlers = if block_given?
+            { out_r => ->(data) { yield(data.force_encoding(Encoding::UTF_8), '') },
+              err_r => ->(data) { yield('', data.force_encoding(Encoding::UTF_8)) } }
+          else
+            { out_r => ->(data) { STDOUT.write(data) },
+              err_r => ->(data) { STDOUT.write(data) } }
+          end
+
+          previous_trailing = Hash.new('')
+          loop do
+            ios = [err_r, out_r].reject(&:closed?)
+            break if ios.empty?
+
+            readers, = IO.select(ios)
+            readers.each do |io|
+              data, trailing = split_partial_characters(io.readpartial(4096))
+              handlers[io].call(previous_trailing[io] + data)
+              previous_trailing[io] = trailing
+            rescue IOError
+              io.close
+            end
+          end
+
+          Process.wait(pid)
+          $CHILD_STATUS
+        end
+
+        # Split off trailing partial UTF-8 Characters. UTF-8 Multibyte characters start with a 11xxxxxx byte that tells
+        # how many following bytes are part of this character, followed by some number of 10xxxxxx bytes.  This simple
+        # algorithm will split off a whole trailing multi-byte character.
+        def split_partial_characters(data)
+          last_byte = data.getbyte(-1)
+          return [data, ''] if (last_byte & 0b1000_0000).zero?
+
+          # UTF-8 is up to 6 characters per rune, so we could never want to trim more than that, and we want to avoid
+          # allocating an array for the whole of data with bytes
+          min_bound = -[6, data.bytesize].min
+          final_bytes = data.byteslice(min_bound..-1).bytes
+          partial_character_sub_index = final_bytes.rindex { |byte| byte & 0b1100_0000 == 0b1100_0000 }
+          # Bail out for non UTF-8
+          return [data, ''] unless partial_character_sub_index
+          partial_character_index = min_bound + partial_character_sub_index
+
+          [data.byteslice(0...partial_character_index), data.byteslice(partial_character_index..-1)]
+        end
+
+        def os
+          @current_os ||= case RbConfig::CONFIG['host_os']
+          when /darwin/ then :mac
+          when /linux/ then :linux
+          else
+            if RUBY_PLATFORM !~ /cygwin/ && ENV['OS'] == 'Windows_NT'
+              :windows
+            else
+              raise "Could not determine OS from host_os #{RbConfig::CONFIG["host_os"]}"
+            end
+          end
+        end
+
+        private
+
+        def apply_sudo(*a, sudo)
+          a.unshift('sudo', '-S', '-p', SUDO_PROMPT, '--') if sudo
+          sudo_reason(sudo) if sudo.is_a?(String)
+          a
+        end
+
+        def delegate_open3(*a, sudo: raise, env: raise, method: raise, **kwargs, &block)
+          a = apply_sudo(*a, sudo)
+          Open3.send(method, env, *resolve_path(a, env), **kwargs, &block)
+        rescue Errno::EINTR
+          raise(Errno::EINTR, "command interrupted: #{a.join(' ')}")
+        end
+
+        # Ruby resolves the program to execute using its own PATH, but we want it to
+        # use the provided one, so we ensure ruby chooses to spawn a shell, which will
+        # parse our command and properly spawn our target using the provided environment.
+        #
+        # This is important because dev clobbers its own environment such that ruby
+        # means /usr/bin/ruby, but we want it to select the ruby targeted by the active
+        # project.
+        #
+        # See https://github.com/Shopify/dev/pull/625 for more details.
+        def resolve_path(a, env)
+          # If only one argument was provided, make sure it's interpreted by a shell.
+          if a.size == 1
+            if os == :windows
+              return ["break && " + a[0]]
+            else
+              return ["true ; " + a[0]]
+            end
+          end
+          return a if a.first.include?('/')
+
+          item = which(a.first, env)
+          a[0] = item if item
+          a
+        end
+
+        def which(cmd, env)
+          exts = (os == :windows && env['PATHEXT']&.split(';')) || ['']
+          env.fetch('PATH', '').split(File::PATH_SEPARATOR).each do |path|
+            exts.each do |ext|
+              exe = File.join(path, "#{cmd}#{ext}")
+              return exe if File.executable?(exe) && !File.directory?(exe)
+            end
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/vendor/deps/cli-kit/lib/cli/kit/util.rb

@@ -0,0 +1,193 @@
+module CLI
+  module Kit
+    module Util
+      class << self
+        def snake_case(camel_case, seperator = "_")
+          camel_case.to_s # MyCoolThing::MyAPIModule
+            .gsub(/::/, '/') # MyCoolThing/MyAPIModule
+            .gsub(/([A-Z]+)([A-Z][a-z])/, "\\1#{seperator}\\2") # MyCoolThing::MyAPI_Module
+            .gsub(/([a-z\d])([A-Z])/, "\\1#{seperator}\\2") # My_Cool_Thing::My_API_Module
+            .downcase # my_cool_thing/my_api_module
+        end
+
+        def dash_case(camel_case)
+          snake_case(camel_case, '-')
+        end
+
+        # The following methods is taken from activesupport
+        # All credit for this method goes to the original authors.
+        # https://github.com/rails/rails/blob/d66e7835bea9505f7003e5038aa19b6ea95ceea1/activesupport/lib/active_support/core_ext/string/strip.rb
+        #
+        # Copyright (c) 2005-2018 David Heinemeier Hansson
+        #
+        # Permission is hereby granted, free of charge, to any person obtaining
+        # a copy of this software and associated documentation files (the
+        # "Software"), to deal in the Software without restriction, including
+        # without limitation the rights to use, copy, modify, merge, publish,
+        # distribute, sublicense, and/or sell copies of the Software, and to
+        # permit persons to whom the Software is furnished to do so, subject to
+        # the following conditions:
+        #
+        # The above copyright notice and this permission notice shall be
+        # included in all copies or substantial portions of the Software.
+        #
+        # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+        # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+        # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+        # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+        # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+        # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+        # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+        #
+        # Strips indentation by removing the amount of leading whitespace in the least indented
+        # non-empty line in the whole string
+        #
+        def strip_heredoc(str)
+          str.gsub(/^#{str.scan(/^[ \t]*(?=\S)/).min}/, "".freeze)
+        end
+
+        # Joins an array with commas and "and", using the Oxford comma.
+        def english_join(array)
+          return "" if array.nil?
+          return array.join(" and ") if array.length < 3
+
+          "#{array[0..-2].join(', ')}, and #{array[-1]}"
+        end
+
+        # Execute a block within the context of a variable enviroment
+        #
+        def with_environment(environment, value)
+          return yield unless environment
+
+          old_env = ENV[environment]
+          begin
+            ENV[environment] = value
+            yield
+          ensure
+            old_env ? ENV[environment] = old_env : ENV.delete(environment)
+          end
+        end
+
+        # Converts an integer representing bytes into a human readable format
+        #
+        def to_filesize(bytes, precision: 2, space: false)
+          to_si_scale(bytes, 'B', precision: precision, space: space, factor: 1024)
+        end
+
+        # Converts a number to a human readable format on the SI scale
+        #
+        def to_si_scale(number, unit = '', factor: 1000, precision: 2, space: false)
+          raise ArgumentError, "factor should only be 1000 or 1024" unless [1000, 1024].include?(factor)
+
+          small_scale = %w(m µ n p f a z y)
+          big_scale = %w(k M G T P E Z Y)
+          negative = number < 0
+          number = number.abs.to_f
+
+          if number == 0 || number.between?(1, factor)
+            prefix = ""
+            scale = 0
+          else
+            scale = Math.log(number, factor).floor
+            if number < 1
+              index = [-scale - 1, small_scale.length].min
+              scale = -(index + 1)
+              prefix = small_scale[index]
+            else
+              index = [scale - 1, big_scale.length].min
+              scale = index + 1
+              prefix = big_scale[index]
+            end
+          end
+
+          divider = (factor**scale)
+          fnum = (number / divider).round(precision)
+
+          # Trim useless decimal
+          fnum = fnum.to_i if (fnum.to_i.to_f * divider) == number
+
+          fnum = -fnum if negative
+          prefix = " " + prefix if space
+
+          "#{fnum}#{prefix}#{unit}"
+        end
+
+        # Dir.chdir, when invoked in block form, complains when we call chdir
+        # again recursively. There's no apparent good reason for this, so we
+        # simply implement our own block form of Dir.chdir here.
+        def with_dir(dir)
+          prev = Dir.pwd
+          Dir.chdir(dir)
+          yield
+        ensure
+          Dir.chdir(prev)
+        end
+
+        def with_tmp_dir
+          require 'fileutils'
+          dir = Dir.mktmpdir
+          with_dir(dir) do
+            yield(dir)
+          end
+        ensure
+          FileUtils.remove_entry(dir)
+        end
+
+        # Standard way of checking for CI / Tests
+        def testing?
+          ci? || ENV['TEST']
+        end
+
+        # Set only in IntegrationTest#session; indicates that the process was
+        # called by `session.execute` from an IntegrationTest subclass.
+        def integration_test_session?
+          ENV['INTEGRATION_TEST_SESSION']
+        end
+
+        # Standard way of checking for CI
+        def ci?
+          ENV['CI']
+        end
+
+        # Must call retry_after on the result in order to execute the block
+        #
+        # Example usage:
+        #
+        # CLI::Kit::Util.begin do
+        #   might_raise_if_costly_prep_not_done()
+        # end.retry_after(ExpectedError) do
+        #   costly_prep()
+        # end
+        def begin(&block_that_might_raise)
+          Retrier.new(block_that_might_raise)
+        end
+      end
+
+      class Retrier
+        def initialize(block_that_might_raise)
+          @block_that_might_raise = block_that_might_raise
+        end
+
+        def retry_after(exception = StandardError, retries: 1, only: nil, &before_retry)
+          @block_that_might_raise.call
+        rescue exception => e
+          should_retry = only ? only.call : true
+  
+          raise unless should_retry
+
+          raise if (retries -= 1) < 0
+          if before_retry
+            if before_retry.arity == 0
+              yield
+            else
+              yield e
+            end
+          end
+          retry
+        end
+      end
+
+      private_constant :Retrier
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+module CLI
+  module Kit
+    VERSION = "3.3.0"
+  end
+end

package/assets/cli-ruby/vendor/deps/cli-kit/lib/cli/kit.rb

@@ -0,0 +1,60 @@
+require 'cli/ui'
+require 'cli/kit/ruby_backports/enumerable'
+
+module CLI
+  module Kit
+    autoload :Autocall,        'cli/kit/autocall'
+    autoload :BaseCommand,     'cli/kit/base_command'
+    autoload :CommandRegistry, 'cli/kit/command_registry'
+    autoload :Config,          'cli/kit/config'
+    autoload :ErrorHandler,    'cli/kit/error_handler'
+    autoload :Executor,        'cli/kit/executor'
+    autoload :Ini,             'cli/kit/ini'
+    autoload :Levenshtein,     'cli/kit/levenshtein'
+    autoload :Logger,          'cli/kit/logger'
+    autoload :Resolver,        'cli/kit/resolver'
+    autoload :Support,         'cli/kit/support'
+    autoload :System,          'cli/kit/system'
+    autoload :Util,            'cli/kit/util'
+
+    EXIT_FAILURE_BUT_NOT_BUG = 30
+    EXIT_BUG                 = 1
+    EXIT_SUCCESS             = 0
+
+    # Abort, Bug, AbortSilent, and BugSilent are four ways of immediately bailing
+    # on command-line execution when an unrecoverable error occurs.
+    #
+    # Note that these don't inherit from StandardError, and so are not caught by
+    # a bare `rescue => e`.
+    #
+    # * Abort prints its message in red and exits 1;
+    # * Bug additionally submits the exception to Bugsnag;
+    # * AbortSilent and BugSilent do the same as above, but do not print
+    #     messages before exiting.
+    #
+    # Treat these like panic() in Go:
+    #   * Don't rescue them. Use a different Exception class if you plan to recover;
+    #   * Provide a useful message, since it will be presented in brief to the
+    #       user, and will be useful for debugging.
+    #   * Avoid using it if it does actually make sense to recover from an error.
+    #
+    # Additionally:
+    #   * Do not subclass these.
+    #   * Only use AbortSilent or BugSilent if you prefer to print a more
+    #       contextualized error than Abort or Bug would present to the user.
+    #   * In general, don't attach a message to AbortSilent or BugSilent.
+    #   * Never raise GenericAbort directly.
+    #   * Think carefully about whether Abort or Bug is more appropriate. Is this
+    #       a bug in the tool? Or is it just user error, transient network
+    #       failure, etc.?
+    #   * One case where it's ok to rescue (cli-kit internals or tests aside):
+    #       1. rescue Abort or Bug
+    #       2. Print a contextualized error message
+    #       3. Re-raise AbortSilent or BugSilent respectively.
+    GenericAbort = Class.new(Exception) # rubocop:disable Lint/InheritException
+    Abort        = Class.new(GenericAbort)
+    Bug          = Class.new(GenericAbort)
+    BugSilent    = Class.new(GenericAbort)
+    AbortSilent  = Class.new(GenericAbort)
+  end
+end

package/assets/cli-ruby/vendor/deps/cli-ui/REVISION

@@ -0,0 +1 @@
+168ce68b31d8436b2b222d6f063e5c7225785bd4

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

@@ -0,0 +1,157 @@
+require 'cli/ui'
+
+module CLI
+  module UI
+    module ANSI
+      ESC = "\x1b"
+
+      # ANSI escape sequences (like \x1b[31m) have zero width.
+      # when calculating the padding width, we must exclude them.
+      # This also implements a basic version of utf8 character width calculation like
+      # we could get for real from something like utf8proc.
+      #
+      def self.printing_width(str)
+        zwj = false
+        strip_codes(str).codepoints.reduce(0) do |acc, cp|
+          if zwj
+            zwj = false
+            next acc
+          end
+          case cp
+          when 0x200d # zero-width joiner
+            zwj = true
+            acc
+          when "\n"
+            acc
+          else
+            acc + 1
+          end
+        end
+      end
+
+      # Strips ANSI codes from a str
+      #
+      # ==== Attributes
+      #
+      # - +str+ - The string from which to strip codes
+      #
+      def self.strip_codes(str)
+        str.gsub(/\x1b\[[\d;]+[A-z]|\r/, '')
+      end
+
+      # Returns an ANSI control sequence
+      #
+      # ==== Attributes
+      #
+      # - +args+ - Argument to pass to the ANSI control sequence
+      # - +cmd+ - ANSI control sequence Command
+      #
+      def self.control(args, cmd)
+        ESC + "[" + args + cmd
+      end
+
+      # https://en.wikipedia.org/wiki/ANSI_escape_code#graphics
+      def self.sgr(params)
+        control(params.to_s, 'm')
+      end
+
+      # Cursor Movement
+
+      # Move the cursor up n lines
+      #
+      # ==== Attributes
+      #
+      # * +n+ - number of lines by which to move the cursor up
+      #
+      def self.cursor_up(n = 1)
+        return '' if n.zero?
+        control(n.to_s, 'A')
+      end
+
+      # Move the cursor down n lines
+      #
+      # ==== Attributes
+      #
+      # * +n+ - number of lines by which to move the cursor down
+      #
+      def self.cursor_down(n = 1)
+        return '' if n.zero?
+        control(n.to_s, 'B')
+      end
+
+      # Move the cursor forward n columns
+      #
+      # ==== Attributes
+      #
+      # * +n+ - number of columns by which to move the cursor forward
+      #
+      def self.cursor_forward(n = 1)
+        return '' if n.zero?
+        control(n.to_s, 'C')
+      end
+
+      # Move the cursor back n columns
+      #
+      # ==== Attributes
+      #
+      # * +n+ - number of columns by which to move the cursor back
+      #
+      def self.cursor_back(n = 1)
+        return '' if n.zero?
+        control(n.to_s, 'D')
+      end
+
+      # Move the cursor to a specific column
+      #
+      # ==== Attributes
+      #
+      # * +n+ - The column to move to
+      #
+      def self.cursor_horizontal_absolute(n = 1)
+        cmd = control(n.to_s, 'G')
+        cmd += control('1', 'D') if CLI::UI::OS.current.shift_cursor_on_line_reset?
+        cmd
+      end
+
+      # Show the cursor
+      #
+      def self.show_cursor
+        control('', "?25h")
+      end
+
+      # Hide the cursor
+      #
+      def self.hide_cursor
+        control('', "?25l")
+      end
+
+      # Save the cursor position
+      #
+      def self.cursor_save
+        control('', 's')
+      end
+
+      # Restore the saved cursor position
+      #
+      def self.cursor_restore
+        control('', 'u')
+      end
+
+      # Move to the next line
+      #
+      def self.next_line
+        cursor_down + cursor_horizontal_absolute
+      end
+
+      # Move to the previous line
+      #
+      def self.previous_line
+        cursor_up + cursor_horizontal_absolute
+      end
+
+      def self.clear_to_end_of_line
+        control('', 'K')
+      end
+    end
+  end
+end