admin/brew
1
0
Fork 0
Code Issues Packages Projects Releases 6 Wiki Activity

deprecate!/disable!: replacement_formula/replacement_cask fields

Browse Source 
Signed-off-by: botantony <antonsm21@gmail.com>
This commit is contained in:
botantony 2025-04-02 13:19:49 +02:00 committed by Anton Melnikov
parent e594e7e0bb
commit ca447e1ce9
6 changed files with 296 additions and 140 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
Library/Homebrew/cask/dsl.rb
View File

@ -91,13 +91,15 @@ module Cask
:deprecation_date,
:deprecation_reason,
:deprecation_replacement,
:deprecation_replacement_type,
:deprecation_replacement_formula,
:deprecation_replacement_cask,
:disable!,
:disabled?,
:disable_date,
:disable_reason,
:disable_replacement,
:disable_replacement_type,
:disable_replacement_formula,
:disable_replacement_cask,
:discontinued?, # TODO: remove once discontinued? is removed (4.5.0)
:livecheck,
:livecheck_defined?,
@ -113,8 +115,9 @@ module Cask
include OnSystem::MacOSAndLinux
attr_reader :cask, :token, :deprecation_date, :deprecation_reason, :deprecation_replacement,
:deprecation_replacement_type, :disable_date, :disable_reason,
:disable_replacement, :disable_replacement_type, :on_system_block_min_os
:deprecation_replacement_formula, :deprecation_replacement_caks, :disable_date,
:disable_reason, :disable_replacement, :disable_replacement_formula,
:disable_replacement_cask, :on_system_block_min_os
def initialize(cask)
@cask = cask
@ -529,16 +532,27 @@ module Cask
# NOTE: A warning will be shown when trying to install this cask.
#
# @api public
def deprecate!(date:, because:, replacement: nil, replacement_type: :cask)
raise ArgumentError, "Invalid replacement type: #{replacement_type}" if [:formula,
:cask].exclude?(replacement_type)
def deprecate!(date:, because:, replacement: nil, replacement_formula: nil, replacement_cask: nil)
if replacement_formula && replacement_cask
raise ArgumentError, "replacement_formula and 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_type = replacement_type
@deprecation_replacement_formula = replacement_formula
@deprecation_replacement_cask = replacement_cask
@deprecated = true
end
@ -547,23 +561,35 @@ module Cask
# NOTE: An error will be thrown when trying to install this cask.
#
# @api public
def disable!(date:, because:, replacement: nil, replacement_type: :cask)
raise ArgumentError, "Invalid replacement type: #{replacement_type}" if [:formula,
:cask].exclude?(replacement_type)
def disable!(date:, because:, replacement: nil, replacement_formula: nil, replacement_cask: nil)
if replacement_formula && replacement_cask
raise ArgumentError, "replacement_formula and 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_type = replacement_type
@deprecation_replacement_formula = replacement_formula
@deprecation_replacement_cask = replacement_cask
@deprecated = true
return
end
@disable_reason = because
@disable_replacement = replacement
@disable_replacement_type = replacement_type
@disable_replacement_formula = replacement_formula
@disable_replacement_cask = replacement_cask
@disabled = true
end

41
Library/Homebrew/deprecate_disable.rb
View File

@ -41,6 +41,23 @@ module DeprecateDisable
:disabled if formula_or_cask.disabled?
end
sig {
params(
formula: T.nilable(String),
cask: T.nilable(String),
not_typed: T.nilable(String),
).returns(T.nilable(String))
}
def replacement_with_type(formula, cask, not_typed)
if formula
"--formula #{formula}"
elsif cask
"--cask #{cask}"
else
not_typed
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,23 +94,25 @@ 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
end
replacement_type = if formula_or_cask.deprecated?
formula_or_cask.deprecation_replacement_type
elsif formula_or_cask.disabled?
formula_or_cask.disable_replacement_type
replacement = if formula_or_cask.disabled?
replacement_with_type(
formula_or_cask.disable_replacement_formula,
formula_or_cask.disable_replacement_cask,
formula_or_cask.disable_replacement,
)
elsif formula_or_cask.deprecated?
replacement_with_type(
formula_or_cask.deprecation_replacement_formula,
formula_or_cask.deprecation_replacement_cask,
formula_or_cask.deprecation_replacement,
)
end
if replacement.present?
message << "\n"
message << <<~EOS
Replacement:
brew install --#{replacement_type} #{replacement}
brew install #{replacement}
EOS
end

