local -a -r files="$@"

for file in "${files[@]}"; do

watch_file "${file}"

done

local -r toolset="$1"; shift

# This is where we'll store generated files. Operations in this directory

# have to be performed with concurrent access in mind.

local -r cache_dir="${XDG_CACHE_HOME:-${HOME}/.cache}/${toolset}/direnv"

mkdir -p "${cache_dir}" || {

if (( ! ${DIRENV_IN_ENVRC:-0} )); then

DIRENV_LOG_FORMAT="direnv: ${FUNCNAME[0]}: %s" log_error \

"${cache_dir}: Unable to create directory."

else

printf '%s: %s: %s' "${FUNCNAME[0]}" "${cache_dir}" \

'Unable to create directory.' >&2

fi

return 1

}

echo "${cache_dir}"

local -r toolset="$1"; shift

local -r file_name="$1"; shift

local -r target_dir="$1"; shift

local input_file

if (( $# )); then

input_file="$1"; shift

fi

local cache_dir

cache_dir="$(command_wrapper_cache_dir "${toolset}")"

# Command `toolset config --dhall-freeze` writes its output atomically,

# But we need to put content hash into the name of the result, hence

# the temporary file.

local file_tmp

file_tmp="$(

)" || {

log_error 'Unable to create temporary file.'

return 1

}

# Usage:

#

# config [ARGUMENT [...]]

function config() {

"${toolset}" --no-aliases config "$@"

}

# Following file reads standard input, i.e. the whole

# `command_wrapper_dhall_cache` reads standard input.

#

# Be aware that on some files this may take a while.

config --dhall-freeze --no-remote-only --for-security \

${input_file:+--input="${input_file}"} --output="${file_tmp}"

# We hash the content as text to take into account that we may have

# gotten the content through a different route (file path / URL)

# even if it normalises to the same content. Normally it wouldn't

# be a problem to use Dhall semantic hash of its resulting

# expression, but if cache gets deleted or if it's explicitly

# ignored then we may end up trying to import non-existing path.

file_hash="$(config --dhall-hash --expression="${file_tmp} as Text")"

file_hash="${file_hash#sha256:}"

file="${cache_dir}/${file_name}-${file_hash}.dhall"

# Both ${file_tmp} and ${file} need to be in the same directory for

# this operation to be atomic on sensible file systems.

mv -f "${file_tmp}" "${file}"

ln -f -s "${file}" "${target_dir}/${file_name}" || {

log_error \

"${target_dir}/${file_name}: Failed to create symbolic link."

return 1

}

if (( ${DEBUG_COMMAND_WRAPPER_DIRENV:-0} )); then

set -x

: "${BASH_VERSION}"

fi

local DIRENV_LOG_FORMAT="direnv: ${FUNCNAME[0]}: %s"

if (( ! ${DIRENV_IN_ENVRC:-0} )); then

# Function log_error may not be available since it is provided by

# Direnv's stdlib.

log_error "This function is intended to be evaluated inside '.envrc'." \

|| printf '%s: %s' "${FUNCNAME[0]}" \

"This function is intended to be evaluated inside '.envrc'." >&2

return 1

fi

local -r toolset="$1"; shift

local -r config_dir_param="$1"; shift

if ! command -v "${toolset}" &>/dev/null; then

log_error "'${toolset}': Not in PATH, has it been installed?"

return 1

fi

# Usage:

#

# toolset [ARGUMENT [...]]

function toolset() {

"${toolset}" --no-aliases "$@"

}

# Let's make sure that the config dir exists and get an absolute path.

# This is one of the few ways how to do this reliably on MacOS and Linux.

local config_dir

config_dir="$(cd "${config_dir_param}" &>/dev/null && pwd)" || {

log_error \

"'${config_dir_param}': Directory does not exist or is not a directory."

return 1

}

local cache_dir

cache_dir="$(command_wrapper_cache_dir "${toolset}")"

# {{{ Convenient Imports ##################################################

#

# Convenient ways of importyng Command Wrapper Dhall libraries and

# Dhall Prelude. One way is via environment variable and the second one is

# via file in "${config_dir}/lib/${lib_name}".

#

# Environment variables may have already been exported by e.g. `nix-shell`.

# In such case they will probably contain absolute path to a file generated

# when instantiating Command Wrappper toolset derivation.

declare -A lib_environment_variables=(

['COMMAND_WRAPPER_LIB']='command-wrapper:CommandWrapper'

['COMMAND_WRAPPER_EXEC_LIB']='exec:Exec'

['COMMAND_WRAPPER_PRELUDE_LIB']='prelude:Prelude'

)

local lib_import

local lib_hash

local lib_name

local lib_file_name

local lib_file

local lib_file_tmp

mkdir -p "${config_dir}/lib"

for var in "${!lib_environment_variables[@]}"; do

lib_name="${lib_environment_variables[${var}]%%:*}"

lib_file_name="${lib_environment_variables[${var}]#*:}"

lib_import="${!var:-}"

if [[ -z "${lib_import:-}" ]]; then

lib_import="$(

export "${var}=${lib_import}"

fi

# Value of ${lib_import} is general Dhall expression, not a file name.

# We need to pass it via stdin to `command_wrapper_dhall_cache`.

command_wrapper_dhall_cache "${toolset}" "${lib_file_name}" \

"${config_dir}/lib" <<< "${lib_import}"

done

# }}} Convenient Imports ##################################################

# {{{ Shell Completion ####################################################

# Completion is toolset-specific. For that reason we need to include

# toolset name in the einvironment variable we want to generate.

#

# The resulting value doesn't need to be nice, but it needs to be

# predictable and consistent with other environment variable names.

local env_var_prefix="${toolset^^*}"

env_var_prefix="${env_var_prefix//[^a-zA-Z0-9_]/_}"

declare -A completion_environment_variables=(

["${env_var_prefix}_BASH_COMPLETION"]='bash'

["${env_var_prefix}_FISH_COMPLETION"]='fish'

["${env_var_prefix}_ZSH_COMPLETION"]='zsh'

)

local completion_file

local completion_file_tmp

local completion_file_hash

local completion_shell

for var in "${!completion_environment_variables[@]}"; do

completion_file="${!var:-}"

completion_shell="${completion_environment_variables[${var}]}"

if [[ -z "${completion_file:-}" || ! -r "${completion_file:-}" ]]; then

local completion_file_tmp

completion_file_tmp="$(

)" || {

log_error 'Unable to create temporary file.'

return 1

}

toolset completion --script --shell="${completion_shell}" \

--output="${completion_file_tmp}"

completion_file_hash="$(

completion_file_hash="${completion_file_hash#sha256:}"

completion_file="${cache_dir}/completion-${completion_file_hash}.${completion_shell}"

mv -f "${completion_file_tmp}" "${completion_file}"

export "${var}=${completion_file}"

fi

done

# }}} Shell Completion ####################################################

# {{{ Cached Dhall Configs ################################################

local toolset_config_dir="${config_dir}/${toolset}"

local default_config_constructor="${toolset_config_dir}/default/constructor.dhall"

if [[ -f "${default_config_constructor}" ]]; then

watch_file "${default_config_constructor}"

command_wrapper_dhall_cache "${toolset}" "default.dhall" \

"${config_dir}/${toolset}" "${default_config_constructor}"

fi

# }}} Cached Dhall Configs ################################################

# This will make toolset aware of project-level configuration. We need to

# keep at the bottom so that above invocations of toolset will not fail

# while we may be building the project-level configuration.

export COMMAND_WRAPPER_LOCAL_CONFIG_DIR="${config_dir}"