@shopify/cli-kit 3.38.0 → 3.40.0

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

@@ -0,0 +1,82 @@
+# Copyright (c) 2014-2016 Yuki Nishijima
+
+# MIT License
+
+# 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.
+
+module CLI
+  module Kit
+    module Levenshtein
+      # This code is based directly on the Text gem implementation
+      # Copyright (c) 2006-2013 Paul Battley, Michael Neumann, Tim Fletcher.
+      #
+      # Returns a value representing the "cost" of transforming str1 into str2
+      def distance(str1, str2)
+        n = str1.length
+        m = str2.length
+        return m if n.zero?
+        return n if m.zero?
+
+        d = (0..m).to_a
+        x = nil
+
+        # to avoid duplicating an enumerable object, create it outside of the loop
+        str2_codepoints = str2.codepoints
+
+        str1.each_codepoint.with_index(1) do |char1, i|
+          j = 0
+          while j < m
+            cost = char1 == str2_codepoints[j] ? 0 : 1
+            x = min3(
+              d[j + 1] + 1, # insertion
+              i + 1,      # deletion
+              d[j] + cost # substitution
+            )
+            d[j] = i
+            i = x
+
+            j += 1
+          end
+          d[m] = x
+        end
+
+        x
+      end
+      module_function :distance
+
+      private
+
+      # detects the minimum value out of three arguments. This method is
+      # faster than `[a, b, c].min` and puts less GC pressure.
+      # See https://github.com/yuki24/did_you_mean/pull/1 for a performance
+      # benchmark.
+      def min3(a, b, c)
+        if a < b && a < c
+          a
+        elsif b < c
+          b
+        else
+          c
+        end
+      end
+      module_function :min3
+    end
+  end
+end

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

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

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

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

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

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