Migrate Homebrew/bundle to Homebrew/brew

.devcontainer/devcontainer.json

@@ -6,15 +6,6 @@
   "workspaceMount": "source=${localWorkspaceFolder},target=/home/linuxbrew/.linuxbrew/Homebrew,type=bind,consistency=cached",
   "onCreateCommand": ".devcontainer/on-create-command.sh",
   "customizations": {
-    "codespaces": {
-      "repositories": {
-        "Homebrew/homebrew-bundle": {
-          "permissions": {
-            "contents": "write"
-          }
-        }
-      }
-    },
     "vscode": {
       // Installing all necessary extensions for vscode
       // Taken from: .vscode/extensions.json

.devcontainer/on-create-command.sh

@@ -23,8 +23,6 @@ brew cleanup
 
 # actually tap homebrew/core, no longer done by default
 brew tap --force homebrew/core
-# tap some other repos so codespaces can be used for developing multiple taps
-brew tap homebrew/bundle
 
 # install some useful development things
 sudo apt-get update

.github/workflows/tests.yml

@@ -113,7 +113,6 @@ jobs:
 
       - name: Set up all Homebrew taps
         run: |
-          brew tap homebrew/bundle
           brew tap homebrew/command-not-found
           brew tap homebrew/portable-ruby
 
@@ -122,8 +121,7 @@ jobs:
 
       - name: Run brew style on official taps
         run: |
-          brew style homebrew/bundle \
-                     homebrew/test-bot
+          brew style homebrew/test-bot
 
           brew style homebrew/command-not-found \
                      homebrew/portable-ruby

Library/.rubocop.yml

@@ -297,6 +297,7 @@ Sorbet/StrictSigil:
     - "Homebrew/utils/ruby_check_version_script.rb" # A standalone script.
     - "Homebrew/{standalone,startup}/*.rb" # These are loaded before sorbet-runtime
     - "Homebrew/test/**/*.rb"
+    - "Homebrew/bundle/{brew_dumper,checker,commands/exec}.rb" # These aren't typed: true yet.
 
 Sorbet/TrueSigil:
   Enabled: true

Library/Homebrew/bundle.rb

@@ -0,0 +1,40 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "bundle/brewfile"
+require "bundle/bundle"
+require "bundle/dsl"
+require "bundle/adder"
+require "bundle/checker"
+require "bundle/remover"
+require "bundle/skipper"
+require "bundle/brew_services"
+require "bundle/brew_service_checker"
+require "bundle/brew_installer"
+require "bundle/brew_checker"
+require "bundle/cask_installer"
+require "bundle/mac_app_store_installer"
+require "bundle/mac_app_store_checker"
+require "bundle/tap_installer"
+require "bundle/brew_dumper"
+require "bundle/cask_dumper"
+require "bundle/cask_checker"
+require "bundle/mac_app_store_dumper"
+require "bundle/tap_dumper"
+require "bundle/tap_checker"
+require "bundle/dumper"
+require "bundle/installer"
+require "bundle/lister"
+require "bundle/commands/install"
+require "bundle/commands/dump"
+require "bundle/commands/cleanup"
+require "bundle/commands/check"
+require "bundle/commands/exec"
+require "bundle/commands/list"
+require "bundle/commands/add"
+require "bundle/commands/remove"
+require "bundle/whalebrew_installer"
+require "bundle/whalebrew_dumper"
+require "bundle/vscode_extension_checker"
+require "bundle/vscode_extension_dumper"
+require "bundle/vscode_extension_installer"

Library/Homebrew/bundle/adder.rb

@@ -0,0 +1,31 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+module Homebrew
+  module Bundle
+    module Adder
+      module_function
+
+      def add(*args, type:, global:, file:)
+        brewfile = Brewfile.read(global:, file:)
+        content = brewfile.input
+        # TODO: - support `:describe`
+        new_content = args.map do |arg|
+          case type
+          when :brew
+            Formulary.factory(arg)
+          when :cask
+            Cask::CaskLoader.load(arg)
+          end
+
+          "#{type} \"#{arg}\""
+        end
+
+        content << new_content.join("\n") << "\n"
+        path = Dumper.brewfile_path(global:, file:)
+
+        Dumper.write_file path, content
+      end
+    end
+  end
+end

Library/Homebrew/bundle/brew_checker.rb

@@ -0,0 +1,17 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+module Homebrew
+  module Bundle
+    module Checker
+      class BrewChecker < Homebrew::Bundle::Checker::Base
+        PACKAGE_TYPE = :brew
+        PACKAGE_TYPE_NAME = "Formula"
+
+        def installed_and_up_to_date?(formula, no_upgrade: false)
+          Homebrew::Bundle::BrewInstaller.formula_installed_and_up_to_date?(formula, no_upgrade:)
+        end
+      end
+    end
+  end
+end

Library/Homebrew/bundle/brew_dumper.rb

@@ -0,0 +1,240 @@
+# typed: false # rubocop:todo Sorbet/TrueSigil
+# frozen_string_literal: true
+
+require "json"
+require "tsort"
+
+module Homebrew
+  module Bundle
+    # TODO: refactor into multiple modules
+    module BrewDumper
+      module_function
+
+      def reset!
+        Homebrew::Bundle::BrewServices.reset!
+        @formulae = nil
+        @formulae_by_full_name = nil
+        @formulae_by_name = nil
+        @formula_aliases = nil
+        @formula_oldnames = nil
+      end
+
+      def formulae
+        return @formulae if @formulae
+
+        formulae_by_full_name
+        @formulae
+      end
+
+      def formulae_by_full_name(name = nil)
+        return @formulae_by_full_name[name] if name.present? && @formulae_by_full_name&.key?(name)
+
+        require "formula"
+        require "formulary"
+        Formulary.enable_factory_cache!
+
+        @formulae_by_name ||= {}
+        @formulae_by_full_name ||= {}
+
+        if name.nil?
+          formulae = Formula.installed.map(&method(:add_formula))
+          sort!(formulae)
+          return @formulae_by_full_name
+        end
+
+        formula = Formula[name]
+        add_formula(formula)
+      rescue FormulaUnavailableError => e
+        opoo "'#{name}' formula is unreadable: #{e}"
+        {}
+      end
+
+      def formulae_by_name(name)
+        formulae_by_full_name(name) || @formulae_by_name[name]
+      end
+
+      def dump(describe: false, no_restart: false)
+        requested_formula = formulae.select do |f|
+          f[:installed_on_request?] || !f[:installed_as_dependency?]
+        end
+        requested_formula.map do |f|
+          brewline = if describe && f[:desc].present?
+            f[:desc].split("\n").map { |s| "# #{s}\n" }.join
+          else
+            ""
+          end
+          brewline += "brew \"#{f[:full_name]}\""
+
+          args = f[:args].map { |arg| "\"#{arg}\"" }.sort.join(", ")
+          brewline += ", args: [#{args}]" unless f[:args].empty?
+          brewline += ", restart_service: :changed" if !no_restart && BrewServices.started?(f[:full_name])
+          brewline += ", link: #{f[:link?]}" unless f[:link?].nil?
+          brewline
+        end.join("\n")
+      end
+
+      def formula_aliases
+        return @formula_aliases if @formula_aliases
+
+        @formula_aliases = {}
+        formulae.each do |f|
+          aliases = f[:aliases]
+          next if aliases.blank?
+
+          aliases.each do |a|
+            @formula_aliases[a] = f[:full_name]
+            if f[:full_name].include? "/" # tap formula
+              tap_name = f[:full_name].rpartition("/").first
+              @formula_aliases["#{tap_name}/#{a}"] = f[:full_name]
+            end
+          end
+        end
+        @formula_aliases
+      end
+
+      def formula_oldnames
+        return @formula_oldnames if @formula_oldnames
+
+        @formula_oldnames = {}
+        formulae.each do |f|
+          oldnames = f[:oldnames]
+          next if oldnames.blank?
+
+          oldnames.each do |oldname|
+            @formula_oldnames[oldname] = f[:full_name]
+            if f[:full_name].include? "/" # tap formula
+              tap_name = f[:full_name].rpartition("/").first
+              @formula_oldnames["#{tap_name}/#{oldname}"] = f[:full_name]
+            end
+          end
+        end
+        @formula_oldnames
+      end
+
+      def add_formula(formula)
+        hash = formula_to_hash formula
+
+        @formulae_by_name[hash[:name]] = hash
+        @formulae_by_full_name[hash[:full_name]] = hash
+
+        hash
+      end
+      private_class_method :add_formula
+
+      def formula_to_hash(formula)
+        keg = if formula.linked?
+          link = true if formula.keg_only?
+          formula.linked_keg
+        else
+          link = false unless formula.keg_only?
+          formula.any_installed_prefix
+        end
+
+        if keg
+          require "tab"
+
+          tab = Tab.for_keg(keg)
+          args = tab.used_options.map(&:name)
+          version = begin
+            keg.realpath.basename
+          rescue
+            # silently handle broken symlinks
+            nil
+          end.to_s
+          args << "HEAD" if version.start_with?("HEAD")
+          installed_as_dependency = tab.installed_as_dependency
+          installed_on_request = tab.installed_on_request
+          runtime_dependencies = if (runtime_deps = tab.runtime_dependencies)
+            runtime_deps.filter_map { |d| d["full_name"] }
+
+          end
+          poured_from_bottle = tab.poured_from_bottle
+        end
+
+        runtime_dependencies ||= formula.runtime_dependencies.map(&:name)
+
+        bottled = if (stable = formula.stable) && stable.bottle_defined?
+          bottle_hash = formula.bottle_hash.deep_symbolize_keys
+          stable.bottled?
+        end
+
+        {
+          name:                     formula.name,
+          desc:                     formula.desc,
+          oldnames:                 formula.oldnames,
+          full_name:                formula.full_name,
+          aliases:                  formula.aliases,
+          any_version_installed?:   formula.any_version_installed?,
+          args:                     Array(args).uniq,
+          version:,
+          installed_as_dependency?: installed_as_dependency || false,
+          installed_on_request?:    installed_on_request || false,
+          dependencies:             runtime_dependencies,
+          build_dependencies:       formula.deps.select(&:build?).map(&:name).uniq,
+          conflicts_with:           formula.conflicts.map(&:name),
+          pinned?:                  formula.pinned? || false,
+          outdated?:                formula.outdated? || false,
+          link?:                    link,
+          poured_from_bottle?:      poured_from_bottle || false,
+          bottle:                   bottle_hash || false,
+          bottled:                  bottled || false,
+          official_tap:             formula.tap&.official? || false,
+        }
+      end
+      private_class_method :formula_to_hash
+
+      class Topo < Hash
+        include TSort
+        alias tsort_each_node each_key
+        def tsort_each_child(node, &block)
+          fetch(node.downcase).sort.each(&block)
+        end
+      end
+
+      def sort!(formulae)
+        # Step 1: Sort by formula full name while putting tap formulae behind core formulae.
+        #         So we can have a nicer output.
+        formulae = formulae.sort do |a, b|
+          if a[:full_name].exclude?("/") && b[:full_name].include?("/")
+            -1
+          elsif a[:full_name].include?("/") && b[:full_name].exclude?("/")
+            1
+          else
+            a[:full_name] <=> b[:full_name]
+          end
+        end
+
+        # Step 2: Sort by formula dependency topology.
+        topo = Topo.new
+        formulae.each do |f|
+          topo[f[:name]] = topo[f[:full_name]] = f[:dependencies].filter_map do |dep|
+            ff = formulae_by_name(dep)
+            next if ff.blank?
+            next unless ff[:any_version_installed?]
+
+            ff[:full_name]
+          end
+        end
+        @formulae = topo.tsort
+                        .map { |name| @formulae_by_full_name[name] || @formulae_by_name[name] }
+                        .uniq { |f| f[:full_name] }
+      rescue TSort::Cyclic => e
+        e.message =~ /\["([^"]*)".*"([^"]*)"\]/
+        cycle_first = Regexp.last_match(1)
+        cycle_last = Regexp.last_match(2)
+        odie e.message if !cycle_first || !cycle_last
+
+        odie <<~EOS
+          Formulae dependency graph sorting failed (likely due to a circular dependency):
+          #{cycle_first}: #{topo[cycle_first]}
+          #{cycle_last}: #{topo[cycle_last]}
+          Please run the following commands and try again:
+            brew update
+            brew uninstall --ignore-dependencies --force #{cycle_first} #{cycle_last}
+            brew install #{cycle_first} #{cycle_last}
+        EOS
+      end
+      private_class_method :sort!
+    end
+  end
+end