install.sh

#!/bin/bash

################################################################################
# Functions                                                                    #
################################################################################

################################################################################
# Gets the full path to a relative path
#
# arg1: The path to be converted into absolute
# return: The full path

function fullPath {
  local targetFile physDir result

  targetFile="${1}"

  cd `dirname "${targetFile}"`
  targetFile=`basename "${targetFile}"`

  # Compute the canonicalized name by finding the physical path
  # for the directory we're in and appending the target file.
  physDir=`pwd -P`
  result="${physDir}/${targetFile}"
  result="${result%/.}"
  echo ${result}
}

################################################################################
# Shows a prompt to confirm continuation. Aborts the script if cancelled
#
# return: Success if accepted. Will abort if cancelled

function checkContinue {
  local input

  if [ "${1}" ]
  then
    echo "${1}"
  fi

  echo -n "Continue? [y/N] "
  read input
  case ${input} in
    [Yy] ) return 0 ;;
  esac

  exit
}

################################################################################
# Checks and installs a package.
#
# arg1: Friendly name for the package
# arg2: Package install command
# arg3: The conditions to check if the package is installed
# return: Abort if cancelled, or success otherwise

function checkInstall {
  local input

  echo -n "Checking ${1}.. ["
  if eval ${3}
  then
    echo "OK]"
  else
    echo "FAIL]"

    echo -n "Install ${1}? [Y/n] "
    read input
    case ${input} in
      [Nn] ) ;;
      *)
        if eval "${2}"
        then
          echo "Done!"
        else
          checkContinue "Could not install ${1}!"
          return 1
        fi
        ;;
    esac
  fi

  return 0
}

################################################################################
# Helper function. Since most of the calls to checkInstall are similar
# this function autogenerates the arguments
#
# arg1: Name of the package
# return: Abort if cancelled, or success otherwise

function checkInstallDefault {
  local checkString='[ $(command -v '"${1}"') ]'
  checkInstall ${1} "${PACKAGE_INSTALL} ${1}" "${checkString}"
}

################################################################################
# Installs a file. The installation might be a copy or a symlink
# The target file is checked for existence and a prompt will ask if it should
# be overwritten
#
# arg1: Either "s" or "c" for symlink or copy, respectively
# arg2: The source path
# [arg3]: Installation path. Defaults to $HOME.
# [arg4]: Installation file name override.
# return: Failure if cancelled, or status code of install operation

function installFile {
  local installPath installName overwrite input
  local source="${BASE_DIR}/${2}"

  if [ ! -f "${source}" ] && [ ! -d "${source}" ]
  then
    echo "Source path does not exist: ${source}"
    return 1
  fi

  if [ "${3}" ]
  then
    if [ "${3:0:1}" = "/" ]
    then
      installPath="${3}/"
    else
      installPath="${HOME}/${3}/"
    fi
  else
    installPath="${HOME}/"
  fi

  if [ "${4}" ]
  then
    installName="${4}"
  else
    installName=`basename "${2}"`
  fi

  echo "Installing ${installPath}${installName}.."

  overwrite=false

  if [ ! -d ${installPath} ]
  then
    echo -n "${installPath} does not exist. Create? [Y/n] "
    read input
    case ${input} in
      [Nn] )
        checkContinue
        return 1
        ;;
      * ) mkdir -p "${installPath}" ;;
    esac
  fi

  if [ -f "${installPath}${installName}" ] || [ -d "${installPath}${installName}" ] || [ -L "${installPath}${installName}" ]
  then
    if [ "${1}" = "s" ] && ([ ! -L "${installPath}${installName}" ] || [ "`readlink -- "${installPath}${installName}"`" != "${source}" ])
    then
      echo -n "${installPath}${installName} seems to not be correctly linked. Overwrite? [Y/n] "
      read input
      case ${input} in
        [Nn] ) ;;
        * )
          rm -rf "${installPath}${installName}"
          overwrite=true
          ;;
      esac
    else
      if [ ${NO_OVERWRITE} ]
      then
        echo "Already exists. Skipping.."
        return 1
      else
        echo -n "${installPath}${installName} already exists. Overwrite? [y/N] "
        read input
        case ${input} in
          [Yy] )
            rm "${installPath}${installName}"
            overwrite=true
            ;;
        esac
      fi
    fi
  else
    overwrite=true
  fi

  if [[ "${overwrite}" == "true" ]]
  then
    if [[ "${1}" == "s" ]]
    then
      ln -sf "${source}" "${installPath}${installName}"
    elif [[ "${1}" == "c" ]]
    then
      cp -r "${source}" "${installPath}${installName}"
    else
      return 1
    fi
  else
    return 1
  fi
}

