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

Merge pull request #971 from penman/follow_alias

Browse Source 
Make `brew upgrade` and `brew outdated` follow alias changes
This commit is contained in:
Mike McQuaid 2016-09-19 15:22:24 +01:00 committed by GitHub
commit c45119de75
9 changed files with 607 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
Library/Homebrew/cmd/install.rb
View File

@ -133,9 +133,14 @@ module Homebrew
raise "No devel block is defined for #{f.full_name}"
end
if f.installed?
msg = "#{f.full_name}-#{f.installed_version} already installed"
msg << ", it's just not linked" unless f.linked_keg.symlink? || f.keg_only?
current = f if f.installed?
current ||= f.old_installed_formulae.first
if current
msg = "#{current.full_name}-#{current.installed_version} already installed"
unless current.linked_keg.symlink? || current.keg_only?
msg << ", it's just not linked"
end
opoo msg
elsif f.migration_needed? && !ARGV.force?
# Check if the formula we try to install is the same as installed

23
Library/Homebrew/cmd/outdated.rb
View File

@ -43,15 +43,28 @@ module Homebrew
outdated_formulae.each do |f|
if verbose
outdated_versions = f.outdated_versions(fetch_head: fetch_head)
current_version = if f.head? && outdated_versions.any? { |v| v.to_s == f.pkg_version.to_s }
outdated_kegs = f.outdated_kegs(fetch_head: fetch_head)
current_version = if f.alias_changed?
latest = f.latest_formula
"#{latest.name} (#{latest.pkg_version})"
elsif f.head? && outdated_kegs.any? { |k| k.version.to_s == f.pkg_version.to_s }
# There is a newer HEAD but the version number has not changed.
"latest HEAD"
else
f.pkg_version.to_s
end
puts "#{f.full_name} (#{outdated_versions.join(", ")}) < #{current_version}"
outdated_versions = outdated_kegs.
group_by { |keg| Formulary.from_keg(keg) }.
sort_by { |formula, kegs| formula.full_name }.
map do |formula, kegs|
"#{formula.full_name} (#{kegs.map(&:version).join(", ")})"
end.join(", ")
puts "#{outdated_versions} < #{current_version}"
else
puts f.full_name
puts f.full_installed_specified_name
end
end
end
@ -62,7 +75,7 @@ module Homebrew
outdated_formulae = formulae.select { |f| f.outdated?(fetch_head: fetch_head) }
outdated = outdated_formulae.each do |f|
outdated_versions = f.outdated_versions(fetch_head: fetch_head)
outdated_versions = f.outdated_kegs(fetch_head: fetch_head).map(&:version)
current_version = if f.head? && outdated_versions.any? { |v| v.to_s == f.pkg_version.to_s }
"HEAD"
else

28
Library/Homebrew/cmd/upgrade.rb
View File

@ -37,10 +37,10 @@ module Homebrew
(ARGV.resolved_formulae - outdated).each do |f|
versions = f.installed_kegs.map(&:version)
if versions.empty?
onoe "#{f.full_name} not installed"
onoe "#{f.full_specified_name} not installed"
else
version = versions.max
onoe "#{f.full_name} #{version} already installed"
onoe "#{f.full_specified_name} #{version} already installed"
end
end
exit 1 if outdated.empty?
@ -51,19 +51,21 @@ module Homebrew
outdated -= pinned
end
if outdated.empty?
formulae_to_install = outdated.map(&:latest_formula)
if formulae_to_install.empty?
oh1 "No packages to upgrade"
else
oh1 "Upgrading #{outdated.length} outdated package#{plural(outdated.length)}, with result:"
puts outdated.map { |f| "#{f.full_name} #{f.pkg_version}" } * ", "
oh1 "Upgrading #{formulae_to_install.length} outdated package#{plural(formulae_to_install.length)}, with result:"
puts formulae_to_install.map { |f| "#{f.full_specified_name} #{f.pkg_version}" } * ", "
end
unless upgrade_pinned? || pinned.empty?
oh1 "Not upgrading #{pinned.length} pinned package#{plural(pinned.length)}:"
puts pinned.map { |f| "#{f.full_name} #{f.pkg_version}" } * ", "
puts pinned.map { |f| "#{f.full_specified_name} #{f.pkg_version}" } * ", "
end
outdated.each do |f|
formulae_to_install.each do |f|
upgrade_formula(f)
next unless ARGV.include?("--cleanup")
next unless f.installed?
@ -76,7 +78,11 @@ module Homebrew
end
def upgrade_formula(f)
outdated_keg = Keg.new(f.linked_keg.resolved_path) if f.linked_keg.directory?
formulae_maybe_with_kegs = [f] + f.old_installed_formulae
outdated_kegs = formulae_maybe_with_kegs.
map(&:linked_keg).
select(&:directory?).
map { |k| Keg.new(k.resolved_path) }
fi = FormulaInstaller.new(f)
fi.options = f.build.used_options
@ -87,12 +93,12 @@ module Homebrew
fi.debug = ARGV.debug?
fi.prelude
oh1 "Upgrading #{f.full_name}"
oh1 "Upgrading #{f.full_specified_name}"
# first we unlink the currently active keg for this formula otherwise it is
# possible for the existing build to interfere with the build we are about to
# do! Seriously, it happens!
outdated_keg.unlink if outdated_keg
outdated_kegs.each(&:unlink)
fi.install
fi.finish
@ -117,7 +123,7 @@ module Homebrew
ensure
# restore previous installation state if build failed
begin
outdated_keg.link if outdated_keg && !f.installed?
outdated_kegs.each(&:link) if !f.installed?
rescue
nil
end

