Merge branch 'master' into mlh-outdated-packages

Library/.rubocop_rspec.yml

@@ -43,3 +43,5 @@ RSpec/MultipleExpectations:
   Max: 26
 RSpec/NestedGroups:
   Max: 5
+RSpec/MultipleMemoizedHelpers:
+  Max: 12

Library/Homebrew/.simplecov

@@ -3,6 +3,8 @@
 
 require "English"
 
+SimpleCov.enable_for_subprocesses true
+
 SimpleCov.start do
   coverage_dir File.expand_path("../test/coverage", File.realpath(__FILE__))
   root File.expand_path("..", File.realpath(__FILE__))
@@ -12,9 +14,21 @@ SimpleCov.start do
   # tests to be dropped. This causes random fluctuations in test coverage.
   merge_timeout 86400
 
+  at_fork do |pid|
+    # This needs a unique name so it won't be ovewritten
+    command_name "#{SimpleCov.command_name} (#{pid})"
+
+    # be quiet, the parent process will be in charge of output and checking coverage totals
+    print_error_status = false
+  end
+
   if ENV["HOMEBREW_INTEGRATION_TEST"]
+    # This needs a unique name so it won't be ovewritten
     command_name "#{ENV["HOMEBREW_INTEGRATION_TEST"]} (#{$PROCESS_ID})"
 
+    # be quiet, the parent process will be in charge of output and checking coverage totals
+    print_error_status = false
+
     at_exit do
       exit_code = $ERROR_INFO.nil? ? 0 : $ERROR_INFO.status
       $stdout.reopen("/dev/null")

Library/Homebrew/Gemfile.lock

@@ -10,7 +10,7 @@ GEM
     ast (2.4.1)
     bindata (2.4.8)
     byebug (11.1.3)
-    codecov (0.2.5)
+    codecov (0.2.6)
       colorize
       json
       simplecov
@@ -112,11 +112,11 @@ GEM
       parser (>= 2.7.1.4)
     rubocop-performance (1.7.1)
       rubocop (>= 0.82.0)
-    rubocop-rspec (1.42.0)
-      rubocop (>= 0.87.0)
+    rubocop-rspec (1.43.1)
+      rubocop (~> 0.87)
     ruby-macho (2.2.0)
     ruby-progressbar (1.10.1)
-    simplecov (0.18.5)
+    simplecov (0.19.0)
       docile (~> 1.1)
       simplecov-html (~> 0.11)
     simplecov-html (0.12.2)

Library/Homebrew/brew.sh

@@ -6,12 +6,18 @@ case "$HOMEBREW_SYSTEM" in
 esac
 
 # Force UTF-8 to avoid encoding issues for users with broken locale settings.
-if [[ "$(locale charmap 2>/dev/null)" != "UTF-8" ]]
+if [[ -n "$HOMEBREW_MACOS" ]]
 then
-  if [[ -n "$HOMEBREW_MACOS" ]]
+  if [[ "$(locale charmap)" != "UTF-8" ]]
   then
     export LC_ALL="en_US.UTF-8"
-  else
+  fi
+else
+  if ! command -v locale >/dev/null
+  then
+    export LC_ALL=C
+  elif [[ "$(locale charmap)" != "UTF-8" ]]
+  then
     locales=$(locale -a)
     c_utf_regex='\bC\.(utf8|UTF-8)\b'
     en_us_regex='\ben_US\.(utf8|UTF-8)\b'

Library/Homebrew/build_environment.rb

 # frozen_string_literal: true
 
+# Settings for the build environment.
+#
+# @api private
 class BuildEnvironment
   def initialize(*settings)
     @settings = Set.new(*settings)
@@ -23,35 +26,35 @@ class BuildEnvironment
     @settings.include? :userpaths
   end
 
+  # DSL for specifying build environment settings.
   module DSL
     def env(*settings)
       @env ||= BuildEnvironment.new
       @env.merge(settings)
     end
   end
-end
 
-module Homebrew
-  module_function
+  KEYS = %w[
+    CC CXX LD OBJC OBJCXX
+    HOMEBREW_CC HOMEBREW_CXX
+    CFLAGS CXXFLAGS CPPFLAGS LDFLAGS SDKROOT MAKEFLAGS
+    CMAKE_PREFIX_PATH CMAKE_INCLUDE_PATH CMAKE_LIBRARY_PATH CMAKE_FRAMEWORK_PATH
+    MACOSX_DEPLOYMENT_TARGET PKG_CONFIG_PATH PKG_CONFIG_LIBDIR
+    HOMEBREW_DEBUG HOMEBREW_MAKE_JOBS HOMEBREW_VERBOSE
+    HOMEBREW_SVN HOMEBREW_GIT
+    HOMEBREW_SDKROOT
+    MAKE GIT CPP
+    ACLOCAL_PATH PATH CPATH
+    LD_LIBRARY_PATH LD_RUN_PATH LD_PRELOAD LIBRARY_PATH
+  ].freeze
+  private_constant :KEYS
 