################################################################################
# Installs a file. The installation might be a copy or a symlink
# The target file is checked for existence and a prompt will ask if it should
# be overwritten
#
# arg1: Either "s" or "c" for symlink or copy, respectively
# arg2: The source file
# arg3: Installation path. Should end with /
# return: Failure if cancelled, or status code of install operation

function installPacaur {
  local input

  echo -n "Install pacaur? [Y/n] "
  read input
  case ${input} in
    [Nn] )
      return 0
      ;;
  esac

  if ! checkInstallDefault git
  then
    return 1
  fi
  GIT_INSTALLED=1

  ${SU_DO} pacman -S base-devel fakeroot jshon expac yajl

  rm -rf /tmp/dotfile_pacaur_install 2> /dev/null
  mkdir /tmp/dotfile_pacaur_install

  cd /tmp/dotfile_pacaur_install
  if git clone https://aur.archlinux.org/cower.git
  then
    cd cower
    gpg --recv-keys --keyserver hkp://pgp.mit.edu 1EB2638FF56C0C53
    makepkg && ${SU_DO} pacman --noconfirm -U *.tar.xz
  fi

  cd /tmp/dotfile_pacaur_install
  if ! git clone https://aur.archlinux.org/pacaur.git
  then
    return 1
  fi

  cd pacaur
  if makepkg && ${SU_DO} pacman --noconfirm -U *.tar.xz
  then
    echo "Using pacaur"
    PACKAGE_INSTALL="pacaur --noedit --noconfirm -S"
    return 0
  else
    return 1
  fi
}

function delete {
  local input searchFlag deleteFlag

  if [[ "${1}" == "file" ]]
  then
    searchFlag='-f'
  elif [[ "${1}" == "dir" ]]
  then
    searchFlag='-d'
    deleteFlag='-rf'
  else
    echo "Invalid parameters for delete()"
    return -1
  fi

  shift

  if [ ${searchFlag} "${1}" ]
  then
    echo -n "Delete ${1}? [y/N] "
    read input
    case ${input} in
      [Yy] )
        rm ${deleteFlag} "${1}"
        ;;
    esac
  fi
}

################################################################################
# Script start                                                                 #
################################################################################

########################################
# Variables
BASE_DIR=$(dirname $(fullPath ${0}))
SU_DO=""
SYS_TYPE=""
PACKAGE_INSTALL=""
PLUGIN_MANAGER=""
ZSH_FRAMEWORK=""

if [[ "${1}" = "-no" ]]
then
  NO_OVERWRITE=1
fi

########################################
# Check OS
echo -n "Checking OS.. ["
case `uname -v` in
  *Ubuntu*) SYS_TYPE="Ubuntu";;
  *FreeBSD*) SYS_TYPE="FreeBSD";;
  *Darwin*) SYS_TYPE="Darwin";;
  *Microsoft*) SYS_TYPE="Bash on Windows";;
  *)
    case `uname -a` in
      *ARCH*) SYS_TYPE="Arch";;
      *Android*) SYS_TYPE="Android";;
      *) SYS_TYPE="";;
    esac
esac

unset change

if [ -z "${SYS_TYPE}" ]
then
  echo "FAIL]"
  change=Y
else
  echo "${SYS_TYPE}]"
  if [ -z ${NO_OVERWRITE} ]
  then
    echo -n "Choose a different OS? [y/N] "
    read change
  fi
fi

case ${change} in
  [Yy] )
    echo "Select your OS"
    echo "[U]buntu"
    echo "[F]ree BSD"
    echo "[D]arwin"
    echo "A[n]droid"
    echo "[B]ash on Windows"
    echo "[A]rch"
    echo "[E]xit"

    echo -n "Choice: "
    read input
    case "${input}" in
      [Uu]) SYS_TYPE="Ubuntu";;
      [Ff]) SYS_TYPE="FreeBSD";;
      [Dd]) SYS_TYPE="Darwin";;
      [Nn]) SYS_TYPE="Android";;
      [Bb]) SYS_TYPE="Bash on Windows";;
      [Aa]) SYS_TYPE="Arch";;
      *) exit;;
    esac
esac

########################################
# Check sudo

