dotfiles/.local/bin/projectdo

#!/bin/sh

# projectdo – universal project commands.
# Copyright (C) 2019-present  Simon Friis Vindum

# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.

# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <https://www.gnu.org/licenses/>.

VERSION="0.2.0"

# Global mutable variables.
QUIET=false
DRY_RUN=false
PROJECT_ROOT="${PROJECT_ROOT:-}"
ACTION=""
TOOL_ARGS=""  # Arguments to pass along to the tool
IS_TOOL=false # True if ACTION is 'tool' as this action is somewhat special.

has_command() {
	command -v "$1" >/dev/null 2>&1
}

# When running the appropriate external tool this function is used which
# evaluates the given command while respecting $QUIET and $DRY_RUN.
execute() {
	if [ $QUIET = false ]; then
		echo "$1" $TOOL_ARGS
	fi
	if [ $DRY_RUN = false ]; then
		if [ $QUIET = false ]; then
			eval "$1" $TOOL_ARGS
		else
			eval "$1" $TOOL_ARGS >/dev/null
		fi
	fi
}

# Takes the name of a tool and an action. If the action is `tool` it is
# ignored. It handles the common case where the tool is invoked as `tool
# action`.
execute_command() {
	if [ "$2" = tool ]; then
		execute "$1"
	else
		execute "$1 $2"
	fi
	exit 0
}

# Every supported tool requires a function `try_tool` where `tool` is a name
# indicating what tool the function tries to detect. The function should:
#
# * Return if it does not detect that the tool is appropriate.
# * Read the variables `ACTION` and `IS_TOOL` to determine the correct action
#   to run.
# * When running an action is should use the `execute` function and _exit_ when
#   it is done.

# Start list of tools

# JavaScript + NodeJS

try_nodejs() {
	if [ ! -f package.json ]; then
		return 1
	fi
	if [ -f yarn.lock ]; then
		tool=yarn
	else
		tool=npm
	fi
	if ! has_command $tool; then
		echo "Found a package.json file but '$tool' is not installed."
		exit 1
	fi
	local node_action="$ACTION"
	# Only the "run" action need translation, the others match 1-to-1
	# if [ "$ACTION" = run ]; then
	# 	node_action=start
	# fi
	# We check if the package.json file contains an appropriate script. We use
	# grep for this. The check is not 100% bulletproof, but it's very close. We
	# could've used `npm run` to get the authorative list of the scripts but
	# invoking `npm` is two orders of magnitude slower which leads to a
	# noticeable delay.
	# if ! $IS_TOOL && ! grep -q "^[[:space:]]*\"${node_action}\":" package.json; then
	# 	return 0
	# fi
	execute_command "$tool" "$node_action"
}

# Rust + Cargo

try_cargo() {
	if [ -f Cargo.toml ]; then
		execute_command cargo "$ACTION"
	fi
}

# CMake

try_cmake() {
	if [ -f CMakeLists.txt ] && [ "$ACTION" = test ]; then
		if [ -f build ]; then
			execute "cmake --build build --target test"
		else
			execute "cmake --build . --target test"
		fi
		exit
	fi
}

# Haskell + Stack

try_stack() {
	if [ -f package.yaml ] && [ -f stack.yaml ]; then
		execute_command stack "$ACTION"
	fi
}

# Haskell + Cabal

try_cabal() {
	cabal_file="$(find ./ -maxdepth 1 -name "*.cabal" 2>/dev/null | wc -l)"
	if [ "$cabal_file" -gt 0 ] && [ ! -f stack.yml ]; then
		execute_command cabal "$ACTION"
	fi
}

# Maven

try_maven() {
	if [ -f pom.xml ]; then
		case $ACTION in
		build)
			execute "mvn compile"
			exit
			;;
		test)
			execute "mvn test"
			exit
			;;
		run)
			echo "projectdo does not know how to run a project with Maven."
			exit
			;;
		esac
	fi
}

# Clojure + Leiningen

try_lein() {
	if [ -f project.clj ] && [ "$ACTION" = test ]; then
		execute "lein test"
	fi
}

# Makefile

has_make_target() {
	target="${1?}"
	output=$(make -n "${target}" 2>&1)
	exit_code=$?
	if [ $exit_code -ne 0 ]; then
		return $exit_code
	fi

	# If there is a file with the name of the target we're looking for but no
	# actual target with that name, make will exit successfully with that
	# message. We need to consider that case as a "target not found". Note that
	# the way the target is quoted in the output (`test' vs 'test') can differ
	# across OSes so we only check a prefix up to the problematic quotes.
	if expr "$output" : "make: Nothing to be done for" 1>/dev/null; then
		return 1
	fi

	return 0
}

