dot

#!/usr/bin/env bash

[[ -z "${DOTFILES}" ]] && echo "Symlink first" && exit 1
. "${DOTFILES}/lib/helpers.sh"
. "${DOTFILES}/lib/pretty.bash"

[[ -d "$PYENV_ROOT" ]] && eval "$(pyenv init -)"
[[ -n "$NVM_DIR" ]] && __dko_source "${NVM_DIR}/nvm.sh"

# ==============================================================================
# Command functions
# ==============================================================================

# ------------------------------------------------------------------------------
# Meta
# ------------------------------------------------------------------------------

__dko_dotfiles__command_not_found() {
  __dko_err "Command not found '${1:-''}'"
  echo
  __dko_dotfiles__usage
  exit 1
}

__dko_dotfiles__usage() {
  __dko_usage "dot <command>"
  echo '
  Utility Commands
    dotfiles    -- update dotfiles (git pull)
    secret      -- update ~/.secret (git pull)
    daily       -- secret, Packages / Developer Tools, fzf, nvm, pyenv

  Shell Tools
    fzf         -- update fzf with flags to not update rc scripts
    node        -- install latest node via nvm
    nvm         -- update nvm installation
    pyenv       -- update pyenv installation

  Packages / Developer Tools
    composer    -- update composer and global packages
    gem         -- update rubygems and global gems for current ruby
    go          -- golang
    pip         -- update all versions of pip (OS dependent)
    neopy       -- update neovim pyenvs
    wpcs        -- update the WordPress-Coding-Standards git repo in src/wpcs

  System: Arch Linux
    arch        -- update arch packages

  System: Debian/Ubuntu
    deb         -- update apt packages

  System: macOS/OS X
    brew        -- homebrew packages
    mac         -- repair permissions and check software updates
'
}

__dko_dotfiles__cd() {
  cd -- "$DOTFILES" || {
    __dko_err "No \$DOTFILES directory"
    return 1
  }
}

__dko_dotfiles__update() {
  __dko_status "Updating dotfiles"

  local lockfile="${LDOTDIR}/dotfiles.lock"
  # shellcheck disable=SC2064
  trap "rm -f \"$lockfile\"" EXIT
  touch "$lockfile"

  (
    __dko_dotfiles__cd || exit 1
    git pull --rebase || exit 1
    git log --no-merges --abbrev-commit --oneline ORIG_HEAD..
  ) || {
    __dko_err "Error updating dotfiles"
    return 1
  }

  __dko_ok "Successfully updated dotfiles"
}

__dko_dotfiles__update_secret() {
  __dko_status "Updating ~/.secret/"
  (
    cd -- "${HOME}/.secret" ||
      { __dko_err "No ~/.secret directory" && exit 1; }
    git pull --rebase --recurse-submodules || exit 1
    git log --no-merges --abbrev-commit --oneline ORIG_HEAD..
  ) || __dko_err "Failed to update ~/.secret/"
}

__dko_dotfiles__update_daily() {
  __dko_dotfiles__update_secret

  if [[ -x "/usr/local/opt/fzf/install" ]] || [[ -d "${HOME}/.fzf" ]]; then
    __dko_dotfiles__update_fzf
  else
    __dko_warn "fzf is not installed"
  fi

  if __dko_dotfiles__node__require_nvm --silent; then
    __dko_dotfiles__node__update_nvm
  else
    __dko_warn "NVM not found, skipping update NVM"
  fi

  if __dko_dotfiles__go__require_go --silent; then
    __dko_dotfiles__go__update_go_packages
  else
    __dko_warn "Go not found, skipping update Go dependencies"
  fi

  if ! __dko_dotfiles__ruby__require_chruby --silent; then
    __dko_warn "Chruby not found, skipping update ruby gems"
  elif ! __dko_dotfiles__ruby__require_rubygems; then
    __dko_warn "Rubygems not found, skipping update ruby gems"
  else
    __dko_dotfiles__ruby__update_gems
  fi

  if ! __dko_dotfiles__php__require_composer --silent; then
    __dko_warn "Composer not found, skipping update composer and packages"
  else
    __dko_dotfiles__php__update_composer
    if __dko_dotfiles__php__require_phpcs --silent; then
      __dko_dotfiles__php__update_wpcs
    else
      __dko_warn "PHPCS not found, skipping update WPCS"
    fi
  fi

  if ! __dko_has "pyenv"; then
    __dko_warn "pyenv not found"
  else
    __dko_dotfiles__py__update_pyenv
    __dko_dotfiles__py__update_pip "pip"
    __dko_dotfiles__py__update_neovim_python
  fi
}

