Merge pull request #9403 from MikeMcQuaid/deprecate-cask-requirements

Deprecate cask requirements.

Library/Homebrew/build.rb

@@ -87,7 +87,6 @@ class Build
       ENV.keg_only_deps = keg_only_deps
       ENV.deps = formula_deps
       ENV.run_time_deps = run_time_deps
-      ENV.x11 = reqs.any? { |rq| rq.is_a?(X11Requirement) }
       ENV.setup_build_environment(
         formula:      formula,
         cc:           args.cc,

Library/Homebrew/cask/dsl/depends_on.rb

@@ -27,8 +27,7 @@ module Cask
         arm64:  { type: :arm, bits: 64 },
       }.freeze
 
-      attr_accessor :java
+      attr_reader :arch, :cask, :formula, :java, :macos, :x11
-      attr_reader :arch, :cask, :formula, :macos, :x11
 
       def initialize
         super({})
@@ -83,9 +82,17 @@ module Cask
         @arch.concat(arches.map { |arch| VALID_ARCHES[arch] })
       end
 
+      def java=(arg)
+        odeprecated "depends_on :java", "depends_on a specific Java formula"
+
+        @java = arg
+      end
+
       def x11=(arg)
         raise "invalid 'depends_on x11' value: #{arg.inspect}" unless [true, false].include?(arg)
 
+        odeprecated "depends_on :x11", "depends_on specific X11 formula(e)"
+
         @x11 = arg
       end
     end

Library/Homebrew/dev-cmd/sh.rb

@@ -36,10 +36,7 @@ module Homebrew
 
     ENV.activate_extensions!(env: args.env)
 
-    if superenv?(args.env)
+    ENV.deps = Formula.installed.select { |f| f.keg_only? && f.opt_prefix.directory? } if superenv?(args.env)
-      ENV.set_x11_env_if_installed
-      ENV.deps = Formula.installed.select { |f| f.keg_only? && f.opt_prefix.directory? }
-    end
     ENV.setup_build_environment
     if superenv?(args.env)
       # superenv stopped adding brew's bin but generally users will want it

Library/Homebrew/extend/ENV/std.rb

@@ -209,7 +209,9 @@ module Stdenv
   end
 
   sig { void }
-  def x11; end
+  def x11
+    odeprecated "ENV.x11", "depends_on specific X11 formula(e)"
+  end
 
   # @private
   sig { params(map: T::Hash[Symbol, String]).void }

Library/Homebrew/extend/ENV/super.rb

@@ -343,7 +343,9 @@ module Superenv
   end
 
   sig { void }
-  def set_x11_env_if_installed; end
+  def set_x11_env_if_installed
+    odeprecated "ENV.set_x11_env_if_installed"
+  end
 end
 
 require "extend/os/extend/ENV/super"

Library/Homebrew/extend/os/linux/requirements/osxfuse_requirement.rb

@@ -6,6 +6,11 @@ require "requirement"
 class OsxfuseRequirement < Requirement
   extend T::Sig
 
+  def initialize(tags = [])
+    odeprecated "depends_on :osxfuse", 'on_linux do; depends_on "libfuse"; end'
+    super(tags)
+  end
+
   download "https://github.com/libfuse/libfuse"
 
   satisfy(build_env: false) do

Library/Homebrew/extend/os/mac/extend/ENV/std.rb

@@ -4,35 +4,12 @@
 module Stdenv
   # @private
 
-  undef homebrew_extra_pkg_config_paths, x11
+  undef homebrew_extra_pkg_config_paths
 
   def homebrew_extra_pkg_config_paths
     ["#{HOMEBREW_LIBRARY}/Homebrew/os/mac/pkgconfig/#{MacOS.sdk_version}"]
   end
 
