dots

#!/bin/sh
# File:        dots
# Author:      Zakhary Kaplan <https://zakhary.dev>
# Created:     05 Jun 2019
# Version:     0.1.0
# SPDX-License-Identifier: MIT
# Vim:         set ft=sh:

#
## Defines
#

# @env NAME      Name of invoked command
NAME="${0##*/}"
# @env VERSION   Version number of this script.
VERSION=0.1.0

# @env DOTS      Default dotfiles installation directory path.
DOTS="${DOTS:-$HOME/.dots}"
# @env REPO  Remote URL to dotfiles repository.
REPO="${REPO:-https://git.zakhary.dev/dotfiles}"

# @env GIT       Call git from the proper directory.
GIT="git -C ${DOTS}"
# @env MAKE      Run the associated Makefile.
MAKE="make -C ${DOTS}"

# @env LOG_FILE  Logging output file.
LOG_FILE="${LOG_FILE:-"${DOTS}/logs/dots.$(date +%s).log"}"
# @env LOG_LEVEL Filter for logging.
LOG_LEVEL="${LOG_LEVEL:-info}"
# @env NO_COLOR  Disable ANSI color escape codes.
NO_COLOR="${NO_COLOR}"


#
## Library
#

# Aliases

# @alias log -<e|w|i|d|t>
alias error="log -e"
alias warn="log -w"
alias info="log -i"
alias debug="log -d"
alias trace="log -t"


# Methods

#
# @desc  Display formatted log messages.
# @env   LOG_LEVEL "warn"
#
log() {
    # Parse opts
    local level=info
    local noeol=
    while getopts ":l:ewidtn" opt; do
        case ${opt} in
            l)
                level="${OPTARG}"
                ;;
            e)
                level=error
                ;;
            w)
                level=warn
                ;;
            i)
                level=info
                ;;
            d)
                level=debug
                ;;
            t)
                level=trace
                ;;
            n)
                noeol=1
                ;;
            \?)
                return
                ;;
        esac
    done
    shift $((OPTIND - 1))
    OPTIND=1 # XXX: cannot uneset in `dash`

    # Extract from env
    local filter=${LOG_LEVEL:-warn}

    # Define levels
    # shellcheck disable=2034
    local none=0
    # shellcheck disable=2034
    local error=1
    # shellcheck disable=2034
    local warn=2
    # shellcheck disable=2034
    local info=3
    # shellcheck disable=2034
    local debug=4
    # shellcheck disable=2034
    local trace=5
    # Indirect variable expansion
    local filterno levelno
    filterno="$(eval "echo \${${filter}}")"
    levelno="$(eval "echo \${${level}}")"
    # Check for misconfiguration
    if [ -z "${filterno}" ] || [ -z "${levelno}" ]; then
        return
    fi
    # Filter-out disabled messages
    if [ "${filterno}" -lt "${levelno}" ]; then
        return
    fi

    # Prepare ANSI color sequences
    local clear=
    local color=
    local style=
    if [ -z "${NO_COLOR}" ]; then
        clear=$(printf "\033[0m")
        case ${level} in
            error )
                color=$(printf "\033[31m")
                style=$(printf "\033[1m")
                ;;
            warn  )
                color=$(printf "\033[33m")
                ;;
            info  )
                color=$(printf "\033[32m")
                ;;
            debug )
                color=$(printf "\033[34m")
                ;;
            trace )
                color=$(printf "\033[35m")
                ;;
        esac
    fi
    # Check if EOL is needed
    local eol=
    if [ -z "${noeol}" ]; then
        eol="\n"
    fi

    # Display message
    printf "[%s] %s${eol}" "${color}${style}${level}${clear}" "${style}$*${clear}"
}

#
# @desc Exit early with a failure code and a message.
#
bail() {
    local code="$1"
    shift
    error "$*"
    exit "${code:-1}"
}

#
# @desc Exit early with a failure code.
#
cancel() {
    bail 1 "Operation cancelled."
}

#
# @desc Run and monitor a command, logging output and exiting on failure.
#
monitor() {
    # Execute monitored command, log output
    $@ >> "${LOG_FILE}" 2>&1
    # Extract status code
    local code=$?
    # Check for success
    if [ ${code} -eq 0 ]; then
        return  # no-op on success
    fi
    # Indicate failure
    error "Failed with exit code: ${code}"
    # Display last few lines of output
    tail -10 "${LOG_FILE}" | while read line; do warn "${line}"; done
    # Abort failed execution
    cancel
}


