@shopify/cli-kit 3.69.3 → 3.70.0

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

@@ -1,82 +0,0 @@
-require 'logger'
-require 'fileutils'
-
-module CLI
-  module Kit
-    class Logger
-      MAX_LOG_SIZE = 5 * 1024 * 1000 # 5MB
-      MAX_NUM_LOGS = 10
-
-      # Constructor for CLI::Kit::Logger
-      #
-      # @param debug_log_file [String] path to the file where debug logs should be stored
-      def initialize(debug_log_file:, env_debug_name: 'DEBUG')
-        FileUtils.mkpath(File.dirname(debug_log_file))
-        @debug_logger = ::Logger.new(debug_log_file, MAX_NUM_LOGS, MAX_LOG_SIZE)
-        @env_debug_name = env_debug_name
-      end
-
-      # Functionally equivalent to Logger#info
-      # Also logs to the debug file, taking into account CLI::UI::StdoutRouter.current_id
-      #
-      # @param msg [String] the message to log
-      # @param debug [Boolean] determines if the debug logger will receive the log (default true)
-      def info(msg, debug: true)
-        $stdout.puts CLI::UI.fmt(msg)
-        @debug_logger.info(format_debug(msg)) if debug
-      end
-
-      # Functionally equivalent to Logger#warn
-      # Also logs to the debug file, taking into account CLI::UI::StdoutRouter.current_id
-      #
-      # @param msg [String] the message to log
-      # @param debug [Boolean] determines if the debug logger will receive the log (default true)
-      def warn(msg, debug: true)
-        $stdout.puts CLI::UI.fmt("{{yellow:#{msg}}}")
-        @debug_logger.warn(format_debug(msg)) if debug
-      end
-
-      # Functionally equivalent to Logger#error
-      # Also logs to the debug file, taking into account CLI::UI::StdoutRouter.current_id
-      #
-      # @param msg [String] the message to log
-      # @param debug [Boolean] determines if the debug logger will receive the log (default true)
-      def error(msg, debug: true)
-        $stderr.puts CLI::UI.fmt("{{red:#{msg}}}")
-        @debug_logger.error(format_debug(msg)) if debug
-      end
-
-      # Functionally equivalent to Logger#fatal
-      # Also logs to the debug file, taking into account CLI::UI::StdoutRouter.current_id
-      #
-      # @param msg [String] the message to log
-      # @param debug [Boolean] determines if the debug logger will receive the log (default true)
-      def fatal(msg, debug: true)
-        $stderr.puts CLI::UI.fmt("{{red:{{bold:Fatal:}} #{msg}}}")
-        @debug_logger.fatal(format_debug(msg)) if debug
-      end
-
-      # Similar to Logger#debug, however will not output to STDOUT unless DEBUG env var is set
-      # Logs to the debug file, taking into account CLI::UI::StdoutRouter.current_id
-      #
-      # @param msg [String] the message to log
-      def debug(msg)
-        $stdout.puts CLI::UI.fmt(msg) if debug?
-        @debug_logger.debug(format_debug(msg))
-      end
-
-      private
-
-      def format_debug(msg)
-        msg = CLI::UI.fmt(msg)
-        return msg unless CLI::UI::StdoutRouter.current_id
-        "[#{CLI::UI::StdoutRouter.current_id[:id]}] #{msg}"
-      end
-
-      def debug?
-        val = ENV[@env_debug_name]
-        val && val != '0' && val != ''
-      end
-    end
-  end
-end

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

@@ -1,60 +0,0 @@
-require 'cli/kit'
-
-module CLI
-  module Kit
-    class Resolver
-      def initialize(tool_name:, command_registry:)
-        @tool_name = tool_name
-        @command_registry = command_registry
-      end
-
-      def call(args)
-        args = args.dup
-        command_name = args.shift
-
-        command, resolved_name = @command_registry.lookup_command(command_name)
-
-        if command.nil?
-          command_not_found(command_name)
-          raise CLI::Kit::AbortSilent # Already output message
-        end
-
-        [command, resolved_name, args]
-      end
-
-      private
-
-      def command_not_found(name)
-        CLI::UI::Frame.open("Command not found", color: :red, timing: false) do
-          $stderr.puts(CLI::UI.fmt("{{command:#{@tool_name} #{name}}} was not found"))
-        end
-
-        cmds = commands_and_aliases
-        if cmds.all? { |cmd| cmd.is_a?(String) }
-          possible_matches = cmds.min_by(2) do |cmd|
-            CLI::Kit::Levenshtein.distance(cmd, name)
-          end
-
-          # We don't want to match against any possible command
-          # so reject anything that is too far away
-          possible_matches.reject! do |possible_match|
-            CLI::Kit::Levenshtein.distance(possible_match, name) > 3
-          end
-
-          # If we have any matches left, tell the user
-          if possible_matches.any?
-            CLI::UI::Frame.open("{{bold:Did you mean?}}", timing: false, color: :blue) do
-              possible_matches.each do |possible_match|
-                $stderr.puts CLI::UI.fmt("{{command:#{@tool_name} #{possible_match}}}")
-              end
-            end
-          end
-        end
-      end
-
-      def commands_and_aliases
-        @command_registry.command_names + @command_registry.aliases.keys
-      end
-    end
-  end
-end

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

