mirror of
https://github.com/webinstall/webi-installers.git
synced 2026-05-06 16:56:40 +00:00
672 lines
21 KiB
Bash
672 lines
21 KiB
Bash
#!/bin/sh
|
|
|
|
__bootstrap_webi() {
|
|
|
|
set -e
|
|
set -u
|
|
#set -x
|
|
|
|
my_libc=''
|
|
if ldd /bin/ls 2> /dev/null | grep -q 'musl' 2> /dev/null; then
|
|
my_libc=' musl-native'
|
|
fi
|
|
|
|
#WEBI_PKG=
|
|
#PKG_NAME=
|
|
#WEBI_OS=
|
|
#WEBI_ARCH=
|
|
#WEBI_HOST=
|
|
#WEBI_RELEASES=
|
|
#WEBI_CSV=
|
|
#WEBI_TAG=
|
|
#WEBI_VERSION=
|
|
#WEBI_MAJOR=
|
|
#WEBI_MINOR=
|
|
#WEBI_PATCH=
|
|
# TODO not sure if BUILD is the best name for this
|
|
#WEBI_BUILD=
|
|
#WEBI_GIT_TAG=
|
|
#WEBI_LTS=
|
|
#WEBI_CHANNEL=
|
|
#WEBI_EXT=
|
|
#WEBI_FORMATS=
|
|
#WEBI_PKG_URL=
|
|
#WEBI_PKG_FILE=
|
|
#PKG_OSES=
|
|
#PKG_ARCHES=
|
|
#PKG_FORMATS=
|
|
WEBI_UA="$(uname -s)/$(uname -r) $(uname -m)/unknown${my_libc}"
|
|
WEBI_PKG_DOWNLOAD=""
|
|
WEBI_DOWNLOAD_DIR="${HOME}/Downloads"
|
|
if command -v xdg-user-dir > /dev/null; then
|
|
WEBI_DOWNLOAD_DIR="$(xdg-user-dir DOWNLOAD)"
|
|
if [ "${WEBI_DOWNLOAD_DIR}" = "${HOME}" ]; then
|
|
WEBI_DOWNLOAD_DIR="${HOME}/Downloads"
|
|
fi
|
|
fi
|
|
|
|
WEBI_PKG_PATH="${WEBI_DOWNLOAD_DIR}/webi/${PKG_NAME:-error}/${WEBI_VERSION:-latest}"
|
|
|
|
export WEBI_HOST
|
|
|
|
##
|
|
## Set up tmp, download, and install directories
|
|
##
|
|
|
|
WEBI_TMP=${WEBI_TMP:-"$(mktemp -d -t webinstall-"${WEBI_PKG-}".XXXXXXXX)"}
|
|
export _webi_tmp="${_webi_tmp:-"$HOME/.local/opt/webi-tmp.d"}"
|
|
|
|
mkdir -p "${WEBI_PKG_PATH}"
|
|
mkdir -p "$HOME/.local/bin"
|
|
mkdir -p "$HOME/.local/opt"
|
|
|
|
##
|
|
## Detect http client
|
|
##
|
|
set +e
|
|
WEBI_CURL="$(command -v curl)"
|
|
export WEBI_CURL
|
|
WEBI_WGET="$(command -v wget)"
|
|
export WEBI_WGET
|
|
set -e
|
|
|
|
# get the special formatted version
|
|
# (i.e. "go is go1.14" while node is "node v12.10.8")
|
|
my_versioned_name=""
|
|
_webi_canonical_name() {
|
|
if [ -n "$my_versioned_name" ]; then
|
|
echo "$my_versioned_name"
|
|
return 0
|
|
fi
|
|
|
|
if command -v pkg_format_cmd_version > /dev/null; then
|
|
my_versioned_name="'$(pkg_format_cmd_version "$WEBI_VERSION")'"
|
|
else
|
|
my_versioned_name="'$pkg_cmd_name v$WEBI_VERSION'"
|
|
fi
|
|
|
|
echo "$my_versioned_name"
|
|
}
|
|
|
|
# Update symlinks as per $HOME/.local/opt and $HOME/.local/bin install paths.
|
|
webi_link() {
|
|
if command -v pkg_link > /dev/null; then
|
|
pkg_link
|
|
return 0
|
|
fi
|
|
|
|
if test -n "${WEBI_SINGLE}"; then
|
|
rm -rf "$pkg_dst_cmd"
|
|
ln -s "$pkg_src_cmd" "$pkg_dst_cmd"
|
|
else
|
|
# 'pkg_dst' will default to $HOME/.local/opt/<pkg>
|
|
# 'pkg_src' will be the installed version,
|
|
# such as to $HOME/.local/opt/<pkg>-<version>
|
|
rm -rf "$pkg_dst"
|
|
ln -s "$pkg_src" "$pkg_dst"
|
|
fi
|
|
}
|
|
|
|
# detect if this program is already installed
|
|
# or if an installed version may cause conflict
|
|
webi_check_installed() {
|
|
# Test for existing version
|
|
set +e
|
|
my_path="$PATH"
|
|
PATH="$(dirname "$pkg_dst_cmd"):$PATH"
|
|
export PATH
|
|
my_current_cmd="$(command -v "$pkg_cmd_name")"
|
|
set -e
|
|
if [ -n "$my_current_cmd" ]; then
|
|
my_canonical_name="$(_webi_canonical_name)"
|
|
if [ "$my_current_cmd" != "$pkg_dst_cmd" ]; then
|
|
echo >&2 "WARN: possible PATH conflict between $my_canonical_name and currently installed version"
|
|
echo >&2 " ${pkg_dst_cmd} (new)"
|
|
echo >&2 " ${my_current_cmd} (existing)"
|
|
#my_current_version=false
|
|
fi
|
|
# 'readlink' can't read links in paths on macOS 🤦
|
|
# but that's okay, 'cmp -s' is good enough for us
|
|
if cmp -s "${pkg_src_cmd}" "${my_current_cmd}"; then
|
|
echo "${my_canonical_name} already installed:"
|
|
my_dst_rel="$(
|
|
webi_sub_home "${pkg_dst}"
|
|
)"
|
|
printf " %s" "${my_dst_rel}"
|
|
if [ "${pkg_src_cmd}" != "${my_current_cmd}" ]; then
|
|
my_src_rel="$(
|
|
webi_sub_home "${pkg_src}"
|
|
)"
|
|
printf " => %s" "${my_src_rel}"
|
|
fi
|
|
echo ""
|
|
exit 0
|
|
fi
|
|
if [ -x "$pkg_src_cmd" ]; then
|
|
webi_link
|
|
echo "switched to $my_canonical_name:"
|
|
my_src_rel="$(
|
|
webi_sub_home "${pkg_src}"
|
|
)"
|
|
my_dst_rel="$(
|
|
webi_sub_home "${pkg_dst}"
|
|
)"
|
|
echo " ${my_dst_rel} => ${my_src_rel}"
|
|
exit 0
|
|
fi
|
|
fi
|
|
export PATH="$my_path"
|
|
}
|
|
|
|
webi_check_available() {
|
|
if test "$WEBI_CHANNEL" != "error"; then
|
|
return 0
|
|
fi
|
|
|
|
echo >&2 "Error: no '$PKG_NAME' release for '${WEBI_OS-}' on '$WEBI_ARCH' as one of '$WEBI_FORMATS' by the tag '${WEBI_TAG-}'"
|
|
echo >&2 " '$PKG_NAME' is available for '$PKG_OSES' on '$PKG_ARCHES' as one of '$PKG_FORMATS'"
|
|
echo >&2 " (check that the package name and version are correct)"
|
|
echo >&2 ""
|
|
my_release_url="$(
|
|
echo "$WEBI_RELEASES" |
|
|
sed 's:\?.*::'
|
|
)"
|
|
echo >&2 " Double check at ${my_release_url}"
|
|
echo >&2 ""
|
|
|
|
exit 1
|
|
}
|
|
|
|
is_interactive_shell() {
|
|
# $- shows shell flags (error,unset,interactive,etc)
|
|
case $- in
|
|
*i*)
|
|
# true
|
|
return 0
|
|
;;
|
|
*)
|
|
# false
|
|
return 1
|
|
;;
|
|
esac
|
|
}
|
|
|
|
webi_sub_home() { (
|
|
my_rel=${HOME}
|
|
my_abs=${1}
|
|
echo "${my_abs}" | sed "s:^${my_rel}:~:"
|
|
); }
|
|
|
|
# detect if file is downloaded, and how to download it
|
|
webi_download() {
|
|
my_url="${1}"
|
|
my_dl="${2}"
|
|
my_dl_name="${3:-${PKG_NAME}}"
|
|
|
|
my_dl_rel="$(
|
|
webi_sub_home "${my_dl}"
|
|
)"
|
|
|
|
WEBI_PKG_DOWNLOAD="${my_dl}"
|
|
export WEBI_PKG_DOWNLOAD
|
|
|
|
if [ -e "${my_dl}" ]; then
|
|
echo "Found ${my_dl_rel}"
|
|
return 0
|
|
fi
|
|
|
|
echo "Downloading ${my_dl_name} from"
|
|
echo "$my_url"
|
|
|
|
# It's only 2020, we can't expect to have reliable CLI tools
|
|
# to tell us the size of a file as part of a base system...
|
|
if [ -n "$WEBI_WGET" ]; then
|
|
# wget has resumable downloads
|
|
# TODO wget -c --content-disposition "$my_url"
|
|
set +e
|
|
my_show_progress=""
|
|
if is_interactive_shell; then
|
|
my_show_progress="--show-progress"
|
|
fi
|
|
if ! wget -q $my_show_progress --user-agent="wget $WEBI_UA" -c "$my_url" -O "$my_dl.part"; then
|
|
echo >&2 "failed to download from $WEBI_PKG_URL"
|
|
exit 1
|
|
fi
|
|
set -e
|
|
else
|
|
# Neither GNU nor BSD curl have sane resume download options, hence we don't bother
|
|
my_show_progress="-#"
|
|
if is_interactive_shell; then
|
|
my_show_progress=""
|
|
fi
|
|
# shellcheck disable=SC2086
|
|
# we want the flags to be split
|
|
curl -fSL $my_show_progress -H "User-Agent: curl $WEBI_UA" "$my_url" -o "$my_dl.part"
|
|
fi
|
|
mv "$my_dl.part" "$my_dl"
|
|
|
|
echo ""
|
|
echo "Saved as ${my_dl_rel}"
|
|
}
|
|
|
|
webi_git_clone() { (
|
|
my_url="${1}"
|
|
my_dl="${2}"
|
|
|
|
my_dl_rel="$(
|
|
webi_sub_home "${my_dl}"
|
|
)"
|
|
if [ -e "${my_dl}" ]; then
|
|
echo "Found ${my_dl_rel}"
|
|
|
|
cp -RPp "${my_dl}" "${WEBI_TMP}/${WEBI_PKG_FILE}/"
|
|
return 0
|
|
fi
|
|
|
|
echo "Cloning ${my_url}"
|
|
cmd_git="git clone --config advice.detachedHead=false --quiet --depth=1 --single-branch"
|
|
rm -rf "${my_dl}.part"
|
|
if ! $cmd_git "${my_url}" --branch "${WEBI_GIT_TAG}" "${my_dl}.part"; then
|
|
echo >&2 "failed to git clone ${WEBI_PKG_URL}"
|
|
exit 1
|
|
fi
|
|
mv "${my_dl}.part" "${my_dl}"
|
|
|
|
cp -RPp "${my_dl}" "${WEBI_TMP}/${WEBI_PKG_FILE}/"
|
|
); }
|
|
|
|
# detect which archives can be used
|
|
webi_extract() {
|
|
(
|
|
cd "$WEBI_TMP"
|
|
|
|
my_dl_rel="$(
|
|
webi_sub_home "${WEBI_PKG_PATH}/${WEBI_PKG_FILE}"
|
|
)"
|
|
if [ "tar" = "$WEBI_EXT" ]; then
|
|
echo "Extracting ${my_dl_rel}"
|
|
tar xf "${WEBI_PKG_PATH}/$WEBI_PKG_FILE"
|
|
elif [ "zip" = "$WEBI_EXT" ]; then
|
|
echo "Extracting ${my_dl_rel}"
|
|
unzip "${WEBI_PKG_PATH}/$WEBI_PKG_FILE" > __unzip__.log
|
|
elif [ "exe" = "$WEBI_EXT" ]; then
|
|
echo "Moving ${my_dl_rel}"
|
|
mv "${WEBI_PKG_PATH}/$WEBI_PKG_FILE" .
|
|
elif [ "git" = "$WEBI_EXT" ]; then
|
|
echo "Moving ${my_dl_rel}"
|
|
mv "${WEBI_PKG_PATH}/$WEBI_PKG_FILE" .
|
|
elif [ "xz" = "$WEBI_EXT" ]; then
|
|
echo "Inflating ${my_dl_rel}"
|
|
unxz -c "${WEBI_PKG_PATH}/$WEBI_PKG_FILE" > "$(basename "$WEBI_PKG_FILE")"
|
|
else
|
|
echo "Failed to extract ${WEBI_PKG_PATH}/$WEBI_PKG_FILE"
|
|
exit 1
|
|
fi
|
|
)
|
|
}
|
|
|
|
# use 'pathman' to update $HOME/.config/envman/PATH.env
|
|
webi_path_add() {
|
|
my_path="${1}"
|
|
|
|
fn_envman_init
|
|
|
|
# \v was chosen as it is extremely unlikely for a filename
|
|
# \1 could be an even better choice, but needs more testing.
|
|
# (currently tested working on: linux & mac)
|
|
# "\0001" should also work
|
|
my_delim="$(
|
|
printf '\v'
|
|
)"
|
|
|
|
my_path_expanded="$(
|
|
echo "${my_path}" |
|
|
sed -e "s${my_delim}\$HOME${my_delim}$HOME${my_delim}g" \
|
|
-e "s${my_delim}\${HOME}${my_delim}$HOME${my_delim}g" \
|
|
-e "s${my_delim}^~/${my_delim}$HOME/${my_delim}g"
|
|
)"
|
|
|
|
# A gift for @adamcstephens.
|
|
# See https://github.com/webinstall/webi-installers/issues/322
|
|
case "${PATH}" in
|
|
# matches whether the first, a middle, the last, or the only PATH entry
|
|
"${my_path_expanded}":* | \
|
|
*:"${my_path_expanded}":* | \
|
|
*:"${my_path_expanded}" | \
|
|
"${my_path_expanded}")
|
|
|
|
if fn_is_defined_in_all_shells "${my_path}"; then
|
|
return 0
|
|
fi
|
|
;;
|
|
*) ;;
|
|
esac
|
|
|
|
my_path_export="$(
|
|
echo "${my_path}" |
|
|
sed -e "s${my_delim}${HOME}${my_delim}\$HOME${my_delim}g" \
|
|
-e "s${my_delim}\${HOME}${my_delim}\$HOME${my_delim}g" \
|
|
-e "s${my_delim}^~/${my_delim}\$HOME/${my_delim}g"
|
|
)"
|
|
|
|
my_export="export PATH=\"$my_path_export:\$PATH\""
|
|
if grep -q -F "${my_export}" ~/.config/envman/PATH.env; then
|
|
return 0
|
|
fi
|
|
|
|
echo "${my_export}" >> ~/.config/envman/PATH.env
|
|
|
|
mkdir -p "$_webi_tmp"
|
|
my_path_tilde="$(
|
|
echo "${my_path}" |
|
|
sed -e "s${my_delim}${HOME}${my_delim}~${my_delim}g"
|
|
)"
|
|
|
|
if ! test -f "$_webi_tmp/.PATH.env" ||
|
|
! grep -q -F "${my_path_tilde}" "$_webi_tmp/.PATH.env"; then
|
|
echo "${my_path_tilde}" >> "$_webi_tmp/.PATH.env"
|
|
fi
|
|
}
|
|
|
|
fn_envman_init() {
|
|
mkdir -p ~/.config/envman/
|
|
if ! test -e ~/.config/envman/PATH.env; then
|
|
touch ~/.config/envman/PATH.env
|
|
fi
|
|
|
|
if ! test -e ~/.config/envman/load.sh; then
|
|
# shellcheck disable=SC2016
|
|
{
|
|
echo '# Generated for envman. Do not edit.'
|
|
echo 'for x in ~/.config/envman/*.env; do'
|
|
echo ' my_basename="$(basename "${x}")"'
|
|
echo ' if [ "*.env" = "${my_basename}" ]; then'
|
|
echo ' continue'
|
|
echo ' fi'
|
|
echo ''
|
|
echo ' # shellcheck source=/dev/null'
|
|
echo ' . "${x}"'
|
|
echo 'done'
|
|
} > ~/.config/envman/load.sh
|
|
fi
|
|
|
|
if command -v sh > /dev/null; then
|
|
if test -e ~/.profile; then
|
|
if ! grep -q -F '/.config/envman/load.sh' ~/.profile; then
|
|
fn_echo_load_sh >> ~/.profile
|
|
fi
|
|
fi
|
|
fi
|
|
if command -v bash > /dev/null; then
|
|
if test -e ~/.bashrc; then
|
|
if ! grep -q -F '/.config/envman/load.sh' ~/.bashrc; then
|
|
fn_echo_load_sh >> ~/.bashrc
|
|
fi
|
|
fi
|
|
fi
|
|
if command -v zsh > /dev/null; then
|
|
if test -e ~/.zshrc; then
|
|
if ! grep -q -F '/.config/envman/load.sh' ~/.zshrc; then
|
|
fn_echo_load_sh >> ~/.zshrc
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if command -v fish > /dev/null; then
|
|
if test ! -e ~/.config/envman/load.fish; then
|
|
# shellcheck disable=SC2016
|
|
{
|
|
echo '# Generated for envman. Do not edit.'
|
|
echo 'for x in ~/.config/envman/*.env'
|
|
echo ' source "$x"'
|
|
echo 'end'
|
|
} > ~/.config/envman/load.fish
|
|
fi
|
|
|
|
mkdir -p ~/.config/fish
|
|
if test -e ~/.config/fish/config.fish; then
|
|
touch ~/.config/fish/config.fish
|
|
fi
|
|
if ! grep -q -F '/.config/envman/load.fish' ~/.config/fish/config.fish; then
|
|
fn_echo_load_fish >> ~/.config/fish/config.fish
|
|
fi
|
|
fi
|
|
}
|
|
|
|
fn_echo_load_fish() {
|
|
echo ''
|
|
echo '# Generated for envman. Do not edit.'
|
|
# shellcheck disable=SC2016
|
|
echo 'test -s "$HOME/.config/envman/load.fish"; and source "$HOME/.config/envman/load.fish"'
|
|
}
|
|
|
|
fn_echo_load_sh() {
|
|
echo ''
|
|
echo '# Generated for envman. Do not edit.'
|
|
# shellcheck disable=SC2016
|
|
echo '[ -s "$HOME/.config/envman/load.sh" ] && source "$HOME/.config/envman/load.sh"'
|
|
}
|
|
|
|
fn_is_defined_in_all_shells() {
|
|
my_path="${1}"
|
|
|
|
my_path_expanded="$(
|
|
echo "${my_path}" |
|
|
sed -e "s${my_delim}\$HOME|${my_delim}$HOME${my_delim}g" \
|
|
-e "s${my_delim}\${HOME}${my_delim}$HOME${my_delim}g" \
|
|
-e "s${my_delim}^~/${my_delim}$HOME/${my_delim}g"
|
|
)"
|
|
my_paths="$(
|
|
echo "${my_path_expanded}"
|
|
# $HOME/foo
|
|
echo "${my_path_expanded}" |
|
|
sed "s${my_delim}${HOME}${my_delim}\$HOME${my_delim}g"
|
|
# ${HOME}/foo
|
|
echo "${my_path_expanded}" |
|
|
sed "s${my_delim}${HOME}${my_delim}\${HOME}${my_delim}g"
|
|
echo "${my_path}"
|
|
)"
|
|
|
|
my_confs="$(
|
|
echo "${HOME}/.profile"
|
|
echo "${HOME}/.bashrc"
|
|
echo "${HOME}/.zshrc"
|
|
echo "${HOME}/.config/fish/config.fish"
|
|
)"
|
|
for my_conf in $my_confs; do
|
|
if test -e "${my_conf}"; then
|
|
if ! grep -q -F "${my_paths}" "${my_conf}"; then
|
|
return 1
|
|
fi
|
|
fi
|
|
done
|
|
}
|
|
|
|
# group common pre-install tasks as default
|
|
webi_pre_install() {
|
|
webi_check_installed
|
|
webi_check_available
|
|
if test "git" = "${WEBI_EXT}"; then
|
|
webi_git_clone \
|
|
"${WEBI_PKG_URL}" \
|
|
"${WEBI_PKG_PATH}/${WEBI_PKG_FILE}"
|
|
return 0
|
|
fi
|
|
webi_download \
|
|
"${WEBI_PKG_URL}" \
|
|
"${WEBI_PKG_PATH}/${WEBI_PKG_FILE}"
|
|
webi_extract
|
|
}
|
|
|
|
# move commands from the extracted archive directory
|
|
# to $HOME/.local/opt or $HOME/.local/bin
|
|
webi_install() {
|
|
if test -n "${WEBI_SINGLE}"; then
|
|
mkdir -p "$(dirname "$pkg_src_cmd")"
|
|
mv ./"$pkg_cmd_name"* "$pkg_src_cmd"
|
|
else
|
|
rm -rf "$pkg_src"
|
|
mv ./"$pkg_cmd_name"* "$pkg_src"
|
|
fi
|
|
}
|
|
|
|
# run post-install functions - just updating PATH by default
|
|
webi_post_install() {
|
|
webi_path_add "$(dirname "$pkg_dst_cmd")"
|
|
}
|
|
|
|
_webi_enable_exec() {
|
|
if command -v spctl > /dev/null && command -v xattr > /dev/null; then
|
|
# note: some packages contain files that cannot be affected by xattr
|
|
xattr -r -d com.apple.quarantine "$pkg_src" || true
|
|
return 0
|
|
fi
|
|
}
|
|
|
|
_webi_done_message() {
|
|
my_dst_rel="$(
|
|
webi_sub_home "${pkg_dst_cmd}"
|
|
)"
|
|
my_canonical_name="$(
|
|
_webi_canonical_name
|
|
)"
|
|
echo "Installed ${my_canonical_name} as ${my_dst_rel}"
|
|
}
|
|
|
|
##
|
|
##
|
|
## BEGIN custom override functions from <package>/install.sh
|
|
##
|
|
##
|
|
|
|
WEBI_SINGLE=
|
|
|
|
if [ -z "${WEBI_WELCOME-}" ]; then
|
|
echo ""
|
|
printf "Thanks for using webi to install '\e[32m%s\e[0m' on '\e[33m%s/%s\e[0m'.\n" "${WEBI_PKG-}" "$(uname -s)" "$(uname -m)"
|
|
echo "Have a problem? Experience a bug? Please let us know:"
|
|
printf " \e[2m\e[36mhttps://github.com/webinstall/webi-installers/issues\e[0m\n"
|
|
echo ""
|
|
printf "\e[35mLovin'\e[0m it? Say thanks with a \e[1m\e[33mStar on GitHub\e[0m:\n"
|
|
printf " \e[36mhttps://github.com/webinstall/webi-installers\e[0m\n"
|
|
echo ""
|
|
fi
|
|
|
|
WEBI_WELCOME=true
|
|
export WEBI_WELCOME
|
|
|
|
__init_installer() {
|
|
# the installer will be injected here
|
|
# {{ installer }}
|
|
|
|
return 0
|
|
}
|
|
|
|
__init_installer
|
|
|
|
##
|
|
##
|
|
## END custom override functions
|
|
##
|
|
##
|
|
|
|
# run everything with defaults or overrides as needed
|
|
if command -v pkg_install > /dev/null ||
|
|
command -v pkg_link > /dev/null ||
|
|
command -v pkg_post_install > /dev/null ||
|
|
command -v pkg_done_message > /dev/null ||
|
|
command -v pkg_format_cmd_version > /dev/null ||
|
|
[ -n "${WEBI_SINGLE-}" ] ||
|
|
[ -n "${pkg_cmd_name-}" ] ||
|
|
[ -n "${pkg_dst_cmd-}" ] ||
|
|
[ -n "${pkg_dst_dir-}" ] ||
|
|
[ -n "${pkg_dst-}" ] ||
|
|
[ -n "${pkg_src_cmd-}" ] ||
|
|
[ -n "${pkg_src_dir-}" ] ||
|
|
[ -n "${pkg_src-}" ]; then
|
|
|
|
pkg_cmd_name="${pkg_cmd_name:-$PKG_NAME}"
|
|
|
|
pkg_no_exec="${pkg_no_exec:-}"
|
|
|
|
if [ -n "${pkg_no_exec}" ]; then
|
|
pkg_dst_cmd="${pkg_dst}"
|
|
pkg_src="${pkg_dst}"
|
|
pkg_src_cmd="${pkg_dst}"
|
|
elif [ -n "${WEBI_SINGLE}" ]; then
|
|
pkg_dst_cmd="${pkg_dst_cmd:-$HOME/.local/bin/$pkg_cmd_name}"
|
|
pkg_dst="$pkg_dst_cmd"
|
|
|
|
#pkg_src_cmd="${pkg_src_cmd:-$HOME/.local/opt/$pkg_cmd_name-v$WEBI_VERSION/bin/$pkg_cmd_name-v$WEBI_VERSION}"
|
|
pkg_src_cmd="${pkg_src_cmd:-$HOME/.local/opt/$pkg_cmd_name-v$WEBI_VERSION/bin/$pkg_cmd_name}"
|
|
pkg_src="$pkg_src_cmd"
|
|
else
|
|
pkg_dst="${pkg_dst:-$HOME/.local/opt/$pkg_cmd_name}"
|
|
pkg_dst_cmd="${pkg_dst_cmd:-$pkg_dst/bin/$pkg_cmd_name}"
|
|
|
|
pkg_src="${pkg_src:-$HOME/.local/opt/$pkg_cmd_name-v$WEBI_VERSION}"
|
|
pkg_src_cmd="${pkg_src_cmd:-$pkg_src/bin/$pkg_cmd_name}"
|
|
fi
|
|
# shellcheck disable=SC2034 # used in ${WEBI_PKG}/install.sh
|
|
pkg_src_bin="$(dirname "$pkg_src_cmd")"
|
|
# shellcheck disable=SC2034 # used in ${WEBI_PKG}/install.sh
|
|
pkg_dst_bin="$(dirname "$pkg_dst_cmd")"
|
|
|
|
if command -v pkg_pre_install > /dev/null; then pkg_pre_install; else webi_pre_install; fi
|
|
|
|
(
|
|
cd "$WEBI_TMP"
|
|
my_src_rel="$(
|
|
webi_sub_home "${pkg_src_cmd}"
|
|
)"
|
|
if test -e "${pkg_src_cmd}"; then
|
|
echo "Found ${my_src_rel} (remove to force reinstall)"
|
|
else
|
|
echo "Installing to ${my_src_rel}"
|
|
if command -v pkg_install > /dev/null; then pkg_install; else webi_install; fi
|
|
chmod a+x "$pkg_src"
|
|
chmod a+x "$pkg_src_cmd"
|
|
fi
|
|
)
|
|
|
|
webi_link
|
|
|
|
if test -z "${pkg_no_exec}"; then
|
|
_webi_enable_exec
|
|
fi
|
|
(
|
|
cd "$WEBI_TMP"
|
|
if command -v pkg_post_install > /dev/null; then pkg_post_install; else webi_post_install; fi
|
|
)
|
|
|
|
(
|
|
cd "$WEBI_TMP"
|
|
if command -v pkg_done_message > /dev/null; then pkg_done_message; else _webi_done_message; fi
|
|
)
|
|
|
|
echo ""
|
|
fi
|
|
|
|
webi_path_add "$HOME/.local/bin"
|
|
if [ -z "${_WEBI_CHILD-}" ] && [ -f "$_webi_tmp/.PATH.env" ]; then
|
|
if test -s "$_webi_tmp/.PATH.env"; then
|
|
printf 'PATH.env updated with:\n'
|
|
sort -u "$_webi_tmp/.PATH.env" | while read -r my_new_path; do
|
|
echo " ${my_new_path}"
|
|
done
|
|
printf "\n"
|
|
|
|
rm -f "$_webi_tmp/.PATH.env"
|
|
|
|
printf "\e[1m\e[35mTO FINISH\e[0m: copy, paste & run the following command:\n"
|
|
printf "\n"
|
|
printf " \e[1m\e[32msource ~/.config/envman/PATH.env\e[0m\n"
|
|
printf " (newly opened terminal windows will update automatically)\n"
|
|
fi
|
|
fi
|
|
|
|
rm -rf "$WEBI_TMP"
|
|
}
|
|
|
|
__bootstrap_webi
|