if [ ! "${SYS_TYPE}" = "Android" ]
then
  case `id -u` in
    0) SU_DO="";;
    *)
      if [ ! $(command -v sudo) ]
      then
        checkContinue "sudo not found"
      else
        SU_DO="sudo"
      fi
      ;;
  esac
fi

########################################
# Determine package manager
echo -n "Checking package manager.. ["
if [ $(command -v apt-get) ]
then
  echo "apt-get]"
  if [ ! "${SYS_TYPE}" = "Ubuntu" ] \
    && [ ! "${SYS_TYPE}" = "Bash on Windows" ] \
    && [ ! "${SYS_TYPE}" = "Android" ]
  then
    checkContinue "OS mismatch"
  fi
  PACKAGE_INSTALL="${SU_DO} apt-get -y install"

elif [ $(command -v pkg) ]
then
  echo "pkg]"
  [ ! "${SYS_TYPE}" = "FreeBSD" ] && checkContinue "OS mismatch"
  PACKAGE_INSTALL="${SU_DO} pkg install -y"

elif [ $(command -v brew) ]
then
  echo "brew]"
  [ ! "${SYS_TYPE}" = "Darwin" ] && checkContinue "OS mismatch"
  PACKAGE_INSTALL="brew install"

elif [ $(command -v pacaur) ]
then
  echo "pacaur]"
  [ ! "${SYS_TYPE}" = "Arch" ] && checkContinue "OS mismatch"
  PACKAGE_INSTALL="pacaur --noedit --noconfirm -S"

elif [ $(command -v pacman) ]
then
  echo "pacman]"
  [ ! "${SYS_TYPE}" = "Arch" ] && checkContinue "OS mismatch"
  PACKAGE_INSTALL="${SU_DO} pacman --noconfirm -S"

else
  echo "FAIL]"
  echo "Could not determine package manager"
  exit
fi

########################################
# Suggest pacaur
if [[ "${PACKAGE_INSTALL}" == "${SU_DO} pacman --noconfirm -S" ]] && ! installPacaur
then
  echo "Could not install pacaur!"
  echo -n "Continue using pacman? [Y/n] "
  read input
  case ${input} in
    [Nn] )
      exit
      ;;
  esac
fi

cd ${HOME}

########################################
# Install git
[ -z ${GIT_INSTALLED} ] && checkInstallDefault git

########################################
# Install curl
checkInstallDefault curl

########################################
# Install NeoVim
checkInstall "NeoVim" "${PACKAGE_INSTALL} neovim" '[ $(command -v 'nvim') ]'

########################################
# Check pluginManager
echo -n "Checking Plugin Manager.. ["
if [ -f "${HOME}/.config/m-lima/zsh/local.zsh" ]
then
  PLUGIN_MANAGER=`awk '{ if ($1 ~ /^local_pluginManager=.+/) { print $1 }}' "${HOME}/.config/m-lima/zsh/local.zsh" | cut -d '=' -f2 | tail -1`
  unset change

  if [ -z "${PLUGIN_MANAGER}" ]
  then
    PLUGIN_MANAGER=`awk '{ if ($1 ~ /^local_pluginManager=.+/) { print $1 }}' "${HOME}/.zshrc" | cut -d '=' -f2 | tail -1`
  fi

  if [ -z "${PLUGIN_MANAGER}" ]
  then
    echo "FAIL]"
    change=Y
  else
    echo "${PLUGIN_MANAGER}]"
    if [ -z ${NO_OVERWRITE} ]
    then
      echo -n "Choose a different manager? [y/N] "
      oldPluginManager="${PLUGIN_MANAGER}"
      read change
    fi
  fi

  case ${change} in
    [Yy] )
      echo "Select your manager"
      echo "Z[G]en"
      echo "Z[P]lug"
      echo "[N]one"
      echo "[E]xit"

      echo -n "Choice: "
      read input
      case "${input}" in
        [Gg]) PLUGIN_MANAGER="zgen";;
        [Pp]) PLUGIN_MANAGER="zplug";;
        [Nn]) PLUGIN_MANAGER="";;
        *) exit;;
      esac

      echo -n "Updating local configuration"
      if sed -i 's~pluginManager=.*~pluginManager='"${PLUGIN_MANAGER}"'~g' "${HOME}/.config/m-lima/zsh/local.zsh"
      then
        echo " by replacing existing declaration"
      else
        echo " by inserting new declaration"
        echo 'pluginManager='"${PLUGIN_MANAGER}" >> "${HOME}/.config/m-lima/zsh/local.zsh"
      fi
  esac