-  def x11
-    # There are some config scripts here that should go in the PATH
-    append_path "PATH", MacOS::XQuartz.bin.to_s
-
-    # Append these to PKG_CONFIG_LIBDIR so they are searched
-    # *after* our own pkgconfig directories, as we dupe some of the
-    # libs in XQuartz.
-    append_path "PKG_CONFIG_LIBDIR", "#{MacOS::XQuartz.lib}/pkgconfig"
-    append_path "PKG_CONFIG_LIBDIR", "#{MacOS::XQuartz.share}/pkgconfig"
-
-    append "LDFLAGS", "-L#{MacOS::XQuartz.lib}"
-    append_path "CMAKE_PREFIX_PATH", MacOS::XQuartz.prefix.to_s
-    append_path "CMAKE_INCLUDE_PATH", MacOS::XQuartz.include.to_s
-    append_path "CMAKE_INCLUDE_PATH", "#{MacOS::XQuartz.include}/freetype2"
-
-    append "CPPFLAGS", "-I#{MacOS::XQuartz.include}"
-    append "CPPFLAGS", "-I#{MacOS::XQuartz.include}/freetype2"
-
-    append_path "ACLOCAL_PATH", "#{MacOS::XQuartz.share}/aclocal"
-
-    append "CFLAGS", "-I#{MacOS::XQuartz.include}" unless MacOS::CLT.installed?
-  end
-
   def setup_build_environment(**options)
     generic_setup_build_environment(**options)
 

Library/Homebrew/extend/os/mac/extend/ENV/super.rb

@@ -23,7 +23,7 @@ module Superenv
         homebrew_extra_cmake_include_paths,
         homebrew_extra_cmake_library_paths,
         homebrew_extra_cmake_frameworks_paths,
-        determine_cccfg, set_x11_env_if_installed
+        determine_cccfg
 
   def homebrew_extra_paths
     paths = []
@@ -105,10 +105,6 @@ module Superenv
     s.freeze
   end
 
-  def set_x11_env_if_installed
-    ENV.x11 = MacOS::XQuartz.installed?
-  end
-
   # @private
   def setup_build_environment(**options)
     formula = options[:formula]

Library/Homebrew/extend/os/mac/requirements/osxfuse_requirement.rb

@@ -6,6 +6,11 @@ require "requirement"
 class OsxfuseRequirement < Requirement
   extend T::Sig
 
+  def initialize(tags = [])
+    odeprecated "depends_on :osxfuse"
+    super(tags)
+  end
+
   download "https://osxfuse.github.io/"
 
   satisfy(build_env: false) { self.class.binary_osxfuse_installed? }

Library/Homebrew/formula.rb

@@ -2526,9 +2526,6 @@ class Formula
     # depends_on "sqlite" if MacOS.version >= :catalina
     # depends_on xcode: :build # If the formula really needs full Xcode to compile.
     # depends_on macos: :mojave # Needs at least macOS Mojave (10.14) to run.
-    # depends_on x11: :optional # X11/XQuartz components.
-    # depends_on :osxfuse # Permits the use of the upstream signed binary or our cask.
-    # depends_on :tuntap # Does the same thing as above. This is vital for Yosemite and later.</pre>
     # <pre># It is possible to only depend on something if
     # # `build.with?` or `build.without? "another_formula"`:
     # depends_on "postgresql" if build.without? "sqlite"</pre>

Library/Homebrew/requirements/tuntap_requirement.rb

@@ -9,6 +9,11 @@ require "requirement"
 class TuntapRequirement < Requirement
   extend T::Sig
 
+  def initialize(tags = [])
+    odeprecated "depends_on :tuntap"
+    super(tags)
+  end
+
   fatal true
   cask "tuntap"
   satisfy(build_env: false) { self.class.binary_tuntap_installed? }

Library/Homebrew/requirements/x11_requirement.rb

@@ -8,16 +8,18 @@ require "requirement"
 # @api private
 class X11Requirement < Requirement
   extend T::Sig
-
   include Comparable
 
+  def initialize(tags = [])
+    odeprecated "depends_on :x11", "depends_on specific X11 formula(e)"
+    super(tags)
+  end
+
   fatal true
 
   cask "xquartz"
   download "https://xquartz.macosforge.org"
 
-  env { ENV.x11 }
-
   sig { returns(String) }
   def min_version
     "1.12.2"

Library/Homebrew/rubocops/lines.rb