# ------------------------------------------------------------------------------
# Private utilities
# ------------------------------------------------------------------------------

__dko_dotfiles__pyenv_system() {
  # switch to brew's python (fallback to system if no brew python)
  __dko_has "pyenv" &&
    __dko_status "Switching to system python to upgrade brew packages" &&
    pyenv shell system || exit 1 &&
  python --version
}

# probably don't need this as long as running updates in subshells
__dko_dotfiles__pyenv_global() {
  __dko_has "pyenv" &&
    __dko_status_ "Switching back to global python" &&
    pyenv shell --unset || exit 1
}

# ------------------------------------------------------------------------------
# Externals
# ------------------------------------------------------------------------------

__dko_dotfiles__update_fzf() {
  local installer

  if [[ -x "/usr/local/opt/fzf/install" ]]; then
    __dko_status "fzf was installed via brew, re-running installer"
    installer="/usr/local/opt/fzf/install"
  elif [[ -d "${HOME}/.fzf" ]]; then
    __dko_status "fzf was installed in ~/.fzf"
    installer="${HOME}/.fzf/install"
    (
      cd -- "${HOME}/.fzf" || { __dko_err "Could not cd to ~/.fzf" && exit 1; }
      __dko_status "Updating fzf"
      git pull || { __dko_err "Could not update ~/.fzf" && exit 1; }
      git log --no-merges --abbrev-commit --oneline ORIG_HEAD..
    ) || return 1
  else
    __dko_err "fzf is not installed"
    return 1
  fi

  # Install/update shell extensions
  if [[ -n "$installer" ]]; then
    __dko_status "Updating fzf shell extensions"
    "$installer" --bin || return 1
  fi
}

# ----------------------------------------------------------------------------
# Ruby: Introspection
# ----------------------------------------------------------------------------

# pass any arg to silence
__dko_dotfiles__ruby__require_chruby() {
  [[ -n "$RUBY_VERSION" ]] && return 0
  __dko_warn "System ruby detected! Please install and use chruby"
  return 1
}

# pass any arg to silence
__dko_dotfiles__ruby__require_rubygems() {
  __dko_has "gem" && return 0
  __dko_warn "rubygems is not installed"
  return 1
}

# ----------------------------------------------------------------------------
# Ruby: Update Gems
# ----------------------------------------------------------------------------

__dko_dotfiles__ruby__update_gems() {
  __dko_status "Updating gems"
  __dko_dotfiles__ruby__require_chruby || return 1
  __dko_dotfiles__ruby__require_rubygems || return 1

  __dko_status "Updating RubyGems itself for ruby: ${RUBY_VERSION}"
  gem update --system || {
    __dko_err "Could not update RubyGems"
    return 1
  }

  gem update || {
    __dko_err "Could not update gems"
    return 1
  }
}

# ----------------------------------------------------------------------------
# Go
# ----------------------------------------------------------------------------

# pass any arg to silence
__dko_dotfiles__go__require_go() {
  __dko_has "go" && return 0
  __dko_warn "go is not installed"
  return 1
}

# pass any arg to silence
__dko_dotfiles__go__require_goenv() {
  __dko_has "goenv" && return 0
  __dko_warn "goenv is not installed"
  return 1
}
__dko_dotfiles__go__update_go_packages() {
  __dko_status "Updating go packages"
  __dko_dotfiles__go__require_goenv || return 1
  __dko_dotfiles__go__require_go || return 1

  # in case go was updated recently, the go shim needs to be reset
  goenv rehash

  go get -u all || {
    __dko_err "Could not update go packages"
    return 1
  }
}

# ----------------------------------------------------------------------------
# Node.js: Introspection
# ----------------------------------------------------------------------------