238
Library/Homebrew/formula.rb
View File

@ -1484,16 +1484,19 @@ class Formula
# @see .deprecate!
delegate deprecation_replacement: :"self.class"
# Type of the replacement for this deprecated {Formula}.
# Returns `nil` if the formula is not deprecated.
# @!method deprecation_replacement_type
# @return [Symbol]
# The replacement formula for this deprecated {Formula}.
# Returns `nil` if no replacement is specified or the formula is not deprecated.
# @!method deprecation_replacement_formula
# @return [String]
# @see .deprecate!
# delegate deprecation_replacement_type: :@deprecation_replacement_type
sig { returns(T.nilable(Symbol)) }
def deprecation_replacement_type
@deprecation_replacement_type ||= T.let(nil, T.nilable(Symbol))
end
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.
@ -1523,16 +1526,19 @@ class Formula
# @see .disable!
delegate disable_replacement: :"self.class"
# Type of the replacement for this disabled {Formula}.
# Returns `nil` if no replacement is specified or the formula is not deprecated.
# @!method disable_replacement_type
# @return [Symbol]
# The replacement formula for this disabled {Formula}.
# Returns `nil` if no replacement is specified or the formula is not disabled.
# @!method disable_replacement_formula
# @return [String]
# @see .disable!
# delegate disable_replacement_type: :@disable_replacement_type
sig { returns(T.nilable(Symbol)) }
def disable_replacement_type
@disable_replacement_type ||= T.let(nil, T.nilable(Symbol))
end
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
@ -2513,59 +2519,61 @@ 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,
"deprecation_replacement_type" => @deprecation_replacement_type,
"disabled" => disabled?,
"disable_date" => disable_date,
"disable_reason" => disable_reason,
"disable_replacement" => disable_replacement,
"disable_replacement_type" => @disable_replacement_type,
"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" => 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,
"ruby_source_path" => ruby_source_path,
"ruby_source_checksum" => {},
}
hsh["bottle"]["stable"] = bottle_hash if stable && bottle_defined?
@ -4342,31 +4350,46 @@ 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: "foo",
# replacement_type: :cask
# 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),
replacement_type: Symbol).void
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_type: :formula)
if [:formula, :cask].exclude?(replacement_type)
raise ArgumentError, "Invalid replacement type: #{replacement_type}"
def deprecate!(date:, because:, replacement: nil, replacement_formula: nil, replacement_cask: nil)
if replacement_formula && replacement_cask
raise ArgumentError, "replacement_formula and 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_type = T.let(replacement_type, T.nilable(Symbol))
@deprecation_replacement_formula = T.let(replacement_formula, T.nilable(String))
@deprecation_replacement_cask = T.let(replacement_cask, T.nilable(String))
T.must(@deprecated = T.let(true, T.nilable(T::Boolean)))
end
@ -4399,12 +4422,19 @@ class Formula
sig { returns(T.nilable(String)) }
attr_reader :deprecation_replacement
# Type of 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(Symbol)) }
attr_reader :deprecation_replacement_type
sig { returns(T.nilable(String)) }
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
@ -4421,37 +4451,54 @@ 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: "foo", replacement_type: :cask
# 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),
replacement_type: Symbol).void
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_type: :formula)
if [:formula, :cask].exclude?(replacement_type)
raise ArgumentError, "Invalid replacement type: #{replacement_type}"
def disable!(date:, because:, replacement: nil, replacement_formula: nil, replacement_cask: nil)
if replacement_formula && replacement_cask
raise ArgumentError, "replacement_formula and 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_type = T.let(replacement_type, T.nilable(Symbol))
@deprecation_replacement_formula = T.let(replacement_formula, T.nilable(String))
@deprecation_replacement_cask = T.let(replacement_cask, 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_type = T.let(replacement_type, T.nilable(Symbol))
@disable_replacement_formula = T.let(replacement_formula, T.nilable(String))
@disable_replacement_cask = T.let(replacement_cask, T.nilable(String))
@disabled = T.let(true, T.nilable(T::Boolean))
end
@ -4485,12 +4532,19 @@ class Formula
sig { returns(T.nilable(String)) }
attr_reader :disable_replacement
# Type of the replacement for a disabled {Formula}.
# Returns `nil` if the formula is not disabled.
# 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(Symbol)) }
attr_reader :disable_replacement_type
sig { returns(T.nilable(String)) }
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.
#

10
Library/Homebrew/sorbet/rbi/dsl/cask/cask.rbi generated
View File

@ -70,7 +70,10 @@ class Cask::Cask
def deprecation_replacement(*args, &block); end
sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
def deprecation_replacement_type(*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
@ -91,7 +94,10 @@ class Cask::Cask
def disable_replacement(*args, &block); end
sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
def disable_replacement_type(*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

12
Library/Homebrew/sorbet/rbi/dsl/formula.rbi generated
View File

@ -54,6 +54,12 @@ class Formula
sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
def deprecation_replacement(*args, &block); end
sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
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
@ -69,6 +75,12 @@ class Formula
sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
def disable_replacement(*args, &block); end
sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
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

83
Library/Homebrew/test/deprecate_disable_spec.rb
View File

@ -7,32 +7,38 @@ 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_replacement_type: nil,
deprecation_date: nil, disable_date: nil)
deprecation_replacement: 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_replacement_type: nil,
deprecation_date: deprecate_date, disable_date: nil)
deprecation_replacement: 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, disable_replacement_type: nil,
deprecation_replacement: nil, deprecation_replacement_formula: nil,
deprecation_replacement_cask: nil, disable_replacement: 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, disable_replacement_type: nil,
deprecation_replacement: nil, deprecation_replacement_formula: nil,
deprecation_replacement_cask: nil, disable_replacement: 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_replacement_type: nil,
deprecation_date: nil, disable_date: nil)
deprecation_replacement: 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, disable_replacement_type: nil,
deprecation_replacement: nil, deprecation_replacement_formula: nil,
deprecation_replacement_cask: nil, disable_replacement: nil,
disable_replacement_formula: nil, disable_replacement_cask: nil,
deprecation_date: nil, disable_date: nil)
end
let(:deprecated_formula_with_replacement) do
@ -131,55 +137,88 @@ RSpec.describe DeprecateDisable do
end
it "returns a replacement message for a deprecated formula" do
# allow(deprecated_formula_with_replacement).to receive(:deprecation_replacement_type).and_return(:formula)
expect(deprecated_formula_with_replacement).to receive(:deprecation_replacement_type).and_return(:formula)
allow(deprecated_formula_with_replacement).to receive_messages(deprecation_replacement_formula: nil,
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"
end
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 --formula foo\n"
end
it "returns a replacement cask message for a deprecated formula" do
allow(deprecated_formula_with_replacement).to receive(:deprecation_replacement_type).and_return(:cask)
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 message for a disabled formula" do
# allow(disabled_formula_with_replacement).to receive(:disable_replacement_type).and_return(:formula)
expect(disabled_formula_with_replacement).to receive(:disable_replacement_type).and_return(:formula)
allow(disabled_formula_with_replacement).to receive_messages(disable_replacement_formula: nil,
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"
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 --formula bar\n"
end
it "returns a replacement cask message for a disabled formula" do
allow(disabled_formula_with_replacement).to receive(:disable_replacement_type).and_return(:cask)
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 message for a deprecated cask" do
# allow(deprecated_cask_with_replacement).to receive(:deprecation_replacement_type).and_return(:cask)
expect(deprecated_cask_with_replacement).to receive(:deprecation_replacement_type).and_return(:cask)
allow(deprecated_cask_with_replacement).to receive_messages(deprecation_replacement_formula: nil,
deprecation_replacement_cask: nil)
expect(described_class.message(deprecated_cask_with_replacement))
.to eq "deprecated because it is discontinued upstream!\nReplacement:\n brew install --cask baz\n"
.to eq "deprecated because it is discontinued upstream!\nReplacement:\n brew install baz\n"
end
it "returns a replacement formula message for a deprecated cask" do
allow(deprecated_cask_with_replacement).to receive(:deprecation_replacement_type).and_return(:formula)
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 --formula baz\n"
end
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 message for a disabled cask" do
expect(disabled_cask_with_replacement).to receive(:disable_replacement_type).and_return(:cask)
allow(disabled_cask_with_replacement).to receive_messages(disable_replacement_formula: nil,
disable_replacement_cask: nil)
expect(described_class.message(disabled_cask_with_replacement))
.to eq "disabled!\nReplacement:\n brew install --cask qux\n"
.to eq "disabled!\nReplacement:\n brew install qux\n"
end
it "returns a replacement formula message for a disabled cask" do
allow(disabled_cask_with_replacement).to receive(:disable_replacement_type).and_return(:formula)
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 --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
describe "::to_reason_string_or_symbol" do