bundler-interactive 0.1.2.1 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7cb83b26ff4dea18f9dcfb7c8aa94ca8b1a90ed6e87f6cf3350686e75d828dee
-  data.tar.gz: ca98b4c3abd8b9654341d960f19af1867f29fa87da2d3cb72620527d1fa9308d
+  metadata.gz: dfd73e115e07573a200d343fa615b58145d99c31875eec4dd5e9082d8738b264
+  data.tar.gz: fbf663bfb19615ee023946b2adec69079a4d7ba7b2a6d69d94c2391d3cfa8fa6
 SHA512:
-  metadata.gz: 618be7c402a08da7a0e4a46098b2aed18ec20dad968e3d34be05ed0192bbb90acbe90fd364bc6394ab5e2fe891d98917110c919195a9a147b45e63420c43168b
-  data.tar.gz: d4aa3d4202a94a0a555d315f46c34e44969c886d753864ae2097953f19c052c556c749df1cc221af737ab0e445a574ceec8a931e05fda51fe362e4ec097adb0b
+  metadata.gz: 5b5621ad3e3e46be1b93afb3bbdf1f0ce974168cfd340766cee04357a88e3ad75aead8a2d794d535eec6462e4697cc28e7fa0853bc27b206e1f83bbcdc606d67
+  data.tar.gz: f051064dc386dfc6ab892f8c6406d56e154892d817c76b46b8f9cb4e3d054cfe81f770a539730260e0cdeb0ebd8f2c4f05e8bf6c1683b7af708609c023774460

data/.github/workflows/ci.yml

@@ -0,0 +1,37 @@
+name: CI
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+
+jobs:
+  test:
+    name: Ruby ${{ matrix.ruby }} / Bundler ${{ matrix.bundler }}
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    strategy:
+      fail-fast: false
+      matrix:
+        # Bundler 4.x requires Ruby >= 3.2.
+        ruby: ["3.2", "3.3", "3.4", "4.0"]
+        # This is a Bundler plugin, so the Bundler version is the axis that
+        # matters most: "default" exercises the Bundler that ships with each
+        # Ruby, and "latest" guards against API drift and covers the cooldown
+        # feature (Bundler >= 4.0.13).
+        bundler: [default, latest]
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v5
+
+      - name: Set up Ruby and bundle install
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler: ${{ matrix.bundler }}
+          bundler-cache: true
+          rubygems: latest
+
+      - name: Run tests
+        run: bundle exec rspec

data/.gitignore

@@ -11,3 +11,6 @@ Gemfile.lock
 
 # rspec failure tracking
 .rspec_status
+
+*.pem
+bundler-interactive*.gem

data/README.md

@@ -1,6 +1,9 @@
 # Bundler::Interactive
 
-This is a plugin to Bundler which provides an interactive interface to manage updating outdated gems within your project similar to [`yarn upgrade-interactive`]
+A Bundler plugin that turns updating your gems into a quick, interactive pass —
+think [`yarn upgrade-interactive`], but for your Gemfile. Instead of guessing
+which gems are behind and editing version numbers by hand, you get a list you
+can walk through and pick exactly what to bump.
 
 ## Installation
 
@@ -8,8 +11,57 @@ This is a plugin to Bundler which provides an interactive interface to manage up
 
 ## Usage
 
+From a project with a Gemfile, run:
+
     $ bundle update-interactive
 
+(`bundle upgrade-interactive` works too — it's an alias, for muscle memory
+either way.)
+
+You'll see one row per outdated gem, showing its group (development, test, …)
+and the versions you can move to:
+
+```
+Select gems and target versions to update:
+* = newer version held by cooldown
+❯ rake   (default)            12.0.0   [12.3.3]   13.4.2
+  rexml  (development,test)   3.4.0   [3.4.1]   3.4.4*
+```
+
+Each row offers up to three targets:
+
+- **current** — what's installed now
+- **in-range** — the newest version your Gemfile constraint already allows
+- **latest** — the newest version published, even if it's beyond your constraint
+
+### Keys
+
+| Key            | Action                                            |
+| -------------- | ------------------------------------------------- |
+| `↑` / `↓`      | move between gems                                 |
+| `←` / `→`      | choose a target version for the highlighted gem   |
+| `space`        | skip a gem (or restore it)                        |
+| `enter`        | apply your selections                             |
+| `q` / `Ctrl-C` | cancel without changing anything                  |
+
+The selected version is shown in `[brackets]`. By default each gem is set to its
+in-range latest; gems where the only newer option is **beyond** your constraint
+start out skipped, so pressing `enter` never changes your Gemfile unless you ask
+it to.
+
+When you hit `enter`, Bundler updates the lockfile for everything you picked. If
+you chose a version that's outside the current constraint, the matching line in
+your Gemfile is rewritten to allow it first.
+
+### Cooldown
+
+If you've enabled Bundler's [cooldown] setting (Bundler 4.0.13+), which holds
+back gem versions for a few days after release as a supply-chain safeguard,
+`bundle update-interactive` respects it: the versions you can pick are the ones
+Bundler will actually install. A version that's newer but still inside the
+cooldown window is shown with an asterisk (`*`) so you know an update is coming
+once it clears.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
@@ -22,3 +74,4 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/wesric
 
 
 [`yarn upgrade-interactive`]: https://yarnpkg.com/lang/en/docs/cli/upgrade-interactive/
