direnvrc

#!/usr/bin/env sh
set -eo pipefail

# This is the directory where all the recipes and ingredients are stored.
# By default, it is an empty string.
# If you want to use a different path, then override the default value with
# and absolute path name pointing to a direnv.d/ directory
CUPBOARD=""

# This is the directory where all the temporary locks are stored.
# By default, it is an empty string.
# If you want to use a different path, then override the default value with
# an absolute path name pointing to a directory writeable by $USER.
LOCKER_ROOM=""

# @FUNCTION: project
# @USAGE: project <name>
#
# @DESCRIPTION:
# This function expands the supplied <name> to the environment variable PROJECT.
#
# Example:
#    $ cat ~/my/project/.envrc
#    project darkstar
#
#    $ direnv allow ~/my/project/.envrc
#    direnv: loading ~/.direnvrc
#    direnv: loading .envrc
#    direnv: export +PROJECT
#
#    $ env | grep PROJECT
#    PROJECT=darkstar
function project() {
	local name="${1:-isempty}"

	# Exit if the project name is empty
	if [[ "isempty" == ${name##*/} ]]; then
		log_error "You must supply a valid project name when invoking project()!"
		exit 1
	fi

	# Export PROJECT
	export PROJECT="${name}"
	log_status "setting project: ${name##*/}"
}


# @FUNCTION: concoct
# @USAGE: concoct <recipe>
#
# @DESCRIPTION:
# This function loads the supplied <recipe>.
function concoct() {

	# Determine the location of the direnv.d directory
	if [[ -z $( echo ${CUPBOARD} ) ]]; then
		local direnvrc="$HOME/.direnvrc"
		if [[ ! -L ${direnvrc} ]]; then
			log_error "${direnvrc} is not a symbolic link!"
			log_error "this Direnv recipe has not been installed by 'bestow'."
			log_error "sorry, I cannot continue. Please, ask upstream for feedbacks:"
			log_error "-  https://github.com/Dr-Terrible/dotfiles-direnv"
			exit 1
		fi

		CUPBOARD="$( readlink ${direnvrc} )"
		CUPBOARD="$( dirname ${CUPBOARD} )/direnv.d"
	fi

	local cmd="${1}"

	# Exit if the recipe name is empty
	if [[ -z $( echo ${cmd} ) ]]; then
		log_error "You must supply a valid recipe name when invoking concoct()!"
		exit 1
	fi

	local recipe="${CUPBOARD}/recipes/${1}.direnv"

	# If the recipe isn't readable, then exit
	if [[ ! -r ${recipe} ]]; then
		log_error "Unable to read recipe: ${cmd}!"
		exit 1
	fi

	# Load the required recipe from direnv.d directory and guard it with
	# a lock to avoid conflicting executions of the same commands.
	shift
	log_status "checking ${cmd}"
	_include "${recipe}" "$@"
}


# @FUNCTION: require
# @USAGE: require <food container> <ingredient>
#
# @DESCRIPTION:
# This function loads an <ingredient> from a specific <food container>. If the
# <food container>, or the <ingredient>, doesn't exist, the function returns
# an error. This helper function is supposed to be used by recipes only.
#
# NOTE: Works like Direnv's use() function, except that the required external
# dependencies must be installed to allow Direnv to complete the set up of
# the environment.
function require() {
	local container="${1:-empty}"
	local cmd="${2:-empty}"
	local ingredient="${CUPBOARD}/ingredients/${container}/${cmd}.direnv"

	# Load the required ingredient from direnv.d directory, and guard it
	# with a lock to avoid conflicting executions of the same commands.
	if [[ ! -r ${ingredient} ]]; then
		log_error "Unable to find ingredient: ${cmd}!"
		log_error "No such file or directory: ${ingredient}"
		exit 1
	fi
	_include "${ingredient}"

	# Detect the presence of the specified command
	if ! has ${cmd}; then
		log_error "Unable to find command: ${cmd}!"
		exit 1
	fi

	shift
	shift
	local DIRENV_LOG_FORMAT="   ---> %s"
	usepkg ${cmd} "$@"
}


# Usage: log_status_nonewline [<message> ...]
#
# Logs a status message without the trailing newline char.
# Acts like echo, but wraps output in the standard direnv log format
# (controlled by $DIRENV_LOG_FORMAT), and directs it to stderr
# rather than stdout.
#
# Example:
#
#    log_status_nonewline "Loading ..."
#
function log_status_nonewline() {
	if [[ -n $DIRENV_LOG_FORMAT ]]; then
		local msg=$*
		# shellcheck disable=SC2059
		printf "${DIRENV_LOG_FORMAT}" "$msg" >&2
	fi
}


# Usage: usepkg <program_name> [<version>]
#
# A semantic command dispatcher intended for loading external dependencies into
# the environment.
#
# Example:
#
#    use_go() {
#      local version="$( go version | cut -d ' ' -f 3 )"
#      printf "${version//go/v}\n"
#    }
#    usepkg go
#    # output: go v1.9
#
function usepkg() {
	local cmd=$1
	log_status_nonewline "found $* "
	shift
	"use_$cmd" "$@"
	printf "\n"
}


# @FUNCTION:
# @USAGE: make_dir <directory> ... <directoryN>
#
# @DESCRIPTION:
# This helper function creates the given directories,
# if they do not already exist.
function make_dir() {
	for dir in $@; do
		[[ -d ${dir} ]] && continue
		mkdir -p ${dir}
		printf "   >>>> created: ${dir//${PWD}\//}/ \n"
	done
}


# @FUNCTION:
# @USAGE: make_tmpfs <directory>
#
# @DESCRIPTION:
# This helper function creates a temporary directory that won't clash with other
# running envrc processes, and avoids race conditions if possible.
function make_tmpfs() {
	for dir in $@; do
		[[ -d ${dir} ]] && continue
		# TODO: find a way to execute the mount without requiring root privileges.
		#       possibly, try to use systemd services for mounting points.
		#       for now we use symlinks to /tmp
		#mount -t tmpfs none ${dir} -o 'rw,nosuid,nodev,noexec,noauto,nouser,owner,lazytime,async'

		# Make sure $PROJECT exists
		if [ -z $( echo "${PROJECT}" ) ]; then
			log_error "Environment variable \$PROJECT is missing"
			return -1
		fi

		# Make sure mktemp is available.
		if ! command -pv mktemp >/dev/null ; then
			log_error "Command 'mktemp' not found"
			return -1
		fi

		# Make sure /tmp is writeable.
		# TODO: /tmp is not cross-platform, and TMPDIR is a bash-isms (overwritten
		#       by os-project); we should rely on something else.
		if [ ! -w "/tmp" ]; then
			log_error "/tmp is not writeable"
			return -1
		fi

		# Create the directory which will contain the template for mktemp.
		local template="envrc-${USER}"
		mkdir -p "/tmp/${template}"

		# Create the temporary directory and symlink it into the local project.
		local tempdir=$( mktemp --suffix="-${dir//${PWD}\//}" -d "/tmp/${template}/${PROJECT}-XXXXXXXX" )
		ln -sf "${tempdir}" "${dir//${PWD}\//}"
		printf "   >>>> mounted ${dir//${PWD}\//} -> ${tempdir} \n"
	done
}


# @FUNCTION: _include
# @USAGE: _include <file>
# @INTERNAL
#
# @DESCRIPTION:
# This helper function will read commands from <file> and execute them in the
# current shell environment.
#
# It's a thin wrapper around shell built-in command ".", with the addiction of
# a file locking mechanism to prevent concurrent execution of the entire
# content of the given <file>.
#
# Beware, the locking mechanism has a time-out of 60 seconds, after which the
# lock is released; this is necessary to avoid to stall infinitely in case the
# commands from <file> got stuck due to undefined behaviours.
#
# NOTE: By default, the locks are stored in "${XDG_RUNTIME_DIR}/direnv", but
# if the XDG environment variables are not available then it will fall back
# to "/tmp/direnv-$USER".
function _include() {
	local file="${1}"

	# Determine the location of the directory for storing the locks
	if [[ -z $( echo "${LOCKER_ROOM}" ) ]]; then

		# Try to determine a decent runtime path exclusive for the current user.
		local runtime
		if [[ -n "${XDG_RUNTIME_DIR}" ]]; then
			runtime="${XDG_RUNTIME_DIR}/direnv/"
		else
			runtime="/tmp/direnv-$USER"
		fi

		LOCKER_ROOM="${runtime}/.locks/"
	fi

	# Prepare the lock
	local lock_file="${file##*/}"
	local lock_dir="${file//${lock_file}/}"
	lock_dir="${LOCKER_ROOM}/$( basename ${lock_dir} )"
	[ ! -d "${lock_dir}" ] && mkdir -p "${lock_dir}"

	# Load the required <file> and guard it with a lock.
	# NOTE: subsequent invocations of the same <file> from different shell
	#       sessions will queue up, creating a queue of processes.
	exec 200>"${lock_dir}"/${lock_file}.lock
	flock -w 60 -x 200

		shift
		. "${file}" "$@"

	flock -u 200 # unlocking
}