@@ -551,10 +551,6 @@ module RuboCop
             problem "macOS has been 64-bit only since 10.6 so ENV.universal_binary is deprecated."
           end
 
-          find_instance_method_call(body_node, "ENV", :x11) do
-            problem 'Use "depends_on :x11" instead of "ENV.x11"'
-          end
-
           find_every_method_call_by_name(body_node, :depends_on).each do |method|
             next unless method_called?(method, :new)
 

Library/Homebrew/test/cask/depends_on_spec.rb

@@ -74,37 +74,4 @@ describe "Satisfy Dependencies and Requirements", :cask do
       end
     end
   end
-
-  describe "depends_on x11" do
-    before do
-      allow(MacOS::XQuartz).to receive(:installed?).and_return(x11_installed)
-    end
-
-    context "when satisfied" do
-      let(:cask) { Cask::CaskLoader.load(cask_path("with-depends-on-x11")) }
-      let(:x11_installed) { true }
-
-      it "does not raise an error" do
-        expect { install }.not_to raise_error
-      end
-    end
-
-    context "when not satisfied" do
-      let(:cask) { Cask::CaskLoader.load(cask_path("with-depends-on-x11")) }
-      let(:x11_installed) { false }
-
-      it "does not raise an error" do
-        expect { install }.to raise_error Cask::CaskX11DependencyError
-      end
-    end
-
-    context "when depends_on x11: false" do
-      let(:cask) { Cask::CaskLoader.load(cask_path("with-depends-on-x11-false")) }
-      let(:x11_installed) { false }
-
-      it "does not raise an error" do
-        expect { install }.not_to raise_error
-      end
-    end
-  end
 end

Library/Homebrew/test/cask/dsl_spec.rb

@@ -410,14 +410,6 @@ describe Cask::DSL, :cask do
   end
 
   describe "depends_on x11" do
-    context "valid" do
-      let(:token) { "with-depends-on-x11" }
-
-      it "is allowed to be specified" do
-        expect(cask.depends_on.x11).not_to be nil
-      end
-    end
-
     context "invalid depends_on x11 value" do
       let(:token) { "invalid/invalid-depends-on-x11-value" }
 

Library/Homebrew/test/cask_dependent_spec.rb

@@ -13,7 +13,6 @@ describe CaskDependent, :needs_macos do
         depends_on formula: "baz"
         depends_on cask: "foo-cask"
         depends_on macos: ">= :mojave"
-        depends_on x11: true
       end
     RUBY
   end
@@ -28,7 +27,7 @@ describe CaskDependent, :needs_macos do
   describe "#requirements" do
     it "is the requirements of the cask" do
       expect(dependent.requirements.map(&:name))
-        .to eq %w[foo-cask macos x11]
+        .to eq %w[foo-cask macos]
     end
   end
 
@@ -39,7 +38,6 @@ describe CaskDependent, :needs_macos do
       setup_test_formula "baz", <<-RUBY
         url "https://brew.sh/baz-1.0"
         depends_on "bar"
-        depends_on :osxfuse
       RUBY
 
       expect(dependent.recursive_dependencies.map(&:name))
@@ -54,11 +52,10 @@ describe CaskDependent, :needs_macos do
       setup_test_formula "baz", <<-RUBY
         url "https://brew.sh/baz-1.0"
         depends_on "bar"
-        depends_on :osxfuse
       RUBY
 
       expect(dependent.recursive_requirements.map(&:name))
-        .to eq(%w[foo-cask macos x11 osxfuse])
+        .to eq(%w[foo-cask macos])
     end
   end
 end

Library/Homebrew/test/dependency_collector_spec.rb

@@ -27,32 +27,20 @@ describe DependencyCollector do
     end
 
     specify "requirement creation" do
-      subject.add :x11
+      subject.add :xcode
-      expect(find_requirement(X11Requirement)).to be_an_instance_of(X11Requirement)
+      expect(find_requirement(XcodeRequirement)).to be_an_instance_of(XcodeRequirement)
     end
 
     it "deduplicates requirements" do
-      2.times { subject.add :x11 }
+      2.times { subject.add :xcode }
       expect(subject.requirements.count).to eq(1)
     end
 
     specify "requirement tags" do
