diff --git a/Library/Homebrew/cask/cask.rb b/Library/Homebrew/cask/cask.rb index b57147a8b7..a48af3acb2 100644 --- a/Library/Homebrew/cask/cask.rb +++ b/Library/Homebrew/cask/cask.rb @@ -361,40 +361,42 @@ module Cask def to_h { - "token" => token, - "full_token" => full_name, - "old_tokens" => old_tokens, - "tap" => tap&.name, - "name" => name, - "desc" => desc, - "homepage" => homepage, - "url" => url, - "url_specs" => url_specs, - "version" => version, - "installed" => installed_version, - "installed_time" => install_time&.to_i, - "bundle_version" => bundle_long_version, - "bundle_short_version" => bundle_short_version, - "outdated" => outdated?, - "sha256" => sha256, - "artifacts" => artifacts_list, - "caveats" => (Tty.strip_ansi(caveats) unless caveats.empty?), - "depends_on" => depends_on, - "conflicts_with" => conflicts_with, - "container" => container&.pairs, - "auto_updates" => auto_updates, - "deprecated" => deprecated?, - "deprecation_date" => deprecation_date, - "deprecation_reason" => deprecation_reason, - "deprecation_replacement" => deprecation_replacement, - "disabled" => disabled?, - "disable_date" => disable_date, - "disable_reason" => disable_reason, - "disable_replacement" => disable_replacement, - "tap_git_head" => tap_git_head, - "languages" => languages, - "ruby_source_path" => ruby_source_path, - "ruby_source_checksum" => ruby_source_checksum, + "token" => token, + "full_token" => full_name, + "old_tokens" => old_tokens, + "tap" => tap&.name, + "name" => name, + "desc" => desc, + "homepage" => homepage, + "url" => url, + "url_specs" => url_specs, + "version" => version, + "installed" => installed_version, + "installed_time" => install_time&.to_i, + "bundle_version" => bundle_long_version, + "bundle_short_version" => bundle_short_version, + "outdated" => outdated?, + "sha256" => sha256, + "artifacts" => artifacts_list, + "caveats" => (Tty.strip_ansi(caveats) unless caveats.empty?), + "depends_on" => depends_on, + "conflicts_with" => conflicts_with, + "container" => container&.pairs, + "auto_updates" => auto_updates, + "deprecated" => deprecated?, + "deprecation_date" => deprecation_date, + "deprecation_reason" => deprecation_reason, + "deprecation_replacement_formula" => deprecation_replacement_formula, + "deprecation_replacement_cask" => deprecation_replacement_cask, + "disabled" => disabled?, + "disable_date" => disable_date, + "disable_reason" => disable_reason, + "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, + "ruby_source_checksum" => ruby_source_checksum, } end diff --git a/Library/Homebrew/cask/dsl.rb b/Library/Homebrew/cask/dsl.rb index 497e41f775..4de0e32c32 100644 --- a/Library/Homebrew/cask/dsl.rb +++ b/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, - :disable_reason, :disable_replacement, :on_system_block_min_os + attr_reader :cask, :token, :deprecation_date, :deprecation_reason, :deprecation_replacement_formula, + :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 diff --git a/Library/Homebrew/deprecate_disable.rb b/Library/Homebrew/deprecate_disable.rb index 05e85ec8ed..c09e95f30c 100644 --- a/Library/Homebrew/deprecate_disable.rb +++ b/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? - formula_or_cask.deprecation_replacement - elsif formula_or_cask.disabled? - formula_or_cask.disable_replacement + replacement = if formula_or_cask.disabled? + replacement_with_type( + formula_or_cask.disable_replacement_formula, + 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? diff --git a/Library/Homebrew/formula.rb b/Library/Homebrew/formula.rb index 7265845e66..1eeed5aa13 100644 --- a/Library/Homebrew/formula.rb +++ b/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 @@ -2491,57 +2505,59 @@ class Formula sig { returns(T::Hash[String, T.untyped]) } def to_hash hsh = { - "name" => name, - "full_name" => full_name, - "tap" => tap&.name, - "oldnames" => oldnames, - "aliases" => aliases.sort, - "versioned_formulae" => versioned_formulae.map(&:name), - "desc" => desc, - "license" => SPDX.license_expression_to_string(license), - "homepage" => homepage, - "versions" => { + "name" => name, + "full_name" => full_name, + "tap" => tap&.name, + "oldnames" => oldnames, + "aliases" => aliases.sort, + "versioned_formulae" => versioned_formulae.map(&:name), + "desc" => desc, + "license" => SPDX.license_expression_to_string(license), + "homepage" => homepage, + "versions" => { "stable" => stable&.version&.to_s, "head" => head&.version&.to_s, "bottle" => bottle_defined?, }, - "urls" => urls_hash, - "revision" => revision, - "version_scheme" => version_scheme, - "bottle" => {}, - "pour_bottle_only_if" => self.class.pour_bottle_only_if&.to_s, - "keg_only" => keg_only?, - "keg_only_reason" => keg_only_reason&.to_hash, - "options" => [], - "build_dependencies" => [], - "dependencies" => [], - "test_dependencies" => [], - "recommended_dependencies" => [], - "optional_dependencies" => [], - "uses_from_macos" => [], - "uses_from_macos_bounds" => [], - "requirements" => serialized_requirements, - "conflicts_with" => conflicts.map(&:name), - "conflicts_with_reasons" => conflicts.map(&:reason), - "link_overwrite" => self.class.link_overwrite_paths.to_a, - "caveats" => caveats_with_placeholders, - "installed" => T.let([], T::Array[T::Hash[String, T.untyped]]), - "linked_keg" => linked_version&.to_s, - "pinned" => pinned?, - "outdated" => outdated?, - "deprecated" => deprecated?, - "deprecation_date" => deprecation_date, - "deprecation_reason" => deprecation_reason, - "deprecation_replacement" => deprecation_replacement, - "disabled" => disabled?, - "disable_date" => disable_date, - "disable_reason" => disable_reason, - "disable_replacement" => disable_replacement, - "post_install_defined" => post_install_defined?, - "service" => (service.to_hash if service?), - "tap_git_head" => tap_git_head, - "ruby_source_path" => ruby_source_path, - "ruby_source_checksum" => {}, + "urls" => urls_hash, + "revision" => revision, + "version_scheme" => version_scheme, + "bottle" => {}, + "pour_bottle_only_if" => self.class.pour_bottle_only_if&.to_s, + "keg_only" => keg_only?, + "keg_only_reason" => keg_only_reason&.to_hash, + "options" => [], + "build_dependencies" => [], + "dependencies" => [], + "test_dependencies" => [], + "recommended_dependencies" => [], + "optional_dependencies" => [], + "uses_from_macos" => [], + "uses_from_macos_bounds" => [], + "requirements" => serialized_requirements, + "conflicts_with" => conflicts.map(&:name), + "conflicts_with_reasons" => conflicts.map(&:reason), + "link_overwrite" => self.class.link_overwrite_paths.to_a, + "caveats" => caveats_with_placeholders, + "installed" => T.let([], T::Array[T::Hash[String, T.untyped]]), + "linked_keg" => linked_version&.to_s, + "pinned" => pinned?, + "outdated" => outdated?, + "deprecated" => deprecated?, + "deprecation_date" => deprecation_date, + "deprecation_reason" => deprecation_reason, + "deprecation_replacement_formula" => deprecation_replacement_formula, + "deprecation_replacement_cask" => deprecation_replacement_cask, + "disabled" => disabled?, + "disable_date" => disable_date, + "disable_reason" => disable_reason, + "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, + "ruby_source_path" => ruby_source_path, + "ruby_source_checksum" => {}, } hsh["bottle"]["stable"] = bottle_hash if stable && bottle_defined? @@ -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 } - def deprecate!(date:, because:, replacement: nil) + sig { + 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 } - def disable!(date:, because:, replacement: nil) + sig { + 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. # diff --git a/Library/Homebrew/sorbet/rbi/dsl/cask/cask.rbi b/Library/Homebrew/sorbet/rbi/dsl/cask/cask.rbi index d9f42ba625..78c80320e5 100644 --- a/Library/Homebrew/sorbet/rbi/dsl/cask/cask.rbi +++ b/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 diff --git a/Library/Homebrew/sorbet/rbi/dsl/formula.rbi b/Library/Homebrew/sorbet/rbi/dsl/formula.rbi index 8e7c2d0290..86118a7373 100644 --- a/Library/Homebrew/sorbet/rbi/dsl/formula.rbi +++ b/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 diff --git a/Library/Homebrew/test/deprecate_disable_spec.rb b/Library/Homebrew/test/deprecate_disable_spec.rb index 71ed29e2b3..0110e6e209 100644 --- a/Library/Homebrew/test/deprecate_disable_spec.rb +++ b/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 diff --git a/Library/Homebrew/test/support/fixtures/cask/everything.json b/Library/Homebrew/test/support/fixtures/cask/everything.json index b247e82a05..d3d981258f 100644 --- a/Library/Homebrew/test/support/fixtures/cask/everything.json +++ b/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",