How do i use the && and || operators with more than two variables correctly?

Question

I'm trying to compare the state of more than two variables. The use-case is a script that, among other options, should select (or auto-select) only one of several "modes" based on available executables. A partial syntax diagram is:

 [ [--fzf,-f]|[--rofi,-r]|[--dmenu,-d] ]

The variables are defined based on presence of command arguments, so, for example, if --fzf or -f are found on the command line arguments, an associated fzf variable is set to "1" indicating that the user wants to run the script in, for lack of better terms, fzf mode.

The && operator statement below addresses what happens if none of the command arguments is found on the command-line. Basically, if no "mode" was selected, then the script will auto-select one, and only one, mode to use in a hierarchical fashion.

The || operator statement below is supposed to address what happens if a mode is selected (by the user), but the underlying executable is not found.

Here is the original version for the && operator:

if [[ $fzf = 0 && $rofi = 0 ]]; then
        if command_exists fzf; then
            fzf=1
        elif command_exists rofi; then
            rofi=1
        fi
    fi

to

if [[ $fzf = 0 && $rofi = 0 && $dmenu = 0 ]]; then
        if command_exists fzf; then
            fzf=1
        elif command_exists rofi; then
            rofi=1
        elif command_exists dmenu; then
            dmenu=1
        fi
    fi

And lastly, here the original for the || operator:

if [[ $rofi = 1 || $fzf = 0 ]]; then
        command_exists rofi || die "Could not find rofi in \$PATH"
        menu="$rofi_cmd"
elif [[ $fzf = 1 || $rofi = 0 ]]; then
        command_exists fzf || die "Could not find fzf in \$PATH"
        menu="$fzf_cmd"
else
        die "Could not find either fzf or rofi in \$PATH"
fi

to

if [[ $rofi = 1 || $fzf = 0 || $dmenu = 0 ]]; then
        command_exists rofi || die "Could not find rofi in \$PATH"
        menu="$rofi_cmd"
    elif [[ $fzf = 1 || $rofi = 0 || $dmenu = 0 ]]; then
        command_exists fzf || die "Could not find fzf in \$PATH"
        menu="$fzf_cmd"
    elif [[ $dmenu = 1 || $rofi = 0 || $fzf = 0 ]]; then
        command_exists dmenu || die "Could not find dmenu in \$PATH"
        menu="$dmenu_cmd"
    else
        die "Could not find either fzf or rofi or dmenu in \$PATH"
    fi

Which doesn't seem to throw any error, but i suspect that this is neither the correct way to do this, and probably doesn't work as expected (as it seems to report wrong values when using -x and seeing it's output).

I'm aware of post such as this one, but i didn't (yet) found examples with more than two variables (like what I tried to do above).

The above original part were taken from this script. I'm basically trying to add support for dmenu since it only support rofi and fzf (as showed above).

Here the full modified script. It need password-store as dependencies.

I'm using Bash 5.0.3.

How do i use the && and || operators with more than two variables correctly?

Answer 1

If the user is only supposed to choose one of many, I'd just use one variable to hold the choice, dropping the per-option variables. We don't really care about all the combinations anyway, we just want one choice of out of three, and another for "unset/default".

So:

#!/bin/sh
cmd=             # empty value for default
case "$1" in
    --rofi|-r)  cmd=rofi ;;
    --fzf|-f)   cmd=fzf ;;
    --dmenu|-d) cmd=dmenu ;;
esac
if [ -z "$cmd" ]; then
    echo "no command set, looking for default"
    if command_exists fzf; then
        cmd=fzf
    elif
        ...
    fi
fi
echo "running with command $cmd"
actually do something

Here, the chosen mode is stored in cmd. I didn't actually even give the user the possibility to give two commands, only the first argument is read for the flag. Now, if you use getopt or getopts, that doesn't really fly, but we could check if the mode has already been set before setting it (again).

#!/bin/sh
error_if_cmd_set() {
    if [ -n "$1" ]; then
        echo "command already set"
        exit 1
    fi
}
cmd=
for arg in "$@"; do
    case "$1" in
        --rofi|-r)  error_if_cmd_set "$cmd"; cmd=rofi ;;
        --fzf|-f)   error_if_cmd_set "$cmd"; cmd=fzf ;;
        --dmenu|-d) error_if_cmd_set "$cmd"; cmd=dmenu ;;
    esac
done
# ...
echo "using command $cmd"

Answer 2

I honestly don't know what you're trying to do with those checks. If you need to check that at least one of those programs is available:

programs=(fzf rofi dmenu)
available=()
for prog in "${programs[@]}"; do
  location=$(type -P $prog) && available+=("$location")
done
(( ${#available[@]} == 0 )) && die "none of ${programs[*] are available"
what is your logic for choosing one if multiple are available?
menu=${available[0]}

---

Based on your comments, it'll be cleaner to push more work into the case branches:

    fzf_exists=0
    rofi_exists=0
    dmenu_exists=0
# reorder these if you want: the _last_ one to succeed is the default
if command_exists dmenu; then
    dmenu_exists=1
    menu_default=$dmenu_cmd
fi
if command_exists rofi; then 
    rofi_exists=1
    menu_default=$rofi_cmd
fi
if command_exists fzf; then 
    fzf_exists=1
    menu_default=$fzf_cmd
fi

if [[ -z $menu_default ]]; then
    die "none of fzf, rofi, dmenu are available"
fi

while true; do 
    case "$1" in
        -f|--fzf) 
            (( fzf_exists )) || die "fzf is not available"
            [[ -n $menu ]]   && die "choose only one of fzf/rofi/dmenu"
            menu=$fzf_cmd
            shift 
            ;;
        -r|--rofi)
            (( rofi_exists )) || die "rofi is not available"
            [[ -n $menu ]]    && die "choose only one of fzf/rofi/dmenu"
            menu=$rofi_cmd
            shift 
            ;;
        -d|--dmenu)
            (( dmenu_exists )) || die "dmenu is not available"
            [[ -n $menu ]]     && die "choose only one of fzf/rofi/dmenu"
            menu=$dmenu_cmd
            shift 
            ;;
        # ...
    esac
done

: ${menu:=$menu_default}

Note that the command_exists function should return 1 not exit 1

Answer 3

The || and && operators are working fine. There are problems in the way that the script is translated, but, despite repeated requests for logic clarification, none has been offered. I have therefore added to the question based on how I understand the copied script is working.

One interesting thing is that a bit of the script not posted in the question has been translated incorrectly:

if [[ $fzf = 1 && $rofi = 1 && $dmenu = 1 ]]; then
    die 'Either --fzf,-f or --rofi,-r or --dmenu,-d must be given, not more than one'
fi

The intent, best as can be told after a quick review, is that the statement should be something more along the lines of:

if [[ $(( $fzf + $rofi + $dmenu )) > 1 ]]; then
    die 'Either --fzf,-f or --rofi,-r or --dmenu,-d must be given, not more than one'
fi

There could be other issues. It is VERY important that you provide all relevant information.