fi

########################################
# Check ZSH framework
echo -n "Checking ZSH framework.. ["
if [ -f "${HOME}/.config/m-lima/zsh/local.zsh" ]
then
  ZSH_FRAMEWORK=`awk '{ if ($1 ~ /^local_zshFramework=.+/) { print $1 }}' "${HOME}/.config/m-lima/zsh/local.zsh" | cut -d '=' -f2 | tail -1`
  unset change

  if [ -z "${ZSH_FRAMEWORK}" ]
  then
    ZSH_FRAMEWORK=`awk '{ if ($1 ~ /^local_zshFramework=.+/) { print $1 }}' "${HOME}/.zshrc" | cut -d '=' -f2 | tail -1`
  fi

  if [ -z "${ZSH_FRAMEWORK}" ]
  then
    echo "FAIL]"
    change=Y
  else
    oldZshFramework="${ZSH_FRAMEWORK}"
    echo "${ZSH_FRAMEWORK}]"
    if [ -z ${NO_OVERWRITE} ]
    then
      echo -n "Choose a different framework? [y/N] "
      read change
    fi
  fi

  case ${change} in
    [Yy] )
      echo "Select your framework"
      echo "[P]rezto"
      echo "[O]h-my-zsh"
      echo "[N]one"
      echo "[E]xit"

      echo -n "Choice: "
      read input
      case "${input}" in
        [Pp]) ZSH_FRAMEWORK="prezto";;
        [Oo]) ZSH_FRAMEWORK="omz";;
        [Nn]) ZSH_FRAMEWORK="";;
        *) exit;;
      esac

      echo -n "Updating local configuration"
      if sed -i 's~zshFramework=.*~zshFramework='"${ZSH_FRAMEWORK}"'~g' "${HOME}/.config/m-lima/zsh/local.zsh"
      then
        echo " by replacing existing declaration"
      else
        echo " by inserting new declaration"
        echo 'zshFramework='"${ZSH_FRAMEWORK}" >> "${HOME}/.config/m-lima/zsh/local.zsh"
      fi
  esac
fi

########################################
# Install vim
if [[ "${SYS_TYPE}" == "Darwin" ]]
then
  checkInstall "Vim" "${PACKAGE_INSTALL} vim --with-lua" '[ $(command -v 'vim') ]'
elif [[ "${SYS_TYPE}" == "Arch" ]]
then
  checkInstall "Vim" "${PACKAGE_INSTALL} vim" '[ $(command -v 'vim') ]'
else
  checkInstall "Vim" "${PACKAGE_INSTALL} vim-nox" '[ $(command -v 'vim') ]'
fi

########################################
# Install Vim-Plug
# checkInstall "Vundle" 'git clone https://github.com/VundleVim/Vundle.vim.git "${HOME}"/.vim/bundle/Vundle.vim' '[ -d "${HOME}"/.vim/bundle/Vundle.vim ]'

# NeoVim
if [ $(command -v nvim) ]
then
  if checkInstall "Vim-Plug for NeoVim" 'curl -fLo ~/.local/share/nvim/site/autoload/plug.vim --create-dirs https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim' '[ -f ~/.local/share/nvim/site/autoload/plug.vim ]'
  then
    nvim -c 'PlugInstall' -c 'qa!'
  fi
else
  echo "Skipping Vim-Plug for NeoVim"
fi

# Vim
if [ $(command -v vim) ]
then
  if checkInstall "Vim-Plug for Vim" 'curl -fLo ~/.vim/autoload/plug.vim --create-dirs https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim' '[ -f ~/.vim/autoload/plug.vim ]'
  then
    vim -c 'PlugInstall' -c 'qa!'
  fi
else
  echo "Skipping Vim-Plug for Vim"
fi

########################################
# Install tmux
checkInstallDefault tmux

########################################
# Install ZSH
if checkInstallDefault zsh && [ ! "${SYS_TYPE}" = "Bash on Windows" ]
then
  echo -n "Checking default shell.. ["
  if [[ "${SHELL}" == */zsh ]]
  then
    echo "OK]"
  else
    echo "FAIL]"

    echo -n "Set ZSH as main shell? [y/N] "
    read input
    case ${input} in
      [Yy] )
        echo "Setting as main shell.."

        if chsh -s $(which zsh)
        then
          echo "Done!"
          export SHELL=zsh
        else
          checkContinue "Could not set the main shell!"
        fi
        ;;
    esac
  fi
