upgrade

#!/bin/bash

# SPDX-FileCopyrightText: 2017 - 2024 sudorook <daemon@nullcodon.com>
#
# SPDX-License-Identifier: GPL-3.0-or-later
#
# This program is free software: you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by the Free
# Software Foundation, either version 3 of the License, or (at your option)
# any later version.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
# for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program. If not, see <https://www.gnu.org/licenses/>.

set -eu

ROOT="$(dirname "${0}")"

source "${ROOT}"/globals

! check_command git && exit 3

#
# Functions
#

function check_command() { # overrides check_command() in globals
  local package
  local missing=()
  for package in "${@}"; do
    if ! command -v "${package}" > /dev/null; then
      missing+=("${package}")
    fi
  done
  if [ ${#missing[@]} -eq 0 ]; then
    return 0
  else
    show_warning "Install ${missing[*]@Q} first. Skipping."
    return 1
  fi
}

function rand_int() {
  local min
  local max
  min="${1:-1}"
  max="${2:-10}"
  shuf -i"${min}-${max}" -n1
}

function is_git_dirty() {
  if [ "${#}" -eq 0 ]; then
    if [[ "$(git status --porcelain --untracked-files=no)" != "" ]]; then
      return 0
    else
      return 1
    fi
  else
    if [[ "$(git -C "${1}" status --porcelain --untracked-files=no)" != "" ]]; then
      return 0
    else
      return 1
    fi
  fi
}

function git_update() {
  local h
  local u
  local b
  local d=false
  local n=false

  if [ -z "$(git -C "${1}" remote)" ]; then
    show_warning "No remote is configured. Skipping."
    return 1
  fi

  # get current branch
  b="$(git -C "${1}" branch --show-current)"

  # check if repository is dirty
  if is_git_dirty "${1}"; then
    d=true
  fi

  # if dirty, stash changes on current branch
  if "${d}"; then
    git -C "${1}" stash
  fi

  # if not master branch, switch to it
  if [[ "${b}" != "master" ]]; then
    git -C "${1}" checkout master
  fi

  # fetch updates
  git -C "${1}" fetch --tags -f

  # merge changes if local and remote HEAD differ
  h=$(git -C "${1}" rev-parse HEAD)
  u=$(git -C "${1}" rev-parse "@{u}")
  if [ "${h}" != "${u}" ]; then
    n=true
    git -C "${1}" merge
  fi

  # restore original checked-out branch
  if [[ "${b}" != "master" ]]; then
    git -C "${1}" checkout "${b}"
  fi

  # restore stashed changes
  if "${d}"; then
    git -C "${1}" stash pop
  fi

  if "${n}"; then
    return 0
  else
    return 1
  fi
}

function print_usage() {
  show_header "Usage: upgrade"
  show_listitem "\
  -i|--images    upgrade Podman images
  -j|--julia     upgrade Julia packages
  -r|--rust      upgrade Rust via rustup
  -R|--R         upgrade R CRAN packages"
  if [[ -v pkgbuilddir ]]; then
    show_listitem "  -p|--pkgbuild  upgrade AUR pkgbuilds in ${pkgbuilddir}"
  fi
  show_listitem "  -s|--system    upgrade system packages (pacman or apt)"
  if [[ -v gtkdir ]] && [[ -v plasmadir ]] && [[ -v icondir ]]; then
    show_listitem "  -t|--themes    upgrade themes in ${gtkdir}, ${plasmadir}, and ${icondir}"
  fi
  if [[ -v vimpack ]]; then
    show_listitem "  -v|--vim       upgrade Git-versioned Vim packages installed in ${vimpack}"
  fi
  if [[ -v nvimpack ]]; then
    show_listitem "  -n|--nvim      upgrade Git-versioned Neovim packages installed in ${nvimpack}"
  fi
  if [[ -v weechatdir ]]; then
    show_listitem "  -w|--weechat   upgrade wee-slack plugin for weechat in ${weechatdir}"
  fi
  if [[ -v zshdir ]]; then
    show_listitem "  -z|--zsh       upgrade Zsh plugins in ${zshdir}"
  fi
  show_listitem "  -x|--extra     execute custom upgrade rules"
}

function upgrade_system() {
  # Arch Linux (pacman)
  if check_command pacman; then
    show_header "Upgrading Arch Linux packages."
    sudo -k sh -c "pacman -Syu && paccache -r && paccache -ruk0"
    echo
    return 0
  fi

  # Debian, Ubuntu (apt)
  if check_command apt; then
    show_header "Upgrading Debian packages."
    sudo -k sh -c "apt update && apt -y full-upgrade && apt -y autoremove"
    echo
    return 0
  fi
}

function upgrade_themes() {
  show_header "Upgrading GTK, Plasma, and icon themes."
  local repo_name
  local dir
  local branch
  local dirty=false

  local dirs=()
  if [[ -v gtkdir ]] && [ -d "${gtkdir}" ]; then
    for dir in "${gtkdir}"/*; do
      if git -C "${dir}" rev-parse 2> /dev/null; then
        dirs+=("${dir}")
      fi
    done
  fi
  if [[ -v plasmadir ]] && [ -d "${plasmadir}" ]; then
    for dir in "${plasmadir}"/*; do
      if git -C "${dir}" rev-parse 2> /dev/null; then
        dirs+=("${dir}")
      fi
    done
  fi
  if [[ -v icondir ]] && [ -d "${icondir}" ]; then
    for dir in "${icondir}"/*; do
      if git -C "${dir}" rev-parse 2> /dev/null; then
        dirs+=("${dir}")
      fi
    done
  fi

  for dir in "${dirs[@]}"; do
    repo_name="$(basename "${dir}")"
    show_info "${repo_name}"
    branch="$(git -C "${dir}" branch --show-current)"
    if is_git_dirty "${dir}"; then
      dirty=true
    else
      dirty=false
    fi
    if git_update "${dir}"; then
      case "${repo_name}" in
        papirus-icon-theme)
          if git -C "${dir}" show-ref --verify --quiet "refs/heads/tweak"; then
            pushd "${dir}" > /dev/null
            git checkout tweak
            git reset HEAD~1
            git reset --hard
            git clean -xdf
            git rebase master
            tools/_restore_adapta_icons.sh
            sync
            git add .
            git commit -m "Mirror updates to Adapta icon set."
            git checkout master
            popd > /dev/null
          fi
          ;;
        *)
          if git -C "${dir}" show-ref --verify --quiet "refs/heads/tweak"; then
            if "${dirty}"; then
              git -C "${dir}" stash
            fi
            if [ "${branch}" != tweak ]; then
              git -C "${dir}" checkout tweak
            fi
            git -C "${dir}" rebase master
            if [ "${branch}" != tweak ]; then
              git -C "${dir}" checkout "${branch}"
            fi
            if "${dirty}"; then
              git -C "${dir}" stash pop
            fi
          fi
          ;;
      esac
    fi
    sleep "$(rand_int 2 10)"
    echo
  done

  if [[ -v thunderbirddir ]] && [[ -d "${thunderbirddir}/chrome" ]]; then
    show_info "$(basename "${thunderbirddir}") (thunderbird)"
    git -C "${thunderbirddir}/chrome" pull --ff-only origin master
    sleep "$(rand_int 2 10)"
    echo
  fi
}

function upgrade_extra() {
  show_header "Running extra upgrade script(s)."
}

function upgrade_vim_packages() {
  show_header "Upgrading Vim plugins."
  local vimpack=${HOME}/.vim/pack/dist/start
  local dir
  if check_command vim; then
    if [ -d "${vimpack}" ]; then
      for dir in "${vimpack}"/*; do
        if git -C "${dir}" rev-parse 2> /dev/null; then
          show_info "$(basename "${dir}")"
          git_update "${dir}" || true
          sleep "$(rand_int 2 10)"
          echo
        fi
      done
    else
      show_warning "${vimpack@Q} does not exist. Skipping."
      echo
    fi
  else
    echo # for output text spacing
  fi
}

function upgrade_nvim_packages() {
  show_header "Upgrading Neovim plugins."
  local nvimpack=${HOME}/.config/nvim/pack/dist/start
  local dir
  if check_command nvim; then
    if [ -d "${nvimpack}" ]; then
      for dir in "${nvimpack}"/*; do
        if git -C "${dir}" rev-parse 2> /dev/null; then
          show_info "$(basename "${dir}")"
          git_update "${dir}" || true
          sleep "$(rand_int 2 10)"
          echo
        fi
      done
    else
      show_warning "${nvimpack@Q} does not exist. Skipping."
      echo
    fi
  else
    echo # for output text spacing
  fi
}

function upgrade_zsh() {
  show_header "Upgrading Zsh plugins."
  local dir
  if check_command zsh; then
    # antigen-update may not be in the bash PATH, so check the zsh path if
    # 'command -v antigen' returns false.
    if zsh -ic "command -v antigen" > /dev/null 2>&1; then
      zsh -ic "antigen update"
      sleep "$(rand_int 2 10)"
    else
      if [[ -v zshdir ]] && [ -d "${zshdir}" ]; then
        for dir in "${zshdir}"/*; do
          if git -C "${dir}" rev-parse 2> /dev/null; then
            show_info "$(basename "${dir}")"
            git -C "${dir}" pull --ff-only origin master --tags
            sleep "$(rand_int 2 10)"
            echo
          fi
        done
      else
        show_warning "No Zsh plugins found in ${zshdir@Q}. Skipping."
        echo
      fi
    fi
  else
    echo # for output text spacing
  fi
}

function upgrade_gems() {
  show_header "Upgrading user-installed gems."
  local gemhome
  local gem
  gemhome="$(gem env user_gemhome)"
  while read -r gem; do
    if gem list --silent -i "${gem}"; then
      gem update --conservative --minimal-deps "${gem}"
    else
      show_warning "Something went wrong parsing ${gem@Q}."
    fi
  done < <(
      find "${gemhome}/gems/" -mindepth 1 -maxdepth 1 -type d -exec basename {} \; |
        sed \
          -e "s/-linux$//g" \
          -e "s/-\(x86\)\(_64\)\?$//g" \
          -e "s/-[0-9\.]\+$//g"

  )
}

function update_images() {
  show_header "Upgrading Podman images."
  local image
  if check_command podman; then
    if [[ "$(podman image list --noheading)" = "" ]]; then
      show_warning "No images installed. Skipping..."
    else
      while read -r image; do
        if [[ "${image}" =~ ^localhost/ ]]; then
          continue
        fi
        podman image pull "${image}"
      done <<< "$(podman image list --format "{{ .Repository }}")"
      show_info "Pruning dangling images."
      podman image prune --force
    fi
  fi
  echo
}

function upgrade_julia_packages() {
  show_header "Upgrading Julia packages."
  if check_command julia; then
    julia -e "using Pkg; Pkg.update()"
    sleep "$(rand_int 2 10)"
  fi
  echo
}

function upgrade_rust() {
  show_header "Upgrading Rust compiler and components."
  if check_command rustup cargo; then
    if ! [[ "$(rustup toolchain list)" = "no installed toolchains" ]]; then
      rustup self upgrade-data
      rustup update
      if ! [ -d /usr/share/cargo/registry ]; then
        show_info "Updating crates."
        if [ -d "${projectdir}"/crate_dl ]; then
          pushd "${projectdir}"/crate_dl > /dev/null
          rm -f Cargo.lock
          cargo fetch
          popd > /dev/null
        else
          local tmpdir
          tmpdir="$(mktemp -d)"
          git clone --depth 1 https://github.com/sudorook/crate_dl.git "${tmpdir}"
          pushd "${tmpdir}" > /dev/null
          cargo fetch
          popd > /dev/null
          rm -rf "${tmpdir}"
        fi
      fi
    else
      show_warning "No rust toolchain installed. Skipping."
    fi
  fi
  echo
}

function upgrade_R() {
  show_header "Upgrading R packages."
  if check_command Rscript; then
    if [[ -v R_LIBS_USER ]]; then
      Rscript <(
        cat << EOF
update.packages(ask = FALSE,
                checkBuilt = TRUE,
                clean = TRUE,
                lib = "${R_LIBS_USER}",
                repos = 'https://cloud.r-project.org/')
EOF
      )
    else
      show_warning "R_LIBS_USER is not set. Skipping."
    fi
    sleep "$(rand_int 2 10)"
  fi
  echo
}

function upgrade_pkgbuild() {
  if check_command makepkg; then
    show_header "Upgrading AUR pkgbuilds."
    local dir
    if [[ -v pkgbuilddir ]] && [[ -d "${pkgbuilddir}" ]]; then
      for dir in "${pkgbuilddir}"/*; do
        if git -C "${dir}" rev-parse 2> /dev/null; then
          show_info "$(basename "${dir}")"
          if git_update "${dir}"; then
            pushd "${dir}" > /dev/null
            makepkg -si --noconfirm
            git clean -xdf
            git reset --hard
            popd > /dev/null
          fi
          sleep "$(rand_int 2 10)"
          echo
        fi
      done
    else
      show_warning "No PKGBUILDs found. Skipping."
      echo
    fi
  else
    echo # for output text spacing
  fi
}

function upgrade_weechat_plugins {
  show_header "Upgrading weechat plugins."
  local weechatdir=${HOME}/.weechat/plugins
  local dir
  if [ -d "${weechatdir}" ]; then
    for dir in "${weechatdir}"/*; do
      if git -C "${dir}" rev-parse 2> /dev/null; then
        show_info "$(basename "${dir}")"
        git -C "${dir}" pull --ff-only origin master --tags
        sleep "$(rand_int 2 10)"
        echo
      fi
    done
  else
    show_warning "No weechat plugin directory exists. Skipping."
    echo
  fi
}

#
# Main
#

OPTIONS=ahgijrRpstnvwxz
LONGOPTIONS=all,help,gems,images,julia,rust,R,pkgbuild,system,theme,nvim,vim,weechat,extra,zsh
PARSED=$(getopt -o "${OPTIONS}" --long "${LONGOPTIONS}" -n "${0}" -- "${@}")
eval set -- "${PARSED}"

while [ ${#} -ge 1 ]; do
  case ${1} in
    -a | --all)
      upgrade_system
      upgrade_gems
      upgrade_julia_packages
      upgrade_rust
      upgrade_R
      upgrade_pkgbuild
      upgrade_themes
      upgrade_vim_packages
      upgrade_nvim_packages
      upgrade_weechat_plugins
      upgrade_zsh
      upgrade_extra
      shift
      break
      ;;
    -h | --help)
      print_usage
      exit
      ;;
    -g | --gems)
      upgrade_gems
      shift
      ;;
    -i | --images)
      update_images
      shift
      ;;
    -j | --julia)
      upgrade_julia_packages
      shift
      ;;
    -r | --rust)
      upgrade_rust
      shift
      ;;
    -R | --R)
      upgrade_R
      shift
      ;;
    -p | --pkgbuild)
      upgrade_pkgbuild
      shift
      ;;
    -s | --system)
      upgrade_system
      shift
      ;;
    -t | --theme)
      upgrade_themes
      shift
      ;;
    -n | --nvim)
      upgrade_nvim_packages
      shift
      ;;
    -v | --vim)
      upgrade_vim_packages
      shift
      ;;
    -w | --weechat)
      upgrade_weechat_plugins
      shift
      ;;
    -z | --zsh)
      upgrade_zsh
      shift
      ;;
    -x | --extra)
      upgrade_extra
      shift
      ;;
    --)
      shift
      break
      ;;
    *)
      show_error "Error: invalid flag."
      exit 3
      ;;
  esac
done