subcmd

#!/usr/bin/env bash
set -eu

if [[ $# -eq 0 ]] ; then
    entryPoint=help
else
    entryPoint=$1
    shift;
fi
cliArgs=$@

function helpForCmd() {
    cat <<EOF
subcmd

Convert directory tree of executables into CLI sub-commands. 

subcmd entryPath [sub commands]     # eval mode
subcmd init entryPath [cmdTree]     # init mode

eval mode - Evaluates a pre-existing subcmd entry point. The
arguments are evaluated in the cmd tree until an executable
is found. At which point that executable is invoked by the
shell with any unconsumed arguments passed in. Most times you
won't use this directly, just set the entrypoint's shebang:

    #!/usr/bin/env subcmd

init mode - Creates a new subcmd entrypoint and an empty
directory for the cmd tree. If no cmdTree is specified the default
companion directory will be used.

EOF
    >&2
    exit 1
}

function initTree() {
    if [[ $# -eq 0 ]] ; then
        helpForCmd
        exit 1
    fi
    
    local entryPath=$1
    if isHelpCmd "$entryPath" ; then
	helpForCmd
    fi
    
    local cmdTree=$entryPath-subcmd
    local specTree=""
    if [[ $# -ge 2 ]] ; then
	local cmdTree=$2
	local specTree=$cmdTree
    fi
    
    assertFreshInit "$entryPath" "$cmdTree"
    createFresh "$entryPath" "$cmdTree" "$specTree"
}

function assertFreshInit() {
    local entryPath=$1
    local cmdTree=$2
    if [[ -e "$entryPath" ]] ; then
	echo "subcmd Error: Cannot init - entryPath already exists:" \
	     "$entryPath" >&2
	exit 1
    elif [[ -e "$cmdTree" ]] ; then
	echo "subcmd Error: Cannot init - cmdTree already exists:" \
	     "$cmdTree" >&2
	exit 1
    fi
}

function createFresh() {
    local entryPath=$1
    local cmdTree=$2
    local specTree=$3
    formEntryContent "$specTree" > "$entryPath"
    chmod a+rx "$entryPath"
    mkdir "$cmdTree"
    declareInit "$entryPath" "$cmdTree" >&2
}

function formEntryContent() {
    echo "#!/usr/bin/env subcmd"
    echo
    if [[ $# -ge 1 ]] ; then
	echo "$1"
    fi
}

function declareInit() {
    local entryPath=$1
    local cmdTree=$2
    echo "New subcmd tree initialized."
    echo
    echo "To create sub-commands add executables to the cmdTree:"
    echo $(formatExecView "$cmdTree/")
    echo
    echo "Command can be invoked by calling the entrypoint at: "
    echo $(formatExecView "$entryPath")
    echo
}

function formatExecView() {
    local entryPath=$1
    if isAbsPath "$entryPath" ; then
	echo "$entryPath"
    else
	echo "./$entryPath"
    fi
}

function discoverTree() {
    local treeSpec=$(scanTreeSpec)
    if [[ -z "$treeSpec" ]] ; then
	companionTree "$entryPoint"
    else
	resolveSpec "$entryPoint" "$treeSpec"
    fi
}

function scanTreeSpec() {
    cat "$entryPoint" \
	| grep -E -v "^#" \
	| grep -E -v "^$" \
	| tail -n 1
}

function companionTree() {
    local entryPoint=$1
    local companionTree=$(formCompanion "$entryPoint")
    assertCompanion "$companionTree"
    echo "$companionTree"
}

function assertCompanion() {
    local companionTree=$1
    if [[ ! -d "$companionTree" ]] ; then
	echo "subcmd Error: No dir-tree specified and companion directory" \
	     "does not exist:" "$companionTree" >&2
	exit 1
    fi
    
}

function formCompanion() {
    local entryPoint=$1
    local canonEntry=$(readlink -f "$entryPoint")
    echo $(dirname "$canonEntry")/$(basename "$canonEntry")-subcmd/
}


function resolveSpec() {
    local entryPoint=$1
    local treeSpec=$2
    local treePath=$(locateTreePath "$entryPoint" "$treeSpec")
    assertSpec "$treePath"
    echo "$treePath"
}

function locateTreePath() {
    local entryPoint=$1
    local treeSpec=$2
    if isAbsPath "$treeSpec" ; then
	echo "$treeSpec"
    else
	relatePathFrom "$entryPoint" "$treeSpec"
    fi
}

function isAbsPath() {
    local entryPoint=$1
    (echo "$entryPoint" | grep -E -q "^[/~]")
}

function relatePathFrom() {
    local entryPoint=$1
    local treeSpec=$2
    local canonEntry=$(readlink -f "$entryPoint")
    local rootDir=$(dirname "$canonEntry")
    echo "$rootDir/$treeSpec"
}

function assertSpec() {
    local treePath=$1
    if [[ ! -d $treePath ]] ; then
	echo "subcmd Error: User specified dir-tree path does not exist:" \
	     "$treePath" >&2
	exit 1
    fi
}

function isHelpCmd() {
    local subCmd=$1
    listHelpWords | grep -E -q "^$subCmd$"
}

function listHelpWords() {
    cat <<EOF
--help
--Help
help
Help
HELP
-h
-H
--h
--H
-help
-Help
EOF
}

function isCmdLister() {
    local subCmd=$1
    listCmdWords | grep -E -q "^$subCmd$"
}

function listCmdWords() {
    cat <<EOF
cmds
Cmds
CMDS
-cmds
-Cmds
-CMDS
--cmds
--Cmds
--CMDS
CMD
-cmd
-Cmd
-CMD
--cmd
--Cmd
--CMD
EOF
}

function yellForHelp() {
    local descentDir=$1
    if ! attemptHelp "$descentDir" ; then
	echo "subcmd Error: No Help file found at $descentDir" >&2
	exit 1
    fi
}

function attemptHelp() {
    local descentDir=$1
    if [[ -f "$descentDir/help" ]] ; then
	helpWithStream "$descentDir" <("$descentDir"/help $cliArgs)
    elif [[ -f $descentDir/help.txt ]] ; then
	helpWithStream "$descentDir" "$descentDir/help.txt"
    else
	bestEffortNoHelp "$descentDir"
	return 1
    fi
}

function helpWithStream() {
    local descentDir=$1
    local helpStream=$2
    local cmdName=$(basename "$descentDir")
    headerHelp "$cmdName" "$helpStream"  >&2
}

function bestEffortNoHelp() {
    local descentDir=$1
    local cmdName=$(basename "$descentDir")
    listSubCmds "$descentDir" "$cmdName" >&2
}

function headerHelp() {
    local cmdName=$1
    local helpPath=$2
    echo "------ Command Help: $cmdName -------"
    cat "$helpPath"
}

function helpSubCmds() {
    local descentDir=$1
    local cmdName=$(basename "$descentDir")
    listSubCmds "$descentDir" "$cmdName" >&2
}

function listSubCmds()  {
    local descentDir=$1
    local cmdName=$2
    echo "------ Valid Sub-Commands for $cmdName -----"
    echo
    findSubCmds "$descentDir"
    echo
    echo "--------------------------------------------"
}

function findSubCmds() {
    local descentDir=$1
    shopt -s nullglob
    for subPath in "$descentDir"/* ; do
	if [[ -x "$subPath" || -d "$subPath" ]] ; then
	    basename "$subPath"
	fi
    done
}

function failNonExec() {
    failWithReason "$1" "$2" "is not executable"
}

function failBrokenLink() {
    failWithReason "$1" "$2" "is a broken link"
}

function failMissing() {
    failWithReason "$1" "$2" "does not exist"
}

function failDanglingDir() {
    failWithReason "$1" "" "is a directory"
}

function failWithReason() {
    local baseDir=$1
    local tryCmd=$2
    local reason=$3
    echo "subcmd Error: $baseDir/$tryCmd $reason" >&2
    attemptHelp "$baseDir"
    exit 1
}

function sourceTreeEnv() {
    local descentDir=$1
    envPath="$descentDir/env.sh"
    if [[ -e "$envPath" && ! -x "$envPath" ]] ; then
        . $envPath
    fi
}

## help mode for subcmd itself
if isHelpCmd "$entryPoint" ; then
    helpForCmd
fi

## init mode - prepare a new subcmd tree
if [[ "$entryPoint" == "init" ]] ; then
    initTree "$@"
    exit 0
fi

## Standard eval mode - called from shebang line
cmdTree=$(discoverTree)
descent=$cmdTree

while [[ $# -gt 0 ]] ; do
    sourceTreeEnv "$descent"

    if isHelpCmd "$1" ; then
	yellForHelp "$descent"
	exit 0

    elif isCmdLister "$1" ; then
	helpSubCmds "$descent"
	exit 0
	
    elif [[ -d "$descent/$1" ]] ; then
	descent="$descent/$1"
	shift
	
    elif [[ -x "$descent/$1" ]] ; then
	executor="$descent/$1"
	shift
	$executor "$@"
	exit 0
	
    elif [[ -e "$descent/$1" ]] ; then
	failNonExec "$descent" "$1"
	
    elif [[ -L "$descent/$1" ]] ; then
	failBrokenLink "$descent" "$1"
	
    else
	failMissing "$descent" "$1"
    fi
done

failDanglingDir "$descent"