hookit-common

#!/usr/bin/env bash
#
# hookit or not — git hook manager.
# https://github.com/neonnoon/hookit
#
# Here's the guts and stuff.

set -euo pipefail

# Allowed rc configs..
HOOKS_BASE_PATH=

# Optional rc file.
HOOKITRC=~/.hookitrc
[ -f $HOOKITRC ] && source $HOOKITRC

# Some global stuffs, config kinda thing..
AVAILABLE_HOOKS="applypatch-msg commit-msg fsmonitor-watchman post-update pre-applypatch pre-commit pre-push pre-rebase pre-receive prepare-commit-msg update post-checkout post-merge"
[ -n "$HOOKS_BASE_PATH" ] && HOOKBASE=$(cd $HOOKS_BASE_PATH && pwd) || HOOKBASE=$(echo ~/.hookit)

if [ ! -d $HOOKBASE ]; then
    mkdir -p $HOOKBASE
fi

printbyline() {
    prompt=$1 && shift
    input=$1 && shift
    cmd="$@"

    ceol=`tput el`
    tput rmam
    # 3>&2 2>&1 1>&3
    echo "$input" | $cmd | while IFS= read -r line; do
        printf "\r${ceol}"
        printf "$prompt > "
        printf "%s" "$line"
    done
    retcode=${PIPESTATUS[1]}
    printf "\r${ceol}"

    if [ $retcode != 0 ]; then
        printf "$prompt ✘\n"
    else
        printf "$prompt ✔\n"
    fi
    tput smam
    return $retcode
}

execprint() {
    prompt=$1 && shift
    input=$1 && shift
    command="$@"

    exec 3>&1
    retcode=0
    output=$( printbyline "$prompt" "$input" "$command" 2>&1 1>&3 | sed 's/^/  /'; exit ${PIPESTATUS[0]} ) || retcode=$?

    [ -z "$output" ] || echo "$output"
    return $retcode
}