# pass any arg to skip autoinstall
# pass any arg to silence
__dko_dotfiles__node__require_nvm() {
  if [[ -z "$NVM_DIR" ]]; then
    __dko_err "\$NVM_DIR is not defined, make sure rc files are linked"
    return 1
  fi

  if (($# == 0)) && [[ ! -d "$NVM_DIR" ]]; then
    __dko_status "Installing nvm"
    git clone https://github.com/creationix/nvm.git "$NVM_DIR" ||
      { __dko_err "Could not install nvm" && return 1; }
  fi
}

# ----------------------------------------------------------------------------
# Node.js: Update node to latest stable
# ----------------------------------------------------------------------------

__dko_dotfiles__update_node() {
  __dko_dotfiles__node__require_nvm || return 1

  local wanted
  wanted="${1:-"$(nvm version-remote --lts)"}"
  [[ "$wanted" != "v"* ]] && wanted="v${wanted}"

  . "${NVM_DIR}/nvm.sh"
  __dko_status "Checking node versions against ${wanted}"

  local wanted_with_minor
  wanted_with_minor="$(nvm version-remote "$wanted")"

  local previous_node
  previous_node="$(nvm current)"

  if [[ "$wanted_with_minor" == "$previous_node" ]]; then
    __dko_ok "Node.js is already up-to-date"
    return 0
  fi

  __dko_status_ "Previous node version was $previous_node"
  echo -n "Install and use new node ${wanted_with_minor} as default? [y/N] "
  read -r
  echo
  if [[ "$REPLY" == "y" ]] || [[ "$REPLY" == "Y" ]]; then
    __dko_status "Installing node ${wanted_with_minor}..."
    if nvm install "$wanted"; then
      __dko_status "Updating default alias to ${wanted_with_minor}..."
      nvm alias default "$wanted"
      __dko_status "Switching to ${wanted_with_minor}..."
      nvm use "$wanted"
      __dko_status "install-latest-npm"
      nvm install-latest-npm
      __dko_ok "Node.js and npm updated, shell restart required"
    fi
  fi
}

# ----------------------------------------------------------------------------
# Node.js: Update NVM
# ----------------------------------------------------------------------------

__dko_dotfiles__node__update_nvm() {
  __dko_dotfiles__node__require_nvm || return 1

  (
    cd -- "$NVM_DIR" || exit 1

    __dko_status "Updating nvm"
    readonly previous_nvm="$(git describe --abbrev=0 --tags)"

    __dko_status_ "Found nvm ${previous_nvm}"
    { git checkout master && git pull --tags; } ||
      { __dko_err "Could not fetch" && exit 1; }
    readonly latest_nvm="$(git describe --abbrev=0 --tags)"
    # Already up to date
    [[ "$previous_nvm" == "$latest_nvm" ]] &&
      { __dko_ok "Already have nvm ${latest_nvm}" && exit 0; }

    __dko_status "Fast-forwarding to nvm ${latest_nvm}"
    git checkout --quiet --progress "$latest_nvm" ||
      { __dko_err "Could not fast-forward" && exit 1; }

    exit 0
  ) || return 1
}

# ----------------------------------------------------------------------------
# Python
# ----------------------------------------------------------------------------

__dko_dotfiles__py__update_pyenv() {
  if [[ -n "$PYENV_ROOT" ]] && [[ -d "${PYENV_ROOT}/.git" ]]; then
    __dko_status "Updating pyenv"
    (
      cd -- "${PYENV_ROOT}" || exit 1
      pyenv update
    ) || return 1
  else
    __dko_warn "pyenv was not installed using pyenv-installer"
  fi
}

# $1 pip command (e.g. `pip2`)
__dko_dotfiles__py__update_pip() {
  local pip_command=${1:-pip}
  __dko_status "Updating $pip_command"
  ! __dko_has "$pip_command" &&
    __dko_warn "${pip_command} not found" && return 1
  "$pip_command" install --upgrade setuptools || return 1
  "$pip_command" install --upgrade pip || return 1
  "$pip_command" install --upgrade \
    --requirement "${DOTFILES}/python/requirements.txt"
}

__dko_dotfiles__py__update_neovim_python() {
  ! __dko_has "pyenv" &&
    __dko_err "pyenv is not installed" && return 1

  __dko_status "Updating neovim3" &&
    pyenv activate neovim3 &&
    __dko_dotfiles__py__update_pip &&
    pip install --upgrade pynvim

  pyenv deactivate
}

# ----------------------------------------------------------------------------
# PHP
# ----------------------------------------------------------------------------

# pass any arg to silence
__dko_dotfiles__php__require_composer() {
  __dko_has "composer" && return 0
  __dko_warn "composer is not installed"
  return 1
}

__dko_dotfiles__php__update_composer() {
  __dko_status "Updating composer"
  __dko_dotfiles__php__require_composer || return 1

  if [[ -x "/usr/local/bin/composer" ]]; then
    __dko_ok "composer was installed via brew (yay)"
  else
    __dko_status_ "Updating composer itself"
    composer self-update || {
      __dko_err "Could not update composer"
      return 1
    }
  fi

  if [[ -f "$COMPOSER_HOME/composer.json" ]]; then
    __dko_status "Updating composer global packages"
    composer global update || {
      __dko_err "Could not update global packages"
      return 1
    }
  fi
}

# pass any arg to silence
__dko_dotfiles__php__require_phpcs() {
  __dko_has "phpcs" && return 0
  __dko_warn "phpcs is not installed. Install via composer global require"
  __dko_warn_ "and run again, or set installed_paths manually"
  return 1
}

__dko_dotfiles__php__update_wpcs() {
  readonly wpcs_repo="https://github.com/WordPress-Coding-Standards/WordPress-Coding-Standards.git"
  readonly sources_path="${HOME}/src"
  readonly wpcs_path="${sources_path}/wpcs"

  # --------------------------------------------------------------------------
  # Create and clone wpcs if not exists
  # --------------------------------------------------------------------------

  __dko_status "Updating wpcs"
  __dko_dotfiles__php__require_composer || return 1
  __dko_dotfiles__php__require_phpcs || return 1

  if [[ ! -d "$wpcs_path" ]]; then
    mkdir -p "${sources_path}"
    git clone -b master "$wpcs_repo" "$wpcs_path"
  else
    (
      cd -- "$wpcs_path" || exit 1
      git pull &&
        git log --no-merges --abbrev-commit --oneline ORIG_HEAD..
    ) || return 1
  fi

  # --------------------------------------------------------------------------
  # Determine installed standards
  # --------------------------------------------------------------------------

  __dko_status "Looking for standards"
  readonly possible=(
    "${COMPOSER_HOME}/vendor/squizlabs/php_codesniffer/CodeSniffer/Standards"
    "$wpcs_path"
  )
  local standards=()

  for entry in "${possible[@]}"; do
    [[ -d "$entry" ]] && echo "Found $entry" && standards+=("$entry")
  done
  standards_path=$(
    IFS=','
    echo "${standards[*]}"
  )

  # --------------------------------------------------------------------------
  # Update config
  # --------------------------------------------------------------------------

  __dko_status "Updating standards path to:"
  __dko_echo "${standards_path}"
  phpcs --config-set installed_paths "$standards_path"

  # List installed standards:
  phpcs -i
  phpcs --config-set default_standard PSR2
}

# ------------------------------------------------------------------------------
# OS-specific commands
# ------------------------------------------------------------------------------

__dko_dotfiles__linux__update() {
  case "$1" in
  arch) __dko_dotfiles__linux__arch__update ;;
  deb) __dko_dotfiles__linux__deb__update ;;
  *)
    __dko_dotfiles__command_not_found "$1"
    return 1
    ;;
  esac
}

