Add support for options in install script

This adds support for serveral new command line options (taken from the usage):
    "-b, --bin-dir" "Override the bin installation directory [default: ${_bin_dir}]" \
    "-m, --man-dir" "Override the man installation directory [default: ${_man_dir}]" \
    "-a, --arch" "Override the architecture identified by the installer [default: ${_arch}]" \
    "-h, --help" "Display this help message"
This also (coincidentally) allows for $BIN_DIR, $MAN_DIR, and $ARCH to be set to create default settings for these.
These variables are *always* overwritten by the command line arguments.

This diff is unusually large, as my formatter ([shfmt](https://github.com/mvdan/sh)) ran, reformatting the majority of the script.

This also adds a few utilities to the script (`log`/`abort`) and modifies `err` to simply output to stderr.
This allows for more fine grain control over script flow and output, without relying on `echo >&2`.
This commit is contained in:
aarondill 2023-07-05 12:48:58 -05:00
parent 72a49ec9c9
commit f1a54433a2
1 changed files with 443 additions and 312 deletions

View File

@ -1,120 +1,203 @@
#!/bin/sh #!/bin/sh
# shellcheck shell=dash # shellcheck shell=dash
# shellcheck disable=SC3043
# The official zoxide installer. # The official zoxide installer.
# #
# It runs on Unix shells like {a,ba,da,k,z}sh. It uses the common `local` # It runs on Unix shells like {a,ba,da,k,z}sh. It uses the common `local`
# extension. Note: Most shells limit `local` to 1 var per line, contra bash. # extension. Note: Most shells limit `local` to 1 var per line, contra bash.
main() { usage() {
if [ "${KSH_VERSION-}" = 'Version JM 93t+ 2010-03-05' ]; then printf "%s\n" \
# The version of ksh93 that ships with many illumos systems does not "install.sh [option]" \
# support the "local" extension. Print a message rather than fail in "" \
# subtle ways later on: "Fetch and install the latest version of zoxide, if zoxide is already" \
err 'the installer does not work with this ksh93 version; please try bash' "installed it will be updated to the latest version."
printf "\n%s\n" "Options"
printf "\t%s\n\t\t%s\n\n" \
"-b, --bin-dir" "Override the bin installation directory [default: ${_bin_dir}]" \
"-m, --man-dir" "Override the man installation directory [default: ${_man_dir}]" \
"-a, --arch" "Override the architecture identified by the installer [default: ${_arch}]" \
"-h, --help" "Display this help message"
}
# outputs sudo command to use to stdout, exits script if no command can be found
elevate_priv() {
if has sudo; then
if sudo true; then
printf 'sudo'
return 0
else
err "Sudo failed. Checking doas support."
fi fi
fi
set -u if has doas; then
if doas true; then
printf "doas"
return 0
else
err "doas failed."
fi
fi
# Detect and print host target triple. # returns before this if a command is found.
err 'Could not find the command "sudo" or "doas", needed to get permissions for install.'
err "If you are on Windows, please run your shell as an administrator, then"
err "rerun this script. Otherwise, please run this script as root, or install"
err "sudo or doas."
exit 1
}
main() {
if [ "${KSH_VERSION-}" = 'Version JM 93t+ 2010-03-05' ]; then
# The version of ksh93 that ships with many illumos systems does not
# support the "local" extension. Print a message rather than fail in
# subtle ways later on:
abort 'the installer does not work with this ksh93 version; please try bash'
fi
set -u
# Detect and print host target triple.
if [ -n "${ARCH:-}" ]; then
# if the user specifed, trust them - don't error on unrecognized hardware.
local _arch="${ARCH}"
else
ensure get_architecture ensure get_architecture
local _arch="${RETVAL}" local _arch="${RETVAL}"
assert_nz "${_arch}" "arch" fi
echo "Detected architecture: ${_arch}" assert_nz "${_arch}" "arch"
log "Detected architecture: ${_arch}"
# Create and enter a temporary directory. local _bin_dir="${HOME}/.local/bin"
local _tmp_dir local _bin_name
_tmp_dir="$(mktemp -d)" || err "mktemp: could not create temporary directory" local _man_dir="${HOME}/.local/share/man"
cd "${_tmp_dir}" || err "cd: failed to enter directory: ${_tmp_dir}"
# Download and extract zoxide. parse_args "$@" # sets global variables (BIN_DIR, MAN_DIR, ARCH)
ensure download_zoxide "${_arch}"
local _package="${RETVAL}"
assert_nz "${_package}" "package"
echo "Downloaded package: ${_package}"
case "${_package}" in
*.tar.gz)
need_cmd tar
ensure tar -xf "${_package}"
;;
*.zip)
need_cmd unzip
ensure unzip -oq "${_package}"
;;
*)
err "unsupported package format: ${_package}"
;;
esac
# Install binary. _bin_dir=${BIN_DIR:-$_bin_dir}
local _bin_dir="${HOME}/.local/bin" _man_dir=${MAN_DIR:-$_man_dir}
local _bin_name _arch=${ARCH:-$_arch}
case "${_arch}" in
*windows*) _bin_name="zoxide.exe" ;;
*) _bin_name="zoxide" ;;
esac
ensure mkdir -p "${_bin_dir}"
ensure cp "${_bin_name}" "${_bin_dir}"
ensure chmod +x "${_bin_dir}/${_bin_name}"
echo "Installed zoxide to ${_bin_dir}"
# Install manpages. case "${_arch}" in
local _man_dir="${HOME}/.local/share/man" *windows*) _bin_name="zoxide.exe" ;;
ensure mkdir -p "${_man_dir}/man1" *) _bin_name="zoxide" ;;
ensure cp "man/man1/"* "${_man_dir}/man1/" esac
echo "Installed manpages to ${_man_dir}"
# Print success message and check $PATH. if ! [ -d "${_bin_dir}" ]; then
echo "" abort "Please ensure the destination exists! (${_bin_dir})"
echo "zoxide is installed!" fi
if ! echo ":${PATH}:" | grep -Fq ":${_bin_dir}:"; then if ! [ -d "${_man_dir}" ]; then
echo "NOTE: ${_bin_dir} is not on your \$PATH. zoxide will not work unless it is added to \$PATH." abort "Please ensure the manual destination exists! (${_man_dir})"
fi fi
local sudo=""
if test_writeable "${_bin_dir}"; then
log "Installing zoxide, please wait…"
else
log "Escalated permissions are required to install to ${_bin_dir}"
sudo=$(elevate_priv)
log "Installing zoxide as root, please wait…"
fi
# Create and enter a temporary directory.
local _tmp_dir
_tmp_dir="$(mktemp -d)" || abort "mktemp: could not create temporary directory"
cd -- "${_tmp_dir}" || abort "cd: failed to enter directory: ${_tmp_dir}"
# Download and extract zoxide.
ensure download_zoxide "${_arch}"
local _package="${RETVAL}"
assert_nz "${_package}" "package"
log "Downloaded package: ${_package}"
case "${_package}" in
*.tar.gz)
need_cmd tar
ensure tar -xf "${_package}"
;;
*.zip)
need_cmd unzip
ensure unzip -oq "${_package}"
;;
*)
abort "unsupported package format: ${_package}"
;;
esac
# Install binary.
# shellcheck disable=SC2086 # The lack of quoting is intentional. This may not be the best way to do it, but it's hard to properly do in POSIX
{
ensure ${sudo} cp "${_bin_name}" "${_bin_dir}"
ensure ${sudo} chmod +x "${_bin_dir}/${_bin_name}"
}
log "Installed zoxide to ${_bin_dir}"
# Install manpages.
# shellcheck disable=SC2086 # The lack of quoting is intentional.
ensure ${sudo} cp "man/man1/"* "${_man_dir}/man1/"
log "Installed manpages to ${_man_dir}"
# Print success message and check $PATH.
log ""
log "zoxide is installed!"
case ":${PATH}:" in
*":${_bin_dir}:"*) true ;; # noop
*) log "NOTE: ${_bin_dir} is not on your \$PATH. zoxide will not work unless it is added to \$PATH." ;;
esac
} }
download_zoxide() { download_zoxide() {
local _arch="$1" local _arch="$1"
if check_cmd curl; then if has_cmd curl; then
_dld=curl _dld=curl
elif check_cmd wget; then elif has_cmd wget; then
_dld=wget _dld=wget
else elif has_cmd fetch; then
need_cmd 'curl or wget' _dld="fetch"
fi # cmd="fetch --quiet --output=$file $url"
need_cmd grep else
abort 'curl or wget are required to download zoxide'
fi
local _releases_url="https://api.github.com/repos/ajeetdsouza/zoxide/releases/latest" need_cmd grep
local _releases
case "${_dld}" in
curl) _releases="$(curl -sL "${_releases_url}")" ||
err "curl: failed to download ${_releases_url}" ;;
wget) _releases="$(wget -qO- "${_releases_url}")" ||
err "wget: failed to download ${_releases_url}" ;;
*) err "unsupported downloader: ${_dld}" ;;
esac
(echo "${_releases}" | grep -q 'API rate limit exceeded') &&
err "you have exceeded GitHub's API rate limit. Please try again later, or use a different installation method: https://github.com/ajeetdsouza/zoxide/#installation"
local _package_url local _releases_url="https://api.github.com/repos/ajeetdsouza/zoxide/releases/latest"
_package_url="$(echo "${_releases}" | grep "browser_download_url" | cut -d '"' -f 4 | grep "${_arch}")" || local _releases
err "zoxide has not yet been packaged for your architecture (${_arch}), please file an issue: https://github.com/ajeetdsouza/zoxide/issues" case "${_dld}" in
curl) _releases="$(curl -sL "${_releases_url}")" ||
abort "curl: failed to download ${_releases_url}" ;;
wget) _releases="$(wget -qO- "${_releases_url}")" ||
abort "wget: failed to download ${_releases_url}" ;;
fetch) _releases="$(fetch --quiet "${_releases_url}")" ||
abort "fetch: failed to download ${_releases_url}" ;;
*) abort "unsupported downloader: ${_dld}" ;;
esac
(printf "%s" "${_releases}" | grep -q 'API rate limit exceeded') &&
abort "you have exceeded GitHub's API rate limit. Please try again later, or use a different installation method: https://github.com/ajeetdsouza/zoxide/#installation"
local _ext local _package_url
case "${_package_url}" in _package_url="$(printf "%s" "${_releases}" | grep "browser_download_url" | cut -d '"' -f 4 | grep "${_arch}")" ||
*.tar.gz) _ext="tar.gz" ;; abort "zoxide has not yet been packaged for your architecture (${_arch}), please file an issue: https://github.com/ajeetdsouza/zoxide/issues"
*.zip) _ext="zip" ;;
*) err "unsupported package format: ${_package_url}" ;;
esac
local _package="zoxide.${_ext}" local _ext
case "${_dld}" in case "${_package_url}" in
curl) _releases="$(curl -sLo "${_package}" "${_package_url}")" || err "curl: failed to download ${_package_url}" ;; *.tar.gz) _ext="tar.gz" ;;
wget) _releases="$(wget -qO "${_package}" "${_package_url}")" || err "wget: failed to download ${_package_url}" ;; *.zip) _ext="zip" ;;
*) err "unsupported downloader: ${_dld}" ;; *) abort "unsupported package format: ${_package_url}" ;;
esac esac
RETVAL="${_package}" local _package="zoxide.${_ext}"
case "${_dld}" in
curl) _releases="$(curl -sLo "${_package}" "${_package_url}")" || abort "curl: failed to download ${_package_url}" ;;
wget) _releases="$(wget -qO "${_package}" "${_package_url}")" || abort "wget: failed to download ${_package_url}" ;;
fetch) _releases="$(fetch --quiet --output="${_package}" "${_package_url}")" || abort "fetch: failed to download ${_package_url}" ;;
*) abort "unsupported downloader: ${_dld}" ;;
esac
RETVAL="${_package}"
} }
# The below functions have been extracted with minor modifications from the # The below functions have been extracted with minor modifications from the
@ -123,269 +206,317 @@ download_zoxide() {
# https://github.com/rust-lang/rustup/blob/4c1289b2c3f3702783900934a38d7c5f912af787/rustup-init.sh # https://github.com/rust-lang/rustup/blob/4c1289b2c3f3702783900934a38d7c5f912af787/rustup-init.sh
get_architecture() { get_architecture() {
local _ostype _cputype _bitness _arch _clibtype local _ostype _cputype _bitness _arch _clibtype
_ostype="$(uname -s)" _ostype="$(uname -s)"
_cputype="$(uname -m)" _cputype="$(uname -m)"
_clibtype="musl" _clibtype="musl"
if [ "${_ostype}" = Linux ]; then if [ "${_ostype}" = Linux ]; then
if [ "$(uname -o || true)" = Android ]; then if [ "$(uname -o || true)" = Android ]; then
_ostype=Android _ostype=Android
fi fi
fi
if [ "${_ostype}" = Darwin ] && [ "${_cputype}" = i386 ]; then
# Darwin `uname -m` lies
if sysctl hw.optional.x86_64 | grep -q ': 1'; then
_cputype=x86_64
fi
fi
if [ "${_ostype}" = SunOS ]; then
# Both Solaris and illumos presently announce as "SunOS" in "uname -s"
# so use "uname -o" to disambiguate. We use the full path to the
# system uname in case the user has coreutils uname first in PATH,
# which has historically sometimes printed the wrong value here.
if [ "$(/usr/bin/uname -o || true)" = illumos ]; then
_ostype=illumos
fi fi
if [ "${_ostype}" = Darwin ] && [ "${_cputype}" = i386 ]; then # illumos systems have multi-arch userlands, and "uname -m" reports the
# Darwin `uname -m` lies # machine hardware name; e.g., "i86pc" on both 32- and 64-bit x86
if sysctl hw.optional.x86_64 | grep -q ': 1'; then # systems. Check for the native (widest) instruction set on the
_cputype=x86_64 # running kernel:
fi if [ "${_cputype}" = i86pc ]; then
_cputype="$(isainfo -n)"
fi fi
fi
if [ "${_ostype}" = SunOS ]; then case "${_ostype}" in
# Both Solaris and illumos presently announce as "SunOS" in "uname -s" Android)
# so use "uname -o" to disambiguate. We use the full path to the _ostype=linux-android
# system uname in case the user has coreutils uname first in PATH, ;;
# which has historically sometimes printed the wrong value here. Linux)
if [ "$(/usr/bin/uname -o || true)" = illumos ]; then check_proc
_ostype=illumos _ostype=unknown-linux-${_clibtype}
fi _bitness=$(get_bitness)
;;
FreeBSD)
_ostype=unknown-freebsd
;;
NetBSD)
_ostype=unknown-netbsd
;;
DragonFly)
_ostype=unknown-dragonfly
;;
Darwin)
_ostype=apple-darwin
;;
illumos)
_ostype=unknown-illumos
;;
MINGW* | MSYS* | CYGWIN* | Windows_NT)
_ostype=pc-windows-msvc
;;
*)
abort "unrecognized OS type: ${_ostype}"
;;
esac
# illumos systems have multi-arch userlands, and "uname -m" reports the case "${_cputype}" in
# machine hardware name; e.g., "i86pc" on both 32- and 64-bit x86 i386 | i486 | i686 | i786 | x86)
# systems. Check for the native (widest) instruction set on the _cputype=i686
# running kernel: ;;
if [ "${_cputype}" = i86pc ]; then xscale | arm)
_cputype="$(isainfo -n)" _cputype=arm
fi if [ "${_ostype}" = "linux-android" ]; then
_ostype=linux-androideabi
fi fi
;;
armv6l)
_cputype=arm
if [ "${_ostype}" = "linux-android" ]; then
_ostype=linux-androideabi
else
_ostype="${_ostype}eabihf"
fi
;;
armv7l | armv8l)
_cputype=armv7
if [ "${_ostype}" = "linux-android" ]; then
_ostype=linux-androideabi
else
_ostype="${_ostype}eabihf"
fi
;;
aarch64 | arm64)
_cputype=aarch64
;;
x86_64 | x86-64 | x64 | amd64)
_cputype=x86_64
;;
mips)
_cputype=$(get_endianness mips '' el)
;;
mips64)
if [ "${_bitness}" -eq 64 ]; then
# only n64 ABI is supported for now
_ostype="${_ostype}abi64"
_cputype=$(get_endianness mips64 '' el)
fi
;;
ppc)
_cputype=powerpc
;;
ppc64)
_cputype=powerpc64
;;
ppc64le)
_cputype=powerpc64le
;;
s390x)
_cputype=s390x
;;
riscv64)
_cputype=riscv64gc
;;
*)
abort "unknown CPU type: ${_cputype}"
;;
esac
case "${_ostype}" in # Detect 64-bit linux with 32-bit userland
Android) if [ "${_ostype}" = unknown-linux-musl ] && [ "${_bitness}" -eq 32 ]; then
_ostype=linux-android case ${_cputype} in
;; x86_64)
Linux) # 32-bit executable for amd64 = x32
check_proc if is_host_amd64_elf; then
_ostype=unknown-linux-${_clibtype} abort "x32 userland is unsupported"
_bitness=$(get_bitness) else
;;
FreeBSD)
_ostype=unknown-freebsd
;;
NetBSD)
_ostype=unknown-netbsd
;;
DragonFly)
_ostype=unknown-dragonfly
;;
Darwin)
_ostype=apple-darwin
;;
illumos)
_ostype=unknown-illumos
;;
MINGW* | MSYS* | CYGWIN* | Windows_NT)
_ostype=pc-windows-msvc
;;
*)
err "unrecognized OS type: ${_ostype}"
;;
esac
case "${_cputype}" in
i386 | i486 | i686 | i786 | x86)
_cputype=i686 _cputype=i686
;; fi
xscale | arm) ;;
_cputype=arm
if [ "${_ostype}" = "linux-android" ]; then
_ostype=linux-androideabi
fi
;;
armv6l)
_cputype=arm
if [ "${_ostype}" = "linux-android" ]; then
_ostype=linux-androideabi
else
_ostype="${_ostype}eabihf"
fi
;;
armv7l | armv8l)
_cputype=armv7
if [ "${_ostype}" = "linux-android" ]; then
_ostype=linux-androideabi
else
_ostype="${_ostype}eabihf"
fi
;;
aarch64 | arm64)
_cputype=aarch64
;;
x86_64 | x86-64 | x64 | amd64)
_cputype=x86_64
;;
mips)
_cputype=$(get_endianness mips '' el)
;;
mips64) mips64)
if [ "${_bitness}" -eq 64 ]; then _cputype=$(get_endianness mips '' el)
# only n64 ABI is supported for now ;;
_ostype="${_ostype}abi64" powerpc64)
_cputype=$(get_endianness mips64 '' el) _cputype=powerpc
fi ;;
;; aarch64)
ppc) _cputype=armv7
_cputype=powerpc if [ "${_ostype}" = "linux-android" ]; then
;; _ostype=linux-androideabi
ppc64) else
_cputype=powerpc64 _ostype="${_ostype}eabihf"
;; fi
ppc64le) ;;
_cputype=powerpc64le riscv64gc)
;; abort "riscv64 with 32-bit userland unsupported"
s390x) ;;
_cputype=s390x *) ;;
;;
riscv64)
_cputype=riscv64gc
;;
*)
err "unknown CPU type: ${_cputype}"
;;
esac esac
fi
# Detect 64-bit linux with 32-bit userland # Detect armv7 but without the CPU features Rust needs in that build,
if [ "${_ostype}" = unknown-linux-musl ] && [ "${_bitness}" -eq 32 ]; then # and fall back to arm.
case ${_cputype} in # See https://github.com/rust-lang/rustup.rs/issues/587.
x86_64) if [ "${_ostype}" = "unknown-linux-musleabihf" ] && [ "${_cputype}" = armv7 ]; then
# 32-bit executable for amd64 = x32 if ensure grep '^Features' /proc/cpuinfo | grep -q -v neon; then
if is_host_amd64_elf; then { # At least one processor does not have NEON.
echo "x32 userland is unsupported" 1>&2 _cputype=arm
exit 1
}; else
_cputype=i686
fi
;;
mips64)
_cputype=$(get_endianness mips '' el)
;;
powerpc64)
_cputype=powerpc
;;
aarch64)
_cputype=armv7
if [ "${_ostype}" = "linux-android" ]; then
_ostype=linux-androideabi
else
_ostype="${_ostype}eabihf"
fi
;;
riscv64gc)
err "riscv64 with 32-bit userland unsupported"
;;
*) ;;
esac
fi fi
fi
# Detect armv7 but without the CPU features Rust needs in that build, _arch="${_cputype}-${_ostype}"
# and fall back to arm. RETVAL="${_arch}"
# See https://github.com/rust-lang/rustup.rs/issues/587.
if [ "${_ostype}" = "unknown-linux-musleabihf" ] && [ "${_cputype}" = armv7 ]; then
if ensure grep '^Features' /proc/cpuinfo | grep -q -v neon; then
# At least one processor does not have NEON.
_cputype=arm
fi
fi
_arch="${_cputype}-${_ostype}"
RETVAL="${_arch}"
} }
get_bitness() { get_bitness() {
need_cmd head need_cmd head
# Architecture detection without dependencies beyond coreutils. # Architecture detection without dependencies beyond coreutils.
# ELF files start out "\x7fELF", and the following byte is # ELF files start out "\x7fELF", and the following byte is
# 0x01 for 32-bit and # 0x01 for 32-bit and
# 0x02 for 64-bit. # 0x02 for 64-bit.
# The printf builtin on some shells like dash only supports octal # The printf builtin on some shells like dash only supports octal
# escape sequences, so we use those. # escape sequences, so we use those.
local _current_exe_head local _current_exe_head
_current_exe_head=$(head -c 5 /proc/self/exe) _current_exe_head=$(head -c 5 /proc/self/exe)
if [ "${_current_exe_head}" = "$(printf '\177ELF\001')" ]; then if [ "${_current_exe_head}" = "$(printf '\177ELF\001')" ]; then
echo 32 printf 32
elif [ "${_current_exe_head}" = "$(printf '\177ELF\002')" ]; then elif [ "${_current_exe_head}" = "$(printf '\177ELF\002')" ]; then
echo 64 printf 64
else else
err "unknown platform bitness" abort "unknown platform bitness"
fi fi
} }
get_endianness() { get_endianness() {
local cputype=$1 local cputype="$1"
local suffix_eb=$2 local suffix_eb="$2"
local suffix_el=$3 local suffix_el="$3"
# detect endianness without od/hexdump, like get_bitness() does. # detect endianness without od/hexdump, like get_bitness() does.
need_cmd head need_cmd head
need_cmd tail need_cmd tail
local _current_exe_endianness local _current_exe_endianness
_current_exe_endianness="$(head -c 6 /proc/self/exe | tail -c 1)" _current_exe_endianness="$(head -c 6 /proc/self/exe | tail -c 1)"
if [ "${_current_exe_endianness}" = "$(printf '\001')" ]; then if [ "${_current_exe_endianness}" = "$(printf '\001')" ]; then
echo "${cputype}${suffix_el}" printf "%s" "${cputype}${suffix_el}"
elif [ "${_current_exe_endianness}" = "$(printf '\002')" ]; then elif [ "${_current_exe_endianness}" = "$(printf '\002')" ]; then
echo "${cputype}${suffix_eb}" printf "%s" "${cputype}${suffix_eb}"
else else
err "unknown platform endianness" abort "unknown platform endianness"
fi fi
} }
is_host_amd64_elf() { is_host_amd64_elf() {
need_cmd head need_cmd head
need_cmd tail need_cmd tail
# ELF e_machine detection without dependencies beyond coreutils. # ELF e_machine detection without dependencies beyond coreutils.
# Two-byte field at offset 0x12 indicates the CPU, # Two-byte field at offset 0x12 indicates the CPU,
# but we're interested in it being 0x3E to indicate amd64, or not that. # but we're interested in it being 0x3E to indicate amd64, or not that.
local _current_exe_machine local _current_exe_machine
_current_exe_machine=$(head -c 19 /proc/self/exe | tail -c 1) _current_exe_machine=$(head -c 19 /proc/self/exe | tail -c 1)
[ "${_current_exe_machine}" = "$(printf '\076')" ] [ "${_current_exe_machine}" = "$(printf '\076')" ]
}
# Test if a location is writeable by trying to write to it. Windows does not let
# you test writeability other than by writing: https://stackoverflow.com/q/1999988
test_writeable() {
path="${1:-}/test.txt"
if touch "${path}" 2>/dev/null; then
rm "${path}"
return 0
else
return 1
fi
} }
check_proc() { check_proc() {
# Check for /proc by looking for the /proc/self/exe link. # Check for /proc by looking for the /proc/self/exe link.
# This is only run on Linux. # This is only run on Linux.
if ! test -L /proc/self/exe; then if ! test -L /proc/self/exe; then
err "unable to find /proc/self/exe. Is /proc mounted? Installation cannot proceed without /proc." abort "unable to find /proc/self/exe. Is /proc mounted? Installation cannot proceed without /proc."
fi fi
} }
need_cmd() { need_cmd() {
if ! check_cmd "$1"; then if ! has_cmd "$1"; then
err "need '$1' (command not found)" abort "need '$1' (command not found)"
fi fi
} }
check_cmd() { has_cmd() { command -v "$1" >/dev/null 2>&1; }
command -v "$1" >/dev/null 2>&1
# parse the arguments passed and set the environment variables accordingly
parse_args() {
# parse argv variables
while [ "$#" -gt 0 ]; do
case "$1" in
-b | --bin-dir)
BIN_DIR="$2"
shift 2
;;
-m | --man-dir)
MAN_DIR="$2"
shift 2
;;
-a | --arch)
ARCH="$2"
shift 2
;;
-h | --help)
usage
exit 0
;;
-b=* | --bin-dir=*)
BIN_DIR="${1#*=}"
shift 1
;;
-m=* | --man-dir=*)
MAN_DIR="${1#*=}"
shift 1
;;
-a=* | --arch=*)
ARCH="${1#*=}"
shift 1
;;
*)
err "Unknown option: $1"
usage
exit 1
;;
esac
done
} }
# Run a command that should never fail. If the command fails execution # Run a command that should never fail. If the command fails execution
# will immediately terminate with an error showing the failing # will immediately terminate with an error showing the failing
# command. # command.
ensure() { ensure() { if ! "$@"; then abort "command failed: $*"; fi; }
if ! "$@"; then err "command failed: $*"; fi assert_nz() { if [ -z "$1" ]; then abort "found empty string: $2"; fi; }
} log() { printf '%s\n' "$1"; }
err() { printf 'Error: %s\n' "$1" >&2; }
assert_nz() { abort() {
if [ -z "$1" ]; then err "found empty string: $2"; fi err "$1"
} exit "${2:-1}"
err() {
echo "Error: $1" >&2
exit 1
} }
# This is put in braces to ensure that the script does not run until it is # This is put in braces to ensure that the script does not run until it is
# downloaded completely. # downloaded completely.
{ {
main "$@" || exit 1 main "$@" || exit 1
} }