-      subject.add :x11
       subject.add xcode: :build
-      expect(find_requirement(X11Requirement).tags).to be_empty
       expect(find_requirement(XcodeRequirement)).to be_a_build_requirement
     end
 
-    specify "x11 without tag" do
-      subject.add :x11
-      expect(find_requirement(X11Requirement).tags).to be_empty
-    end
-
-    specify "x11 with tag" do
-      subject.add x11: :optional
-      expect(find_requirement(X11Requirement)).to be_optional
-    end
-
     it "doesn't mutate the dependency spec" do
       spec = { "foo" => :optional }
       copy = spec.dup

Library/Homebrew/test/formula_spec.rb

@@ -794,17 +794,15 @@ describe Formula do
     f1 = formula "f1" do
       url "f1-1"
 
-      depends_on x11: :recommended
       depends_on xcode: ["1.0", :optional]
     end
     stub_formula_loader(f1)
 
-    x11 = X11Requirement.new([:recommended])
     xcode = XcodeRequirement.new(["1.0", :optional])
 
-    expect(Set.new(f1.recursive_requirements)).to eq(Set[x11])
+    expect(Set.new(f1.recursive_requirements)).to eq(Set[])
 
-    f1.build = BuildOptions.new(["--with-xcode", "--without-x11"], f1.options)
+    f1.build = BuildOptions.new(["--with-xcode"], f1.options)
 
     expect(Set.new(f1.recursive_requirements)).to eq(Set[xcode])
 
@@ -815,14 +813,14 @@ describe Formula do
       depends_on "f1"
     end
 
-    expect(Set.new(f2.recursive_requirements)).to eq(Set[x11])
+    expect(Set.new(f2.recursive_requirements)).to eq(Set[])
-    expect(Set.new(f2.recursive_requirements {})).to eq(Set[x11, xcode])
+    expect(Set.new(f2.recursive_requirements {})).to eq(Set[xcode])
 
     requirements = f2.recursive_requirements do |_dependent, requirement|
-      Requirement.prune if requirement.is_a?(X11Requirement)
+      Requirement.prune if requirement.is_a?(XcodeRequirement)
     end
 
-    expect(Set.new(requirements)).to eq(Set[xcode])
+    expect(Set.new(requirements)).to eq(Set[])
   end
 
   specify "#to_hash" do

Library/Homebrew/test/requirements/osxfuse_requirement_spec.rb

@@ -1,53 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-require "requirements/osxfuse_requirement"
-
-describe OsxfuseRequirement do
-  subject(:requirement) { described_class.new([]) }
-
-  describe "::binary_osxfuse_installed?", :needs_macos do
-    alias_matcher :have_binary_osxfuse_installed, :be_binary_osxfuse_installed
-
-    it "returns false if fuse.h does not exist" do
-      allow(File).to receive(:exist?).and_return(false)
-      expect(described_class).not_to have_binary_osxfuse_installed
-    end
-
-    it "returns false if osxfuse include directory is a symlink" do
-      allow(File).to receive(:exist?).and_return(true)
-      allow(File).to receive(:symlink?).and_return(true)
-      expect(described_class).not_to have_binary_osxfuse_installed
-    end
-  end
-
-  describe "#modify_build_environment", :needs_macos do
-    it "adds the fuse directories to PKG_CONFIG_PATH" do
-      allow(ENV).to receive(:append_path)
-      requirement.modify_build_environment
-      expect(ENV).to have_received(:append_path).with("PKG_CONFIG_PATH", any_args)
-    end
-
-    it "adds the fuse directories to HOMEBREW_LIBRARY_PATHS" do
-      allow(ENV).to receive(:append_path)
-      requirement.modify_build_environment
-      expect(ENV).to have_received(:append_path).with("HOMEBREW_LIBRARY_PATHS", any_args)
-    end
-
-    it "adds the fuse directories to HOMEBREW_INCLUDE_PATHS" do
-      allow(ENV).to receive(:append_path)
-      requirement.modify_build_environment
-      expect(ENV).to have_received(:append_path).with("HOMEBREW_INCLUDE_PATHS", any_args)
-    end
-  end
-
-  describe "#message" do
-    it "prompts for installation of 'libfuse' on Linux", :needs_linux do
-      expect(requirement.message).to match("libfuse is required for this software")
-    end
-
-    it "prompts for installation of 'osxFuse' on macOS", :needs_macos do
-      expect(requirement.message).to match("osxfuse.github.io")
-    end
-  end
-end

