Merge pull request #19578 from botantony/replacement-type

deprecate!/disable!: allow to specify replacement type

Library/Homebrew/cask/cask.rb

@@ -386,11 +386,13 @@ module Cask
         "deprecated"                      => deprecated?,
         "deprecation_date"                => deprecation_date,
         "deprecation_reason"              => deprecation_reason,
-        "deprecation_replacement" => deprecation_replacement,
+        "deprecation_replacement_formula" => deprecation_replacement_formula,
+        "deprecation_replacement_cask"    => deprecation_replacement_cask,
         "disabled"                        => disabled?,
         "disable_date"                    => disable_date,
         "disable_reason"                  => disable_reason,
-        "disable_replacement"     => disable_replacement,
+        "disable_replacement_formula"     => disable_replacement_formula,
+        "disable_replacement_cask"        => disable_replacement_cask,
         "tap_git_head"                    => tap_git_head,
         "languages"                       => languages,
         "ruby_source_path"                => ruby_source_path,

Library/Homebrew/cask/dsl.rb

@@ -90,12 +90,14 @@ module Cask
       :deprecated?,
       :deprecation_date,
       :deprecation_reason,
-      :deprecation_replacement,
+      :deprecation_replacement_formula,
+      :deprecation_replacement_cask,
       :disable!,
       :disabled?,
       :disable_date,
       :disable_reason,
-      :disable_replacement,
+      :disable_replacement_formula,
+      :disable_replacement_cask,
       :discontinued?, # TODO: remove once discontinued? is removed (4.5.0)
       :livecheck,
       :livecheck_defined?,
@@ -110,8 +112,9 @@ module Cask
 
     include OnSystem::MacOSAndLinux
 
-    attr_reader :cask, :token, :deprecation_date, :deprecation_reason, :deprecation_replacement, :disable_date,
+    attr_reader :cask, :token, :deprecation_date, :deprecation_reason, :deprecation_replacement_formula,
-                :disable_reason, :disable_replacement, :on_system_block_min_os
+                :deprecation_replacement_cask, :disable_date, :disable_reason, :disable_replacement_formula,
+                :disable_replacement_cask, :on_system_block_min_os
 
     def initialize(cask)
       @cask = cask
@@ -526,12 +529,26 @@ module Cask
     # NOTE: A warning will be shown when trying to install this cask.
     #
     # @api public
-    def deprecate!(date:, because:, replacement: nil)
+    def deprecate!(date:, because:, replacement: nil, replacement_formula: nil, replacement_cask: nil)
+      if [replacement, replacement_formula, replacement_cask].filter_map(&:presence).length > 1
+        raise ArgumentError, "more than one of replacement, replacement_formula and/or replacement_cask specified!"
+      end
+
+      # TODO: deprecate in >= 4.5.0
+      # if replacement
+      #   odeprecated(
+      #     "deprecate!(:replacement)",
+      #     "deprecate!(:replacement_formula) or deprecate!(:replacement_cask)",
+      #     disable_on: Time.new(2025, 10, 15),
+      #   )
+      # end
+
       @deprecation_date = Date.parse(date)
       return if @deprecation_date > Date.today
 
       @deprecation_reason = because
-      @deprecation_replacement = replacement
+      @deprecation_replacement_formula = replacement_formula.presence || replacement
+      @deprecation_replacement_cask = replacement_cask.presence || replacement
       @deprecated = true
     end
 
@@ -540,18 +557,33 @@ module Cask
     # NOTE: An error will be thrown when trying to install this cask.
     #
     # @api public
-    def disable!(date:, because:, replacement: nil)
+    def disable!(date:, because:, replacement: nil, replacement_formula: nil, replacement_cask: nil)
+      if [replacement, replacement_formula, replacement_cask].filter_map(&:presence).length > 1
+        raise ArgumentError, "more than one of replacement, replacement_formula and/or replacement_cask specified!"
+      end
+
+      # TODO: deprecate in >= 4.5.0
+      # if replacement
+      #   odeprecated(
+      #     "disable!(:replacement)",
+      #     "disable!(:replacement_formula) or disable!(:replacement_cask)",
+      #     disable_on: Time.new(2025, 10, 15),
+      #   )
+      # end
+
       @disable_date = Date.parse(date)
 
       if @disable_date > Date.today
         @deprecation_reason = because