@@ -1,6 +0,0 @@
-module Enumerable
-  def min_by(n = nil, &block)
-    return sort_by(&block).first unless n
-    sort_by(&block).first(n)
-  end if instance_method(:min_by).arity == 0
-end

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

@@ -1,244 +0,0 @@
-module CLI
-  module Kit
-    module Support
-      module TestHelper
-        def setup
-          super
-          CLI::Kit::System.reset!
-        end
-
-        def assert_all_commands_run(should_raise: true)
-          errors = CLI::Kit::System.error_message
-          CLI::Kit::System.reset!
-          assert(false, errors) if should_raise && !errors.nil?
-          errors
-        end
-
-        def teardown
-          super
-          assert_all_commands_run
-        end
-
-        module FakeConfig
-          require 'tmpdir'
-          require 'fileutils'
-
-          def setup
-            super
-            @tmpdir = Dir.mktmpdir
-            @prev_xdg = ENV['XDG_CONFIG_HOME']
-            ENV['XDG_CONFIG_HOME'] = @tmpdir
-          end
-
-          def teardown
-            FileUtils.rm_rf(@tmpdir)
-            ENV['XDG_CONFIG_HOME'] = @prev_xdg
-            super
-          end
-        end
-
-        class FakeSuccess
-          def initialize(success)
-            @success = success
-          end
-
-          def success?
-            @success
-          end
-        end
-
-        module ::CLI
-          module Kit
-            module System
-              class << self
-                alias_method :original_system, :system
-                def system(*a, sudo: false, env: {}, **kwargs)
-                  expected_command = expected_command(*a, sudo: sudo, env: env)
-
-                  # In the case of an unexpected command, expected_command will be nil
-                  return FakeSuccess.new(false) if expected_command.nil?
-
-                  # Otherwise handle the command
-                  if expected_command[:allow]
-                    original_system(*a, sudo: sudo, env: env, **kwargs)
-                  else
-                    FakeSuccess.new(expected_command[:success])
-                  end
-                end
-
-                alias_method :original_capture2, :capture2
-                def capture2(*a, sudo: false, env: {}, **kwargs)
-                  expected_command = expected_command(*a, sudo: sudo, env: env)
-
-                  # In the case of an unexpected command, expected_command will be nil
-                  return [nil, FakeSuccess.new(false)] if expected_command.nil?
-
-                  # Otherwise handle the command
-                  if expected_command[:allow]
-                    original_capture2(*a, sudo: sudo, env: env, **kwargs)
-                  else
-                    [
-                      expected_command[:stdout],
-                      FakeSuccess.new(expected_command[:success]),
-                    ]
-                  end
-                end
-
-                alias_method :original_capture2e, :capture2e
-                def capture2e(*a, sudo: false, env: {}, **kwargs)
-                  expected_command = expected_command(*a, sudo: sudo, env: env)
-
-                  # In the case of an unexpected command, expected_command will be nil
-                  return [nil, FakeSuccess.new(false)] if expected_command.nil?
-
-                  # Otherwise handle the command
-                  if expected_command[:allow]
-                    original_capture2ecapture2e(*a, sudo: sudo, env: env, **kwargs)
-                  else
-                    [
-                      expected_command[:stdout],
-                      FakeSuccess.new(expected_command[:success]),
-                    ]
-                  end
-                end
-
-                alias_method :original_capture3, :capture3
-                def capture3(*a, sudo: false, env: {}, **kwargs)
-                  expected_command = expected_command(*a, sudo: sudo, env: env)
-
-                  # In the case of an unexpected command, expected_command will be nil
-                  return [nil, nil, FakeSuccess.new(false)] if expected_command.nil?
-
-                  # Otherwise handle the command
-                  if expected_command[:allow]
-                    original_capture3(*a, sudo: sudo, env: env, **kwargs)
-                  else
-                    [
-                      expected_command[:stdout],
-                      expected_command[:stderr],
-                      FakeSuccess.new(expected_command[:success]),
-                    ]
-                  end
-                end
-
-                # Sets up an expectation for a command and stubs out the call (unless allow is true)
-                #
-                # #### Parameters
-                # `*a` : the command, represented as a splat
-                # `stdout` : stdout to stub the command with (defaults to empty string)
-                # `stderr` : stderr to stub the command with (defaults to empty string)
-                # `allow` : allow determines if the command will be actually run, or stubbed. Defaults to nil (stub)
-                # `success` : success status to stub the command with (Defaults to nil)
-                # `sudo` : expectation of sudo being set or not (defaults to false)
-                # `env` : expectation of env being set or not (defaults to {})
-                #
-                # Note: Must set allow or success
-                #
-                def fake(*a, stdout: "", stderr: "", allow: nil, success: nil, sudo: false, env: {})
-                  raise ArgumentError, "success or allow must be set" if success.nil? && allow.nil?
-
-                  @delegate_open3 ||= {}
-                  @delegate_open3[a.join(' ')] = {
-                    expected: {
-                      sudo: sudo,
-                      env: env,
-                    },
-                    actual: {
-                      sudo: nil,
-                      env: nil,
-                    },
-                    stdout: stdout,
-                    stderr: stderr,
-                    allow: allow,
-                    success: success,
-                    run: false,
-                  }
-                end
-
-                # Resets the faked commands
-                #
-                def reset!
-                  @delegate_open3 = {}
-                end
-
-                # Returns the errors associated to a test run
-                #
-                # #### Returns
-                # `errors` (String) a string representing errors found on this run, nil if none
-                def error_message
-                  errors = {
-                    unexpected: [],
-                    not_run: [],
-                    other: {},
-                  }
-
-                  @delegate_open3.each do |cmd, opts|
-                    if opts[:unexpected]
-                      errors[:unexpected] << cmd
-                    elsif opts[:run]
-                      error = []
-
-                      if opts[:expected][:sudo] != opts[:actual][:sudo]
-                        error << "- sudo was supposed to be #{opts[:expected][:sudo]} but was #{opts[:actual][:sudo]}"
-                      end
-
-                      if opts[:expected][:env] != opts[:actual][:env]
-                        error << "- env was supposed to be #{opts[:expected][:env]} but was #{opts[:actual][:env]}"
-                      end
-
-                      errors[:other][cmd] = error.join("\n") unless error.empty?
-                    else
-                      errors[:not_run] << cmd
-                    end
-                  end
-
-                  final_error = []
-
-                  unless errors[:unexpected].empty?
-                    final_error << CLI::UI.fmt(<<~EOF)
-                      {{bold:Unexpected command invocations:}}
-                      {{command:#{errors[:unexpected].join("\n")}}}
-                    EOF
-                  end
-
-                  unless errors[:not_run].empty?
-                    final_error << CLI::UI.fmt(<<~EOF)
-                      {{bold:Expected commands were not run:}}
-                      {{command:#{errors[:not_run].join("\n")}}}
-                    EOF
-                  end
-
-                  unless errors[:other].empty?
-                    final_error << CLI::UI.fmt(<<~EOF)
-                      {{bold:Commands were not run as expected:}}
-                      #{errors[:other].map { |cmd, msg| "{{command:#{cmd}}}\n#{msg}" }.join("\n\n")}
-                    EOF
-                  end
-
-                  return nil if final_error.empty?
-                  "\n" + final_error.join("\n") # Initial new line for formatting reasons
-                end
-
-                private
-
-                def expected_command(*a, sudo: raise, env: raise)
-                  expected_cmd = @delegate_open3[a.join(' ')]
-
-                  if expected_cmd.nil?
-                    @delegate_open3[a.join(' ')] = { unexpected: true }
-                    return nil
-                  end
-
-                  expected_cmd[:run] = true
-                  expected_cmd[:actual][:sudo] = sudo
-                  expected_cmd[:actual][:env] = env
-                  expected_cmd
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,9 +0,0 @@
-require 'cli/kit'
-
-module CLI
-  module Kit
-    module Support
-      autoload :TestHelper, 'cli/kit/support/test_helper'
-    end
-  end
-end

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

@@ -1,243 +0,0 @@
-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