-  def build_env_keys(env)
-    %w[
-      CC CXX LD OBJC OBJCXX
-      HOMEBREW_CC HOMEBREW_CXX
-      CFLAGS CXXFLAGS CPPFLAGS LDFLAGS SDKROOT MAKEFLAGS
-      CMAKE_PREFIX_PATH CMAKE_INCLUDE_PATH CMAKE_LIBRARY_PATH CMAKE_FRAMEWORK_PATH
-      MACOSX_DEPLOYMENT_TARGET PKG_CONFIG_PATH PKG_CONFIG_LIBDIR
-      HOMEBREW_DEBUG HOMEBREW_MAKE_JOBS HOMEBREW_VERBOSE
-      HOMEBREW_SVN HOMEBREW_GIT
-      HOMEBREW_SDKROOT
-      MAKE GIT CPP
-      ACLOCAL_PATH PATH CPATH
-      LD_LIBRARY_PATH LD_RUN_PATH LD_PRELOAD LIBRARY_PATH
-    ].select { |key| env.key?(key) }
+  def self.keys(env)
+    KEYS & env.keys
   end
 
-  def dump_build_env(env, f = $stdout)
-    keys = build_env_keys(env)
+  def self.dump(env, f = $stdout)
+    keys = self.keys(env)
     keys -= %w[CC CXX OBJC OBJCXX] if env["CC"] == env["HOMEBREW_CC"]
 
     keys.each do |key|

Library/Homebrew/cask/artifact/stage_only.rb

@@ -18,6 +18,10 @@ module Cask
       def to_a
         [true]
       end
+
+      def summarize
+        "true"
+      end
     end
   end
 end

Library/Homebrew/cask/cmd.rb

@@ -47,6 +47,16 @@ module Cask
       "dr"       => "doctor",
     }.freeze
 
+    DEPRECATED_COMMANDS = {
+      Cmd::Cache     => "brew --cache --cask",
+      Cmd::Doctor    => "brew doctor --verbose",
+      Cmd::Home      => "brew home",
+      Cmd::List      => "brew list --cask",
+      Cmd::Outdated  => "brew outdated --cask",
+      Cmd::Reinstall => "brew reinstall",
+      Cmd::Upgrade   => "brew upgrade --cask",
+    }.freeze
+
     def self.description
       max_command_len = Cmd.commands.map(&:length).max
 
@@ -212,6 +222,11 @@ module Cask
                       detect_external_command(*argv) ||
                       [args.remaining.empty? ? NullCommand : UnknownSubcommand.new(args.remaining.first), argv]
 
+      # TODO: enable for next major/minor release
+      # if (replacement = DEPRECATED_COMMANDS[command])
+      #   odeprecated "brew cask #{command.command_name}", replacement
+      # end
+
       if args.help?
         puts command.help
       else

Library/Homebrew/cask/cmd/audit.rb

@@ -28,9 +28,9 @@ module Cask
           switch "--online",
                  description: "Run additional, slower style checks that require a network connection"
           switch "--new-cask",
-                 description: "Run various additional style checks to determine if a new cask is eligible
-                               for Homebrew. This should be used when creating new casks and implies
-                               `--strict` and `--online`"
+                 description: "Run various additional style checks to determine if a new cask is eligible " \
+                              "for Homebrew. This should be used when creating new casks and implies " \
+                              "`--strict` and `--online`"
         end
       end
 

Library/Homebrew/cask/cmd/home.rb

@@ -8,8 +8,6 @@ module Cask
       end
 
       def run
-        # odeprecated "brew cask home", "brew home"
-
         if casks.none?
           odebug "Opening project homepage"
           self.class.open_url "https://brew.sh/"

Library/Homebrew/cleanup.rb

@@ -6,126 +6,131 @@ require "formula"
 require "cask/cask_loader"
 require "set"
 
-CLEANUP_DEFAULT_DAYS = 30
+module Homebrew
+  # Helper class for cleaning up the Homebrew cache.
+  #
+  # @api private
+  class Cleanup
+    CLEANUP_DEFAULT_DAYS = 30
+    private_constant :CLEANUP_DEFAULT_DAYS
+
+    # `Pathname` refinement with helper functions for cleaning up files.
+    module CleanupRefinement
+      refine Pathname do
+        def incomplete?
+          extname.end_with?(".incomplete")
+        end
 
