Parse named args from formula stubs

Library/Homebrew/cli/named_args.rb

@@ -80,17 +80,28 @@ module Homebrew
         @to_formulae_and_casks ||= T.let(
           {}, T.nilable(T::Hash[T.nilable(Symbol), T::Array[T.any(Formula, Keg, Cask::Cask)]])
         )
-        @to_formulae_and_casks[only] ||= downcased_unique_named.flat_map do |name|
+        @to_formulae_and_casks[only] ||= begin
-          options = { warn: }.compact
+          download_queue = Homebrew::DownloadQueue.new if Homebrew::EnvConfig.download_concurrency > 1
-          load_formula_or_cask(name, only:, method:, **options)
+
-        rescue FormulaUnreadableError, FormulaClassUnavailableError,
+          formulae_and_casks = downcased_unique_named.flat_map do |name|
-               TapFormulaUnreadableError, TapFormulaClassUnavailableError,
+            load_and_fetch_full_formula_or_cask(name, only:, method:, warn:, download_queue:)
-               Cask::CaskUnreadableError
+          rescue FormulaUnreadableError, FormulaClassUnavailableError,
-          # Need to rescue before `*UnavailableError` (superclass of this)
+                 TapFormulaUnreadableError, TapFormulaClassUnavailableError,
-          # The formula/cask was found, but there's a problem with its implementation
+                 Cask::CaskUnreadableError
-          raise
+            # Need to rescue before `*UnavailableError` (superclass of this)
-        rescue NoSuchKegError, FormulaUnavailableError, Cask::CaskUnavailableError, FormulaOrCaskUnavailableError
+            # The formula/cask was found, but there's a problem with its implementation
-          ignore_unavailable ? [] : raise
+            raise
+          rescue NoSuchKegError, FormulaUnavailableError, Cask::CaskUnavailableError, FormulaOrCaskUnavailableError
+            ignore_unavailable ? [] : raise
+          end
+
+          download_queue&.fetch
+
+          formulae_and_casks.map do |formula_or_cask|
+            next formula_or_cask unless formula_or_cask.is_a?(Formula)
+
+            formula_or_cask.fully_loaded_formula
+          end
         end.freeze
 
         if uniq
@@ -152,11 +163,23 @@ module Homebrew
             T::Array[T.any(Formula, Keg, Cask::Cask, T::Array[Keg], FormulaOrCaskUnavailableError)],
           ]),
         )
-        @to_formulae_casks_unknowns[method] = downcased_unique_named.map do |name|
+        @to_formulae_casks_unknowns[method] = begin
-          load_formula_or_cask(name, only:, method:)
+          download_queue = Homebrew::DownloadQueue.new if Homebrew::EnvConfig.download_concurrency > 1
-        rescue FormulaOrCaskUnavailableError => e
+
-          e
+          formulae_and_casks = downcased_unique_named.map do |name|
-        end.uniq.freeze
+            load_and_fetch_full_formula_or_cask(name, only:, method:, download_queue:)
+          rescue FormulaOrCaskUnavailableError => e
+            e
+          end.uniq
+
+          download_queue&.fetch
+
+          formulae_and_casks.map do |formula_or_cask|
+            next formula_or_cask unless formula_or_cask.is_a?(Formula)
+
+            formula_or_cask.fully_loaded_formula
+          end
+        end.freeze
       end
 
       sig { params(uniq: T::Boolean).returns(T::Array[Formula]) }
@@ -314,6 +337,17 @@ module Homebrew
         end.uniq
       end
 
+      sig {
+        params(name: String, only: T.nilable(Symbol), method: T.nilable(Symbol), warn: T.nilable(T::Boolean),
+               download_queue: T.nilable(Homebrew::DownloadQueue))
+          .returns(T.any(Formula, Keg, Cask::Cask, T::Array[Keg]))
+      }
+      def load_and_fetch_full_formula_or_cask(name, only: nil, method: nil, warn: nil, download_queue: nil)
+        formula_or_cask = load_formula_or_cask(name, only:, method:, warn:)
+        formula_or_cask.fetch_fully_loaded_formula!(download_queue:) if formula_or_cask.is_a?(Formula)
+        formula_or_cask
+      end
+
       sig {
         params(name: String, only: T.nilable(Symbol), method: T.nilable(Symbol), warn: T.nilable(T::Boolean))
           .returns(T.any(Formula, Keg, Cask::Cask, T::Array[Keg]))
@@ -326,8 +360,8 @@ module Homebrew
             begin
               case method
               when nil, :factory
-                options = { warn:, force_bottle: @force_bottle, flags: @flags }.compact
+                Formulary.factory(name, *@override_spec,
-                Formulary.factory(name, *@override_spec, **options)
+                                  warn:, force_bottle: @force_bottle, flags: @flags, prefer_stub: true)
               when :resolve
                 resolve_formula(name)
               when :latest_kegs
@@ -447,7 +481,7 @@ module Homebrew
 
       sig { params(name: String).returns(Formula) }
       def resolve_formula(name)
-        Formulary.resolve(name, **{ spec: @override_spec, force_bottle: @force_bottle, flags: @flags }.compact)
+        Formulary.resolve(name, spec: @override_spec, force_bottle: @force_bottle, flags: @flags, prefer_stub: true)
       end
 
       sig { params(name: String).returns([Pathname, T::Array[Keg]]) }

Library/Homebrew/cli/parser.rb

@@ -733,7 +733,7 @@ module Homebrew
           next if arg.match?(HOMEBREW_CASK_TAP_CASK_REGEX)
 
           begin
-            Formulary.factory(arg, spec, flags: argv.select { |a| a.start_with?("--") })
+            Formulary.factory(arg, spec, flags: argv.select { |a| a.start_with?("--") }, prefer_stub: true)
           rescue FormulaUnavailableError, FormulaSpecificationError
             nil
           end