__dko_dotfiles__darwin__update() {
  case "$1" in
  brew) __dko_dotfiles__darwin__update_brew ;;
  mac) __dko_dotfiles__darwin__update_mac ;;
  *)
    __dko_dotfiles__command_not_found "$1"
    return 1
    ;;
  esac
}

# ------------------------------------------------------------------------------
# OS: GNU/Linux: Arch Linux
# ------------------------------------------------------------------------------

__dko_dotfiles__linux__arch__update() {
  __dko_status "Arch Linux system update"
  if __dko_has "pacaur"; then
    # update system
    pacaur -Syu
  elif __dko_has "aura"; then
    aura -Syua
  else
    pacman -Syu
  fi
}

# ------------------------------------------------------------------------------
# OS: GNU/Linux: Debian or Ubuntu
# ------------------------------------------------------------------------------

__dko_dotfiles__linux__deb__update() {
  __dko_status "Apt system update"

  ! __dko_has "apt" &&
    __dko_err "apt not found, manually use 'apt-get' for crappy systems" &&
    return 1

  sudo apt update

  # This is for home systems only! Removes unused stuff, same as
  # `apt-get dist-upgrade`
  sudo apt full-upgrade
}

# ------------------------------------------------------------------------------
# OS: macOS/OS X
# ------------------------------------------------------------------------------

