Streamline loading casks from API

Library/Homebrew/cask/cask.rb

@@ -6,7 +6,6 @@
 require "cask/dsl"
 require "cask/metadata"
 require "searchable"
-require "api"
 
 module Cask
   # An instance of a cask.
@@ -166,14 +165,7 @@ def outdated_versions(greedy: false, greedy_latest: false, greedy_auto_updates:
       # special case: tap version is not available
       return [] if version.nil?
 
-      latest_version = if Homebrew::EnvConfig.install_from_api? &&
-                          (latest_cask_version = Homebrew::API::Versions.latest_cask_version(token))
-        DSL::Version.new latest_cask_version.to_s
-      else
-        version
-      end
-
-      if latest_version.latest?
+      if version.latest?
         return versions if (greedy || greedy_latest) && outdated_download_sha?
 
         return []
@@ -185,10 +177,10 @@ def outdated_versions(greedy: false, greedy_latest: false, greedy_auto_updates:
       current   = installed.last
 
       # not outdated unless there is a different version on tap
-      return [] if current == latest_version
+      return [] if current == version
 
       # collect all installed versions that are different than tap version and return them
-      installed.reject { |v| v == latest_version }
+      installed.reject { |v| v == version }
     end
 
     def outdated_info(greedy, verbose, json, greedy_latest, greedy_auto_updates)

Library/Homebrew/cask/cask_loader.rb

@@ -214,7 +214,15 @@ def self.for(ref)
         FromTapPathLoader,
         FromPathLoader,
       ].each do |loader_class|
-        return loader_class.new(ref) if loader_class.can_load?(ref)
+        next unless loader_class.can_load?(ref)
+
+        if loader_class == FromTapLoader && Homebrew::EnvConfig.install_from_api? &&
+           ref.start_with?("homebrew/cask/") && !Tap.fetch("homebrew/cask").installed? &&
+           Homebrew::API::CaskSource.available?(ref)
+          return FromContentLoader.new(Homebrew::API::CaskSource.fetch(ref))
+        end
+
+        return loader_class.new(ref)
       end
 
       return FromTapPathLoader.new(default_path(ref)) if FromTapPathLoader.can_load?(default_path(ref))
@@ -231,6 +239,10 @@ def self.for(ref)
         EOS
       end
 
+      if Homebrew::EnvConfig.install_from_api? && Homebrew::API::CaskSource.available?(ref)
+        return FromContentLoader.new(Homebrew::API::CaskSource.fetch(ref))
+      end
+
       possible_installed_cask = Cask.new(ref)
       return FromPathLoader.new(possible_installed_cask.installed_caskfile) if possible_installed_cask.installed?
 

Library/Homebrew/cask/caskroom.rb

@@ -49,7 +49,8 @@ def self.casks(config: nil)
         begin
           if (tap_path = CaskLoader.tap_paths(token).first)
             CaskLoader::FromTapPathLoader.new(tap_path).load(config: config)
-          elsif (caskroom_path = Pathname.glob(path.join(".metadata/*/*/*/*.rb")).first)
+          elsif (caskroom_path = Pathname.glob(path.join(".metadata/*/*/*/*.rb")).first) &&
+                (!Homebrew::EnvConfig.install_from_api? || !Homebrew::API::CaskSource.available?(token))
             CaskLoader::FromPathLoader.new(caskroom_path).load(config: config)
           else
             CaskLoader.load(token, config: config)

Library/Homebrew/cli/named_args.rb

@@ -45,18 +45,16 @@ def to_formulae
       # the formula and prints a warning unless `only` is specified.
       sig {
         params(
-          only:                    T.nilable(Symbol),
-          ignore_unavailable:      T.nilable(T::Boolean),
-          method:                  T.nilable(Symbol),
-          uniq:                    T::Boolean,
-          prefer_loading_from_api: T::Boolean,
+          only:               T.nilable(Symbol),
+          ignore_unavailable: T.nilable(T::Boolean),
+          method:             T.nilable(Symbol),
+          uniq:               T::Boolean,
         ).returns(T::Array[T.any(Formula, Keg, Cask::Cask)])
       }
-      def to_formulae_and_casks(only: parent&.only_formula_or_cask, ignore_unavailable: nil, method: nil, uniq: true,
-                                prefer_loading_from_api: false)
+      def to_formulae_and_casks(only: parent&.only_formula_or_cask, ignore_unavailable: nil, method: nil, uniq: true)
         @to_formulae_and_casks ||= {}
         @to_formulae_and_casks[only] ||= downcased_unique_named.flat_map do |name|
-          load_formula_or_cask(name, only: only, method: method, prefer_loading_from_api: prefer_loading_from_api)
+          load_formula_or_cask(name, only: only, method: method)
         rescue FormulaUnreadableError, FormulaClassUnavailableError,
                TapFormulaUnreadableError, TapFormulaClassUnavailableError,
                Cask::CaskUnreadableError
@@ -90,7 +88,7 @@ def to_formulae_and_casks_and_unavailable(only: parent&.only_formula_or_cask, me
         end.uniq.freeze
       end
 
-      def load_formula_or_cask(name, only: nil, method: nil, prefer_loading_from_api: false)
+      def load_formula_or_cask(name, only: nil, method: nil)
         unreadable_error = nil
 
         if only != :cask
@@ -124,16 +122,11 @@ def load_formula_or_cask(name, only: nil, method: nil, prefer_loading_from_api:
         end
 
         if only != :formula
-          if prefer_loading_from_api && Homebrew::EnvConfig.install_from_api? &&
-             Homebrew::API::CaskSource.available?(name)
-            contents = Homebrew::API::CaskSource.fetch(name)
-          end
-
           want_keg_like_cask = [:latest_kegs, :default_kegs, :kegs].include?(method)
 
           begin
             config = Cask::Config.from_args(@parent) if @cask_options
-            cask = Cask::CaskLoader.load(contents || name, config: config)
+            cask = Cask::CaskLoader.load(name, config: config)
 
             if unreadable_error.present?
               onoe <<~EOS

Library/Homebrew/cmd/install.rb

@@ -167,7 +167,7 @@ def install
     end
 
     begin
-      formulae, casks = args.named.to_formulae_and_casks(prefer_loading_from_api: true)
+      formulae, casks = args.named.to_formulae_and_casks
                             .partition { |formula_or_cask| formula_or_cask.is_a?(Formula) }
     rescue FormulaOrCaskUnavailableError, Cask::CaskUnavailableError => e
       retry if Tap.install_default_cask_tap_if_necessary(force: args.cask?)

Library/Homebrew/cmd/upgrade.rb

@@ -213,15 +213,6 @@ def upgrade_outdated_formulae(formulae, args:)
   def upgrade_outdated_casks(casks, args:)
     return false if args.formula?
 
-    if Homebrew::EnvConfig.install_from_api?
-      casks = casks.map do |cask|
-        next cask if cask.tap.present? && cask.tap != "homebrew/cask"
-        next cask unless Homebrew::API::CaskSource.available?(cask.token)
-
-        Cask::CaskLoader.load Homebrew::API::CaskSource.fetch(cask.token)
-      end
-    end
-
     Cask::Cmd::Upgrade.upgrade_casks(
       *casks,
       force:               args.force?,