mac安装 homebrew

#!/bin/bash

set -u

# First check if the OS is Linux.

if [[ "$(uname)" = "Linux" ]]; then

HOMEBREW_ON_LINUX=1

# On macOS, this script installs to /usr/local only.

# On Linux, it installs to /home/linuxbrew/.linuxbrew if you have sudo access

# and ~/.linuxbrew otherwise.

# To install elsewhere (which is unsupported)

# you can untar https://github.com/Homebrew/brew/tarball/master

# anywhere you like.

if [[ -z "${HOMEBREW_ON_LINUX-}" ]]; then

HOMEBREW_PREFIX="/usr/local"

HOMEBREW_REPOSITORY="/usr/local/Homebrew"

HOMEBREW_CACHE="${HOME}/Library/Caches/Homebrew"

STAT="stat -f"

CHOWN="/usr/sbin/chown"

CHGRP="/usr/bin/chgrp"

GROUP="admin"

TOUCH="/usr/bin/touch"

else

HOMEBREW_PREFIX_DEFAULT="/home/linuxbrew/.linuxbrew"

HOMEBREW_CACHE="${HOME}/.cache/Homebrew"

STAT="stat --printf"

CHOWN="/bin/chown"

CHGRP="/bin/chgrp"

GROUP="$(id -gn)"

TOUCH="/bin/touch"

BREW_REPO="https://github.com/Homebrew/brew"

# TODO: bump version when new macOS is released

MACOS_LATEST_SUPPORTED="10.15"

# TODO: bump version when new macOS is released

MACOS_OLDEST_SUPPORTED="10.13"

# no analytics during installation

export HOMEBREW_NO_ANALYTICS_THIS_RUN=1

export HOMEBREW_NO_ANALYTICS_MESSAGE_OUTPUT=1

# string formatters

if [[ -t 1 ]]; then

tty_escape() { printf "\033[%sm" "$1"; }

else

tty_escape() { :; }

tty_mkbold() { tty_escape "1;$1"; }

tty_underline="$(tty_escape "4;39")"

tty_blue="$(tty_mkbold 34)"

tty_red="$(tty_mkbold 31)"

tty_bold="$(tty_mkbold 39)"

tty_reset="$(tty_escape 0)"

have_sudo_access() {

if [[ -z "${HAVE_SUDO_ACCESS-}" ]]; then

/usr/bin/sudo -l mkdir &>/dev/null

HAVE_SUDO_ACCESS="$?"

if [[ -z "${HOMEBREW_ON_LINUX-}" ]] && [[ "$HAVE_SUDO_ACCESS" -ne 0 ]]; then

abort "Need sudo access on macOS!"

return "$HAVE_SUDO_ACCESS"

}

shell_join() {

local arg

printf "%s" "$1"

shift

for arg in "$@"; do

printf " "

printf "%s" "${arg// /\ }"

done

}

chomp() {

printf "%s" "${1/"$'\n'"/}"

}

ohai() {

printf "${tty_blue}==>${tty_bold} %s${tty_reset}\n" "$(shell_join "$@")"

}

warn() {

printf "${tty_red}Warning${tty_reset}: %s\n" "$(chomp "$1")"

}

abort() {

printf "%s\n" "$1"

exit 1

}

execute() {

if ! "$@"; then

abort "$(printf "Failed during: %s" "$(shell_join "$@")")"

}

execute_sudo() {

local -a args=("$@")

if [[ -n "${SUDO_ASKPASS-}" ]]; then

args=("-A" "${args[@]}")

if have_sudo_access; then

ohai "/usr/bin/sudo" "${args[@]}"

execute "/usr/bin/sudo" "${args[@]}"

else

ohai "${args[@]}"

execute "${args[@]}"

}

getc() {

local save_state

save_state=$(/bin/stty -g)

/bin/stty raw -echo

IFS= read -r -n 1 -d '' "$@"

/bin/stty "$save_state"

}

wait_for_user() {

local c

echo

echo "Press RETURN to continue or any other key to abort"

getc c

# we test for \r and \n because some stuff does \r instead

if ! [[ "$c" == $'\r' || "$c" == $'\n' ]]; then

exit 1

}