-module CleanupRefinement
-  refine Pathname do
-    def incomplete?
-      extname.end_with?(".incomplete")
-    end
+        def nested_cache?
+          directory? && %w[
+            cargo_cache
+            go_cache
+            go_mod_cache
+            glide_home
+            java_cache
+            npm_cache
+            gclient_cache
+          ].include?(basename.to_s)
+        end
 
-    def nested_cache?
-      directory? && %w[
-        cargo_cache
-        go_cache
-        go_mod_cache
-        glide_home
-        java_cache
-        npm_cache
-        gclient_cache
-      ].include?(basename.to_s)
-    end
+        def go_cache_directory?
+          # Go makes its cache contents read-only to ensure cache integrity,
+          # which makes sense but is something we need to undo for cleanup.
+          directory? && %w[go_cache go_mod_cache].include?(basename.to_s)
+        end
 
-    def go_cache_directory?
-      # Go makes its cache contents read-only to ensure cache integrity,
-      # which makes sense but is something we need to undo for cleanup.
-      directory? && %w[go_cache go_mod_cache].include?(basename.to_s)
-    end
+        def prune?(days)
+          return false unless days
+          return true if days.zero?
 
-    def prune?(days)
-      return false unless days
-      return true if days.zero?
+          return true if symlink? && !exist?
 
-      return true if symlink? && !exist?
+          mtime < days.days.ago && ctime < days.days.ago
+        end
 
-      mtime < days.days.ago && ctime < days.days.ago
-    end
+        def stale?(scrub = false)
+          return false unless resolved_path.file?
 
-    def stale?(scrub = false)
-      return false unless resolved_path.file?
+          if dirname.basename.to_s == "Cask"
+            stale_cask?(scrub)
+          else
+            stale_formula?(scrub)
+          end
+        end
 
-      if dirname.basename.to_s == "Cask"
-        stale_cask?(scrub)
-      else
-        stale_formula?(scrub)
-      end
-    end
+        private
 
-    private
+        def stale_formula?(scrub)
+          return false unless HOMEBREW_CELLAR.directory?
 
-    def stale_formula?(scrub)
-      return false unless HOMEBREW_CELLAR.directory?
+          version = if to_s.match?(Pathname::BOTTLE_EXTNAME_RX)
+            begin
+              Utils::Bottles.resolve_version(self)
+            rescue
+              nil
+            end
+          end
 
