Add Go package support to Brewfile

Co-authored-by: MikeMcQuaid <[email protected]>

Author: Copilot

Library/Homebrew/.rubocop.yml

@@ -24,6 +24,10 @@ Naming/PredicatePrefix:
     - is_32_bit?
     - is_64_bit?
 
+Naming/MethodParameterName:
+  AllowedNames:
+    - go
+
 # Only enforce documentation for public APIs.
 # Checked by the tests.yml syntax job
 Style/Documentation:

Library/Homebrew/bundle.rb

@@ -62,6 +62,16 @@ def whalebrew_installed?
         @whalebrew_installed ||= which_formula?("whalebrew")
       end
 
+      sig { returns(T.nilable(Pathname)) }
+      def which_go
+        @which_go ||= which("go", ORIGINAL_PATHS)
+      end
+
+      sig { returns(T::Boolean) }
+      def go_installed?
+        @go_installed ||= which_go.present?
+      end
+
       sig { returns(T::Boolean) }
       def cask_installed?
         @cask_installed ||= File.directory?("#{HOMEBREW_PREFIX}/Caskroom") &&
@@ -138,7 +148,9 @@ def reset!
         @mas_installed = T.let(nil, T.nilable(T::Boolean))
         @vscode_installed = T.let(nil, T.nilable(T::Boolean))
         @which_vscode = T.let(nil, T.nilable(Pathname))
+        @which_go = T.let(nil, T.nilable(Pathname))
         @whalebrew_installed = T.let(nil, T.nilable(T::Boolean))
+        @go_installed = T.let(nil, T.nilable(T::Boolean))
         @cask_installed = T.let(nil, T.nilable(T::Boolean))
         @formula_versions_from_env = T.let(nil, T.nilable(T::Hash[String, String]))
         @upgrade_formulae = T.let(nil, T.nilable(T::Array[String]))

Library/Homebrew/bundle/checker.rb

@@ -59,12 +59,13 @@ def find_actionable(entries, exit_on_first_error: false, no_upgrade: false, verb
       CheckResult = Struct.new :work_to_be_done, :errors
 
       CHECKS = {
-        taps_to_tap:           "Taps",
-        casks_to_install:      "Casks",
-        extensions_to_install: "VSCode Extensions",
-        apps_to_install:       "Apps",
-        formulae_to_install:   "Formulae",
-        formulae_to_start:     "Services",
+        taps_to_tap:            "Taps",
+        casks_to_install:       "Casks",
+        extensions_to_install:  "VSCode Extensions",
+        apps_to_install:        "Apps",
+        formulae_to_install:    "Formulae",
+        formulae_to_start:      "Services",
+        go_packages_to_install: "Go Packages",
       }.freeze
 
       def self.check(global: false, file: nil, exit_on_first_error: false, no_upgrade: false, verbose: false)
@@ -137,6 +138,14 @@ def self.formulae_to_start(exit_on_first_error: false, no_upgrade: false, verbos
         )
       end
 
+      def self.go_packages_to_install(exit_on_first_error: false, no_upgrade: false, verbose: false)
+        require "bundle/go_checker"
+        Homebrew::Bundle::Checker::GoChecker.new.find_actionable(
+          @dsl.entries,
+          exit_on_first_error:, no_upgrade:, verbose:,
+        )
+      end
+
       def self.reset!
         require "bundle/cask_dumper"
         require "bundle/formula_dumper"

Library/Homebrew/bundle/commands/dump.rb

@@ -10,12 +10,13 @@ module Dump
         sig {
           params(global: T::Boolean, file: T.nilable(String), describe: T::Boolean, force: T::Boolean,
                  no_restart: T::Boolean, taps: T::Boolean, formulae: T::Boolean, casks: T::Boolean,
-                 mas: T::Boolean, whalebrew: T::Boolean, vscode: T::Boolean).void
+                 mas: T::Boolean, whalebrew: T::Boolean, vscode: T::Boolean, go: T::Boolean).void
         }
         def self.run(global:, file:, describe:, force:, no_restart:, taps:, formulae:, casks:, mas:, whalebrew:,
-                     vscode:)
+                     vscode:, go:)
           Homebrew::Bundle::Dumper.dump_brewfile(
             global:, file:, describe:, force:, no_restart:, taps:, formulae:, casks:, mas:, whalebrew:, vscode:,
+            go:
           )
         end
       end

