INSTALL

#!/usr/bin/env bash
#
# Dotfiles installer and uninstaller
#

# Set useful shell options.
set -Cueo pipefail

shopt -s extglob
shopt -s nullglob

warning () {
  if [[ -t 2 ]]; then
    local -r prefix='\033[33m'
    local -r suffix='\033[0m'
  else
    local -r prefix=
    local -r suffix=
  fi

  echo -e "${prefix}${*}${suffix}" >&2
}

error () {
  if [[ -t 2 ]]; then
    local -r prefix='\033[31m'
    local -r suffix='\033[0m'
  else
    local -r prefix=
    local -r suffix=
  fi

  echo -e "${prefix}${*}${suffix}" >&2
}

# Bare portable realpath.
::realpath () {
  if [[ -d "$1" ]]; then
    (cd -P "$1" && pwd)
  elif [[ "$1" != */* ]]; then
    local path
    path="$(pwd -P)"
    echo "$path/$1"
  elif [[ -h "$1" ]]; then
    readlink "$1"
  else
    local base="${1##*/}"
    local dir="${1%/*}"

    if [[ -d "$dir" ]]; then
      (cd -P "$dir" && echo "$PWD/$base")
    else
      error "::realpath: $1: No such file or directory"
    fi
  fi
}

parent="$(::realpath "${0%/*}")"
self="${0##*/}"

# Useful ln to create symlink. Pass basename contained destination path
# explicitly.
#
# Good.
# $ symln /path/to/conf ~/.conf
#
# Bad.
# $ symln /path/to/conf ~
symln () {
  local src="$1" dst="$2"

  if [[ -d "$dst" ]]; then
    error "It is a directory: '$dst'"
    return 1
  fi

  mkdir -p "${dst%/*}"

  ln -sv "$src" "$dst"
}

is_linux () {
  [[ "$OSTYPE" =~ ^linux ]]
}

is_macos () {
  [[ "$OSTYPE" =~ ^darwin ]]
}

has () {
  type "$1" &>/dev/null
}

has_commands () {
  local all=0

  for cmd; do
    if ! has "$cmd"; then
      error "'$cmd is not found on command line."
      all=1
    fi
  done

  return "$all"
}

if ! cd "$parent"; then
  error 'Fail to change directory to script parent.'
  exit 1
fi

help () {
  echo -e -n "\
Descriptions:
  Dotfiles installer and uninstaller with extra.

Usage:
  $self <SUBCOMMAND>

Subcommands:
  init         Initialize setup
  deploy       Deploy dotfiles
  undeploy     Remove deployed dotfiles
  rust         Install rust tool chain
  haskell      Install haskell tool chain
  lscolor      Install ls color config
  python-packages
               Install python packages with pip
  haskell-packages
               Install haskell packages with cabal
  ghq-binary   Install ghq binary from GitHub release
  zsh-config   Install zsh config
  tmux-config  Install tmux config
  vim-config   Install vim config
  xmonad-config
               Install xmonad config

Options:
  -h, --help   Show this messages and exit.
"
}

readonly bin_srcpath="${parent}/bin"
readonly bin_dstpath=~/bin
readonly config_srcpath="${parent}/.config"
readonly config_dstpath=~/.config
readonly home_config_srcpath="${parent}/home"
readonly home_config_dstpath=~

# List files in a directory which is specified as an argument. Each files are
# preceded by the directory path.
list_files () {
  local src="${1%%*(/)}"

  if [[ ! -d "$src" ]]; then
    warning "$src is not directory."
    return 1
  fi

  local GLOBIGNORE="$src/*~:$src/*.sw[a-z]"
  printf '%s\n' "$src"/*
}

# Make symbolik links from files in source directory to in destination
# directory.
links () {
  local -r src_dir="${1%%*(/)}"
  local -r dst_dir="${2%%*(/)}"

  # validations
  if [[ ! "$src_dir" =~ ^/ ]]; then
    error "Source directory is not absolute path '$src_dir'"
    return 1
  fi

  if [[ ! -d "$src_dir" ]]; then
    error "No such source directory '$src_dir'"
    return 1
  fi

  if [[ ! "$dst_dir" =~ ^/ ]]; then
    error "Destination directory is not absolute path '$dst_dir'"
    return 1
  fi

  if [[ ! -d "$dst_dir" ]]; then
    error "No such destination directory '$dst_dir'"
    return 1
  fi

  list_files "$src_dir" | while read -r -d $'\n' link_src; do
    local f_base="${link_src##*/}"
    local link_dst="${dst_dir}/${f_base}"

    if [[ -a "${link_dst}" ]]; then
      warning "Skip linking from ${link_src} to ${link_dst} because ${f_base} has already existed in ${dst_dir}."
    else
      command ln -sv "$link_src" "$link_dst"
    fi
  done
}

