bundle_update_interactive 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0bdc9b0322d61da7334ee24e12d415948f8f1117f6824ebb4afe5eec6eadd57e
-  data.tar.gz: bdc4cf0e7a740c4f33f9211b269257cc854ba49f9d190f956dcdb2513cbfef6b
+  metadata.gz: 32a7f01a5cd12b428ccbf01ae0dbe016fcea9d3a3ab9e390b602f9387ece19f8
+  data.tar.gz: 3fc3df0da19212ffa444e4d8b1d5ac6b4e33eff27704d7c0d18ea98c3aac1c91
 SHA512:
-  metadata.gz: 6120695a0dcd0f21cc652e3e37a7b3f2a1573bfc042aba435d97896522cfd92a169c7d66cc73f7bbd2b4e5d8244b37321acda4e42ca61092201f80c584c65552
-  data.tar.gz: 37b171778494c7e5e8b89f16f6c9b0c6e47a22d2c3dc174c7d80e0324dac1a36260a485cc220aa7746d43db757917a8eb11df8dac312e6bee2048f5d0fb56371
+  metadata.gz: a13fb74ddbd25a6570b0ec6655b539328edca5140cb8156a2d1b94c64d0c5d195089330a408498a79d881d7b7013fb31b98490163250d1d7e34ab68499b7f291
+  data.tar.gz: db26535a1961ad67e3932f94ca358a747e8e1209b83f8c44070ded841338cf052123960ae8d89f6664c4aac7c4fc987ce07fa72cc1e373f772c48ba0d9c0054e

data/README.md

@@ -87,6 +87,36 @@ https://github.com/rails/rails/compare/5a8d894...77dfa65
 
 This feature currently works for GitHub, GitLab, and Bitbucket repos.
 
+### Limit impact by Gemfile groups
+
+The effects of `bundle update-interactive` can be limited to one or more Gemfile groups using the `--exclusively` option:
+
+```sh
+bundle update-interactive --exclusively=group1,group2
+```
+
+This is especially useful when you want to safely update a subset of your lock file without introducing any risk to your application in production. The best way to do this is with `--exclusively=development,test`, which can be abbreviated to simply `-D`:
+
+```sh
+# Update non-production dependencies.
+# This is equivalent to `bundle update-interactive --exclusively=development,test`
+bundle update-interactive -D
+```
+
+The `--exclusively` and `-D` options will cause `update-interactive` to only consider gems that are used _exclusively_ by the specified Gemfile groups. Indirect dependencies that are shared with other Gemfile groups will not be updated.
+
+For example, given this Gemfile:
+
+```ruby
+gem "rails"
+
+group :test do
+  gem "capybara"
+end
+```
+
+If `--exclusively=test` is used, `capybara` and its indirect dependency `xpath` are both exclusively used in test and can therefore be updated. However, capybara's `nokogiri` indirect dependency, which is also used in production via `rails` → `actionpack` → `nokogiri`, would not be allowed to update.
+
 ### Conservative updates
 
 `bundle update-interactive` updates the gems you select by running `bundle update --conservative [GEMS...]`. This means that only those specific gems will be updated. Indirect dependencies shared with other gems will not be affected.

data/exe/bundler-ui

@@ -2,4 +2,5 @@
 # frozen_string_literal: true
 
 require "bundle_update_interactive"
-BundleUpdateInteractive::CLI.start(ARGV)
+
+BundleUpdateInteractive::CLI.new.run

data/exe/bundler-update-interactive

@@ -2,4 +2,5 @@
 # frozen_string_literal: true
 
 require "bundle_update_interactive"
-BundleUpdateInteractive::CLI.start(ARGV)
+
+BundleUpdateInteractive::CLI.new.run

data/lib/bundle_update_interactive/bundler_commands.rb

@@ -1,18 +1,30 @@
 # frozen_string_literal: true
 
+require "bundler"
 require "shellwords"
 
 module BundleUpdateInteractive
   module BundlerCommands
     class << self
       def update_gems_conservatively(*gems)
-        system "bundle update --conservative #{gems.flatten.map(&:shellescape).join(' ')}"
+        system "#{bundle_bin.shellescape} update --conservative #{gems.flatten.map(&:shellescape).join(' ')}"
       end
 
