Merge pull request #6366 from reitermarkus/depends_on-macos

Use `MacOSRequirement` for casks.

Library/Homebrew/cask/dsl/depends_on.rb

@@ -37,25 +37,6 @@ module Cask
         end
       end
 
-      def self.coerce_os_release(arg)
-        @macos_symbols ||= MacOS::Version::SYMBOLS
-        @inverted_macos_symbols ||= @macos_symbols.invert
-
-        begin
-          if arg.is_a?(Symbol)
-            Gem::Version.new(@macos_symbols.fetch(arg))
-          elsif arg =~ /^\s*:?([a-z]\S+)\s*$/i
-            Gem::Version.new(@macos_symbols.fetch(Regexp.last_match[1].downcase.to_sym))
-          elsif @inverted_macos_symbols.key?(arg)
-            Gem::Version.new(arg)
-          else
-            raise
-          end
-        rescue
-          raise "invalid 'depends_on macos' value: #{arg.inspect}"
-        end
-      end
-
       def formula=(*args)
         @formula.concat(args)
       end
@@ -65,19 +46,23 @@ module Cask
       end
 
       def macos=(*args)
-        @macos ||= []
-        macos = if args.count == 1 && args.first =~ /^\s*(<|>|[=<>]=)\s*(\S+)\s*$/
-          raise "'depends_on macos' comparison expressions cannot be combined" unless @macos.empty?
+        raise "Only a single 'depends_on macos:' is allowed." if defined?(@macos)
 
-          operator = Regexp.last_match[1].to_sym
-          release = self.class.coerce_os_release(Regexp.last_match[2])
-          [[operator, release]]
-        else
-          raise "'depends_on macos' comparison expressions cannot be combined" if @macos.first.is_a?(Symbol)
-
-          args.map(&self.class.method(:coerce_os_release)).sort
+        begin
+          @macos = if args.count > 1
+            MacOSRequirement.new([args], comparator: "==")
+          elsif MacOS::Version::SYMBOLS.key?(args.first)
+            MacOSRequirement.new([args.first], comparator: "==")
+          elsif /^\s*(?<comparator><|>|[=<>]=)\s*:(?<version>\S+)\s*$/ =~ args.first
+            MacOSRequirement.new([version.to_sym], comparator: comparator)
+          elsif /^\s*(?<comparator><|>|[=<>]=)\s*(?<version>\S+)\s*$/ =~ args.first
+            MacOSRequirement.new([version], comparator: comparator)
+          else
+            MacOSRequirement.new([args.first], comparator: "==")
+          end
+        rescue
+          raise "invalid 'depends_on macos' value: #{args.first.inspect}"
         end
-        @macos.concat(macos)
       end
 
       def arch=(*args)

Library/Homebrew/cask/installer.rb

@@ -253,29 +253,9 @@ module Cask
 
     def macos_dependencies
       return unless @cask.depends_on.macos
+      return if @cask.depends_on.macos.satisfied?
 
-      if @cask.depends_on.macos.first.is_a?(Array)
-        operator, release = @cask.depends_on.macos.first
-        unless MacOS.version.send(operator, release)
-          raise CaskError,
-                "Cask #{@cask} depends on macOS release #{operator} #{release}, " \
-                "but you are running release #{MacOS.version}."
-        end
-      elsif @cask.depends_on.macos.length > 1
-        unless @cask.depends_on.macos.include?(Gem::Version.new(MacOS.version.to_s))
-          raise CaskError,
-                "Cask #{@cask} depends on macOS release being one of " \
-                "[#{@cask.depends_on.macos.map(&:to_s).join(", ")}], " \
-                "but you are running release #{MacOS.version}."
-        end
-      else
-        unless MacOS.version == @cask.depends_on.macos.first
-          raise CaskError,
-                "Cask #{@cask} depends on macOS release " \
-                "#{@cask.depends_on.macos.first}, " \
-                "but you are running release #{MacOS.version}."
-        end
-      end
+      raise CaskError, @cask.depends_on.macos.message(type: :cask)
     end
 
     def arch_dependencies

