bundle_update_interactive 0.2.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 24de9c6dde2b3514ffad21a64256359200e2bb717b1a0385caa8d032776d5fe6
-  data.tar.gz: 4a1a1c65bd89e4c7e17d563c2a854c80e07edeb7d04e6b4ffdf3cbef1d47ddee
+  metadata.gz: 5eb0324c92b1a60c3611ce47993022fef9c3d69aeba735a752252cc2cffe8158
+  data.tar.gz: f68c74d7fc286abf743796b3323bed579736bf548ccc2a405b8a2433bf3eddf1
 SHA512:
-  metadata.gz: 493421b5621ff128b56ed96041fd4c1e776de8c0160f330d8458d40963248e2c2e779dc64c7f7afd390c2f98d62a6203b3495534e7b57051f79add6edc729715
-  data.tar.gz: 638b235f21664177f8b9de29a0b69b9229ef1b57fc985c4ba6c73678ca2142a926caff18626a809b4ab4fdd2aeff4573e7a4137c471ca569d62b95e55322e0ec
+  metadata.gz: 874b63b22b4ff2ad9101f9a5a51b2947cf27009ff37096ae0ff3f00e3f5de5ba2ea32a4e2a2adae0d46bf4a523868deb5f8f7ec45599f988719a983e1bb9e16f
+  data.tar.gz: 7f134fec1b5304ed93921506a4e763a1f7ef7954f812b679cb63e271c99fc76bd291f68f1e9fd51a532a3d63a55e74ad01657767250924cd8a2a0d0d7baa69ce

data/README.md

@@ -75,17 +75,47 @@ If you discover a gem that is missing a changelog in `bundle update-interactive`
 
 ### Git diffs
 
-If your `Gemfile` sources a gem from a GitHub repo like this:
+If your `Gemfile` sources a gem from a Git repo like this:
 
 ```ruby
 gem "rails", github: "rails/rails", branch: "7-1-stable"
 ```
 
-Then `bundle update-interactive` will show a GitHub diff link instead of a changelog, so you can see exactly what changed when the gem is updated. For example:
+Then `bundle update-interactive` will show a diff link instead of a changelog, so you can see exactly what changed when the gem is updated. For example:
 
 https://github.com/rails/rails/compare/5a8d894...77dfa65
 
-Currently only GitHub repos are supported, but I'm considering adding GitLab and BitBucket as well.
+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
 

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

@@ -9,10 +9,13 @@ module BundleUpdateInteractive
         system "bundle 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 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
     end
   end

data/lib/bundle_update_interactive/changelog_locator.rb

@@ -3,55 +3,79 @@
 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
-    # TODO: refactor
-    def find_changelog_uri(name:, version: nil) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
-      if version
-        response = Faraday.get("https://rubygems.org/api/v2/rubygems/#{name}/versions/#{version}.json")
-        version = nil unless response.success?
+    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|
+          return new(Regexp.last_match(1)) if uri&.match(GITHUB_PATTERN)
+        end
+        nil
       end
 
-      response = Faraday.get("https://rubygems.org/api/v1/gems/#{name}.json") if version.nil?
+      attr_reader :path
 
-      return nil unless response.success?
+      def initialize(path)
+        @path = path
+      end
 
-      data = JSON.parse(response.body)
+      def discover_changelog_uri(version)
+        repo_html = fetch_repo_html(follow_redirect: true)
+        return if repo_html.nil?
 
