Streamline loading casks from API
This commit is contained in:
		
							parent
							
								
									ccd46af7c6
								
							
						
					
					
						commit
						1e536217b2
					
				@ -6,7 +6,6 @@ require "cask/config"
 | 
			
		||||
require "cask/dsl"
 | 
			
		||||
require "cask/metadata"
 | 
			
		||||
require "searchable"
 | 
			
		||||
require "api"
 | 
			
		||||
 | 
			
		||||
module Cask
 | 
			
		||||
  # An instance of a cask.
 | 
			
		||||
@ -166,14 +165,7 @@ module Cask
 | 
			
		||||
      # 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 @@ module Cask
 | 
			
		||||
      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)
 | 
			
		||||
 | 
			
		||||
@ -214,7 +214,15 @@ module Cask
 | 
			
		||||
        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 @@ module Cask
 | 
			
		||||
        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?
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
@ -49,7 +49,8 @@ module Cask
 | 
			
		||||
        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)
 | 
			
		||||
 | 
			
		||||
@ -45,18 +45,16 @@ module Homebrew
 | 
			
		||||
      # 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 @@ module Homebrew
 | 
			
		||||
        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 @@ module Homebrew
 | 
			
		||||
        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
 | 
			
		||||
 | 
			
		||||
@ -167,7 +167,7 @@ module Homebrew
 | 
			
		||||
    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?)
 | 
			
		||||
 | 
			
		||||
@ -213,15 +213,6 @@ module Homebrew
 | 
			
		||||
  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?,
 | 
			
		||||
 | 
			
		||||
		Loading…
	
	
			
			x
			
			
		
	
		Reference in New Issue
	
	Block a user