cli-kit 1.0.0 → 3.0.0.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 194c6fb318a717adb92458539db84f4e82c0c7d8
-  data.tar.gz: ed39204760603166cb42990fef86db6f69f1e44a
+  metadata.gz: d38479bdf5b6e03725e44c04e6b44c306bad6a59
+  data.tar.gz: 4268a52a77172588b586e1e5e21cee635e7ed99a
 SHA512:
-  metadata.gz: 325c4f7a072a9004275079d04b9925ef791a4d450ac63d757f9bf294234551a4b8f946e817d4287b146849d6823d46ae7a22a732b616bb1a2ceb1cbcd24f3fe2
-  data.tar.gz: 0507ec4b45eddf96c736c4b552a45bea2528cdff30666006c86d5796d71503b1e25ec9dea415d1b1220b86a055a29a12535e94ed671dec5719301a2e55ee7670
+  metadata.gz: ddd5316dc74a06d96a35ad8953b198de161b1700822f15ff62e9987e46957fc493a7c6af1e605d435235567805a2bc230d4d287677a372619d3653e12c31e66e
+  data.tar.gz: e61a9cac88db2728fd81c5d782288788a8b6a95579e00b3c27b0c86129e0afcee3fbdde18104e3c8beb997fc9d9ee9190f7de6e4f22570679b93f8ed494ad1d7

data/Gemfile.lock

@@ -1,8 +1,8 @@
 PATH
   remote: .
   specs:
-    dev-kit (0.1.0)
-      dev-ui (>= 0.1.0)
+    cli-kit (2.0.0)
+      cli-ui (>= 1.0.0)
 
 GEM
   remote: https://rubygems.org/
@@ -11,7 +11,7 @@ GEM
     ast (2.3.0)
     builder (3.2.3)
     byebug (9.0.6)
-    dev-ui (0.1.0)
+    cli-ui (1.0.0)
     metaclass (0.0.4)
     method_source (0.8.2)
     minitest (5.10.2)
@@ -45,7 +45,7 @@ PLATFORMS
 DEPENDENCIES
   bundler (~> 1.15)
   byebug
-  dev-kit!
+  cli-kit!
   method_source
   minitest (>= 5.0.0)
   minitest-reporters

data/README.md

@@ -1,2 +1,18 @@
 # cli-kit
 