-        @deprecation_replacement = replacement
+        @deprecation_replacement_formula = replacement_formula.presence || replacement
+        @deprecation_replacement_cask = replacement_cask.presence || replacement
         @deprecated = true
         return
       end
 
       @disable_reason = because
-      @disable_replacement = replacement
+      @disable_replacement_formula = replacement_formula.presence || replacement
+      @disable_replacement_cask = replacement_cask.presence || replacement
       @disabled = true
     end
 

Library/Homebrew/deprecate_disable.rb

@@ -41,6 +41,22 @@ module DeprecateDisable
     :disabled if formula_or_cask.disabled?
   end
 
+  sig {
+    params(
+      formula: T.nilable(String),
+      cask:    T.nilable(String),
+    ).returns(T.nilable(String))
+  }
+  def replacement_with_type(formula, cask)
+    if formula && formula == cask
+      formula
+    elsif formula
+      "--formula #{formula}"
+    elsif cask
+      "--cask #{cask}"
+    end
+  end
+
   sig { params(formula_or_cask: T.any(Formula, Cask::Cask)).returns(T.nilable(String)) }
   def message(formula_or_cask)
     return if type(formula_or_cask).blank?
@@ -77,10 +93,16 @@ module DeprecateDisable
       end
     end
 
-    replacement = if formula_or_cask.deprecated?
+    replacement = if formula_or_cask.disabled?
-      formula_or_cask.deprecation_replacement
+      replacement_with_type(
-    elsif formula_or_cask.disabled?
+        formula_or_cask.disable_replacement_formula,
-      formula_or_cask.disable_replacement
+        formula_or_cask.disable_replacement_cask,
+      )
+    elsif formula_or_cask.deprecated?
+      replacement_with_type(
+        formula_or_cask.deprecation_replacement_formula,
+        formula_or_cask.deprecation_replacement_cask,
+      )
     end
 
     if replacement.present?

Library/Homebrew/formula.rb

@@ -1477,12 +1477,19 @@ class Formula
   # @see .deprecate!
   delegate deprecation_reason: :"self.class"
 
-  # The replacement for this deprecated {Formula}.
+  # The replacement formula for this deprecated {Formula}.
   # Returns `nil` if no replacement is specified or the formula is not deprecated.
-  # @!method deprecation_replacement
+  # @!method deprecation_replacement_formula
   # @return [String]
   # @see .deprecate!
-  delegate deprecation_replacement: :"self.class"
+  delegate deprecation_replacement_formula: :"self.class"
+
+  # The replacement cask for this deprecated {Formula}.
+  # Returns `nil` if no replacement is specified or the formula is not deprecated.
+  # @!method deprecation_replacement_cask
+  # @return [String]
+  # @see .deprecate!
+  delegate deprecation_replacement_cask: :"self.class"
 
   # Whether this {Formula} is disabled (i.e. cannot be installed).
   # Defaults to false.
@@ -1505,12 +1512,19 @@ class Formula
   # @see .disable!
   delegate disable_reason: :"self.class"
 
-  # The replacement for this disabled {Formula}.
+  # The replacement formula for this disabled {Formula}.
   # Returns `nil` if no replacement is specified or the formula is not disabled.
-  # @!method disable_replacement
+  # @!method disable_replacement_formula
   # @return [String]
   # @see .disable!
-  delegate disable_replacement: :"self.class"
+  delegate disable_replacement_formula: :"self.class"
+
+  # The replacement cask for this disabled {Formula}.
+  # Returns `nil` if no replacement is specified or the formula is not disabled.
+  # @!method disable_replacement_cask
+  # @return [String]
+  # @see .disable!
+  delegate disable_replacement_cask: :"self.class"
 
   sig { returns(T::Boolean) }
   def skip_cxxstdlib_check? = false
@@ -2532,11 +2546,13 @@ class Formula
       "deprecated"                      => deprecated?,
       "deprecation_date"                => deprecation_date,
       "deprecation_reason"              => deprecation_reason,
-      "deprecation_replacement"  => deprecation_replacement,
+      "deprecation_replacement_formula" => deprecation_replacement_formula,
+      "deprecation_replacement_cask"    => deprecation_replacement_cask,
       "disabled"                        => disabled?,
       "disable_date"                    => disable_date,
       "disable_reason"                  => disable_reason,