-      version ||= data["version"]
-      changelog_uri = data["changelog_uri"]
-      github_repo = guess_github_repo(data)
+        changelog_path = repo_html[%r{/(#{path}/blob/[^/]+/#{FILE_PATTERN}(?:\.#{EXT_PATTERN})?)"}i, 1]
+        return "https://github.com/#{changelog_path}" if changelog_path
 
-      if changelog_uri.nil? && github_repo
-        file_list = Faraday.get("https://github.com/#{github_repo}")
-        if file_list.status == 301
-          github_repo = file_list.headers["Location"][GITHUB_PATTERN, 1]
-          file_list = Faraday.get(file_list.headers["Location"])
-        end
-        match = file_list.body.match(%r{/(#{github_repo}/blob/[^/]+/#{FILE_PATTERN}(?:\.#{EXT_PATTERN})?)"}i)
-        changelog_uri = "https://github.com/#{match[1]}" if match
+        releases_url = "https://github.com/#{path}/releases"
+        releases_url if Faraday.head("#{releases_url}/tag/v#{version}").success?
       end
 
-      if changelog_uri.nil? && github_repo
-        releases_uri = "https://github.com/#{github_repo}/releases"
-        changelog_uri = releases_uri if Faraday.head("#{releases_uri}/tag/v#{version}").success?
+      private
+
+      def fetch_repo_html(follow_redirect:)
+        response = Faraday.get("https://github.com/#{path}")
+
+        if response.status == 301 && follow_redirect
+          @path = response.headers["Location"][GITHUB_PATTERN, 1]
+          return fetch_repo_html(follow_redirect: false)
+        end
+
+        response.success? ? response.body : nil
       end
+    end
 
-      changelog_uri
+    def find_changelog_uri(name:, version: nil)
+      data = fetch_rubygems_data(name, version)
+      return if data.nil?
+
+      if (rubygems_changelog_uri = data["changelog_uri"])
+        rubygems_changelog_uri
+      elsif (github_repo = GitHubRepo.from_uris(data.values_at(*URI_KEYS)))
+        github_repo.discover_changelog_uri(data["version"])
+      end
     end
 
     private
 
-    def guess_github_repo(data)
-      data.values_at(*URI_KEYS).each do |uri|
-        return Regexp.last_match(1) if uri&.match(GITHUB_PATTERN)
-      end
-      nil
+    def fetch_rubygems_data(name, version)
+      api_url = if version.nil?
+                  "https://rubygems.org/api/v1/gems/#{name}.json"
+                else
+                  "https://rubygems.org/api/v2/rubygems/#{name}/versions/#{version}.json"
+                end
+
+      response = Faraday.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.
+      return fetch_rubygems_data(name, nil) if !response.success? && !version.nil?
+
+      response.success? ? JSON.parse(response.body) : nil
     end
   end
 end

data/lib/bundle_update_interactive/cli/options.rb

@@ -0,0 +1,52 @@
+# 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
+
+      private
+
+      def build_parser(options) # rubocop:disable Metrics/MethodLength
+        OptionParser.new do |parser|
+          parser.banner = "Usage: bundle update-interactive"
+          parser.on(
+            "--exclusively=GROUP",
+            "Update gems that exclusively belong to the specified Gemfile GROUP(s) (comma-separated)"
+          ) do |value|
+            options.exclusively = value.split(",").map(&:strip).reject(&:empty?).map(&:to_sym)
+          end
+          parser.on(
+            "-D",
+            "Update development and test gems only; short for --exclusively=development,test"
+          ) do
+            options.exclusively = %i[development test]
+          end
+          parser.on("-v", "--version", "Display bundle_update_interactive 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 parser
+            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/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/outdated_gem.rb

@@ -35,8 +35,8 @@ module BundleUpdateInteractive
       return @changelog_uri if defined?(@changelog_uri)
 
       @changelog_uri =
-        if git_version_changed? && github_repo
-          "https://github.com/#{github_repo}/compare/#{current_git_version}...#{updated_git_version}"
+        if (diff_url = build_git_diff_url)
+          diff_url
         elsif rubygems_source?
           changelog_locator.find_changelog_uri(name: name, version: updated_version.to_s)
         else
@@ -56,10 +56,34 @@ module BundleUpdateInteractive
 
     attr_reader :changelog_locator
 
+    def build_git_diff_url
+      return nil unless git_version_changed?
+
+      if github_repo
+        "https://github.com/#{github_repo}/compare/#{current_git_version}...#{updated_git_version}"
+      elsif gitlab_repo
+        "https://gitlab.com/os85/httpx/-/compare/#{current_git_version}...#{updated_git_version}"
+      elsif bitbucket_cloud_repo
+        "https://bitbucket.org/#{bitbucket_cloud_repo}/branches/compare/#{updated_git_version}..#{current_git_version}"
+      end
+    end
+
     def github_repo
       return nil unless updated_git_version
 
       git_source_uri.to_s[%r{^(?:git@github.com:|https://github.com/)([^/]+/[^/]+?)(:?\.git)?(?:$|/)}i, 1]
     end
+
+    def gitlab_repo
+      return nil unless updated_git_version
+
+      git_source_uri.to_s[%r{^(?:git@gitlab.com:|https://gitlab.com/)([^/]+/[^/]+?)(:?\.git)?(?:$|/)}i, 1]
+    end
+
+    def bitbucket_cloud_repo
+      return nil unless updated_git_version
+
+      git_source_uri.to_s[%r{(?:@|://)bitbucket.org[:/]([^/]+/[^/]+?)(:?\.git)?(?:$|/)}i, 1]
+    end
   end
 end

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.2.1"
+  VERSION = "0.4.0"
 end

data/lib/bundle_update_interactive.rb

@@ -6,6 +6,7 @@ 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 :Lockfile, "bundle_update_interactive/lockfile"
   autoload :LockfileEntry, "bundle_update_interactive/lockfile_entry"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bundle_update_interactive
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Matt Brictson
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-07-17 00:00:00.000000000 Z
+date: 2024-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,20 +66,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,9 +112,10 @@ 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/lockfile.rb
 - lib/bundle_update_interactive/lockfile_entry.rb
@@ -160,7 +147,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