fi

########################################
# Install bat
checkInstall "Bat" "${PACKAGE_INSTALL} bat" '[ $(command -v "bat") ] || [ $(command -v "batcat") ]'

########################################
# Install delta
if [ "${SYS_TYPE}" = "Ubuntu" ]
then
  echo 'Incompatible OS for delta check https://dandavison.github.io/delta/installation.html for manual installation'
else
  checkInstall "Delta" "${PACKAGE_INSTALL} git-delta" '[ $(command -v "delta") ]'
fi

########################################
# Install fzf
checkInstall "fzf" 'git clone --depth 1 https://github.com/junegunn/fzf.git ${HOME}/code/others/fzf && "${HOME}/code/others/fzf/install" --no-fish' '[ $(command -v "fzf") ]'

########################################
# Install rg
checkInstall "rg" "${PACKAGE_INSTALL} ripgrep" '[ $(command -v "rg") ]'

########################################
# Create ~/bin
echo -n "Checking bin folder.. ["
if [ -d "${HOME}"/bin ]
then
  echo "OK]"
else
  echo "FAIL]"
  echo "Creating folder.."

  if mkdir "${HOME}"/bin &> /dev/null
  then
    echo "Done!"
  else
    checkContinue "Could not create bin folder!"
  fi
fi

########################################
# Make symlinks
echo "Making symlinks.."
if [ $(command -v zsh) ]
then
  installFile s zsh/.zshrc
  installFile s zsh/.zshenv
  installFile s zsh/config .config/m-lima zsh
else
  echo "Skipping ZSH links"
fi

if [ $(command -v git) ]
then
  installFile s git/.gitconfig
  if installFile s git/config .config/m-lima git
  then
    touch "${HOME}/.config/m-lima/git/local"
    vi "${HOME}/.config/m-lima/git/local"
  fi
else
  echo "Skipping Git links"
fi

if [ $(command -v nvim) ] || [ $(command -v vim) ]
then
  installFile s vim/config .config/m-lima vim
else
  echo "Skipping generic (Neo)Vim links"
fi

if [ $(command -v nvim) ]
then
  installFile s vim/init.vim .config/nvim
  installFile s vim/grayalt.vim .config/nvim/colors
  installFile s vim/simpalt.vim .config/nvim/colors
  installFile s vim/config/lua .config/nvim
else
  echo "Skipping NeoVim links"
fi

if [ $(command -v vim) ]
then
  installFile s vim/init.vim . .vimrc
  installFile s vim/grayalt.vim .vim/colors
  installFile s vim/simpalt.vim .vim/colors
else
  echo "Skipping Vim links"
fi

if [ $(command -v nvim) ] || [ $(command -v vim) ]
then
  installFile s vim/.ideavimrc .
else
  echo "Skipping IdeaVim links"
fi

if [ $(command -v tmux) ]
then
  if installFile s tmux .config tmux
  then
    touch "${HOME}/.config/tmux/local.conf"
    vi "${HOME}/.config/tmux/local.conf"
  fi
else
  echo "Skipping Tmux links"
fi

if [ $(command -v alacritty) ]
then
  if installFile s alacritty/config .config alacritty
  then
    case "${SYS_TYPE}" in
      Darwin)
        ln -sf macos.yml "${HOME}/.config/alacritty/system.yml" ;;
      *)
        ln -sf linux.yml "${HOME}/.config/alacritty/system.yml" ;;
    esac
  fi
fi

installFile s scripts/scaffpp bin
installFile s scripts/scaffjs bin
installFile s scripts/cargo-all bin
installFile s scripts/rg-comment bin
installFile s scripts/rpl bin

if [[ "${SYS_TYPE}" == "Android" ]]
then
  installFile s termux/colors.properties .termux
fi

if [ $(command -v bat) ]
then
  installFile s config/bat/config `bat --config-dir`
elif [ $(command -v batcat) ]
then
  installFile s config/bat/config `batcat --config-dir`
fi

if [ $(command -v cargo) ]
then
  if [ -n "${CARGO_HOME}" ]
  then
    installFile s cargo/config.toml "${CARGO_HOME}"
  else
    installFile s cargo/config.toml "${HOME}/.cargo"
  fi
fi

########################################
# Copy files
echo "Copying files.."