+[cooldown]: https://blog.rubygems.org/2026/06/03/cooldown-let-new-gems-be-vetted.html

data/bundler-interactive.gemspec

@@ -39,7 +39,7 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version     = '>= 2.3.0'
 
   spec.add_development_dependency 'bundler', '>= 1.16'
-  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rake', '>= 10.0'
   spec.add_development_dependency 'rspec', '~> 3.0'
 
   spec.add_dependency 'tty-prompt'

data/lib/bundler/interactive/gemfile_editor.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Bundler
+  module Interactive
+    # Rewrites a gem's version requirement in the Gemfile when the user picks a
+    # version beyond the declared constraint.
+    #
+    # Bundler's own Injector can only append or remove entries, so this performs
+    # a targeted, in-place edit of the existing `gem "name", ...` line, keeping
+    # any groups, options, and trailing comments intact. When no editable line
+    # is found it warns and returns false rather than risk corrupting the file.
+    class GemfileEditor
+      def initialize(name, target_version, gemfile_path: Bundler.default_gemfile)
+        @name = name
+        @target = Gem::Version.new(target_version.to_s)
+        @gemfile_path = gemfile_path
+      end
+
+      def rewrite!
+        content = File.read(@gemfile_path)
+        updated = replace_requirement(content)
+
+        if updated.nil?
+          warn_unfound
+          return false
+        end
+
+        File.write(@gemfile_path, updated)
+        true
+      rescue StandardError => e
+        warn_failure(e)
+        false
+      end
+
+      # A pessimistic requirement that admits the chosen version, pinned to its
+      # major.minor (e.g. 8.0.1 -> "~> 8.0").
+      def new_requirement
+        "~> #{@target.segments.first(2).join('.')}"
+      end
+
+      private
+
+      def replace_requirement(content)
+        pattern = /^(?<indent>[ \t]*)gem\s+(?<q>['"])#{Regexp.escape(@name)}\k<q>(?<rest>[^\n]*)$/
+        match = content.match(pattern)
+        return nil unless match
+
+        content.sub(pattern) do
+          "#{match[:indent]}gem #{match[:q]}#{@name}#{match[:q]}#{rebuild_rest(match[:rest])}"
+        end
+      end
+
+      # Strips any existing version-requirement string literals that follow the
+      # gem name and inserts the new requirement, preserving option pairs and a
+      # trailing comment.
+      def rebuild_rest(rest)
+        code, comment = split_comment(rest)
+        remainder = strip_leading_versions(code.strip.sub(/\A,\s*/, ''))
+
+        parts = ["\"#{new_requirement}\""]
+        parts << remainder unless remainder.empty?
+
+        result = ", #{parts.join(', ')}"
+        comment.empty? ? result : "#{result} #{comment}"
+      end
+
+      def split_comment(rest)
+        if (index = comment_index(rest))
+          [rest[0...index], rest[index..-1].strip]
+        else
+          [rest, '']
+        end
+      end
+
+      # Index of a `#` that begins a comment (i.e. one not inside a string).
+      def comment_index(rest)
+        in_string = nil
+        rest.each_char.with_index do |char, index|
+          if in_string
+            in_string = nil if char == in_string
+          elsif char == '"' || char == "'"
+            in_string = char
+          elsif char == '#'
+            return index
+          end
+        end
+        nil
+      end
+
+      def strip_leading_versions(code)
+        loop do
+          match = code.match(/\A(?<q>['"])(?<req>[^'"]*)\k<q>\s*,?\s*/)
+          break unless match && version_requirement?(match[:req])
+
+          code = code[match[0].length..-1]
+        end
+        code.strip
+      end
+
+      def version_requirement?(string)
+        Gem::Requirement::PATTERN.match?(string.strip)
+      end
+
+      def warn_unfound
+        Bundler.ui.warn(
+          "bundler-interactive: could not find an editable `gem \"#{@name}\"` line in " \
+          "#{@gemfile_path}; updating #{@name} within its existing constraint instead."
+        )
+      end
+
+      def warn_failure(error)
+        Bundler.ui.warn(
+          "bundler-interactive: failed to rewrite the Gemfile for #{@name} " \
+          "(#{error.message}); updating within its existing constraint instead."
+        )
+      end
+    end
+  end
+end

data/lib/bundler/interactive/outdated_gem.rb

@@ -2,54 +2,165 @@
 
 module Bundler
   module Interactive
+    # View-model for a single outdated gem row in the interactive table.
+    #
+    # It exposes an ordered, de-duplicated list of selectable version +choices+
+    # (current -> in-range latest -> absolute latest) and tracks which one the
+    # user has highlighted. The renderer cycles the selection with
+    # +cycle_left+/+cycle_right+ and reads +selected_version+ when applying.
     class OutdatedGem
-      VERSION_NAMES = %w[MAJOR MINOR PATCH].freeze
+      Choice = Struct.new(:version, :role, :held, :git, :ref, keyword_init: true)
 
-      def initialize(current_spec, active_spec, dependency)
+      def initialize(current_spec:, resolved_spec:, dependency:,
+                     latest_version: nil, pending_version: nil,
+                     cooldown_active: false)
         @current_spec = current_spec
-        @active_spec = active_spec
+        @resolved_spec = resolved_spec
         @dependency = dependency
+        @latest_version = latest_version || resolved_spec.version
+        @pending_version = pending_version
+        @cooldown_active = cooldown_active
+        @selected_index = default_index
       end
 
+      attr_reader :dependency, :latest_version, :pending_version, :selected_index
+
       def name(padding = 0)
         current_spec.name.ljust(padding)
       end
 
+      def groups
+        dependency ? Array(dependency.groups) : []
+      end
+
+      # Only the noteworthy groups; the implicit :default group renders as blank.
+      def group_label
+        (groups.map(&:to_s) - ['default']).join(',')
+      end
+
       def current_version
         current_spec.version
       end
 
-      def active_version
-        active_spec.version
+      def resolved_version
+        resolved_spec.version
+      end
+
+      def choices
+        @choices ||= build_choices
+      end
+
+      # True when there is anything to pick beyond the installed version.
+      def upgradable?
+        choices.size > 1
+      end
+
+      def selected
+        choices[@selected_index]
+      end
+
+      def selected_version
+        selected.version
+      end
+
+      def cycle_left
+        @selected_index = (@selected_index - 1) % choices.size
+      end
+
+      def cycle_right
+        @selected_index = (@selected_index + 1) % choices.size
+      end
+
+      def select_current!
+        @selected_index = choices.index { |choice| choice.role == :current } || 0
+      end
+
+      # Jump to the best upgrade target (in-range latest, else absolute latest).
+      def select_upgrade!
+        index = choices.index { |choice| choice.role == :in_range } ||
+                choices.index { |choice| choice.role == :latest }
+        @selected_index = index if index
+      end
+
+      # A row is "skipped" (left untouched) when the highlighted choice is the
+      # currently installed version.
+      def skip?
+        selected.role == :current
+      end
+
+      def git_changed?
+        current_git != resolved_git && !(current_git.nil? && resolved_git.nil?)
       end
 
-      def label
-        "#{version_label.ljust(10)} " \
-          "newest #{active_version.to_s.ljust(10)} " \
-          "installed #{current_version.to_s.ljust(10)} " \
-          "#{dependency_text.ljust(20)}"
+      # The selected target is newer than the Gemfile constraint allows, so the
+      # Gemfile requirement must be rewritten before updating.
+      def cross_constraint?
+        return false unless dependency
+        return false if git_changed?
+
+        !dependency.requirement.satisfied_by?(selected_version)
+      end
+
+      # Informational note for an in-range update that is being withheld by the
+      # cooldown window but is not otherwise visible as a selectable choice.
+      def cooldown_note
+        return nil unless @cooldown_active
+        return nil unless pending_version
+        return nil if choices.any?(&:held)
+
+        "#{pending_version} held by cooldown"
       end
 
       private
 
-      attr_reader :current_spec, :active_spec, :dependency
+      attr_reader :current_spec, :resolved_spec
+
+      def build_choices
+        list = [Choice.new(version: current_version, role: :current, held: false, git: false, ref: short_ref(current_spec))]
+
+        if git_changed?
+          list << Choice.new(version: resolved_version, role: :in_range, held: false, git: true, ref: short_ref(resolved_spec))
+        elsif resolved_version > current_version
+          list << Choice.new(version: resolved_version, role: :in_range, held: held?(resolved_version), git: false, ref: nil)
+        end
+
+        if latest_version > resolved_version && latest_version > current_version
+          list << Choice.new(version: latest_version, role: :latest, held: held?(latest_version), git: false, ref: nil)
+        end
+
+        list.uniq { |choice| [choice.version, choice.git] }
+      end
+
+      # The short git revision for a git-sourced spec (e.g. "380c0bc"), or nil.
+      def short_ref(spec)
+        return nil unless spec.respond_to?(:git_version)
+
+        ref = spec.git_version
+        ref && !ref.strip.empty? ? ref.strip : nil
+      end
+
+      # Default to the current version (skip), matching `yarn
+      # upgrade-interactive` — nothing is touched until you opt a gem in.
+      def default_index
+        choices.index { |choice| choice.role == :current } || 0
+      end
+
+      # A version is held by cooldown when it satisfies the Gemfile constraint
+      # (so it is not merely blocked by the declared range) yet sits above the
+      # version resolution was willing to pick.
+      def held?(version)
+        return false unless @cooldown_active
+        return false unless dependency
 
-      def dependency_text
-        dependency ? "requested #{dependency.requirement}" : ''
+        version > resolved_version && dependency.requirement.satisfied_by?(version)
       end
 
-      def version_label
-        index = version_diff_index
-        index ? VERSION_NAMES[index] : 'GIT'
+      def current_git
+        current_spec.respond_to?(:git_version) ? current_spec.git_version : nil
       end
 
-      def version_diff_index
-        active_version
-          .segments
-          .zip(current_version.segments)
-          .index do |active_segment, current_segment|
-            active_segment.to_i > current_segment.to_i
-          end
+      def resolved_git
+        resolved_spec.respond_to?(:git_version) ? resolved_spec.git_version : nil
       end
     end
   end

data/lib/bundler/interactive/update.rb

@@ -2,18 +2,49 @@
 
 module Bundler
   module Interactive
+    # Applies the version selections the user made in the interactive table.
+    #
+    # Selections whose target exceeds the Gemfile constraint have their
+    # requirement rewritten first (via GemfileEditor); then every selected gem
+    # is unlocked and re-resolved through a fresh Bundler definition so the
+    # lockfile is updated in one pass.
     class Update
-      attr_reader :gems
-
-      def initialize(gems)
-        @gems = gems
+      def initialize(selections)
+        @selections = Array(selections)
       end
 
       def update!
-        puts "Updating #{gems.join(', ')}..."
-        # Update Gemfile?
-        definition = Bundler.definition(gems: gems)
+        return if selections.empty?
+
+        rewrite_gemfile!
+        names = selections.map(&:name)
+
+        Bundler.ui.info("Updating #{names.join(', ')}...")
+        definition = Bundler.definition(gems: names)
+        definition.resolve_remotely!
         Bundler::Installer.install(Bundler.root, definition)
+        definition.lock
+
+        print_summary
+      end
+
+      private
+
+      attr_reader :selections
+
+      def rewrite_gemfile!
+        selections.select(&:cross_constraint?).each do |selection|
+          GemfileEditor.new(selection.name, selection.selected_version).rewrite!
+        end
+      end
+
+      def print_summary
+        Bundler.ui.confirm('Updated:')
+        selections.each do |selection|
+          Bundler.ui.confirm(
+            "  #{selection.name} #{selection.current_version} -> #{selection.selected_version}"
+          )
+        end
       end
     end
   end

data/lib/bundler/interactive/update_interactive.rb

@@ -1,60 +1,350 @@
 # frozen_string_literal: true
 
+require 'io/console'
+
+module Bundler
+  module Interactive
+    # When bundler-interactive runs as an installed Bundler plugin, its gem
+    # dependencies (tty-prompt/tty-reader and their transitive deps) are
+    # installed alongside this gem under the plugin root, but Bundler does not
+    # add them to the load path -- see the "to support plugin deps" note in
+    # Bundler::Plugin#load_plugin. This bridges that gap.
+    module PluginDependencies
+      # Adds every sibling gem's lib directory to the load path so the plugin's
+      # dependency closure can be required. +anchor+ is a directory inside this
+      # gem (e.g. __dir__); its ancestor named "gems" is the plugin gem home,
+      # whose children are this gem and its installed dependencies. Appends
+      # (rather than prepends) so host application gems keep precedence.
+      def self.load!(anchor)
+        gems_dir = File.expand_path('../../../..', anchor)
+        return unless File.basename(gems_dir) == 'gems'
+
+        Dir[File.join(gems_dir, '*', 'lib')].sort.each do |lib|
+          $LOAD_PATH.push(lib) unless $LOAD_PATH.include?(lib)
+        end
+      end
+    end
+  end
+end
+
 begin
-  require 'tty-prompt'
+  require 'tty-reader'
 rescue LoadError
-  # tty-prompt probably wasn't loaded when we tried to install the plugin
-  # for now, this is fine
-  nil
+  Bundler::Interactive::PluginDependencies.load!(__dir__)
+  require 'tty-reader'
 end
 
 module Bundler
   module Interactive
+    # The `bundle update-interactive` command.
+    #
+    # Renders a navigable table of outdated gems: up/down move between gems,
+    # left/right cycle a gem's target version (current / in-range latest /
+    # absolute latest), space skips or restores a row, enter applies the
+    # selection, and q (or Ctrl-C) cancels.
     class UpdateInteractive < Bundler::Plugin::API
+      KEY_UP = ["\e[A", "\eOA"].freeze
+      KEY_DOWN = ["\e[B", "\eOB"].freeze
+      KEY_RIGHT = ["\e[C", "\eOC"].freeze
+      KEY_LEFT = ["\e[D", "\eOD"].freeze
+      KEY_RETURN = ["\r", "\n"].freeze
+      KEY_SPACE = [' '].freeze
+      KEY_QUIT = ['q', "\e"].freeze
+
+      # Fixed version columns, mirroring `yarn upgrade-interactive`.
+      ROLE_ORDER = %i[current in_range latest].freeze
+      COLUMN_LABELS = { current: 'Current', in_range: 'Range', latest: 'Latest' }.freeze
+
+      # Semver bump levels, coloured like `yarn upgrade-interactive`.
+      LEVEL_COLOR = { major: '31', minor: '33', patch: '32' }.freeze # red / yellow / green
+
       def exec(_command, _args)
-        response = prompt.multi_select(
-          'Select one or more gems to update:', outdated_gem_list,
-          echo: false, per_page: 20, filter: true, cycle: true
-        )
-        Update.new(response).update! if response.any?
-      rescue TTY::Reader::InputInterrupt
-        prompt.say('Canceling...')
+        if outdated_gems.empty?
+          Bundler.ui.info('Bundle up to date!')
+          return
+        end
+
+        selection = interactive_select
+        return Bundler.ui.info('Canceling...') if selection.nil?
+
+        chosen = selection.reject(&:skip?)
+        return Bundler.ui.info('No gems selected.') if chosen.empty?
+
+        Update.new(chosen).update!
+      # TTY::Reader raises InputInterrupt (a subclass of Interrupt) on Ctrl-C
+      # because the reader is created with `interrupt: :error`. Rescue Interrupt
+      # directly so exception handling never references the TTY constant, which
+      # keeps a clear error if the dependency ever fails to load.
+      rescue Interrupt
+        show_cursor
+        Bundler.ui.info("\nCanceling...")
       end
 
-      def outdated_gem_list
-        outdated_gems.map do |gem|
-          {
-            name: "#{gem.name(name_padding)} #{gem.label}",
-            value: gem.name
-          }
-        end
+      def outdated_gems
+        @outdated_gems ||= VersionResolver.new(
+          current_specs: current_gems,
+          resolved_definition: definition,
+          dependencies: dependencies,
+          cooldown_days: cooldown_days
+        ).outdated_gems
       end
 
       private
 
-      def prompt
-        @prompt ||= TTY::Prompt.new
+      # --- interaction loop ----------------------------------------------------
+
+      def interactive_select
+        @gems = outdated_gems
+        reader = TTY::Reader.new(interrupt: :error)
+        @cursor = 0
+        @offset = 0
+
+        hide_cursor
+        render(first: true)
+
+        loop do
+          case reader.read_keypress
+          when *KEY_UP    then @cursor = (@cursor - 1) % @gems.size
+          when *KEY_DOWN  then @cursor = (@cursor + 1) % @gems.size
+          when *KEY_LEFT  then @gems[@cursor].cycle_left
+          when *KEY_RIGHT then @gems[@cursor].cycle_right
+          when *KEY_SPACE then toggle_skip(@gems[@cursor])
+          when *KEY_RETURN then return @gems
+          when *KEY_QUIT   then return nil
+          end
+          render
+        end
+      ensure
+        show_cursor
       end
 
-      def outdated_gems
-        @outdated_gems ||= begin
-          current_gems
-            .sort_by(&:name)
-            .each_with_object([]) do |current_spec, outdated|
-              active_spec = definition.find_resolved_spec(current_spec)
-              next unless gem_outdated?(current_spec, active_spec)
-
-              outdated << OutdatedGem.new(current_spec, active_spec, dependencies[current_spec.name])
-            end
+      def toggle_skip(gem)
+        gem.skip? ? gem.select_upgrade! : gem.select_current!
+      end
+
+      # --- rendering -----------------------------------------------------------
+
+      # Renders the header, a scrolling window of gem rows sized to the
+      # terminal, and a footer. Keeping the block within the terminal height is
+      # what lets the in-place `cursor_up` redraw work instead of scrolling the
+      # whole list off-screen on every keypress.
+      def render(first: false)
+        total = @gems.size
+        page = [page_size, total].min
+        adjust_viewport(total, page)
+
+        lines = header_lines
+        lines << column_header_line
+        (@offset...(@offset + page)).each { |i| lines << row_line(@gems[i], i == @cursor) }
+        lines << ''
+        lines << footer_line(total, page)
+
+        output = +''
+        output << cursor_up(@line_count) if !first && @line_count
+        lines.each { |line| output << "\e[2K" << line.rstrip << "\n" }
+        @line_count = lines.size
+
+        $stdout.print(output)
+        $stdout.flush
+      end
+
+      def adjust_viewport(total, page)
+        @offset = @cursor if @cursor < @offset
+        @offset = @cursor - page + 1 if @cursor > @offset + page - 1
+        max_offset = [total - page, 0].max
+        @offset = [[@offset, max_offset].min, 0].max
+      end
+
+      def page_size
+        @page_size ||= [terminal_rows - header_lines.size - 4, 3].max
+      end
+
+      def terminal_rows
+        (IO.console && IO.console.winsize.first) || 24
+      rescue StandardError
+        24
+      end
+
+      def header_lines
+        lines = [
+          colorize('Select gems and target versions to update:', '1'),
+          dim('↑/↓ move · ←/→ choose version · space skip/restore · enter apply · q cancel'),
+          legend_line
+        ]
+        lines << dim('* = newer version held by cooldown') if cooldown_present?
+        lines << ''
+        lines
+      end
+
+      def legend_line
+        levels = %i[major minor patch].map { |level| color_for_level(level.to_s, level) }
+        dim('diff: ') + levels.join(dim(' · '))
+      end
+
+      def cooldown_present?
+        return @cooldown_present if defined?(@cooldown_present)
+
+        @cooldown_present = outdated_gems.any? do |gem|
+          gem.cooldown_note || gem.choices.any?(&:held)
+        end
+      end
+
+      def column_header_line
+        name_blank = ' ' * (2 + name_padding)
+        cells = present_roles.map { |role| bold(COLUMN_LABELS[role].ljust(column_width(role))) }
+        cells << bold('Group') if show_group?
+        "#{name_blank}  #{cells.join('  ')}".rstrip
+      end
+
+      def row_line(gem, active)
+        pointer = active ? '❯ ' : '  '
+        cells = present_roles.map do |role|
+          choice = cell_for(gem, role)
+          version_cell(choice, choice && gem.selected.equal?(choice), column_width(role), gem.current_version)
+        end
+        cells << gem.group_label if show_group?
+        note = gem.cooldown_note ? "  #{dim("← #{gem.cooldown_note}")}" : ''
+
+        "#{pointer}#{gem.name(name_padding)}  #{cells.join('  ')}#{note}"
+      end
+
+      # Show the Group column only when at least one gem belongs to a group
+      # other than the implicit :default.
+      def show_group?
+        return @show_group if defined?(@show_group)
+
+        @show_group = outdated_gems.any? { |gem| !gem.group_label.empty? }
+      end
+
+      # Renders one version into a fixed-width column with a radio marker
+      # (● selected / ○ not), colouring the changed portion of the version by
+      # bump level so the table shows patch/minor/major at a glance. Padding is
+      # computed from the visible (uncoloured) text so columns stay aligned.
+      def version_cell(choice, selected, width, current)
+        return ' ' * width if choice.nil?
+
+        marker = selected ? '●' : '○'
+        ref = choice.ref ? " @#{choice.ref}" : ''
+        held = choice.held ? '*' : ''
+        visible = "#{marker} #{version_text(choice)}"
+        marker_out = selected ? color_for_level(marker, diff_level(choice.version, current)) : dim(marker)
+
+        "#{marker_out} #{colorize_diff(choice.version, current)}#{dim(ref)}#{held}" +
+          (' ' * [width - visible.length, 0].max)
+      end
+
+      # Returns the version string with the segments that differ from +current+
+      # (and everything after) coloured by bump level; the unchanged prefix is
+      # left plain. e.g. 8.1 -> 8.1.3 colours ".3" green, 7 -> 7.29.7 ".29.7"
+      # yellow, 4 -> 5.3.0 the whole thing red.
+      def colorize_diff(version, current)
+        index = diff_index(version, current)
+        return version.to_s if index.nil?
+
+        segments = version.segments
+        prefix = segments[0...index].join('.')
+        suffix = color_for_level(segments[index..-1].join('.'), diff_level(version, current))
+        prefix.empty? ? suffix : "#{prefix}.#{suffix}"
+      end
+
+      def diff_index(version, current)
+        current_segments = current.segments
+        version.segments.each_index.find { |i| version.segments[i] != current_segments[i] }
+      end
+
+      def diff_level(version, current)
+        case diff_index(version, current)
+        when nil then nil
+        when 0 then :major
+        when 1 then :minor
+        else :patch
         end
       end
 
+      def color_for_level(text, level)
+        level ? colorize(text, LEVEL_COLOR[level]) : text
+      end
+
+      def version_text(choice)
+        ref = choice.ref ? " @#{choice.ref}" : ''
+        "#{choice.version}#{ref}#{choice.held ? '*' : ''}"
+      end
+
+      def cell_for(gem, role)
+        gem.choices.find { |choice| choice.role == role }
+      end
+
+      def present_roles
+        @present_roles ||= ROLE_ORDER.select do |role|
+          outdated_gems.any? { |gem| cell_for(gem, role) }
+        end
+      end
+
+      def column_width(role)
+        @column_widths ||= {}
+        # +2 for the "● " radio marker that precedes each version.
+        @column_widths[role] ||= outdated_gems.map do |gem|
+          (choice = cell_for(gem, role)) ? version_text(choice).length + 2 : 0
+        end.push(COLUMN_LABELS[role].length).max
+      end
+
+      def footer_line(total, page)
+        count = @gems.count { |gem| !gem.skip? }
+        parts = ["#{count} of #{total} selected to update"]
+        parts << "showing #{@offset + 1}-#{@offset + page} of #{total}" if total > page
+        dim(parts.join(' · '))
+      end
+
+      def bold(text)
+        colorize(text, '1')
+      end
+
+      def cursor_up(count)
+        count.positive? ? "\e[#{count}A" : ''
+      end
+
+      def hide_cursor
+        $stdout.print("\e[?25l") if color?
+      end
+
+      def show_cursor
+        $stdout.print("\e[?25h") if color?
+      end
+
+      def colorize(text, code)
+        color? ? "\e[#{code}m#{text}\e[0m" : text
+      end
+
+      def dim(text)
+        colorize(text, '2')
+      end
+
+      def color?
+        $stdout.tty?
+      end
+
+      def name_padding
+        @name_padding ||= outdated_gems.map { |gem| gem.name.length }.max
+      end
+
+      # --- bundler data --------------------------------------------------------
+
       def current_gems
         @current_gems ||= Bundler.definition.tap(&:validate_runtime!).resolve
       end
 
+      # Adapts a resolved Bundler SpecSet to the lookup the resolver expects.
+      # (Bundler::Definition#find_resolved_spec was removed in Bundler 4.x.)
+      ResolvedSpecs = Struct.new(:spec_set) do
+        def find_resolved_spec(current_spec)
+          spec_set.find_by_name_and_platform(current_spec.name, current_spec.platform)
+        end
+      end
+
       def definition
-        @definition ||= Bundler.definition(true).tap(&:resolve_remotely!)
+        @definition ||= ResolvedSpecs.new(
+          Bundler.definition(true).tap(&:resolve_remotely!).resolve
+        )
       end
 
       def dependencies
@@ -62,15 +352,18 @@ module Bundler
           Bundler.load.dependencies.map { |dep| [dep.name, dep] }.to_h
       end
 
-      def gem_outdated?(current_spec, active_spec)
-        active_spec.version > current_spec.version ||
-          active_spec.git_version != current_spec.git_version
-      rescue NoMethodError
-        puts "Gem #{current_spec.name}, couldn't find an active_spec"
-      end
+      # Cooldown is opt-in and only exists on Bundler >= 4.0.13, so read it
+      # defensively and treat anything unparseable as "off".
+      def cooldown_days
+        return @cooldown_days if defined?(@cooldown_days)
 
-      def name_padding
-        @name_padding ||= outdated_gems.map { |gem| gem.name.length }.max
+        @cooldown_days =
+          begin
+            value = Bundler.settings[:cooldown]
+            value.nil? ? 0 : value.to_i
+          rescue StandardError
+            0
+          end
       end
     end
   end

data/lib/bundler/interactive/version.rb

@@ -2,6 +2,6 @@
 
 module Bundler
   module Interactive
-    VERSION = '0.1.2.1'
+    VERSION = '0.2.1'
   end
 end

data/lib/bundler/interactive/version_resolver.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Bundler
+  module Interactive
+    # Gathers the candidate versions for every outdated gem.
+    #
+    # For each installed gem it computes:
+    #   * the currently installed (locked) version,
+    #   * the in-range latest that dependency resolution selected (which already
+    #     respects the Gemfile constraint and, when configured, the cooldown
+    #     window),
+    #   * the absolute latest published version from the gem's source, and
+    #   * the in-range version held back by cooldown, if any.
+    #
+    # Collaborators are injected so the resolver can be unit-tested without a
+    # live Bundler environment.
+    class VersionResolver
+      def initialize(current_specs:, resolved_definition:, dependencies:, cooldown_days: 0)
+        @current_specs = current_specs
+        @resolved_definition = resolved_definition
+        @dependencies = dependencies
+        @cooldown_days = cooldown_days.to_i
+      end
+
+      def outdated_gems
+        current_specs.sort_by(&:name).each_with_object([]) do |current_spec, list|
+          resolved = resolved_definition.find_resolved_spec(current_spec)
+          next unless resolved
+
+          gem = build(current_spec, resolved)
+          # A gem is worth listing when it offers any upgrade target — an
+          # in-range bump, a newer git revision, or a version beyond the
+          # declared constraint (which `bundle outdated` surfaces too).
+          list << gem if gem.upgradable?
+        end
+      end
+
+      private
+
+      attr_reader :current_specs, :resolved_definition, :dependencies, :cooldown_days
+
+      def build(current_spec, resolved)
+        dependency = dependencies[current_spec.name]
+        available = available_versions(current_spec, resolved)
+
+        OutdatedGem.new(
+          current_spec: current_spec,
+          resolved_spec: resolved,
+          dependency: dependency,
+          latest_version: available.max || resolved.version,
+          pending_version: pending_version(resolved, dependency, available),
+          cooldown_active: cooldown_active?
+        )
+      end
+
+      # All published versions for the gem, straight from the source index (this
+      # list is *not* cooldown-filtered, which is what lets us detect held
+      # versions). Prereleases are dropped unless the installed gem is itself a
+      # prerelease, mirroring `bundle outdated`.
+      def available_versions(current_spec, resolved)
+        specs = resolved.source.specs.search(resolved.name)
+        specs = specs.select { |spec| installable?(spec, current_spec) }
+        versions = specs.map(&:version)
+        versions = versions.reject(&:prerelease?) unless current_spec.version.prerelease?
+        versions.uniq.sort
+      rescue StandardError
+        []
+      end
+
+      def installable?(spec, current_spec)
+        return true unless spec.respond_to?(:installable_on_platform?)
+
+        spec.installable_on_platform?(current_spec.platform)
+      rescue StandardError
+        true
+      end
+
+      # The highest in-range version available in the source that resolution
+      # refused to pick — i.e. a version waiting out the cooldown window.
+      def pending_version(resolved, dependency, available)
+        return nil unless cooldown_active?
+        return nil unless dependency
+
+        candidate = available.select { |version| dependency.requirement.satisfied_by?(version) }.max
+        return nil unless candidate
+
+        candidate > resolved.version ? candidate : nil
+      end
+
+      def cooldown_active?
+        cooldown_days.positive?
+      end
+    end
+  end
+end

data/plugins.rb

@@ -2,6 +2,8 @@
 
 require 'bundler/interactive'
 
-Bundler::Plugin::API.command(
-  'update-interactive', Bundler::Interactive::UpdateInteractive
-)
+# `update-interactive` matches Bundler's own verb (`bundle update`);
+# `upgrade-interactive` is an alias for parity with `yarn upgrade-interactive`.
+%w[update-interactive upgrade-interactive].each do |command|
+  Bundler::Plugin::API.command(command, Bundler::Interactive::UpdateInteractive)
+end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: bundler-interactive
 version: !ruby/object:Gem::Version
-  version: 0.1.2.1
+  version: 0.2.1
 platform: ruby
 authors:
 - Wes Rich
-autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-08-02 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -28,14 +27,14 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '10.0'
 - !ruby/object:Gem::Dependency
@@ -73,11 +72,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
-- ".semaphore/semaphore.yml"
-- ".travis.yml"
 - Gemfile
 - README.md
 - Rakefile
@@ -85,10 +83,12 @@ files:
 - bin/setup
 - bundler-interactive.gemspec
 - lib/bundler/interactive.rb
+- lib/bundler/interactive/gemfile_editor.rb
 - lib/bundler/interactive/outdated_gem.rb
 - lib/bundler/interactive/update.rb
 - lib/bundler/interactive/update_interactive.rb
 - lib/bundler/interactive/version.rb
+- lib/bundler/interactive/version_resolver.rb
 - plugins.rb
 homepage: https://github.com/wesrich/Bundler-Interactive
 licenses: []
@@ -97,7 +97,6 @@ metadata:
   homepage_uri: https://github.com/wesrich/Bundler-Interactive
   source_code_uri: https://github.com/wesrich/Bundler-Interactive
   changelog_uri: https://github.com/wesrich/Bundler-Interactive
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -112,8 +111,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.4
-signing_key: 
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Interactive prompt for Bundler
 test_files: []

data/.semaphore/semaphore.yml

@@ -1,26 +0,0 @@
-version: v1.0
-name: Bundler::Interactive
-agent:
-  machine:
-    type: e1-standard-2
-    os_image: ubuntu1804
-
-blocks:
-  - name: Build
-    execution_time_limit:
-      minutes: 1
-    task:
-      jobs:
-        - name: Tests
-          matrix:
-            - env_var: RUBY_VERSION
-              values: ['2.3', '2.4', '2.5', '2.6.3']
-          commands:
-            - checkout
-            - sem-version ruby $RUBY_VERSION
-
-            # - cache restore gems-$RUBY_VERSION,gems-
-            # - bundle check --path=vendor/bundle || bundle install
-            # - cache store gems-$RUBY_VERSION vendor/bundle
-            - bundle install
-            - bundle exec rspec --format documentation

data/.travis.yml

@@ -1,9 +0,0 @@
----
-sudo: false
-language: ruby
-cache: bundler
-rvm:
-  - 2.3
-  - 2.4
-  - 2.5
-  - 2.6