bundle_update_interactive 0.6.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e71278ee6c0ffbfb39537712a8d97e956c57062dad9723d358d97474cf63b69c
-  data.tar.gz: 13491cad6f990d97fb3a2c918913fb4bc5eb5048829a18dd8c5400f6e5f9fadf
+  metadata.gz: 0cbe5e5a4fef836edfd7c1bc87939066c2f7460f4f1b883510ea065840747a54
+  data.tar.gz: 26bc0b61f7d3d2830c3fd687bd8e723486446cdbe6acf91455e6d02dfbb93df6
 SHA512:
-  metadata.gz: 9bf5c295484ae3aa19d12d5891afd7883873204d0a9314babcf111b832cab60b89be13afcb6f33e8a8d2cbc7b702df9b0c800ca0639a2c8148e56adb6964cde4
-  data.tar.gz: 0caebaf4d1bbc2a2d3cd6a5820ed031491a41a43286d7ba6f3e7bf419c28c5627ac58b8bed0407658d46efdc01d105f75857c66784b61b98eb581c00fe0ec575
+  metadata.gz: d351f14505560566df5b09fd27ca1a537bca621208bb1859bb6ba1a430333a5889a2d8f1dfd6ce5b72ede3cecb3429c148a1e48a3a795c3290effe0e37c207d0
+  data.tar.gz: c649e223608a24c65715f7c430abc64841b41a8d765612a57c64cc5c7c56f4cc1327389916521c5f19af0742e177b4f3e5d31267aacbda3048efa5b9b9b0cc78

data/README.md