-      "disable_replacement"      => disable_replacement,
+      "disable_replacement_formula"     => disable_replacement_formula,
+      "disable_replacement_cask"        => disable_replacement_cask,
       "post_install_defined"            => post_install_defined?,
       "service"                         => (service.to_hash if service?),
       "tap_git_head"                    => tap_git_head,
@@ -4318,19 +4334,45 @@ class Formula
     # ```
     #
     # ```ruby
-    # deprecate! date: "2020-08-27", because: "has been replaced by foo", replacement: "foo"
+    # deprecate! date: "2020-08-27", because: "has been replaced by foo", replacement_formula: "foo"
     # ```
+    # ```ruby
+    # deprecate! date: "2020-08-27", because: "has been replaced by foo", replacement_cask: "foo"
+    # ```
+    # TODO: replace legacy `replacement` with `replacement_formula` or `replacement_cask`
     #
     # @see https://docs.brew.sh/Deprecating-Disabling-and-Removing-Formulae
     # @see DeprecateDisable::FORMULA_DEPRECATE_DISABLE_REASONS
     # @api public
-    sig { params(date: String, because: T.any(NilClass, String, Symbol), replacement: T.nilable(String)).void }
+    sig {
-    def deprecate!(date:, because:, replacement: nil)
+      params(
+        date:                String,
+        because:             T.any(NilClass, String, Symbol),
+        replacement:         T.nilable(String),
+        replacement_formula: T.nilable(String),
+        replacement_cask:    T.nilable(String),
+      ).void
+    }
+    def deprecate!(date:, because:, replacement: nil, replacement_formula: nil, replacement_cask: nil)
+      if [replacement, replacement_formula, replacement_cask].filter_map(&:presence).length > 1
+        raise ArgumentError, "more than one of replacement, replacement_formula and/or replacement_cask specified!"
+      end
+
+      # TODO: deprecate in >= 4.5.0
+      # if replacement
+      #   odeprecated(
+      #     "deprecate!(:replacement)",
+      #     "deprecate!(:replacement_formula) or deprecate!(:replacement_cask)",
+      #     disable_on: Time.new(2025, 10, 15),
+      #   )
+      # end
+
       @deprecation_date = T.let(Date.parse(date), T.nilable(Date))
       return if T.must(@deprecation_date) > Date.today
 
       @deprecation_reason = T.let(because, T.any(NilClass, String, Symbol))
-      @deprecation_replacement = T.let(replacement, T.nilable(String))
+      @deprecation_replacement_formula = T.let(replacement_formula.presence || replacement, T.nilable(String))
+      @deprecation_replacement_cask = T.let(replacement_cask.presence || replacement, T.nilable(String))
       T.must(@deprecated = T.let(true, T.nilable(T::Boolean)))
     end
 
@@ -4356,12 +4398,19 @@ class Formula
     sig { returns(T.any(NilClass, String, Symbol)) }
     attr_reader :deprecation_reason
 
-    # The replacement for a deprecated {Formula}.
+    # The replacement formula for a deprecated {Formula}.
     #
     # @return [nil] if no replacement was provided or the formula is not deprecated.
     # @see .deprecate!
     sig { returns(T.nilable(String)) }
-    attr_reader :deprecation_replacement
+    attr_reader :deprecation_replacement_formula
+
+    # The replacement cask for a deprecated {Formula}.
+    #
+    # @return [nil] if no replacement was provided or the formula is not deprecated.
+    # @see .deprecate!
+    sig { returns(T.nilable(String)) }
+    attr_reader :deprecation_replacement_cask
 
     # Disables a {Formula} (on the given date) so it cannot be
     # installed. If the date has not yet passed the formula
@@ -4378,25 +4427,52 @@ class Formula
     # ```
     #
     # ```ruby
-    # disable! date: "2020-08-27", because: "has been replaced by foo", replacement: "foo"
+    # disable! date: "2020-08-27", because: "has been replaced by foo", replacement_formula: "foo"
     # ```
+    # ```ruby
+    # disable! date: "2020-08-27", because: "has been replaced by foo", replacement_cask: "foo"
+    # ```
+    #  TODO: replace legacy `replacement` with `replacement_formula` or `replacement_cask`
     #
     # @see https://docs.brew.sh/Deprecating-Disabling-and-Removing-Formulae
     # @see DeprecateDisable::FORMULA_DEPRECATE_DISABLE_REASONS
     # @api public
