@shopify/cli-kit 3.69.4 → 3.70.0

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

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

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

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

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

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

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

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

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

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