Library/Homebrew/bundle/commands/list.rb

@@ -10,13 +10,14 @@ module Commands
       module List
         sig {
           params(global: T::Boolean, file: T.nilable(String), formulae: T::Boolean, casks: T::Boolean,
-                 taps: T::Boolean, mas: T::Boolean, whalebrew: T::Boolean, vscode: T::Boolean).void
+                 taps: T::Boolean, mas: T::Boolean, whalebrew: T::Boolean, vscode: T::Boolean,
+                 go: T::Boolean).void
         }
-        def self.run(global:, file:, formulae:, casks:, taps:, mas:, whalebrew:, vscode:)
+        def self.run(global:, file:, formulae:, casks:, taps:, mas:, whalebrew:, vscode:, go:)
           parsed_entries = Brewfile.read(global:, file:).entries
           Homebrew::Bundle::Lister.list(
             parsed_entries,
-            formulae:, casks:, taps:, mas:, whalebrew:, vscode:,
+            formulae:, casks:, taps:, mas:, whalebrew:, vscode:, go:,
           )
         end
       end

Library/Homebrew/bundle/dsl.rb

@@ -83,6 +83,11 @@ def vscode(name)
         @entries << Entry.new(:vscode, name)
       end
 
+      sig { params(name: String).void }
+      def go(name)
+        @entries << Entry.new(:go, name)
+      end
+
       def tap(name, clone_target = nil, options = {})
         raise "name(#{name.inspect}) should be a String object" unless name.is_a? String
         if clone_target && !clone_target.is_a?(String)

Library/Homebrew/bundle/dumper.rb

@@ -24,15 +24,17 @@ module Dumper
           mas:        T::Boolean,
           whalebrew:  T::Boolean,
           vscode:     T::Boolean,
+          go:         T::Boolean,
         ).returns(String)
       }
-      def self.build_brewfile(describe:, no_restart:, formulae:, taps:, casks:, mas:, whalebrew:, vscode:)
+      def self.build_brewfile(describe:, no_restart:, formulae:, taps:, casks:, mas:, whalebrew:, vscode:, go:)
         require "bundle/tap_dumper"
         require "bundle/formula_dumper"
         require "bundle/cask_dumper"
         require "bundle/mac_app_store_dumper"
         require "bundle/whalebrew_dumper"
         require "bundle/vscode_extension_dumper"
+        require "bundle/go_dumper"
 
         content = []
         content << TapDumper.dump if taps
@@ -41,6 +43,7 @@ def self.build_brewfile(describe:, no_restart:, formulae:, taps:, casks:, mas:,
         content << MacAppStoreDumper.dump if mas
         content << WhalebrewDumper.dump if whalebrew
         content << VscodeExtensionDumper.dump if vscode
+        content << GoDumper.dump if go
         "#{content.reject(&:empty?).join("\n")}\n"
       end
 
@@ -57,13 +60,14 @@ def self.build_brewfile(describe:, no_restart:, formulae:, taps:, casks:, mas:,
           mas:        T::Boolean,
           whalebrew:  T::Boolean,
           vscode:     T::Boolean,
+          go:         T::Boolean,
         ).void
       }
       def self.dump_brewfile(global:, file:, describe:, force:, no_restart:, formulae:, taps:, casks:, mas:,
-                             whalebrew:, vscode:)
+                             whalebrew:, vscode:, go:)
         path = brewfile_path(global:, file:)
         can_write_to_brewfile?(path, force:)
-        content = build_brewfile(describe:, no_restart:, taps:, formulae:, casks:, mas:, whalebrew:, vscode:)
+        content = build_brewfile(describe:, no_restart:, taps:, formulae:, casks:, mas:, whalebrew:, vscode:, go:)
         write_file path, content
       end
 