-      def read_updated_lockfile
-        `bundle lock --print --update`.tap do
-          raise "bundle lock command failed" unless Process.last_status.success?
-        end
+      def read_updated_lockfile(*gems)
+        command = ["#{bundle_bin.shellescape} lock --print"]
+        command << "--conservative" if gems.any?
+        command << "--update"
+        command.push(*gems.flatten.map(&:shellescape))
+
+        `#{command.join(" ")}`.tap { raise "bundle lock command failed" unless Process.last_status.success? }
+      end
+
+      private
+
+      def bundle_bin
+        Gem.bin_path("bundler", "bundle", Bundler::VERSION)
+      rescue Gem::GemNotFoundException
+        "bundle"
       end
     end
   end

data/lib/bundle_update_interactive/changelog_locator.rb

@@ -1,15 +1,14 @@
 # frozen_string_literal: true
 
-require "faraday"
 require "json"
 
-GITHUB_PATTERN = %r{^(?:https?://)?github\.com/([^/]+/[^/]+)(?:\.git)?/?}.freeze
-URI_KEYS = %w[source_code_uri homepage_uri bug_tracker_uri wiki_uri].freeze
-FILE_PATTERN = /changelog|changes|history|news|release/i.freeze
-EXT_PATTERN = /md|txt|rdoc/i.freeze
-
 module BundleUpdateInteractive
   class ChangelogLocator
+    GITHUB_PATTERN = %r{^(?:https?://)?github\.com/([^/]+/[^/]+)(?:\.git)?/?}.freeze
+    URI_KEYS = %w[source_code_uri homepage_uri bug_tracker_uri wiki_uri].freeze
+    FILE_PATTERN = /changelog|changes|history|news|release/i.freeze
+    EXT_PATTERN = /md|txt|rdoc/i.freeze
+
     class GitHubRepo
       def self.from_uris(*uris)
         uris.flatten.each do |uri|
@@ -32,16 +31,16 @@ module BundleUpdateInteractive
         return "https://github.com/#{changelog_path}" if changelog_path
 
         releases_url = "https://github.com/#{path}/releases"
-        releases_url if Faraday.head("#{releases_url}/tag/v#{version}").success?
+        releases_url if HTTP.head("#{releases_url}/tag/v#{version}").success?
       end
 
       private
 
       def fetch_repo_html(follow_redirect:)
-        response = Faraday.get("https://github.com/#{path}")
+        response = HTTP.get("https://github.com/#{path}")
 
-        if response.status == 301 && follow_redirect
-          @path = response.headers["Location"][GITHUB_PATTERN, 1]
+        if response.code == "301" && follow_redirect
+          @path = response["Location"][GITHUB_PATTERN, 1]
           return fetch_repo_html(follow_redirect: false)
         end
 
@@ -69,7 +68,7 @@ module BundleUpdateInteractive
                   "https://rubygems.org/api/v2/rubygems/#{name}/versions/#{version}.json"
                 end
 
-      response = Faraday.get(api_url)
+      response = HTTP.get(api_url)
 
       # Try again without the version in case the version does not exist at rubygems for some reason.
       # This can happen when using a pre-release Ruby that has a bundled gem newer than the published version.

data/lib/bundle_update_interactive/cli/options.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module BundleUpdateInteractive
+  class CLI::Options
+    class << self
+      def parse(argv=ARGV)
+        options = new
+        remaining = build_parser(options).parse!(argv.dup)
+        raise Error, "update-interactive does not accept arguments. See --help for available options." if remaining.any?
+
+        options.freeze
+      end
+
+      def summary
+        build_parser(new).summarize.join.gsub(/^\s+-.*?  /, pastel.yellow('\0'))
+      end
+
+      def help # rubocop:disable Metrics/AbcSize
+        <<~HELP
+          Provides an easy way to update gems to their latest versions.
+
+          #{pastel.bold.underline('USAGE')}
+            #{pastel.green('bundle update-interactive')} #{pastel.yellow('[options]')}
+            #{pastel.green('bundle ui')} #{pastel.yellow('[options]')}
+
+          #{pastel.bold.underline('OPTIONS')}
+          #{summary}
+          #{pastel.bold.underline('DESCRIPTION')}
+            Displays the list of gems that would be updated by `bundle update`, allowing you
+            to navigate them by keyboard and pick which ones to update. A changelog URL,
+            when available, is displayed alongside each update. Gems with known security
+            vulnerabilities are also highlighted.
+
+            Your Gemfile.lock will be updated conservatively based on the gems you select.
+            Transitive dependencies are not affected.
+
+            More information: #{pastel.blue('https://github.com/mattbrictson/bundle_update_interactive')}
+
+          #{pastel.bold.underline('EXAMPLES')}
+            Show all gems that can be updated.
+            #{pastel.green('bundle update-interactive')}
+
+            The "ui" command alias can also be used.
+            #{pastel.green('bundle ui')}
+
+            Show updates for development and test gems only, leaving production gems untouched.
+            #{pastel.green('bundle update-interactive')} #{pastel.yellow('-D')}
+
+        HELP
+      end
+
+      private
+
+      def pastel
+        BundleUpdateInteractive.pastel
+      end
+
+      def build_parser(options) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        OptionParser.new do |parser|
+          parser.summary_indent = "  "
+          parser.summary_width = 24
+          parser.on(
+            "--exclusively=GROUP",
+            "Update gems exclusively belonging to the specified Gemfile GROUP(s)"
+          ) do |value|
+            options.exclusively = value.split(",").map(&:strip).reject(&:empty?).map(&:to_sym)
+          end
+          parser.on("-D", "Shorthand for --exclusively=development,test") do
+            options.exclusively = %i[development test]
+          end
+          parser.on("-v", "--version", "Display version") do
+            require "bundler"
+            puts "bundle_update_interactive/#{VERSION} bundler/#{Bundler::VERSION} #{RUBY_DESCRIPTION}"
+            exit
+          end
+          parser.on("-h", "--help", "Show this help") do
+            puts help
+            exit
+          end
+        end
+      end
+    end
+
+    attr_accessor :exclusively
+
+    def initialize
+      @exclusively = []
+    end
+  end
+end

data/lib/bundle_update_interactive/cli.rb

@@ -1,40 +1,33 @@
 # frozen_string_literal: true
 
-require "thor"
+require "bundler"
 
 module BundleUpdateInteractive
-  class CLI < Thor
+  class CLI
     autoload :MultiSelect, "bundle_update_interactive/cli/multi_select"
+    autoload :Options, "bundle_update_interactive/cli/options"
     autoload :Row, "bundle_update_interactive/cli/row"
     autoload :Table, "bundle_update_interactive/cli/table"
-    autoload :ThorExt, "bundle_update_interactive/cli/thor_ext"
 
-    extend ThorExt::Start
+    def run(argv: ARGV) # rubocop:disable Metrics/AbcSize
+      options = Options.parse(argv)
 
-    default_command :ui
-    map %w[-v --version] => "version"
+      report = generate_report(options)
+      puts("No gems to update.").then { return } if report.updateable_gems.empty?
 
-    desc "version", "Display bundle_update_interactive version", hide: true
-    def version
-      say "bundle_update_interactive/#{VERSION} #{RUBY_DESCRIPTION}"
-    end
-
-    desc "ui", "Update Gemfile.lock interactively", hide: true
-    def ui # rubocop:disable Metrics/AbcSize
-      report = generate_report
-      say("No gems to update.") && return if report.updateable_gems.empty?
-
-      say
-      say legend
-      say
+      puts
+      puts legend
+      puts
       selected_gems = MultiSelect.prompt_for_gems_to_update(report.updateable_gems)
-      say("No gems to update.") && return if selected_gems.empty?
+      puts("No gems to update.").then { return } if selected_gems.empty?
 
-      say "\nUpdating the following gems."
-      say
-      say Table.new(selected_gems).render
-      say
+      puts "\nUpdating the following gems."
+      puts
+      puts Table.new(selected_gems).render
+      puts
       report.bundle_update!(*selected_gems.keys)
+    rescue Exception => e # rubocop:disable Lint/RescueException
+      handle_exception(e)
     end
 
     private
@@ -51,9 +44,9 @@ module BundleUpdateInteractive
       LEGEND
     end
 
-    def generate_report
+    def generate_report(options)
       whisper "Resolving latest gem versions..."
-      report = Report.generate
+      report = Report.generate(groups: options.exclusively)
       updateable_gems = report.updateable_gems
       return report if updateable_gems.empty?
 
@@ -65,7 +58,7 @@ module BundleUpdateInteractive
     end
 
     def whisper(message)
-      $stderr.puts(message) # rubocop:disable Style/StderrPuts
+      $stderr.puts(message)
     end
 
     def progress(message, items, &block)
@@ -76,5 +69,17 @@ module BundleUpdateInteractive
       end
       $stderr.print("\n")
     end
+
+    def handle_exception(error)
+      case error
+      when Errno::EPIPE
+        # Ignore
+      when BundleUpdateInteractive::Error, OptionParser::ParseError, Interrupt, Bundler::Dsl::DSLError
+        $stderr.puts BundleUpdateInteractive.pastel.red(error.message)
+        exit false
+      else
+        raise
+      end
+    end
   end
 end

data/lib/bundle_update_interactive/error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module BundleUpdateInteractive
+  class Error < StandardError
+  end
+end

data/lib/bundle_update_interactive/gemfile.rb

@@ -18,5 +18,9 @@ module BundleUpdateInteractive
     def [](name)
       @dependencies[name]
     end
+
+    def dependencies
+      @dependencies.values
+    end
   end
 end

data/lib/bundle_update_interactive/http.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+
+module BundleUpdateInteractive
+  module HTTP
+    module Success
+      def success?
+        code.start_with?("2")
+      end
+    end
+
+    class << self
+      def get(url)
+        http(:get, url)
+      end
+
+      def head(url)
+        http(:head, url)
+      end
+
+      private
+
+      def http(method, url_string)
+        uri = URI(url_string)
+        response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme.end_with?("s")) do |http|
+          http.public_send(method, uri.request_uri)
+        end
+        response.extend(Success)
+      end
+    end
+  end
+end

data/lib/bundle_update_interactive/lockfile.rb

@@ -1,54 +1,70 @@
 # frozen_string_literal: true
 
 require "bundler"
+require "set"
 
 module BundleUpdateInteractive
   class Lockfile
-    # TODO: refactor
-    def self.parse(lockfile_contents=File.read("Gemfile.lock")) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+    def self.parse(lockfile_contents=File.read("Gemfile.lock"))
       parser = Bundler::LockfileParser.new(lockfile_contents)
-      specs_by_name = {}
-      exact = Set.new
-      exact_children = {}
+      new(parser.specs)
+    end
 
-      parser.specs.each do |spec|
-        specs_by_name[spec.name] = spec
+    def initialize(specs)
+      @specs_by_name = {}
+      required_exactly = Set.new
 
-        spec.dependencies.each do |dep|
-          next unless dep.requirement.exact?
+      specs.each do |spec|
+        specs_by_name[spec.name] = spec
+        spec.dependencies.each { |dep| required_exactly << dep.name if dep.requirement.exact? }
+      end
 
-          exact << dep.name
-          (exact_children[spec.name] ||= []) << dep.name
-        end
+      @entries_by_name = specs_by_name.transform_values do |spec|
+        build_entry(spec, required_exactly.include?(spec.name))
       end
+    end
 
-      entries = specs_by_name.transform_values do |spec|
-        exact_dependencies = Set.new
-        traversal = exact_children[spec.name]&.dup || []
-        until traversal.empty?
-          name = traversal.pop
-          next if exact_dependencies.include?(name)
+    def entries
+      entries_by_name.values
+    end
 
-          exact_dependencies << name
-          traversal.push(*exact_children.fetch(name, []))
-        end
+    def [](gem_name)
+      entries_by_name[gem_name]
+    end
 
-        LockfileEntry.new(spec, exact_dependencies, exact.include?(spec.name))
-      end
+    def gems_exclusively_installed_by(gemfile:, groups:)
+      return [] if groups.empty?
 
-      new(entries)
-    end
+      other_group_gems = gemfile.dependencies.filter_map { |gem| gem.name unless (gem.groups & groups).any? }
+      other_group_gems &= entries_by_name.keys
+      gems_installed_by_other_groups = other_group_gems + traverse_transient_dependencies(*other_group_gems)
 
-    def initialize(entries)
-      @entries = entries.freeze
+      entries_by_name.keys - gems_installed_by_other_groups
     end
 
-    def entries
-      @entries.values
+    private
+
+    attr_reader :entries_by_name, :specs_by_name
+
+    def build_entry(spec, exact)
+      exact_dependencies = traverse_transient_dependencies(spec.name) { |dep| dep.requirement.exact? }
+      LockfileEntry.new(spec, exact_dependencies, exact)
     end
 
-    def [](gem_name)
-      @entries[gem_name]
+    def traverse_transient_dependencies(*gem_names) # rubocop:disable Metrics/AbcSize
+      traversal = Set.new
+      stack = gem_names.flatten
+      until stack.empty?
+        specs_by_name[stack.pop].dependencies.each do |dep|
+          next if traversal.include?(dep.name)
+          next unless specs_by_name.key?(dep.name)
+          next if block_given? && !yield(dep)
+
+          traversal << dep.name
+          stack << dep.name
+        end
+      end
+      traversal.to_a
     end
   end
 end

data/lib/bundle_update_interactive/lockfile_entry.rb

@@ -4,10 +4,10 @@ module BundleUpdateInteractive
   class LockfileEntry
     attr_reader :spec, :exact_dependencies
 
-    def initialize(spec, exact_dependencies, exact_dependency)
+    def initialize(spec, exact_dependencies, exact_requirement)
       @spec = spec
       @exact_dependencies = exact_dependencies
-      @exact_dependency = exact_dependency
+      @exact_requirement = exact_requirement
     end
 
     def name
@@ -28,8 +28,8 @@ module BundleUpdateInteractive
       end
     end
 
-    def exact_dependency?
-      @exact_dependency
+    def exact_requirement?
+      @exact_requirement
     end
 
     def git_version

data/lib/bundle_update_interactive/report.rb

@@ -8,11 +8,12 @@ require "set"
 module BundleUpdateInteractive
   class Report
     class << self
-      def generate
+      def generate(groups: [])
         gemfile = Gemfile.parse
         current_lockfile = Lockfile.parse
-        updated_lockfile = Lockfile.parse(BundlerCommands.read_updated_lockfile)
+        gems = groups.any? ? current_lockfile.gems_exclusively_installed_by(gemfile: gemfile, groups: groups) : nil
 
+        updated_lockfile = gems&.none? ? nil : Lockfile.parse(BundlerCommands.read_updated_lockfile(*Array(gems)))
         new(gemfile: gemfile, current_lockfile: current_lockfile, updated_lockfile: updated_lockfile)
       end
     end
@@ -21,9 +22,9 @@ module BundleUpdateInteractive
 
     def initialize(gemfile:, current_lockfile:, updated_lockfile:)
       @current_lockfile = current_lockfile
-      @outdated_gems ||= current_lockfile.entries.each_with_object({}) do |current_lockfile_entry, hash|
+      @outdated_gems = current_lockfile.entries.each_with_object({}) do |current_lockfile_entry, hash|
         name = current_lockfile_entry.name
-        updated_lockfile_entry = updated_lockfile[name]
+        updated_lockfile_entry = updated_lockfile && updated_lockfile[name]
         next unless current_lockfile_entry.older_than?(updated_lockfile_entry)
 
         hash[name] = build_outdated_gem(current_lockfile_entry, updated_lockfile_entry, gemfile[name]&.groups)
@@ -36,7 +37,7 @@ module BundleUpdateInteractive
 
     def updateable_gems
       @updateable_gems ||= outdated_gems.reject do |name, _|
-        current_lockfile[name].exact_dependency?
+        current_lockfile[name].exact_requirement?
       end.freeze
     end
 

data/lib/bundle_update_interactive/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module BundleUpdateInteractive
-  VERSION = "0.3.0"
+  VERSION = "0.5.0"
 end

data/lib/bundle_update_interactive.rb

@@ -6,7 +6,9 @@ module BundleUpdateInteractive
   autoload :BundlerCommands, "bundle_update_interactive/bundler_commands"
   autoload :ChangelogLocator, "bundle_update_interactive/changelog_locator"
   autoload :CLI, "bundle_update_interactive/cli"
+  autoload :Error, "bundle_update_interactive/error"
   autoload :Gemfile, "bundle_update_interactive/gemfile"
+  autoload :HTTP, "bundle_update_interactive/http"
   autoload :Lockfile, "bundle_update_interactive/lockfile"
   autoload :LockfileEntry, "bundle_update_interactive/lockfile_entry"
   autoload :OutdatedGem, "bundle_update_interactive/outdated_gem"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bundle_update_interactive
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Matt Brictson
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-07-19 00:00:00.000000000 Z
+date: 2024-08-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,20 +38,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.9.1
-- !ruby/object:Gem::Dependency
-  name: faraday
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 2.8.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 2.8.0
 - !ruby/object:Gem::Dependency
   name: pastel
   requirement: !ruby/object:Gem::Requirement
@@ -66,20 +52,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.8.0
-- !ruby/object:Gem::Dependency
-  name: thor
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.2'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: tty-prompt
   requirement: !ruby/object:Gem::Requirement
@@ -126,10 +98,12 @@ files:
 - lib/bundle_update_interactive/changelog_locator.rb
 - lib/bundle_update_interactive/cli.rb
 - lib/bundle_update_interactive/cli/multi_select.rb
+- lib/bundle_update_interactive/cli/options.rb
 - lib/bundle_update_interactive/cli/row.rb
 - lib/bundle_update_interactive/cli/table.rb
-- lib/bundle_update_interactive/cli/thor_ext.rb
+- lib/bundle_update_interactive/error.rb
 - lib/bundle_update_interactive/gemfile.rb
+- lib/bundle_update_interactive/http.rb
 - lib/bundle_update_interactive/lockfile.rb
 - lib/bundle_update_interactive/lockfile_entry.rb
 - lib/bundle_update_interactive/outdated_gem.rb
@@ -160,7 +134,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
+rubygems_version: 3.5.16
 signing_key:
 specification_version: 4
 summary: Adds an update-interactive command to Bundler

data/lib/bundle_update_interactive/cli/thor_ext.rb

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-require "bundler"
-
-class BundleUpdateInteractive::CLI
-  module ThorExt
-    # Configures Thor to behave more like a typical CLI, with better help and error handling.
-    #
-    # - Passing -h or --help to a command will show help for that command.
-    # - Unrecognized options will be treated as errors (instead of being silently ignored).
-    # - Error messages will be printed in red to stderr, without stack trace.
-    # - Full stack traces can be enabled by setting the VERBOSE environment variable.
-    # - Errors will cause Thor to exit with a non-zero status.
-    #
-    # To take advantage of this behavior, your CLI should subclass Thor and extend this module.
-    #
-    #   class CLI < Thor
-    #     extend ThorExt::Start
-    #   end
-    #
-    # Start your CLI with:
-    #
-    #   CLI.start
-    #
-    # In tests, prevent Kernel.exit from being called when an error occurs, like this:
-    #
-    #   CLI.start(args, exit_on_failure: false)
-    #
-    module Start
-      def self.extended(base)
-        super
-        base.check_unknown_options!
-      end
-
-      def start(given_args=ARGV, config={})
-        config[:shell] ||= Thor::Base.shell.new
-        handle_help_switches(given_args) do |args|
-          dispatch(nil, args, nil, config)
-        end
-      rescue Exception => e # rubocop:disable Lint/RescueException
-        handle_exception_on_start(e, config)
-      end
-
-      private
-
-      def handle_help_switches(given_args)
-        yield(given_args.dup)
-      rescue Thor::UnknownArgumentError => e
-        retry_with_args = []
-
-        if given_args.first == "help"
-          retry_with_args = ["help"] if given_args.length > 1
-        elsif (e.unknown & %w[-h --help]).any?
-          retry_with_args = ["help", (given_args - e.unknown).first]
-        end
-        raise unless retry_with_args.any?
-
-        yield(retry_with_args)
-      end
-
-      def handle_exception_on_start(error, config)
-        case error
-        when Errno::EPIPE
-          # Ignore
-        when Thor::Error, Interrupt, Bundler::Dsl::DSLError
-          raise unless config.fetch(:exit_on_failure, true)
-
-          config[:shell]&.say_error(error.message, :red)
-          exit(false)
-        else
-          raise
-        end
-      end
-    end
-  end
-end