mirrors/brew
1
0
Fork 0
mirror of https://github.com/Homebrew/brew.git synced 2025-07-14 16:09:03 +08:00
Code Issues Packages Projects Releases Wiki Activity

Deprecate macOS versions below Mavericks

Browse Source 
And remove all dead/unneeded code.
This commit is contained in:
Mike McQuaid 2019-01-26 17:13:14 +00:00
parent 38cce518e0
commit 1aa8ad09e2
No known key found for this signature in database
GPG Key ID: 48A898132FD8EE70
50 changed files with 157 additions and 830 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
Library/Homebrew/brew.sh
View File

@ -93,23 +93,14 @@ then
# Don't change this from Mac OS X to match what macOS itself does in Safari on 10.12 # Don't change this from Mac OS X to match what macOS itself does in Safari on 10.12
HOMEBREW_OS_USER_AGENT_VERSION="Mac OS X $HOMEBREW_MACOS_VERSION" HOMEBREW_OS_USER_AGENT_VERSION="Mac OS X $HOMEBREW_MACOS_VERSION"
# The system Curl is too old for some modern HTTPS certificates on
# older macOS versions.
#
# Intentionally set this variable by exploding another. # Intentionally set this variable by exploding another.
# shellcheck disable=SC2086,SC2183 # shellcheck disable=SC2086,SC2183
printf -v HOMEBREW_MACOS_VERSION_NUMERIC "%02d%02d%02d" ${HOMEBREW_MACOS_VERSION//./ } printf -v HOMEBREW_MACOS_VERSION_NUMERIC "%02d%02d%02d" ${HOMEBREW_MACOS_VERSION//./ }
if [[ "$HOMEBREW_MACOS_VERSION_NUMERIC" -lt "101000" ]]
then
HOMEBREW_SYSTEM_CURL_TOO_OLD="1"
HOMEBREW_FORCE_BREWED_CURL="1"
fi
# Announce pre-Mavericks deprecation now # Refuse to run on pre-Mavericks
if [[ "$HOMEBREW_MACOS_VERSION_NUMERIC" -lt "100900" ]] if [[ "$HOMEBREW_MACOS_VERSION_NUMERIC" -lt "100900" ]]
then then
printf "WARNING: Your version of macOS (%s) will not be able to run Homebrew when\n" "$HOMEBREW_MACOS_VERSION" >&2 printf "ERROR: Your version of macOS (%s) is too old to run Homebrew!" "$HOMEBREW_MACOS_VERSION" >&2
printf " version 2.0.0 is released (Q1 2019)!\n" >&2
if [[ "$HOMEBREW_MACOS_VERSION_NUMERIC" -lt "100700" ]] if [[ "$HOMEBREW_MACOS_VERSION_NUMERIC" -lt "100700" ]]
then then
printf " For 10.4 - 10.6 support see: https://github.com/mistydemeo/tigerbrew\n" >&2 printf " For 10.4 - 10.6 support see: https://github.com/mistydemeo/tigerbrew\n" >&2
@ -117,6 +108,15 @@ then
printf "\n" >&2 printf "\n" >&2
fi fi
# The system Curl is too old for some modern HTTPS certificates on
# older macOS versions.
#
if [[ "$HOMEBREW_MACOS_VERSION_NUMERIC" -lt "101000" ]]
then
HOMEBREW_SYSTEM_CURL_TOO_OLD="1"
HOMEBREW_FORCE_BREWED_CURL="1"
fi
# The system Git on macOS versions before Sierra is too old for some Homebrew functionality we rely on. # The system Git on macOS versions before Sierra is too old for some Homebrew functionality we rely on.
HOMEBREW_MINIMUM_GIT_VERSION="2.14.3" HOMEBREW_MINIMUM_GIT_VERSION="2.14.3"
if [[ "$HOMEBREW_MACOS_VERSION_NUMERIC" -lt "101200" ]] if [[ "$HOMEBREW_MACOS_VERSION_NUMERIC" -lt "101200" ]]

20
Library/Homebrew/compilers.rb
View File

@ -4,7 +4,6 @@ module CompilerConstants
GNU_GCC_REGEXP = /^gcc-(4\.9|[5-8])$/.freeze GNU_GCC_REGEXP = /^gcc-(4\.9|[5-8])$/.freeze
COMPILER_SYMBOL_MAP = { COMPILER_SYMBOL_MAP = {
"gcc" => :gcc, "gcc" => :gcc,
"gcc-4.2" => :gcc_4_2,
"clang" => :clang, "clang" => :clang,
"llvm_clang" => :llvm_clang, "llvm_clang" => :llvm_clang,
}.freeze }.freeze
@ -19,9 +18,11 @@ class CompilerFailure
def version(val = nil) def version(val = nil)
if val if val
@version = Version.parse(val.to_s) @version = Version.parse(val.to_s)
else if name.to_s == "clang" && val.to_i < 600
@version odisabled "'fails_with :clang' with 'build' < 600"
end
end end
@version
end end
# Allows Apple compiler `fails_with` statements to keep using `build` # Allows Apple compiler `fails_with` statements to keep using `build`
@ -66,14 +67,6 @@ class CompilerFailure
end end
COLLECTIONS = { COLLECTIONS = {
cxx11: [
create(:gcc_4_2),
create(:clang) { build 425 },
],
cxx14: [
create(:clang) { build 600 },
create(:gcc_4_2),
],
openmp: [ openmp: [
create(:clang), create(:clang),
], ],
@ -86,9 +79,8 @@ class CompilerSelector
Compiler = Struct.new(:name, :version) Compiler = Struct.new(:name, :version)
COMPILER_PRIORITY = { COMPILER_PRIORITY = {
clang: [:clang, :gcc_4_2, :gnu, :llvm_clang], clang: [:clang, :gnu, :llvm_clang],
gcc_4_2: [:gcc_4_2, :gnu, :clang], gcc: [:gnu, :gcc, :llvm_clang, :clang],
gcc: [:gnu, :gcc, :llvm_clang, :clang, :gcc_4_2],
}.freeze }.freeze
def self.select_for(formula, compilers = self.compilers) def self.select_for(formula, compilers = self.compilers)

13
Library/Homebrew/development_tools.rb
View File

@ -37,18 +37,6 @@ class DevelopmentTools
:clang :clang
end end
def gcc_4_2_build_version
@gcc_4_2_build_version ||= begin
if (gcc = locate("gcc-4.2")) &&
!gcc.realpath.basename.to_s.start_with?("llvm") &&
build_version = `#{gcc} --version 2>/dev/null`[/build (\d{4,})/, 1]
Version.new build_version
else
Version::NULL
end
end
end
def clang_version def clang_version
@clang_version ||= begin @clang_version ||= begin
if (path = locate("clang")) && if (path = locate("clang")) &&
@ -98,7 +86,6 @@ class DevelopmentTools
end end
def clear_version_cache def clear_version_cache
@gcc_4_2_build_version = nil
@clang_version = @clang_build_version = nil @clang_version = @clang_build_version = nil
@non_apple_gcc_version = {} @non_apple_gcc_version = {}
end end

2
Library/Homebrew/diagnostic.rb
View File

@ -190,8 +190,6 @@ module Homebrew
# Static libs which are generally OK should be added to this list, # Static libs which are generally OK should be added to this list,
# with a short description of the software they come with. # with a short description of the software they come with.
white_list = [ white_list = [
"libsecurity_agent_client.a", # OS X 10.8.2 Supplemental Update
"libsecurity_agent_server.a", # OS X 10.8.2 Supplemental Update
"libntfs-3g.a", # NTFS-3G "libntfs-3g.a", # NTFS-3G
"libntfs.a", # NTFS-3G "libntfs.a", # NTFS-3G
"libublio.a", # NTFS-3G "libublio.a", # NTFS-3G

3
Library/Homebrew/emoji.rb
View File

@ -7,8 +7,5 @@ module Emoji
def enabled? def enabled?
!ENV["HOMEBREW_NO_EMOJI"] !ENV["HOMEBREW_NO_EMOJI"]
end end
alias generic_enabled? enabled?
end end
end end
require "extend/os/emoji"

12
Library/Homebrew/extend/ENV/shared.rb
View File

@ -316,18 +316,6 @@ module SharedEnvExtension
%w[clang llvm_clang].include?(cc.to_s) %w[clang llvm_clang].include?(cc.to_s)
end end
# @private
def compiler_with_cxx11_support?(cc)
return if compiler_any_clang?(cc)
version = if cc == :gcc
DevelopmentTools.non_apple_gcc_version "gcc"
else
cc[/^gcc-(\d+(?:\.\d+)?)$/, 1]
end
version && Version.create(version) >= Version.create("4.8")
end
private private
def cc=(val) def cc=(val)

15
Library/Homebrew/extend/ENV/std.rb
View File

@ -100,11 +100,6 @@ module Stdenv
dir/base.to_s.sub("gcc", "g++").sub("clang", "clang++") dir/base.to_s.sub("gcc", "g++").sub("clang", "clang++")
end end
def gcc_4_2
super
set_cpu_cflags
end
GNU_GCC_VERSIONS.each do |n| GNU_GCC_VERSIONS.each do |n|
define_method(:"gcc-#{n}") do define_method(:"gcc-#{n}") do
super() super()
@ -145,14 +140,8 @@ module Stdenv
end end
def cxx11 def cxx11
if compiler == :clang append "CXX", "-std=c++11"
append "CXX", "-std=c++11" libcxx
append "CXX", "-stdlib=libc++"
elsif compiler_with_cxx11_support?(compiler)
append "CXX", "-std=c++11"
else
raise "The selected compiler doesn't support C++11: #{compiler}"
end
end end
def libcxx def libcxx

19
Library/Homebrew/extend/ENV/super.rb
View File

@ -77,7 +77,7 @@ module Superenv
# K - Don't strip -arch <arch>, -m32, or -m64 # K - Don't strip -arch <arch>, -m32, or -m64
# w - Pass -no_weak_imports to the linker # w - Pass -no_weak_imports to the linker
# #
# On 10.8 and newer, these flags will also be present: # These flags will also be present:
# s - apply fix for sed's Unicode support # s - apply fix for sed's Unicode support
# a - apply fix for apr-1-config path # a - apply fix for apr-1-config path
end end
@ -109,13 +109,8 @@ module Superenv
path.append(homebrew_extra_paths) path.append(homebrew_extra_paths)
path.append("/usr/bin", "/bin", "/usr/sbin", "/sbin") path.append("/usr/bin", "/bin", "/usr/sbin", "/sbin")
# Homebrew's apple-gcc42 will be outside the PATH in superenv,
# so xcrun may not be able to find it
begin begin
case homebrew_cc if homebrew_cc =~ GNU_GCC_REGEXP
when "gcc-4.2"
path.append(Formulary.factory("apple-gcc42").opt_bin)
when GNU_GCC_REGEXP
path.append(gcc_version_formula($&).opt_bin) path.append(gcc_version_formula($&).opt_bin)
end end
rescue FormulaUnavailableError rescue FormulaUnavailableError
@ -279,14 +274,8 @@ module Superenv
end end
def cxx11 def cxx11
if homebrew_cc == "clang" append_to_cccfg "x"
append_to_cccfg "x" append_to_cccfg "g" if homebrew_cc == "clang"
append_to_cccfg "g"
elsif compiler_with_cxx11_support?(homebrew_cc)
append_to_cccfg "x"
else
raise "The selected compiler doesn't support C++11: #{homebrew_cc}"
end
end end
def libcxx def libcxx

1
Library/Homebrew/extend/os/emoji.rb
View File

@ -1 +0,0 @@
require "extend/os/mac/emoji" if OS.mac?

14
Library/Homebrew/extend/os/mac/dependency_collector.rb
View File

@ -2,25 +2,15 @@ class DependencyCollector
undef git_dep_if_needed, subversion_dep_if_needed, cvs_dep_if_needed, undef git_dep_if_needed, subversion_dep_if_needed, cvs_dep_if_needed,
xz_dep_if_needed, unzip_dep_if_needed, bzip2_dep_if_needed xz_dep_if_needed, unzip_dep_if_needed, bzip2_dep_if_needed
def git_dep_if_needed(tags) def git_dep_if_needed(tags); end
return if MacOS.version >= :lion
Dependency.new("git", tags)
end
def subversion_dep_if_needed(tags); end def subversion_dep_if_needed(tags); end
def cvs_dep_if_needed(tags) def cvs_dep_if_needed(tags)
return if MacOS.version < :lion
Dependency.new("cvs", tags) Dependency.new("cvs", tags)
end end
def xz_dep_if_needed(tags) def xz_dep_if_needed(tags); end
return if MacOS.version >= :mavericks
Dependency.new("xz", tags)
end
def unzip_dep_if_needed(tags); end def unzip_dep_if_needed(tags); end

33
Library/Homebrew/extend/os/mac/development_tools.rb
View File

@ -26,17 +26,7 @@ class DevelopmentTools
end end
def default_compiler def default_compiler
case default_cc :clang
when /^gcc/ then :gcc_4_2
when "clang" then :clang
else
# guess :(
if MacOS::Xcode.version >= "4.3"
:clang
else
:gcc_4_2
end
end
end end
def curl_handles_most_https_certificates? def curl_handles_most_https_certificates?
@ -52,23 +42,10 @@ class DevelopmentTools
end end
def installation_instructions def installation_instructions
if MacOS.version >= "10.9" <<~EOS
<<~EOS Install the Command Line Tools:
Install the Command Line Tools: xcode-select --install
xcode-select --install EOS
EOS
elsif MacOS.version == "10.8" || MacOS.version == "10.7"
<<~EOS
Install the Command Line Tools from
https://developer.apple.com/download/more/
or via Xcode's preferences.
EOS
else
<<~EOS
Install Xcode from
https://developer.apple.com/download/more/
EOS
end
end end
def custom_installation_instructions def custom_installation_instructions

7
Library/Homebrew/extend/os/mac/emoji.rb
View File

@ -1,7 +0,0 @@
module Emoji
class << self
def enabled?
generic_enabled? && MacOS.version >= :lion
end
end
end

26
Library/Homebrew/extend/os/mac/extend/ENV/std.rb
View File

@ -27,36 +27,24 @@ module Stdenv
append_path "ACLOCAL_PATH", "#{MacOS::X11.share}/aclocal" append_path "ACLOCAL_PATH", "#{MacOS::X11.share}/aclocal"
if MacOS::XQuartz.provided_by_apple? && MacOS.sdk_path_if_needed
append_path "CMAKE_PREFIX_PATH", "#{MacOS.sdk_path_if_needed}/usr/X11"
end
append "CFLAGS", "-I#{MacOS::X11.include}" unless MacOS::CLT.installed? append "CFLAGS", "-I#{MacOS::X11.include}" unless MacOS::CLT.installed?
end end
def setup_build_environment(formula = nil) def setup_build_environment(formula = nil)
generic_setup_build_environment formula generic_setup_build_environment formula
if MacOS.version >= :mountain_lion # sed is strict, and errors out when it encounters files with
# Mountain Lion's sed is stricter, and errors out when # mixed character sets
# it encounters files with mixed character sets delete("LC_ALL")
delete("LC_ALL") self["LC_CTYPE"] = "C"
self["LC_CTYPE"] = "C"
end
# Add lib and include etc. from the current macosxsdk to compiler flags: # Add lib and include etc. from the current macosxsdk to compiler flags:
macosxsdk MacOS.version macosxsdk MacOS.version
if MacOS::Xcode.without_clt? return unless MacOS::Xcode.without_clt?
append_path "PATH", "#{MacOS::Xcode.prefix}/usr/bin"
append_path "PATH", "#{MacOS::Xcode.toolchain_path}/usr/bin"
end
# Leopard's ld needs some convincing that it's building 64-bit append_path "PATH", "#{MacOS::Xcode.prefix}/usr/bin"
# See: https://github.com/mistydemeo/tigerbrew/issues/59 append_path "PATH", "#{MacOS::Xcode.toolchain_path}/usr/bin"
return unless MacOS.version == :leopard
append "LDFLAGS", "-arch #{Hardware::CPU.arch_64_bit}"
end end
def remove_macosxsdk(version = MacOS.version) def remove_macosxsdk(version = MacOS.version)

17
Library/Homebrew/extend/os/mac/extend/ENV/super.rb
View File

@ -22,13 +22,6 @@ module Superenv
def homebrew_extra_paths def homebrew_extra_paths
paths = [] paths = []
# On 10.9, there are shims for all tools in /usr/bin.
# On 10.7 and 10.8 we need to add these directories ourselves.
if MacOS::Xcode.without_clt? && MacOS.version <= "10.8"
paths << "#{MacOS::Xcode.prefix}/usr/bin"
paths << "#{MacOS::Xcode.toolchain_path}/usr/bin"
end
paths << MacOS::X11.bin.to_s if x11? paths << MacOS::X11.bin.to_s if x11?
paths paths
end end
@ -96,9 +89,9 @@ module Superenv
def determine_cccfg def determine_cccfg
s = "" s = ""
# Fix issue with sed barfing on unicode characters on Mountain Lion # Fix issue with sed barfing on unicode characters on Mountain Lion
s << "s" if MacOS.version >= :mountain_lion s << "s"
# Fix issue with >= 10.8 apr-1-config having broken paths # Fix issue with >= Mountain Lion apr-1-config having broken paths
s << "a" if MacOS.version >= :mountain_lion s << "a"
s s
end end
@ -133,9 +126,9 @@ module Superenv
ENV["ac_have_clock_syscall"] = "no" ENV["ac_have_clock_syscall"] = "no"
end end
# On 10.9, the tools in /usr/bin proxy to the active developer directory. # The tools in /usr/bin proxy to the active developer directory.
# This means we can use them for any combination of CLT and Xcode. # This means we can use them for any combination of CLT and Xcode.
self["HOMEBREW_PREFER_CLT_PROXIES"] = "1" if MacOS.version >= "10.9" self["HOMEBREW_PREFER_CLT_PROXIES"] = "1"
end end
def no_weak_imports def no_weak_imports

125
Library/Homebrew/extend/os/mac/hardware/cpu.rb
View File

@ -1,20 +1,7 @@
module Hardware module Hardware
class CPU class CPU
class << self class << self
undef optimization_flags, type, family, universal_archs, can_run?, undef type, family, universal_archs, features, sse4?
features, sse4?
PPC_OPTIMIZATION_FLAGS = {
g3: "-mcpu=750",
g4: "-mcpu=7400",
g4e: "-mcpu=7450",
g5: "-mcpu=970",
g5_64: "-mcpu=970 -arch ppc64",
}.freeze
def optimization_flags
OPTIMIZATION_FLAGS.merge(PPC_OPTIMIZATION_FLAGS)
end
# These methods use info spewed out by sysctl. # These methods use info spewed out by sysctl.
# Look in <mach/machine.h> for decoding info. # Look in <mach/machine.h> for decoding info.
@ -22,54 +9,37 @@ module Hardware
case sysctl_int("hw.cputype") case sysctl_int("hw.cputype")
when 7 when 7
:intel :intel
when 18
:ppc
else else
:dunno :dunno
end end
end end
def family def family
if intel? case sysctl_int("hw.cpufamily")
case sysctl_int("hw.cpufamily") when 0x73d67300 # Yonah: Core Solo/Duo
when 0x73d67300 # Yonah: Core Solo/Duo :core
:core when 0x426f69ef # Merom: Core 2 Duo
when 0x426f69ef # Merom: Core 2 Duo :core2
:core2 when 0x78ea4fbc # Penryn
when 0x78ea4fbc # Penryn :penryn
:penryn when 0x6b5a4cd2 # Nehalem
when 0x6b5a4cd2 # Nehalem :nehalem
:nehalem when 0x573B5EEC # Arrandale
when 0x573B5EEC # Arrandale :arrandale
:arrandale when 0x5490B78C # Sandy Bridge
when 0x5490B78C # Sandy Bridge :sandybridge
:sandybridge when 0x1F65E835 # Ivy Bridge
when 0x1F65E835 # Ivy Bridge :ivybridge
:ivybridge when 0x10B282DC # Haswell
when 0x10B282DC # Haswell :haswell
:haswell when 0x582ed09c # Broadwell
when 0x582ed09c # Broadwell :broadwell
:broadwell when 0x37fc219f # Skylake
when 0x37fc219f # Skylake :skylake
:skylake when 0x0f817246 # Kaby Lake
when 0x0f817246 # Kaby Lake :kabylake
:kabylake else
else :dunno
:dunno
end
elsif ppc?
case sysctl_int("hw.cpusubtype")
when 9
:g3 # PowerPC 750
when 10
:g4 # PowerPC 7400
when 11
:g4e # PowerPC 7450
when 100
:g5_64 # PowerPC 970
else
:dunno
end
end end
end end
@ -83,20 +53,6 @@ module Hardware
[arch_64_bit, arch_32_bit].extend ArchitectureListExtension [arch_64_bit, arch_32_bit].extend ArchitectureListExtension
end end
# Determines whether the current CPU and macOS combination
# can run an executable of the specified architecture.
# `arch` is a symbol in the same format returned by
# {Hardware::CPU.family}.
def can_run?(arch)
if Hardware::CPU.intel?
intel_can_run? arch
elsif Hardware::CPU.ppc?
ppc_can_run? arch
else
false
end
end
def features def features
@features ||= sysctl_n( @features ||= sysctl_n(
"machdep.cpu.features", "machdep.cpu.features",
@ -156,35 +112,6 @@ module Hardware
@properties[keys] = Utils.popen_read("/usr/sbin/sysctl", "-n", *keys) @properties[keys] = Utils.popen_read("/usr/sbin/sysctl", "-n", *keys)
end end
end end
def intel_can_run?(arch)
case arch
when *PPC_32BIT_ARCHS
# Rosetta is still available
MacOS.version < :lion
when *PPC_64BIT_ARCHS
# Rosetta never supported PPC64
false
when *INTEL_64BIT_ARCHS
Hardware::CPU.is_64_bit?
when *INTEL_32BIT_ARCHS
true
else # dunno
false
end
end
def ppc_can_run?(arch)
case arch
when *PPC_32BIT_ARCHS
true
when *PPC_64BIT_ARCHS
Hardware::CPU.is_64_bit?
else
# Intel is never supported
false
end
end
end end
end end
end end

12
Library/Homebrew/extend/os/mac/missing_formula.rb
View File

@ -4,15 +4,9 @@ module Homebrew
def blacklisted_reason(name) def blacklisted_reason(name)
case name.downcase case name.downcase
when "xcode" when "xcode"
if MacOS.version >= :lion <<~EOS
<<~EOS Xcode can be installed from the App Store.
Xcode can be installed from the App Store. EOS
EOS
else
<<~EOS
Xcode can be installed from #{Formatter.url("https://developer.apple.com/download/more/")}.
EOS
end
else else
generic_blacklisted_reason(name) generic_blacklisted_reason(name)
end end

4
Library/Homebrew/extend/os/mac/system_config.rb
View File

@ -36,7 +36,7 @@ class SystemConfig
end end
def clt def clt
@clt ||= if MacOS::CLT.installed? && MacOS::Xcode.version >= "4.3" @clt ||= if MacOS::CLT.installed?
MacOS::CLT.version MacOS::CLT.version
end end
end end
@ -59,7 +59,7 @@ class SystemConfig
f.puts "CLT: #{clt || "N/A"}" f.puts "CLT: #{clt || "N/A"}"
f.puts "Xcode: #{xcode || "N/A"}" f.puts "Xcode: #{xcode || "N/A"}"
f.puts "CLT headers: #{clt_headers}" if MacOS::CLT.separate_header_package? && clt_headers f.puts "CLT headers: #{clt_headers}" if MacOS::CLT.separate_header_package? && clt_headers
f.puts "XQuartz: #{xquartz}" if !MacOS::XQuartz.provided_by_apple? && xquartz f.puts "XQuartz: #{xquartz}" if xquartz
end end
end end
end end

8
Library/Homebrew/extend/os/mac/utils/bottles.rb
View File

@ -4,13 +4,7 @@ module Utils
undef tag undef tag
def tag def tag
if MacOS.version >= :lion MacOS.cat
MacOS.cat
elsif MacOS.version == :snow_leopard
Hardware::CPU.is_64_bit? ? :snow_leopard : :snow_leopard_32
else
"#{MacOS.cat}_64".to_sym
end
end end
end end

15
Library/Homebrew/formula.rb
View File

@ -1034,7 +1034,7 @@ class Formula
# called or when brewing a formula. # called or when brewing a formula.
# This is optional. You can use all the vars like #{version} here. # This is optional. You can use all the vars like #{version} here.
# EOS # EOS
# s += "Some issue only on older systems" if MacOS.version < :mountain_lion # s += "Some issue only on older systems" if MacOS.version < :el_capitan
# s # s
# end</pre> # end</pre>
def caveats def caveats
@ -2350,12 +2350,9 @@ class Formula
# <pre># Optional and enforce that boost is built with `--with-c++11`. # <pre># Optional and enforce that boost is built with `--with-c++11`.
# depends_on "boost" => [:optional, "with-c++11"]</pre> # depends_on "boost" => [:optional, "with-c++11"]</pre>
# <pre># If a dependency is only needed in certain cases: # <pre># If a dependency is only needed in certain cases:
# depends_on "sqlite" if MacOS.version == :leopard # depends_on "sqlite" if MacOS.version == :mavericks
# depends_on :xcode # If the formula really needs full Xcode. # depends_on :xcode # If the formula really needs full Xcode.
# depends_on :macos => :lion # Needs at least OS X Lion (10.7). # depends_on :macos => :mojave # Needs at least OS X Lion (10.14).
# depends_on :arch => :intel # If this formula only builds on Intel architecture.
# depends_on :arch => :x86_64 # If this formula only builds on Intel x86 64-bit.
# depends_on :arch => :ppc # Only builds on PowerPC?
# depends_on :x11 => :optional # X11/XQuartz components. # depends_on :x11 => :optional # X11/XQuartz components.
# depends_on :osxfuse # Permits the use of the upstream signed binary or our source package. # depends_on :osxfuse # Permits the use of the upstream signed binary or our source package.
# depends_on :tuntap # Does the same thing as above. This is vital for Yosemite and above.</pre> # depends_on :tuntap # Does the same thing as above. This is vital for Yosemite and above.</pre>
@ -2366,8 +2363,6 @@ class Formula
# depends_on "python3" => :optional</pre> # depends_on "python3" => :optional</pre>
# <pre># Python 2.7: # <pre># Python 2.7:
# depends_on "python@2"</pre> # depends_on "python@2"</pre>
# <pre># Python 2.7 but use system Python where possible
# depends_on "python@2" if MacOS.version <= :snow_leopard</pre>
def depends_on(dep) def depends_on(dep)
specs.each { |spec| spec.depends_on(dep) } specs.each { |spec| spec.depends_on(dep) }
end end
@ -2511,10 +2506,14 @@ class Formula
# end</pre> # end</pre>
def fails_with(compiler, &block) def fails_with(compiler, &block)
odisabled "fails_with :gcc_4_0" if compiler == :gcc_4_0 odisabled "fails_with :gcc_4_0" if compiler == :gcc_4_0
odisabled "fails_with :gcc_4_2" if compiler == :gcc_4_2
odisabled "fails_with :gcc" if compiler == :gcc && !block_given?
specs.each { |spec| spec.fails_with(compiler, &block) } specs.each { |spec| spec.fails_with(compiler, &block) }
end end
def needs(*standards) def needs(*standards)
odisabled "needs :cxx11" if standards.include?(:cxx11)
odisabled "needs :cxx14" if standards.include?(:cxx14)
specs.each { |spec| spec.needs(*standards) } specs.each { |spec| spec.needs(*standards) }
end end

12
Library/Homebrew/hardware.rb
View File

@ -117,18 +117,6 @@ module Hardware
def feature?(name) def feature?(name)
features.include?(name) features.include?(name)
end end
def can_run?(arch)
if is_32_bit?
arch_32_bit == arch
elsif intel?
(INTEL_32BIT_ARCHS + INTEL_64BIT_ARCHS).include?(arch)
elsif ppc?
(PPC_32BIT_ARCHS + PPC_64BIT_ARCHS).include?(arch)
else
false
end
end
end end
end end

5
Library/Homebrew/language/haskell.rb
View File

@ -1,11 +1,6 @@
module Language module Language
module Haskell module Haskell
module Cabal module Cabal
def self.included(base)
# use llvm-gcc on Lion or below, as when building GHC)
base.fails_with(:clang) if MacOS.version <= :lion
end
def cabal_sandbox(options = {}) def cabal_sandbox(options = {})
pwd = Pathname.pwd pwd = Pathname.pwd
home = options[:home] || pwd home = options[:home] || pwd

24
Library/Homebrew/os/mac.rb
View File

@ -167,30 +167,6 @@ module OS
end end
STANDARD_COMPILERS = { STANDARD_COMPILERS = {
"3.1.4" => { gcc_4_2_build: 5577 },
"3.2.6" => { gcc_4_2_build: 5666, clang: "1.7", clang_build: 77 },
"4.0" => { gcc_4_2_build: 5666, clang: "2.0", clang_build: 137 },
"4.0.1" => { gcc_4_2_build: 5666, clang: "2.0", clang_build: 137 },
"4.0.2" => { gcc_4_2_build: 5666, clang: "2.0", clang_build: 137 },
"4.2" => { clang: "3.0", clang_build: 211 },
"4.3" => { clang: "3.1", clang_build: 318 },
"4.3.1" => { clang: "3.1", clang_build: 318 },
"4.3.2" => { clang: "3.1", clang_build: 318 },
"4.3.3" => { clang: "3.1", clang_build: 318 },
"4.4" => { clang: "4.0", clang_build: 421 },
"4.4.1" => { clang: "4.0", clang_build: 421 },
"4.5" => { clang: "4.1", clang_build: 421 },
"4.5.1" => { clang: "4.1", clang_build: 421 },
"4.5.2" => { clang: "4.1", clang_build: 421 },
"4.6" => { clang: "4.2", clang_build: 425 },
"4.6.1" => { clang: "4.2", clang_build: 425 },
"4.6.2" => { clang: "4.2", clang_build: 425 },
"4.6.3" => { clang: "4.2", clang_build: 425 },
"5.0" => { clang: "5.0", clang_build: 500 },
"5.0.1" => { clang: "5.0", clang_build: 500 },
"5.0.2" => { clang: "5.0", clang_build: 500 },
"5.1" => { clang: "5.1", clang_build: 503 },
"5.1.1" => { clang: "5.1", clang_build: 503 },
"6.0" => { clang: "6.0", clang_build: 600 }, "6.0" => { clang: "6.0", clang_build: 600 },
"6.0.1" => { clang: "6.0", clang_build: 600 }, "6.0.1" => { clang: "6.0", clang_build: 600 },
"6.1" => { clang: "6.0", clang_build: 600 }, "6.1" => { clang: "6.0", clang_build: 600 },

36
Library/Homebrew/os/mac/architecture_list.rb
View File

@ -1,49 +1,15 @@
require "hardware" require "hardware"
module ArchitectureListExtension module ArchitectureListExtension
# @private
def fat?
length > 1
end
# @private
def intel_universal?
intersects_all?(Hardware::CPU::INTEL_32BIT_ARCHS, Hardware::CPU::INTEL_64BIT_ARCHS)
end
# @private
def ppc_universal?
intersects_all?(Hardware::CPU::PPC_32BIT_ARCHS, Hardware::CPU::PPC_64BIT_ARCHS)
end
# Old-style 32-bit PPC/Intel universal, e.g. ppc7400 and i386
# @private
def cross_universal?
intersects_all?(Hardware::CPU::PPC_32BIT_ARCHS, Hardware::CPU::INTEL_32BIT_ARCHS)
end
# @private # @private
def universal? def universal?
intel_universal? || ppc_universal? || cross_universal? intersects_all?(Hardware::CPU::INTEL_32BIT_ARCHS, Hardware::CPU::INTEL_64BIT_ARCHS)
end
def ppc?
(Hardware::CPU::PPC_32BIT_ARCHS + Hardware::CPU::PPC_64BIT_ARCHS).any? { |a| include? a }
end
# @private
def remove_ppc!
(Hardware::CPU::PPC_32BIT_ARCHS + Hardware::CPU::PPC_64BIT_ARCHS).each { |a| delete a }
end end
def as_arch_flags def as_arch_flags
map { |a| "-arch #{a}" }.join(" ") map { |a| "-arch #{a}" }.join(" ")
end end
def as_cmake_arch_flags
join(";")
end
protected protected
def intersects_all?(*set) def intersects_all?(*set)

2
Library/Homebrew/os/mac/sdk.rb
View File

@ -84,8 +84,6 @@ module OS
@sdk_prefix ||= begin @sdk_prefix ||= begin
# Xcode.prefix is pretty smart, so let's look inside to find the sdk # Xcode.prefix is pretty smart, so let's look inside to find the sdk
sdk_prefix = "#{Xcode.prefix}/Platforms/MacOSX.platform/Developer/SDKs" sdk_prefix = "#{Xcode.prefix}/Platforms/MacOSX.platform/Developer/SDKs"
# Xcode < 4.3 style
sdk_prefix = "/Developer/SDKs" unless File.directory? sdk_prefix
# Finally query Xcode itself (this is slow, so check it last) # Finally query Xcode itself (this is slow, so check it last)
sdk_platform_path = Utils.popen_read(DevelopmentTools.locate("xcrun"), "--show-sdk-platform-path").chomp sdk_platform_path = Utils.popen_read(DevelopmentTools.locate("xcrun"), "--show-sdk-platform-path").chomp
sdk_prefix = File.join(sdk_platform_path, "Developer", "SDKs") unless File.directory? sdk_prefix sdk_prefix = File.join(sdk_platform_path, "Developer", "SDKs") unless File.directory? sdk_prefix

17
Library/Homebrew/os/mac/version.rb
View File

@ -4,17 +4,12 @@ module OS
module Mac module Mac
class Version < ::Version class Version < ::Version
SYMBOLS = { SYMBOLS = {
mojave: "10.14", mojave: "10.14",
high_sierra: "10.13", high_sierra: "10.13",
sierra: "10.12", sierra: "10.12",
el_capitan: "10.11", el_capitan: "10.11",
yosemite: "10.10", yosemite: "10.10",
mavericks: "10.9", mavericks: "10.9",
mountain_lion: "10.8",
lion: "10.7",
snow_leopard: "10.6",
leopard_64: "10.5",
leopard: "10.5",
}.freeze }.freeze
def self.from_symbol(sym) def self.from_symbol(sym)

72
Library/Homebrew/os/mac/xcode.rb
View File

@ -9,10 +9,6 @@ module OS
def latest_version def latest_version
case MacOS.version case MacOS.version
when "10.5" then "3.1.4"
when "10.6" then "3.2.6"
when "10.7" then "4.6.3"
when "10.8" then "5.1.1"
when "10.9" then "6.2" when "10.9" then "6.2"
when "10.10" then "7.2.1" when "10.10" then "7.2.1"
when "10.11" then "8.2.1" when "10.11" then "8.2.1"
@ -59,7 +55,7 @@ module OS
end end
def without_clt? def without_clt?
version >= "4.3" && !MacOS::CLT.installed? !MacOS::CLT.installed?
end end
# Returns a Pathname object corresponding to Xcode.app's Developer # Returns a Pathname object corresponding to Xcode.app's Developer
@ -80,8 +76,6 @@ module OS
end end
def toolchain_path def toolchain_path
return if version < "4.3"
Pathname.new("#{prefix}/Toolchains/XcodeDefault.xctoolchain") Pathname.new("#{prefix}/Toolchains/XcodeDefault.xctoolchain")
end end
@ -110,14 +104,14 @@ module OS
end end
def update_instructions def update_instructions
if MacOS.version >= "10.9" && !OS::Mac.prerelease? if OS::Mac.prerelease?
<<~EOS <<~EOS
Xcode can be updated from the App Store. Xcode can be updated from:
https://developer.apple.com/download/more/
EOS EOS
else else
<<~EOS <<~EOS
Xcode can be updated from Xcode can be updated from the App Store.
https://developer.apple.com/download/more/
EOS EOS
end end
end end
@ -169,18 +163,6 @@ module OS
# comparable version. # comparable version.
case (DevelopmentTools.clang_version.to_f * 10).to_i case (DevelopmentTools.clang_version.to_f * 10).to_i
when 0 then "dunno" when 0 then "dunno"
when 1..14 then "3.2.2"
when 15 then "3.2.4"
when 16 then "3.2.5"
when 17..20 then "4.0"
when 21 then "4.1"
when 22..30 then "4.2"
when 31 then "4.3"
when 40 then "4.4"
when 41 then "4.5"
when 42 then "4.6"
when 50 then "5.0"
when 51 then "5.1"
when 60 then "6.0" when 60 then "6.0"
when 61 then "6.1" when 61 then "6.1"
when 70 then "7.0" when 70 then "7.0"
@ -194,24 +176,14 @@ module OS
end end
end end
def provides_gcc?
version < "4.3"
end
def default_prefix? def default_prefix?
if version < "4.3" prefix.to_s == "/Applications/Xcode.app/Contents/Developer"
prefix.to_s.start_with? "/Developer"
else
prefix.to_s == "/Applications/Xcode.app/Contents/Developer"
end
end end
end end
module CLT module CLT
module_function module_function
STANDALONE_PKG_ID = "com.apple.pkg.DeveloperToolsCLILeo".freeze
FROM_XCODE_PKG_ID = "com.apple.pkg.DeveloperToolsCLI".freeze
# The original Mavericks CLT package ID # The original Mavericks CLT package ID
EXECUTABLE_PKG_ID = "com.apple.pkg.CLTools_Executables".freeze EXECUTABLE_PKG_ID = "com.apple.pkg.CLTools_Executables".freeze
MAVERICKS_NEW_PKG_ID = "com.apple.pkg.CLTools_Base".freeze # obsolete MAVERICKS_NEW_PKG_ID = "com.apple.pkg.CLTools_Base".freeze # obsolete
@ -220,8 +192,7 @@ module OS
"/Library/Developer/CommandLineTools/Packages/macOS_SDK_headers_for_macOS_:macos_version.pkg".freeze "/Library/Developer/CommandLineTools/Packages/macOS_SDK_headers_for_macOS_:macos_version.pkg".freeze
HEADER_PKG_ID = "com.apple.pkg.macOS_SDK_headers_for_macOS_10.14".freeze HEADER_PKG_ID = "com.apple.pkg.macOS_SDK_headers_for_macOS_10.14".freeze
# Returns true even if outdated tools are installed, e.g. # Returns true even if outdated tools are installed
# tools from Xcode 4.x on 10.9
def installed? def installed?
!version.null? !version.null?
end end
@ -257,16 +228,10 @@ module OS
<<~EOS <<~EOS
Update them from Software Update in System Preferences. Update them from Software Update in System Preferences.
EOS EOS
elsif MacOS.version >= "10.9" else
<<~EOS <<~EOS
Update them from Software Update in the App Store. Update them from Software Update in the App Store.
EOS EOS
elsif MacOS.version == "10.8" || MacOS.version == "10.7"
<<~EOS
The standalone package can be obtained from
https://developer.apple.com/download/more/
or it can be installed via Xcode's preferences.
EOS
end end
end end
@ -280,9 +245,7 @@ module OS
when "10.12" then "900.0.39.2" when "10.12" then "900.0.39.2"
when "10.11" then "800.0.42.1" when "10.11" then "800.0.42.1"
when "10.10" then "700.1.81" when "10.10" then "700.1.81"
when "10.9" then "600.0.57" else "600.0.57"
when "10.8" then "503.0.40"
else "425.0.28"
end end
end end
@ -296,8 +259,6 @@ module OS
end end
def below_minimum_version? def below_minimum_version?
# Lion was the first version of OS X to ship with a CLT
return false if MacOS.version < :lion
return false unless installed? return false unless installed?
version < minimum_version version < minimum_version
@ -311,9 +272,6 @@ module OS
end end
def detect_clang_version def detect_clang_version
# Lion was the first version of OS X to ship with a CLT
return if MacOS.version < :lion
path = if MacOS.version >= :mavericks path = if MacOS.version >= :mavericks
"#{PKG_PATH}/usr/bin/clang" "#{PKG_PATH}/usr/bin/clang"
else else
@ -349,17 +307,9 @@ module OS
end end
def detect_version def detect_version
# CLT isn't a distinct entity pre-4.3, and pkgutil doesn't exist
# at all on Tiger, so just count it as installed if Xcode is installed
if MacOS::Xcode.installed? && MacOS::Xcode.version < "3.0"
return MacOS::Xcode.version
end
version = nil version = nil
[EXECUTABLE_PKG_ID, MAVERICKS_NEW_PKG_ID, STANDALONE_PKG_ID, FROM_XCODE_PKG_ID].each do |id| [EXECUTABLE_PKG_ID, MAVERICKS_NEW_PKG_ID].each do |id|
if MacOS.version >= :mavericks next unless File.exist?("#{PKG_PATH}/usr/bin/clang")
next unless File.exist?("#{PKG_PATH}/usr/bin/clang")
end
version = MacOS.pkgutil_info(id)[/version: (.+)$/, 1] version = MacOS.pkgutil_info(id)[/version: (.+)$/, 1]
break if version break if version
end end

56
Library/Homebrew/os/mac/xquartz.rb
View File

@ -7,7 +7,6 @@ module OS
DEFAULT_BUNDLE_PATH = Pathname.new("Applications/Utilities/XQuartz.app").freeze DEFAULT_BUNDLE_PATH = Pathname.new("Applications/Utilities/XQuartz.app").freeze
FORGE_BUNDLE_ID = "org.macosforge.xquartz.X11".freeze FORGE_BUNDLE_ID = "org.macosforge.xquartz.X11".freeze
APPLE_BUNDLE_ID = "org.x.X11".freeze
FORGE_PKG_ID = "org.macosforge.xquartz.pkg".freeze FORGE_PKG_ID = "org.macosforge.xquartz.pkg".freeze
PKGINFO_VERSION_MAP = { PKGINFO_VERSION_MAP = {
@ -44,17 +43,12 @@ module OS
def detect_version def detect_version
if (path = bundle_path) && path.exist? && (version = version_from_mdls(path)) if (path = bundle_path) && path.exist? && (version = version_from_mdls(path))
version version
elsif prefix.to_s == "/usr/X11" || prefix.to_s == "/usr/X11R6"
guess_system_version
else else
version_from_pkgutil version_from_pkgutil
end end
end end
def minimum_version def minimum_version
version = guess_system_version
return version unless version == "dunno"
# Update this a little later than latest_version to give people # Update this a little later than latest_version to give people
# time to upgrade. # time to upgrade.
"2.7.11" "2.7.11"
@ -63,12 +57,7 @@ module OS
# - https://xquartz.macosforge.org/trac/wiki # - https://xquartz.macosforge.org/trac/wiki
# - https://xquartz.macosforge.org/trac/wiki/Releases # - https://xquartz.macosforge.org/trac/wiki/Releases
def latest_version def latest_version
case MacOS.version "2.7.11"
when "10.5"
"2.6.3"
else
"2.7.11"
end
end end
def bundle_path def bundle_path
@ -77,7 +66,7 @@ module OS
# Ask Spotlight where XQuartz is. If the user didn't install XQuartz # Ask Spotlight where XQuartz is. If the user didn't install XQuartz
# in the conventional place, this is our only option. # in the conventional place, this is our only option.
MacOS.app_with_bundle_id(FORGE_BUNDLE_ID, APPLE_BUNDLE_ID) MacOS.app_with_bundle_id(FORGE_BUNDLE_ID)
end end
def version_from_mdls(path) def version_from_mdls(path)
@ -87,18 +76,6 @@ module OS
version unless version.empty? version unless version.empty?
end end
# The XQuartz that Apple shipped in OS X through 10.7 does not have a
# pkg-util entry, so if Spotlight indexing is disabled we must make an
# educated guess as to what version is installed.
def guess_system_version
case MacOS.version
when "10.5" then "2.1.6"
when "10.6" then "2.3.6"
when "10.7" then "2.6.3"
else "dunno"
end
end
# Upstream XQuartz *does* have a pkg-info entry, so if we can't get it # Upstream XQuartz *does* have a pkg-info entry, so if we can't get it
# from mdls, we can try pkgutil. This is very slow. # from mdls, we can try pkgutil. This is very slow.
def version_from_pkgutil def version_from_pkgutil
@ -106,23 +83,12 @@ module OS
PKGINFO_VERSION_MAP.fetch(str, str) PKGINFO_VERSION_MAP.fetch(str, str)
end end
def provided_by_apple?
[FORGE_BUNDLE_ID, APPLE_BUNDLE_ID].find do |id|
MacOS.app_with_bundle_id(id)
end == APPLE_BUNDLE_ID
end
# This should really be private, but for compatibility reasons it must # This should really be private, but for compatibility reasons it must
# remain public. New code should use `MacOS::X11.bin`, `MacOS::X11.lib` and # remain public. New code should use `MacOS::X11.bin`, `MacOS::X11.lib` and
# `MacOS::X11.include` instead, as that accounts for Xcode-only systems. # `MacOS::X11.include` instead, as that accounts for Xcode-only systems.
def prefix def prefix
@prefix ||= if Pathname.new("/opt/X11/lib/libpng.dylib").exist? @prefix ||= if Pathname.new("/opt/X11/lib/libpng.dylib").exist?
Pathname.new("/opt/X11") Pathname.new("/opt/X11")
elsif Pathname.new("/usr/X11/lib/libpng.dylib").exist?
Pathname.new("/usr/X11")
# X11 doesn't include libpng on Tiger
elsif Pathname.new("/usr/X11R6/lib/libX11.dylib").exist?
Pathname.new("/usr/X11R6")
end end
end end
@ -132,34 +98,20 @@ module OS
def outdated? def outdated?
return false unless installed? return false unless installed?
return false if provided_by_apple?
version < latest_version version < latest_version
end end
# If XQuartz and/or the CLT are installed, headers will be found under
# `/opt/X11/include` or `/usr/X11/include`. For Xcode-only systems, they are
# found in the SDK, so we use {.sdk_path} for both the headers and libraries.
# Confusingly, executables (e.g. config scripts) are only found under
# `/opt/X11/bin` or `/usr/X11/bin` in all cases.
def effective_prefix
if provided_by_apple? && Xcode.without_clt?
Pathname.new("#{OS::Mac.sdk_path}/usr/X11")
else
prefix
end
end
def bin def bin
prefix/"bin" prefix/"bin"
end end
def include def include
effective_prefix/"include" prefix/"include"
end end
def lib def lib
effective_prefix/"lib" prefix/"lib"
end end
def share def share

6
Library/Homebrew/requirements/xcode_requirement.rb
View File

@ -28,13 +28,9 @@ class XcodeRequirement < Requirement
Xcode#{version} cannot be installed on macOS #{MacOS.version}. Xcode#{version} cannot be installed on macOS #{MacOS.version}.
You must upgrade your version of macOS. You must upgrade your version of macOS.
EOS EOS
elsif MacOS.version >= :lion
message + <<~EOS
Xcode can be installed from the App Store.
EOS
else else
message + <<~EOS message + <<~EOS
Xcode can be installed from #{Formatter.url("https://developer.apple.com/download/more/")}. Xcode can be installed from the App Store.
EOS EOS
end end
end end

7
Library/Homebrew/rubocops/lines.rb
View File

@ -362,13 +362,6 @@ module RuboCop
problem "`depends_on` can take requirement classes instead of instances" problem "`depends_on` can take requirement classes instead of instances"
end end
os = [:leopard?, :snow_leopard?, :lion?, :mountain_lion?]
os.each do |version|
find_instance_method_call(body_node, "MacOS", version) do |method|
problem "\"#{method.source}\" is deprecated, use a comparison to MacOS.version instead"
end
end
find_instance_method_call(body_node, "Dir", :[]) do |method| find_instance_method_call(body_node, "Dir", :[]) do |method|
next unless parameters(method).size == 1 next unless parameters(method).size == 1

2
Library/Homebrew/sandbox.rb
View File

@ -5,7 +5,7 @@ class Sandbox
SANDBOX_EXEC = "/usr/bin/sandbox-exec".freeze SANDBOX_EXEC = "/usr/bin/sandbox-exec".freeze
def self.available? def self.available?
OS.mac? && OS::Mac.version >= "10.6" && File.executable?(SANDBOX_EXEC) OS.mac? && File.executable?(SANDBOX_EXEC)
end end
def self.formula?(_formula) def self.formula?(_formula)

4
Library/Homebrew/software_spec.rb
View File

@ -209,10 +209,14 @@ class SoftwareSpec
def fails_with(compiler, &block) def fails_with(compiler, &block)
odisabled "fails_with :gcc_4_0" if compiler == :gcc_4_0 odisabled "fails_with :gcc_4_0" if compiler == :gcc_4_0
odisabled "fails_with :gcc_4_2" if compiler == :gcc_4_2
odisabled "fails_with :gcc" if compiler == :gcc && !block_given?
compiler_failures << CompilerFailure.create(compiler, &block) compiler_failures << CompilerFailure.create(compiler, &block)
end end
def needs(*standards) def needs(*standards)
odisabled "needs :cxx11" if standards.include?(:cxx11)
odisabled "needs :cxx14" if standards.include?(:cxx14)
standards.each do |standard| standards.each do |standard|
compiler_failures.concat CompilerFailure.for_standard(standard) compiler_failures.concat CompilerFailure.for_standard(standard)
end end

23
Library/Homebrew/test/ENV_spec.rb
View File

@ -126,10 +126,8 @@ shared_examples EnvActivation do
describe "#compiler" do describe "#compiler" do
it "allows switching compilers" do it "allows switching compilers" do
[:clang, :gcc_4_2].each do |compiler| subject.public_send("gcc-6")
subject.public_send(compiler) expect(subject.compiler).to eq("gcc-6")
expect(subject.compiler).to eq(compiler)
end
end end
end end
@ -162,12 +160,6 @@ shared_examples EnvActivation do
expect(subject.compiler_any_clang?(:llvm_clang)).to be true expect(subject.compiler_any_clang?(:llvm_clang)).to be true
end end
end end
describe "#compiler_with_cxx11_support?" do
it "returns true for gcc-4.9" do
expect(subject.compiler_with_cxx11_support?("gcc-4.9")).to be true
end
end
end end
describe Stdenv do describe Stdenv do
@ -183,17 +175,6 @@ describe Superenv do
end end
describe "#cxx11" do describe "#cxx11" do
it "raises an error when the compiler isn't supported" do
%w[gcc gcc-4.7].each do |compiler|
subject["HOMEBREW_CC"] = compiler
expect { subject.cxx11 }
.to raise_error(/The selected compiler doesn't support C\+\+11:/)
expect(subject["HOMEBREW_CCCFG"]).to be nil
end
end
it "supports gcc-5" do it "supports gcc-5" do
subject["HOMEBREW_CC"] = "gcc-5" subject["HOMEBREW_CC"] = "gcc-5"
subject.cxx11 subject.cxx11

9
Library/Homebrew/test/compiler_failure_spec.rb
View File

@ -6,18 +6,17 @@ describe CompilerFailure do
describe "::create" do describe "::create" do
it "creates a failure when given a symbol" do it "creates a failure when given a symbol" do
failure = described_class.create(:clang) failure = described_class.create(:clang)
expect(failure).to fail_with(double("Compiler", name: :clang, version: 425)) expect(failure).to fail_with(double("Compiler", name: :clang, version: 600))
end end
it "can be given a build number in a block" do it "can be given a build number in a block" do
failure = described_class.create(:clang) { build 211 } failure = described_class.create(:clang) { build 700 }
expect(failure).to fail_with(double("Compiler", name: :clang, version: 210)) expect(failure).to fail_with(double("Compiler", name: :clang, version: 700))
expect(failure).not_to fail_with(double("Compiler", name: :clang, version: 318))
end end
it "can be given an empty block" do it "can be given an empty block" do
failure = described_class.create(:clang) {} failure = described_class.create(:clang) {}
expect(failure).to fail_with(double("Compiler", name: :clang, version: 425)) expect(failure).to fail_with(double("Compiler", name: :clang, version: 600))
end end
it "creates a failure when given a hash" do it "creates a failure when given a hash" do

33
Library/Homebrew/test/compiler_selector_spec.rb
View File

@ -4,14 +4,13 @@ require "software_spec"
describe CompilerSelector do describe CompilerSelector do
subject { described_class.new(software_spec, versions, compilers) } subject { described_class.new(software_spec, versions, compilers) }
let(:compilers) { [:clang, :gcc_4_2, :gnu] } let(:compilers) { [:clang, :gnu] }
let(:software_spec) { SoftwareSpec.new } let(:software_spec) { SoftwareSpec.new }
let(:cc) { :clang } let(:cc) { :clang }
let(:versions) do let(:versions) do
double( double(
gcc_4_2_build_version: Version.create("5666"), llvm_build_version: Version::NULL,
llvm_build_version: Version::NULL, clang_build_version: Version.create("600"),
clang_build_version: Version.create("425"),
) )
end end
@ -37,36 +36,10 @@ describe CompilerSelector do
it "still returns gcc-7 if it fails with gcc without a specific version" do it "still returns gcc-7 if it fails with gcc without a specific version" do
software_spec.fails_with(:clang) software_spec.fails_with(:clang)
software_spec.fails_with(:gcc_4_2)
expect(subject.compiler).to eq("gcc-7") expect(subject.compiler).to eq("gcc-7")
end end
it "returns gcc if it fails with clang and llvm" do
software_spec.fails_with(:clang)
expect(subject.compiler).to eq(:gcc_4_2)
end
it "returns clang if it fails with gcc and llvm" do
software_spec.fails_with(:gcc_4_2)
expect(subject.compiler).to eq(:clang)
end
example "returns gcc if it fails with a specific gcc version" do
software_spec.fails_with(:clang)
software_spec.fails_with(gcc: "7")
expect(subject.compiler).to eq(:gcc_4_2)
end
example "returns a lower version of gcc if it fails with the highest version" do
software_spec.fails_with(:clang)
software_spec.fails_with(:gcc_4_2)
software_spec.fails_with(gcc: "7")
expect(subject.compiler).to eq("gcc-6")
end
it "raises an error when gcc or llvm is missing" do it "raises an error when gcc or llvm is missing" do
allow(versions).to receive(:gcc_4_2_build_version).and_return(Version::NULL)
software_spec.fails_with(:clang) software_spec.fails_with(:clang)
software_spec.fails_with(gcc: "7") software_spec.fails_with(gcc: "7")
software_spec.fails_with(gcc: "6") software_spec.fails_with(gcc: "6")

10
Library/Homebrew/test/cxxstdlib_spec.rb
View File

@ -3,21 +3,13 @@ require "cxxstdlib"
describe CxxStdlib do describe CxxStdlib do
let(:clang) { described_class.create(:libstdcxx, :clang) } let(:clang) { described_class.create(:libstdcxx, :clang) }
let(:gcc) { described_class.create(:libstdcxx, :gcc) }
let(:gcc42) { described_class.create(:libstdcxx, :gcc_4_2) }
let(:gcc6) { described_class.create(:libstdcxx, "gcc-6") } let(:gcc6) { described_class.create(:libstdcxx, "gcc-6") }
let(:gcc7) { described_class.create(:libstdcxx, "gcc-7") } let(:gcc7) { described_class.create(:libstdcxx, "gcc-7") }
let(:lcxx) { described_class.create(:libcxx, :clang) } let(:lcxx) { described_class.create(:libcxx, :clang) }
let(:purec) { described_class.create(nil, :clang) } let(:purec) { described_class.create(nil, :clang) }
describe "#compatible_with?" do describe "#compatible_with?" do
specify "Apple libstdcxx intercompatibility" do
expect(clang).to be_compatible_with(gcc)
expect(clang).to be_compatible_with(gcc42)
end
specify "compatibility with itself" do specify "compatibility with itself" do
expect(gcc).to be_compatible_with(gcc)
expect(gcc7).to be_compatible_with(gcc7) expect(gcc7).to be_compatible_with(gcc7)
expect(clang).to be_compatible_with(clang) expect(clang).to be_compatible_with(clang)
end end
@ -49,8 +41,6 @@ describe CxxStdlib do
describe "#apple_compiler?" do describe "#apple_compiler?" do
it "returns true for Apple compilers" do it "returns true for Apple compilers" do
expect(clang).to be_an_apple_compiler expect(clang).to be_an_apple_compiler
expect(gcc).to be_an_apple_compiler
expect(gcc42).to be_an_apple_compiler
end end
it "returns false for non-Apple compilers" do it "returns false for non-Apple compilers" do

75
Library/Homebrew/test/hardware/cpu_spec.rb
View File

@ -5,7 +5,6 @@ describe Hardware::CPU do
let(:cpu_types) { let(:cpu_types) {
[ [
:intel, :intel,
:ppc,
:dunno, :dunno,
] ]
} }
@ -37,78 +36,4 @@ describe Hardware::CPU do
expect(cpu_families).to include described_class.family expect(cpu_families).to include described_class.family
end end
end end
describe "::can_run?" do
subject { described_class }
matcher :be_able_to_run do |arch|
match do |expected|
allow(expected).to receive(:type).and_return type
allow(expected).to receive(:bits).and_return bits
expect(expected.can_run?(arch)).to be true
end
end
let(:type) { described_class.type }
let(:bits) { described_class.bits }
before do
allow(described_class).to receive(:type).and_return type
allow(described_class).to receive(:bits).and_return bits
end
context "when on an 32-bit Intel machine" do
let(:type) { :intel }
let(:bits) { 32 }
it { is_expected.to be_able_to_run :i386 }
it { is_expected.not_to be_able_to_run :x86_64 }
it { is_expected.not_to be_able_to_run :ppc32 }
it { is_expected.not_to be_able_to_run :ppc64 }
end
context "when on an 64-bit Intel machine" do
let(:type) { :intel }
let(:bits) { 64 }
it { is_expected.to be_able_to_run :i386 }
it { is_expected.to be_able_to_run :x86_64 }
it { is_expected.not_to be_able_to_run :ppc32 }
it { is_expected.not_to be_able_to_run :ppc64 }
end
context "when on a 32-bit PowerPC machine" do
let(:type) { :ppc }
let(:bits) { 32 }
it { is_expected.not_to be_able_to_run :i386 }
it { is_expected.not_to be_able_to_run :x86_64 }
it { is_expected.to be_able_to_run :ppc32 }
it { is_expected.not_to be_able_to_run :ppc64 }
end
context "when on a 64-bit PowerPC machine" do
let(:type) { :ppc }
let(:bits) { 64 }
it { is_expected.not_to be_able_to_run :i386 }
it { is_expected.not_to be_able_to_run :x86_64 }
it { is_expected.to be_able_to_run :ppc32 }
it { is_expected.to be_able_to_run :ppc64 }
end
context "when the CPU type is unknown" do
let(:type) { :dunno }
it { is_expected.not_to be_able_to_run :i386 }
it { is_expected.not_to be_able_to_run :x86_64 }
it { is_expected.not_to be_able_to_run :ppc32 }
it { is_expected.not_to be_able_to_run :ppc64 }
end
context "when the architecture is unknown" do
it { is_expected.not_to be_able_to_run :blah }
end
end
end end

15
Library/Homebrew/test/os/mac/dependency_collector_spec.rb
View File

@ -7,20 +7,7 @@ describe DependencyCollector do
described_class.clear_cache described_class.clear_cache
end end
specify "#tar_needs_xz_dependency?" do specify "Resource dependency from a '.xz' URL" do
allow(MacOS).to receive(:version).and_return(MacOS::Version.new("10.9"))
expect(described_class).not_to need_tar_xz_dependency
end
specify "Resource xz pre-Mavericks dependency" do
allow(MacOS).to receive(:version).and_return(MacOS::Version.new("10.8"))
resource = Resource.new
resource.url("https://brew.sh/foo.tar.xz")
expect(subject.add(resource)).to eq(Dependency.new("xz", [:build]))
end
specify "Resource xz Mavericks or newer dependency" do
allow(MacOS).to receive(:version).and_return(MacOS::Version.new("10.9"))
resource = Resource.new resource = Resource.new
resource.url("https://brew.sh/foo.tar.xz") resource.url("https://brew.sh/foo.tar.xz")
expect(subject.add(resource)).to be nil expect(subject.add(resource)).to be nil

56
Library/Homebrew/test/os/mac/hardware_spec.rb
View File

@ -1,56 +0,0 @@
require "hardware"
require "extend/os/mac/hardware/cpu"
describe Hardware::CPU do
describe "::can_run?" do
it "reports that Intel Macs can run Intel executables" do
allow(described_class).to receive(:type).and_return :intel
allow(described_class).to receive(:bits).and_return 64
expect(described_class.can_run?(:i386)).to be true
expect(described_class.can_run?(:x86_64)).to be true
end
it "reports that PowerPC Macs can run PowerPC executables" do
allow(described_class).to receive(:type).and_return :ppc
allow(described_class).to receive(:bits).and_return 64
expect(described_class.can_run?(:ppc)).to be true
expect(described_class.can_run?(:ppc64)).to be true
end
it "reports that 32-bit Intel Macs can't run x86_64 executables" do
allow(described_class).to receive(:type).and_return :intel
allow(described_class).to receive(:bits).and_return 32
expect(described_class.can_run?(:x86_64)).to be false
end
it "reports that 32-bit PowerPC Macs can't run ppc64 executables" do
allow(described_class).to receive(:type).and_return :ppc
allow(described_class).to receive(:bits).and_return 32
expect(described_class.can_run?(:ppc64)).to be false
end
it "reports that Intel Macs can only run 32-bit PowerPC executables on 10.6 and older" do
allow(described_class).to receive(:type).and_return :intel
allow(OS::Mac).to receive(:version).and_return OS::Mac::Version.new "10.6"
expect(described_class.can_run?(:ppc)).to be true
allow(OS::Mac).to receive(:version).and_return OS::Mac::Version.new "10.7"
expect(described_class.can_run?(:ppc)).to be false
end
it "reports that PowerPC Macs can't run Intel executables" do
allow(described_class).to receive(:type).and_return :ppc
expect(described_class.can_run?(:i386)).to be false
expect(described_class.can_run?(:x86_64)).to be false
end
it "returns false for unknown CPU types" do
allow(described_class).to receive(:type).and_return :dunno
expect(described_class.can_run?(:i386)).to be false
end
it "returns false for unknown arches" do
expect(described_class.can_run?(:blah)).to be false
end
end
end

26
Library/Homebrew/test/os/mac/mach_spec.rb
View File

@ -110,42 +110,18 @@ describe ArchitectureListExtension do
specify "universal checks" do specify "universal checks" do
expect(archs).to be_universal expect(archs).to be_universal
expect(archs).to be_intel_universal
expect(archs).to be_ppc_universal
expect(archs).to be_cross_universal
expect(archs).to be_fat
non_universal = [:i386].extend(described_class) non_universal = [:i386].extend(described_class)
expect(non_universal).not_to be_universal expect(non_universal).not_to be_universal
intel_only = [:i386, :x86_64].extend(described_class) intel_only = [:i386, :x86_64].extend(described_class)
expect(intel_only).to be_universal expect(intel_only).to be_universal
expect(intel_only).not_to be_ppc_universal
expect(intel_only).not_to be_cross_universal
ppc_only = [:ppc970, :ppc64].extend(described_class)
expect(ppc_only).to be_universal
expect(ppc_only).not_to be_intel_universal
expect(ppc_only).not_to be_cross_universal
cross = [:ppc7400, :i386].extend(described_class)
expect(cross).to be_universal
expect(cross).not_to be_intel_universal
expect(cross).not_to be_ppc_universal
end
specify "messaging flags" do
archs.remove_ppc!
expect(archs.length).to eq(2)
expect(archs.as_arch_flags).to match(/-arch i386/)
expect(archs.as_arch_flags).to match(/-arch x86_64/)
end end
specify "architecture flags" do specify "architecture flags" do
pn = dylib_path("fat") pn = dylib_path("fat")
expect(pn.archs).to be_intel_universal expect(pn.archs).to be_universal
expect(pn.archs.as_arch_flags).to eq("-arch x86_64 -arch i386") expect(pn.archs.as_arch_flags).to eq("-arch x86_64 -arch i386")
expect(pn.archs.as_cmake_arch_flags).to eq("x86_64;i386")
end end
end end

36
Library/Homebrew/test/os/mac/version_spec.rb
View File

@ -2,13 +2,13 @@ require "version"
require "os/mac/version" require "os/mac/version"
describe OS::Mac::Version do describe OS::Mac::Version do
subject { described_class.new("10.7") } subject { described_class.new("10.10") }
specify "comparison with Symbol" do specify "comparison with Symbol" do
expect(subject).to be > :snow_leopard expect(subject).to be > :mavericks
expect(subject).to be == :lion expect(subject).to be == :yosemite
expect(subject).to be === :lion # rubocop:disable Style/CaseEquality expect(subject).to be === :yosemite # rubocop:disable Style/CaseEquality
expect(subject).to be < :mountain_lion expect(subject).to be < :el_capitan
end end
specify "comparison with Fixnum" do specify "comparison with Fixnum" do
@ -17,35 +17,33 @@ describe OS::Mac::Version do
end end
specify "comparison with Float" do specify "comparison with Float" do
expect(subject).to be > 10.6 expect(subject).to be > 10.9
expect(subject).to be == 10.7 expect(subject).to be < 10.11
expect(subject).to be === 10.7 # rubocop:disable Style/CaseEquality
expect(subject).to be < 10.8
end end
specify "comparison with String" do specify "comparison with String" do
expect(subject).to be > "10.6" expect(subject).to be > "10.9"
expect(subject).to be == "10.7" expect(subject).to be == "10.10"
expect(subject).to be === "10.7" # rubocop:disable Style/CaseEquality expect(subject).to be === "10.10" # rubocop:disable Style/CaseEquality
expect(subject).to be < "10.8" expect(subject).to be < "10.11"
end end
specify "comparison with Version" do specify "comparison with Version" do
expect(subject).to be > Version.create("10.6") expect(subject).to be > Version.create("10.9")
expect(subject).to be == Version.create("10.7") expect(subject).to be == Version.create("10.10")
expect(subject).to be === Version.create("10.7") # rubocop:disable Style/CaseEquality expect(subject).to be === Version.create("10.10") # rubocop:disable Style/CaseEquality
expect(subject).to be < Version.create("10.8") expect(subject).to be < Version.create("10.11")
end end
specify "#from_symbol" do specify "#from_symbol" do
expect(described_class.from_symbol(:lion)).to eq(subject) expect(described_class.from_symbol(:yosemite)).to eq(subject)
expect { described_class.from_symbol(:foo) } expect { described_class.from_symbol(:foo) }
.to raise_error(ArgumentError) .to raise_error(ArgumentError)
end end
specify "#pretty_name" do specify "#pretty_name" do
expect(described_class.new("10.11").pretty_name).to eq("El Capitan") expect(described_class.new("10.11").pretty_name).to eq("El Capitan")
expect(described_class.new("10.8").pretty_name).to eq("Mountain Lion") expect(described_class.new("10.14").pretty_name).to eq("Mojave")
expect(described_class.new("10.10").pretty_name).to eq("Yosemite") expect(described_class.new("10.10").pretty_name).to eq("Yosemite")
end end
end end

11
Library/Homebrew/test/rubocops/lines_spec.rb
View File

@ -483,17 +483,6 @@ describe RuboCop::Cop::FormulaAudit::Miscellaneous do
RUBY RUBY
end end
it "old style OS check" do
expect_offense(<<~RUBY)
class Foo < Formula
desc "foo"
url 'https://brew.sh/foo-1.0.tgz'
depends_on :foo if MacOS.snow_leopard?
^^^^^^^^^^^^^^^^^^^ \"MacOS.snow_leopard?\" is deprecated, use a comparison to MacOS.version instead
end
RUBY
end
it "non glob DIR usage" do it "non glob DIR usage" do
expect_offense(<<~RUBY) expect_offense(<<~RUBY)
class Foo < Formula class Foo < Formula

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

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

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

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

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

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

23
Library/Homebrew/test/utils/bottles/bottles_spec.rb
View File

@ -2,26 +2,9 @@ require "utils/bottles"
describe Utils::Bottles do describe Utils::Bottles do
describe "#tag", :needs_macos do describe "#tag", :needs_macos do
it "returns :leopard_64 on Leopard Intel 64-bit" do it "returns :mavericks on Mavericks" do
allow(MacOS).to receive(:version).and_return(MacOS::Version.new("10.5")) allow(MacOS).to receive(:version).and_return(MacOS::Version.new("10.9"))
allow(Hardware::CPU).to receive(:type).and_return(:intel) expect(described_class.tag).to eq(:mavericks)
expect(described_class.tag).to eq(:leopard_64)
end
it "returns :snow_leopard on Snow Leopard 64-bit" do
allow(MacOS).to receive(:version).and_return(MacOS::Version.new("10.6"))
allow(Hardware::CPU).to receive(:is_64_bit?).and_return(true)
expect(described_class.tag).to eq(:snow_leopard)
end
it "returns :lion on Lion" do
allow(MacOS).to receive(:version).and_return(MacOS::Version.new("10.7"))
expect(described_class.tag).to eq(:lion)
end
it "returns :mountain_lion on Mountain Lion" do
allow(MacOS).to receive(:version).and_return(MacOS::Version.new("10.8"))
expect(described_class.tag).to eq(:mountain_lion)
end end
end end
end end

14
Library/Homebrew/test/utils/bottles/collector_spec.rb
View File

@ -3,9 +3,9 @@ require "utils/bottles"
describe Utils::Bottles::Collector do describe Utils::Bottles::Collector do
describe "#fetch_checksum_for" do describe "#fetch_checksum_for" do
it "returns passed tags" do it "returns passed tags" do
subject[:lion] = "foo" subject[:yosemite] = "foo"
subject[:mountain_lion] = "bar" subject[:el_captain] = "bar"
expect(subject.fetch_checksum_for(:mountain_lion)).to eq(["bar", :mountain_lion]) expect(subject.fetch_checksum_for(:el_captain)).to eq(["bar", :el_captain])
end end
it "returns nil if empty" do it "returns nil if empty" do
@ -13,14 +13,14 @@ describe Utils::Bottles::Collector do
end end
it "returns nil when there is no match" do it "returns nil when there is no match" do
subject[:lion] = "foo" subject[:yosemite] = "foo"
expect(subject.fetch_checksum_for(:foo)).to be nil expect(subject.fetch_checksum_for(:foo)).to be nil
end end
it "uses older tags when needed", :needs_macos do it "uses older tags when needed", :needs_macos do
subject[:lion] = "foo" subject[:yosemite] = "foo"
expect(subject.fetch_checksum_for(:mountain_lion)).to eq(["foo", :lion]) expect(subject.fetch_checksum_for(:yosemite)).to eq(["foo", :yosemite])
expect(subject.fetch_checksum_for(:snow_leopard)).to be nil expect(subject.fetch_checksum_for(:mavericks)).to be nil
end end
end end
end end

23
docs/Common-Issues.md
View File

@ -4,7 +4,6 @@ This is a list of commonly encountered problems, known issues, and their solutio
### `brew` complains about absence of "Command Line Tools" ### `brew` complains about absence of "Command Line Tools"
You need to have the Xcode Command Line Utilities installed (and updated): run `xcode-select --install` in the terminal. You need to have the Xcode Command Line Utilities installed (and updated): run `xcode-select --install` in the terminal.
(In OS X prior to 10.9, the "Command Line Tools" package can alternatively be installed from within Xcode. `⌘,` will get you to preferences. Visit the "Downloads" tab and hit the install button next to "Command Line Tools".)
### Ruby: `bad interpreter: /usr/bin/ruby^M: no such file or directory` ### Ruby: `bad interpreter: /usr/bin/ruby^M: no such file or directory`
You cloned with `git`, and your Git configuration is set to use Windows line endings. See this page: <https://help.github.com/articles/dealing-with-line-endings> You cloned with `git`, and your Git configuration is set to use Windows line endings. See this page: <https://help.github.com/articles/dealing-with-line-endings>
@ -29,28 +28,6 @@ cd $(brew --repository)/Library
git clean -fd git clean -fd
``` ```
### Ruby: `invalid multibyte escape: /^\037\213/`
You see an error similar to:
```
Error: /usr/local/Library/Homebrew/download_strategy.rb:84: invalid multibyte escape: /^\037\213/
invalid multibyte escape: /^\037\235/
```
In the past, Homebrew assumed that `/usr/bin/ruby` was Ruby 1.8. On OS X 10.9, it is now Ruby 2.0. There are various incompatibilities between the two versions, so if you upgrade to OS X 10.9 while using a sufficiently old version of Homebrew, you will encounter errors.
The incompatibilities have been addressed in more recent versions of Homebrew, and instead of making assumptions about `/usr/bin/ruby`, it uses the executable inside macOS's Ruby framework or a vendored Ruby.
To recover from this situation, do the following:
```sh
cd $(brew --prefix)
git fetch origin
git reset --hard FETCH_HEAD
brew update
```
### `launchctl` refuses to load launchd plist files ### `launchctl` refuses to load launchd plist files
When trying to load a plist file into launchctl, you receive an error that resembles When trying to load a plist file into launchctl, you receive an error that resembles

4
docs/Gems,-Eggs-and-Perl-Modules.md
View File

@ -7,8 +7,8 @@ add-ons available to all users:
* `/Library/Python` * `/Library/Python`
* `/Library/Perl` * `/Library/Perl`
Starting with OS X Lion (10.7), you need `sudo` to install to these like You need `sudo` to install to these like so: `sudo gem install`,
so: `sudo gem install`, `sudo easy_install` or `sudo cpan -i`. `sudo easy_install` or `sudo cpan -i`.
An option to avoid sudo is to use an access control list. For example: An option to avoid sudo is to use an access control list. For example:

4
docs/Installation.md
View File

@ -10,6 +10,7 @@ installed to `/usr/local` already. It tells you exactly what it will do before
it does it too. You have to confirm everything it will do before it starts. it does it too. You have to confirm everything it will do before it starts.
## macOS Requirements ## macOS Requirements
* An 64-bit Intel CPU <sup>[1](#1)</sup> * An 64-bit Intel CPU <sup>[1](#1)</sup>
* macOS 10.12 (or higher) <sup>[2](#2)</sup> * macOS 10.12 (or higher) <sup>[2](#2)</sup>
* Command Line Tools (CLT) for Xcode: `xcode-select --install`, * Command Line Tools (CLT) for Xcode: `xcode-select --install`,
@ -24,6 +25,7 @@ it does it too. You have to confirm everything it will do before it starts.
Check out [the Linuxbrew installation documentation](Linuxbrew.md). Check out [the Linuxbrew installation documentation](Linuxbrew.md).
### Untar anywhere ### Untar anywhere
Just extract (or `git clone`) Homebrew wherever you want. Just avoid: Just extract (or `git clone`) Homebrew wherever you want. Just avoid:
* Directories with names that contain spaces. Homebrew itself can handle spaces, but many build scripts cannot. * Directories with names that contain spaces. Homebrew itself can handle spaces, but many build scripts cannot.
@ -40,9 +42,11 @@ mkdir homebrew && curl -L https://github.com/Homebrew/brew/tarball/master | tar
``` ```
### Multiple installations ### Multiple installations
Create a Homebrew installation wherever you extract the tarball. Whichever `brew` command is called is where the packages will be installed. You can use this as you see fit, e.g. a system set of libs in `/usr/local` and tweaked formulae for development in `~/homebrew`. Create a Homebrew installation wherever you extract the tarball. Whichever `brew` command is called is where the packages will be installed. You can use this as you see fit, e.g. a system set of libs in `/usr/local` and tweaked formulae for development in `~/homebrew`.
## Uninstallation ## Uninstallation
Uninstallation is documented in the [FAQ](FAQ.md). Uninstallation is documented in the [FAQ](FAQ.md).
<a name="1"><sup>1</sup></a> For 32-bit or PPC support see <a name="1"><sup>1</sup></a> For 32-bit or PPC support see

8
docs/Python-for-Formula-Authors.md
View File

@ -18,13 +18,7 @@ Applications should unconditionally bundle all of their Python-language dependen
Formulae for apps that require Python 3 **should** declare an unconditional dependency on `"python"`. These apps **must** work with the current Homebrew Python 3.x formula. Formulae for apps that require Python 3 **should** declare an unconditional dependency on `"python"`. These apps **must** work with the current Homebrew Python 3.x formula.
Applications that are compatible with Python 2 **should** use the Apple-provided system Python in `/usr/bin` on systems that provide Python 2.7. To do this, declare: Applications that are compatible with Python 2 **should** use the Apple-provided system Python in `/usr/bin` on systems that provide Python 2.7. No explicit Python dependency is needed since `/usr/bin` is always in `PATH` for Homebrew formulae.
```ruby
depends_on "python@2" if MacOS.version <= :snow_leopard
```
No explicit Python dependency is needed on recent OS versions since `/usr/bin` is always in `PATH` for Homebrew formulae; on Leopard and older, the `python` in `PATH` is used if it's at least version 2.7, or else Homebrew's Python 2.7.x is installed.
### Installing ### Installing