Library/Homebrew/test/requirements/x11_requirement_spec.rb

@@ -1,44 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-require "requirements/x11_requirement"
-
-describe X11Requirement do
-  subject(:requirement) { described_class.new([]) }
-
-  let(:default_name) { "x11" }
-
-  describe "#name" do
-    it "defaults to x11" do
-      expect(requirement.name).to eq(default_name)
-    end
-  end
-
-  describe "#eql?" do
-    it "returns true if the requirements are equal" do
-      other = described_class.new
-      expect(requirement).to eql(other)
-    end
-  end
-
-  describe "#modify_build_environment" do
-    it "calls ENV#x11" do
-      allow(requirement).to receive(:satisfied?).and_return(true)
-      expect(ENV).to receive(:x11)
-      requirement.modify_build_environment
-    end
-  end
-
-  describe "#satisfied?", :needs_macos do
-    it "returns true if X11 is installed" do
-      expect(MacOS::XQuartz).to receive(:version).and_return("2.7.5")
-      expect(MacOS::XQuartz).to receive(:installed?).and_return(true)
-      expect(requirement).to be_satisfied
-    end
-
-    it "returns false if X11 is not installed" do
-      expect(MacOS::XQuartz).to receive(:installed?).and_return(false)
-      expect(requirement).not_to be_satisfied
-    end
-  end
-end

Library/Homebrew/test/requirements_spec.rb

@@ -10,10 +10,8 @@ describe Requirements do
     end
 
     it "merges duplicate requirements" do
-      subject << X11Requirement.new << X11Requirement.new
+      subject << Requirement.new << Requirement.new
       expect(subject.count).to eq(1)
-      subject << Requirement.new
-      expect(subject.count).to eq(2)
     end
   end
 end

Library/Homebrew/test/rubocops/lines_spec.rb

@@ -1122,19 +1122,6 @@ describe RuboCop::Cop::FormulaAudit::Miscellaneous do
       RUBY
     end
 
-    it "deprecated ENV.x11 usage" do
-      expect_offense(<<~RUBY)
-        class Foo < Formula
-          desc "foo"
-          url 'https://brew.sh/foo-1.0.tgz'
-          if build?
-             ENV.x11
-             ^^^^^^^ Use "depends_on :x11" instead of "ENV.x11"
-          end
-        end
-      RUBY
-    end
-
     it "install_name_tool usage instead of ruby-macho" do
       expect_offense(<<~RUBY)
         class Foo < Formula

Library/Homebrew/test/support/fixtures/cask/Casks/with-depends-on-x11-false.rb

@@ -1,11 +0,0 @@
-cask "with-depends-on-x11-false" do
-  version "1.2.3"
-  sha256 "67cdb8a02803ef37fdbf7e0be205863172e41a561ca446cd84f0d7ab35a99d94"
-
-  url "file://#{TEST_FIXTURE_DIR}/cask/caffeine.zip"
-  homepage "https://brew.sh/with-depends-on-x11-false"
-
-  depends_on x11: false
-
-  app "Caffeine.app"
-end

Library/Homebrew/test/support/fixtures/cask/Casks/with-depends-on-x11.rb

@@ -1,11 +0,0 @@
-cask "with-depends-on-x11" do
-  version "1.2.3"
-  sha256 "67cdb8a02803ef37fdbf7e0be205863172e41a561ca446cd84f0d7ab35a99d94"
-
-  url "file://#{TEST_FIXTURE_DIR}/cask/caffeine.zip"
-  homepage "https://brew.sh/with-depends-on-x11"
-
-  depends_on x11: true
-
-  app "Caffeine.app"
-end