Link versioned keg-only formulae by default

Link `@` versioned or `-full` formulae by default if their unversioned
or unfull siblings are not installed.

Author: MikeMcQuaid

Library/Homebrew/formula.rb

@@ -652,6 +652,28 @@ def versioned_formulae
     end.sort_by(&:version).reverse
   end
 
+  # Returns the sibling `-full` or non-`-full` formula names for any Formula.
+  sig { returns(T::Array[String]) }
+  def full_formulae_names
+    [
+      if name.end_with?("-full")
+        name.delete_suffix("-full")
+      else
+        "#{name}-full"
+      end,
+    ]
+  end
+
+  # Returns sibling `-full` or non-`-full` Formula objects for any Formula.
+  sig { returns(T::Array[Formula]) }
+  def full_formulae
+    full_formulae_names.filter_map do |formula_name|
+      Formula[formula_name]
+    rescue FormulaUnavailableError
+      nil
+    end.sort_by(&:version).reverse
+  end
+
   # Whether this {Formula} is version-synced with other formulae.
   sig { returns(T::Boolean) }
   def synced_with_other_formulae?

Library/Homebrew/formula_installer.rb

@@ -113,7 +113,10 @@ def initialize(
     @overwrite = overwrite
     @keep_tmp = keep_tmp
     @debug_symbols = debug_symbols
-    @link_keg = T.let(!formula.keg_only? || link_keg, T::Boolean)
+    @installed_as_dependency = installed_as_dependency
+    @installed_on_request = installed_on_request
+    link_keg ||= auto_link_versioned_keg_only?
+    @link_keg = T.let(link_keg, T::Boolean)
     @show_header = show_header
     @ignore_deps = ignore_deps
     @only_deps = only_deps
@@ -131,8 +134,6 @@ def initialize(
     @verbose = verbose
     @quiet = quiet
     @debug = debug
-    @installed_as_dependency = installed_as_dependency
-    @installed_on_request = installed_on_request
     @options = options
     @requirement_messages = T.let([], T::Array[String])
     @poured_bottle = T.let(false, T::Boolean)
@@ -1701,6 +1702,18 @@ def forbidden_formula_check
 
   private
 
+  sig { returns(T::Boolean) }
+  def auto_link_versioned_keg_only?
+    return false if installed_as_dependency?
+    return false unless formula.keg_only?
+    return false unless formula.keg_only_reason.versioned_formula?
+    return false if formula.any_version_installed?
+    return false if formula.versioned_formulae.any?(&:any_version_installed?)
+    return false if formula.full_formulae.any?(&:any_version_installed?)
+
+    true
+  end
+
   sig { void }
   def lock
     return unless self.class.locked.empty?

Library/Homebrew/test/formula_installer_spec.rb

@@ -83,6 +83,88 @@ def temporary_install(formula, **options)
     end
   end
 
+  describe "versioned keg-only linking defaults" do
+    let(:base_name) { "homebrew-versioned-formula" }
+    let(:formula_name) { "#{base_name}@1.0" }
+    let(:keg_only_formula) do
+      formula formula_name do
+        url "foo-1.0"
+        keg_only :versioned_formula
+      end
+    end
+
+    before do
+      allow(keg_only_formula).to receive_messages(any_version_installed?: false, versioned_formulae: [],
+                                                  full_formulae: [])
+    end
+
+    it "links by default when no sibling variants are installed" do
+      fi = described_class.new(keg_only_formula)
+
+      expect(fi.link_keg).to be true
+    end
+
+    it "does not link by default when any version is already installed" do
+      allow(keg_only_formula).to receive(:any_version_installed?).and_return(true)
+
+      fi = described_class.new(keg_only_formula)
+
+      expect(fi.link_keg).to be false
+    end
+
+    it "links when explicitly requested" do
+      allow(keg_only_formula).to receive(:any_version_installed?).and_return(true)
+
+      fi = described_class.new(keg_only_formula, link_keg: true)
+
+      expect(fi.link_keg).to be true
+    end
+
+    it "does not link by default when another @-versioned formula is installed" do
+      other_version = formula "#{base_name}@2.0" do
+        url "foo-2.0"
+        keg_only :versioned_formula
+      end
+      allow(other_version).to receive(:any_version_installed?).and_return(true)
+      allow(keg_only_formula).to receive(:versioned_formulae).and_return([other_version])
+
+      fi = described_class.new(keg_only_formula)
+
+      expect(fi.link_keg).to be false
+    end
+
+    it "does not link by default when the -full variant is installed" do
+      full_variant = formula "#{base_name}-full" do
+        url "foo-full-1.0"
+        keg_only :versioned_formula
+      end
+      allow(full_variant).to receive(:any_version_installed?).and_return(true)
+      allow(keg_only_formula).to receive(:full_formulae).and_return([full_variant])
+
+      fi = described_class.new(keg_only_formula)
+
+      expect(fi.link_keg).to be false
+    end
+
+    it "does not link by default when the non-full variant is installed" do
+      full_formula = formula "#{base_name}-full" do
+        url "foo-full-1.0"
+        keg_only :versioned_formula
+      end
+      non_full_variant = formula base_name do
+        url "foo-1.0"
+        keg_only :versioned_formula
+      end
+      allow(full_formula).to receive(:any_version_installed?).and_return(false)
+      allow(non_full_variant).to receive(:any_version_installed?).and_return(true)
+      allow(full_formula).to receive_messages(versioned_formulae: [], full_formulae: [non_full_variant])
+
+      fi = described_class.new(full_formula)
+
+      expect(fi.link_keg).to be false
+    end
+  end
+
   describe "#check_install_sanity" do
     it "raises on direct cyclic dependency" do
       ENV["HOMEBREW_DEVELOPER"] = "1"

Library/Homebrew/test/formula_spec.rb

@@ -180,6 +180,58 @@
     end
   end
 
+  describe "#full_formulae_names" do
+    let(:f) do
+      formula "foo" do
+        url "foo-1.0"
+      end
+    end
+
+    let(:f_full) do
+      formula "foo-full" do
+        url "foo-full-1.0"
+      end
+    end
+
+    let(:f_versioned) do
+      formula "foo@2.0" do
+        url "foo-2.0"
+      end
+    end
+
+    it "returns sibling full and non-full names" do
+      expect(f.full_formulae_names).to eq ["foo-full"]
+      expect(f_full.full_formulae_names).to eq ["foo"]
+      expect(f_versioned.full_formulae_names).to eq ["foo@2.0-full"]
+    end
+  end
+
+  describe "#full_formulae" do
+    let(:f) do
+      formula "foo" do
+        url "foo-1.0"
+      end
+    end
+
+    let(:f_full) do
+      formula "foo-full" do
+        url "foo-full-1.0"
+      end
+    end
+
+    before do
+      allow(Formulary).to receive(:load_formula_from_path).with(f_full.name, f_full.path).and_return(f_full)
+      allow(Formulary).to receive(:factory).with(f_full.name).and_return(f_full)
+      allow(f).to receive(:full_formulae_names).and_return([f_full.name])
+    end
+
+    it "returns array with sibling full formulae" do
+      FileUtils.touch f.path
+      FileUtils.touch f_full.path
+      expect(f.full_formulae).to eq [f_full]
+    end
+  end
+
   example "installed alias with core" do
     f = formula do
       url "foo-1.0"