-    sig { params(date: String, because: T.any(NilClass, String, Symbol), replacement: T.nilable(String)).void }
+    sig {
-    def disable!(date:, because:, replacement: nil)
+      params(
+        date:                String,
+        because:             T.any(NilClass, String, Symbol),
+        replacement:         T.nilable(String),
+        replacement_formula: T.nilable(String),
+        replacement_cask:    T.nilable(String),
+      ).void
+    }
+    def disable!(date:, because:, replacement: nil, replacement_formula: nil, replacement_cask: nil)
+      if [replacement, replacement_formula, replacement_cask].filter_map(&:presence).length > 1
+        raise ArgumentError, "more than one of replacement, replacement_formula and/or replacement_cask specified!"
+      end
+
+      # TODO: deprecate in >= 4.5.0
+      # if replacement
+      #   odeprecated(
+      #     "disable!(:replacement)",
+      #     "disable!(:replacement_formula) or deprecate!(:replacement_cask)",
+      #     disable_on: Time.new(2025, 10, 15),
+      #   )
+      # end
+
       @disable_date = T.let(Date.parse(date), T.nilable(Date))
 
       if T.must(@disable_date) > Date.today
         @deprecation_reason = T.let(because, T.any(NilClass, String, Symbol))
-        @deprecation_replacement = T.let(replacement, T.nilable(String))
+        @deprecation_replacement_formula = T.let(replacement_formula.presence || replacement, T.nilable(String))
+        @deprecation_replacement_cask = T.let(replacement_cask.presence || replacement, T.nilable(String))
         @deprecated = T.let(true, T.nilable(T::Boolean))
         return
       end
 
       @disable_reason = T.let(because, T.nilable(T.any(String, Symbol)))
-      @disable_replacement = T.let(replacement, T.nilable(String))
+      @disable_replacement_formula = T.let(replacement_formula.presence || replacement, T.nilable(String))
+      @disable_replacement_cask = T.let(replacement_cask.presence || replacement, T.nilable(String))
       @disabled = T.let(true, T.nilable(T::Boolean))
     end
 
@@ -4423,12 +4499,19 @@ class Formula
     sig { returns(T.any(NilClass, String, Symbol)) }
     attr_reader :disable_reason
 
-    # The replacement for a disabled {Formula}.
+    # The replacement formula for a disabled {Formula}.
     # Returns `nil` if no reason was provided or the formula is not disabled.
     #
     # @see .disable!
     sig { returns(T.nilable(String)) }
-    attr_reader :disable_replacement
+    attr_reader :disable_replacement_formula
+
+    # The replacement cask for a disabled {Formula}.
+    # Returns `nil` if no reason was provided or the formula is not disabled.
+    #
+    # @see .disable!
+    sig { returns(T.nilable(String)) }
+    attr_reader :disable_replacement_cask
 
     # Permit overwriting certain files while linking.
     #

Library/Homebrew/sorbet/rbi/dsl/cask/cask.rbi

@@ -67,7 +67,10 @@ class Cask::Cask
   def deprecation_reason(*args, &block); end
 
   sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
