Show versions of dependencies in dry-run

Library/Homebrew/cask/upgrade.rb

@@ -7,6 +7,7 @@
 require "deprecate_disable"
 require "install"
 require "upgrade"
+require "version_change"
 require "utils/output"
 require "cask/installer"
 
@@ -32,7 +33,7 @@ def self.greedy_casks
         greedy:              T.nilable(T::Boolean),
         greedy_latest:       T.nilable(T::Boolean),
         greedy_auto_updates: T.nilable(T::Boolean),
-        summary_pinned:      T.nilable(T::Array[String]),
+        summary_pinned:      T.nilable(T::Array[VersionChange]),
         summary_disabled:    T.nilable(T::Array[String]),
       ).returns(T::Array[Cask])
     }
@@ -82,28 +83,29 @@ def self.outdated_casks(casks, args:, force:, quiet:,
       pinned_casks = outdated_casks.select(&:pinned?)
       outdated_casks -= pinned_casks
       pinned_versions = pinned_casks.map do |cask|
-        "#{cask.full_name} #{cask.installed_version} -> #{cask.version}"
+        VersionChange.new(name: cask.full_name, old_version: cask.installed_version.to_s,
+                          new_version: cask.version.to_s)
       end
       summary_pinned&.concat(pinned_versions)
 
       if pinned_casks.any? && ((!quiet && summary_pinned.nil?) || casks.any?)
         message = "Not upgrading #{pinned_casks.count} pinned #{::Utils.pluralize("package", pinned_casks.count)}:"
         casks.any? ? ofail(message) : opoo(message)
-        $stderr.puts Homebrew::Upgrade.format_upgrade_summary(pinned_versions).join("\n") if
+        $stderr.puts Formatter.version_changes(pinned_versions).join("\n") if
           !quiet && summary_pinned.nil?
       end
 
       outdated_casks
     end
 
-    sig { params(cask_upgrades: T::Array[String], dry_run: T.nilable(T::Boolean), verb: String).void }
+    sig { params(cask_upgrades: T::Array[VersionChange], dry_run: T.nilable(T::Boolean), verb: String).void }
     def self.show_upgrade_summary(cask_upgrades, dry_run: false, verb: "Upgrading")
       cask_upgrades = cask_upgrades.uniq
       return if cask_upgrades.empty?
 
       verb = "Would upgrade" if dry_run
       oh1 "#{verb} #{cask_upgrades.count} outdated #{::Utils.pluralize("package", cask_upgrades.count)}:"
-      puts Homebrew::Upgrade.format_upgrade_summary(cask_upgrades).join("\n")
+      puts Formatter.version_changes(cask_upgrades).join("\n")
     end
 
     sig {
@@ -124,8 +126,8 @@ def self.show_upgrade_summary(cask_upgrades, dry_run: false, verb: "Upgrading")
         skip_prefetch:              T::Boolean,
         show_upgrade_summary:       T::Boolean,
         download_queue:             T.nilable(Homebrew::DownloadQueue),
-        summary_upgrades:           T.nilable(T::Array[String]),
-        summary_pinned:             T.nilable(T::Array[String]),
+        summary_upgrades:           T.nilable(T::Array[VersionChange]),
+        summary_pinned:             T.nilable(T::Array[VersionChange]),
         summary_deprecated:         T.nilable(T::Array[String]),
         summary_disabled:           T.nilable(T::Array[String]),
         prefetched_errors:          T.nilable(T::Array[StandardError]),
@@ -272,7 +274,8 @@ def self.upgrade_casks!(
       return false if upgradable_casks.empty? && !failed
 
       cask_upgrades = upgradable_casks.map do |(old_cask, new_cask)|
-        "#{new_cask.full_name} #{old_cask.version} -> #{new_cask.version}"
+        VersionChange.new(name: new_cask.full_name, old_version: old_cask.version.to_s,
+                          new_version: new_cask.version.to_s)
       end
       summary_upgrades&.concat(cask_upgrades) if dry_run
       summary_deprecated&.concat(upgradable_casks.filter_map do |(_, new_cask)|

Library/Homebrew/cmd/install.rb

@@ -210,7 +210,7 @@ def run
           [T::Array[Formula], T::Array[Cask::Cask]],
         )
         ask = !args.no_ask? && !args.dry_run?
-        cask_upgrade_summary = T.let([], T::Array[String])
+        cask_upgrade_summary = T.let([], T::Array[VersionChange])
 
         installed_casks = T.let([], T::Array[Cask::Cask])
         new_casks = T.let([], T::Array[Cask::Cask])

Library/Homebrew/cmd/upgrade.rb

@@ -26,15 +26,15 @@ class FormulaeUpgradeContext < T::Struct
       end
 
       class FinalUpgradeSummary < T::Struct
-        prop :version_changes, T::Array[String], default: []
-        prop :dependent_version_changes, T::Array[String], default: []
-        prop :pinned_formulae, T::Array[String], default: []
-        prop :pinned_casks, T::Array[String], default: []
+        prop :version_changes, T::Array[VersionChange], default: []
+        prop :dependent_version_changes, T::Array[VersionChange], default: []
+        prop :pinned_formulae, T::Array[VersionChange], default: []
+        prop :pinned_casks, T::Array[VersionChange], default: []
         prop :deprecated, T::Array[String], default: []
         prop :disabled, T::Array[String], default: []
         prop :source_build_formulae, T::Array[String], default: []
 
-        sig { returns(T::Array[String]) }
+        sig { returns(T::Array[VersionChange]) }
         def all_version_changes = version_changes | dependent_version_changes
       end
 
@@ -255,7 +255,7 @@ def run
             )
           end
 
-          planned_fetch_names = final_upgrade_summary.all_version_changes.map { |change| change.split.fetch(0) }
+          planned_fetch_names = final_upgrade_summary.all_version_changes.map(&:name)
           if Install.ask_prompt_needed?(
             planned_names:   planned_fetch_names.map do |planned_name|
               formulae.find { |formula| formula.full_specified_name == planned_name }&.full_name || planned_name
@@ -436,7 +436,7 @@ def formulae_upgrade_context(formulae, show_upgrade_summary: true, dry_run: args
           verb = dry_run ? "Would upgrade" : "Upgrading"
           oh1 "#{verb} #{formulae_to_install.count} outdated #{Utils.pluralize("package",
                                                                                formulae_to_install.count)}:"
-          puts Upgrade.format_upgrade_summary(formula_upgrade_descriptions(formulae_to_install)).join("\n") if
+          puts Formatter.version_changes(formula_version_changes(formulae_to_install)).join("\n") if
             args.no_ask?
         end
 
@@ -511,8 +511,8 @@ def final_upgrade_summary
           context:                   FormulaeUpgradeContext,
           include_sizes:             T::Boolean,
           formulae_installer:        T.nilable(T::Array[FormulaInstaller]),
-          version_changes:           T.nilable(T::Array[String]),
-          dependent_version_changes: T.nilable(T::Array[String]),
+          version_changes:           T.nilable(T::Array[VersionChange]),
+          dependent_version_changes: T.nilable(T::Array[VersionChange]),
         ).void
       }
       def record_formula_upgrade_summary(context, include_sizes: false, formulae_installer: nil, version_changes: nil,
@@ -521,13 +521,12 @@ def record_formula_upgrade_summary(context, include_sizes: false, formulae_insta
         formulae_installer ||= context.formulae_installer
         upgrade_formulae = formulae_installer.map(&:formula)
         dependent_formulae = context.dependants.upgradeable
-        summary.version_changes.concat(version_changes || formula_upgrade_descriptions(upgrade_formulae,
-                                                                                       include_sizes:))
+        summary.version_changes.concat(version_changes || formula_version_changes(upgrade_formulae, include_sizes:))
         summary.dependent_version_changes.concat(
-          dependent_version_changes || formula_upgrade_descriptions(dependent_formulae, include_sizes:),
+          dependent_version_changes || formula_version_changes(dependent_formulae, include_sizes:),
         )
         summary.pinned_formulae.concat((context.pinned_formulae + context.dependants.pinned).map do |formula|
-          Upgrade.formula_upgrade_description(formula)
+          Upgrade.formula_version_change(formula)
         end)
 
         formulae = context.formulae_to_install + context.pinned_formulae +
@@ -566,29 +565,29 @@ def show_final_upgrade_summary(dry_run: args.dry_run?, show_upgrade_summary: arg
             "#{dry_run ? "Would upgrade" : "Upgraded"} #{version_change_count} " \
             "#{"requested " if named}outdated " \
             "#{Utils.pluralize("package", version_change_count)}",
-            Upgrade.format_upgrade_summary(version_changes),
+            Formatter.version_changes(version_changes),
           )
         end
         if show_upgrade_summary && named && summary.dependent_version_changes.present?
           dependent_count = summary.dependent_version_changes.uniq.count
           show_final_upgrade_summary_section(
             "#{dry_run ? "Would upgrade" : "Upgraded"} #{dependent_count} " \
             "#{Utils.pluralize("dependent", dependent_count)}",
-            Upgrade.format_upgrade_summary(summary.dependent_version_changes),
+            Formatter.version_changes(summary.dependent_version_changes),
           )
         end
         if summary.pinned_formulae.present?
           pinned_count = summary.pinned_formulae.uniq.count
           show_final_upgrade_summary_section(
             "#{pinned_count} Pinned #{Utils.pluralize("formula", pinned_count)}",
-            Upgrade.format_upgrade_summary(summary.pinned_formulae.uniq),
+            Formatter.version_changes(summary.pinned_formulae.uniq),
           )
         end
         if summary.pinned_casks.present?
           pinned_count = summary.pinned_casks.uniq.count
           show_final_upgrade_summary_section(
             "#{pinned_count} Pinned #{Utils.pluralize("cask", pinned_count)}",
-            Upgrade.format_upgrade_summary(summary.pinned_casks.uniq),
+            Formatter.version_changes(summary.pinned_casks.uniq),
           )
         end
         deprecate_disable_summary = summary.deprecated.map { |item| "#{item} (deprecated)" } +
@@ -613,23 +612,16 @@ def show_final_upgrade_summary(dry_run: args.dry_run?, show_upgrade_summary: arg
         end
       end
 
-      sig { params(formulae: T::Array[Formula], include_sizes: T::Boolean).returns(T::Array[String]) }
-      def formula_upgrade_descriptions(formulae, include_sizes: false)
+      sig { params(formulae: T::Array[Formula], include_sizes: T::Boolean).returns(T::Array[VersionChange]) }
+      def formula_version_changes(formulae, include_sizes: false)
         formulae.map do |formula|
+          size = formula_upgrade_size(formula) if include_sizes
           if formula.optlinked?
-            old_keg = Keg.new(formula.opt_prefix)
-            old_version = old_keg.version
+            old_version = Keg.new(formula.opt_prefix).version
             new_version = formula_upgrade_display_version(formula, old_version)
-            if include_sizes
-              "#{formula.full_specified_name} #{old_version} -> " \
-                "#{new_version}#{formula_upgrade_size(formula)}"
-            else
-              "#{formula.full_specified_name} #{old_version} -> #{new_version}"
-            end
-          elsif include_sizes
-            "#{formula.full_specified_name} #{formula.pkg_version}#{formula_upgrade_size(formula)}"
+            VersionChange.new(name: formula.full_specified_name, old_version: old_version.to_s, new_version:, size:)
           else
-            "#{formula.full_specified_name} #{formula.pkg_version}"
+            VersionChange.new(name: formula.full_specified_name, new_version: formula.pkg_version.to_s, size:)
           end
         end
       end
@@ -642,7 +634,7 @@ def formula_upgrade_descriptions(formulae, include_sizes: false)
           dry_run:              T::Boolean,
           download_queue:       T.nilable(Homebrew::DownloadQueue),
           prefetch_names:       T.nilable(T::Array[String]),
-          prefetch_upgrades:    T.nilable(T::Array[String]),
+          prefetch_upgrades:    T.nilable(T::Array[VersionChange]),
           show_upgrade_summary: T::Boolean,
         ).returns(T::Boolean)
       }
@@ -693,7 +685,7 @@ def upgrade_outdated_formulae!(formulae, prefetch_only: false, use_prefetched: f
                                                                 .uniq { |fi| fi.formula.full_name },
                                                               download_queue: prefetch_download_queue)
           prefetch_names&.replace(valid_formula_installers.map { |fi| fi.formula.name })
-          prefetch_upgrades&.replace(formula_upgrade_descriptions(valid_formula_installers.map(&:formula)))
+          prefetch_upgrades&.replace(formula_version_changes(valid_formula_installers.map(&:formula)))
           valid_dependent_formulae_installer = valid_formula_installers & dependent_formulae_installer
           @prefetched_formulae_upgrade_context = FormulaeUpgradeContext.new(
             formulae_to_install:          context.formulae_to_install,
@@ -709,11 +701,10 @@ def upgrade_outdated_formulae!(formulae, prefetch_only: false, use_prefetched: f
           return true
         end
 
-        planned_formula_version_changes = formula_upgrade_descriptions(context.formulae_installer.map(&:formula),
-                                                                       include_sizes: dry_run)
+        planned_formula_version_changes = formula_version_changes(context.formulae_installer.map(&:formula),
+                                                                  include_sizes: dry_run)
         dependent_formulae = context.dependants.upgradeable.dup
-        planned_dependent_version_changes = formula_upgrade_descriptions(dependent_formulae,
-                                                                         include_sizes: dry_run)
+        planned_dependent_version_changes = formula_version_changes(dependent_formulae, include_sizes: dry_run)
         if dry_run
           record_formula_upgrade_summary(context,
                                          version_changes:           planned_formula_version_changes,
@@ -792,7 +783,7 @@ def upgrade_outdated_formulae!(formulae, prefetch_only: false, use_prefetched: f
       sig {
         params(casks: T::Array[Cask::Cask], download_queue: Homebrew::DownloadQueue,
                prefetch_names: T.nilable(T::Array[String]),
-               prefetch_upgrades: T.nilable(T::Array[String]),
+               prefetch_upgrades: T.nilable(T::Array[VersionChange]),
                prefetch_casks: T.nilable(T::Array[Cask::Cask]),
                prefetch_installers: T.nilable(T::Array[Cask::Installer]),
                prefetch_errors: T.nilable(T::Array[StandardError]))
@@ -858,7 +849,10 @@ def prefetch_outdated_casks!(casks, download_queue:, prefetch_names: nil,
         prefetch_casks&.replace(valid_casks)
         prefetch_names&.replace(valid_casks.map(&:full_name))
         prefetch_upgrades&.replace(
-          valid_casks.map { |cask| "#{cask.full_name} #{cask.installed_version} -> #{cask.version}" },
+          valid_casks.map do |cask|
+            VersionChange.new(name: cask.full_name, old_version: cask.installed_version.to_s,
+                              new_version: cask.version.to_s)
+          end,
         )
         true
       rescue => e
@@ -986,17 +980,17 @@ def formula_upgrade_display_version(formula, old_version)
         latest_head_version.to_s
       end
 
-      sig { params(formula: Formula).returns(String) }
+      sig { params(formula: Formula).returns(T.nilable(String)) }
       def formula_upgrade_size(formula)
-        return "" if args.build_from_source_formulae.include?(formula.name)
+        return if args.build_from_source_formulae.include?(formula.name)
 
         bottle = formula.bottle
-        return "" unless bottle
+        return unless bottle
 
         bottle.fetch_tab(quiet: !args.debug?)
-        return "" unless (download_size = bottle.bottle_size)
+        return unless (download_size = bottle.bottle_size)
 
-        " (#{Formatter.disk_usage_readable(download_size.to_i)})"
+        Formatter.disk_usage_readable(download_size.to_i)
       end
     end
   end

Library/Homebrew/install.rb

@@ -23,7 +23,7 @@ module Homebrew
   module Install
     extend Utils::Output::Mixin
 
-    DependencySummary = T.type_alias { T::Hash[Symbol, T::Array[String]] }
+    DependencySummary = T.type_alias { T::Hash[Symbol, T::Array[VersionChange]] }
 
     class << self
       sig { params(all_fatal: T::Boolean).void }
@@ -379,19 +379,21 @@ def install_formulae(
           groups.keys.sort.each do |action|
             group = groups.fetch(action)
             ohai "Would #{action} #{Utils.pluralize("formula", group.count, include_count: true)}:"
-            puts Upgrade.format_upgrade_summary(group.map do |formula|
+            puts Formatter.version_changes(group.map do |formula|
               if action == "upgrade"
-                Upgrade.formula_upgrade_description(formula)
+                Upgrade.formula_version_change(formula)
               else
-                "#{formula.full_specified_name} #{formula.pkg_version}"
+                VersionChange.new(name: formula.full_specified_name, new_version: formula.pkg_version.to_s)
               end
             end)
           end
 
           formula_installers.each do |fi|
             next if fi.ignore_deps?
 
-            print_dry_run_dependencies(fi.formula, fi.compute_dependencies, &:name)
+            print_dry_run_dependencies(fi.formula, fi.compute_dependencies) do |dependency|
+              Upgrade.formula_version_change(dependency)
+            end
           end
           return []
         end
@@ -423,7 +425,7 @@ def install_formulae(
           dependencies:       T::Array[Dependency],
           skip_formula_names: T::Array[String],
           dependency_summary: T.nilable(DependencySummary),
-          _block:             T.proc.params(arg0: Formula).returns(String),
+          _block:             T.proc.params(arg0: Formula).returns(VersionChange),
         ).void
       }
       def print_dry_run_dependencies(formula, dependencies, skip_formula_names: [], dependency_summary: nil, &_block)
@@ -453,7 +455,7 @@ def print_dry_run_dependency_summary(summary, formula: nil)
 
           ohai "Would #{verb} #{Utils.pluralize("dependency", group.count, include_count: true)}" \
                "#{" for #{formula.name}" if formula}:"
-          puts Upgrade.format_upgrade_summary(group)
+          puts Formatter.version_changes(group)
         end
       end
 

Library/Homebrew/sorbet/rbi/shims/rspec.rbi

@@ -12,6 +12,7 @@ class RSpec::Core::ExampleGroup
   include Test::Helper::Cask
   include Test::Helper::Fixtures
   include Test::Helper::Formula
+  include Test::Helper::VersionChange
   include Test::Helper::IntegrationTest
   include Test::Helper::MkTmpDir
   include Test::Helper::Subcommand