Neovim Install Script

#!/usr/bin/env bash
#
# Copyright (C) 2023 Ronald Record <ronaldrecord@gmail.com>
# Copyright (C) 2022 Michael Peter <michaeljohannpeter@gmail.com>
#
# Install Neovim and all dependencies for the Neovim config at:
# https://github.com/doctorfree/nvim-lazyman
#
# shellcheck disable=SC2001,SC2016,SC2006,SC2086,SC2181,SC2129,SC2059,SC2164
DOC_HOMEBREW="https://docs.brew.sh"
BREW_EXE="brew"
HOMEBREW_HOME=
PYTHON=
export PATH=${HOME}/.local/bin:${PATH}
abort() {
 printf "\nERROR: %s\n" "$@" >&2
 exit 1
}
log() {
 [ "$quiet" ] || {
 printf "\n\t%s" "$@"
 }
}
calc_elapsed() {
 FINISH_SECONDS=$(date +%s)
 ELAPSECS=$((FINISH_SECONDS - START_SECONDS))
 ELAPSED=$(eval "echo $(date -ud "@$ELAPSECS" +'$((%s/3600/24)) days %H hr %M min %S sec')")
}
check_prerequisites() {
 if [ "${BASH_VERSION:-}" = "" ]; then
 abort "Bash is required to interpret this script."
 fi
 [ "${BASH_VERSINFO:-0}" -ge 4 ] || install_bash=1
 if [[ $EUID -eq 0 ]]; then
 abort "Script must not be run as root user"
 fi
}
get_platform() {
 platform=$(uname -s)
 if [ "$platform" == "Darwin" ]; then
 darwin=1
 else
 if [ -f /etc/os-release ]; then
 . /etc/os-release
 [ "${ID}" == "debian" ] || [ "${ID_LIKE}" == "debian" ] && debian=1
 [ "${ID}" == "arch" ] || [ "${ID_LIKE}" == "arch" ] && arch=1
 [ "${ID}" == "alpine" ] && alpine=1
 [ "${ID}" == "fedora" ] && redhat=1
 [ "${ID}" == "centos" ] && redhat=1
 [ "${ID}" == "opensuse" ] && suse=1
 [ "${ID}" == "void" ] && void=1
 [ "${alpine}" ] || [ "${arch}" ] || [ "${debian}" ] \
 || [ "${redhat}" ] || [ "${suse}" ] || [ "${void}" ] || {
 echo "${ID_LIKE}" | grep debian >/dev/null && debian=1
 echo "${ID_LIKE}" | grep suse >/dev/null && suse=1
 echo "${ID_LIKE}" | grep void >/dev/null && void=1
 }
 else
 if [ -f /etc/arch-release ]; then
 arch=1
 else
 if [ "${have_apt}" ]; then
 debian=1
 else
 if [ -f /etc/fedora-release ]; then
 redhat=1
 else
 if [ "${have_dnf}" ] || [ "${have_yum}" ]; then
 redhat=1
 else
 if [ "${have_zyp}" ]; then
 suse=1
 else
 if [ "${have_xbps}" ]; then
 void=1
 else
 if [ "${have_apk}" ]; then
 alpine=1
 else
 printf "\nUnknown operating system distribution\n"
 fi
 fi
 fi
 fi
 fi
 fi
 fi
 fi
 fi
 [ "${debian}" ] && {
 PKGMGR="APT"
 if [ "${have_apt}" ]; then
 APT="apt -q -y"
 else
 if [ "${have_aptget}" ]; then
 APT="apt-get -q -y"
 else
 printf "\nCould not locate apt or apt-get"
 printf "\nUsing Homebrew to install Neovim dependencies and tools\n"
 native=
 fi
 fi
 }
 [ "${redhat}" ] && {
 if [ "${have_dnf}" ]; then
 DNF="dnf --assumeyes --quiet"
 PKGMGR="DNF"
 else
 if [ "${have_yum}" ]; then
 DNF="yum --assumeyes --quiet"
 PKGMGR="YUM"
 else
 printf "\nCould not locate dnf or yum"
 printf "\nUsing Homebrew to install Neovim dependencies and tools\n"
 native=
 fi
 fi
 }
 [ "${suse}" ] && {
 if [ "${have_zyp}" ]; then
 PKGMGR="DNF"
 else
 printf "\nCould not locate zypper"
 printf "\nUsing Homebrew to install Neovim dependencies and tools\n"
 native=
 fi
 }
 [ "${alpine}" ] && {
 if [ "${have_apk}" ]; then
 PKGMGR="APK"
 else
 printf "\nCould not locate apk"
 printf "\nUsing Homebrew to install Neovim dependencies and tools\n"
 native=
 fi
 }
 [ "${arch}" ] && {
 if [ "${have_pac}" ]; then
 PKGMGR="PACMAN"
 else
 printf "\nCould not locate pacman"
 printf "\nUsing Homebrew to install Neovim dependencies and tools\n"
 native=
 fi
 }
 [ "${void}" ] && {
 if [ "${have_xbps}" ]; then
 PKGMGR="XBPS"
 else
 printf "\nCould not locate xbps-install"
 printf "\nUsing Homebrew to install Neovim dependencies and tools\n"
 native=
 fi
 }
}
# Compare two version strings [1ドル: version string 1 (v1), 2ドル: version string 2 (v2)]
# Return values:
# 0: v1 == v2
# 1: v1 > v2
# 2: v1 < v2
# Based on https://stackoverflow.com/a/4025065 by Dennis Williamson
# and https://stackoverflow.com/questions/4023830/how-to-compare-two-strings-in-dot-separated-version-format-in-bash/49351294#49351294 by Github user @fonic
compare_versions() {
 # Trivial v1 == v2 test based on string comparison
 [[ "1ドル" == "2ドル" ]] && return 0
 # Local variables
 local regex="^(.*)-r([0-9]*)$" va1=() vr1=0 va2=() vr2=0 len i IFS="."
 # Split version strings into arrays, extract trailing revisions
 if [[ "1ドル" =~ ${regex} ]]; then
 va1=("${BASH_REMATCH[1]}")
 [[ -n "${BASH_REMATCH[2]}" ]] && vr1=${BASH_REMATCH[2]}
 else
 va1=("1ドル")
 fi
 if [[ "2ドル" =~ ${regex} ]]; then
 va2=("${BASH_REMATCH[1]}")
 [[ -n "${BASH_REMATCH[2]}" ]] && vr2=${BASH_REMATCH[2]}
 else
 va2=("2ドル")
 fi
 # Bring va1 and va2 to same length by filling empty fields with zeros
 ((${#va1[@]} > ${#va2[@]})) && len=${#va1[@]} || len=${#va2[@]}
 for ((i = 0; i < len; ++i)); do
 [[ -z "${va1[i]}" ]] && va1[i]="0"
 [[ -z "${va2[i]}" ]] && va2[i]="0"
 done
 # Append revisions, increment length
 va1+=("$vr1")
 va2+=("$vr2")
 len=$((len + 1))
 # Compare version elements, check if v1 > v2 or v1 < v2
 for ((i = 0; i < len; ++i)); do
 if ((10#${va1[i]} > 10#${va2[i]})); then
 return 1
 elif ((10#${va1[i]} < 10#${va2[i]})); then
 return 2
 fi
 done
 # All elements are equal, thus v1 == v2
 return 0
}
install_homebrew() {
 if ! command -v brew >/dev/null 2>&1; then
 [ "$debug" ] && START_SECONDS=$(date +%s)
 log "Installing Homebrew ..."
 BREW_URL="https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh"
 curl -fsSL "$BREW_URL" >/tmp/brew-$$.sh
 [ $? -eq 0 ] || {
 rm -f /tmp/brew-$$.sh
 curl -kfsSL "$BREW_URL" >/tmp/brew-$$.sh
 }
 [ -f /tmp/brew-$$.sh ] || abort "Brew install script download failed"
 chmod 755 /tmp/brew-$$.sh
 NONINTERACTIVE=1 /bin/bash -c "/tmp/brew-$$.sh" >/dev/null 2>&1
 rm -f /tmp/brew-$$.sh
 export HOMEBREW_NO_INSTALL_CLEANUP=1
 export HOMEBREW_NO_ENV_HINTS=1
 export HOMEBREW_NO_AUTO_UPDATE=1
 [ "$quiet" ] || printf " done"
 if [ -x /home/linuxbrew/.linuxbrew/bin/brew ]; then
 HOMEBREW_HOME="/home/linuxbrew/.linuxbrew"
 BREW_EXE="${HOMEBREW_HOME}/bin/brew"
 else
 if [ -x /usr/local/bin/brew ]; then
 HOMEBREW_HOME="/usr/local"
 BREW_EXE="${HOMEBREW_HOME}/bin/brew"
 else
 if [ -x /opt/homebrew/bin/brew ]; then
 HOMEBREW_HOME="/opt/homebrew"
 BREW_EXE="${HOMEBREW_HOME}/bin/brew"
 else
 abort "Homebrew brew executable could not be located"
 fi
 fi
 fi
 if [ -f "${HOME}/.bashrc" ]; then
 grep "eval \"\$(${BREW_EXE} shellenv)\"" "${HOME}/.bashrc" >/dev/null || {
 echo 'if [ -x XXX ]; then' | sed -e "s%XXX%${BREW_EXE}%" >>"${HOME}/.bashrc"
 echo ' eval "$(XXX shellenv)"' | sed -e "s%XXX%${BREW_EXE}%" >>"${HOME}/.bashrc"
 echo 'fi' >>"${HOME}/.bashrc"
 }
 else
 echo 'if [ -x XXX ]; then' | sed -e "s%XXX%${BREW_EXE}%" >"${HOME}/.bashrc"
 echo ' eval "$(XXX shellenv)"' | sed -e "s%XXX%${BREW_EXE}%" >>"${HOME}/.bashrc"
 echo 'fi' >>"${HOME}/.bashrc"
 fi
 [ -f "${HOME}/.zshrc" ] && {
 grep "eval \"\$(${BREW_EXE} shellenv)\"" "${HOME}/.zshrc" >/dev/null || {
 echo 'if [ -x XXX ]; then' | sed -e "s%XXX%${BREW_EXE}%" >>"${HOME}/.zshrc"
 echo ' eval "$(XXX shellenv)"' | sed -e "s%XXX%${BREW_EXE}%" >>"${HOME}/.zshrc"
 echo 'fi' >>"${HOME}/.zshrc"
 }
 }
 [ "$debug" ] && {
 calc_elapsed
 printf "\nHomebrew install elapsed time = ${ELAPSED}\n"
 }
 log "Homebrew installed in ${HOMEBREW_HOME}"
 log "See ${DOC_HOMEBREW}"
 fi
 eval "$("$BREW_EXE" shellenv)"
 have_brew=$(type -p brew)
 [ "$have_brew" ] && BREW_EXE="brew"
 [ "$HOMEBREW_HOME" ] || {
 brewpath=$(command -v brew)
 if [ $? -eq 0 ]; then
 HOMEBREW_HOME=$(dirname "$brewpath" | sed -e "s%/bin$%%")
 else
 HOMEBREW_HOME="Unknown"
 fi
 }
}
brew_install() {
 brewpkg="1ドル"
 if command -v "$brewpkg" >/dev/null 2>&1; then
 log "Using previously installed ${brewpkg}"
 else
 log "Installing ${brewpkg} ..."
 [ "$debug" ] && START_SECONDS=$(date +%s)
 "$BREW_EXE" install --quiet "$brewpkg" >/dev/null 2>&1
 [ $? -eq 0 ] || "$BREW_EXE" link --overwrite --quiet "$brewpkg" >/dev/null 2>&1
 [ "$quiet" ] || printf " done"
 if [ "$debug" ]; then
 calc_elapsed
 printf " elapsed time = %s${ELAPSED}"
 fi
 fi
}
platform_install() {
 platpkg="1ドル"
 if [ "2ドル" ]; then
 pkgname="2ドル"
 else
 pkgname="$platpkg"
 fi
 if command -v "$pkgname" >/dev/null 2>&1; then
 log "Using previously installed ${platpkg}"
 else
 log "Installing ${platpkg} ..."
 [ "$debug" ] && START_SECONDS=$(date +%s)
 if [ "${debian}" ]; then
 if [ "${APT}" ]; then
 sudo ${APT} install ${platpkg} >/dev/null 2>&1
 else
 [ "${quiet}" ] || printf "\n\t\tCannot locate apt to install. Skipping ..."
 fi
 else
 if [ "${redhat}" ]; then
 if [ "${DNF}" ]; then
 sudo ${DNF} install ${platpkg} >/dev/null 2>&1
 else
 [ "${quiet}" ] || {
 printf "\n\t\tCannot locate dnf to install. Skipping ..."
 }
 fi
 else
 [ "${arch}" ] && {
 if [ "${have_pac}" ]; then
 sudo pacman -S --noconfirm ${platpkg} >/dev/null 2>&1
 else
 [ "${quiet}" ] || {
 printf "\n\t\tCannot locate pacman to install. Skipping ..."
 }
 fi
 }
 [ "${suse}" ] && {
 if [ "${have_zyp}" ]; then
 sudo zypper install ${platpkg} >/dev/null 2>&1
 else
 [ "${quiet}" ] || {
 printf "\n\t\tCannot locate zypper to install. Skipping ..."
 }
 fi
 }
 [ "${alpine}" ] && {
 if [ "${have_apk}" ]; then
 sudo apk add ${platpkg} >/dev/null 2>&1
 else
 [ "${quiet}" ] || {
 printf "\n\t\tCannot locate apk to install. Skipping ..."
 }
 fi
 }
 [ "${void}" ] && {
 if [ "${have_xbps}" ]; then
 sudo xbps-install -S ${platpkg} >/dev/null 2>&1
 else
 [ "${quiet}" ] || {
 printf "\n\t\tCannot locate xbps-install to install. Skipping ..."
 }
 fi
 }
 fi
 fi
 [ "$quiet" ] || printf " done"
 if [ "$debug" ]; then
 calc_elapsed
 printf " elapsed time = %s${ELAPSED}"
 fi
 fi
}
plat_install() {
 if [ "${use_homebrew}" ]; then
 brew_install "1ドル"
 else
 platform_install "1ドル"
 fi
}
install_neovim_dependencies() {
 [ "$quiet" ] || printf "\nInstalling dependencies"
 [ "$install_bash" ] && {
 log "Installing a modern version of bash ..."
 [ "$debug" ] && START_SECONDS=$(date +%s)
 if [ "${use_homebrew}" ]; then
 "$BREW_EXE" install --quiet bash >/dev/null 2>&1
 [ $? -eq 0 ] || "$BREW_EXE" link --overwrite --quiet bash >/dev/null 2>&1
 else
 platform_install bash xxxfoobaryyy
 fi
 if [ "$debug" ]; then
 calc_elapsed
 printf " elapsed time = %s${ELAPSED}"
 fi
 }
 PKGS="git curl jq tar unzip fzf wget xclip"
 for pkg in $PKGS
 do
 plat_install "$pkg"
 done
 if [ "${use_homebrew}" ]; then
 brew_install clipboard
 else
 platform_install "wl-clipboard" wl-copy
 fi
 have_curl=$(type -p curl)
 [ "$have_curl" ] || abort "The curl command could not be located."
 have_jq=$(type -p jq)
 have_wget=$(type -p wget)
 if command -v gh >/dev/null 2>&1; then
 log "Using previously installed gh"
 else
 if [ "${use_homebrew}" ]; then
 # Things are so much easier with Homebrew
 brew_install gh
 else
 OWNER=cli
 PROJECT=cli
 API_URL="https://api.github.com/repos/${OWNER}/${PROJECT}/releases/latest"
 DL_URL=
 [ "${have_curl}" ] && [ "${have_jq}" ] && {
 DL_URL=$(curl --silent "${API_URL}" \
 | jq --raw-output '.assets | .[]?.browser_download_url' \
 | grep "linux_amd64\.tar\.gz$")
 }
 [ "${DL_URL}" ] && {
 [ "${have_wget}" ] && {
 log "Installing gh ..."
 TEMP_TGZ="$(mktemp --suffix=.tgz)"
 wget --quiet -O "${TEMP_TGZ}" "${DL_URL}" >/dev/null 2>&1
 chmod 644 "${TEMP_TGZ}"
 mkdir -p /tmp/ghit$$
 tar -C /tmp/ghit$$ -xzf "${TEMP_TGZ}"
 for ghimbin in /tmp/"ghit$$"/*/bin/gh /tmp/"ghit$$"/bin/gh
 do
 [ "${ghimbin}" == "/tmp/ghit$$/*/bin/gh" ] && continue
 [ -f "${ghimbin}" ] && {
 ghimdir=$(dirname ${ghimbin})
 ghimdir=$(dirname ${ghimdir})
 tar -C ${ghimdir} -cf /tmp/ghim-$$.tar bin share
 tar -C ${HOME}/.local -xf /tmp/ghim-$$.tar
 [ -f ${HOME}/.local/bin/gh ] && chmod 755 ${HOME}/.local/bin/gh
 break
 }
 done
 rm -f "${TEMP_TGZ}"
 rm -f "/tmp/ghim-$$.tar"
 rm -rf /tmp/ghit$$
 [ "$quiet" ] || printf " done"
 }
 }
 fi
 fi
 if command -v lazygit >/dev/null 2>&1; then
 log "Using previously installed lazygit"
 else
 if [ "${use_homebrew}" ]; then
 # Things are so much easier with Homebrew
 brew_install lazygit
 else
 if [[ $architecture =~ "arm" || $architecture =~ "aarch64" ]]; then
 larch="arm64"
 else
 larch="x86_64"
 fi
 OWNER=jesseduffield
 PROJECT=lazygit
 API_URL="https://api.github.com/repos/${OWNER}/${PROJECT}/releases/latest"
 DL_URL=
 [ "${have_curl}" ] && [ "${have_jq}" ] && {
 DL_URL=$(curl --silent "${API_URL}" \
 | jq --raw-output '.assets | .[]?.browser_download_url' \
 | grep "Linux_${larch}\.tar\.gz$")
 }
 [ "${DL_URL}" ] && {
 [ "${have_wget}" ] && {
 log "Installing lazygit ..."
 TEMP_TGZ="$(mktemp --suffix=.tgz)"
 wget --quiet -O "${TEMP_TGZ}" "${DL_URL}" >/dev/null 2>&1
 chmod 644 "${TEMP_TGZ}"
 mkdir -p /tmp/lgit$$
 tar -C /tmp/lgit$$ -xzf "${TEMP_TGZ}"
 [ -f /tmp/lgit$$/lazygit ] && {
 cp /tmp/lgit$$/lazygit ${HOME}/.local/bin/lazygit
 chmod 755 ${HOME}/.local/bin/lazygit
 }
 rm -f "${TEMP_TGZ}"
 rm -rf /tmp/lgit$$
 [ "$quiet" ] || printf " done"
 }
 }
 fi
 fi
 if command -v lua-language-server >/dev/null 2>&1; then
 log "Using previously installed lua-language-server"
 else
 if [ "${use_homebrew}" ]; then
 brew_install lua-language-server
 else
 if [ -d ${HOME}/.local/share/lua-language-server ]
 then
 log "Existing ~/.local/share/lua-language-server. Skipping installation of lua-language-server"
 else
 if [[ $architecture =~ "arm" || $architecture =~ "aarch64" ]]; then
 larch="arm64"
 else
 larch="x64"
 fi
 OWNER=LuaLS
 PROJECT=lua-language-server
 API_URL="https://api.github.com/repos/${OWNER}/${PROJECT}/releases/latest"
 DL_URL=
 [ "${have_curl}" ] && [ "${have_jq}" ] && {
 DL_URL=$(curl --silent "${API_URL}" \
 | jq --raw-output '.assets | .[]?.browser_download_url' \
 | grep "linux-${larch}\.tar\.gz$")
 }
 [ "${DL_URL}" ] && {
 [ "${have_wget}" ] && {
 log "Installing lua-language-server ..."
 TEMP_TGZ="$(mktemp --suffix=.tgz)"
 wget --quiet -O "${TEMP_TGZ}" "${DL_URL}" >/dev/null 2>&1
 chmod 644 "${TEMP_TGZ}"
 mkdir -p /tmp/lual$$
 tar -C /tmp/lual$$ -xzf "${TEMP_TGZ}"
 cp -a /tmp/lual$$ ${HOME}/.local/share/lua-language-server
 chmod 755 ${HOME}/.local/share/lua-language-server/bin/lua-language-server
 [ -f "${HOME}/.local/bin/lua-language-server" ] || {
 echo '#!/usr/bin/env bash' > "${HOME}/.local/bin/lua-language-server"
 echo 'exec "${HOME}/.local/share/lua-language-server/bin/lua-language-server" "$@"' >> "${HOME}/.local/bin/lua-language-server"
 chmod 755 "${HOME}/.local/bin/lua-language-server"
 }
 rm -f "${TEMP_TGZ}"
 rm -rf /tmp/lual$$
 [ "$quiet" ] || printf " done"
 }
 }
 fi
 fi
 fi
 if command -v zoxide >/dev/null 2>&1; then
 log "Using previously installed zoxide"
 else
 log "Installing zoxide ..."
 ZOXI_URL="https://raw.githubusercontent.com/ajeetdsouza/zoxide/main/install.sh"
 curl -fsSL "${ZOXI_URL}" >/tmp/zoxi-$$.sh
 [ $? -eq 0 ] || {
 rm -f /tmp/zoxi-$$.sh
 curl -kfsSL "${ZOXI_URL}" >/tmp/zoxi-$$.sh
 }
 [ -f /tmp/zoxi-$$.sh ] && bash /tmp/zoxi-$$.sh >/dev/null 2>&1
 rm -f /tmp/zoxi-$$.sh
 if [ -f "${HOME}/.bashrc" ]; then
 grep "eval \"\$(zoxide init" "${HOME}/.bashrc" >/dev/null || {
 echo 'if command -v zoxide > /dev/null; then' >>"${HOME}/.bashrc"
 echo ' eval "$(zoxide init bash)"' >>"${HOME}/.bashrc"
 echo 'fi' >>"${HOME}/.bashrc"
 }
 else
 echo 'if command -v zoxide > /dev/null; then' >"${HOME}/.bashrc"
 echo ' eval "$(zoxide init bash)"' >>"${HOME}/.bashrc"
 echo 'fi' >>"${HOME}/.bashrc"
 fi
 [ -f "${HOME}/.zshrc" ] && {
 grep "eval \"\$(zoxide init" "${HOME}/.zshrc" >/dev/null || {
 echo 'if command -v zoxide > /dev/null; then' >>"${HOME}/.zshrc"
 echo ' eval "$(zoxide init zsh)"' >>"${HOME}/.zshrc"
 echo 'fi' >>"${HOME}/.zshrc"
 }
 }
 [ "$quiet" ] || printf " done"
 fi
 if command -v rg >/dev/null 2>&1; then
 log "Using previously installed ripgrep"
 else
 plat_install ripgrep
 fi
 [ "$quiet" ] || printf "\n"
}
install_neovim() {
 log "Installing Neovim ..."
 OWNER=neovim
 PROJECT=neovim
 API_URL="https://api.github.com/repos/${OWNER}/${PROJECT}/releases/latest"
 DL_URL=
 if [ "$debug" ]; then
 START_SECONDS=$(date +%s)
 if [ "${use_homebrew}" ]; then
 "$BREW_EXE" link -q libuv
 "$BREW_EXE" install neovim
 else
 [ -d $HOME/.local ] || mkdir -p $HOME/.local
 [ "${have_curl}" ] && [ "${have_jq}" ] && {
 DL_URL=$(curl --silent "${API_URL}" \
 | jq --raw-output '.assets | .[]?.browser_download_url' \
 | grep "linux64\.tar\.gz$")
 }
 [ "${DL_URL}" ] && {
 [ "${have_wget}" ] && {
 TEMP_TGZ="$(mktemp --suffix=.tgz)"
 wget --quiet -O "${TEMP_TGZ}" "${DL_URL}"
 chmod 644 "${TEMP_TGZ}"
 mkdir -p /tmp/nvim$$
 tar -C /tmp/nvim$$ -xzf "${TEMP_TGZ}"
 if [ -f /tmp/nvim$$/nvim-linux64/bin/nvim ]; then
 tar -C /tmp/nvim$$/nvim-linux64 -cf /tmp/nvim-$$.tar .
 tar -C ${HOME}/.local -xf /tmp/nvim-$$.tar
 chmod 755 ${HOME}/.local/bin/nvim
 else
 for nvimbin in /tmp/"nvim$$"/*/bin/nvim /tmp/"nvim$$"/bin/nvim
 do
 [ "${nvimbin}" == "/tmp/nvim$$/*/bin/nvim" ] && continue
 [ -f "${nvimbin}" ] && {
 nvimdir=$(dirname ${nvimbin})
 nvimdir=$(dirname ${nvimdir})
 tar -C ${nvimdir} -cf /tmp/nvim-$$.tar .
 tar -C ${HOME}/.local -xf /tmp/nvim-$$.tar
 chmod 755 ${HOME}/.local/bin/nvim
 break
 }
 done
 fi
 rm -f "${TEMP_TGZ}"
 rm -f /tmp/nvim-$$.tar
 rm -rf /tmp/nvim$$
 }
 }
 fi
 else
 if [ "${use_homebrew}" ]; then
 "$BREW_EXE" link -q libuv >/dev/null 2>&1
 "$BREW_EXE" install -q neovim >/dev/null 2>&1
 else
 [ -d $HOME/.local ] || mkdir -p $HOME/.local
 [ "${have_curl}" ] && [ "${have_jq}" ] && {
 DL_URL=$(curl --silent "${API_URL}" \
 | jq --raw-output '.assets | .[]?.browser_download_url' \
 | grep "linux64\.tar\.gz$")
 }
 [ "${DL_URL}" ] && {
 [ "${have_wget}" ] && {
 TEMP_TGZ="$(mktemp --suffix=.tgz)"
 wget --quiet -O "${TEMP_TGZ}" "${DL_URL}" >/dev/null 2>&1
 chmod 644 "${TEMP_TGZ}"
 mkdir -p /tmp/nvim$$
 tar -C /tmp/nvim$$ -xzf "${TEMP_TGZ}"
 if [ -f /tmp/nvim$$/nvim-linux64/bin/nvim ]; then
 tar -C /tmp/nvim$$/nvim-linux64 -cf /tmp/nvim-$$.tar .
 tar -C ${HOME}/.local -xf /tmp/nvim-$$.tar
 chmod 755 ${HOME}/.local/bin/nvim
 else
 for nvimbin in /tmp/"nvim$$"/*/bin/nvim /tmp/"nvim$$"/bin/nvim; do
 [ "${nvimbin}" == "/tmp/nvim$$/*/bin/nvim" ] && continue
 [ -f "${nvimbin}" ] && {
 nvimdir=$(dirname ${nvimbin})
 nvimdir=$(dirname ${nvimdir})
 tar -C ${nvimdir} -cf /tmp/nvim-$$.tar .
 tar -C ${HOME}/.local -xf /tmp/nvim-$$.tar
 chmod 755 ${HOME}/.local/bin/nvim
 break
 }
 done
 fi
 rm -f "${TEMP_TGZ}"
 rm -f /tmp/nvim-$$.tar
 rm -rf /tmp/nvim$$
 }
 }
 fi
 fi
 [ "$quiet" ] || printf " done"
 if [ "$debug" ]; then
 calc_elapsed
 printf "\nInstall Neovim elapsed time = %s${ELAPSED}\n"
 fi
}
install_neovim_head() {
 [ "${use_homebrew}" ] && "$BREW_EXE" link -q libuv >/dev/null 2>&1
 log "Building and installing nightly Neovim ..."
 if [ "$debug" ]; then
 START_SECONDS=$(date +%s)
 if [ "${use_homebrew}" ]; then
 "$BREW_EXE" install --HEAD neovim
 else
 [ -d /tmp/neovim$$ ] && rm -rf /tmp/neovim$$
 git clone https://github.com/neovim/neovim.git /tmp/neovim$$
 cd /tmp/neovim$$
 rm -f ${HOME}/.local/bin/nvim
 rm -rf ${HOME}/.local/share/nvim
 make CMAKE_BUILD_TYPE=Release \
 CMAKE_EXTRA_FLAGS="-DCMAKE_INSTALL_PREFIX=${HOME}/.local"
 make install
 cd
 rm -rf /tmp/neovim$$
 fi
 else
 if [ "${use_homebrew}" ]; then
 "$BREW_EXE" install -q --HEAD neovim >/dev/null 2>&1
 else
 [ -d /tmp/neovim$$ ] && rm -rf /tmp/neovim$$
 git clone https://github.com/neovim/neovim.git /tmp/neovim$$ >/dev/null 2>&1
 cd /tmp/neovim$$
 rm -f ${HOME}/.local/bin/nvim
 rm -rf ${HOME}/.local/share/nvim
 make CMAKE_BUILD_TYPE=Release \
 CMAKE_EXTRA_FLAGS="-DCMAKE_INSTALL_PREFIX=${HOME}/.local" >/dev/null 2>&1
 make install >/dev/null 2>&1
 cd
 rm -rf /tmp/neovim$$
 fi
 fi
 if [ "$debug" ]; then
 calc_elapsed
 printf "\nInstall Neovim elapsed time = %s${ELAPSED}\n"
 fi
 [ "$quiet" ] || printf " done"
}
check_python() {
 brew_path=$(command -v brew)
 [ "${brew_path}" ] || {
 [ "${BREW_EXE}" == "brew" ] || {
 [ "${BREW_EXE}" ] && brew_path="${BREW_EXE}"
 }
 }
 [ "${brew_path}" ] || {
 [ "$HOMEBREW_HOME" == "Unknown" ] || {
 [ "$HOMEBREW_HOME" ] && brew_path="${HOMEBREW_HOME}/bin/brew"
 }
 [ "${brew_path}" ] || {
 if [ -x /home/linuxbrew/.linuxbrew/bin/brew ]; then
 HOMEBREW_HOME="/home/linuxbrew/.linuxbrew"
 brew_path="${HOMEBREW_HOME}/bin/brew"
 else
 if [ -x /usr/local/bin/brew ]; then
 HOMEBREW_HOME="/usr/local"
 brew_path="${HOMEBREW_HOME}/bin/brew"
 else
 if [ -x /opt/homebrew/bin/brew ]; then
 HOMEBREW_HOME="/opt/homebrew"
 brew_path="${HOMEBREW_HOME}/bin/brew"
 fi
 fi
 fi
 }
 }
 brew_dir=$(dirname "$brew_path")
 if [ -x ${brew_dir}/python3 ]; then
 PYTHON="${brew_dir}/python3"
 else
 PYTHON=$(command -v python3)
 fi
}
check_ruby() {
 brew_path=$(command -v brew)
 brew_dir=$(dirname "$brew_path")
 if [ -x "$brew_dir"/ruby ]; then
 RUBY="${brew_dir}/ruby"
 else
 RUBY=$(command -v ruby)
 fi
 if [ -x "$brew_dir"/gem ]; then
 GEM="${brew_dir}/gem"
 else
 GEM=$(command -v gem)
 fi
}
# Brew doesn't create a python symlink so we do so here
link_python() {
 python3_path=$(command -v python3)
 [ "$python3_path" ] && {
 python_dir=$(dirname "$python3_path")
 if [ -w "$python_dir" ]; then
 rm -f "$python_dir"/python
 ln -s "$python_dir"/python3 "$python_dir"/python
 fi
 }
}
install_extra() {
 [ "$quiet" ] || printf "\nInstalling extra language servers and tools"
 for pkg in luarocks julia php composer
 do
 plat_install ${pkg}
 done
 if command -v lemonade >/dev/null 2>&1; then
 log "Using previously installed lemonade"
 else
 [ "${darwin}" ] || {
 if [ -x ${HOME}/.local/bin/lemonade ]
 then
 log "Existing ~/.local/bin/lemonade. Skipping installation of lemonade."
 else
 [[ $architecture =~ "arm" || $architecture =~ "aarch64" ]] || {
 OWNER=lemonade-command
 PROJECT=lemonade
 API_URL="https://api.github.com/repos/${OWNER}/${PROJECT}/releases/latest"
 DL_URL=
 [ "${have_curl}" ] && [ "${have_jq}" ] && {
 DL_URL=$(curl --silent "${API_URL}" \
 | jq --raw-output '.assets | .[]?.browser_download_url' \
 | grep "linux_amd64\.tar\.gz$")
 }
 [ "${DL_URL}" ] && {
 [ "${have_wget}" ] && {
 log "Installing lemonade ..."
 TEMP_TGZ="$(mktemp --suffix=.tgz)"
 wget --quiet -O "${TEMP_TGZ}" "${DL_URL}" >/dev/null 2>&1
 chmod 644 "${TEMP_TGZ}"
 mkdir -p /tmp/lmnd$$
 tar -C /tmp/lmnd$$ -xzf "${TEMP_TGZ}"
 [ -f /tmp/lmnd$$/lemonade ] && {
 cp /tmp/lmnd$$/lemonade ${HOME}/.local/bin/lemonade
 chmod 755 ${HOME}/.local/bin/lemonade
 }
 rm -f "${TEMP_TGZ}"
 rm -rf /tmp/lmnd$$
 [ "$quiet" ] || printf " done"
 }
 }
 }
 fi
 }
 fi
 have_check=$(type -p luacheck)
 [ "${have_check}" ] || {
 have_rocks=$(type -p luarocks)
 [ "${have_rocks}" ] && {
 luarocks --local install luacheck > /dev/null 2>&1
 }
 }
 printf "\nAdding luarocks bin to PATH in shell initialization file(s)"
 if [ -f "${HOME}/.bashrc" ]; then
 grep "luarocks/bin" "${HOME}/.bashrc" >/dev/null || {
 echo '# Luarocks bin path' >>"${HOME}/.bashrc"
 echo '[ -d ${HOME}/.luarocks/bin ] && {' >>"${HOME}/.bashrc"
 echo ' export PATH="${HOME}/.luarocks/bin${PATH:+:${PATH}}"' >>"${HOME}/.bashrc"
 echo '}' >>"${HOME}/.bashrc"
 }
 else
 echo '# Luarocks bin path' >"${HOME}/.bashrc"
 echo '[ -d ${HOME}/.luarocks/bin ] && {' >>"${HOME}/.bashrc"
 echo ' export PATH="${HOME}/.luarocks/bin${PATH:+:${PATH}}"' >>"${HOME}/.bashrc"
 echo '}' >>"${HOME}/.bashrc"
 fi
 [ -f "${HOME}/.zshrc" ] && {
 grep "luarocks/bin" "${HOME}/.zshrc" >/dev/null || {
 echo '# Luarocks bin path' >>"${HOME}/.zshrc"
 echo '[ -d ${HOME}/.luarocks/bin ] && {' >>"${HOME}/.zshrc"
 echo ' export PATH="${HOME}/.luarocks/bin${PATH:+:${PATH}}"' >>"${HOME}/.zshrc"
 echo '}' >>"${HOME}/.zshrc"
 }
 }
}
nvm_default_install_dir() {
 [ -z "${XDG_CONFIG_HOME-}" ] && printf %s "${HOME}/.nvm" || printf %s "${XDG_CONFIG_HOME}/nvm"
}
nvm_install_dir() {
 if [ -n "$NVM_DIR" ]; then
 printf %s "${NVM_DIR}"
 else
 nvm_default_install_dir
 fi
}
install_tools() {
 # Check for n node version manager
 have_n=$(type -p n)
 [ "${have_n}" ] && {
 n list 2>&1 | grep node > /dev/null || have_n=
 }
 [ "${have_n}" ] && {
 printf "\nIt appears the 'n' node version manager is installed"
 printf "\nLazyman uses the 'nvm' node version manager"
 printf "\nResolve any node version mismatch post-initialization\n"
 }
 dir_nvm=$(nvm_install_dir)
 if [ -d "${dir_nvm}/.git" ]; then
 export NVM_DIR="${dir_nvm}"
 else
 if [ -d "${HOME}/.config/nvm/.git" ]; then
 if [ -d "${HOME}/.nvm/.git" ]; then
 export NVM_DIR="${HOME}/.nvm"
 else
 export NVM_DIR="${HOME}/.config/nvm"
 fi
 else
 export NVM_DIR="${HOME}/.nvm"
 fi
 fi
 HERE=$(pwd)
 if [ -d "${NVM_DIR}" ]; then
 log "Verifying latest version of nvm ..."
 cd "$NVM_DIR"
 git fetch --tags origin > /dev/null 2>&1
 git checkout \
 `git describe --abbrev=0 --tags --match "v[0-9]*" $(git rev-list --tags --max-count=1)` \
 > /dev/null 2>&1
 [ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh"
 cd "${HERE}"
 [ "$quiet" ] || printf " done"
 else
 log "Installing nvm node version manager ..."
 git clone https://github.com/nvm-sh/nvm.git "$NVM_DIR" > /dev/null 2>&1
 cd "$NVM_DIR"
 git checkout \
 `git describe --abbrev=0 --tags --match "v[0-9]*" $(git rev-list --tags --max-count=1)` \
 > /dev/null 2>&1
 if [ -x install.sh ]; then
 ./install.sh > /dev/null 2>&1
 else
 [ -f install.sh ] && {
 chmod 755 install.sh
 ./install.sh > /dev/null 2>&1
 }
 fi
 cd "${HERE}"
 [ "$quiet" ] || printf " done"
 fi
 log "Verifying latest version of node with nvm ..."
 [ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh"
 nvm install node --reinstall-packages-from=node > /dev/null 2>&1
 nvm install node > /dev/null 2>&1
 [ "$quiet" ] || printf " done"
 log "Verifying latest version of npm with nvm ..."
 nvm install-latest-npm > /dev/null 2>&1
 [ "$quiet" ] || printf " done"
 [ "$quiet" ] || printf "\nInstalling language servers and tools"
 plat_install ccls
 [ "${use_homebrew}" ] && {
 "$BREW_EXE" link --overwrite --quiet ccls >/dev/null 2>&1
 }
 if command -v "cargo" >/dev/null 2>&1; then
 log "Using previously installed cargo"
 else
 log "Installing cargo ..."
 [ "$debug" ] && START_SECONDS=$(date +%s)
 if [ "${use_homebrew}" ]; then
 "$BREW_EXE" install --quiet "rust" >/dev/null 2>&1
 [ $? -eq 0 ] || "$BREW_EXE" link --overwrite --quiet "rust" >/dev/null 2>&1
 else
 RUST_URL="https://sh.rustup.rs"
 curl -fsSL "${RUST_URL}" >/tmp/rust-$$.sh
 [ $? -eq 0 ] || {
 rm -f /tmp/rust-$$.sh
 curl -kfsSL "${RUST_URL}" >/tmp/rust-$$.sh
 [ -f /tmp/rust-$$.sh ] && {
 cat /tmp/rust-$$.sh | sed -e "s/--show-error/--insecure --show-error/" >/tmp/ins$$
 cp /tmp/ins$$ /tmp/rust-$$.sh
 rm -f /tmp/ins$$
 }
 }
 [ -f /tmp/rust-$$.sh ] && sh /tmp/rust-$$.sh -y >/dev/null 2>&1
 rm -f /tmp/rust-$$.sh
 fi
 if [ "$debug" ]; then
 calc_elapsed
 printf " elapsed time = %s${ELAPSED}"
 fi
 fi
 if ! command -v "cargo" >/dev/null 2>&1; then
 [ -x "${HOME}"/.cargo/bin/cargo ] && {
 export PATH="$HOME/.cargo/bin:$PATH"
 }
 fi
 [ "$quiet" ] || printf "\nInstalling npm and treesitter dependencies"
 # First try to install tree-sitter-cli with cargo then npm
 if command -v tree-sitter >/dev/null 2>&1; then
 log "Using previously installed tree-sitter cli"
 else
 if command -v "cargo" >/dev/null 2>&1; then
 log "Installing tree-sitter cli with cargo ..."
 cargo install tree-sitter-cli >/dev/null 2>&1
 [ "$quiet" ] || printf " done"
 fi
 fi
 if ! command -v tldr >/dev/null 2>&1; then
 if [ "${use_homebrew}" ]; then
 brew_install tealdeer
 else
 if [[ $architecture =~ "arm" || $architecture =~ "aarch64" ]]; then
 larch="arm-musleabi"
 else
 larch="x86_64-musl"
 fi
 OWNER=dbrgn
 PROJECT=tealdeer
 API_URL="https://api.github.com/repos/${OWNER}/${PROJECT}/releases/latest"
 DL_URL=
 [ "${have_curl}" ] && [ "${have_jq}" ] && {
 DL_URL=$(curl --silent "${API_URL}" \
 | jq --raw-output '.assets | .[]?.browser_download_url' \
 | grep "linux-${larch}$")
 }
 [ "${DL_URL}" ] && {
 [ "${have_wget}" ] && {
 log "Installing tealdeer ..."
 TEMP_TGZ="$(mktemp --suffix=.bin)"
 wget --quiet -O "${TEMP_TGZ}" "${DL_URL}" >/dev/null 2>&1
 [ -d ${HOME}/.local/bin ] || mkdir -p ${HOME}/.local/bin
 cp "${TEMP_TGZ}" ${HOME}/.local/bin/tldr
 [ -f ${HOME}/.local/bin/tldr ] && {
 chmod 755 ${HOME}/.local/bin/tldr
 ${HOME}/.local/bin/tldr --update > /dev/null 2>&1
 }
 rm -f "${TEMP_TGZ}"
 [ "$quiet" ] || printf " done"
 }
 }
 fi
 fi
 if command -v ascii-image-converter >/dev/null 2>&1; then
 log "Using previously installed ascii-image-converter"
 else
 if [ "${use_homebrew}" ]; then
 log "Installing ascii-image-converter ..."
 "$BREW_EXE" install --quiet \
 TheZoraiz/ascii-image-converter/ascii-image-converter >/dev/null 2>&1
 [ "$quiet" ] || printf " done"
 else
 OWNER=TheZoraiz
 PROJECT=ascii-image-converter
 API_URL="https://api.github.com/repos/${OWNER}/${PROJECT}/releases/latest"
 DL_URL=
 [ "${have_curl}" ] && [ "${have_jq}" ] && {
 DL_URL=$(curl --silent "${API_URL}" \
 | jq --raw-output '.assets | .[]?.browser_download_url' \
 | grep "Linux_amd64")
 }
 [ "${DL_URL}" ] && {
 [ "${have_wget}" ] && {
 log "Installing ascii-image-converter ..."
 TEMP_TGZ="$(mktemp --suffix=.bin)"
 wget --quiet -O "${TEMP_TGZ}" "${DL_URL}" >/dev/null 2>&1
 chmod 644 "${TEMP_TGZ}"
 mkdir -p /tmp/ascc$$
 [ -d ${HOME}/.local/bin ] || mkdir -p ${HOME}/.local/bin
 tar -C /tmp/ascc$$ -xzf "${TEMP_TGZ}"
 for asccbin in /tmp/"ascc$$"/*/ascii-image-converter /tmp/"ascc$$"/ascii-image-converter
 do
 [ "${asccbin}" == "/tmp/ascc$$/*/ascii-image-converter" ] && continue
 [ -f "${asccbin}" ] && {
 cp "${asccbin}" ${HOME}/.local/bin/ascii-image-converter
 [ -f ${HOME}/.local/bin/ascii-image-converter ] && {
 chmod 755 ${HOME}/.local/bin/ascii-image-converter
 break
 }
 }
 done
 rm -f "${TEMP_TGZ}"
 rm -rf /tmp/ascc$$
 [ "$quiet" ] || printf " done"
 }
 }
 fi
 fi
 have_npm=$(type -p npm)
 [ "$have_npm" ] && {
 if ! command -v tree-sitter >/dev/null 2>&1; then
 log "Installing tree-sitter command line npm package ..."
 npm i -g tree-sitter-cli >/dev/null 2>&1
 [ "$quiet" ] || printf " done"
 fi
 log "Installing Neovim npm package ..."
 npm i -g neovim >/dev/null 2>&1
 [ "$quiet" ] || printf " done"
 log "Installing fd-find package ..."
 npm i -g fd-find >/dev/null 2>&1
 [ "$quiet" ] || printf " done"
 if command -v cspell >/dev/null 2>&1; then
 log "Using previously installed cspell"
 else
 log "Installing cspell npm package ..."
 npm i -g cspell >/dev/null 2>&1
 [ "$quiet" ] || printf " done"
 fi
 if command -v tsserver >/dev/null 2>&1; then
 log "Using previously installed typescript package"
 else
 log "Installing typescript npm package ..."
 npm i -g typescript >/dev/null 2>&1
 [ "$quiet" ] || printf " done"
 fi
 if command -v eslint_d >/dev/null 2>&1; then
 log "Using previously installed eslint_d"
 else
 log "Installing eslint_d npm package ..."
 npm i -g eslint_d >/dev/null 2>&1
 [ "$quiet" ] || printf " done"
 fi
 log "Installing the icon font for Visual Studio Code ..."
 npm i -g @vscode/codicons >/dev/null 2>&1
 [ "$quiet" ] || printf " done"
 }
 if command -v tree-sitter >/dev/null 2>&1; then
 tree-sitter init-config >/dev/null 2>&1
 fi
 for pkg in bat lsd figlet luarocks lolcat xsel
 do
 plat_install "${pkg}"
 done
 if ! command -v lsd >/dev/null 2>&1; then
 if command -v "cargo" >/dev/null 2>&1; then
 log "Installing lsd with cargo ..."
 cargo install lsd >/dev/null 2>&1
 [ "$quiet" ] || printf " done"
 fi
 fi
 [ "$quiet" ] || printf "\nInstalling Python dependencies"
 check_python
 [ "$PYTHON" ] || {
 # Could not find Python
 if [ "${use_homebrew}" ]; then
 log 'Installing Python with Homebrew ...'
 "$BREW_EXE" install --quiet python >/dev/null 2>&1
 [ $? -eq 0 ] || "$BREW_EXE" link --overwrite --quiet python >/dev/null 2>&1
 else
 log 'Installing Python ...'
 platform_install python3
 fi
 check_python
 [ "$quiet" ] || printf " done"
 }
 link_python
 [ "$PYTHON" ] && {
 PIPARGS="--user --no-cache-dir --upgrade --force-reinstall"
 log 'Upgrading pip, setuptools, wheel, doq, and pynvim ...'
 "$PYTHON" -m pip install ${PIPARGS} pip >/dev/null 2>&1
 "$PYTHON" -m pip install ${PIPARGS} setuptools >/dev/null 2>&1
 "$PYTHON" -m pip install ${PIPARGS} wheel >/dev/null 2>&1
 "$PYTHON" -m pip install ${PIPARGS} pynvim doq >/dev/null 2>&1
 [ "$quiet" ] || printf " done"
 log 'Installing black, beautysh, and ruff formatters/linters ...'
 "$PYTHON" -m pip install ${PIPARGS} beautysh >/dev/null 2>&1
 "$PYTHON" -m pip install ${PIPARGS} black >/dev/null 2>&1
 "$PYTHON" -m pip install ${PIPARGS} ruff >/dev/null 2>&1
 [ "$quiet" ] || printf " done"
 [ "${native}" ] && [ "${debian}" ] && platform_install python3-venv
 [ "$quiet" ] || printf "\n\tInstalling neovim-remote (nvr) ..."
 if [ "${use_homebrew}" ]; then
 "$BREW_EXE" install -q neovim-remote >/dev/null 2>&1
 else
 ${PYTHON} -m pip install ${PIPARGS} neovim-remote >/dev/null 2>&1
 fi
 [ "$quiet" ] || printf " done"
 log 'Installing langchain, llama-cpp-python, and pygments ...'
 "$PYTHON" -m pip install ${PIPARGS} pygments >/dev/null 2>&1
 "$PYTHON" -m pip install --user --no-cache-dir --force-reinstall \
 langchain==0.0.177 llama-cpp-python==0.1.48 > /dev/null 2>&1
 [ "$quiet" ] || printf " done"
 if command -v "flake8" >/dev/null 2>&1; then
 log "Using previously installed flake8"
 else
 log "Installing flake8 ..."
 ${PYTHON} -m pip install ${PIPARGS} flake8 >/dev/null 2>&1
 fi
 [ "$quiet" ] || printf " done"
 if command -v "rich" >/dev/null 2>&1; then
 log "Using previously installed rich-cli"
 else
 log "Installing rich-cli ..."
 if [ "${use_homebrew}" ]; then
 "$BREW_EXE" install --quiet "rich-cli" >/dev/null 2>&1
 [ $? -eq 0 ] || "$BREW_EXE" link --overwrite --quiet "rich-cli" >/dev/null 2>&1
 else
 ${PYTHON} -m pip install ${PIPARGS} rich-cli >/dev/null 2>&1
 fi
 fi
 [ "$quiet" ] || printf " done"
 if command -v "trash" >/dev/null 2>&1; then
 log "Using previously installed trash-cli"
 else
 log "Installing trash-cli ..."
 ${PYTHON} -m pip install ${PIPARGS} trash-cli >/dev/null 2>&1
 fi
 [ "$quiet" ] || printf " done"
 if command -v "codespell" >/dev/null 2>&1; then
 log "Using previously installed codespell"
 else
 log "Installing codespell ..."
 ${PYTHON} -m pip install ${PIPARGS} codespell >/dev/null 2>&1
 fi
 [ "$quiet" ] || printf " done"
 if command -v "misspell" >/dev/null 2>&1; then
 log "Using previously installed misspell"
 else
 log "Installing misspell ..."
 MISS_URL="https://git.io/misspell"
 curl -fsSL "$MISS_URL" >/tmp/miss-$$.sh
 [ $? -eq 0 ] || {
 rm -f /tmp/miss-$$.sh
 curl -kfsSL "$MISS_URL" >/tmp/miss-$$.sh
 }
 [ -f /tmp/miss-$$.sh ] && {
 chmod 755 /tmp/miss-$$.sh
 /tmp/miss-$$.sh -b ${HOME}/.local/bin >/dev/null 2>&1
 rm -f /tmp/miss-$$.sh
 }
 fi
 [ "$quiet" ] || printf " done"
 }
 [ "$quiet" ] || printf "\nInstalling Ruby dependencies"
 check_ruby
 [ "$RUBY" ] || {
 # Could not find Ruby
 if [ "${use_homebrew}" ]; then
 log 'Installing Ruby with Homebrew ...'
 "$BREW_EXE" install --quiet ruby >/dev/null 2>&1
 [ $? -eq 0 ] || "$BREW_EXE" link --overwrite --quiet ruby >/dev/null 2>&1
 else
 log 'Installing Ruby ...'
 platform_install ruby
 fi
 check_ruby
 [ "$quiet" ] || printf " done"
 }
 [ "${native}" ] && {
 [ "${debian}" ] && platform_install ruby-dev
 [ "${redhat}" ] || [ "${suse}" ] || [ "${void}" ] && {
 platform_install ruby-devel
 }
 }
 [ "$GEM" ] && {
 log "Installing Ruby neovim gem ..."
 ${GEM} install neovim --user-install >/dev/null 2>&1
 [ "$quiet" ] || printf " done"
 }
 if command -v deno >/dev/null 2>&1; then
 log "Using previously installed deno"
 else
 log "Installing deno ..."
 export DENO_INSTALL="${HOME}/.local"
 curl -fsSL https://deno.land/x/install/install.sh | sh > /dev/null 2>&1
 [ "$quiet" ] || printf " done"
 fi
 if command -v tectonic >/dev/null 2>&1; then
 log "Using previously installed tectonic"
 else
 log "Installing tectonic ..."
 curl --proto '=https' --tlsv1.2 -fsSL \
 https://drop-sh.fullyjustified.net |sh > /dev/null 2>&1
 [ -f tectonic ] && {
 chmod +x tectonic
 [ -d ${HOME}/.local/bin ] || mkdir -p ${HOME}/.local/bin
 mv tectonic ${HOME}/.local/bin
 }
 [ "$quiet" ] || printf " done"
 fi
 GHUC="https://raw.githubusercontent.com"
 JETB_URL="${GHUC}/JetBrains/JetBrainsMono/master/install_manual.sh"
 [ "$quiet" ] || printf "\n\tInstalling JetBrains Mono font ... "
 curl -fsSL "$JETB_URL" >/tmp/jetb-$$.sh
 [ $? -eq 0 ] || {
 rm -f /tmp/jetb-$$.sh
 curl -kfsSL "$JETB_URL" >/tmp/jetb-$$.sh
 }
 [ -f /tmp/jetb-$$.sh ] && {
 chmod 755 /tmp/jetb-$$.sh
 /bin/bash -c "/tmp/jetb-$$.sh" >/dev/null 2>&1
 rm -f /tmp/jetb-$$.sh
 }
 [ "$quiet" ] || printf "done\n"
}
main() {
 check_prerequisites
 get_platform
 [ "$proceed" ] || {
 [ "${alpine}" ] || [ "${arch}" ] || [ "${debian}" ] \
 || [ "${redhat}" ] || [ "${suse}" ] || [ "${void}" ] && {
 prompt=
 if [ "${native}" ]; then
 printf "\n\n${PKGMGR} will be used to install dependencies and tools."
 printf "\nThis requires 'sudo' (root) privilege.\n"
 have_brew=$(type -p brew)
 [ "${have_brew}" ] && {
 prompt=1
 printf "\nAn existing Homebrew installation has been detected.\n"
 printf "\nEnter 'h' to use Homebrew, 'n' or <Enter> to use ${PKGMGR}"
 }
 else
 prompt=1
 printf "\n\nHomebrew will be used to install dependencies and tools.\n"
 printf "\nEnter 'h' or <Enter> to use Homebrew, 'n' to use ${PKGMGR}"
 fi
 if [ "${prompt}" ]; then
 printf "\nEnter 'q' to exit the Neovim installer\n"
 while true; do
 read -r -p "Do you wish to use ${PKGMGR} or Homebrew ? (h/n/q) " yn
 case $yn in
 [Nn]*)
 printf "\nUsing ${PKGMGR} to install dependencies and tools\n"
 native=1
 break
 ;;
 [Hh]*)
 printf "\nUsing Homebrew to install dependencies and tools\n"
 native=
 break
 ;;
 [Qq]*)
 printf "\nExiting Neovim installer without installing dependencies or tools\n"
 exit 1
 ;;
 '')
 if [ "${native}" ]; then
 printf "\nUsing ${PKGMGR} to install dependencies and tools\n"
 else
 printf "\nUsing Homebrew to install dependencies and tools\n"
 fi
 break
 ;;
 *)
 printf "\nPlease answer 'h' or 'n'.\n"
 ;;
 esac
 done
 fi
 }
 }
 if [ "${darwin}" ]; then
 # Always use Homebrew on macOS
 use_homebrew=1
 else
 # All other platforms, use Homebrew only when instructed
 [ "${native}" ] || use_homebrew=1
 fi
 [ "${use_homebrew}" ] && install_homebrew
 install_neovim_dependencies
 if command -v nvim >/dev/null 2>&1; then
 if [ "$nvim_head" ]; then
 printf "\nInstalling nightly build of Neovim"
 install_neovim_head
 else
 # Check if installed nvim is v0.9.0 or greater
 ver_head=$(nvim --version | head -1 | awk '{ print 2ドル }')
 nvim_ver=$(echo ${ver_head} | awk -F '-' '{ print 1ドル }' | sed -e "s/^v//")
 if [ "${nvim_ver}" ]; then
 compare_versions "${nvim_ver}" "0.9.0" >/dev/null 2>&1
 [ $? -eq 2 ] && {
 printf "\nCurrently installed Neovim is less than version 0.9"
 printf "\nInstalling/upgrading Neovim"
 install_neovim
 }
 else
 # Don't know, install anyway
 printf "\nInstalling/upgrading Neovim"
 install_neovim
 fi
 fi
 else
 if [ "$nvim_head" ]; then
 install_neovim_head
 else
 install_neovim
 fi
 fi
 install_tools
 [ "${alltools}" ] && install_extra
}
APT=
DNF=
nvim_head=
quiet=
debug=
darwin=
alpine=
arch=
debian=
redhat=
suse=
void=
have_apk=$(type -p apk)
have_apt=$(type -p apt)
have_aptget=$(type -p apt-get)
have_dnf=$(type -p dnf)
have_pac=$(type -p pacman)
have_xbps=$(type -p xbps-install)
have_yum=$(type -p yum)
have_zyp=$(type -p zypper)
alltools=
native=1
proceed=
architecture=$(uname -m)
while getopts "adhnqy" flag; do
 case $flag in
 a)
 alltools=1
 ;;
 d)
 debug=1
 ;;
 n)
 nvim_head=1
 ;;
 h)
 native=
 PKGMGR="Homebrew"
 ;;
 q)
 quiet=1
 ;;
 y)
 proceed=1
 ;;
 *) ;;
 esac
done
currlimit=$(ulimit -n)
hardlimit=$(ulimit -Hn)
[ "$hardlimit" == "unlimited" ] && hardlimit=9999
if [ "$hardlimit" -gt 4096 ]; then
 ulimit -n 4096
else
 ulimit -n "$hardlimit"
fi
install_bash=
[ "$debug" ] && MAIN_START_SECONDS=$(date +%s)
main
[ "$debug" ] && {
 MAIN_FINISH_SECONDS=$(date +%s)
 MAIN_ELAPSECS=$((MAIN_FINISH_SECONDS - MAIN_START_SECONDS))
 MAIN_ELAPSED=$(eval "echo $(date -ud "@$MAIN_ELAPSECS" +'$((%s/3600/24)) days %H hr %M min %S sec')")
 printf "\nTotal elapsed time = %s${MAIN_ELAPSED}\n"
}
ulimit -n "$currlimit"