if [ $(command -v zsh) ]
then
  if installFile c zsh/local.zsh .config/m-lima/zsh
  then
    if [[ "${PACKAGE_INSTALL}" == "pacaur --noedit --noconfirm -S" ]]
    then
      echo "alias pc='pacaur --color always'" >> "${HOME}/.config/m-lima/zsh/local.zsh"
      echo "alias pcm='pacman --color always'" >> "${HOME}/.config/m-lima/zsh/local.zsh"
    fi
    [ "${PLUGIN_MANAGER}" ] && echo "pluginManager=${PLUGIN_MANAGER}" >> "${HOME}/.config/m-lima/zsh/local.zsh"
    [ "${ZSH_FRAMEWORK}" ] && echo "zshFramework=${ZSH_FRAMEWORK}" >> "${HOME}/.config/m-lima/zsh/local.zsh"
    vi "${HOME}/.config/m-lima/zsh/local.zsh"
  fi

  if installFile c zsh/final.zsh .config/m-lima/zsh
  then
    vi "${HOME}/.config/m-lima/zsh/final.zsh"
  fi

  if installFile c config/fd/config .config/m-lima/fd
  then
    vi "${HOME}/.config/m-lima/fd/config"
  fi
else
  echo "Skipping ZSH files"
fi

########################################
# PyEnv for (Neo)Vim
if [ $(command -v nvim) ]
then
  if [ ! -d "${HOME}/code/python/env/vim" ] || [ -z ${NO_OVERWRITE} ]
  then
    echo "Installing vim pyenv.."
    echo -n "Create pyenv for vim? [y/N] "
    read input
    case ${input} in
      [Yy] )
        python3 -m virtualenv &> /dev/null
        if (( $? == 2 ))
        then
          python3 -m virtualenv "${HOME}/code/python/env/vim"
        else
          python3 -m venv &> /dev/null
          if (( $? == 2 ))
          then
            python3 -m venv "${HOME}/code/python/env/vim"
          fi
        fi

        if [ -f  "${HOME}/code/python/env/vim/bin/activate" ]
        then
          source "${HOME}/code/python/env/vim/bin/activate"
          pip3 install pynvim
          deactivate
        else
          echo "Could not set virtual environment"
        fi
    esac
  fi
fi

########################################
# Download fonts

echo "Downloading fonts.."
echo -n "Download fonts? [y/N] "
read input
case ${input} in
  [Yy] )
    if [ ! -f "${HOME}/DejaVu Sans Mono for Powerline.ttf" ] || [ -z ${NO_OVERWRITE} ]
    then
      echo "Downloading font.."
      echo -n "Download DejaVu Sans for Powerline? [y/N] "
      read input
      case ${input} in
        [Yy] )
          cd "${HOME}"
          curl -s -L 'https://raw.githubusercontent.com/powerline/fonts/master/DejaVuSansMono/DejaVu Sans Mono for Powerline.ttf' -o "${HOME}/DejaVu Sans Mono for Powerline.ttf" && echo "Font saved as ${HOME}/DejaVu Sans Mono for Powerline.ttf"
          ;;
      esac
    fi

    if [ ! -f "${HOME}/DejaVu Sans Mono Nerd Font.zip" ] || [ -z ${NO_OVERWRITE} ]
    then
      echo -n "Download DejaVu Sans Nerd Font? [y/N] "
      read input
      case ${input} in
        [Yy] )
          cd "${HOME}"
          curl -s -L 'https://github.com/ryanoasis/nerd-fonts/releases/download/v2.0.0/DejaVuSansMono.zip' -o "${HOME}/DejaVu Sans Mono Nerd Font.zip" && echo "Font saved as ${HOME}/DejaVu Sans Mono Nerd Font.zip"
          ;;
      esac
    fi

    if [ ! -f "${HOME}/ter-powerline-v14b.psf.gz" ] || [ -z ${NO_OVERWRITE} ]
    then
      echo "Downloading font.."
      echo -n "Download Terminus Powerline PSF? [y/N] "
      read input
      case ${input} in
        [Yy] )
          cd "${HOME}"
          curl -s -L 'https://github.com/ryanoasis/nerd-fonts/raw/master/src/unpatched-fonts/Terminus/PSF/ter-powerline-v14b.psf.gz' -o "${HOME}/ter-powerline-v14b.psf.gz" && echo "Font saved as ${HOME}/ter-powerline-v14b.psf.gz"
          ;;
      esac
    fi
    ;;
esac