has_same_resolved_path () {
  local p1 p2
  p1="$(::realpath "$1")"
  p2="$(::realpath "$2")"

  [[ "$p1" == "$p2" ]]
}

# Remove symbolic links from destination directory.
unlinks () {
  local -r src_dir="${1%%*(/)}"
  local -r dst_dir="${2%%*(/)}"

  # validations
  if [[ ! "$src_dir" =~ ^/ ]]; then
    error "Source directory is not absolute path '$src_dir'"
    return 1
  fi

  if [[ ! -d "$src_dir" ]]; then
    error "No such source directory '$src_dir'"
    return 1
  fi

  if [[ ! "$dst_dir" =~ ^/ ]]; then
    error "Destination directory is not absolute path '$dst_dir'"
    return 1
  fi

  if [[ ! -d "$dst_dir" ]]; then
    error "No such destination directory '$dst_dir'"
    return 1
  fi

  list_files "$src_dir" | while read -r -d $'\n' link_src; do
    local f_base="${link_src##*/}"
    local link_dst="${dst_dir}/${f_base}"

    if [[ ! -h "$link_dst" ]]; then
      warning "Skip unlinking $link_dst because no such link."
      continue
    fi

    if ! has_same_resolved_path "$link_src" "$link_dst"; then
      warning "Skip unlinking $link_dst because the link is not under control of this repository."
      continue
    fi

    command unlink "$link_dst" && echo "unlink: $link_dst"
  done
}

deploy_bins () {
  links "$bin_srcpath" "$bin_dstpath"
}

deploy_configs () {
  links "$config_srcpath" "$config_dstpath"
}

deploy_home_configs () {
  links "$home_config_srcpath" "$home_config_dstpath"
}

undeploy_bins () {
  unlinks "$bin_srcpath" "$bin_dstpath"
}

undeploy_configs () {
  unlinks "$config_srcpath" "$config_dstpath"
}

undeploy_home_configs () {
  unlinks "$home_config_srcpath" "$home_config_dstpath"
}

deploy () {
  deploy_bins
  deploy_configs
  deploy_home_configs
}

undeploy () {
  undeploy_bins
  undeploy_configs
  undeploy_home_configs
}

init () {
  mkdir -vp \
    ~/bin \
    ~/.config \
    ~/.cache \
    ~/.local/share \
    ;
}

rust () {
  # https://rustup.rs/
  curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
}

haskell () {
  # https://www.haskell.org/ghcup/
  curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh
}

lscolor () {
  curl -sL https://raw.githubusercontent.com/trapd00r/LS_COLORS/master/LS_COLORS > ~/.dircolors
}

python-packages () {
  local -ar packages=(
    pipenv
    'python-language-server[all]'
    flake8
    ipdb
    tmuxp
    kaggle
    youtube-dl
    vim-vint
    # powerline-status
  )

  pip3 install --user "${packages[@]}"
}

haskell-packages () {
  cabal install --overwrite-policy=always ShellCheck

  cabal install --overwrite-policy=always --lib xmonad xmonad-contrib X11
  cabal install --overwrite-policy=always xmonad
  cabal install --overwrite-policy=always xmobar --flags="all_extensions"
}