hookit_mux() {
    local HOOKDIR="$1" && shift
    local HOOKNAME="$1" && shift

    if [ -d $HOOKDIR/$HOOKTYPE.d ]; then
        STDIN=$(cat /dev/stdin)

        for HOOKNAME in `gls --quoting-style=shell-escape $HOOKDIR/$HOOKTYPE.d`; do
            hookdisplay=
            POINTSTO=$(readlink .git/hooks/$HOOKTYPE.d/$HOOKNAME)
            if [[ $POINTSTO == $HOOKBASE/*/$HOOKTYPE/* ]]; then
                hookdisplay=${POINTSTO#"$HOOKBASE/"}
            else
                hookdisplay=$HOOKTYPE/$HOOKNAME
            fi

            if [ ! -e $HOOKDIR/$HOOKTYPE.d/$HOOKNAME ]; then
                echo "• $hookdisplay ✘" >&2
                echo "  missing hook"
                exit 1
            fi

            if [ ! -x $HOOKDIR/$HOOKTYPE.d/$HOOKNAME ]; then
                echo "• $hookdisplay ✘" >&2
                echo "  hook not executable"
                exit 1
            fi

            execprint "• $hookdisplay" "$STDIN" $HOOKDIR/$HOOKTYPE.d/$HOOKNAME "$@"
            EXITCODE=$?
            [ $EXITCODE != 0 ] && exit $EXITCODE
        done
    fi

    exit 0
}

hookit_install() {
    local LOCATION=$1

    (cd $HOOKBASE && git clone $LOCATION)
}

hookit_update() {
    local LOCATION=$1

    if [ "$LOCATION" == "all" ]; then
        for REPO in `gls --quoting-style=shell-escape $HOOKBASE`; do
            echo $REPO
            (cd $HOOKBASE/$REPO && git pull | sed 's/^/  /')
            echo
        done
    else
        if [ -d $HOOKBASE/$LOCATION ]; then
            echo $LOCATION
            (cd $HOOKBASE/$LOCATION && git pull | sed 's/^/  /')
        else
            die "No such repo: $LOCATION, install it first?"
        fi
    fi

}

enable_mux() {
    local HOOKTYPE=$1
    [ -e .git/hooks/$HOOKTYPE ] && die "Hook already exists!"
    ln -s $(which hookit-mux) .git/hooks/$HOOKTYPE
    mkdir -p .git/hooks/$HOOKTYPE.d
}

is_mux_enabled() {
    local HOOKTYPE=$1
    [ "$(readlink .git/hooks/$HOOKTYPE)" = "$(which hookit-mux)" ] && return 0
    return 1
}

hookit_find_available() {
    local query=$1 &&

    AVAILABLE_HOOKS=`_find_avaiable_hooks`
    if [ -n "$AVAILABLE_HOOKS" ]; then
        if [ -n "$query" ]; then
            MATCHING_HOOKS=`echo "$AVAILABLE_HOOKS" | egrep $query`
            if [ -n "$MATCHING_HOOKS" ]; then
                echo "Matching hooks:"
                echo "$MATCHING_HOOKS" | sed 's/^/  /'
            else
                echo "No matching hooks found."
            fi
        else
            echo "Available hooks:"
            echo "$AVAILABLE_HOOKS" | sed 's/^/  /'
        fi
    else
        echo "No available hooks."
    fi
}

_find_avaiable_hooks() {
    for PLUGIN in `gls --quoting-style=shell-escape $HOOKBASE`; do
        [ -d $HOOKBASE/$PLUGIN ] || continue

        for HOOKTYPE in $AVAILABLE_HOOKS; do
            if [ -d $HOOKBASE/$PLUGIN/$HOOKTYPE ]; then
                for HOOKNAME in `gls --quoting-style=shell-escape $HOOKBASE/$PLUGIN/$HOOKTYPE`; do
                    echo "$PLUGIN/$HOOKTYPE/$HOOKNAME"
                done
            fi
        done
    done
}

hookit_list_configured() {
    CONFIGURED_HOOKS=`_list_configured_hooks`
    if [ -n "$CONFIGURED_HOOKS" ]; then
        echo "Configured hooks:"
        echo "$CONFIGURED_HOOKS"
    else
        echo "No configured hooks."
    fi
}

_list_configured_hooks() {
    for HOOKTYPE in $AVAILABLE_HOOKS; do
        if [ -e .git/hooks/$HOOKTYPE ]; then
            if [ -L .git/hooks/$HOOKTYPE ] && is_mux_enabled $HOOKTYPE; then
                for HOOKNAME in `gls --quoting-style=shell-escape .git/hooks/$HOOKTYPE.d/`; do
                    if [ -L .git/hooks/$HOOKTYPE.d/$HOOKNAME ]; then
                        POINTSTO=$(readlink .git/hooks/$HOOKTYPE.d/$HOOKNAME)
                        if [[ $POINTSTO == $HOOKBASE/*/$HOOKTYPE/* ]]; then
                            if [ -f .git/hooks/$HOOKTYPE.d/$HOOKNAME ]; then
                                echo "  ${POINTSTO#"$HOOKBASE/"}"
                            else
                                echo "  ${POINTSTO#"$HOOKBASE/"} [orphaned]"
                            fi
                        else
                            echo "> $HOOKTYPE/$HOOKNAME -> $POINTSTO"
                        fi
                    else
                        echo "> $HOOKTYPE/$HOOKNAME"
                    fi
                done
            else
                echo "* $HOOKTYPE"
            fi
        fi
    done
}

hookit_remove() {
    local HOOK=$1
    local PLUGIN=$(dirname $(dirname $HOOK))
    local HOOKTYPE=$(basename $(dirname $HOOK))
    local HOOKNAME=$(basename $HOOK)

    # Make sure we get a valid hook type.
    if [ $HOOKTYPE = "." ]; then
        if [ -e .git/hooks/$HOOKNAME ]; then
            die "Refusing to delete main hook, run: mv .git/hooks/$HOOKNAME .git/hooks/$HOOKNAME.disabled"
        else
            die "Missing hook type."
        fi
    fi

    echo $AVAILABLE_HOOKS | fgrep -q $HOOKTYPE || die "Not a valid hook type"

    # Check if the target already exists?
    [ -e .git/hooks/$HOOKTYPE.d/$HOOKNAME -o -L .git/hooks/$HOOKTYPE.d/$HOOKNAME ] || die "Hook file doesn't exist!"

    if [ -L .git/hooks/$HOOKTYPE.d/$HOOKNAME ]; then
        POINTSTO=$(readlink .git/hooks/$HOOKTYPE.d/$HOOKNAME)
        if [[ $POINTSTO == $HOOKBASE/$PLUGIN/$HOOKTYPE/* ]]; then
            rm .git/hooks/$HOOKTYPE.d/$HOOKNAME
        else
            die "Refusing to delete non-standard hook, run: rm .git/hooks/$HOOKTYPE.d/$HOOKNAME"
        fi
    else
        die "Refusing to delete non-standard hook, run: rm .git/hooks/$HOOKTYPE.d/$HOOKNAME"
    fi
}

hookit_add() {
    local HOOK=$1
    local PLUGIN=$(dirname $(dirname $HOOK))
    local HOOKTYPE=$(basename $(dirname $HOOK))
    local HOOKNAME=$(basename $HOOK)

    # Make sure we get a valid hook type.
    [ $HOOKTYPE = "." ] && die "Missing hook type."
    echo $AVAILABLE_HOOKS | fgrep -q $HOOKTYPE || die "Not a valid hook type"

    # Check if the target already exists?
    [ -e .git/hooks/$HOOKTYPE.d/$HOOKNAME ] && die "Hook file already exists!"

    # Local, global or non-existent?
    [ -e $HOOKBASE/$PLUGIN/$HOOKTYPE/$HOOKNAME ] || die "Hook does not exist."

    # Check if we can or must enable mux?
    if [ -e .git/hooks/$HOOKTYPE ]; then
        [ -L .git/hooks/$HOOKTYPE ] && is_mux_enabled $HOOKTYPE || die "Base hook already exists!"
    else
        enable_mux $HOOKTYPE
    fi

    # Just fucking do it!
    ln -s $HOOKBASE/$PLUGIN/$HOOKTYPE/$HOOKNAME .git/hooks/$HOOKTYPE.d/$HOOKNAME
}