Library/Homebrew/compat.rb

@@ -1,3 +1,4 @@
 # frozen_string_literal: true
 
 require "compat/cask/dsl/version"
+require "compat/requirements/macos_requirement"

Library/Homebrew/compat/requirements/macos_requirement.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+class MacOSRequirement < Requirement
+  module Compat
+    def initialize(tags = [], comparator: ">=")
+      if tags.first.respond_to?(:map)
+        versions, *rest = tags
+
+        versions = versions.map do |v|
+          next v if v.is_a?(Symbol)
+
+          sym = MacOS::Version.new(v).to_sym
+
+          odeprecated "depends_on macos: #{v.inspect}", "depends_on macos: #{sym.inspect}",
+                      disable_on: Time.parse("2019-10-15")
+
+          sym
+        end
+
+        tags = [versions, *rest]
+      elsif !tags.empty? && !tags.first.is_a?(Symbol)
+        v, *rest = tags
+        sym = MacOS::Version.new(v).to_sym
+
+        odeprecated "depends_on macos: #{v.inspect}", "depends_on macos: #{sym.inspect}",
+                    disable_on: Time.parse("2019-10-15")
+
+        tags = [sym, *rest]
+      end
+
+      super(tags, comparator: comparator)
+    end
+  end
+
+  prepend Compat
+end

Library/Homebrew/dependency_collector.rb

@@ -125,7 +125,7 @@ class DependencyCollector
     when :java          then java_dep_if_needed(tags)
     when :linux         then LinuxRequirement.new(tags)
     when :macos         then MacOSRequirement.new(tags)
-    when :maximum_macos then MaximumMacOSRequirement.new(tags)
+    when :maximum_macos then MacOSRequirement.new(tags, comparator: "<=")
     when :osxfuse       then OsxfuseRequirement.new(tags)
     when :tuntap        then TuntapRequirement.new(tags)
     when :x11           then X11Requirement.new(tags)

Library/Homebrew/requirements.rb

@@ -6,7 +6,6 @@ require "requirements/codesign_requirement"
 require "requirements/java_requirement"
 require "requirements/linux_requirement"
 require "requirements/macos_requirement"
-require "requirements/maximum_macos_requirement"
 require "requirements/osxfuse_requirement"
 require "requirements/tuntap_requirement"
 require "requirements/x11_requirement"

Library/Homebrew/requirements/macos_requirement.rb

@@ -5,32 +5,58 @@ require "requirement"
 class MacOSRequirement < Requirement
   fatal true
 
-  def initialize(tags = [])
-    @version = MacOS::Version.from_symbol(tags.shift) unless tags.empty?
+  def initialize(tags = [], comparator: ">=")
+    if comparator == "==" && tags.first.respond_to?(:map)
+      @version = tags.shift.map { |s| MacOS::Version.from_symbol(s) }
+    else
+      @version = MacOS::Version.from_symbol(tags.shift) unless tags.empty?
+    end
+
+    @comparator = comparator
     super(tags)
   end
 
-  def minimum_version_specified?
+  def version_specified?
     OS.mac? && @version
   end
 
   satisfy(build_env: false) do
-    next MacOS.version >= @version if minimum_version_specified?
+    next [*@version].any? { |v| MacOS.version.public_send(@comparator, v) } if version_specified?
     next true if OS.mac?
     next true if @version
 
     false
   end
 
-  def message
-    return "macOS is required." unless minimum_version_specified?
+  def message(type: :formula)
+    return "macOS is required." unless version_specified?
 
-    "macOS #{@version.pretty_name} or newer is required."
+    case @comparator
+    when ">="
+      "macOS #{@version.pretty_name} or newer is required."
+    when "<="
+      case type
+      when :formula
+        <<~EOS
+          This formula either does not compile or function as expected on macOS
+          versions newer than #{@version.pretty_name} due to an upstream incompatibility.
+        EOS
+      when :cask
+        "This cask does not on macOS versions newer than #{@version.pretty_name}."
+      end
+    else
+      if @version.respond_to?(:to_ary)
+        *versions, last = @version.map(:pretty_name)
+        return "macOS #{versions.join(", ")} or #{last} is required."
+      end
+
+      "macOS #{@version.pretty_name} is required."
+    end
   end
 
   def display_s