-      version = if to_s.match?(Pathname::BOTTLE_EXTNAME_RX)
-        begin
-          Utils::Bottles.resolve_version(self)
-        rescue
-          nil
-        end
-      end
+          version ||= basename.to_s[/\A.*(?:--.*?)*--(.*?)#{Regexp.escape(extname)}\Z/, 1]
+          version ||= basename.to_s[/\A.*--?(.*?)#{Regexp.escape(extname)}\Z/, 1]
 
-      version ||= basename.to_s[/\A.*(?:--.*?)*--(.*?)#{Regexp.escape(extname)}\Z/, 1]
-      version ||= basename.to_s[/\A.*--?(.*?)#{Regexp.escape(extname)}\Z/, 1]
+          return false unless version
 
-      return false unless version
+          version = Version.new(version)
 
-      version = Version.new(version)
+          return false unless formula_name = basename.to_s[/\A(.*?)(?:--.*?)*--?(?:#{Regexp.escape(version)})/, 1]
 
-      return false unless formula_name = basename.to_s[/\A(.*?)(?:--.*?)*--?(?:#{Regexp.escape(version)})/, 1]
+          formula = begin
+            Formulary.from_rack(HOMEBREW_CELLAR/formula_name)
+          rescue FormulaUnavailableError, TapFormulaAmbiguityError, TapFormulaWithOldnameAmbiguityError
+            return false
+          end
 
-      formula = begin
-        Formulary.from_rack(HOMEBREW_CELLAR/formula_name)
-      rescue FormulaUnavailableError, TapFormulaAmbiguityError, TapFormulaWithOldnameAmbiguityError
-        return false
-      end
+          resource_name = basename.to_s[/\A.*?--(.*?)--?(?:#{Regexp.escape(version)})/, 1]
+
+          if resource_name == "patch"
+            patch_hashes = formula.stable&.patches&.select(&:external?)&.map(&:resource)&.map(&:version)
+            return true unless patch_hashes&.include?(Checksum.new(:sha256, version.to_s))
+          elsif resource_name && resource_version = formula.stable&.resources&.dig(resource_name)&.version
+            return true if resource_version != version
+          elsif version.is_a?(PkgVersion)
+            return true if formula.pkg_version > version
+          elsif formula.version > version
+            return true
+          end
 
-      resource_name = basename.to_s[/\A.*?--(.*?)--?(?:#{Regexp.escape(version)})/, 1]
-
-      if resource_name == "patch"
-        patch_hashes = formula.stable&.patches&.select(&:external?)&.map(&:resource)&.map(&:version)
-        return true unless patch_hashes&.include?(Checksum.new(:sha256, version.to_s))
-      elsif resource_name && resource_version = formula.stable&.resources&.dig(resource_name)&.version
-        return true if resource_version != version
-      elsif version.is_a?(PkgVersion)
-        return true if formula.pkg_version > version
-      elsif formula.version > version
-        return true
-      end
+          return true if scrub && !formula.latest_version_installed?
 
-      return true if scrub && !formula.latest_version_installed?
+          return true if Utils::Bottles.file_outdated?(formula, self)
 
-      return true if Utils::Bottles.file_outdated?(formula, self)
+          false
+        end
 
-      false
-    end
+        def stale_cask?(scrub)
+          return false unless name = basename.to_s[/\A(.*?)--/, 1]
 
-    def stale_cask?(scrub)
-      return false unless name = basename.to_s[/\A(.*?)--/, 1]
+          cask = begin
+            Cask::CaskLoader.load(name)
+          rescue Cask::CaskError
+            return false
+          end
 
-      cask = begin
-        Cask::CaskLoader.load(name)
-      rescue Cask::CaskError
-        return false
-      end
+          return true unless basename.to_s.match?(/\A#{Regexp.escape(name)}--#{Regexp.escape(cask.version)}\b/)
 
-      return true unless basename.to_s.match?(/\A#{Regexp.escape(name)}--#{Regexp.escape(cask.version)}\b/)
+          return true if scrub && !cask.versions.include?(cask.version)
 
-      return true if scrub && !cask.versions.include?(cask.version)
+          if cask.version.latest?
+            return mtime < CLEANUP_DEFAULT_DAYS.days.ago &&
+                   ctime < CLEANUP_DEFAULT_DAYS.days.ago
+          end
 
-      if cask.version.latest?
-        return mtime < CLEANUP_DEFAULT_DAYS.days.ago &&
-               ctime < CLEANUP_DEFAULT_DAYS.days.ago
+          false
+        end
       end
-
-      false
     end
-  end
-end
 
-using CleanupRefinement
+    using CleanupRefinement
 
-module Homebrew
-  class Cleanup
     extend Predicable
 
     PERIODIC_CLEAN_FILE = (HOMEBREW_CACHE/".cleaned").freeze

Library/Homebrew/cli/args.rb

 # frozen_string_literal: true
 
+require "cli/named_args"
 require "ostruct"
 
 module Homebrew
@@ -19,7 +20,7 @@ module Homebrew
 
         # Can set these because they will be overwritten by freeze_named_args!
         # (whereas other values below will only be overwritten if passed).
-        self[:named_args] = []
+        self[:named_args] = NamedArgs.new
         self[:remaining] = []
       end
 
@@ -28,18 +29,12 @@ module Homebrew
       end
 
       def freeze_named_args!(named_args)
-        # Reset cache values reliant on named_args
-        @formulae = nil
-        @formulae_and_casks = nil
-        @resolved_formulae = nil
-        @resolved_formulae_casks = nil
-        @formulae_paths = nil
-        @casks = nil
-        @loaded_casks = nil
-        @kegs = nil
-        @kegs_casks = nil
-
-        self[:named_args] = named_args.freeze
+        self[:named_args] = NamedArgs.new(
+          *named_args.freeze,
+          override_spec: spec(nil),
+          force_bottle:  force_bottle?,
+          flags:         flags_only,
+        )
       end
 
       def freeze_processed_options!(processed_options)
@@ -54,7 +49,7 @@ module Homebrew
       end
 
       def named
-        named_args || []
+        named_args || NamedArgs.new
       end
 
       def no_named?
@@ -62,102 +57,39 @@ module Homebrew
       end
 
       def formulae
-        require "formula"
-
-        @formulae ||= (downcased_unique_named - casks).map do |name|
-          Formulary.factory(name, spec, force_bottle: force_bottle?, flags: flags_only)
-        end.uniq(&:name).freeze
+        named.to_formulae
       end
 
       def formulae_and_casks
-        @formulae_and_casks ||= begin
-          formulae_and_casks = []
-
-          downcased_unique_named.each do |name|
-            formulae_and_casks << Formulary.factory(name, spec)
-          rescue FormulaUnavailableError
-            begin
-              formulae_and_casks << Cask::CaskLoader.load(name)
-            rescue Cask::CaskUnavailableError
-              raise "No available formula or cask with the name \"#{name}\""
-            end
-          end
-
-          formulae_and_casks.freeze
-        end
+        named.to_formulae_and_casks
       end
 
       def resolved_formulae
-        require "formula"
-
-        @resolved_formulae ||= (downcased_unique_named - casks).map do |name|
-          Formulary.resolve(name, spec: spec(nil), force_bottle: force_bottle?, flags: flags_only)
-        end.uniq(&:name).freeze
+        named.to_resolved_formulae
       end
 
       def resolved_formulae_casks
-        @resolved_formulae_casks ||= begin
-          resolved_formulae = []
-          casks = []
-
-          downcased_unique_named.each do |name|
-            resolved_formulae << Formulary.resolve(name, spec: spec(nil),
-                                                   force_bottle: force_bottle?, flags: flags_only)
-          rescue FormulaUnavailableError
-            begin
-              casks << Cask::CaskLoader.load(name)
-            rescue Cask::CaskUnavailableError
-              raise "No available formula or cask with the name \"#{name}\""
-            end
-          end
-
-          [resolved_formulae.freeze, casks.freeze].freeze
-        end
+        named.to_resolved_formulae_to_casks
       end
 
       def formulae_paths
-        @formulae_paths ||= (downcased_unique_named - casks).map do |name|
-          Formulary.path(name)
-        end.uniq.freeze
+        named.to_formulae_paths
       end
 
       def casks
-        @casks ||= downcased_unique_named.grep(HOMEBREW_CASK_TAP_CASK_REGEX)
-                                         .freeze
+        named.homebrew_tap_cask_names
       end
 
       def loaded_casks
-        @loaded_casks ||= downcased_unique_named.map(&Cask::CaskLoader.method(:load)).freeze
+        named.to_casks
       end
 
       def kegs
-        @kegs ||= downcased_unique_named.map do |name|
-          resolve_keg name
-        rescue NoSuchKegError => e
-          if (reason = Homebrew::MissingFormula.suggest_command(name, "uninstall"))
-            $stderr.puts reason
-          end
-          raise e
-        end.freeze
+        named.to_kegs
       end
 
       def kegs_casks
-        @kegs_casks ||= begin
-          kegs = []
-          casks = []
-
-          downcased_unique_named.each do |name|
-            kegs << resolve_keg(name)
-          rescue NoSuchKegError
-            begin
-              casks << Cask::CaskLoader.load(name)
-            rescue Cask::CaskUnavailableError
-              raise "No installed keg or cask with the name \"#{name}\""
-            end
-          end
-
-          [kegs.freeze, casks.freeze].freeze
-        end
+        named.to_kegs_to_casks
       end
 
       def build_stable?
@@ -218,17 +150,6 @@ module Homebrew
         @cli_args.freeze
       end
 
-      def downcased_unique_named
-        # Only lowercase names, not paths, bottle filenames or URLs
-        named.map do |arg|
-          if arg.include?("/") || arg.end_with?(".tar.gz") || File.exist?(arg)
-            arg
-          else
-            arg.downcase
-          end
-        end.uniq
-      end
-
       def spec(default = :stable)
         if HEAD?
           :head
@@ -238,50 +159,6 @@ module Homebrew
           default
         end
       end
-
-      def resolve_keg(name)
-        require "keg"
-        require "formula"
-        require "missing_formula"
-
-        raise UsageError if name.blank?
-
-        rack = Formulary.to_rack(name.downcase)
-
-        dirs = rack.directory? ? rack.subdirs : []
-        raise NoSuchKegError, rack.basename if dirs.empty?
-
-        linked_keg_ref = HOMEBREW_LINKED_KEGS/rack.basename
-        opt_prefix = HOMEBREW_PREFIX/"opt/#{rack.basename}"
-
-        begin
-          if opt_prefix.symlink? && opt_prefix.directory?
-            Keg.new(opt_prefix.resolved_path)
-          elsif linked_keg_ref.symlink? && linked_keg_ref.directory?
-            Keg.new(linked_keg_ref.resolved_path)
-          elsif dirs.length == 1
-            Keg.new(dirs.first)
-          else
-            f = if name.include?("/") || File.exist?(name)
-              Formulary.factory(name)
-            else
-              Formulary.from_rack(rack)
-            end
-
-            unless (prefix = f.installed_prefix).directory?
-              raise MultipleVersionsInstalledError, "#{rack.basename} has multiple installed versions"
-            end
-
-            Keg.new(prefix)
-          end
-        rescue FormulaUnavailableError
-          raise MultipleVersionsInstalledError, <<~EOS
-            Multiple kegs installed to #{rack}
-            However we don't know which one you refer to.
-            Please delete (with rm -rf!) all but one and then try again.
-          EOS
-        end
-      end
     end
   end
 end

Library/Homebrew/cli/named_args.rb

+# frozen_string_literal: true
+
+require "delegate"
+
+module Homebrew
+  module CLI
+    class NamedArgs < SimpleDelegator
+      def initialize(*args, override_spec: nil, force_bottle: false, flags: [])
+        @args = args
+        @override_spec = override_spec
+        @force_bottle = force_bottle
+        @flags = flags
+
+        __setobj__(@args)
+      end
+
+      def to_formulae
+        @to_formulae ||= (downcased_unique_named - homebrew_tap_cask_names).map do |name|
+          Formulary.factory(name, spec, force_bottle: @force_bottle, flags: @flags)
+        end.uniq(&:name).freeze
+      end
+
+      def to_formulae_and_casks
+        @to_formulae_and_casks ||= begin
+          formulae_and_casks = []
+
+          downcased_unique_named.each do |name|
+            formulae_and_casks << Formulary.factory(name, spec)
+
+            puts "Treating #{name} as a formula. For the cask, use homebrew/cask/#{name}" if cask_exists_with_ref name
+          rescue FormulaUnavailableError
+            begin
+              formulae_and_casks << Cask::CaskLoader.load(name)
+            rescue Cask::CaskUnavailableError
+              raise "No available formula or cask with the name \"#{name}\""
+            end
+          end
+
+          formulae_and_casks.freeze
+        end
+      end
+
+      def to_resolved_formulae
+        @to_resolved_formulae ||= (downcased_unique_named - homebrew_tap_cask_names).map do |name|
+          Formulary.resolve(name, spec: spec(nil), force_bottle: @force_bottle, flags: @flags)
+        end.uniq(&:name).freeze
+      end
+
+      def to_resolved_formulae_to_casks
+        @to_resolved_formulae_to_casks ||= begin
+          resolved_formulae = []
+          casks = []
+
+          downcased_unique_named.each do |name|
+            resolved_formulae << Formulary.resolve(name, spec: spec(nil), force_bottle: @force_bottle, flags: @flags)
+
+            puts "Treating #{name} as a formula. For the cask, use homebrew/cask/#{name}" if cask_exists_with_ref name
+          rescue FormulaUnavailableError
+            begin
+              casks << Cask::CaskLoader.load(name)
+            rescue Cask::CaskUnavailableError
+              raise "No available formula or cask with the name \"#{name}\""
+            end
+          end
+
+          [resolved_formulae.freeze, casks.freeze].freeze
+        end
+      end
+
+      def to_formulae_paths
+        @to_formulae_paths ||= (downcased_unique_named - homebrew_tap_cask_names).map do |name|
+          Formulary.path(name)
+        end.uniq.freeze
+      end
+
+      def to_casks
+        @to_casks ||= downcased_unique_named.map(&Cask::CaskLoader.method(:load)).freeze
+      end
+
+      def to_kegs
+        @to_kegs ||= downcased_unique_named.map do |name|
+          resolve_keg name
+        rescue NoSuchKegError => e
+          if (reason = Homebrew::MissingFormula.suggest_command(name, "uninstall"))
+            $stderr.puts reason
+          end
+          raise e
+        end.freeze
+      end
+
+      def to_kegs_to_casks
+        @to_kegs_to_casks ||= begin
+          kegs = []
+          casks = []
+
+          downcased_unique_named.each do |name|
+            kegs << resolve_keg(name)
+
+            puts "Treating #{name} as a keg. For the cask, use homebrew/cask/#{name}" if cask_exists_with_ref name
+          rescue NoSuchKegError, FormulaUnavailableError
+            begin
+              casks << Cask::CaskLoader.load(name)
+            rescue Cask::CaskUnavailableError
+              raise "No installed keg or cask with the name \"#{name}\""
+            end
+          end
+
+          [kegs.freeze, casks.freeze].freeze
+        end
+      end
+
+      def homebrew_tap_cask_names
+        downcased_unique_named.grep(HOMEBREW_CASK_TAP_CASK_REGEX)
+      end
+
+      private
+
+      def downcased_unique_named
+        # Only lowercase names, not paths, bottle filenames or URLs
+        map do |arg|
+          if arg.include?("/") || arg.end_with?(".tar.gz") || File.exist?(arg)
+            arg
+          else
+            arg.downcase
+          end
+        end.uniq
+      end
+
+      def spec(default = :stable)
+        @override_spec || default
+      end
+
+      def resolve_keg(name)
+        raise UsageError if name.blank?
+
+        rack = Formulary.to_rack(name.downcase)
+
+        dirs = rack.directory? ? rack.subdirs : []
+        raise NoSuchKegError, rack.basename if dirs.empty?
+
+        linked_keg_ref = HOMEBREW_LINKED_KEGS/rack.basename
+        opt_prefix = HOMEBREW_PREFIX/"opt/#{rack.basename}"
+
+        begin
+          if opt_prefix.symlink? && opt_prefix.directory?
+            Keg.new(opt_prefix.resolved_path)
+          elsif linked_keg_ref.symlink? && linked_keg_ref.directory?
+            Keg.new(linked_keg_ref.resolved_path)
+          elsif dirs.length == 1
+            Keg.new(dirs.first)
+          else
+            f = if name.include?("/") || File.exist?(name)
+              Formulary.factory(name)
+            else
+              Formulary.from_rack(rack)
+            end
+
+            unless (prefix = f.installed_prefix).directory?
+              raise MultipleVersionsInstalledError, "#{rack.basename} has multiple installed versions"
+            end
+
+            Keg.new(prefix)
+          end
+        rescue FormulaUnavailableError
+          raise MultipleVersionsInstalledError, <<~EOS
+            Multiple kegs installed to #{rack}
+            However we don't know which one you refer to.
+            Please delete (with rm -rf!) all but one and then try again.
+          EOS
+        end
+      end
+
+      def cask_exists_with_ref(ref)
+        Cask::CaskLoader.load ref
+      rescue Cask::CaskUnavailableError
+        false
+      end
+    end
+  end
+end

Library/Homebrew/cmd/--env.rb

@@ -43,9 +43,9 @@ module Homebrew
       Utils::Shell.from_path(args.shell)
     end
 
-    env_keys = build_env_keys(ENV)
+    env_keys = BuildEnvironment.keys(ENV)
     if shell.nil?
-      dump_build_env ENV
+      BuildEnvironment.dump ENV
     else
       env_keys.each do |key|
         puts Utils::Shell.export_value(key, ENV[key], shell)

Library/Homebrew/cmd/home.rb

@@ -25,10 +25,7 @@ module Homebrew
     end
 
     homepages = args.formulae_and_casks.map do |formula_or_cask|
-      disclaimer = disclaimers(formula_or_cask)
-      disclaimer = " (#{disclaimer})" if disclaimer.present?
-
-      puts "Opening homepage for #{name_of(formula_or_cask)}#{disclaimer}"
+      puts "Opening homepage for #{name_of(formula_or_cask)}"
       formula_or_cask.homepage
     end
 
@@ -42,15 +39,4 @@ module Homebrew
       "Cask #{formula_or_cask.token}"
     end
   end
-
-  def disclaimers(formula_or_cask)
-    return unless formula_or_cask.is_a? Formula
-
-    begin
-      cask = Cask::CaskLoader.load formula_or_cask.name
-      "for the cask, use #{cask.tap.name}/#{cask.token}"
-    rescue Cask::CaskUnavailableError
-      nil
-    end
-  end
 end

Library/Homebrew/cxxstdlib.rb

@@ -2,9 +2,11 @@
 
 require "compilers"
 
+# Combination of C++ standard library and compiler.
 class CxxStdlib
   include CompilerConstants
 
+  # Error for when a formula's dependency was built with a different C++ standard library.
   class CompatibilityError < StandardError
     def initialize(formula, dep, stdlib)
       super <<~EOS
@@ -17,8 +19,8 @@ class CxxStdlib
   def self.create(type, compiler)
     raise ArgumentError, "Invalid C++ stdlib type: #{type}" if type && ![:libstdcxx, :libcxx].include?(type)
 
-    klass = (compiler.to_s =~ GNU_GCC_REGEXP) ? GnuStdlib : AppleStdlib
-    klass.new(type, compiler)
+    apple_compiler = compiler.to_s.match?(GNU_GCC_REGEXP) ? false : true
+    CxxStdlib.new(type, compiler, apple_compiler)
   end
 
   def self.check_compatibility(formula, deps, keg, compiler)
@@ -35,9 +37,10 @@ class CxxStdlib
 
   attr_reader :type, :compiler
 
-  def initialize(type, compiler)
+  def initialize(type, compiler, apple_compiler)
     @type = type
     @compiler = compiler.to_sym
+    @apple_compiler = apple_compiler
   end
 
   # If either package doesn't use C++, all is well.
@@ -72,15 +75,7 @@ class CxxStdlib
     "#<#{self.class.name}: #{compiler} #{type}>"
   end
 
-  class AppleStdlib < CxxStdlib
-    def apple_compiler?
-      true
-    end
-  end
-
-  class GnuStdlib < CxxStdlib
-    def apple_compiler?
-      false
-    end
+  def apple_compiler?
+    @apple_compiler
   end
 end

Library/Homebrew/debrew/irb.rb

@@ -11,7 +11,7 @@ module IRB
 
     def start_within(binding)
       unless @setup_done
-        setup(nil)
+        setup(nil, argv: [])
         @setup_done = true
       end
 

Library/Homebrew/dev-cmd/audit.rb

@@ -350,6 +350,11 @@ module Homebrew
       "LGPL-3.0" => ["LGPL-3.0-only", "LGPL-3.0-or-later"],
     }.freeze
 
+    PERMITTED_FORMULA_LICENSE_MISMATCHES = {
+      "cmockery" => "0.1.2",
+      "scw@1"    => "1.20",
+    }.freeze
+
     def audit_license
       if formula.license.present?
         non_standard_licenses = formula.license.map do |license|
@@ -380,12 +385,13 @@ module Homebrew
 
         return unless @online
 
-        user, repo = get_repo_data(%r{https?://github\.com/([^/]+)/([^/]+)/?.*}) if @new_formula
+        user, repo = get_repo_data(%r{https?://github\.com/([^/]+)/([^/]+)/?.*})
         return if user.blank?
 
         github_license = GitHub.get_repo_license(user, repo)
         return if github_license && (formula.license + ["NOASSERTION"]).include?(github_license)
         return if PERMITTED_LICENSE_MISMATCHES[github_license]&.any? { |license| formula.license.include? license }
+        return if PERMITTED_FORMULA_LICENSE_MISMATCHES[formula.name] == formula.version
 
         problem "Formula license #{formula.license} does not match GitHub license #{Array(github_license)}."
 

Library/Homebrew/dev-cmd/bump-formula-pr.rb

@@ -294,7 +294,10 @@ module Homebrew
         "",
       ]
     end
-    new_contents = inreplace_pairs(formula.path, replacement_pairs.uniq.compact, args: args)
+    new_contents = Utils::Inreplace.inreplace_pairs(formula.path,
+                                                    replacement_pairs.uniq.compact,
+                                                    read_only_run: read_only_run,
+                                                    silent:        args.quiet?)
 
     new_formula_version = formula_version(formula, requested_spec, new_contents)
 
@@ -462,34 +465,6 @@ module Homebrew
     [remote_url, username]
   end
 
-  def inreplace_pairs(path, replacement_pairs, args:)
-    read_only_run = args.dry_run? && !args.write?
-    if read_only_run
-      str = path.open("r") { |f| Formulary.ensure_utf8_encoding(f).read }
-      contents = StringInreplaceExtension.new(str)
-      replacement_pairs.each do |old, new|
-        ohai "replace #{old.inspect} with #{new.inspect}" unless args.quiet?
-        raise "No old value for new value #{new}! Did you pass the wrong arguments?" unless old
-
-        contents.gsub!(old, new)
-      end
-      raise Utils::InreplaceError, path => contents.errors unless contents.errors.empty?
-
-      path.atomic_write(contents.inreplace_string) if args.write?
-      contents.inreplace_string
-    else
-      Utils::Inreplace.inreplace(path) do |s|
-        replacement_pairs.each do |old, new|
-          ohai "replace #{old.inspect} with #{new.inspect}" unless args.quiet?
-          raise "No old value for new value #{new}! Did you pass the wrong arguments?" unless old
-
-          s.gsub!(old, new)
-        end
-      end
-      path.open("r") { |f| Formulary.ensure_utf8_encoding(f).read }
-    end
-  end
-
   def formula_version(formula, spec, contents = nil)
     name = formula.name
     path = formula.path

Library/Homebrew/dev-cmd/pr-automerge.rb

@@ -49,7 +49,7 @@ module Homebrew
       return
     end
 
-    ohai "#{prs.size} matching pull requests:"
+    ohai "#{prs.count} matching pull #{"request".pluralize(prs.count)}:"
     pr_urls = []
     prs.each do |pr|
       puts "#{tap.full_name unless tap.core_tap?}##{pr["number"]}: #{pr["title"]}"

Library/Homebrew/development_tools.rb

@@ -99,6 +99,15 @@ class DevelopmentTools
     def subversion_handles_most_https_certificates?
       true
     end
+
+    def build_system_info
+      {
+        "os"         => ENV["HOMEBREW_SYSTEM"],
+        "os_version" => OS_VERSION,
+        "cpu_family" => Hardware::CPU.family,
+      }
+    end
+    alias generic_build_system_info build_system_info
   end
 end