16
Library/Homebrew/extend/ARGV.rb
View File

@ -37,11 +37,23 @@ module HomebrewArgvExtension
f.version.update_commit(k.version.version.commit) if k.version.head?
end
end
f
else
rack = Formulary.to_rack(name)
Formulary.from_rack(rack, spec(nil))
alias_path = Formulary.factory(name).alias_path
f = Formulary.from_rack(rack, spec(nil), alias_path: alias_path)
end
# If this formula was installed with an alias that has since changed,
# then it was specified explicitly in ARGV. (Using the alias would
# instead have found the new formula.)
#
# Because of this, the user is referring to this specific formula,
# not any formula targetted by the same alias, so in this context
# the formula shouldn't be considered outdated if the alias used to
# install it has changed.
f.follow_installed_alias = false
f
end
end

163
Library/Homebrew/formula.rb
View File

@ -60,16 +60,24 @@ class Formula
# e.g. `this-formula`
attr_reader :name
# The name specified when installing this {Formula}.
# Could be the name of the {Formula}, or an alias.
# e.g. `another-name-for-this-formula`
# The path to the alias that was used to identify this {Formula}.
# e.g. `/usr/local/Library/Taps/homebrew/homebrew-core/Aliases/another-name-for-this-formula`
attr_reader :alias_path
# The name of the alias that was used to identify this {Formula}.
# e.g. `another-name-for-this-formula`
attr_reader :alias_name
# The fully-qualified name of this {Formula}.
# For core formula it's the same as {#name}.
# e.g. `homebrew/tap-name/this-formula`
attr_reader :full_name
# The fully-qualified alias referring to this {Formula}.
# For core formula it's the same as {#alias_name}.
# e.g. `homebrew/tap-name/another-name-for-this-formula`
attr_reader :full_alias_name
# The full path to this {Formula}.
# e.g. `/usr/local/Library/Taps/homebrew/homebrew-core/Formula/this-formula.rb`
attr_reader :path
@ -149,25 +157,31 @@ class Formula
# @return [BuildOptions]
attr_accessor :build
# A {Boolean} indicating whether this formula should be considered outdated
# if the target of the alias it was installed with has since changed.
# Defaults to true.
# @return [Boolean]
attr_accessor :follow_installed_alias
alias follow_installed_alias? follow_installed_alias
# @private
def initialize(name, path, spec, alias_path: nil)
@name = name
@path = path
@alias_path = alias_path
@alias_name = File.basename(alias_path) if alias_path
@revision = self.class.revision || 0
@version_scheme = self.class.version_scheme || 0
if path == Formulary.core_path(name)
@tap = CoreTap.instance
@full_name = name
@tap = if path == Formulary.core_path(name)
CoreTap.instance
elsif path.to_s =~ HOMEBREW_TAP_PATH_REGEX
@tap = Tap.fetch($1, $2)
@full_name = "#{@tap}/#{name}"
else
@tap = nil
@full_name = name
Tap.fetch($1, $2)
end
@full_name = get_full_name(name)
@full_alias_name = get_full_name(@alias_name)
set_spec :stable
set_spec :devel
set_spec :head
@ -183,6 +197,7 @@ class Formula
validate_attributes!
@build = active_spec.build
@pin = FormulaPin.new(self)
@follow_installed_alias = true
end
# @private
@ -197,6 +212,16 @@ class Formula
private
# Allow full name logic to be re-used between names, aliases,
# and installed aliases.
def get_full_name(name)
if name.nil? || @tap.nil? || @tap.core_tap?
name
else
"#{@tap}/#{name}"
end
end
def set_spec(name)
spec = self.class.send(name)
if spec.url
@ -228,11 +253,47 @@ class Formula
public
# The path that was specified to find/install this formula.
# The alias path that was used to install this formula, if present.
# Can differ from alias_path, which is the alias used to find the formula,
# and is specified to this instance.
def installed_alias_path
path = build.source["path"] if build.is_a?(Tab)
path if path =~ %r{#{HOMEBREW_TAP_DIR_REGEX}/Aliases}
end
def installed_alias_name
File.basename(installed_alias_path) if installed_alias_path
end
def full_installed_alias_name
get_full_name(installed_alias_name)
end
# The path that was specified to find this formula.
def specified_path
alias_path || path
end
# The name specified to find this formula.
def specified_name
alias_name || name
end
# The name (including tap) specified to find this formula.
def full_specified_name
full_alias_name || full_name
end
# The name specified to install this formula.
def installed_specified_name
installed_alias_name || name
end
# The name (including tap) specified to install this formula.
def full_installed_specified_name
full_installed_alias_name || full_name
end
# Is the currently active {SoftwareSpec} a {#stable} build?
# @private
def stable?
@ -503,13 +564,13 @@ class Formula
prefix.parent
end
# All of current installed prefix directories.
# All currently installed prefix directories.
# @private
def installed_prefixes
rack.directory? ? rack.subdirs : []
end
# All of current installed kegs.
# All currently installed kegs.
# @private
def installed_kegs
installed_prefixes.map { |dir| Keg.new(dir) }
@ -1059,39 +1120,88 @@ class Formula
end
# @private
def outdated_versions(options = {})
@outdated_versions ||= Hash.new do |cache, key|
def outdated_kegs(options = {})
@outdated_kegs ||= Hash.new do |cache, key|
raise Migrator::MigrationNeededError, self if migration_needed?
cache[key] = _outdated_versions(key)
cache[key] = _outdated_kegs(key)
end
@outdated_versions[options]
@outdated_kegs[options]
end
def _outdated_versions(options = {})
all_versions = []
def _outdated_kegs(options = {})
all_kegs = []
installed_kegs.each do |keg|
all_kegs << keg
version = keg.version
all_versions << version
next if version.head?
tab = Tab.for_keg(keg)
next if version_scheme > tab.version_scheme
next if version_scheme == tab.version_scheme && pkg_version > version
return []
# don't consider this keg current if there's a newer formula available
next if follow_installed_alias? && new_formula_available?
return [] # this keg is the current version of the formula, so it's not outdated
end
# Even if this formula hasn't been installed, there may be installations
# of other formulae which used to be targets of the alias currently
# targetting this formula. These should be counted as outdated versions.
all_kegs.concat old_installed_formulae.flat_map(&:installed_kegs)
head_version = latest_head_version
if head_version && !head_version_outdated?(head_version, options)
[]
else
all_versions.sort
all_kegs.sort_by(&:version)
end
end
def new_formula_available?
installed_alias_target_changed? && !latest_formula.installed?
end
def current_installed_alias_target
Formulary.factory(installed_alias_path) if installed_alias_path
end
# Has the target of the alias used to install this formula changed?
# Returns false if the formula wasn't installed with an alias.
def installed_alias_target_changed?
target = current_installed_alias_target
target && target != self
end
# Is this formula the target of an alias used to install an old formula?
def supersedes_an_installed_formula?
old_installed_formulae.any?
end
# Has the alias used to install the formula changed, or are different
# formulae already installed with this alias?
def alias_changed?
installed_alias_target_changed? || supersedes_an_installed_formula?
end
# If the alias has changed value, return the new formula.
# Otherwise, return self.
def latest_formula
installed_alias_target_changed? ? current_installed_alias_target : self
end
def old_installed_formulae
# If this formula isn't the current target of the alias,
# it doesn't make sense to say that other formulae are older versions of it
# because we don't know which came first.
return [] if alias_path.nil? || installed_alias_target_changed?
self.class.installed_with_alias_path(alias_path) - [self]
end
# @private
def outdated?(options = {})
!outdated_versions(options).empty?
!outdated_kegs(options).empty?
rescue Migrator::MigrationNeededError
true
end
@ -1246,6 +1356,11 @@ class Formula
end.compact
end
def self.installed_with_alias_path(alias_path)
return [] if alias_path.nil?
installed.select { |f| f.installed_alias_path == alias_path }
end
# an array of all alias files of core {Formula}
# @private
def self.core_alias_files

39
Library/Homebrew/formulary.rb
View File

@ -77,8 +77,11 @@ class Formulary
end
# Gets the formula instance.
def get_formula(spec)
klass.new(name, path, spec, alias_path: alias_path)
#
# `alias_path` can be overridden here in case an alias was used to refer to
# a formula that was loaded in another way.
def get_formula(spec, alias_path: nil)
klass.new(name, path, spec, alias_path: alias_path || self.alias_path)
end
def klass
@ -103,7 +106,7 @@ class Formulary
super name, Formulary.path(full_name)
end
def get_formula(spec)
def get_formula(spec, alias_path: nil)
formula = super
formula.local_bottle_path = @bottle_filename
formula_version = formula.pkg_version
@ -120,7 +123,7 @@ class Formulary
path = alias_path.resolved_path
name = path.basename(".rb").to_s
super name, path
@alias_path = alias_path
@alias_path = alias_path.to_s
end
end
@ -175,7 +178,7 @@ class Formulary
super name, path
end
def get_formula(spec)
def get_formula(spec, alias_path: nil)
super
rescue FormulaUnavailableError => e
raise TapFormulaUnavailableError.new(tap, name), "", e.backtrace
@ -187,7 +190,7 @@ class Formulary
super name, Formulary.core_path(name)
end
def get_formula(_spec)
def get_formula(_spec, alias_path: nil)
raise FormulaUnavailableError, name
end
end
@ -215,38 +218,42 @@ class Formulary
# * a formula pathname
# * a formula URL
# * a local bottle reference
def self.factory(ref, spec = :stable)
loader_for(ref).get_formula(spec)
def self.factory(ref, spec = :stable, alias_path: nil)
loader_for(ref).get_formula(spec, alias_path: alias_path)
end
# Return a Formula instance for the given rack.
# It will auto resolve formula's spec when requested spec is nil
def self.from_rack(rack, spec = nil)
#
# The :alias_path option will be used if the formula is found not to be
# installed, and discarded if it is installed because the alias_path used
# to install the formula will be set instead.
def self.from_rack(rack, spec = nil, alias_path: nil)
kegs = rack.directory? ? rack.subdirs.map { |d| Keg.new(d) } : []
keg = kegs.detect(&:linked?) || kegs.detect(&:optlinked?) || kegs.max_by(&:version)
if keg
from_keg(keg, spec)
from_keg(keg, spec, :alias_path => alias_path)
else
factory(rack.basename.to_s, spec || :stable)
factory(rack.basename.to_s, spec || :stable, :alias_path => alias_path)
end
end
# Return a Formula instance for the given keg.
# It will auto resolve formula's spec when requested spec is nil
def self.from_keg(keg, spec = nil)
def self.from_keg(keg, spec = nil, alias_path: nil)
tab = Tab.for_keg(keg)
tap = tab.tap
spec ||= tab.spec
f = if tap.nil?
factory(keg.rack.basename.to_s, spec)
factory(keg.rack.basename.to_s, spec, :alias_path => alias_path)
else
begin
factory("#{tap}/#{keg.rack.basename}", spec)
factory("#{tap}/#{keg.rack.basename}", spec, :alias_path => alias_path)
rescue FormulaUnavailableError
# formula may be migrated to different tap. Try to search in core and all taps.
factory(keg.rack.basename.to_s, spec)
factory(keg.rack.basename.to_s, spec, :alias_path => alias_path)
end
end
f.build = tab
@ -346,7 +353,7 @@ class Formulary
end
def self.core_path(name)
CoreTap.instance.formula_dir/"#{name.downcase}.rb"
CoreTap.instance.formula_dir/"#{name.to_s.downcase}.rb"
end
def self.tap_paths(name, taps = Dir["#{HOMEBREW_LIBRARY}/Taps/*/*/"])

428
Library/Homebrew/test/test_formula.rb
View File

@ -8,15 +8,153 @@ class FormulaTests < Homebrew::TestCase
name = "formula_name"
path = Formulary.core_path(name)
spec = :stable
alias_path = CoreTap.instance.alias_dir/"formula_alias"
f = klass.new(name, path, spec)
assert_equal name, f.name
assert_equal name, f.specified_name
assert_equal name, f.full_name
assert_equal name, f.full_specified_name
assert_equal path, f.path
assert_nil f.alias_path
assert_nil f.alias_name
assert_nil f.full_alias_name
assert_raises(ArgumentError) { klass.new }
end
def test_formula_instantiation_with_alias
klass = Class.new(Formula) { url "http://example.com/foo-1.0.tar.gz" }
name = "formula_name"
path = Formulary.core_path(name)
spec = :stable
alias_name = "baz@1"
alias_path = CoreTap.instance.alias_dir/alias_name
f = klass.new(name, path, spec, alias_path: alias_path)
assert_equal name, f.name
assert_equal name, f.full_name
assert_equal path, f.path
assert_equal alias_path, f.alias_path
assert_equal alias_name, f.alias_name
assert_equal alias_name, f.specified_name
assert_equal alias_name, f.full_alias_name
assert_equal alias_name, f.full_specified_name
assert_raises(ArgumentError) { klass.new }
end
def test_tap_formula_instantiation
tap = Tap.new("foo", "bar")
klass = Class.new(Formula) { url "baz-1.0" }
name = "baz"
full_name = "#{tap.user}/#{tap.repo}/#{name}"
path = tap.path/"Formula/#{name}.rb"
spec = :stable
f = klass.new(name, path, spec)
assert_equal name, f.name
assert_equal name, f.specified_name
assert_equal full_name, f.full_name
assert_equal full_name, f.full_specified_name
assert_equal path, f.path
assert_nil f.alias_path
assert_nil f.alias_name
assert_nil f.full_alias_name
assert_raises(ArgumentError) { klass.new }
end
def test_tap_formula_instantiation_with_alias
tap = Tap.new("foo", "bar")
klass = Class.new(Formula) { url "baz-1.0" }
name = "baz"
full_name = "#{tap.user}/#{tap.repo}/#{name}"
path = tap.path/"Formula/#{name}.rb"
spec = :stable
alias_name = "baz@1"
full_alias_name = "#{tap.user}/#{tap.repo}/#{alias_name}"
alias_path = CoreTap.instance.alias_dir/alias_name
f = klass.new(name, path, spec, alias_path: alias_path)
assert_equal name, f.name
assert_equal full_name, f.full_name
assert_equal path, f.path
assert_equal alias_path, f.alias_path
assert_equal alias_name, f.alias_name
assert_equal alias_name, f.specified_name
assert_equal full_alias_name, f.full_alias_name
assert_equal full_alias_name, f.full_specified_name
assert_raises(ArgumentError) { klass.new }
end
def test_follow_installed_alias
f = formula { url "foo-1.0" }
assert_predicate f, :follow_installed_alias?
f.follow_installed_alias = true
assert_predicate f, :follow_installed_alias?
f.follow_installed_alias = false
refute_predicate f, :follow_installed_alias?
end
def test_installed_alias_with_core
f = formula { url "foo-1.0" }
build_values_with_no_installed_alias = [
nil,
BuildOptions.new({}, {}),
Tab.new(source: { "path" => f.path.to_s }),
]
build_values_with_no_installed_alias.each do |build|
f.build = build
assert_nil f.installed_alias_path
assert_nil f.installed_alias_name
assert_nil f.full_installed_alias_name
assert_equal f.name, f.installed_specified_name
assert_equal f.name, f.full_installed_specified_name
end
alias_name = "bar"
alias_path = "#{CoreTap.instance.alias_dir}/#{alias_name}"
f.build = Tab.new(source: { "path" => alias_path })
assert_equal alias_path, f.installed_alias_path
assert_equal alias_name, f.installed_alias_name
assert_equal alias_name, f.full_installed_alias_name
assert_equal alias_name, f.installed_specified_name
assert_equal alias_name, f.full_installed_specified_name
end
def test_installed_alias_with_tap
tap = Tap.new("user", "repo")
name = "foo"
path = "#{tap.path}/Formula/#{name}.rb"
f = formula(name, path) { url "foo-1.0" }
build_values_with_no_installed_alias = [
nil,
BuildOptions.new({}, {}),
Tab.new(source: { "path" => f.path }),
]
build_values_with_no_installed_alias.each do |build|
f.build = build
assert_nil f.installed_alias_path
assert_nil f.installed_alias_name
assert_nil f.full_installed_alias_name
assert_equal f.name, f.installed_specified_name
assert_equal f.full_name, f.full_installed_specified_name
end
alias_name = "bar"
full_alias_name = "#{tap.user}/#{tap.repo}/#{alias_name}"
alias_path = "#{tap.alias_dir}/#{alias_name}"
f.build = Tab.new(source: { "path" => alias_path })
assert_equal alias_path, f.installed_alias_path
assert_equal alias_name, f.installed_alias_name
assert_equal full_alias_name, f.full_installed_alias_name
assert_equal alias_name, f.installed_specified_name
assert_equal full_alias_name, f.full_installed_specified_name
end
def test_prefix
f = Testball.new
assert_equal HOMEBREW_CELLAR/f.name/"0.1", f.prefix
@ -248,6 +386,62 @@ class FormulaTests < Homebrew::TestCase
assert_nil Testball.new <=> Object.new
end
def test_alias_paths_with_build_options
alias_path = CoreTap.instance.alias_dir/"another_name"
f = formula(:alias_path => alias_path) { url "foo-1.0" }
f.build = BuildOptions.new({}, {})
assert_equal alias_path, f.alias_path
assert_nil f.installed_alias_path
end
def test_alias_paths_with_tab_with_non_alias_source_path
alias_path = CoreTap.instance.alias_dir/"another_name"
source_path = CoreTap.instance.formula_dir/"another_other_name"
f = formula(:alias_path => alias_path) { url "foo-1.0" }
f.build = Tab.new(:source => { "path" => source_path.to_s })
assert_equal alias_path, f.alias_path
assert_nil f.installed_alias_path
end
def test_alias_paths_with_tab_with_alias_source_path
alias_path = CoreTap.instance.alias_dir/"another_name"
source_path = CoreTap.instance.alias_dir/"another_other_name"
f = formula(:alias_path => alias_path) { url "foo-1.0" }
f.build = Tab.new(:source => { "path" => source_path.to_s })
assert_equal alias_path, f.alias_path
assert_equal source_path.to_s, f.installed_alias_path
end
def test_installed_with_alias_path_with_nil
assert_predicate Formula.installed_with_alias_path(nil), :empty?
end
def test_installed_with_alias_path_with_a_path
alias_path = "#{CoreTap.instance.alias_dir}/alias"
different_alias_path = "#{CoreTap.instance.alias_dir}/another_alias"
formula_with_alias = formula("foo") { url "foo-1.0" }
formula_with_alias.build = Tab.empty
formula_with_alias.build.source["path"] = alias_path
formula_without_alias = formula("bar") { url "bar-1.0" }
formula_without_alias.build = Tab.empty
formula_without_alias.build.source["path"] = formula_without_alias.path.to_s
formula_with_different_alias = formula("baz") { url "baz-1.0" }
formula_with_different_alias.build = Tab.empty
formula_with_different_alias.build.source["path"] = different_alias_path
formulae = [
formula_with_alias,
formula_without_alias,
formula_with_different_alias,
]
Formula.stubs(:installed).returns(formulae)
assert_equal [formula_with_alias], Formula.installed_with_alias_path(alias_path)
end
def test_formula_spec_integration
f = formula do
homepage "http://example.com"
@ -581,29 +775,113 @@ class FormulaTests < Homebrew::TestCase
end
end
class AliasChangeTests < Homebrew::TestCase
attr_reader :f, :new_formula, :tab, :alias_path
def make_formula(version)
f = formula(alias_path: alias_path) { url "foo-#{version}" }
f.build = tab
f
end
def setup
alias_name = "bar"
@alias_path = "#{CoreTap.instance.alias_dir}/#{alias_name}"
@tab = Tab.empty
@f = make_formula("1.0")
@new_formula = make_formula("1.1")
Formula.stubs(:installed).returns([f])
end
def test_alias_changes_when_not_installed_with_alias
tab.source["path"] = Formulary.core_path(f.name).to_s
assert_nil f.current_installed_alias_target
assert_equal f, f.latest_formula
refute_predicate f, :installed_alias_target_changed?
refute_predicate f, :supersedes_an_installed_formula?
refute_predicate f, :alias_changed?
assert_predicate f.old_installed_formulae, :empty?
end
def test_alias_changes_when_not_changed
tab.source["path"] = alias_path
stub_formula_loader(f, alias_path)
assert_equal f, f.current_installed_alias_target
assert_equal f, f.latest_formula
refute_predicate f, :installed_alias_target_changed?
refute_predicate f, :supersedes_an_installed_formula?
refute_predicate f, :alias_changed?
assert_predicate f.old_installed_formulae, :empty?
end
def test_alias_changes_when_new_alias_target
tab.source["path"] = alias_path
stub_formula_loader(new_formula, alias_path)
assert_equal new_formula, f.current_installed_alias_target
assert_equal new_formula, f.latest_formula
assert_predicate f, :installed_alias_target_changed?
refute_predicate f, :supersedes_an_installed_formula?
assert_predicate f, :alias_changed?
assert_predicate f.old_installed_formulae, :empty?
end
def test_alias_changes_when_old_formulae_installed
tab.source["path"] = alias_path
stub_formula_loader(new_formula, alias_path)
assert_equal new_formula, new_formula.current_installed_alias_target
assert_equal new_formula, new_formula.latest_formula
refute_predicate new_formula, :installed_alias_target_changed?
assert_predicate new_formula, :supersedes_an_installed_formula?
assert_predicate new_formula, :alias_changed?
assert_equal [f], new_formula.old_installed_formulae
end
end
class OutdatedVersionsTests < Homebrew::TestCase
attr_reader :outdated_prefix, :same_prefix, :greater_prefix, :head_prefix
attr_reader :f
attr_reader :outdated_prefix,
:same_prefix,
:greater_prefix,
:head_prefix,
:old_alias_target_prefix
attr_reader :f, :old_formula, :new_formula
def setup
@f = formula do
url "foo"
version "1.20"
end
@old_formula = formula("foo@1") { url "foo-1.0" }
@new_formula = formula("foo@2") { url "foo-2.0" }
@outdated_prefix = HOMEBREW_CELLAR/"#{f.name}/1.11"
@same_prefix = HOMEBREW_CELLAR/"#{f.name}/1.20"
@greater_prefix = HOMEBREW_CELLAR/"#{f.name}/1.21"
@head_prefix = HOMEBREW_CELLAR/"#{f.name}/HEAD"
@old_alias_target_prefix = HOMEBREW_CELLAR/"#{old_formula.name}/1.0"
end
def teardown
@f.rack.rmtree if @f.rack.exist?
formulae = [@f, @old_formula, @new_formula]
formulae.map(&:rack).select(&:exist?).each(&:rmtree)
end
def alias_path
"#{@f.tap.alias_dir}/bar"
end
def setup_tab_for_prefix(prefix, options = {})
prefix.mkpath
tab = Tab.empty
tab.tabfile = prefix.join("INSTALL_RECEIPT.json")
tab.source["path"] = options[:path].to_s if options[:path]
tab.source["tap"] = options[:tap] if options[:tap]
tab.source["versions"] = options[:versions] if options[:versions]
tab.source_modified_time = options[:source_modified_time].to_i
@ -611,96 +889,148 @@ class OutdatedVersionsTests < Homebrew::TestCase
tab
end
def reset_outdated_versions
f.instance_variable_set(:@outdated_versions, nil)
def reset_outdated_kegs
f.instance_variable_set(:@outdated_kegs, nil)
end
def test_greater_different_tap_installed
setup_tab_for_prefix(greater_prefix, tap: "user/repo")
assert_predicate f.outdated_versions, :empty?
assert_predicate f.outdated_kegs, :empty?
end
def test_greater_same_tap_installed
f.instance_variable_set(:@tap, CoreTap.instance)
setup_tab_for_prefix(greater_prefix, tap: "homebrew/core")
assert_predicate f.outdated_versions, :empty?
assert_predicate f.outdated_kegs, :empty?
end
def test_outdated_different_tap_installed
setup_tab_for_prefix(outdated_prefix, tap: "user/repo")
refute_predicate f.outdated_versions, :empty?
refute_predicate f.outdated_kegs, :empty?
end
def test_outdated_same_tap_installed
f.instance_variable_set(:@tap, CoreTap.instance)
setup_tab_for_prefix(outdated_prefix, tap: "homebrew/core")
refute_predicate f.outdated_versions, :empty?
refute_predicate f.outdated_kegs, :empty?
end
def test_same_head_installed
def test_outdated_follow_alias_and_alias_unchanged
f.follow_installed_alias = true
f.build = setup_tab_for_prefix(same_prefix, path: alias_path)
stub_formula_loader(f, alias_path)
assert_predicate f.outdated_kegs, :empty?
end
def test_outdated_follow_alias_and_alias_changed_and_new_target_not_installed
f.follow_installed_alias = true
f.build = setup_tab_for_prefix(same_prefix, path: alias_path)
stub_formula_loader(new_formula, alias_path)
refute_predicate f.outdated_kegs, :empty?
end
def test_outdated_follow_alias_and_alias_changed_and_new_target_installed
f.follow_installed_alias = true
f.build = setup_tab_for_prefix(same_prefix, path: alias_path)
stub_formula_loader(new_formula, alias_path)
setup_tab_for_prefix(new_formula.prefix) # install new_formula
assert_predicate f.outdated_kegs, :empty?
end
def test_outdated_no_follow_alias_and_alias_unchanged
f.follow_installed_alias = false
f.build = setup_tab_for_prefix(same_prefix, path: alias_path)
stub_formula_loader(f, alias_path)
assert_predicate f.outdated_kegs, :empty?
end
def test_outdated_no_follow_alias_and_alias_changed
f.follow_installed_alias = false
f.build = setup_tab_for_prefix(same_prefix, path: alias_path)
stub_formula_loader(formula("foo@2") { url "foo-2.0" }, alias_path)
assert_predicate f.outdated_kegs, :empty?
end
def test_outdated_old_alias_targets_installed
@f = formula(alias_path: alias_path) { url "foo-1.0" }
tab = setup_tab_for_prefix(old_alias_target_prefix, path: alias_path)
old_formula.build = tab
Formula.stubs(:installed).returns([old_formula])
refute_predicate f.outdated_kegs, :empty?
end
def test_outdated_old_alias_targets_not_installed
@f = formula(alias_path: alias_path) { url "foo-1.0" }
tab = setup_tab_for_prefix(old_alias_target_prefix, path: old_formula.path)
old_formula.build = tab
Formula.stubs(:installed).returns([old_formula])
assert_predicate f.outdated_kegs, :empty?
end
def test_outdated_same_head_installed
f.instance_variable_set(:@tap, CoreTap.instance)
setup_tab_for_prefix(head_prefix, tap: "homebrew/core")
assert_predicate f.outdated_versions, :empty?
assert_predicate f.outdated_kegs, :empty?
end
def test_different_head_installed
def test_outdated_different_head_installed
f.instance_variable_set(:@tap, CoreTap.instance)
setup_tab_for_prefix(head_prefix, tap: "user/repo")
assert_predicate f.outdated_versions, :empty?
assert_predicate f.outdated_kegs, :empty?
end
def test_mixed_taps_greater_version_installed
def test_outdated_mixed_taps_greater_version_installed
f.instance_variable_set(:@tap, CoreTap.instance)
setup_tab_for_prefix(outdated_prefix, tap: "homebrew/core")
setup_tab_for_prefix(greater_prefix, tap: "user/repo")
assert_predicate f.outdated_versions, :empty?
assert_predicate f.outdated_kegs, :empty?
setup_tab_for_prefix(greater_prefix, tap: "homebrew/core")
reset_outdated_versions
reset_outdated_kegs
assert_predicate f.outdated_versions, :empty?
assert_predicate f.outdated_kegs, :empty?
end
def test_mixed_taps_outdated_version_installed
def test_outdated_mixed_taps_outdated_version_installed
f.instance_variable_set(:@tap, CoreTap.instance)
extra_outdated_prefix = HOMEBREW_CELLAR/"#{f.name}/1.0"
setup_tab_for_prefix(outdated_prefix)
setup_tab_for_prefix(extra_outdated_prefix, tap: "homebrew/core")
reset_outdated_versions
reset_outdated_kegs
refute_predicate f.outdated_versions, :empty?
refute_predicate f.outdated_kegs, :empty?
setup_tab_for_prefix(outdated_prefix, tap: "user/repo")
reset_outdated_versions
reset_outdated_kegs
refute_predicate f.outdated_versions, :empty?
refute_predicate f.outdated_kegs, :empty?
end
def test_same_version_tap_installed
def test_outdated_same_version_tap_installed
f.instance_variable_set(:@tap, CoreTap.instance)
setup_tab_for_prefix(same_prefix, tap: "homebrew/core")
assert_predicate f.outdated_versions, :empty?
assert_predicate f.outdated_kegs, :empty?
setup_tab_for_prefix(same_prefix, tap: "user/repo")
reset_outdated_versions
reset_outdated_kegs
assert_predicate f.outdated_versions, :empty?
assert_predicate f.outdated_kegs, :empty?
end
def test_outdated_installed_head_less_than_stable
tab = setup_tab_for_prefix(head_prefix, versions: { "stable" => "1.0" })
refute_predicate f.outdated_versions, :empty?
refute_predicate f.outdated_kegs, :empty?
# Tab.for_keg(head_prefix) will be fetched from CACHE but we write it anyway
tab.source["versions"] = { "stable" => f.version.to_s }
tab.write
reset_outdated_versions
reset_outdated_kegs
assert_predicate f.outdated_versions, :empty?
assert_predicate f.outdated_kegs, :empty?
end
def test_outdated_fetch_head
@ -738,20 +1068,20 @@ class OutdatedVersionsTests < Homebrew::TestCase
end
end
refute_predicate f.outdated_versions(fetch_head: true), :empty?
refute_predicate f.outdated_kegs(fetch_head: true), :empty?
tab_a.source["versions"] = { "stable" => f.version.to_s }
tab_a.write
reset_outdated_versions
refute_predicate f.outdated_versions(fetch_head: true), :empty?
reset_outdated_kegs
refute_predicate f.outdated_kegs(fetch_head: true), :empty?
head_prefix_a.rmtree
reset_outdated_versions
refute_predicate f.outdated_versions(fetch_head: true), :empty?
reset_outdated_kegs
refute_predicate f.outdated_kegs(fetch_head: true), :empty?
setup_tab_for_prefix(head_prefix_c, source_modified_time: 1)
reset_outdated_versions
assert_predicate f.outdated_versions(fetch_head: true), :empty?
reset_outdated_kegs
assert_predicate f.outdated_kegs(fetch_head: true), :empty?
ensure
ENV.replace(initial_env)
testball_repo.rmtree if testball_repo.exist?
@ -762,7 +1092,7 @@ class OutdatedVersionsTests < Homebrew::TestCase
FileUtils.rm_rf HOMEBREW_CELLAR/"testball"
end
def test_outdated_versions_version_scheme_changed
def test_outdated_kegs_version_scheme_changed
@f = formula("testball") do
url "foo"
version "20141010"
@ -772,12 +1102,12 @@ class OutdatedVersionsTests < Homebrew::TestCase
prefix = HOMEBREW_CELLAR.join("testball/0.1")
setup_tab_for_prefix(prefix, versions: { "stable" => "0.1" })
refute_predicate f.outdated_versions, :empty?
refute_predicate f.outdated_kegs, :empty?
ensure
prefix.rmtree
end
def test_outdated_versions_mixed_version_schemes
def test_outdated_kegs_mixed_version_schemes
@f = formula("testball") do
url "foo"
version "20141010"
@ -790,23 +1120,23 @@ class OutdatedVersionsTests < Homebrew::TestCase
prefix_b = HOMEBREW_CELLAR.join("testball/2.14")
setup_tab_for_prefix(prefix_b, versions: { "stable" => "2.14", "version_scheme" => 2 })
refute_predicate f.outdated_versions, :empty?
reset_outdated_versions
refute_predicate f.outdated_kegs, :empty?
reset_outdated_kegs
prefix_c = HOMEBREW_CELLAR.join("testball/20141009")
setup_tab_for_prefix(prefix_c, versions: { "stable" => "20141009", "version_scheme" => 3 })
refute_predicate f.outdated_versions, :empty?
reset_outdated_versions
refute_predicate f.outdated_kegs, :empty?
reset_outdated_kegs
prefix_d = HOMEBREW_CELLAR.join("testball/20141011")
setup_tab_for_prefix(prefix_d, versions: { "stable" => "20141009", "version_scheme" => 3 })
assert_predicate f.outdated_versions, :empty?
assert_predicate f.outdated_kegs, :empty?
ensure
f.rack.rmtree
end
def test_outdated_versions_head_with_version_scheme
def test_outdated_kegs_head_with_version_scheme
@f = formula("testball") do
url "foo"
version "1.0"
@ -816,13 +1146,13 @@ class OutdatedVersionsTests < Homebrew::TestCase
head_prefix = HOMEBREW_CELLAR.join("testball/HEAD")
setup_tab_for_prefix(head_prefix, versions: { "stable" => "1.0", "version_scheme" => 1 })
refute_predicate f.outdated_versions, :empty?
refute_predicate f.outdated_kegs, :empty?
reset_outdated_versions
reset_outdated_kegs
head_prefix.rmtree
setup_tab_for_prefix(head_prefix, versions: { "stable" => "1.0", "version_scheme" => 2 })
assert_predicate f.outdated_versions, :empty?
assert_predicate f.outdated_kegs, :empty?
ensure
head_prefix.rmtree
end

2
Library/Homebrew/test/test_formulary.rb
View File

@ -89,7 +89,7 @@ class FormularyFactoryTest < Homebrew::TestCase
FileUtils.ln_s @path, alias_path
result = Formulary.factory("foo")
assert_kind_of Formula, result
assert_equal alias_path, result.alias_path
assert_equal alias_path.to_s, result.alias_path
ensure
alias_dir.rmtree
end

8
Library/Homebrew/test/testing_env.rb
View File

@ -121,5 +121,13 @@ module Homebrew
ENV.replace old
end
end
# Use a stubbed {Formulary::FormulaLoader} to make a given formula be found
# when loading from {Formulary} with `ref`.
def stub_formula_loader(formula, ref = formula.name)
loader = mock
loader.stubs(:get_formula).returns(formula)
Formulary.stubs(:loader_for).with(ref).returns(loader)
end
end
end