Library/Homebrew/bundle/go_checker.rb

@@ -0,0 +1,24 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Homebrew
+  module Bundle
+    module Checker
+      class GoChecker < Homebrew::Bundle::Checker::Base
+        PACKAGE_TYPE = :go
+        PACKAGE_TYPE_NAME = "Go Package"
+
+        sig { params(package: String, no_upgrade: T::Boolean).returns(String) }
+        def failure_reason(package, no_upgrade:)
+          "#{PACKAGE_TYPE_NAME} #{package} needs to be installed."
+        end
+
+        sig { params(package: String, no_upgrade: T::Boolean).returns(T::Boolean) }
+        def installed_and_up_to_date?(package, no_upgrade: false)
+          require "bundle/go_installer"
+          Homebrew::Bundle::GoInstaller.package_installed?(package)
+        end
+      end
+    end
+  end
+end

Library/Homebrew/bundle/go_dumper.rb

@@ -0,0 +1,51 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Homebrew
+  module Bundle
+    module GoDumper
+      sig { void }
+      def self.reset!
+        @packages = nil
+      end
+
+      sig { returns(T::Array[String]) }
+      def self.packages
+        @packages ||= T.let(nil, T.nilable(T::Array[String]))
+        @packages ||= if Bundle.go_installed?
+          go = Bundle.which_go
+          gobin = `#{go} env GOBIN`.chomp
+          gopath = `#{go} env GOPATH`.chomp
+          bin_dir = gobin.empty? ? "#{gopath}/bin" : gobin
+
+          return [] unless File.directory?(bin_dir)
+
+          binaries = Dir.glob("#{bin_dir}/*").select { |f| File.executable?(f) && !File.directory?(f) }
+
+          binaries.filter_map do |binary|
+            output = `#{go} version -m "#{binary}" 2>/dev/null`
+            next if output.empty?
+
+            # Parse the output to find the path line
+            # Format: "\tpath\tgithub.com/user/repo"
+            lines = output.split("\n")
+            path_line = lines.find { |line| line.strip.start_with?("path\t") }
+            next unless path_line
+
+            # Extract the package path (second field after splitting by tab)
+            # The line format is: "\tpath\tgithub.com/user/repo"
+            parts = path_line.split("\t")
+            parts[2]&.strip if parts.length >= 3
+          end.compact.uniq
+        else
+          []
+        end
+      end
+
+      sig { returns(String) }
+      def self.dump
+        packages.map { |name| "go \"#{name}\"" }.join("\n")
+      end
+    end
+  end
+end

Library/Homebrew/bundle/go_installer.rb

@@ -0,0 +1,48 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+module Homebrew
+  module Bundle
+    module GoInstaller
+      def self.reset!
+        @installed_packages = nil
+      end
+
+      def self.preinstall!(name, verbose: false, **_options)
+        unless Bundle.go_installed?
+          puts "Installing go. It is not currently installed." if verbose
+          Bundle.brew("install", "--formula", "go", verbose:)
+          raise "Unable to install #{name} package. Go installation failed." unless Bundle.go_installed?
+        end
+
+        if package_installed?(name)
+          puts "Skipping install of #{name} Go package. It is already installed." if verbose
+          return false
+        end
+
+        true
+      end
+
+      def self.install!(name, preinstall: true, verbose: false, force: false, **_options)
+        return true unless preinstall
+
+        puts "Installing #{name} Go package. It is not currently installed." if verbose
+
+        go = Bundle.which_go
+        return false unless Bundle.system go.to_s, "install", "#{name}@latest", verbose: verbose
+
+        installed_packages << name
+        true
+      end
+
+      def self.package_installed?(package)
+        installed_packages.include? package
+      end
+
+      def self.installed_packages
+        require "bundle/go_dumper"
+        @installed_packages ||= Homebrew::Bundle::GoDumper.packages
+      end
+    end
+  end
+end