-    return "macOS is required" unless minimum_version_specified?
+    return "macOS is required" unless version_specified?
 
-    "macOS >= #{@version}"
+    "macOS #{@comparator} #{@version}"
   end
 end

Library/Homebrew/requirements/maximum_macos_requirement.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require "requirement"
-
-class MaximumMacOSRequirement < Requirement
-  fatal true
-
-  def initialize(tags)
-    @version = MacOS::Version.from_symbol(tags.shift)
-    super(tags)
-  end
-
-  satisfy(build_env: false) { MacOS.version <= @version }
-
-  def message
-    <<~EOS
-      This formula either does not compile or function as expected on macOS
-      versions newer than #{@version.pretty_name} due to an upstream incompatibility.
-    EOS
-  end
-
-  def display_s
-    "macOS <= #{@version}"
-  end
-end

Library/Homebrew/test/cask/depends_on_spec.rb

@@ -45,8 +45,8 @@ describe "Satisfy Dependencies and Requirements", :cask do
       it { is_expected.not_to raise_error }
     end
 
-    context "given a string" do
-      let(:cask) { Cask::CaskLoader.load(cask_path("with-depends-on-macos-string")) }
+    context "given a string", :needs_compat do
+      let(:cask) { Cask::CaskLoader.load(cask_path("compat/with-depends-on-macos-string")) }
 
       it { is_expected.not_to raise_error }
     end

Library/Homebrew/test/cask/dsl_spec.rb

@@ -337,8 +337,8 @@ describe Cask::DSL, :cask do
   end
 
   describe "depends_on macos" do
-    context "valid" do
-      let(:token) { "with-depends-on-macos-string" }
+    context "valid", :needs_compat do
+      let(:token) { "compat/with-depends-on-macos-string" }
 
       it "allows depends_on macos to be specified" do
         expect(cask.depends_on.macos).not_to be nil

Library/Homebrew/test/requirements/macos_requirement_spec.rb

@@ -7,7 +7,17 @@ describe MacOSRequirement do
 
   describe "#satisfied?" do
     it "returns true on macOS" do
-      expect(requirement.satisfied?).to eq(OS.mac?)
+      expect(requirement.satisfied?).to eq OS.mac?
+    end
+
+    it "supports version symbols", :needs_macos do
+      requirement = described_class.new([MacOS.version.to_sym])
+      expect(requirement).to be_satisfied
+    end
+
+    it "supports maximum versions", :needs_macos do
+      requirement = described_class.new([:mavericks], comparator: "<=")
+      expect(requirement.satisfied?).to eq MacOS.version <= :mavericks
     end
   end
 end

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

@@ -6,7 +6,7 @@ cask 'with-depends-on-macos-array' do
   homepage 'https://brew.sh/with-depends-on-macos-array'
 
   # since all OS releases are included, this should always pass
-  depends_on macos: ['10.9', '10.10', MacOS.version.to_s]
+  depends_on macos: [:mavericks, :sierra, MacOS.version.to_sym]
 
   app 'Caffeine.app'
 end

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

@@ -5,7 +5,7 @@ cask 'with-depends-on-macos-comparison' do
   url "file://#{TEST_FIXTURE_DIR}/cask/caffeine.zip"
   homepage 'https://brew.sh/with-depends-on-macos-comparison'
 
-  depends_on macos: '>= 10.9'
+  depends_on macos: '>= :mavericks'
 
   app 'Caffeine.app'
 end

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

@@ -6,7 +6,7 @@ cask 'with-depends-on-macos-failure' do
   homepage 'https://brew.sh/with-depends-on-macos-failure'
 
   # guarantee a mismatched release
-  depends_on macos: MacOS.version.to_s == '10.9' ? '10.10' : '10.9'
+  depends_on macos: MacOS.version == :mavericks ? :sierra : :mavericks
 
   app 'Caffeine.app'
 end