+`cli-kit` is a ruby Command-Line application framework. Its primary design goals are:
+
+1. Modularity: The framework tries not to own your application, but rather to live on its edges.
+2. Startup Time: `cli-kit` encourages heavy use of autoloading (and uses it extensively internally)
+   to reduce the amount of code loaded and evaluated whilst booting your application. We are able to
+   achieve a 130ms runtime in a project with 21kLoC and ~50 commands.
+
+`cli-kit` is developed and heavily used by the Developer Infrastructure team at Shopify. We use it
+to build a number of internal developer tools, along with
+[cli-ui](https://github.com/shopify/cli-ui).
+
+## Example Usage
+
+You can see example usage [here](https://github.com/Shopify/cli-kit-example). We may one day build
+an application generator, as this framework paradigm requires a small amount of boilerplate. For
+now, the best way to get going is to use this example application as a starting point.

data/lib/cli/kit.rb

@@ -1,7 +1,56 @@
 require 'cli/ui'
+require 'cli/kit/ruby_backports/enumerable'
 
 module CLI
   module Kit
-    autoload :System, 'cli/kit/system'
+    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 :Resolver,        'cli/kit/resolver'
+    autoload :System,          'cli/kit/system'
+
+    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)
+    Abort        = Class.new(GenericAbort)
+    Bug          = Class.new(GenericAbort)
+    BugSilent    = Class.new(GenericAbort)
+    AbortSilent  = Class.new(GenericAbort)
   end
 end

data/lib/cli/kit/base_command.rb

@@ -0,0 +1,43 @@
+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 = ["task:#{cmd.class}"]
+        stats_tags << "subcommand:#{args.first}" if args && args.first && cmd.has_subcommands?
+        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 => e
+          statsd_increment("cli.command.exception", tags: stats_tags + ["exception:#{e.class}"])
+          raise e
+        end
+      end
+
+      def call(args, command_name)
+        raise NotImplementedError
+      end
+
+      def has_subcommands?
+        false
+      end
+    end
+  end
+end

data/lib/cli/kit/command_registry.rb

@@ -0,0 +1,93 @@
+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: NullContextualResolver)
+        @commands = {}
+        @aliases  = {}
+        @default = default
+        @contextual_resolver = contextual_resolver
+      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 resolve_command(name)
+        resolve_global_command(name) || \
+          resolve_contextual_command(name) || \
+          [nil, resolve_alias(name)]
+      end
+
+      def resolve_alias(name)
+        aliases[name] || @contextual_resolver.aliases.fetch(name, name)
+      end
+
+      def resolve_global_command(name)
+        name = resolve_alias(name)
+        klass = resolve_class(commands.fetch(name, ""))
+        return nil unless klass.defined? # (BaseCommand)
+        [klass, name]
+      rescue NameError
+        nil
+      end
+
+      def resolve_contextual_command(name)
+        name = resolve_alias(name)
+        found = @contextual_resolver.command_names.include?(name)
+        return nil unless found
+        [@contextual_resolver.command_class(name), name]
+      end
+
+      def command_names
+        @contextual_resolver.command_names + commands.keys
+      end
+
+      def exist?(name)
+        !resolve_command(name).first.nil?
+      end
+
+      private
+
+      def resolve_class(class_or_proc)
+        if class_or_proc.is_a?(Class)
+          class_or_proc
+        else
+          class_or_proc.call
+        end
+      end
+    end
+  end
+end

data/lib/cli/kit/config.rb

@@ -0,0 +1,100 @@
+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)
+        all_configs.dig("[#{section}]", name) || false
+      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
+
+      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

data/lib/cli/kit/error_handler.rb

@@ -0,0 +1,95 @@
+require 'cli/kit'
+
+module CLI
+  module Kit
+    class ErrorHandler
+      def initialize(log_file: nil, exception_reporter: NullExceptionReporter)
+        @log_file = log_file
+        @exception_reporter_or_proc = exception_reporter
+      end
+
+      module NullExceptionReporter
+        def self.report(exception, logs)
+          nil
+        end
+      end
+
+      def install!
+        at_exit { handle_final_exception(@exception || $ERROR_INFO) }
+      end
+
+      def handle_abort
+        yield
+      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(format_error_message("Interrupt"))
+        return CLI::Kit::EXIT_FAILURE_BUT_NOT_BUG
+      end
+
+      private
+
+      def handle_final_exception(error)
+        notify_with = nil
+
+        case error
+        when nil         # normal, non-error termination
+        when Interrupt   # ctrl-c
+        when CLI::Kit::Abort, CLI::Kit::AbortSilent # Not a bug
+        when SignalException
+          skip = %w(SIGTERM SIGHUP SIGINT)
+          unless skip.include?(error.message)
+            notify_with = error
+          end
+        when SystemExit  # "exit N" called
+          case error.status
+          when CLI::Kit::EXIT_SUCCESS  # submit nothing if it was `exit 0`
+          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.
+            # But 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
+            notify_with = error.exception "abnormal termination status: #{error.status}"
+          end
+        else
+          notify_with = error
+        end
+
+        if notify_with
+          logs = begin
+            File.read(@log_file)
+          rescue => e
+            "(#{e.class}: #{e.message})"
+          end
+          exceptiono_reporter.report(notify_with, logs)
+        end
+      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)
+        STDERR.puts(format_error_message(e.message))
+      end
+    end
+  end
+end

data/lib/cli/kit/executor.rb