__dko_dotfiles__darwin__update_mac() {
  __dko_status "macOS system update"
  sudo softwareupdate --install --all

  __dko_status "xcode and cli update"
  sudo xcode-select --install

  __dko_has "mas" && mas upgrade
}

# pass any arg to silence
__dko_dotfiles__darwin__require_latest_xcode() {
  local latest_xcode="10.1"
  xcodebuild -version | grep -q "$latest_xcode" && return 0
  __dko_err "Using an outdated Xcode, please install/switch to latest version."
  return 1
}

# pass any arg to silence
__dko_dotfiles__darwin__require_brew() {
  __dko_has "brew" && return 0
  __dko_warn "Homebrew is not installed"
  return 1
}

__dko_dotfiles__darwin__update_brew() {
  __dko_dotfiles__darwin__require_latest_xcode || return 1
  __dko_dotfiles__darwin__require_brew || return 1

  __dko_status "Updating homebrew"
  (
    # CLEANROOM
    # enter dotfiles dir to do this in case user has any gem flags or local
    # vendor bundle that will cause use of local gems
    __dko_dotfiles__cd || exit 1
    __dko_dotfiles__pyenv_system
    # Brew some makefiles like macvim use tput for output so need to reset
    # from xterm-256color-italic I use in iterm
    TERM="xterm-256color"

    brew update

    # check if needed
    local outdated
    outdated="$(brew outdated --quiet)"

    [[ -z "$outdated" ]] && {
      __dko_ok "Packages up-to-date"
      exit
    }

    # Upgrade remaining
    __dko_status "Upgrading packages"
    brew upgrade
    __dko_dotfiles__darwin__update_brew_postupgrade "$outdated"
  ) && {
    __dko_status "Clean up old versions and prune dead symlinks"
    brew cleanup
    __dko_ok "All clean"
  }
}

__dko_dotfiles__darwin__update_brew_postupgrade() {
  __dko_status "Running post-upgrade packages"

  local outdated="$1"

  # link curl
  if grep -q "curl" <<<"$outdated"; then
    brew unlink curl && brew link --force curl
  fi

  # re-init goenv
  if grep -q "goenv" <<<"$outdated"; then
    goenv rehash
  fi

  # do not use zsh git completion, the bash one is better
  if grep -q "git" <<<"$outdated"; then
    "${DOTFILES}/bin/dko-fix-git-completion"
  fi

  # If imagemagick was outdated and php-imagick was not, force a reinstall
  # of php-imagick from source (using the new imagemagick)
  if grep -q "imagemagick" <<<"$outdated"; then
    readonly phpimagick="$(brew ls | grep 'php.*imagick')"
    if [[ -n "$phpimagick" ]]; then
      __dko_status "Rebuilding ${phpimagick} for new imagemagick"
      brew reinstall --build-from-source "$phpimagick"
    fi
  fi

  # Detect if brew's python3 (not pyenv) was outdated
  if grep -q "python3" <<<"$outdated"; then
    __dko_status "Python3 was outdated, upgrading python3"
    brew upgrade python3
  fi

  __dko_ok "Post-upgrade complete"
}

# ==============================================================================
# Main
# ==============================================================================

# $1 command
__dko_dotfiles() {
  local argcount="$#"
  [[ "$argcount" == "0" ]] && __dko_dotfiles__usage && return 1

  case $1 in
  dotfiles) __dko_dotfiles__update ;;
  secret) __dko_dotfiles__update_secret ;;
  daily) __dko_dotfiles__update_daily ;;
  composer) __dko_dotfiles__php__update_composer ;;
  fzf) __dko_dotfiles__update_fzf ;;
  gem) __dko_dotfiles__ruby__update_gems ;;
  go) __dko_dotfiles__go__update_go_packages ;;
  node) __dko_dotfiles__update_node "$2" ;;
  nvm) __dko_dotfiles__node__update_nvm ;;
  pip) __dko_dotfiles__py__update_pip "pip" ;;
  pyenv) __dko_dotfiles__py__update_pyenv ;;
  neopy) __dko_dotfiles__py__update_neovim_python ;;
  wpcs) __dko_dotfiles__php__update_wpcs ;;

  *)
    case "$OSTYPE" in
    linux*) __dko_dotfiles__linux__update "$@" ;;
    darwin*) __dko_dotfiles__darwin__update "$@" ;;
    esac
    ;;
  esac
}

__dko_dotfiles "$@"