@@ -12,6 +12,7 @@
 ---
 
 - [Quick start](#quick-start)
+- [Options](#options)
 - [Features](#features)
 - [Prior art](#prior-art)
 - [Support](#support)
@@ -39,6 +40,11 @@ Or the shorthand:
 bundle ui
 ```
 
+## Options
+
+- `--latest` [modifies the Gemfile if necessary to allow the latest gem versions](#allow-latest-versions)
+- `-D` / `--exclusively=GROUP` [limits updatable gems by Gemfile groups](#limit-impact-by-gemfile-groups)
+
 ## Features
 
 ### Semver highlighting
@@ -63,6 +69,36 @@ Some gems, notably `rails`, are composed of smaller gems like `actionpack`, `act
 
 Therefore, if any Rails component has a security vulnerability, `bundle update-interactive` will automatically roll up that information into a single `rails` line item, so you can select it and upgrade all of its components in one shot.
 
+### Held back gems
+
+When a newer version of a gem is available, but updating is not allowed due to a Gemfile requirement, `update-interactive` will report that the gem has been held back.
+
+<img src="images/held-back.png" alt="Screenshot of rails and selenium-webdriver gems held back due to Gemfile requirements" width="717" />
+
+To allow updates for gems that would normally be held back, use the `--latest` option (explained in the next section).
+
+### Allow latest versions
+
+Normally `update-interactive` only makes changes to your Gemfile.lock. It honors the version restrictions ("pins") in your Gemfile and will not update your Gemfile.lock to have versions that are not allowed. However with the `--latest` flag, update-interactive can update the version pins in your Gemfile as well. Consider the following Gemfile:
+
+```ruby
+gem "rails", "~> 7.1.0"
+```
+
+Normally running `bundle update-interactive` will report that Rails is held back and therefore cannot be updated to the latest version. However, if you pass the `--latest` option like this:
+
+```
+bundle update-interactive --latest
+```
+
+Now Rails will be allowed to update. If you select to update Rails to the latest version (e.g. 7.2.0), `update-interactive` will modify the version requirement in your Gemfile to look like this:
+
+```ruby
+gem "rails", "~> 7.2.0"
+```
+
+In other words, it works similarly to `yarn upgrade-interactive --latest`.
+
 ### Changelogs
 
 `bundle update-interactive` will do its best to find an appropriate changelog for each gem.

data/lib/bundle_update_interactive/bundler_commands.rb

@@ -10,6 +10,13 @@ module BundleUpdateInteractive
         system "#{bundle_bin.shellescape} update --conservative #{gems.flatten.map(&:shellescape).join(' ')}"
       end
 
+      def lock
+        success = system "#{bundle_bin.shellescape} lock"
+        raise "bundle lock command failed" unless success
+
+        true
+      end
+
       def read_updated_lockfile(*gems)
         command = ["#{bundle_bin.shellescape} lock --print"]
         command << "--conservative" if gems.any?
@@ -19,6 +26,14 @@ module BundleUpdateInteractive
         `#{command.join(" ")}`.tap { raise "bundle lock command failed" unless Process.last_status.success? }
       end
 
+      def parse_outdated(*gems)
+        command = ["#{bundle_bin.shellescape} outdated --parseable", *gems.flatten.map(&:shellescape)]
+        output = `#{command.join(" ")}`
+        raise "bundle outdated command failed" if output.empty? && !Process.last_status.success?
+
+        output.scan(/^(\S+) \(newest (\S+),/).to_h
+      end
+
       private
 
       def bundle_bin

data/lib/bundle_update_interactive/cli/multi_select.rb

@@ -7,6 +7,8 @@ require "tty/screen"
 
 class BundleUpdateInteractive::CLI
   class MultiSelect
+    extend BundleUpdateInteractive::StringHelper
+
     class List < TTY::Prompt::MultiList
       def initialize(prompt, **options)
         @opener = options.delete(:opener)
@@ -46,8 +48,8 @@ class BundleUpdateInteractive::CLI
     end
 
     def self.prompt_for_gems_to_update(outdated_gems, prompt: nil)
-      table = Table.new(outdated_gems)
-      title = "#{outdated_gems.length} gems can be updated."
+      table = Table.updatable(outdated_gems)
+      title = "#{pluralize(outdated_gems.length, 'gem')} can be updated."
       opener = lambda do |gem|
         url = outdated_gems[gem].changelog_uri
         Launchy.open(url) unless url.nil?

data/lib/bundle_update_interactive/cli/options.rb

@@ -48,6 +48,9 @@ module BundleUpdateInteractive
             Show updates for development and test gems only, leaving production gems untouched.
             #{pastel.green('bundle update-interactive')} #{pastel.yellow('-D')}
 
+            Allow the latest gem versions, ignoring Gemfile pins. May modify the Gemfile.
+            #{pastel.green('bundle update-interactive')} #{pastel.yellow('--latest')}
+
         HELP
       end
 
@@ -61,6 +64,9 @@ module BundleUpdateInteractive
         OptionParser.new do |parser|
           parser.summary_indent = "  "
           parser.summary_width = 24
+          parser.on("--latest", "Modify the Gemfile to allow the latest gem versions") do
+            options.latest = true
+          end
           parser.on(
             "--exclusively=GROUP",
             "Update gems exclusively belonging to the specified Gemfile GROUP(s)"
@@ -84,9 +90,15 @@ module BundleUpdateInteractive
     end
 
     attr_accessor :exclusively
+    attr_writer :latest
 
     def initialize
       @exclusively = []
+      @latest = false
+    end
+
+    def latest?
+      @latest
     end
   end
 end

data/lib/bundle_update_interactive/cli/row.rb

@@ -16,17 +16,6 @@ class BundleUpdateInteractive::CLI
       @pastel = BundleUpdateInteractive.pastel
     end
 
-    def to_a
-      [
-        formatted_gem_name,
-        formatted_current_version,
-        "→",
-        formatted_updated_version,
-        formatted_gemfile_groups,
-        formatted_changelog_uri
-      ]
-    end
-
     def formatted_gem_name
       vulnerable? ? pastel.white.on_red(name) : apply_semver_highlight(name)
     end
@@ -46,6 +35,10 @@ class BundleUpdateInteractive::CLI
       gemfile_groups&.map(&:inspect)&.join(", ")
     end
 
+    def formatted_gemfile_requirement
+      gemfile_requirement.to_s == ">= 0" ? "" : gemfile_requirement.to_s
+    end
+
     def formatted_changelog_uri
       pastel.blue(changelog_uri)
     end

data/lib/bundle_update_interactive/cli/table.rb

@@ -4,12 +4,44 @@ require "pastel"
 
 class BundleUpdateInteractive::CLI
   class Table
-    HEADERS = ["name", "from", nil, "to", "group", "url"].freeze
+    class << self
+      def withheld(gems)
+        columns = [
+          ["name", :formatted_gem_name],
+          ["requirement", :formatted_gemfile_requirement],
+          ["current", :formatted_current_version],
+          ["latest", :formatted_updated_version],
+          ["group", :formatted_gemfile_groups],
+          ["url", :formatted_changelog_uri]
+        ]
+        new(gems, columns)
+      end
 
-    def initialize(outdated_gems)
+      def updatable(gems)
+        columns = [
+          ["name", :formatted_gem_name],
+          ["from", :formatted_current_version],
+          [nil, "→"],
+          ["to", :formatted_updated_version],
+          ["group", :formatted_gemfile_groups],
+          ["url", :formatted_changelog_uri]
+        ]
+        new(gems, columns)
+      end
+    end
+
+    def initialize(gems, columns)
       @pastel = BundleUpdateInteractive.pastel
-      @headers = HEADERS.map { |h| pastel.dim.underline(h) }
-      @rows = outdated_gems.transform_values { |gem| Row.new(gem).to_a.map(&:to_s) }
+      @headers = columns.map { |header, _| pastel.dim.underline(header) }
+      @rows = gems.transform_values do |gem|
+        row = Row.new(gem)
+        columns.map do |_, col|
+          case col
+          when Symbol then row.public_send(col).to_s
+          when String then col
+          end
+        end
+      end
       @column_widths = calculate_column_widths
     end
 

data/lib/bundle_update_interactive/cli.rb

@@ -4,34 +4,42 @@ require "bundler"
 
 module BundleUpdateInteractive
   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"
-
     def run(argv: ARGV) # rubocop:disable Metrics/AbcSize
       options = Options.parse(argv)
+      report, updater = generate_report(options)
 
-      report = generate_report(options)
-      puts("No gems to update.").then { return } if report.updateable_gems.empty?
+      puts_legend_and_withheld_gems(report) unless report.empty?
+      puts("No gems to update.").then { return } if report.updatable_gems.empty?
 
-      puts
-      puts legend
-      puts
-      selected_gems = MultiSelect.prompt_for_gems_to_update(report.updateable_gems)
+      selected_gems = MultiSelect.prompt_for_gems_to_update(report.updatable_gems)
       puts("No gems to update.").then { return } if selected_gems.empty?
 
-      puts "\nUpdating the following gems."
+      puts "Updating the following gems."
+      puts Table.updatable(selected_gems).render
       puts
-      puts Table.new(selected_gems).render
-      puts
-      report.bundle_update!(*selected_gems.keys)
+      updater.apply_updates(*selected_gems.keys)
+      puts_gemfile_modified_notice if updater.modified_gemfile?
     rescue Exception => e # rubocop:disable Lint/RescueException
       handle_exception(e)
     end
 
     private
 
+    def puts_gemfile_modified_notice
+      puts BundleUpdateInteractive.pastel.yellow("Your Gemfile was changed to accommodate the latest gem versions.")
+    end
+
+    def puts_legend_and_withheld_gems(report)
+      puts
+      puts legend
+      puts
+      return if report.withheld_gems.empty?
+
+      puts "The following gems are being held back and cannot be updated."
+      puts Table.withheld(report.withheld_gems).render
+      puts
+    end
+
     def legend
       pastel = BundleUpdateInteractive.pastel
       <<~LEGEND
@@ -46,15 +54,17 @@ module BundleUpdateInteractive
 
     def generate_report(options)
       whisper "Resolving latest gem versions..."
-      report = Report.generate(groups: options.exclusively)
-      updateable_gems = report.updateable_gems
-      return report if updateable_gems.empty?
+      updater_class = options.latest? ? Latest::Updater : Updater
+      updater = updater_class.new(groups: options.exclusively)
 
-      whisper "Checking for security vulnerabilities..."
-      report.scan_for_vulnerabilities!
+      report = updater.generate_report
+      unless report.empty?
+        whisper "Checking for security vulnerabilities..."
+        report.scan_for_vulnerabilities!
+        progress "Finding changelogs", report.all_gems.values, &:changelog_uri
+      end
 
-      progress "Finding changelogs", updateable_gems.values, &:changelog_uri
-      report
+      [report, updater]
     end
 
     def whisper(message)

data/lib/bundle_update_interactive/latest/gem_requirement.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module BundleUpdateInteractive
+  module Latest
+    class GemRequirement
+      def self.parse(version)
+        return version if version.is_a?(GemRequirement)
+
+        _, operator, number = version.strip.match(/^([^\d\s]*)\s*(.+)/).to_a
+        operator = nil if operator.empty?
+
+        new(parts: number.split("."), operator: operator, parsed_from: version)
+      end
+
+      attr_reader :parts, :operator
+
+      def initialize(parts:, operator: nil, parsed_from: nil)
+        @parts = parts
+        @operator = operator
+        @parsed_from = parsed_from
+      end
+
+      def exact?
+        operator.nil?
+      end
+
+      def relax
+        return self if %w[!= > >=].include?(operator)
+        return self.class.parse(">= 0") if %w[< <=].include?(operator)
+
+        self.class.new(parts: parts, operator: ">=")
+      end
+
+      def shift(new_version) # rubocop:disable Metrics/AbcSize
+        return self.class.parse(new_version) if exact?
+        return self if Gem::Requirement.new(to_s).satisfied_by?(Gem::Version.new(new_version))
+        return self.class.new(parts: self.class.parse(new_version).parts, operator: "<=") if %w[< <=].include?(operator)
+
+        new_slice = self.class.parse(new_version).slice(parts.length)
+        self.class.new(parts: new_slice.parts, operator: "~>")
+      end
+
+      def slice(amount)
+        self.class.new(parts: parts[0, amount], operator: operator)
+      end
+
+      def to_s
+        parsed_from || [operator, parts.join(".")].compact.join(" ")
+      end
+
+      def ==(other)
+        return false unless other.is_a?(GemRequirement)
+
+        to_s == other.to_s
+      end
+
+      private
+
+      attr_reader :parsed_from
+    end
+  end
+end

data/lib/bundle_update_interactive/latest/gemfile_editor.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module BundleUpdateInteractive
+  module Latest
+    class GemfileEditor
+      def initialize(gemfile_path: "Gemfile", lockfile_path: "Gemfile.lock")
+        @gemfile_path = gemfile_path
+        @lockfile_path = lockfile_path
+      end
+
+      def with_relaxed_gemfile
+        original, modified = modify_gemfile { |_, requirement| requirement.relax }
+        yield
+      ensure
+        File.write(gemfile_path, original) if original && original != modified
+      end
+
+      def shift_gemfile
+        lockfile = Lockfile.parse(File.read(lockfile_path))
+        original, modified = modify_gemfile do |name, requirement|
+          lockfile_entry = lockfile[name]
+          requirement.shift(lockfile_entry.version.to_s) if lockfile_entry
+        end
+        original != modified
+      end
+
+      private
+
+      attr_reader :gemfile_path, :lockfile_path
+
+      def modify_gemfile(&block)
+        original_contents = File.read(gemfile_path)
+        new_contents = original_contents.dup
+
+        find_rewritable_gem_names(original_contents).each do |name|
+          rewrite_contents(name, new_contents, &block)
+        end
+
+        File.write(gemfile_path, new_contents) unless new_contents == original_contents
+        [original_contents, new_contents]
+      end
+
+      def find_rewritable_gem_names(contents)
+        Gemfile.parse(gemfile_path).dependencies.filter_map do |dep|
+          gem_name = dep.name
+          gem_name if gem_declaration_with_requirement_re(gem_name).match?(contents)
+        end
+      end
+
+      def rewrite_contents(gem_name, contents)
+        found = contents.sub!(gem_declaration_with_requirement_re(gem_name)) do |match|
+          version = Regexp.last_match[1]
+          match[Regexp.last_match.regexp, 1] = yield(gem_name, GemRequirement.parse(version)).to_s
+          match
+        end
+        raise "Can't rewrite version for #{gem_name}" unless found
+      end
+
+      def gem_declaration_re(gem_name)
+        /^\s*gem\s+["']#{Regexp.escape(gem_name)}["']/
+      end
+
+      def gem_declaration_with_requirement_re(gem_name)
+        /#{gem_declaration_re(gem_name)},\s*["']([^'"]+)["']/
+      end
+    end
+  end
+end

data/lib/bundle_update_interactive/latest/updater.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# Extends the default Updater class to allow updating to the latest gem versions.
+# Does this by using GemfileEditor to relax the Gemfile requirements before
+# `find_updatable_gems` and `apply_updates` are called.
+module BundleUpdateInteractive
+  module Latest
+    class Updater < BundleUpdateInteractive::Updater
+      def initialize(editor: GemfileEditor.new, **kwargs)
+        super(**kwargs)
+        @modified_gemfile = false
+        @editor = editor
+      end
+
+      def apply_updates(*, **)
+        result = editor.with_relaxed_gemfile { super }
+        @modified_gemfile = editor.shift_gemfile
+        BundlerCommands.lock
+        result
+      end
+
+      def modified_gemfile?
+        @modified_gemfile
+      end
+
+      private
+
+      attr_reader :editor
+
+      def find_updatable_gems
+        editor.with_relaxed_gemfile { super }
+      end
+
+      # Overrides the default Updater implementation.
+      # When updating the latest gems, by definition nothing is withheld, so we can skip this.
+      def find_withheld_gems(**)
+        {}
+      end
+    end
+  end
+end

data/lib/bundle_update_interactive/outdated_gem.rb

@@ -4,6 +4,7 @@ module BundleUpdateInteractive
   class OutdatedGem
     attr_accessor :name,
                   :gemfile_groups,
+                  :gemfile_requirement,
                   :git_source_uri,
                   :current_version,
                   :current_git_version,

data/lib/bundle_update_interactive/report.rb

@@ -7,78 +7,38 @@ require "set"
 
 module BundleUpdateInteractive
   class Report
-    class << self
-      def generate(groups: [])
-        gemfile = Gemfile.parse
-        current_lockfile = Lockfile.parse
-        gems = groups.any? ? current_lockfile.gems_exclusively_installed_by(gemfile: gemfile, groups: groups) : nil
+    attr_reader :withheld_gems, :updatable_gems
 
-        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
-
-    attr_reader :outdated_gems
-
-    def initialize(gemfile:, current_lockfile:, updated_lockfile:)
+    def initialize(current_lockfile:, withheld_gems:, updatable_gems:)
       @current_lockfile = current_lockfile
-      @outdated_gems = current_lockfile.entries.each_with_object({}) do |current_lockfile_entry, hash|
-        name = current_lockfile_entry.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)
-      end.freeze
+      @withheld_gems = withheld_gems.freeze
+      @updatable_gems = updatable_gems.freeze
     end
 
-    def [](gem_name)
-      outdated_gems[gem_name]
+    def empty?
+      withheld_gems.empty? && updatable_gems.empty?
     end
 
-    def updateable_gems
-      @updateable_gems ||= outdated_gems.reject do |name, _|
-        current_lockfile[name].exact_requirement?
-      end.freeze
-    end
-
-    def expand_gems_with_exact_dependencies(*gem_names)
-      gem_names.flatten!
-      gem_names.flat_map { |name| [name, *current_lockfile[name].exact_dependencies] }.uniq
+    def all_gems
+      @all_gems ||= withheld_gems.merge(updatable_gems)
     end
 
     def scan_for_vulnerabilities!
-      return false if outdated_gems.empty?
+      return false if all_gems.empty?
 
       Bundler::Audit::Database.update!(quiet: true)
       audit_report = Bundler::Audit::Scanner.new.report
       vulnerable_gem_names = Set.new(audit_report.vulnerable_gems.map(&:name))
 
-      outdated_gems.each do |name, gem|
-        gem.vulnerable = (vulnerable_gem_names & [name, *current_lockfile[name].exact_dependencies]).any?
+      all_gems.each do |name, gem|
+        exact_deps = current_lockfile && current_lockfile[name].exact_dependencies
+        gem.vulnerable = (vulnerable_gem_names & [name, *Array(exact_deps)]).any?
       end
       true
     end
 
-    def bundle_update!(*gem_names)
-      expanded_names = expand_gems_with_exact_dependencies(*gem_names)
-      BundlerCommands.update_gems_conservatively(*expanded_names)
-    end
-
     private
 
     attr_reader :current_lockfile
-
-    def build_outdated_gem(current_lockfile_entry, updated_lockfile_entry, gemfile_groups)
-      OutdatedGem.new(
-        name: current_lockfile_entry.name,
-        gemfile_groups: gemfile_groups,
-        rubygems_source: updated_lockfile_entry.rubygems_source?,
-        git_source_uri: updated_lockfile_entry.git_source_uri&.to_s,
-        current_version: current_lockfile_entry.version.to_s,
-        current_git_version: current_lockfile_entry.git_version&.strip,
-        updated_version: updated_lockfile_entry.version.to_s,
-        updated_git_version: updated_lockfile_entry.git_version&.strip
-      )
-    end
   end
 end

data/lib/bundle_update_interactive/string_helper.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# lib/bundle_update_interactive/string_helper.rb
+module BundleUpdateInteractive
+  module StringHelper
+    def pluralize(count, singular, plural=nil)
+      plural ||= "#{singular}s"
+      "#{count} #{count == 1 ? singular : plural}"
+    end
+    module_function :pluralize
+  end
+end

data/lib/bundle_update_interactive/updater.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module BundleUpdateInteractive
+  class Updater
+    def initialize(groups: [])
+      @gemfile = Gemfile.parse
+      @current_lockfile = Lockfile.parse
+      @candidate_gems = current_lockfile.gems_exclusively_installed_by(gemfile: gemfile, groups: groups) if groups.any?
+    end
+
+    def generate_report
+      updatable_gems = find_updatable_gems
+      withheld_gems = find_withheld_gems(exclude: updatable_gems.keys)
+
+      Report.new(current_lockfile: current_lockfile, updatable_gems: updatable_gems, withheld_gems: withheld_gems)
+    end
+
+    def apply_updates(*gem_names)
+      expanded_names = expand_gems_with_exact_dependencies(*gem_names)
+      BundlerCommands.update_gems_conservatively(*expanded_names)
+    end
+
+    # Overridden by Latest::Updater subclass
+    def modified_gemfile?
+      false
+    end
+
+    private
+
+    attr_reader :gemfile, :current_lockfile, :candidate_gems
+
+    def find_updatable_gems
+      return {} if candidate_gems && candidate_gems.empty?
+
+      updated_lockfile = Lockfile.parse(BundlerCommands.read_updated_lockfile(*Array(candidate_gems)))
+      current_lockfile.entries.each_with_object({}) do |current_lockfile_entry, hash|
+        name = current_lockfile_entry.name
+        updated_lockfile_entry = updated_lockfile && updated_lockfile[name]
+        next unless current_lockfile_entry.older_than?(updated_lockfile_entry)
+        next if current_lockfile_entry.exact_requirement?
+
+        hash[name] = build_outdated_gem(name, updated_lockfile_entry.version, updated_lockfile_entry.git_version)
+      end
+    end
+
+    def find_withheld_gems(exclude: [])
+      possibly_withheld = gemfile.dependencies.filter_map do |dep|
+        dep.name if dep.should_include? && !dep.requirement.none? # rubocop:disable Style/InverseMethods
+      end
+      possibly_withheld -= exclude
+      possibly_withheld &= candidate_gems unless candidate_gems.nil?
+
+      return {} if possibly_withheld.empty?
+
+      BundlerCommands.parse_outdated(*possibly_withheld).to_h do |name, newest|
+        [name, build_outdated_gem(name, newest, nil)]
+      end
+    end
+
+    def build_outdated_gem(name, updated_version, updated_git_version)
+      current_lockfile_entry = current_lockfile[name]
+
+      OutdatedGem.new(
+        name: name,
+        gemfile_groups: gemfile[name]&.groups,
+        gemfile_requirement: gemfile[name]&.requirement&.to_s,
+        rubygems_source: current_lockfile_entry.rubygems_source?,
+        git_source_uri: current_lockfile_entry.git_source_uri&.to_s,
+        current_version: current_lockfile_entry.version.to_s,
+        current_git_version: current_lockfile_entry.git_version&.strip,
+        updated_version: updated_version.to_s,
+        updated_git_version: updated_git_version&.strip
+      )
+    end
+
+    def expand_gems_with_exact_dependencies(*gem_names)
+      gem_names.flatten!
+      gem_names.flat_map { |name| [name, *current_lockfile[name].exact_dependencies] }.uniq
+    end
+  end
+end

data/lib/bundle_update_interactive/version.rb

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

data/lib/bundle_update_interactive.rb

@@ -2,20 +2,13 @@
 
 require "pastel"
 
-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"
-  autoload :Report, "bundle_update_interactive/report"
-  autoload :SemverChange, "bundle_update_interactive/semver_change"
-  autoload :VERSION, "bundle_update_interactive/version"
+require "zeitwerk"
+loader = Zeitwerk::Loader.for_gem
+loader.inflector.inflect "cli" => "CLI"
+loader.inflector.inflect "http" => "HTTP"
+loader.setup
 
+module BundleUpdateInteractive
   class << self
     attr_accessor :pastel
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bundle_update_interactive
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Matt Brictson
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-08-10 00:00:00.000000000 Z
+date: 2024-08-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -94,6 +94,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.8.2
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
 description:
 email:
 - opensource@mattbrictson.com
@@ -118,11 +132,16 @@ files:
 - lib/bundle_update_interactive/error.rb
 - lib/bundle_update_interactive/gemfile.rb
 - lib/bundle_update_interactive/http.rb
+- lib/bundle_update_interactive/latest/gem_requirement.rb
+- lib/bundle_update_interactive/latest/gemfile_editor.rb
+- lib/bundle_update_interactive/latest/updater.rb
 - lib/bundle_update_interactive/lockfile.rb
 - lib/bundle_update_interactive/lockfile_entry.rb
 - lib/bundle_update_interactive/outdated_gem.rb
 - lib/bundle_update_interactive/report.rb
 - lib/bundle_update_interactive/semver_change.rb
+- lib/bundle_update_interactive/string_helper.rb
+- lib/bundle_update_interactive/updater.rb
 - lib/bundle_update_interactive/version.rb
 homepage: https://github.com/mattbrictson/bundle_update_interactive
 licenses:
@@ -148,7 +167,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.16
+rubygems_version: 3.5.11
 signing_key:
 specification_version: 4
 summary: Adds an update-interactive command to Bundler