major_minor() {

echo "${1%%.*}.$(x="${1#*.}"; echo "${x%%.*}")"

}

if [[ -z "${HOMEBREW_ON_LINUX-}" ]]; then

macos_version="$(major_minor "$(/usr/bin/sw_vers -productVersion)")"

version_gt() {

[[ "${1%.*}" -gt "${2%.*}" ]] || [[ "${1%.*}" -eq "${2%.*}" && "${1#*.}" -gt "${2#*.}" ]]

}

version_ge() {

[[ "${1%.*}" -gt "${2%.*}" ]] || [[ "${1%.*}" -eq "${2%.*}" && "${1#*.}" -ge "${2#*.}" ]]

}

version_lt() {

[[ "${1%.*}" -lt "${2%.*}" ]] || [[ "${1%.*}" -eq "${2%.*}" && "${1#*.}" -lt "${2#*.}" ]]

}

should_install_git() {

if [[ $(command -v git) ]]; then

return 1

}

should_install_command_line_tools() {

if [[ -n "${HOMEBREW_ON_LINUX-}" ]]; then

return 1

if version_gt "$macos_version" "10.13"; then

! [[ -e "/Library/Developer/CommandLineTools/usr/bin/git" ]]

else

! [[ -e "/Library/Developer/CommandLineTools/usr/bin/git" ]] ||

! [[ -e "/usr/include/iconv.h" ]]

}

get_permission() {

$STAT "%A" "$1"

}

user_only_chmod() {

[[ -d "$1" ]] && [[ "$(get_permission "$1")" != "755" ]]

}

exists_but_not_writable() {

[[ -e "$1" ]] && ! [[ -r "$1" && -w "$1" && -x "$1" ]]

}

get_owner() {

$STAT "%u" "$1"

}

file_not_owned() {

[[ "$(get_owner "$1")" != "$(id -u)" ]]

}

get_group() {

$STAT "%g" "$1"

}

file_not_grpowned() {

[[ " $(id -G "$USER") " != *" $(get_group "$1") "* ]]

}

# USER isn't always set so provide a fall back for the installer and subprocesses.

if [[ -z "${USER-}" ]]; then

USER="$(chomp "$(id -un)")"

export USER

# Invalidate sudo timestamp before exiting (if it wasn't active before).

if ! /usr/bin/sudo -n -v 2>/dev/null; then

trap '/usr/bin/sudo -k' EXIT

# Things can fail later if `pwd` doesn't exist.

# Also sudo prints a warning message for no good reason

cd "/usr" || exit 1

####################################################################### script

if should_install_git; then

abort "$(cat <

You must install Git before installing Homebrew. See:

${tty_underline}https://docs.brew.sh/Installation${tty_reset}

EOABORT

if [[ -n "${HOMEBREW_ON_LINUX-}" ]]; then

if [[ -n "${CI-}" ]] || [[ -w "$HOMEBREW_PREFIX_DEFAULT" ]] || [[ -w "/home/linuxbrew" ]] || [[ -w "/home" ]]; then

HOMEBREW_PREFIX="$HOMEBREW_PREFIX_DEFAULT"

else

trap exit SIGINT

sudo_output="$(/usr/bin/sudo -n -l mkdir 2>&1)"

sudo_exit_code="$?"

if [[ "$sudo_exit_code" -ne 0 ]] && [[ "$sudo_output" = "sudo: a password is required" ]]; then

ohai "Select the Homebrew installation directory"

echo "- ${tty_bold}Enter your password${tty_reset} to install to ${tty_underline}${HOMEBREW_PREFIX_DEFAULT}${tty_reset} (${tty_bold}recommended${tty_reset})"

echo "- ${tty_bold}Press Control-D${tty_reset} to install to ${tty_underline}$HOME/.linuxbrew${tty_reset}"

echo "- ${tty_bold}Press Control-C${tty_reset} to cancel installation"

if have_sudo_access; then

HOMEBREW_PREFIX="$HOMEBREW_PREFIX_DEFAULT"

else

HOMEBREW_PREFIX="$HOME/.linuxbrew"

trap - SIGINT

HOMEBREW_REPOSITORY="${HOMEBREW_PREFIX}/Homebrew"

if [[ "$UID" == "0" ]]; then

abort "Don't run this as root!"

elif [[ -d "$HOMEBREW_PREFIX" && ! -x "$HOMEBREW_PREFIX" ]]; then

abort "$(cat <

The Homebrew prefix, ${HOMEBREW_PREFIX}, exists but is not searchable. If this is

not intentional, please restore the default permissions and try running the

installer again:

sudo chmod 775 ${HOMEBREW_PREFIX}

EOABORT

if [[ -z "${HOMEBREW_ON_LINUX-}" ]]; then

if version_lt "$macos_version" "10.7"; then

abort "$(cat <

Your Mac OS X version is too old. See:

${tty_underline}https://github.com/mistydemeo/tigerbrew${tty_reset}

EOABORT

elif version_lt "$macos_version" "10.9"; then

abort "Your OS X version is too old"

elif ! [[ "$(dsmemberutil checkmembership -U "$USER" -G "$GROUP")" = *"user is a member"* ]]; then

abort "This script requires the user $USER to be an Administrator."

elif version_gt "$macos_version" "$MACOS_LATEST_SUPPORTED" || \

version_lt "$macos_version" "$MACOS_OLDEST_SUPPORTED"; then

who="We"

what=""

if version_gt "$macos_version" "$MACOS_LATEST_SUPPORTED"; then

what="pre-release version"

else

who+=" (and Apple)"

what="old version"

ohai "You are using macOS ${macos_version}."

ohai "${who} do not provide support for this ${what}."

echo "$(cat <

This installation may not succeed.

After installation, you will encounter build failures with some formulae.

Please create pull requests instead of asking for help on Homebrew\'s GitHub,

Discourse, Twitter or IRC. You are responsible for resolving any issues you

experience while you are running this ${what}.

EOS

)

