@shopify/cli-kit 3.39.0 → 3.40.0

package/assets/cli-ruby/utilities/docker.rb

@@ -0,0 +1,89 @@
+require "open3"
+require "securerandom"
+
+module Utilities
+  module Docker
+    autoload :Container, "docker/container"
+
+    Error = Class.new(StandardError)
+
+    class << self
+      def create_container(env: {})
+        id = SecureRandom.hex
+        cwd = "/tmp/#{SecureRandom.hex}"
+
+        build_image_if_needed
+
+        _, stderr, stat = Open3.capture3(
+          "docker", "run",
+          "-t", "-d",
+          "--name", id,
+          "--volume", "#{Shellwords.escape(root_dir)}:/usr/src/app",
+          image_tag,
+          "tail", "-f", "/dev/null"
+        )
+        raise Error, stderr unless stat.success?
+
+        _, stderr, stat = Open3.capture3(
+          "docker", "exec",
+          id,
+          "mkdir", "-p", cwd
+        )
+        raise Error, stderr unless stat.success?
+
+        Container.new(
+          id: id,
+          cwd: cwd,
+          env: env
+        )
+      end
+
+      def run_and_rm_container(*args)
+        build_image_if_needed
+        system(
+          "docker", "run",
+          "-t", "--rm",
+          "--volume", "#{Shellwords.escape(root_dir)}:/usr/src/app",
+          image_tag,
+          *args
+        ) || abort
+      end
+
+      private
+
+      def root_dir
+        File.expand_path("..", __dir__)
+      end
+
+      def build_image_if_needed
+        unless image_exists?(image_tag)
+          puts "Rebuilding the Docker image..."
+          _, err, stat = Open3.capture3(
+            "docker", "build", "-t", image_tag, "-f", File.join(root_dir, "Tests.dockerfile"), root_dir
+          )
+          raise Error, err unless stat.success?
+        end
+      end
+
+      def image_tag
+        gemfile_lock_path = File.expand_path("./Gemfile.lock", root_dir)
+        dockerfile_path = File.expand_path("./Tests.dockerfile", root_dir)
+        fingerprintable_strings = [
+          File.read(gemfile_lock_path),
+          File.read(dockerfile_path),
+        ]
+        image_sha = Digest::SHA256.hexdigest(fingerprintable_strings.join("-"))
+        "shopify-cli-#{image_sha}"
+      end
+
+      def image_exists?(tag)
+        _, stat = Open3.capture2e(
+          "docker", "inspect",
+          "--type=image",
+          tag
+        )
+        stat.success?
+      end
+    end
+  end
+end

package/assets/cli-ruby/utilities/utilities.rb

@@ -0,0 +1,6 @@
+$LOAD_PATH.unshift(__dir__) unless $LOAD_PATH.include?(__dir__)
+
+module Utilities
+  autoload :Docker, "docker"
+  autoload :Constants, "constants"
+end

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

@@ -0,0 +1 @@
+6eadd6c7f7fc9217008c2cfb0bc3101cb6cf3b41

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

