Check if a variable contains only what I want, and nothing else

Question

I'm writing a script to build a software from sources, and there's a --platforms option. I would like to allow the user to select multiple items, but I don't know how to prevent them from making a mistake.

Example:

read -p "For what platforms do you wish to build [mac/win/linux32/linux64/all] ? "

if [[ -n "`echo $REPLY | grep 'win\|mac\|linux32\|linux64\|all`" ]] ; then
    echo "ok"
else 
    echo "not ok"
fi

If the user answers linux32, it should be OK (and it is)

If the user answers linux32,mac, it should be OK (and it is)

If the user answers lulz, it should NOT be OK (and it is not)

If the user answers linux32,lulz, it should NOT be OK (and it is, that's my issue)

I was wondering if you knew a way to allow the user to input whatever they want separated by commas, but only if it's one of the options the script is offering, so in this case linux32 linux64 mac win all.

Maybe with case there is a way to allow multiple inputs, or maybe add an elif $REPLY contains anything else than what we want. Another idea, could awk be used? I can't figure out myself how to do that.

Answer 1

read can break the input into words and store the result in an array. Set the IFS variable to the word separator character (it needs to be a single character, not a string — if the value of IFS contains multiple characters, then each character is a word separator).

IFS=, read -a platforms

Then check each element of the array against the set of supported platforms.

for p in "${platforms[@]}"; do
  case "$p" in
    win|mac|linux32|linux64) :;;
    all) platforms=(win mac linux32 linux64);;
    *) printf 1>&2 "Unsupported platform: %s\n" "$p"; return 2;;
  esac
done

You can also compare the set of platforms in one go. This is more convenient if you don't want to hardcode the set of supported platforms in the checking code¹.

supported_platforms=(win mac linux32 linux64)
IFS=, read -a platforms
bad_platform_names=($(comm -23 <(printf '%s\n' all "${platforms[@]}" | sort -u) \
                               <(printf '%s\n' "${supported_platforms[@]}" | sort -u)))
if [[ ${#bad_platform_names[@]} -ne 0 ]]; then
  printf "Unsupported platform: %s\n" "${bad_platform_names[@]}"
  exit 1
fi
if printf '%s\n' "${platforms[@]}" | grep -qx all; then
  platforms=("${supported_platforms[@]}")
fi

A different approach would be to prompt for platforms one at a time using the select builtin.

¹ _{Of course you can do this in pure bash if you prefer.}

Answer 2

Try this!

buildvar=0
read -p "For what platforms do you wish to build [mac/win/linux32/linux64/all] ? " input
IFS=',' read -a options <<< "$input"

for option in "${options[@]}"
 do
  case "$option" in
    linux32)
        buildcommand="linux32" && buildvar=1
        ;;
    linux64)
        [ $buildvar == 1 ] && buildcommand="$buildcommand",linux64 || buildcommand="linux64" && buildvar=1
        ;;  
    mac)
        [ $buildvar == 1 ] && buildcommand="$buildcommand",mac || buildcommand="mac" && buildvar=1
        ;;  
    win)
        [ $buildvar == 1 ] && buildcommand="$buildcommand",win || buildcommand="win" && buildvar=1
        ;;
    all)
        buildcommand="all" && buildvar=1
        ;;
    *) 
        echo "'$option' was ignored." 
        ;;  
        esac
    done

[ $buildvar == "0" ] && echo "Incorrect input. Default build selected." && buildcommand="default"

echo "=> $buildcommand"

This will prompt for a comma separated list of options. It will then split this list into an array and iterate through the elements checking each element separately, then combine all "good" elements into a single variable.

Answer 3

You can read a single line of input with sed and translate the delimiter to newlines like:

% sed 'y/,/\n/;q' /dev/tty
> this,is,a,single,line
##OUTPUT
this
is
a
single
line

Because sed writes the result to stdout as a text file, following that up with an explicit grep is easy and occurs in a single stream. And, in fact, you can use sed like a smart tee if you make use of its write to file function; and, if you write to file descriptor devices, you can split its output based on rules you define.

A function that prompts for input and outputs only a newline delimited list of acceptable arguments to stdout and erroneous output to stderr might look like:

_accept_prompt() (
   . /dev/fd/0
   IFS=${delim-,}
   _prompt "$@" >&2
   { _read_split "$@" |
        err=all _grep_ok "$@" |
        sed '1{$d}' >&2
   } 3>&1 | _grep_ok "$@"
) <<\HELPERS

_prompt() {
    cat ; printf ' : '
} <<-PROMPT
    Choose from : $(printf "'%s' " "$@")
    Enter a '$IFS'-delimited selection below...
PROMPT

_read_split() {
    y="y/${IFS}/\n/"
    sed -ne "H;x;s/^/Invalid input IGNORED:/;${y};p;x" \
        -ne "/all/s/.*/$*/;${y};w /dev/fd/3" -ne q
} </dev/tty

_grep_ok() {
    grep -${err+v}xF "$(printf '%s\n' "$@" $err)"
}
HELPERS

I split this into hopefully more descriptively named helper functions in lieu of the comments and attached them to the main function. So the flow all happens in the first few lines. I hoped to make this clearer.

_read_split outputs two streams - >&1 and >&3. _grep_ok picks up the first with $err defined and writes to >&2 all lines contained in its input that are not among _accept_prompt's positional parameters.

_grep_ok also concurrently picks up the second stream - >&3 and writes to its >&1 stdout all lines in its input that are among _accept_prompt's positional parameters.

Running it:

% _accept_prompt this is the list of acceptable parameters
###PROMPT
    Choose from : 'this' 'is' 'the' 'list' 'of' 'acceptable' 'parameters'
    Enter a ','-delimited selection below...
###INPUT
 : all,invalid
###STDOUT
this
is
the
list
of
acceptable
parameters
###STDERR
Invalid input IGNORED:
invalid

You can alter the default ,comma delimiter on invocation like:

delim=? _accept_prompt $args

Answer 4

I am presuming you already have some way of getting the variables in from input, since you mentioned a --platforms option. You can use regular expressions to match on the valid conditions.

regex='^(mac|win|linux(32|64)|all)(,(mac|win|linux(32|64)|all))*$'
if [[ $1 =~ $regex ]]; then 
  echo "ok"
else 
  echo "not ok"
fi

That should satisfy all the requirements:

$ ./stack.sh linux32
ok
$ ./stack.sh linux32,mac
ok
$ ./stack.sh lulz
not ok
$ ./stack.sh linux32,lulz
not ok

Granted, this doesn't stop people from using "all,all,all,all", but that at least can be trimmed down when actually running stuff later.

Benefits of this method include being able to loop until the user gets it right, if you're using the read command you have in the first post. Drawbacks include being a bit confusing to just glance at.

regex='^(mac|win|linux(32|64)|all)(,(mac|win|linux(32|64)|all))*$'
while ! [[ $REPLY =~ $regex ]]; do
  read -p "For what platforms do you wish to build [mac/win/linux32/linux64/all] ? "
done

Answer 5

A simplified/improved version of arnefm's answer:

read -p 'Enter a comma-separated list of platforms to build for [win/mac/linux32/linux64/all]: ' input
IFS=',' read -a options <<< "$input"

shopt -s extglob

for option in "${options[@]}"; do
    case "$option" in
        win|mac|linux@(32|64)|all)
            buildcommand="${buildcommand:+$buildcommand,}$option"
            buildvar=1;;
        *)
            printf 'Invalid option "%s" ignored.\n' "$option" >&2;;
    esac
done

IFS=',' read -a options <<< "$buildcommand"

for option in "${options[@]}"; do
    if [[ $option == 'all' ]]; then
        buildcommand='all'
        break
    fi
done

if (( !buildvar )); then
    echo 'Incorrect input. Default build selected.' >&2
    buildcommand='default'
fi

Answer 6

The alternate method as suggested by Gilles, get users to input as little as possible by prompting them for the options.

available_platforms="mac win linux32 linux64"

positive() {
  printf "%s (Answer y for yes or anything else for no) " "$1"
  read answer
  if [ "$answer" != "y" ] && [ "$answer" != "Y" ]; then
    return 1
  fi
}

if positive "Do you want to build for all platforms [$available_platforms]?"; then
  build_platforms="$available_platforms"
else
  for platform in $available_platforms; do
    if positive "Do you want to build for [$platform]?"; then
      build_platforms="${build_platforms}${platform} "
    fi
  done
fi

printf "build_platforms: %s\n" "$build_platforms"