diff options
Diffstat (limited to 'share')
| -rwxr-xr-x | share/spack/qa/run-shell-tests | 6 | ||||
| -rwxr-xr-x | share/spack/qa/setup-env-test.fish | 395 | ||||
| -rwxr-xr-x | share/spack/setup-env.fish | 723 | ||||
| -rwxr-xr-x | share/spack/spack-completion.bash | 8 |
4 files changed, 1128 insertions, 4 deletions
diff --git a/share/spack/qa/run-shell-tests b/share/spack/qa/run-shell-tests index 31c1c1548b..126e639186 100755 --- a/share/spack/qa/run-shell-tests +++ b/share/spack/qa/run-shell-tests @@ -25,6 +25,9 @@ check_dependencies $coverage git hg svn export PATH="$ORIGINAL_PATH" unset spack +# Convert QA_DIR to absolute path before changing directory +export QA_DIR=$(realpath $QA_DIR) + # Start in the spack root directory cd "$SPACK_ROOT" @@ -41,3 +44,6 @@ fi # Run the test scripts for their output (these will print nicely) zsh "$QA_DIR/setup-env-test.sh" dash "$QA_DIR/setup-env-test.sh" + +# Run fish tests +fish "$QA_DIR/setup-env-test.fish" diff --git a/share/spack/qa/setup-env-test.fish b/share/spack/qa/setup-env-test.fish new file mode 100755 index 0000000000..964d876fe9 --- /dev/null +++ b/share/spack/qa/setup-env-test.fish @@ -0,0 +1,395 @@ +#!/usr/bin/env fish +# +# Copyright 2013-2019 Lawrence Livermore National Security, LLC and other +# Spack Project Developers. See the top-level COPYRIGHT file for details. +# +# SPDX-License-Identifier: (Apache-2.0 OR MIT) + +# +# This script tests that Spack's setup-env.fish init script works. +# + + +function allocate_testing_global -d "allocate global variables used for testing" + + # Colors for output + set -gx __spt_red '\033[1;31m' + set -gx __spt_cyan '\033[1;36m' + set -gx __spt_green '\033[1;32m' + set -gx __spt_reset '\033[0m' + + # counts of test successes and failures. + set -gx __spt_success 0 + set -gx __spt_errors 0 +end + + +function delete_testing_global -d "deallocate global varialbes used for testing" + + set -e __spt_red + set -e __spt_cyan + set -e __spt_green + set -e __spt_reset + + set -e __spt_success + set -e __spt_errors +end + +# ------------------------------------------------------------------------ +# Functions for color output. +# ------------------------------------------------------------------------ + + +function echo_red + printf "$__spt_red$argv$__spt_reset\n" +end + +function echo_green + printf "$__spt_green$argv$__spt_reset\n" +end + +function echo_msg + printf "$__spt_cyan$argv$__spt_reset\n" +end + + + +# ------------------------------------------------------------------------ +# Generic functions for testing fish code. +# ------------------------------------------------------------------------ + + +# Print out a header for a group of tests. +function title + + echo + echo_msg "$argv" + echo_msg "---------------------------------" + +end + +# echo FAIL in red text; increment failures +function fail + echo_red FAIL + set __spt_errors (math $__spt_errors+1) +end + +# echo SUCCESS in green; increment successes +function pass + echo_green SUCCESS + set __spt_success (math $__spt_success+1) +end + + +# +# Run a command and suppress output unless it fails. +# On failure, echo the exit code and output. +# +function spt_succeeds + printf "'$argv' succeeds ... " + + set -l output (eval $argv 2>&1) + + if test $status -ne 0 + fail + echo_red "Command failed with error $status" + if test -n "$output" + echo_msg "Output:" + echo "$output" + else + echo_msg "No output." + end + else + pass + end +end + + +# +# Run a command and suppress output unless it succeeds. +# If the command succeeds, echo the output. +# +function spt_fails + printf "'$argv' fails ... " + + set -l output (eval $argv 2>&1) + + if test $status -eq 0 + fail + echo_red "Command failed with error $status" + if test -n "$output" + echo_msg "Output:" + echo "$output" + else + echo_msg "No output." + end + else + pass + end +end + + +# +# Ensure that a string is in the output of a command. +# Suppresses output on success. +# On failure, echo the exit code and output. +# +function spt_contains + set -l target_string $argv[1] + set -l remaining_args $argv[2..-1] + + printf "'$remaining_args' output contains '$target_string' ... " + + set -l output (eval $remaining_args 2>&1) + + if not echo "$output" | string match -q -r ".*$target_string.*" + fail + echo_red "Command exited with error $status" + echo_red "'$target_string' was not in output." + if test -n "$output" + echo_msg "Output:" + echo "$output" + else + echo_msg "No output." + end + else + pass + end +end + + +# +# Ensure that a variable is set. +# +function is_set + printf "'$argv[1]' is set ... " + + if test -z "$$argv[1]" + fail + echo_msg "'$argv[1]' was not set!" + else + pass + end +end + + +# +# Ensure that a variable is not set. +# Fails and prints the value of the variable if it is set. +# +function is_not_set + printf "'$argv[1]' is not set ... " + + if test -n "$$argv[1]" + fail + echo_msg "'$argv[1]' was set!" + echo " $$argv[1]" + else + pass + end +end + + + +# ----------------------------------------------------------------------- +# Setup test environment and do some preliminary checks +# ----------------------------------------------------------------------- + +# Make sure no environment is active +set -e SPACK_ENV +true # ignore failing `set -e` + +# Source setup-env.sh before tests +set -gx QA_DIR (dirname (status --current-filename)) +source $QA_DIR/../setup-env.fish + + + +# ----------------------------------------------------------------------- +# Instead of invoking the module and cd commands, we print the arguments that +# Spack invokes the command with, so we can check that Spack passes the expected +# arguments in the tests below. +# +# We make that happen by defining the fish functions below. NOTE: these overwrite +# existing functions => define them last +# ----------------------------------------------------------------------- + + +function module + echo "module $argv" +end + +function cd + echo "cd $argv" +end + + +allocate_testing_global + + + +# ----------------------------------------------------------------------- +# Let the testing begin! +# ----------------------------------------------------------------------- + + +title "Testing setup-env.fish with $_sp_shell" + +# spack command is now available +spt_succeeds which spack + + +# create a fake mock package install and store its location for later +title "Setup" +echo "Creating a mock package installation" +spack -m install --fake a + +# create a test environment for testing environment commands +echo "Creating a mock environment" +spack env create spack_test_env + +# ensure that we uninstall b on exit +function spt_cleanup + + set trapped_error false + if test $status -ne 0 + set trapped_error true + end + + echo "Removing test environment before exiting." + spack env deactivate 2>&1 > /dev/null + spack env rm -y spack_test_env + + title "Cleanup" + echo "Removing test packages before exiting." + spack -m uninstall -yf b a + + echo + echo "$__spt_success tests succeeded." + echo "$__spt_errors tests failed." + + if test "$trapped_error" = false + echo "Exited due to an error." + end + + if test "$__spt_errors" -eq 0 + if test "$trapped_error" = false + pass + exit 0 + else + fail + exit 1 + end + else + fail + exit 1 + end + + delete_testing_global +end + +trap spt_cleanup EXIT + + + +# ----------------------------------------------------------------------- +# Test all spack commands with special env support +# ----------------------------------------------------------------------- +title 'Testing `spack`' +spt_contains 'usage: spack ' spack +spt_contains "usage: spack " spack -h +spt_contains "usage: spack " spack help +spt_contains "usage: spack " spack -H +spt_contains "usage: spack " spack help --all + +title 'Testing `spack cd`' +spt_contains "usage: spack cd " spack cd -h +spt_contains "usage: spack cd " spack cd --help +spt_contains "cd $b_install" spack cd -i b + +title 'Testing `spack module`' +spt_contains "usage: spack module " spack -m module -h +spt_contains "usage: spack module " spack -m module --help +spt_contains "usage: spack module " spack -m module + +title 'Testing `spack load`' +set _b_loc (spack -m location -i b) +set _b_ld $_b_loc"/lib" +set _a_loc (spack -m location -i a) +set _a_ld $_a_loc"/lib" + +spt_contains "set -gx LD_LIBRARY_PATH $_b_ld" spack -m load --only package --fish b +spt_succeeds spack -m load b +# test a variable MacOS clears and one it doesn't for recursive loads +spt_contains "set -gx LD_LIBRARY_PATH $_a_ld:$_b_ld" spack -m load --fish a +spt_contains "set -gx LIBRARY_PATH $_a_ld:$_b_ld" spack -m load --fish a +spt_succeeds spack -m load --only dependencies a +spt_succeeds spack -m load --only package a +spt_fails spack -m load d +spt_contains "usage: spack load " spack -m load -h +spt_contains "usage: spack load " spack -m load -h d +spt_contains "usage: spack load " spack -m load --help + +title 'Testing `spack unload`' +spack -m load b a # setup +# spt_contains "module unload $b_module" spack -m unload b +spt_succeeds spack -m unload b +spt_succeeds spack -m unload --all +spack -m unload --all # cleanup +spt_fails spack -m unload -l +# spt_contains "module unload -l --arg $b_module" spack -m unload -l --arg b +spt_fails spack -m unload d +spt_contains "usage: spack unload " spack -m unload -h +spt_contains "usage: spack unload " spack -m unload -h d +spt_contains "usage: spack unload " spack -m unload --help + +title 'Testing `spack env`' +spt_contains "usage: spack env " spack env -h +spt_contains "usage: spack env " spack env --help + +title 'Testing `spack env list`' +spt_contains " spack env list " spack env list -h +spt_contains " spack env list " spack env list --help + +title 'Testing `spack env activate`' +spt_contains "No such environment:" spack env activate no_such_environment +spt_contains "usage: spack env activate " spack env activate +spt_contains "usage: spack env activate " spack env activate -h +spt_contains "usage: spack env activate " spack env activate --help + +title 'Testing `spack env deactivate`' +spt_contains "Error: No environment is currently active" spack env deactivate +spt_contains "usage: spack env deactivate " spack env deactivate no_such_environment +spt_contains "usage: spack env deactivate " spack env deactivate -h +spt_contains "usage: spack env deactivate " spack env deactivate --help + +title 'Testing activate and deactivate together' +echo "Testing 'spack env activate spack_test_env'" +spack env activate spack_test_env +is_set SPACK_ENV + +echo "Testing 'spack env deactivate'" +spack env deactivate +is_not_set SPACK_ENV + +echo "Testing 'spack env activate spack_test_env'" +spack env activate spack_test_env +is_set SPACK_ENV + +echo "Testing 'despacktivate'" +despacktivate +is_not_set SPACK_ENV + +# +# NOTE: `--prompt` on fish does nothing => currently not implemented. +# + +# echo "Testing 'spack env activate --prompt spack_test_env'" +# spack env activate --prompt spack_test_env +# is_set SPACK_ENV +# is_set SPACK_OLD_PS1 +# +# echo "Testing 'despacktivate'" +# despacktivate +# is_not_set SPACK_ENV +# is_not_set SPACK_OLD_PS1 diff --git a/share/spack/setup-env.fish b/share/spack/setup-env.fish new file mode 100755 index 0000000000..a534f09ee9 --- /dev/null +++ b/share/spack/setup-env.fish @@ -0,0 +1,723 @@ +# Copyright 2013-2019 Lawrence Livermore National Security, LLC and other +# Spack Project Developers. See the top-level COPYRIGHT file for details. +# +# SPDX-License-Identifier: (Apache-2.0 OR MIT) + + +################################################################################# +# +# This file is part of Spack and sets up the spack environment for the friendly +# interactive shell (fish). This includes module support, and it also puts spack +# in your path. The script also checks that at least module support exists, and +# provides suggestions if it doesn't. Source it like this: +# +# source /path/to/spack/share/spack/setup-env.fish +# +################################################################################# +# This is a wrapper around the spack command that forwards calls to 'spack load' +# and 'spack unload' to shell functions. This in turn allows them to be used to +# invoke environment modules functions. +# +# 'spack load' is smarter than just 'load' because it converts its arguments into +# a unique spack spec that is then passed to module commands. This allows the +# user to load packages without knowing all their installation details. +# +# e.g., rather than requiring a full spec for libelf, the user can type: +# +# spack load libelf +# +# This will first find the available libelf modules and load a matching one. If +# there are two versions of libelf, the user would need to be more specific, +# e.g.: +# +# spack load libelf@0.8.13 +# +# This is very similar to how regular spack commands work and it avoids the need +# to come up with a user-friendly naming scheme for spack dotfiles. +################################################################################# + + +# +# Test for STDERR-NOCARET feature: if this is off, fish will redirect stderr to +# a file named in the string after `^` +# + + +if status test-feature stderr-nocaret +else + echo "WARNING: you have not enabled the 'stderr-nocaret' feature." + echo "This means that you have to escape the caret (^) character when defining specs." + echo "Consider enabling stderr-nocaret: https://fishshell.com/docs/current/index.html#featureflags" +end + + + +# +# SPACK wrapper function, preprocessing arguments and flags. +# + + +function spack -d "wrapper for the `spack` command" + + +# +# DEFINE SUPPORT FUNCTIONS HERE +# + + +# +# ALLOCATE_SP_SHARED, and DELETE_SP_SHARED allocate (and delete) temporary +# global variables +# + + +function allocate_sp_shared -d "allocate shared (global variables)" + set -gx __sp_remaining_args + set -gx __sp_subcommand_args + set -gx __sp_module_args + set -gx __sp_stat + set -gx __sp_stdout + set -gx __sp_stderr +end + + + +function delete_sp_shared -d "deallocate shared (global variables)" + set -e __sp_remaining_args + set -e __sp_subcommand_args + set -e __sp_module_args + set -e __sp_stat + set -e __sp_stdout + set -e __sp_stderr +end + + + + +# +# STREAM_ARGS and SHIFT_ARGS: helper functions manipulating the `argv` array: +# -> STREAM_ARGS: echos the `argv` array element-by-element +# -> SHIFT_ARGS: echos the `argv` array element-by-element starting with the +# second element. If `argv` has only one element, echo the +# empty string `""`. +# NOTE: while `stream_args` is not strictly necessary, it adds a nice symmetry +# to `shift_args` +# + +function stream_args -d "echos args as a stream" + # return the elements of `$argv` as an array + # -> since we want to be able to call it as part of `set x (shift_args + # $x)`, we return these one-at-a-time using echo... this means that the + # sub-command stream will correctly concatenate the output into an array + for elt in $argv + echo $elt + end +end + + +function shift_args -d "simulates bash shift" + # + # Returns argv[2..-1] (as an array) + # -> if argv has only 1 element, then returns the empty string. This + # simulates the behavior of bash `shift` + # + + if test -z "$argv[2]" + # there are no more element, returning the empty string + echo "" + else + # return the next elements `$argv[2..-1]` as an array + # -> since we want to be able to call it as part of `set x (shift_args + # $x)`, we return these one-at-a-time using echo... this means that + # the sub-command stream will correctly concatenate the output into + # an array + for elt in $argv[2..-1] + echo $elt + end + end + +end + + + + +# +# CAPTURE_ALL: helper function used to capture stdout, stderr, and status +# -> CAPTURE_ALL: there is a bug in fish, that prevents stderr re-capture +# from nested command substitution: +# https://github.com/fish-shell/fish-shell/issues/6459 +# + +function capture_all + begin; + begin; + eval $argv[1] + set $argv[2] $status # read sets the `status` flag => capture here + end 2>| read -z __err + end 1>| read -z __out + + # output arrays + set $argv[3] (echo $__out | string split \n) + set $argv[4] (echo $__err | string split \n) + + return 0 +end + + + + +# +# GET_SP_FLAGS, and GET_MOD_ARGS: support functions for extracting arguments and +# flags. Note bash's `shift` operation is simulated by the `__sp_remaining_args` +# array which is roughly equivalent to `$@` in bash. +# + +function get_sp_flags -d "return leading flags" + # + # Accumulate initial flags for main spack command. NOTE: Sets the external + # array: `__sp_remaining_args` containing all unprocessed arguments. + # + + # initialize argument counter + set -l i 1 + + # iterate over elements (`elt`) in `argv` array + for elt in $argv + + # match element `elt` of `argv` array to check if it has a leading dash + if echo $elt | string match -r -q "^-" + # by echoing the current `elt`, the calling stream accumulates list + # of valid flags. NOTE that this can also be done by adding to an + # array, but fish functions can only return integers, so this is the + # most elegant solution. + echo $elt + else + # bash compatibility: stop when the match first fails. Upon failure, + # we pack the remainder of `argv` into a global `__sp_remaining_args` + # array (`i` tracks the index of the next element). + set __sp_remaining_args (stream_args $argv[$i..-1]) + return + end + + # increment argument counter: used in place of bash's `shift` command + set -l i (math $i+1) + + end + + # if all elements in `argv` are matched, make sure that `__sp_remaining_args` + # is deleted (this might be overkill...). + set -e __sp_remaining_args +end + + + +# +# CHECK_SP_FLAGS, CONTAINS_HELP_FLAGS, CHECK_ENV_ACTIVATE_FLAGS, and +# CHECK_ENV_DEACTIVATE_FLAGS: support functions for checking arguments and flags. +# + +function check_sp_flags -d "check spack flags for h/V flags" + # + # Check if inputs contain h or V flags. + # + + # combine argument array into single string (space seperated), to be passed + # to regular expression matching (`string match -r`) + set -l _a "$argv" + + # skip if called with blank input. Notes: [1] (cf. EOF) + if test -n "$_a" + if echo $_a | string match -r -q ".*h.*" + return 0 + end + if echo $_a | string match -r -q ".*V.*" + return 0 + end + end + + return 1 +end + + + +function check_env_activate_flags -d "check spack env subcommand flags for -h, --sh, --csh, or --fish" + # + # Check if inputs contain -h, --sh, --csh, or --fish + # + + # combine argument array into single string (space seperated), to be passed + # to regular expression matching (`string match -r`) + set -l _a "$argv" + + # skip if called with blank input. Notes: [1] (cf. EOF) + if test -n "$_a" + # looks for a single `-h` (possibly surrounded by spaces) + if echo $_a | string match -r -q " *-h *" + return 0 + end + + # looks for a single `--sh` (possibly surrounded by spaces) + if echo $_a | string match -r -q " *--sh *" + return 0 + end + + # looks for a single `--csh` (possibly surrounded by spaces) + if echo $_a | string match -r -q " *--csh *" + return 0 + end + + # looks for a single `--fish` (possibly surrounded by spaces) + if echo $_a | string match -r -q " *--fish *" + return 0 + end + + end + + return 1 +end + + +function check_env_deactivate_flags -d "check spack env subcommand flags for --sh, --csh, or --fish" + # + # Check if inputs contain -h, --sh, --csh, or --fish + # + + # combine argument array into single string (space seperated), to be passed + # to regular expression matching (`string match -r`) + set -l _a "$argv" + + # skip if called with blank input. Notes: [1] (cf. EOF) + if test -n "$_a" + + # TODO: should this crash (we're clearly using fish, not bash, here)? + # looks for a single `--sh` (possibly surrounded by spaces) + if echo $_a | string match -r -q " *--sh *" + return 0 + end + + # TODO: should this crash (we're clearly using fish, not csh, here)? + # looks for a single `--csh` (possibly surrounded by spaces) + if echo $_a | string match -r -q " *--csh *" + return 0 + end + + # looks for a single `--fish` (possibly surrounded by spaces) + if echo $_a | string match -r -q " *--fish *" + return 0 + end + + end + + return 1 +end + + + + +# +# SPACK RUNNER function, this does all the work! +# + + +function spack_runner -d "Runner function for the `spack` wrapper" + + + # + # Accumulate initial flags for main spack command + # + + set __sp_remaining_args # remaining (unparsed) arguments + set -l sp_flags (get_sp_flags $argv) # sets __sp_remaining_args + + + # + # h and V flags don't require further output parsing. + # + + if check_sp_flags $sp_flags + command spack $sp_flags $__sp_remaining_args + return 0 + end + + + # + # Isolate subcommand and subcommand specs. Notes: [1] (cf. EOF) + # + + set -l sp_subcommand "" + + if test -n "$__sp_remaining_args[1]" + set sp_subcommand $__sp_remaining_args[1] + set __sp_remaining_args (shift_args $__sp_remaining_args) # simulates bash shift + end + + set -l sp_spec $__sp_remaining_args + + + # + # Filter out cd, env, and load and unload. For any other commands, just run + # the spack command as is. + # + + switch $sp_subcommand + + # CASE: spack subcommand is `cd`: if the sub command arg is `-h`, nothing + # further needs to be done. Otherwise, test the location referring the + # subcommand and cd there (if it exists). + + case "cd" + + set -l sp_arg "" + + # Extract the first subcommand argument. Notes: [1] (cf. EOF) + if test -n "$__sp_remaining_args[1]" + set sp_arg $__sp_remaining_args[1] + set __sp_remaining_args (shift_args $__sp_remaining_args) # simulates bash shift + end + + # Notes: [2] (cf. EOF) + if test "x$sp_arg" = "x-h"; or test "x$sp_arg" = "x--help" + # nothing more needs to be done for `-h` or `--help` + command spack cd -h + else + # extract location using the subcommand (fish `(...)`) + set -l LOC (command spack location $sp_arg $__sp_remaining_args) + + # test location and cd if exists: + if test -d "$LOC" + cd $LOC + else + return 1 + end + + end + + return 0 + + + # CASE: spack subcommand is `env`. Here we get the spack runtime to + # supply the appropriate shell commands for setting the environment + # varibles. These commands are then run by fish (using the `capture_all` + # function, instead of a command substitution). + + case "env" + + set -l sp_arg "" + + # Extract the first subcommand argument. Notes: [1] (cf. EOF) + if test -n "$__sp_remaining_args[1]" + set sp_arg $__sp_remaining_args[1] + set __sp_remaining_args (shift_args $__sp_remaining_args) # simulates bash shift + end + + # Notes: [2] (cf. EOF) + if test "x$sp_arg" = "x-h"; or test "x$sp_arg" = "x--help" + # nothing more needs to be done for `-h` or `--help` + command spack env -h + else + switch $sp_arg + case "activate" + set -l _a (stream_args $__sp_remaining_args) + + if check_env_activate_flags $_a + # no args or args contain -h/--help, --sh, or --csh: just execute + command spack env activate $_a + else + # actual call to activate: source the output + set -l sp_env_cmd "command spack $sp_flags env activate --fish $__sp_remaining_args" + capture_all $sp_env_cmd __sp_stat __sp_stdout __sp_stderr + eval $__sp_stdout + if test -n "$__sp_stderr" + echo -s \n$__sp_stderr 1>&2 # current fish bug: handle stderr manually + end + end + + case "deactivate" + set -l _a (stream_args $__sp_remaining_args) + + if check_env_deactivate_flags $_a + # just execute the command if --sh, --csh, or --fish are provided + command spack env deactivate $_a + + # Test of further (unparsed arguments). Any other + # arguments are an error or help, so just run help + # -> TODO: This should throw and error but leave as is + # for compatibility with setup-env.sh + # -> Notes: [1] (cf. EOF). + else if test -n "$__sp_remaining_args" + command spack env deactivate -h + else + # no args: source the output of the command + set -l sp_env_cmd "command spack $sp_flags env deactivate --fish" + capture_all $sp_env_cmd __sp_stat __sp_stdout __sp_stderr + eval $__sp_stdout + if test $__sp_stat -ne 0 + if test -n "$__sp_stderr" + echo -s \n$__sp_stderr 1>&2 # current fish bug: handle stderr manually + end + return 1 + end + end + + case "*" + # if $__sp_remaining_args is empty, then don't include it + # as argument (otherwise it will be confused as a blank + # string input!) + if test -n "$__sp_remaining_args" + command spack env $sp_arg $__sp_remaining_args + else + command spack env $sp_arg + end + end + end + + + # CASE: spack subcommand is either `load`, or `unload`. These statements + # deal with the technical details of actually using modules. Especially + # to deal with the substituting latest version numbers to the module + # command. + + case "load" or "unload" + + set -l _a (stream_args $__sp_remaining_args) + + if check_env_activate_flags $_a + # no args or args contain -h/--help, --sh, or --csh: just execute + command spack $sp_flags $sp_subcommand $__sp_remaining_args + else + # actual call to activate: source the output + set -l sp_env_cmd "command spack $sp_flags $sp_subcommand --fish $__sp_remaining_args" + capture_all $sp_env_cmd __sp_stat __sp_stdout __sp_stderr + eval $__sp_stdout + if test $__sp_stat -ne 0 + if test -n "$__sp_stderr" + echo -s \n$__sp_stderr 1>&2 # current fish bug: handle stderr manually + end + return 1 + end + end + + + # CASE: Catch-all + + case "*" + command spack $argv + + end + + return 0 +end + + + + +# +# RUN SPACK_RUNNER HERE +# + + +# +# Allocate temporary global variables used for return extra arguments from +# functions. NOTE: remember to call delete_sp_shared whenever returning from +# this function. +# + +allocate_sp_shared + + +# +# Run spack command using the spack_runner. +# + +spack_runner $argv +# Capture state of spack_runner (returned below) +set -l stat $status + + +# +# Delete temprary global variabels allocated in `allocated_sp_shared`. +# + +delete_sp_shared + + + +return $stat + +end + + + +################################################################################# +# Prepends directories to path, if they exist. +# pathadd /path/to/dir # add to PATH +# or pathadd OTHERPATH /path/to/dir # add to OTHERPATH +################################################################################# +function spack_pathadd -d "Add path to specified variable (defaults to PATH)" + # + # Adds (existing only) paths to specified (defaults to PATH) + # variable. Does not warn attempting to add non-existing path. This is not a + # bug because the MODULEPATH setup tries add all possible compatible systems + # and therefore sp_multi_pathadd relies on this function failing silently. + # + + # If no variable name is supplied, just append to PATH otherwise append to + # that variable. + # -> Notes: [1] (cf. EOF). + if test -n "$argv[2]" + set pa_varname $argv[1] + set pa_new_path $argv[2] + else + true # this is a bit of a strange hack! Notes: [3] (cf EOF). + set pa_varname PATH + set pa_new_path $argv[1] + end + + set pa_oldvalue $$pa_varname + + # skip path is not existing directory + # -> Notes: [1] (cf. EOF). + if test -d "$pa_new_path" + + # combine argument array into single string (space seperated), to be + # passed to regular expression matching (`string match -r`) + set -l _a "$pa_oldvalue" + + # skip path if it is already contained in the variable + # note spaces in regular expression: we're matching to a space delimited + # list of paths + if not echo $_a | string match -q -r " *$pa_new_path *" + if test -n "$pa_oldvalue" + set $pa_varname $pa_new_path $pa_oldvalue + else + true # this is a bit of a strange hack! Notes: [3] (cf. EOF) + set $pa_varname $pa_new_path + end + end + end +end + + +function sp_multi_pathadd -d "Helper for adding module-style paths by incorporating compatible systems into pathadd" --inherit-variable _sp_compatible_sys_types + # + # Calls spack_pathadd in path inputs, adding all compatible system types + # (sourced from $_sp_compatible_sys_types) to input paths. + # + + for pth in $argv[2] + for systype in $_sp_compatible_sys_types + spack_pathadd $argv[1] "$pth/$systype" + end + end +end + + + +# +# Figure out where this file is. Below code only needs to work in fish +# +set -l sp_source_file (status -f) # name of current file + + + +# +# Find root directory and add bin to path. +# +set -l sp_share_dir (realpath (dirname $sp_source_file)) +set -l sp_prefix (realpath (dirname (dirname $sp_share_dir))) +spack_pathadd PATH "$sp_prefix/bin" +set -xg SPACK_ROOT $sp_prefix + + + +# +# No need to determine which shell is being used (obviously it's fish) +# +set -xg SPACK_SHELL "fish" +set -xg _sp_shell "fish" + + + + +# +# Check whether we need environment-variables (module) <= `use` is not available +# +set -l need_module "no" +if not functions -q use; and not functions -q module + set need_module "yes" +end + + + +# +# Make environment-modules available to shell +# +function sp_apply_shell_vars -d "applies expressions of the type `a='b'` as `set a b`" + + # convert `a='b' to array variable `a b` + set -l expr_token (string trim -c "'" (string split "=" $argv)) + + # run set command to takes, converting lists of type `a:b:c` to array + # variables `a b c` by splitting around the `:` character + set -xg $expr_token[1] (string split ":" $expr_token[2]) +end + + +if test "$need_module" = "yes" + set -l sp_shell_vars (command spack --print-shell-vars sh,modules) + + for sp_var_expr in $sp_shell_vars + sp_apply_shell_vars $sp_var_expr + end + + # _sp_module_prefix is set by spack --print-sh-vars + if test "$_sp_module_prefix" != "not_installed" + set -xg MODULE_PREFIX $_sp_module_prefix + spack_pathadd PATH "$MODULE_PREFIX/bin" + end + +else + + set -l sp_shell_vars (command spack --print-shell-vars sh) + + for sp_var_expr in $sp_shell_vars + sp_apply_shell_vars $sp_var_expr + end + +end + +if test "$need_module" = "yes" + function module -d "wrapper for the `module` command to point at Spack's modules instance" --inherit-variable MODULE_PREFIX + eval $MODULE_PREFIX/bin/modulecmd $SPACK_SHELL $argv + end +end + + + +# +# set module system roots +# + +# Search of MODULESPATHS by trying all possible compatible system types as +# module roots. +if test -z "$MODULEPATH" + set -gx MODULEPATH +end +sp_multi_pathadd MODULEPATH $_sp_tcl_roots + + + +# +# NOTES +# +# [1]: `test -n` requires exactly 1 argument. If `argv` is undefined, or if it +# is an array, `test -n $argv` is unpredictable. Instead, encapsulate +# `argv` in a string, and test the string. +# +# [2]: `test "$a" = "$b$` is dangerous if `a` and `b` contain flags at index 1, +# as `test $a` can be interpreted as `test $a[1] $a[2..-1]`. Solution is to +# prepend a non-flag character, eg: `test "x$a" = "x$b"`. +# +# [3]: When the test in the if statement fails, the `status` flag is set to 1. +# `true` here manuallt resets the value of `status` to 0. Since `set` +# passes `status` along, we thus avoid the function returning 1 by mistake. diff --git a/share/spack/spack-completion.bash b/share/spack/spack-completion.bash index 830958fe42..11bd906ad0 100755 --- a/share/spack/spack-completion.bash +++ b/share/spack/spack-completion.bash @@ -732,14 +732,14 @@ _spack_env() { _spack_env_activate() { if $list_options then - SPACK_COMPREPLY="-h --help --sh --csh -v --with-view -V --without-view -d --dir -p --prompt" + SPACK_COMPREPLY="-h --help --sh --csh --fish -v --with-view -V --without-view -d --dir -p --prompt" else _environments fi } _spack_env_deactivate() { - SPACK_COMPREPLY="-h --help --sh --csh" + SPACK_COMPREPLY="-h --help --sh --csh --fish" } _spack_env_create() { @@ -997,7 +997,7 @@ _spack_list() { _spack_load() { if $list_options then - SPACK_COMPREPLY="-h --help -r --dependencies --sh --csh --first --only" + SPACK_COMPREPLY="-h --help -r --dependencies --sh --csh --fish --first --only" else _installed_packages fi @@ -1445,7 +1445,7 @@ _spack_uninstall() { _spack_unload() { if $list_options then - SPACK_COMPREPLY="-h --help --sh --csh -a --all" + SPACK_COMPREPLY="-h --help --sh --csh --fish -a --all" else _installed_packages fi |