-  def deprecation_replacement(*args, &block); end
+  def deprecation_replacement_formula(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def deprecation_replacement_cask(*args, &block); end
 
   sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
   def desc(*args, &block); end
@@ -85,7 +88,10 @@ class Cask::Cask
   def disable_reason(*args, &block); end
 
   sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
-  def disable_replacement(*args, &block); end
+  def disable_replacement_formula(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def disable_replacement_cask(*args, &block); end
 
   sig { params(args: T.untyped, block: T.untyped).returns(T::Boolean) }
   def disabled?(*args, &block); end

Library/Homebrew/sorbet/rbi/dsl/formula.rbi

@@ -52,7 +52,10 @@ class Formula
   def deprecation_reason(*args, &block); end
 
   sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
-  def deprecation_replacement(*args, &block); end
+  def deprecation_replacement_formula(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def deprecation_replacement_cask(*args, &block); end
 
   sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
   def deps(*args, &block); end
@@ -67,7 +70,10 @@ class Formula
   def disable_reason(*args, &block); end
 
   sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
-  def disable_replacement(*args, &block); end
+  def disable_replacement_formula(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def disable_replacement_cask(*args, &block); end
 
   sig { params(args: T.untyped, block: T.untyped).returns(T::Boolean) }
   def disabled?(*args, &block); end

Library/Homebrew/test/deprecate_disable_spec.rb

@@ -7,43 +7,52 @@ RSpec.describe DeprecateDisable do
   let(:disable_date) { deprecate_date >> DeprecateDisable::REMOVE_DISABLED_TIME_WINDOW }
   let(:deprecated_formula) do
     instance_double(Formula, deprecated?: true, disabled?: false, deprecation_reason: :does_not_build,
-                    deprecation_replacement: nil, deprecation_date: nil, disable_date: nil)
+                    deprecation_replacement_formula: nil, deprecation_replacement_cask: nil,
+                    deprecation_date: nil, disable_date: nil)
   end
   let(:deprecated_formula_with_date) do
     instance_double(Formula, deprecated?: true, disabled?: false, deprecation_reason: :does_not_build,
-                    deprecation_replacement: nil, deprecation_date: deprecate_date, disable_date: nil)
+                    deprecation_replacement_formula: nil, deprecation_replacement_cask: nil,
+                    deprecation_date: deprecate_date, disable_date: nil)
   end
   let(:disabled_formula) do
     instance_double(Formula, deprecated?: false, disabled?: true, disable_reason: "is broken",
-                    disable_replacement: nil, deprecation_date: nil, disable_date: nil)
+                    deprecation_replacement_formula: nil, deprecation_replacement_cask: nil,
+                    disable_replacement_formula: nil, disable_replacement_cask: nil,
+                    deprecation_date: nil, disable_date: nil)
   end
   let(:disabled_formula_with_date) do
     instance_double(Formula, deprecated?: false, disabled?: true, disable_reason: :does_not_build,
-                    disable_replacement: nil, deprecation_date: nil, disable_date: disable_date)
+                    deprecation_replacement_formula: nil, deprecation_replacement_cask: nil,
+                    disable_replacement_formula: nil, disable_replacement_cask: nil,
+                    deprecation_date: nil, disable_date: disable_date)
   end
   let(:deprecated_cask) do
     instance_double(Cask::Cask, deprecated?: true, disabled?: false, deprecation_reason: :discontinued,
-                   deprecation_replacement: nil, deprecation_date: nil, disable_date: nil)
+                    deprecation_replacement_formula: nil, deprecation_replacement_cask: nil,
+                    deprecation_date: nil, disable_date: nil)
   end
   let(:disabled_cask) do
     instance_double(Cask::Cask, deprecated?: false, disabled?: true, disable_reason: nil,
-                    disable_replacement: nil, deprecation_date: nil, disable_date: nil)
+                    deprecation_replacement_formula: nil, deprecation_replacement_cask: nil,
+                    disable_replacement_formula: nil, disable_replacement_cask: nil,
+                    deprecation_date: nil, disable_date: nil)
   end
   let(:deprecated_formula_with_replacement) do
     instance_double(Formula, deprecated?: true, disabled?: false, deprecation_reason: :does_not_build,
-                    deprecation_replacement: "foo", deprecation_date: nil, disable_date: nil)
+                    deprecation_date: nil, disable_date: nil)
   end
   let(:disabled_formula_with_replacement) do
     instance_double(Formula, deprecated?: false, disabled?: true, disable_reason: "is broken",
-                    disable_replacement: "bar", deprecation_date: nil, disable_date: nil)
+                    deprecation_date: nil, disable_date: nil)
   end
   let(:deprecated_cask_with_replacement) do
     instance_double(Cask::Cask, deprecated?: true, disabled?: false, deprecation_reason: :discontinued,
-                    deprecation_replacement: "baz", deprecation_date: nil, disable_date: nil)
+                    deprecation_date: nil, disable_date: nil)
   end
   let(:disabled_cask_with_replacement) do
     instance_double(Cask::Cask, deprecated?: false, disabled?: true, disable_reason: nil,
-                    disable_replacement: "qux", deprecation_date: nil, disable_date: nil)
+                    deprecation_date: nil, disable_date: nil)
   end
 
   before do
@@ -124,24 +133,60 @@ RSpec.describe DeprecateDisable do
         .to eq "disabled!"
     end
 