ohai "This script will install:"

echo "${HOMEBREW_PREFIX}/bin/brew"

echo "${HOMEBREW_PREFIX}/share/doc/homebrew"

echo "${HOMEBREW_PREFIX}/share/man/man1/brew.1"

echo "${HOMEBREW_PREFIX}/share/zsh/site-functions/_brew"

echo "${HOMEBREW_PREFIX}/etc/bash_completion.d/brew"

echo "${HOMEBREW_REPOSITORY}"

# Keep relatively in sync with

# https://github.com/Homebrew/brew/blob/master/Library/Homebrew/keg.rb

directories=(bin etc include lib sbin share opt var

Frameworks

etc/bash_completion.d lib/pkgconfig

share/aclocal share/doc share/info share/locale share/man

share/man/man1 share/man/man2 share/man/man3 share/man/man4

share/man/man5 share/man/man6 share/man/man7 share/man/man8

var/log var/homebrew var/homebrew/linked

bin/brew)

group_chmods=()

for dir in "${directories[@]}"; do

if exists_but_not_writable "${HOMEBREW_PREFIX}/${dir}"; then

group_chmods+=("${HOMEBREW_PREFIX}/${dir}")

done

# zsh refuses to read from these directories if group writable

directories=(share/zsh share/zsh/site-functions)

zsh_dirs=()

for dir in "${directories[@]}"; do

zsh_dirs+=("${HOMEBREW_PREFIX}/${dir}")

done

directories=(bin etc include lib sbin share var opt

share/zsh share/zsh/site-functions

var/homebrew var/homebrew/linked

Cellar Caskroom Homebrew Frameworks)

mkdirs=()

for dir in "${directories[@]}"; do

if ! [[ -d "${HOMEBREW_PREFIX}/${dir}" ]]; then

mkdirs+=("${HOMEBREW_PREFIX}/${dir}")

done

user_chmods=()

if [[ "${#zsh_dirs[@]}" -gt 0 ]]; then

for dir in "${zsh_dirs[@]}"; do

if user_only_chmod "${dir}"; then

user_chmods+=("${dir}")

done

chmods=()

if [[ "${#group_chmods[@]}" -gt 0 ]]; then

chmods+=("${group_chmods[@]}")

if [[ "${#user_chmods[@]}" -gt 0 ]]; then

chmods+=("${user_chmods[@]}")

chowns=()

chgrps=()

if [[ "${#chmods[@]}" -gt 0 ]]; then

for dir in "${chmods[@]}"; do

if file_not_owned "${dir}"; then

chowns+=("${dir}")

if file_not_grpowned "${dir}"; then

chgrps+=("${dir}")

done

if [[ "${#group_chmods[@]}" -gt 0 ]]; then

ohai "The following existing directories will be made group writable:"

printf "%s\n" "${group_chmods[@]}"

if [[ "${#user_chmods[@]}" -gt 0 ]]; then

ohai "The following existing directories will be made writable by user only:"

printf "%s\n" "${user_chmods[@]}"

if [[ "${#chowns[@]}" -gt 0 ]]; then