@@ -0,0 +1,87 @@
+require 'cli/kit'
+require 'English'
+
+module CLI
+  module Kit
+    class Executor
+      def initialize(
+        tool_name:, command_registry:, error_handler:, log_file: nil
+      )
+        @tool_name = tool_name
+        @command_registry = command_registry
+        @error_handler = error_handler
+        @log_file = log_file
+      end
+
+      def with_logging(&block)
+        return yield unless @log_file
+        CLI::UI.log_output_to(@log_file, &block)
+      end
+
+      def commands_and_aliases
+        @command_registry.command_names + @command_registry.aliases.keys
+      end
+
+      def trap_signals
+        trap('QUIT') do
+          z = caller
+          CLI::UI.raw do
+            STDERR.puts('SIGQUIT: quit')
+            STDERR.puts(z)
+          end
+          exit 1
+        end
+        trap('INFO') do
+          z = caller
+          CLI::UI.raw do
+            STDERR.puts('SIGINFO:')
+            STDERR.puts(z)
+            # Thread.list.map { |t| t.backtrace }
+          end
+        end
+      end
+
+      def call(command, command_name, args)
+        trap_signals
+        with_logging do
+          @error_handler.handle_abort do
+            if command.nil?
+              command_not_found(command_name)
+              raise CLI::Kit::AbortSilent # Already output message
+            end
+            command.call(args, command_name)
+            CLI::Kit::EXIT_SUCCESS # unless an exception was raised
+          end
+        end
+      end
+
+      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
+    end
+  end
+end

data/lib/cli/kit/ini.rb

@@ -0,0 +1,93 @@
+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, default_section: nil, convert_types: true)
+        @config = File.readlines(path) if path && File.exist?(path)
+        @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('=').map(&:strip)
+            set_val(k, v)
+          end
+        end
+        @ini
+      end
+
+      def to_s
+        to_ini(@ini).flatten.join("\n")
+      end
+
+      private
+
+      def to_ini(h)
+        str = []
+        h.each do |k, v|
+          if section_designator?(k)
+            str << "" unless str.empty?
+            str << k
+            str << to_ini(v)
+          else
+            str << "#{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

data/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

data/lib/cli/kit/resolver.rb

@@ -0,0 +1,24 @@
+require 'cli/kit'
+
+module CLI
+  module Kit
+    class Resolver
+      def initialize(command_registry:, error_handler:)
+        @command_registry = command_registry
+        @error_handler = error_handler
+      end
+
+      def call(args)
+        args = args.dup
+        command_name = args.shift
+
+        @error_handler.handle_abort do
+          command, command_name = @command_registry.lookup_command(command_name)
+          return [command, command_name, args]
+        end
+
+        exit CLI::Kit::EXIT_FAILURE_BUT_NOT_BUG
+      end
+    end
+  end
+end

data/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

data/lib/cli/kit/version.rb

@@ -1,5 +1,5 @@
 module CLI
   module Kit
-    VERSION = "1.0.0"
+    VERSION = "3.0.0.pre"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cli-kit
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 3.0.0.pre
 platform: ruby
 authors:
 - Burke Libbey
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-12-15 00:00:00.000000000 Z
+date: 2018-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cli-ui
@@ -87,6 +87,15 @@ files:
 - cli-kit.gemspec
 - dev.yml
 - lib/cli/kit.rb
+- lib/cli/kit/base_command.rb
+- lib/cli/kit/command_registry.rb
+- lib/cli/kit/config.rb
+- lib/cli/kit/error_handler.rb
+- lib/cli/kit/executor.rb
+- lib/cli/kit/ini.rb
+- lib/cli/kit/levenshtein.rb
+- lib/cli/kit/resolver.rb
+- lib/cli/kit/ruby_backports/enumerable.rb
 - lib/cli/kit/system.rb
 - lib/cli/kit/version.rb
 homepage: https://github.com/shopify/cli-kit
@@ -104,9 +113,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.6.14