-    it "returns a replacement message for a deprecated formula" do
+    it "returns a replacement formula message for a deprecated formula" do
+      allow(deprecated_formula_with_replacement).to receive_messages(deprecation_replacement_formula: "foo",
+                                                                     deprecation_replacement_cask:    nil)
       expect(described_class.message(deprecated_formula_with_replacement))
-        .to eq "deprecated because it does not build!\nReplacement:\n  brew install foo\n"
+        .to eq "deprecated because it does not build!\nReplacement:\n  brew install --formula foo\n"
     end
 
-    it "returns a replacement message for a disabled formula" do
+    it "returns a replacement cask message for a deprecated formula" do
+      allow(deprecated_formula_with_replacement).to receive_messages(deprecation_replacement_formula: nil,
+                                                                     deprecation_replacement_cask:    "foo")
+      expect(described_class.message(deprecated_formula_with_replacement))
+        .to eq "deprecated because it does not build!\nReplacement:\n  brew install --cask foo\n"
+    end
+
+    it "returns a replacement formula message for a disabled formula" do
+      allow(disabled_formula_with_replacement).to receive_messages(disable_replacement_formula: "bar",
+                                                                   disable_replacement_cask:    nil)
       expect(described_class.message(disabled_formula_with_replacement))
-        .to eq "disabled because it is broken!\nReplacement:\n  brew install bar\n"
+        .to eq "disabled because it is broken!\nReplacement:\n  brew install --formula bar\n"
     end
 
-    it "returns a replacement message for a deprecated cask" do
+    it "returns a replacement cask message for a disabled formula" do
+      allow(disabled_formula_with_replacement).to receive_messages(disable_replacement_formula: nil,
+                                                                   disable_replacement_cask:    "bar")
+      expect(described_class.message(disabled_formula_with_replacement))
+        .to eq "disabled because it is broken!\nReplacement:\n  brew install --cask bar\n"
+    end
+
+    it "returns a replacement formula message for a deprecated cask" do
+      allow(deprecated_cask_with_replacement).to receive_messages(deprecation_replacement_formula: "baz",
+                                                                  deprecation_replacement_cask:    nil)
       expect(described_class.message(deprecated_cask_with_replacement))
-        .to eq "deprecated because it is discontinued upstream!\nReplacement:\n  brew install baz\n"
+        .to eq "deprecated because it is discontinued upstream!\nReplacement:\n  brew install --formula baz\n"
     end
 
-    it "returns a replacement message for a disabled cask" do
+    it "returns a replacement cask message for a deprecated cask" do
+      allow(deprecated_cask_with_replacement).to receive_messages(deprecation_replacement_formula: nil,
+                                                                  deprecation_replacement_cask:    "baz")
+      expect(described_class.message(deprecated_cask_with_replacement))
+        .to eq "deprecated because it is discontinued upstream!\nReplacement:\n  brew install --cask baz\n"
+    end
+
+    it "returns a replacement formula message for a disabled cask" do
+      allow(disabled_cask_with_replacement).to receive_messages(disable_replacement_formula: "qux",
+                                                                disable_replacement_cask:    nil)
       expect(described_class.message(disabled_cask_with_replacement))
-        .to eq "disabled!\nReplacement:\n  brew install qux\n"
+        .to eq "disabled!\nReplacement:\n  brew install --formula qux\n"
+    end
+
+    it "returns a replacement cask message for a disabled cask" do
+      allow(disabled_cask_with_replacement).to receive_messages(disable_replacement_formula: nil,
+                                                                disable_replacement_cask:    "qux")
+      expect(described_class.message(disabled_cask_with_replacement))
+        .to eq "disabled!\nReplacement:\n  brew install --cask qux\n"
     end
   end
 

Library/Homebrew/test/support/fixtures/cask/everything.json

@@ -95,11 +95,13 @@
   "deprecated": false,
   "deprecation_date": null,
   "deprecation_reason": null,
-  "deprecation_replacement": null,
+  "deprecation_replacement_formula": null,
+  "deprecation_replacement_cask": null,
   "disabled": false,
   "disable_date": null,
   "disable_reason": null,
-  "disable_replacement": null,
+  "disable_replacement_formula": null,
+  "disable_replacement_cask": null,
   "tap_git_head": "abcdef1234567890abcdef1234567890abcdef12",
   "languages": [
     "en",