ohai "The following existing directories will have their owner set to ${tty_underline}${USER}${tty_reset}:"

printf "%s\n" "${chowns[@]}"

if [[ "${#chgrps[@]}" -gt 0 ]]; then

ohai "The following existing directories will have their group set to ${tty_underline}${GROUP}${tty_reset}:"

printf "%s\n" "${chgrps[@]}"

if [[ "${#mkdirs[@]}" -gt 0 ]]; then

ohai "The following new directories will be created:"

printf "%s\n" "${mkdirs[@]}"

if should_install_command_line_tools; then

ohai "The Xcode Command Line Tools will be installed."

if [[ -t 0 && -z "${CI-}" ]]; then

wait_for_user

if [[ -d "${HOMEBREW_PREFIX}" ]]; then

if [[ "${#chmods[@]}" -gt 0 ]]; then

execute_sudo "/bin/chmod" "u+rwx" "${chmods[@]}"

if [[ "${#group_chmods[@]}" -gt 0 ]]; then

execute_sudo "/bin/chmod" "g+rwx" "${group_chmods[@]}"

if [[ "${#user_chmods[@]}" -gt 0 ]]; then

execute_sudo "/bin/chmod" "755" "${user_chmods[@]}"

if [[ "${#chowns[@]}" -gt 0 ]]; then

execute_sudo "$CHOWN" "$USER" "${chowns[@]}"

if [[ "${#chgrps[@]}" -gt 0 ]]; then

execute_sudo "$CHGRP" "$GROUP" "${chgrps[@]}"

else

execute_sudo "/bin/mkdir" "-p" "${HOMEBREW_PREFIX}"

if [[ -z "${HOMEBREW_ON_LINUX-}" ]]; then

execute_sudo "$CHOWN" "root:wheel" "${HOMEBREW_PREFIX}"

else

execute_sudo "$CHOWN" "$USER:$GROUP" "${HOMEBREW_PREFIX}"

if [[ "${#mkdirs[@]}" -gt 0 ]]; then

execute_sudo "/bin/mkdir" "-p" "${mkdirs[@]}"

execute_sudo "/bin/chmod" "g+rwx" "${mkdirs[@]}"

execute_sudo "$CHOWN" "$USER" "${mkdirs[@]}"

execute_sudo "$CHGRP" "$GROUP" "${mkdirs[@]}"

if ! [[ -d "${HOMEBREW_CACHE}" ]]; then

if [[ -z "${HOMEBREW_ON_LINUX-}" ]]; then

execute_sudo "/bin/mkdir" "-p" "${HOMEBREW_CACHE}"

else

execute "/bin/mkdir" "-p" "${HOMEBREW_CACHE}"

if exists_but_not_writable "${HOMEBREW_CACHE}"; then

execute_sudo "/bin/chmod" "g+rwx" "${HOMEBREW_CACHE}"

if file_not_owned "${HOMEBREW_CACHE}"; then

execute_sudo "$CHOWN" "$USER" "${HOMEBREW_CACHE}"

if file_not_grpowned "${HOMEBREW_CACHE}"; then

execute_sudo "$CHGRP" "$GROUP" "${HOMEBREW_CACHE}"

if [[ -d "${HOMEBREW_CACHE}" ]]; then

execute "$TOUCH" "${HOMEBREW_CACHE}/.cleaned"

if should_install_command_line_tools && version_ge "$macos_version" "10.13"; then

ohai "Searching online for the Command Line Tools"

# This temporary file prompts the 'softwareupdate' utility to list the Command Line Tools

clt_placeholder="/tmp/.com.apple.dt.CommandLineTools.installondemand.in-progress"

execute_sudo "$TOUCH" "$clt_placeholder"

clt_label_command="/usr/sbin/softwareupdate -l |

grep -B 1 -E 'Command Line Tools' |

awk -F'*' '/^ *\\*/ {print \$2}' |

sed -e 's/^ *Label: //' -e 's/^ *//' |

sort -V |

tail -n1"

clt_label="$(chomp "$(/bin/bash -c "$clt_label_command")")"

if [[ -n "$clt_label" ]]; then

ohai "Installing $clt_label"

execute_sudo "/usr/sbin/softwareupdate" "-i" "$clt_label"

execute_sudo "/bin/rm" "-f" "$clt_placeholder"

execute_sudo "/usr/bin/xcode-select" "--switch" "/Library/Developer/CommandLineTools"