@@ -0,0 +1,21 @@
+require 'cli/kit'
+
+module CLI
+  module Kit
+    module Autocall
+      def autocall(const, &block)
+        @autocalls ||= {}
+        @autocalls[const] = block
+      end
+
+      def const_missing(const)
+        block = begin
+          @autocalls.fetch(const)
+                rescue KeyError
+                  return super
+        end
+        const_set(const, block.call)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+require 'cli/kit'
+
+module CLI
+  module Kit
+    class BaseCommand
+      def self.defined?
+        true
+      end
+
+      def self.statsd_increment(_metric, **_kwargs)
+        nil
+      end
+
+      def self.statsd_time(_metric, **_kwargs)
+        yield
+      end
+
+      def self.call(args, command_name)
+        cmd = new
+        stats_tags = cmd.stats_tags(args, command_name)
+        begin
+          statsd_increment("cli.command.invoked", tags: stats_tags)
+          statsd_time("cli.command.time", tags: stats_tags) do
+            cmd.call(args, command_name)
+          end
+          statsd_increment("cli.command.success", tags: stats_tags)
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          statsd_increment("cli.command.exception", tags: stats_tags + ["exception:#{e.class}"])
+          raise e
+        end
+      end
+
+      def stats_tags(args, command_name)
+        tags = ["task:#{self.class}"]
+        tags << "command:#{command_name}" if command_name
+        tags << "subcommand:#{args.first}" if args&.first && has_subcommands?
+        tags
+      end
+
+      def call(_args, _command_name)
+        raise NotImplementedError
+      end
+
+      def has_subcommands?
+        false
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+require 'cli/kit'
+
+module CLI
+  module Kit
+    class CommandRegistry
+      attr_reader :commands, :aliases
+
+      module NullContextualResolver
+        def self.command_names
+          []
+        end
+
+        def self.aliases
+          {}
+        end
+
+        def self.command_class(_name)
+          nil
+        end
+      end
+
+      def initialize(default:, contextual_resolver: nil)
+        @commands = {}
+        @aliases  = {}
+        @default = default
+        @contextual_resolver = contextual_resolver || NullContextualResolver
+      end
+
+      def resolved_commands
+        @commands.each_with_object({}) do |(k, v), a|
+          a[k] = resolve_class(v)
+        end
+      end
+
+      def add(const, name)
+        commands[name] = const
+      end
+
+      def lookup_command(name)
+        name = @default if name.to_s.empty?
+        resolve_command(name)
+      end
+
+      def add_alias(from, to)
+        aliases[from] = to unless aliases[from]
+      end
+
+      def command_names
+        @contextual_resolver.command_names + commands.keys
+      end
+
+      def exist?(name)
+        !resolve_command(name).first.nil?
+      end
+
+      private
+
+      def resolve_alias(name)
+        aliases[name] || @contextual_resolver.aliases.fetch(name, name)
+      end
+
+      def resolve_command(name)
+        name = resolve_alias(name)
+        resolve_global_command(name) || \
+          resolve_contextual_command(name) || \
+          [nil, name]
+      end
+
+      def resolve_global_command(name)
+        klass = resolve_class(commands.fetch(name, nil))
+        return nil unless klass&.defined?
+        [klass, name]
+      rescue NameError
+        nil
+      end
+
+      def resolve_contextual_command(name)
+        found = @contextual_resolver.command_names.include?(name)
+        return nil unless found
+        [@contextual_resolver.command_class(name), name]
+      end
+
+      def resolve_class(class_or_proc)
+        if class_or_proc.is_a?(Class)
+          class_or_proc
+        elsif class_or_proc.respond_to?(:call)
+          class_or_proc.call
+        else
+          class_or_proc
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,133 @@
+require 'cli/kit'
+require 'fileutils'
+
+module CLI
+  module Kit
+    class Config
+      XDG_CONFIG_HOME = 'XDG_CONFIG_HOME'
+
+      def initialize(tool_name:)
+        @tool_name = tool_name
+      end
+
+      # Returns the config corresponding to `name` from the config file
+      # `false` is returned if it doesn't exist
+      #
+      # #### Parameters
+      # `section` : the section of the config value you are looking for
+      # `name` : the name of the config value you are looking for
+      #
+      # #### Returns
+      # `value` : the value of the config variable (false if none)
+      #
+      # #### Example Usage
+      # `config.get('name.of.config')`
+      #
+      def get(section, name, default: false)
+        all_configs.dig("[#{section}]", name) || default
+      end
+
+      # Coalesce and enforce the value of a config to a boolean
+      def get_bool(section, name, default: false)
+        case get(section, name, default: default).to_s
+        when "true"
+          true
+        when "false"
+          false
+        else
+          raise CLI::Kit::Abort, "Invalid config: #{section}.#{name} is expected to be true or false"
+        end
+      end
+
+      # Sets the config value in the config file
+      #
+      # #### Parameters
+      # `section` : the section of the config you are setting
+      # `name` : the name of the config you are setting
+      # `value` : the value of the config you are setting
+      #
+      # #### Example Usage
+      # `config.set('section', 'name.of.config', 'value')`
+      #
+      def set(section, name, value)
+        all_configs["[#{section}]"] ||= {}
+        all_configs["[#{section}]"][name] = value.nil? ? nil : value.to_s
+        write_config
+      end
+
+      # Unsets a config value in the config file
+      #
+      # #### Parameters
+      # `section` : the section of the config you are deleting
+      # `name` : the name of the config you are deleting
+      #
+      # #### Example Usage
+      # `config.unset('section', 'name.of.config')`
+      #
+      def unset(section, name)
+        set(section, name, nil)
+      end
+
+      # Gets the hash for the entire section
+      #
+      # #### Parameters
+      # `section` : the section of the config you are getting
+      #
+      # #### Example Usage
+      # `config.get_section('section')`
+      #
+      def get_section(section)
+        (all_configs["[#{section}]"] || {}).dup
+      end
+
+      # Returns a path from config in expanded form
+      # e.g. shopify corresponds to ~/src/shopify, but is expanded to /Users/name/src/shopify
+      #
+      # #### Example Usage
+      # `config.get_path('srcpath', 'shopify')`
+      #
+      # #### Returns
+      # `path` : the expanded path to the corrsponding value
+      #
+      def get_path(section, name = nil)
+        v = get(section, name)
+        false == v ? v : File.expand_path(v)
+      end
+
+      def to_s
+        ini.to_s
+      end
+
+      # The path on disk at which the configuration is stored:
+      #   `$XDG_CONFIG_HOME/<toolname>/config`
+      # if ENV['XDG_CONFIG_HOME'] is not set, we default to ~/.config, e.g.:
+      #   ~/.config/tool/config
+      #
+      def file
+        config_home = ENV.fetch(XDG_CONFIG_HOME, '~/.config')
+        File.expand_path(File.join(@tool_name, 'config'), config_home)
+      end
+
+      private
+
+      def all_configs
+        ini.ini
+      end
+
+      def ini
+        @ini ||= CLI::Kit::Ini
+          .new(file, default_section: "[global]", convert_types: false)
+          .tap(&:parse)
+      end
+
+      def write_config
+        all_configs.each do |section, sub_config|
+          all_configs[section] = sub_config.reject { |_, value| value.nil? }
+          all_configs.delete(section) if all_configs[section].empty?
+        end
+        FileUtils.mkdir_p(File.dirname(file))
+        File.write(file, to_s)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,123 @@
+require 'cli/kit'
+require 'English'
+
+module CLI
+  module Kit
+    class ErrorHandler
+      def initialize(log_file:, exception_reporter:, tool_name: nil)
+        @log_file = log_file
+        @exception_reporter_or_proc = exception_reporter || NullExceptionReporter
+        @tool_name = tool_name
+      end
+
+      module NullExceptionReporter
+        def self.report(_exception, _logs)
+          nil
+        end
+      end
+
+      def call(&block)
+        install!
+        handle_abort(&block)
+      end
+
+      def handle_exception(error)
+        if (notify_with = exception_for_submission(error))
+          logs = begin
+            File.read(@log_file)
+                 rescue => e
+                   "(#{e.class}: #{e.message})"
+          end
+          exception_reporter.report(notify_with, logs)
+        end
+      end
+
+      # maybe we can get rid of this.
+      attr_writer :exception
+
+      private
+
+      def exception_for_submission(error)
+        case error
+        when nil         # normal, non-error termination
+          nil
+        when Interrupt   # ctrl-c
+          nil
+        when CLI::Kit::Abort, CLI::Kit::AbortSilent # Not a bug
+          nil
+        when SignalException
+          skip = %w(SIGTERM SIGHUP SIGINT)
+          skip.include?(error.message) ? nil : error
+        when SystemExit # "exit N" called
+          case error.status
+          when CLI::Kit::EXIT_SUCCESS # submit nothing if it was `exit 0`
+            nil
+          when CLI::Kit::EXIT_FAILURE_BUT_NOT_BUG
+            # if it was `exit 30`, translate the exit code to 1, and submit nothing.
+            # 30 is used to signal normal failures that are not indicative of bugs.
+            # However, users should see it presented as 1.
+            exit(1)
+          else
+            # A weird termination status happened. `error.exception "message"` will maintain backtrace
+            # but allow us to set a message
+            error.exception("abnormal termination status: #{error.status}")
+          end
+        else
+          error
+        end
+      end
+
+      def install!
+        at_exit { handle_exception(@exception || $ERROR_INFO) }
+      end
+
+      def handle_abort
+        yield
+        CLI::Kit::EXIT_SUCCESS
+      rescue CLI::Kit::GenericAbort => e
+        is_bug    = e.is_a?(CLI::Kit::Bug) || e.is_a?(CLI::Kit::BugSilent)
+        is_silent = e.is_a?(CLI::Kit::AbortSilent) || e.is_a?(CLI::Kit::BugSilent)
+
+        print_error_message(e) unless is_silent
+        (@exception = e) if is_bug
+
+        CLI::Kit::EXIT_FAILURE_BUT_NOT_BUG
+      rescue Interrupt
+        stderr_puts_message('Interrupt')
+        CLI::Kit::EXIT_FAILURE_BUT_NOT_BUG
+      rescue Errno::ENOSPC
+        message = if @tool_name
+          "Your disk is full - {{command:#{@tool_name}}} requires free space to operate"
+        else
+          "Your disk is full - free space is required to operate"
+        end
+        stderr_puts_message(message)
+        CLI::Kit::EXIT_FAILURE_BUT_NOT_BUG
+      end
+
+      def stderr_puts_message(message)
+        $stderr.puts(format_error_message(message))
+      rescue Errno::EPIPE
+        nil
+      end
+
+      def exception_reporter
+        if @exception_reporter_or_proc.respond_to?(:report)
+          @exception_reporter_or_proc
+        else
+          @exception_reporter_or_proc.call
+        end
+      end
+
+      def format_error_message(msg)
+        CLI::UI.fmt("{{red:#{msg}}}")
+      end
+
+      def print_error_message(e)
+        CLI::UI::Frame.open("Error", color: :red, timing: false) do
+          $stderr.puts(format_error_message(e.message))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+require 'cli/kit'
+require 'English'
+require 'fileutils'
+
+module CLI
+  module Kit
+    class Executor
+      def initialize(log_file:)
+        FileUtils.mkpath(File.dirname(log_file))
+        @log_file = log_file
+      end
+
+      def call(command, command_name, args)
+        with_traps do
+          with_logging do |id|
+            command.call(args, command_name)
+          rescue => e
+            begin
+              $stderr.puts "This command ran with ID: #{id}"
+              $stderr.puts "Please include this information in any issues/report along with relevant logs"
+            rescue SystemCallError
+              # Outputting to stderr is best-effort.  Avoid raising another error when outputting debug info so that
+              # we can detect and log the original error, which may even be the source of this error.
+              nil
+            end
+            raise e
+          end
+        end
+      end
+
+      private
+
+      def with_logging(&block)
+        return yield unless @log_file
+        CLI::UI.log_output_to(@log_file) do
+          CLI::UI::StdoutRouter.with_id(on_streams: [CLI::UI::StdoutRouter.duplicate_output_to]) do |id|
+            block.call(id)
+          end
+        end
+      end
+
+      def with_traps
+        twrap('QUIT', method(:quit_handler)) do
+          twrap('INFO', method(:info_handler)) do
+            yield
+          end
+        end
+      end
+
+      def twrap(signal, handler)
+        return yield unless Signal.list.key?(signal)
+
+        begin
+          prev_handler = trap(signal, handler)
+          yield
+        ensure
+          trap(signal, prev_handler)
+        end
+      end
+
+      def quit_handler(_sig)
+        z = caller
+        CLI::UI.raw do
+          $stderr.puts('SIGQUIT: quit')
+          $stderr.puts(z)
+        end
+        exit(CLI::Kit::EXIT_FAILURE_BUT_NOT_BUG)
+      end
+
+      def info_handler(_sig)
+        z = caller
+        CLI::UI.raw do
+          $stderr.puts('SIGINFO:')
+          $stderr.puts(z)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+module CLI
+  module Kit
+    # INI is a language similar to JSON or YAML, but simplied
+    # The spec is here: https://en.wikipedia.org/wiki/INI_file
+    # This parser includes supports for 2 very basic uses
+    # - Sections
+    # - Key Value Pairs (within and outside of the sections)
+    #
+    # [global]
+    # key = val
+    #
+    # Nothing else is supported right now
+    # See the ini_test.rb file for more examples
+    #
+    class Ini
+      attr_accessor :ini
+
+      def initialize(path = nil, config: nil, default_section: nil, convert_types: true)
+        @config = if path && File.exist?(path)
+          File.readlines(path)
+        elsif config
+          config.lines
+        end
+        @ini = {}
+        @current_key = nil
+        @default_section = default_section
+        @convert_types = convert_types
+      end
+
+      def parse
+        return @ini if @config.nil?
+
+        @config.each do |l|
+          l.strip!
+
+          # If section, then set current key, this will nest the setting
+          if section_designator?(l)
+            @current_key = l
+
+          # A new line will reset the current key
+          elsif l.strip.empty?
+            @current_key = nil
+
+          # Otherwise set the values
+          else
+            k, v = l.split('=', 2).map(&:strip)
+            set_val(k, v)
+          end
+        end
+        @ini
+      end
+
+      def git_format
+        to_ini(@ini, git_format: true).flatten.join("\n")
+      end
+
+      def to_s
+        to_ini(@ini).flatten.join("\n")
+      end
+
+      private
+
+      def to_ini(h, git_format: false)
+        optional_tab = git_format ? "\t" : ""
+        str = []
+        h.each do |k, v|
+          if section_designator?(k)
+            str << "" unless str.empty? || git_format
+            str << k
+            str << to_ini(v, git_format: git_format)
+          else
+            str << "#{optional_tab}#{k} = #{v}"
+          end
+        end
+        str
+      end
+
+      def set_val(key, val)
+        return if key.nil? && val.nil?
+
+        current_key = @current_key || @default_section
+        if current_key
+          @ini[current_key] ||= {}
+          @ini[current_key][key] = typed_val(val)
+        else
+          @ini[key] = typed_val(val)
+        end
+      end
+
+      def typed_val(val)
+        return val.to_s unless @convert_types
+        return val.to_i if val =~ /^-?[0-9]+$/
+        return val.to_f if val =~ /^-?[0-9]+\.[0-9]*$/
+        val.to_s
+      end
+
+      def section_designator?(k)
+        k.start_with?('[') && k.end_with?(']')
+      end
+    end
+  end
+end