#
## Application
#

#
# @desc Print help.
#
usage() {
    cat 1>&2 <<EOF
${NAME} ${VERSION}
Zakhary's dotfiles manager

Usage: ${NAME} [OPTIONS] [COMMAND]

Commands:
  i, install    Perform standard installation.
  u, upgrade    Upgrade the current installation.

Options:
  -a            Run with animations enabled
  -c <WHEN>     Coloring: auto, always, never
  -x            Run in script mode (disables animations, color)
  -y            Disable confirmation prompt
  -l <LEVEL>    Logging: none, error, warn, info, debug, trace
  -q            Run quietly
  -v            Run verbosely
  -h            Print help
  -V            Print version
EOF
}

#
# @desc Print banner.
#
banner() {
    info 'Welcome to...                              '
    info '                                           '
    info ' /\/|  __   _       _    __ _ _            '
    info '|/\/  / /__| | ___ | |_ / _(_) | ___  ___  '
    info '     / // _` |/ _ \| __| |_| | |/ _ \/ __| '
    info '    / /| (_| | (_) | |_|  _| | |  __/\__ \ '
    info '   /_/(_)__,_|\___/ \__|_| |_|_|\___||___/ '
    info '                                           '
    info '                        by: Zakhary Kaplan '
    info
}

#
# @desc Executable body.
#
main() {
    # Declare config, set defaults
    local animate=
    local color=auto
    local proceed=
    local subcommand=

    # Parse opts
    while getopts ":ac:xyl:vqhV" opt; do
        case ${opt} in
            a)
                animate=1
                ;;
            c)
                color="${OPTARG}"
                ;;
            x)
                animate=
                color=never
                ;;
            y)
                proceed=yes
                ;;
            l)
                LOG_LEVEL="${OPTARG}"
                ;;
            v)
                LOG_LEVEL=trace
                ;;
            q)
                LOG_LEVEL=none
                animate=
                ;;
            h)
                usage
                exit
                ;;
            V)
                printf "%s\n" "${NAME} ${VERSION}"
                exit
                ;;
            \?)
                printf "%s: illegal option -- %c\n" "${NAME}" "${OPTARG}"
                printf "usage: %s [-cxylvqhV] [install|upgrade]\n" "${NAME}"
                exit 1
                ;;
            :)
                printf "%s: option requires an argument -- %c\n" "${NAME}" "${OPTARG}"
                printf "usage: %s [-cxylvqhV] [install|upgrade]\n" "${NAME}"
                exit 1
                ;;
        esac
    done
    shift $((OPTIND - 1))
    OPTIND=1 # XXX: cannot uneset in `dash`

    # Parse args
    if [ "$#" -le 1 ]; then
        # [SUBCOMMAND]
        [ -n "$1" ] && {
            subcommand="$1"
            shift
        }
    else
        printf "%s: extra arguments\n" "${NAME}"
        printf "usage: %s [-cxylvqhV] [install|upgrade]\n" "${NAME}"
        exit 1
    fi

    # Validate `color`
    case "${color}" in
        auto)
            [ ! -t 0 ] && NO_COLOR=1
            ;;
        always)
            NO_COLOR=
            ;;
        never)
            NO_COLOR=1
            ;;
        *)
            printf "%s: illegal argument -- %s\n" "${NAME}" "${color}"
            printf "usage: %s -c <auto|always|never>\n" "${NAME}"
            exit 1
            ;;
    esac

    # Validate `LOG_LEVEL`
    case "${LOG_LEVEL}" in
        none|error|warn)
            animate= # animations use `info` level
            ;;
        info|debug|trace)
            ;;
        *)
            printf "%s: illegal argument -- %s\n" "${NAME}" "${LOG_LEVEL}"
            printf "usage: %s -l <none|error|warn|info|debug|trace>\n" "${NAME}"
            exit 1
            ;;
    esac

    # Validate `subcommand`
    case "${subcommand}" in
        install|i)
            subcommand=install
            ;;
        upgrade|u)
            subcommand=upgrade
            ;;
        "")
            # Check if we're already installed, if so, then perform an upgrade
            [ -d "${DOTS}" ] && subcommand=upgrade || subcommand=install
            ;;
        *)
            printf "%s: illegal subcommand -- %s\n" "${NAME}" "${subcommand}"
            printf "usage: %s [-cxylvqhV] [install|upgrade]\n" "${NAME}"
            exit 1
            ;;
    esac

    # Display the banner for a few seconds with an animated countdown
    banner
    if [ -n "${animate}" ]; then
        local i=3; while [ $i -gt 0 ]; do
            info "Starting in $i..." "$(printf "\033[A")"
            sleep 1;
            i=$((i - 1))
        done
        printf "\033[2K\r"
    fi

    # Check dependencies
    debug "Checking dependencies..."
    dep_checkall || {
        # If dependencies not found, do not install
        error "Failed: missing dependencies."
        error "Please install missing dependencies and try again."
        error
        dep_logall -w
        warn
        [ "$(uname)" = "Darwin" ] && {
            info "NOTE: Homebrew could be used to satisfy all dependencies."
            info "      Follow the instructions at: https://brew.sh"
            info
        }
        cancel
    }
    dep_logall -t
    debug "Satisfied. May proceed."
    debug

    # Perform subcommand
    debug "Performing ${subcommand}."
    case "${subcommand}" in
        install)
            # Confirm installation
            warn "Installation will occur at: \`${DOTS}\`"
            [ -z "${proceed}" ] && warn -n && read -rp "Proceed with installation? [Y/n] " proceed
            case "${proceed}" in
                [Yy]*)
                    ;;
                "")
                    ;;
                *)
                    bail 0 "Installation cancelled by user."
                    ;;
            esac
            info

            # Download dotfiles
            info "Downloading..."
            if [ ! -d "${DOTS}" ]; then
                git clone "${REPO}" "${DOTS}"
            else
                warn "File already exists at path: \`${DOTS}\`"
                if ${GIT} rev-parse >/dev/null 2>&1; then
                    if [ "$(${GIT} remote get-url origin)" != "${REPO}" ]; then
                        error "Path contains a foreign git repository."
                        cancel
                    fi
                else
                    error "File is not a git directory."
                    cancel
                fi
                warn "Using existing installation."
            fi
            info "Downloaded. May proceed."
            info
            ;;
        upgrade)
            # Confirm upgrade
            [ -z "${proceed}" ] && info -n && read -rp "Proceed with upgrade? [Y/n] " proceed
            case "${proceed}" in
                [Yy]*)
                    ;;
                "")
                    ;;
                *)
                    bail 0 "Upgrade cancelled by user."
                    ;;
            esac
            info

            # Abort early if repo is dirty
            if [ -n "$(${GIT} status -s)" ]; then
                error "Dotfiles repo is dirty."
                cancel
            fi

            # Unstow dotfiles
            info "Unlinking installed files..."
            monitor ${MAKE} unstow
            info "Success."
            info

            # Update dotfiles repository
            info "Updating dotfiles..."
            # Pull updates
            monitor ${GIT} pull --rebase --recurse-submodules
            info "Success."
            info
            ;;
    esac

    # Run Makefile
    info "Running Makefile..."
    monitor ${MAKE} install
    info "Success."
    info

    # Complete installation
    info "Completed. Please use responsibly :)"
}


#
## Utilities
#

#
# @desc Check a single dependency.
#
dep_check() {
    test "$(command -v "$1")"
}

#
# @desc Check if minimal dependencies are installed.
#
dep_checkall() {
    {
        # Check if Homebrew is installed
        dep_check brew
    } || {
        # Check if individual dependencies are installed
        dep_check curl &&
        dep_check git  &&
        dep_check make &&
        dep_check stow &&
        dep_check zsh  &&
        return
    }
}

#
# @desc Print a single dependency.
#
dep_print() {
    printf "%s %s" "$(command -v "$1" >/dev/null 2>&1 && echo '✓' || echo '✗')" "$1"
}

#
# @desc Print all dependencies.
#
dep_logall() {
    log "$@" -- "Required:"
    log "$@" -- "  $(dep_print curl)"
    log "$@" -- "  $(dep_print git)"
    log "$@" -- "  $(dep_print make)"
    log "$@" -- "  $(dep_print stow)"
    log "$@" -- "  $(dep_print zsh)"
    log "$@" -- "Recommended:"
    log "$@" -- "  $(dep_print nvim)"
    log "$@" -- "  $(dep_print tmux)"
}


#
## Entrypoint
#

main "$@"