# Headless install may have failed, so fallback to original 'xcode-select' method

if should_install_command_line_tools && test -t 0; then

ohai "Installing the Command Line Tools (expect a GUI popup):"

execute_sudo "/usr/bin/xcode-select" "--install"

echo "Press any key when the installation has completed."

getc

execute_sudo "/usr/bin/xcode-select" "--switch" "/Library/Developer/CommandLineTools"

if [[ -z "${HOMEBREW_ON_LINUX-}" ]] && ! output="$(/usr/bin/xcrun clang 2>&1)" && [[ "$output" == *"license"* ]]; then

abort "$(cat <

You have not agreed to the Xcode license.

Before running the installer again please agree to the license by opening

Xcode.app or running:

sudo xcodebuild -license

EOABORT

ohai "Downloading and installing Homebrew..."

(

cd "${HOMEBREW_REPOSITORY}" >/dev/null || return

# we do it in four steps to avoid merge errors when reinstalling

execute "git" "init" "-q"

# "git remote add" will fail if the remote is defined in the global config

execute "git" "config" "remote.origin.url" "${BREW_REPO}"

execute "git" "config" "remote.origin.fetch" "+refs/heads/*:refs/remotes/origin/*"

# ensure we don't munge line endings on checkout

execute "git" "config" "core.autocrlf" "false"

execute "git" "fetch" "origin" "--force"

execute "git" "fetch" "origin" "--tags" "--force"

execute "git" "reset" "--hard" "origin/master"

execute "ln" "-sf" "${HOMEBREW_REPOSITORY}/bin/brew" "${HOMEBREW_PREFIX}/bin/brew"

execute "${HOMEBREW_PREFIX}/bin/brew" "update" "--force"

)

if [[ ":${PATH}:" != *":${HOMEBREW_PREFIX}/bin:"* ]]; then

warn "${HOMEBREW_PREFIX}/bin is not in your PATH."

ohai "Installation successful!"

echo

# Use the shell's audible bell.

if [[ -t 1 ]]; then

printf "\a"

# Use an extra newline and bold to avoid this being missed.

ohai "Homebrew has enabled anonymous aggregate formulae and cask analytics."

echo "$(cat <

${tty_bold}Read the analytics documentation (and how to opt-out) here:

${tty_underline}https://docs.brew.sh/Analytics${tty_reset}

No analytics data has been sent yet (or will be during this \`install\` run).

EOS

)

ohai "Homebrew is run entirely by unpaid volunteers. Please consider donating:"

echo "$(cat <

${tty_underline}https://github.com/Homebrew/brew#donations${tty_reset}

EOS

)

(

cd "${HOMEBREW_REPOSITORY}" >/dev/null || return

execute "git" "config" "--replace-all" "homebrew.analyticsmessage" "true"

execute "git" "config" "--replace-all" "homebrew.caskanalyticsmessage" "true"

)

ohai "Next steps:"

echo "- Run \`brew help\` to get started"

echo "- Further documentation: "

echo " ${tty_underline}https://docs.brew.sh${tty_reset}"

if [[ -n "${HOMEBREW_ON_LINUX-}" ]]; then

case "$SHELL" in

*/bash*)

if [[ -r "$HOME/.bash_profile" ]]; then

shell_profile="$HOME/.bash_profile"

else

shell_profile="$HOME/.profile"

;;

*/zsh*)

shell_profile="$HOME/.zprofile"

;;

shell_profile="$HOME/.profile"

;;

esac

cat <

- Install the Homebrew dependencies if you have sudo access:

${tty_bold}Debian, Ubuntu, etc.${tty_reset}

sudo apt-get install build-essential

${tty_bold}Fedora, Red Hat, CentOS, etc.${tty_reset}

sudo yum groupinstall 'Development Tools'

See ${tty_underline}https://docs.brew.sh/linux${tty_reset} for more information.

- Configure Homebrew in your ${tty_underline}${shell_profile}${tty_reset} by running

echo 'eval \$(${HOMEBREW_PREFIX}/bin/brew shellenv)' >> ${shell_profile}

- Add Homebrew to your ${tty_bold}PATH${tty_reset}

eval \$(${HOMEBREW_PREFIX}/bin/brew shellenv)

- We recommend that you install GCC by running:

brew install gcc

EOS

将以上代码保存为install.sh后执行bash install.sh

mac安装 homebrew

你可能感兴趣的:(mac安装 homebrew)