install_ghq () {
  if ! has_commands curl bsdtar grep; then
    return 1
  fi

  local zipfile

  if is_linux; then
    zipfile='ghq_linux_amd64.zip'
  elif is_macos; then
    zipfile='ghq_darwin_amd64.zip'
  else
    error 'This OS is not neither Linux nor macOS, so no prebuild binary on GitHub release.'
    return 1
  fi

  # So bad looking but for compatibility until Bash v4.2. Wanna use lastpipe
  # option.
  local asset_url
  asset_url="$( \
    curl -L -H "Accept: application/vnd.github.v3+json" 'https://api.github.com/repos/x-motemen/ghq/releases/latest' \
      | grep -E -o "https://.*${zipfile}" \
  )"

  if [[ -z "$asset_url" ]]; then
    error 'The asset url is empty.'
    return 1
  fi

  if [[ ! -d ~/bin ]]; then
    warning 'No ~/bin directory exists, so create it to deploy ghq binary.'
    mkdir ~/bin
  fi

  curl -L "$asset_url" | bsdtar -x -f - --include '*/ghq' --strip-components 1 -C ~/bin

  if [[ ! -x ~/bin/ghq ]]; then
    chmod -v +x ~/bin/ghq
  fi
}

zsh-config () {
  local -r url='https://github.com/a5ob7r/zsh-config.git'

  if ! has_commands git; then
    return 1
  fi

  if has ghq; then
    ghq get "$url"
    local path
    path="$(ghq list --exact --full-path github.com/a5ob7r/zsh-config)"
    symln "${path}/.zshrc" ~/.zshrc
  else
    git clone "$url" ~/zsh-config
    symln ~/zsh-config/.zshrc ~/.zshrc
  fi
}

tmux-config () {
  local -r url='https://github.com/a5ob7r/tmux-config.git'

  if ! has_commands git; then
    return 1
  fi

  if has ghq; then
    ghq get "$url"
    local path
    path="$(ghq list --exact --full-path github.com/a5ob7r/tmux-config)"
    symln "${path}" ~/.config/tmux
  else
    git clone "$url" ~/tmux-config
    symln ~/tmux-config ~/.config/tmux
  fi
}

vim-config () {
  local -r url='https://github.com/a5ob7r/vim-config.git'

  if ! has_commands git; then
    return 1
  fi

  if has ghq; then
    ghq get "$url"
    local path
    path="$(ghq list --exact --full-path github.com/a5ob7r/vim-config)"
    symln "${path}" ~/.vim
  else
    git clone "$url" ~/vim-config
    symln ~/vim-config ~/.vim
  fi
}

xmonad-config () {
  local -r url='https://github.com/a5ob7r/xmonad-config.git'

  if ! has_commands git; then
    return 1
  fi

  if has ghq; then
    ghq get "$url"
    local path
    path="$(ghq list --exact --full-path github.com/a5ob7r/xmonad-config)"
    symln "${path}" ~/.xmonad
  else
    git clone "$url" ~/xmonad-config
    symln ~/xmonad-config ~/.xmonad
  fi
}

# main

# Argument array
declare -a args=()

# Parse arguments
while (( $# )); do
  case "$1" in
    --debug )
      set -x
      shift
      ;;
    -h | --help )
      help
      exit 0
      ;;
    -* )
      error "Invalid option '$1'"
      exit 1
      ;;
    * )
      args+=("$1")
      shift
      ;;
  esac
done

if ! (( ${#args[@]} )); then
  help
  exit 0
fi

case "${args[0]}" in
  init )
    init
    ;;
  deploy )
    deploy
    ;;
  undeploy )
    undeploy
    ;;
  rust )
    rust
    ;;
  haskell )
    haskell
    ;;
  lscolor )
    lscolor
    ;;
  python-packages )
    python-packages
    ;;
  haskell-packages )
    haskell-packages
    ;;
  ghq-binary )
    install_ghq
    ;;
  zsh-config )
    zsh-config
    ;;
  tmux-config )
    tmux-config
    ;;
  vim-config )
    vim-config
    ;;
  xmonad-config )
    xmonad-config
    ;;
  * )
    error "Invalid subcommand '${args[0]}'"
    exit 1
    ;;
esac