Merge pull request #18093 from Homebrew/no-include-kernel

Library/Homebrew/cmd/reinstall.rb

@@ -134,7 +134,7 @@ module Homebrew
             next
           end
           Migrator.migrate_if_needed(formula, force: args.force?)
-          Homebrew.reinstall_formula(
+          Homebrew::Reinstall.reinstall_formula(
             formula,
             flags:                      args.flags_only,
             installed_on_request:       args.named.present?,

Library/Homebrew/global.rbi

@@ -1,5 +0,0 @@
-# typed: strict
-
-module Homebrew
-  include Kernel
-end

Library/Homebrew/reinstall.rb

@@ -6,103 +6,106 @@ require "development_tools"
 require "messages"
 
 module Homebrew
-  module_function
+  module Reinstall
-
+    def self.reinstall_formula(
-  def reinstall_formula(
-    formula,
-    flags:,
-    installed_on_request: false,
-    force_bottle: false,
-    build_from_source_formulae: [],
-    interactive: false,
-    keep_tmp: false,
-    debug_symbols: false,
-    force: false,
-    debug: false,
-    quiet: false,
-    verbose: false,
-    git: false
-  )
-    if formula.opt_prefix.directory?
-      keg = Keg.new(formula.opt_prefix.resolved_path)
-      tab = keg.tab
-      keg_had_linked_opt = true
-      keg_was_linked = keg.linked?
-      backup keg
-    end
-
-    build_options = BuildOptions.new(Options.create(flags), formula.options)
-    options = build_options.used_options
-    options |= formula.build.used_options
-    options &= formula.options
-
-    fi = FormulaInstaller.new(
       formula,
-      **{
+      flags:,
-        options:,
+      installed_on_request: false,
-        link_keg:                   keg_had_linked_opt ? keg_was_linked : nil,
+      force_bottle: false,
-        installed_as_dependency:    tab&.installed_as_dependency,
+      build_from_source_formulae: [],
-        installed_on_request:       installed_on_request || tab&.installed_on_request,
+      interactive: false,
-        build_bottle:               tab&.built_bottle?,
+      keep_tmp: false,
-        force_bottle:,
+      debug_symbols: false,
-        build_from_source_formulae:,
+      force: false,
-        git:,
+      debug: false,
-        interactive:,
+      quiet: false,
-        keep_tmp:,
+      verbose: false,
-        debug_symbols:,
+      git: false
-        force:,
-        debug:,
-        quiet:,
-        verbose:,
-      }.compact,
     )
-    fi.prelude
+      if formula.opt_prefix.directory?
-    fi.fetch
+        keg = Keg.new(formula.opt_prefix.resolved_path)
+        tab = keg.tab
+        keg_had_linked_opt = true
+        keg_was_linked = keg.linked?
+        backup keg
+      end
 
-    oh1 "Reinstalling #{Formatter.identifier(formula.full_name)} #{options.to_a.join " "}"
+      build_options = BuildOptions.new(Options.create(flags), formula.options)
+      options = build_options.used_options
+      options |= formula.build.used_options
+      options &= formula.options
 
-    fi.install
+      fi = FormulaInstaller.new(
-    fi.finish
+        formula,
-  rescue FormulaInstallationAlreadyAttemptedError
+        **{
-    nil
+          options:,
-  rescue Exception # rubocop:disable Lint/RescueException
+          link_keg:                   keg_had_linked_opt ? keg_was_linked : nil,
-    ignore_interrupts { restore_backup(keg, keg_was_linked, verbose:) }
+          installed_as_dependency:    tab&.installed_as_dependency,
-    raise
+          installed_on_request:       installed_on_request || tab&.installed_on_request,
-  else
+          build_bottle:               tab&.built_bottle?,
-    begin
+          force_bottle:,
-      backup_path(keg).rmtree if backup_path(keg).exist?
+          build_from_source_formulae:,
-    rescue Errno::EACCES, Errno::ENOTEMPTY
+          git:,
-      odie <<~EOS
+          interactive:,
-        Could not remove #{backup_path(keg).parent.basename} backup keg! Do so manually:
+          keep_tmp:,
-          sudo rm -rf #{backup_path(keg)}
+          debug_symbols:,
-      EOS
+          force:,
+          debug:,
+          quiet:,
+          verbose:,
+        }.compact,
+      )
+      fi.prelude
+      fi.fetch
+
+      oh1 "Reinstalling #{Formatter.identifier(formula.full_name)} #{options.to_a.join " "}"
+
+      fi.install
+      fi.finish
+    rescue FormulaInstallationAlreadyAttemptedError
+      nil
+    rescue Exception # rubocop:disable Lint/RescueException
+      ignore_interrupts { restore_backup(keg, keg_was_linked, verbose:) }
+      raise
+    else
+      begin
+        backup_path(keg).rmtree if backup_path(keg).exist?
+      rescue Errno::EACCES, Errno::ENOTEMPTY
+        odie <<~EOS
+          Could not remove #{backup_path(keg).parent.basename} backup keg! Do so manually:
+            sudo rm -rf #{backup_path(keg)}
+        EOS
+      end
     end
-  end
 
-  def backup(keg)
+    def self.backup(keg)
-    keg.unlink
+      keg.unlink
-    begin
+      begin
-      keg.rename backup_path(keg)
+        keg.rename backup_path(keg)
-    rescue Errno::EACCES, Errno::ENOTEMPTY
+      rescue Errno::EACCES, Errno::ENOTEMPTY
-      odie <<~EOS
+        odie <<~EOS
-        Could not rename #{keg.name} keg! Check/fix its permissions:
+          Could not rename #{keg.name} keg! Check/fix its permissions:
-          sudo chown -R #{ENV.fetch("USER", "$(whoami)")} #{keg}
+            sudo chown -R #{ENV.fetch("USER", "$(whoami)")} #{keg}
-      EOS
+        EOS
+      end
     end
-  end
+    private_class_method :backup
 
-  def restore_backup(keg, keg_was_linked, verbose:)
+    def self.restore_backup(keg, keg_was_linked, verbose:)
-    path = backup_path(keg)
+      path = backup_path(keg)
 
-    return unless path.directory?
+      return unless path.directory?
 
-    Pathname.new(keg).rmtree if keg.exist?
+      Pathname.new(keg).rmtree if keg.exist?
 
-    path.rename keg
+      path.rename keg
-    keg.link(verbose:) if keg_was_linked
+      keg.link(verbose:) if keg_was_linked
-  end
+    end
+    private_class_method :restore_backup
 
-  def backup_path(path)
+    def self.backup_path(path)
-    Pathname.new "#{path}.reinstall"
+      Pathname.new "#{path}.reinstall"
+    end
+    private_class_method :backup_path
   end
 end

Library/Homebrew/upgrade.rb

@@ -409,7 +409,7 @@ module Homebrew
       return if dry_run
 
       reinstallable_broken_dependents.each do |formula|
-        Homebrew.reinstall_formula(
+        Reinstall.reinstall_formula(
           formula,
           flags:,
           force_bottle:,

Library/Homebrew/utils/gems.rb

@@ -30,19 +30,17 @@ module Homebrew
   ).freeze
   private_constant :VENDOR_VERSION_FILE
 
-  module_function
+  def self.gemfile
-
-  def gemfile
     File.join(ENV.fetch("HOMEBREW_LIBRARY"), "Homebrew", "Gemfile")
   end
   private_class_method :gemfile
 
-  def bundler_definition
+  def self.bundler_definition
     @bundler_definition ||= Bundler::Definition.build(Bundler.default_gemfile, Bundler.default_lockfile, false)
   end
   private_class_method :bundler_definition
 
-  def valid_gem_groups
+  def self.valid_gem_groups
     install_bundler!
     require "bundler"
 
@@ -54,11 +52,11 @@ module Homebrew
     end
   end
 
-  def ruby_bindir
+  def self.ruby_bindir
     "#{RbConfig::CONFIG["prefix"]}/bin"
   end
 
-  def ohai_if_defined(message)
+  def self.ohai_if_defined(message)
     if defined?(ohai)
       $stderr.ohai message
     else
@@ -66,7 +64,7 @@ module Homebrew
     end
   end
 
-  def opoo_if_defined(message)
+  def self.opoo_if_defined(message)
     if defined?(opoo)
       $stderr.opoo message
     else
@@ -74,7 +72,7 @@ module Homebrew
     end
   end
 
-  def odie_if_defined(message)
+  def self.odie_if_defined(message)
     if defined?(odie)
       odie message
     else
@@ -83,7 +81,7 @@ module Homebrew
     end
   end
 
-  def setup_gem_environment!(setup_path: true)
+  def self.setup_gem_environment!(setup_path: true)
     require "rubygems"
     raise "RubyGems too old!" if Gem::Version.new(Gem::VERSION) < Gem::Version.new("2.2.0")
 
@@ -114,7 +112,7 @@ module Homebrew
     ENV["GEM_PATH"] = gem_home
   end
 
-  def install_gem!(name, version: nil, setup_gem_environment: true)
+  def self.install_gem!(name, version: nil, setup_gem_environment: true)
     setup_gem_environment! if setup_gem_environment
 
     specs = Gem::Specification.find_all_by_name(name, version)
@@ -141,7 +139,7 @@ module Homebrew
     odie_if_defined "failed to install the '#{name}' gem."
   end
 
-  def install_gem_setup_path!(name, version: nil, executable: name, setup_gem_environment: true)
+  def self.install_gem_setup_path!(name, version: nil, executable: name, setup_gem_environment: true)
     install_gem!(name, version:, setup_gem_environment:)
     return if find_in_path(executable)
 
@@ -151,14 +149,14 @@ module Homebrew
     EOS
   end
 
-  def find_in_path(executable)
+  def self.find_in_path(executable)
     ENV.fetch("PATH").split(":").find do |path|
       File.executable?(File.join(path, executable))
     end
   end
   private_class_method :find_in_path
 
-  def install_bundler!
+  def self.install_bundler!
     old_bundler_version = ENV.fetch("BUNDLER_VERSION", nil)
 
     setup_gem_environment!
@@ -174,7 +172,7 @@ module Homebrew
     ENV["BUNDLER_VERSION"] = old_bundler_version
   end
 
-  def user_gem_groups
+  def self.user_gem_groups
     @user_gem_groups ||= if GEM_GROUPS_FILE.exist?
       GEM_GROUPS_FILE.readlines(chomp: true)
     else
@@ -183,7 +181,7 @@ module Homebrew
   end
   private_class_method :user_gem_groups
 
-  def write_user_gem_groups(groups)
+  def self.write_user_gem_groups(groups)
     return if @user_gem_groups == groups && GEM_GROUPS_FILE.exist?
 
     # Write the file atomically, in case we're working parallel
@@ -206,12 +204,12 @@ module Homebrew
   end
   private_class_method :write_user_gem_groups
 
-  def forget_user_gem_groups!
+  def self.forget_user_gem_groups!
     GEM_GROUPS_FILE.truncate(0) if GEM_GROUPS_FILE.exist?
     @user_gem_groups = []
   end
 
-  def user_vendor_version
+  def self.user_vendor_version
     @user_vendor_version ||= if VENDOR_VERSION_FILE.exist?
       VENDOR_VERSION_FILE.read.to_i
     else
@@ -220,7 +218,7 @@ module Homebrew
   end
   private_class_method :user_vendor_version
 
-  def install_bundler_gems!(only_warn_on_failure: false, setup_path: true, groups: [])
+  def self.install_bundler_gems!(only_warn_on_failure: false, setup_path: true, groups: [])
     old_path = ENV.fetch("PATH", nil)
     old_gem_path = ENV.fetch("GEM_PATH", nil)
     old_gem_home = ENV.fetch("GEM_HOME", nil)