try_makefile() {
	if [ -f Makefile ]; then
		if ! has_command "make"; then
			echo "Found a Makefile but 'make' is not installed."
			exit 1
		fi
		if $IS_TOOL || [ "$ACTION" = build ]; then
			# For make "build" is the default action when running `make`
			execute "make"
			exit
		elif [ "$ACTION" = test ]; then
			# Let's see if the makefile contains a test or check target
			if has_make_target "test"; then
				execute "make test"
				exit
			elif has_make_target "check"; then
				execute "make check"
				exit
			fi
		fi
	fi
	return 1
}

# Python

try_python() {
	if [ -f pyproject.toml ]; then
		if grep -q -m 1 "^\[tool.poetry\]$" pyproject.toml; then
			case $ACTION in
			build)
				execute "poetry build"
				exit
				;;
			test)
				# TODO: There are other Python test frameworks, it would be nice to
				# detect and run the right one.
				execute "poetry run pytest"
				exit
				;;
			run)
				echo "projectdo does not know how to run a project with Poetry."
				exit
				;;
			esac
		else
			echo "Found a pyproject.toml file but projectdo is not sure how to run it."
			exit
		fi
		return 1
	fi
}

# Go

try_go() {
	if [ -f go.mod ] && [ "$ACTION" = test ]; then
		# We detect Makefiles before we detect Go, so here we know that the Go
		# project is _not_ tested by a Makefile.

		# Check if the project uses Mage. A magefile could in theory have any name,
		# but `magefile.go` seems to be the convention.
		if grep -q -m 1 '^func Check(' magefile.go; then
			execute "mage check"
			exit
		elif grep -q -m 1 '^func Test(' magefile.go; then
			execute "mage test"
			exit
		fi
		execute "go test"
		exit
	fi
}

# LaTeX

try_latex() {
	if [ -f Tectonic.toml ] && [ "$ACTION" = build ]; then
		execute "tectonic -X build"
		exit
	fi
}

# End of list of tools

detect_and_run() {
	try_nodejs
	try_cargo
	try_stack
	try_cabal
	try_cmake
	try_maven
	try_lein
	try_makefile
	try_python
	try_go
	try_latex
}

set_project_root() {
	if [ -n "$PROJECT_ROOT" ]; then
		return
	fi

	if has_command git; then
		# Find the root of the git repository if we're inside one. If we're in a
		# git submodule then the root of the outer git repo is used. If we're not
		# in a git repo the git command will not output anything and $PROJECT_ROOT
		# is set to the empty string which is fine.
		PROJECT_ROOT=$(git rev-parse --show-superproject-working-tree --show-toplevel 2>/dev/null | head -n 1)
	fi
}

nothing_found() {
	echo "No way to $ACTION found :'("
	exit 1
}

display_version() {
	echo "$(basename "$0") version $VERSION"
}

display_help() {
	echo "Usage: $(basename "$0") [options] [action] [tool-arguments]
Options:
  -h, --help             Display this help.
  -n, -d, --dry-run      Do not execute any commands with side-effects.
  -q, --quiet            Do not print commands as they are about to be executed.
  -v, --version          Display the version of the program (which is $VERSION).

Actions:
  build, run, test       Build, run, or test the current project.
  tool                   Invoke the guessed tool for the current project.

Tool arguments:
  Any arguments following [action] are passed along to the invoked tool."
}

# Main execution starts here

while getopts dhnqv-: c; do
	case $c in
	d) DRY_RUN=true ;;
	h)
		display_help
		exit 0
		;;
	n) DRY_RUN=true ;;
	q) QUIET=true ;;
	v)
		display_version
		exit 0
		;;
	-) case $OPTARG in
		help)
			display_help
			exit 0
			;;
		dry-run) DRY_RUN=true ;;
		quiet) QUIET=true ;;
		version)
			display_version
			exit 0
			;;
		'') break ;; # "--" should terminate argument processing
		*)
			echo "Illegal option --$OPTARG" >&2
			exit 1
			;;
		esac ;;
	\?) exit 1 ;;
	esac
done

shift $((OPTIND - 1)) # Shift away the parsed option arguments

if [ "$1" = test ] ||
	[ "$1" = run ] ||
	[ "$1" = build ] ||
	[ "$1" = tool ]; then
	ACTION=$1
	if [ "$1" = tool ]; then
		IS_TOOL=true
	fi
	shift 1 # Remove the action from the arguments
	TOOL_ARGS=$@
else
	if [ -z "$1" ]; then
		echo "No action specified."
	else
		echo "$1 is not a valid action."
	fi
	echo ""
	echo "The valid actions are: build, run, test, tool"
	echo ""
	echo "Example: projectdo test"
	exit 1
fi

set_project_root

while :; do
	# We don't want to do anything if we are in the home or root directory
	if [ "$PWD" = "$HOME" ] || [ "$PWD" = / ]; then
		nothing_found
	fi
	detect_and_run
	# If we didn't detect a tool to run in this directory we go up one directory
	# while ensuring that we don't leave the project root
	if [ "$PWD" = "$PROJECT_ROOT" ]; then
		nothing_found
	fi
	cd ..
done