Apply ShellCheck advice

src/bin/saturnin.skel

 }
 
 version_info() {
-    echo "$(basename $0) (Smart and ready desktop helper) $SATURNIN_VERSION"
-    exit $FFOO_EXIT_OK
+    echo "$(basename "$0") (Smart and ready desktop helper) $SATURNIN_VERSION"
+    exit "$FFOO_EXIT_OK"
 }
 
 while true; do case $1 in

src/ffoo/saturnin_meta.sh

         warn "unknown subcommand, ignoring hook: $hname"
         return 0
     }
-    hook_code="$(inigrep -j -p hook.$SATURNIN_SUBCOMMAND.$hname)"
+    hook_code="$(inigrep -j -p "hook.$SATURNIN_SUBCOMMAND.$hname")"
     debug -v SATURNIN_SUBCOMMAND hook_code hname
     bash -n <<<"$hook_code" || {
         warn "syntax errors, ignoring hook: $hname"
 }
 
 saturnin_runsc() {
-    local sc_es=0   # future exit (return) status
     local lexpath="$SATURNIN_LIBEXEC/saturnin-$SATURNIN_SUBCOMMAND"
     debug -v lexpath
     debug "\$*='$*'"
     test -x "$lexpath" || {
         warn "invalid sub-command: $SATURNIN_SUBCOMMAND"
         saturnin_help
-        return $FFOO_EXIT_USAGE
+        return "$FFOO_EXIT_USAGE"
     }
     "$lexpath" "$@"
 }

src/ffoo/saturnin_urimagic.sh

     #
     local d=$(mktemp -d -t saturnin_urimagic.XXXXXXXX)
     local p=__saturnin_urimagic__
-    pushd $d >&/dev/null
+    pushd "$d" >&/dev/null
         ##
         # heat up and fill pipes
         #
             cat uris_from_kws
         } | grep .  # throw away empties; add missing LF
     popd >&/dev/null
-    rm -rf $d
+    rm -rf "$d"
 }
 
 __saturnin_urimagic__deref() {
         debug -v kw query
         if test -n "$query";
         then
-            local fmt=$(inigrep -j -1 -p $pfxN.${kw,,})
+            local fmt=$(inigrep -j -1 -p "$pfxN.${kw,,}")
             debug -v fmt
             printf "$fmt\n" "$query"
         else
-            inigrep -j -1 -p $pfx0.$kw
+            inigrep -j -1 -p "$pfx0.$kw"
         fi
     done
 }
     #
     # Hack expressions like bug = 123 out of the text
     #
-    sed -e 's/(\d)\</\n/;'\
+    sed -e 's/(\d)\</\n/;' \
       | perl -ne '
             next unless m/\b([a-zA-Z]\w*\s*=\s*\w+)\b/;
             print "$1\n";

src/ffoo/saturnin_zleep.sh

 
 __zleep_try_umount() {
     local mp=$1
-    mountpoint -q $mp || return 0
-    umount        $mp || return 1
-    mount | grep  $mp && return 1
+    mountpoint -q "$mp" || return 0
+    umount        "$mp" || return 1
+    mount | grep  "$mp" && return 1
     return 0
 }
 
     local mp
     for mp in $(inigrep -p iam.mounting.point);
     do
-        __zleep_try_umount $mp || return 1
+        __zleep_try_umount "$mp" || return 1
     done
     return 0
 }
 
 __zleep_sudo_part_started() {
     # i.e. password prompt went ok
-    test -e $ZLEEP_ON_ROOT
+    test -e "$ZLEEP_ON_ROOT"
     rv=$?
     debug -v rv
     return $rv
 }
 
 __zleep_user_part_done() {
-    ! test -e $ZLEEP_ON_USER
+    ! test -e "$ZLEEP_ON_USER"
     rv=$?
     debug -v rv
     return $rv
 }
 
 __zleep_min_path() {
-    echo -n $(sudo env | grep ^PATH)
+    echo -n "$(sudo env | grep ^PATH)"
     echo -n :
-    echo -n $(dirname $(which ffoom))
+    echo -n "$(dirname "$(which ffoom)")"
     echo -n :
-    echo -n $(dirname $(which saturnin))
+    echo -n "$(dirname "$(which saturnin)")"
 }
 
 zleep() {
         SUDO_PATH=$(__zleep_min_path)   # needed while bins are still under local
         debug -v ZLEEP_ON_USER ZLEEP_ON_ROOT SUDO_PATH
         sudo env \
-            ZLEEP_ON_ROOT=$ZLEEP_ON_ROOT \
-            ZLEEP_ON_USER=$ZLEEP_ON_USER \
-            PATH=$SUDO_PATH \
+            ZLEEP_ON_ROOT="$ZLEEP_ON_ROOT" \
+            ZLEEP_ON_USER="$ZLEEP_ON_USER" \
+            PATH="$SUDO_PATH" \
             saturnin iam zleeping &
         wait_until -t 60 __zleep_sudo_part_started    # i.e. password prompt done
         __zleep_user_part
-        rm -f $ZLEEP_ON_USER
+        rm -f "$ZLEEP_ON_USER"
     else                            ## we are child (running as root)
-        touch $ZLEEP_ON_ROOT
-        test $(id -u) -eq 0         || die "must be root"
+        touch "$ZLEEP_ON_ROOT"
+        test "$(id -u)" -eq 0               || die "must be root"
         wait_until __zleep_user_part_done   || die "timeout waiting for parent"
         __zleep_sudo_part
-        rm -f $ZLEEP_ON_ROOT
+        rm -f "$ZLEEP_ON_ROOT"
         return $?
     fi
 }

src/libexec/saturnin-au

 #!/bin/bash
 
-. $(ffoom path)
+. "$(ffoom path)"
 
 ffoo import pretty
 

src/libexec/saturnin-clip

 #!/bin/bash
 
-. $(ffoom path)
+. "$(ffoom path)"
 
 ffoo import inigrep
 ffoo import pretty
     #
     case $1 in
         primary|secondary|clipboard)
-            xclip -o -selection $1   2>/dev/null
+            xclip -o -selection "$1"   2>/dev/null
             ;;
         ALL)
             xclip -o -selection primary   2>/dev/null
     local clipname=$1
     mkdir -p "$STORAGE_DIR" || die "could not create directory for saving"
     local path="$STORAGE_DIR/$(date +%Y%m%d-%H%M%S.clip)"
-    clipln $clipname > "$path"
+    clipln "$clipname" > "$path"
 }
 
 lsclips() {
     #
     # List clips with MIME types and hints
     #
-    local clipname=$1
     local ft hint name
     test -d "$STORAGE_DIR" || return 0
-    ls "$STORAGE_DIR/"*.clip 2>/dev/null \
+    find "$STORAGE_DIR" -name "*.clip" 2>/dev/null \
       | while read name;
         do
-            ft=$(file -b -i $name | cut -d\; -f1)
+            ft=$(file -b -i "$name" | cut -d\; -f1)
             case $ft in
                 text/*)
-                    hint=$(head -c 80 $name | tr '\n' '↵')
+                    hint=$(head -c 80 "$name" | tr '\n' '↵')
                     ;;
                 *)
-                    hint=$(head -c 16 $name | hexdump -C | head -1)
+                    hint=$(head -c 16 "$name" | hexdump -C | head -1)
                     ;;
             esac
-            echos "$(basename $name) || $ft || $hint"
+            echos "$(basename "$name") || $ft || $hint"
         done
 }
 
     local clipname=$1
     local name=$(pick_clip)
     test -n "$name" || return 1
-    cat $STORAGE_DIR/$name | xclip -i -selection $clipname
+    < "$STORAGE_DIR/$name" xclip -i -selection "$clipname"
 }
 
 rm_clip() {
     #
     # Remove single clip of choice
     #
-    local clipname=$1
     local name=$(pick_clip)
     test -n "$name" || return 1
-    rm -f $STORAGE_DIR/$name
+    rm -f "$STORAGE_DIR/$name"
 }
 
 rm_all() {
     #
     test -n "$STORAGE_DIR" || die "storage directory is unset, aborting"
     test -d "$STORAGE_DIR" || return 0
-    find "$STORAGE_DIR" -name "*.clip" | xargs rm -f
+    find "$STORAGE_DIR" -name "*.clip" -print0 | xargs -0 rm -f
     rmdir "$STORAGE_DIR" 2>/dev/null | :
 }
 
     *)      usage                     ;;
 esac done
 
-debug "\$@='$@'"
+debug "\$*='$*'"
 debug -v clipname action
 
 case $action in

src/libexec/saturnin-dmenu

 #!/bin/bash
 
-. $(ffoom path)
+. "$(ffoom path)"
 
 ffoo import inigrep
 ffoo import pretty
     mkusage "[-l|--lines NUM] [--split CHAR] ARGS..."
 }
 
-numbered=false
 lines=10
 maybe_split=cat
 delim=" "
 }
 
 do_split() {
-    cut "-d$delim" -f$field
+    cut "-d$delim" -f"$field"
 }
 
-dmenu -b -i -l $lines $(style) "$@" | $maybe_split
+dmenu -b -i -l "$lines" "$(style)" "$@" | $maybe_split

src/libexec/saturnin-iam

 #!/bin/bash
 
-. $(ffoom path)
+. "$(ffoom path)"
 
 ffoo import inigrep
 ffoo import pretty
 available_commands="afk at back gone ooo wfh undocking zleeping"
 
 usage() {
-    mkusage $available_commands
+    mkusage "$available_commands"
 }
 
 
     #
     if=$(inigrep -p iam.using.if)
     gwmac=$(arp | grep "^gateway\\>.*\\<$if\$" | tr ' ' '\n' | grep :)
-    inigrep -p iam.seeing.gw.$gwmac || echo OUT
+    inigrep -p "iam.seeing.gw.$gwmac" || echo OUT
 }
 
 set_status() {
     # set public status $1 by command in conf file
     #
     local what=$1
-    saturnin_runhook say_$what
-    saturnin_runhook log_$what
+    saturnin_runhook "say_$what"
+    saturnin_runhook "log_$what"
 }
 
 
 
 test -n "$cmd" || usage
 
-echo $available_commands | grep -qw "$cmd" || usage
+echo "$available_commands" | grep -qw "$cmd" || usage
 
 shift
 
-i_am_$cmd $1
+"i_am_$cmd" "$1"

src/libexec/saturnin-kb

 #!/bin/bash
 
-. $(ffoom path)
+. "$(ffoom path)"
 
 ffoo import inigrep
 ffoo import pretty
     local def="$default_layout"
     local nxt=$(
         echo -e "$all\n$all" \
-          | grep -m 1 -A 1 $cur \
+          | grep -m 1 -A 1 "$cur" \
           | tail -1
     )
     test -z "$nxt" && nxt=$def

src/libexec/saturnin-ln

 #!/bin/bash
 
-. $(ffoom path)
+. "$(ffoom path)"
 
 ffoo import inigrep
 ffoo import pretty
     local src=$1
     local dst=$2
     think "linking $src to $dst"
-    rm -f $dst
-    ln -sr $src $dst
+    rm -f "$dst"
+    ln -sr "$src" "$dst"
 }
 
 load() {
-    inigrep -p ln.dir.$1 | expand_tilde
+    inigrep -p "ln.dir.$1" | expand_tilde
 }
 
 while true; do case $1 in

src/libexec/saturnin-menu

 #!/bin/bash
 
-. $(ffoom path)
+. "$(ffoom path)"
 
 ffoo import inigrep
 ffoo import pretty
     mname="$SATURNIN_MENU_MNAME"
 
     # check that menu item exists
-    inigrep -s menu.$mname | grep -q . \
+    inigrep -s "menu.$mname" | grep -q . \
      || die "no such menu: $mname"
 
     test -n "$SATURNIN_MENU_GENERATOR" \
     # then for items as 'item' keys at the same place,
     # finally default 'generator'.
     #
-    inigrep -1 -p menu.$mname.generator | grep . \
+    inigrep -1 -p "menu.$mname.generator" | grep . \
      && return 0
-    inigrep -p menu.$mname.item | grep -m 1 -q . \
-     && printf "inigrep -p menu.$mname.item" \
+    inigrep -p "menu.$mname.item" | grep -m 1 -q . \
+     && echo "inigrep -p menu.$mname.item" \
      && return 0
-    inigrep -1 -p menu._default_.generator | grep . \
+    inigrep -1 -p "menu._default_.generator" | grep . \
      && return 0
     return 1
 }
     # First, look for 'selector' key in menu definition,
     # then a default 'selector'.
     #
-    inigrep -1 -p menu.$mname.selector | grep . \
+    inigrep -1 -p "menu.$mname.selector" | grep . \
      && return 0
-    inigrep -1 -p menu._default_.selector | grep .
+    inigrep -1 -p "menu._default_.selector" | grep .
 }
 
 get_select_args() {
     # First, look for 'select_args' key in menu definition,
     # then a default 'select_args'.
     #
-    inigrep -1 -p menu.$mname.select_args | grep . \
+    inigrep -1 -p "menu.$mname.select_args" | grep . \
      && return 0
-    inigrep -1 -p menu._default_.select_args
+    inigrep -1 -p "menu._default_.select_args"
 }
 
 get_consumer() {
     # First, look for 'consumer' key in menu definition,
     # then a default 'consumer'.
     #
-    inigrep -1 -p menu.$mname.consumer | grep . \
+    inigrep -1 -p "menu.$mname.consumer" | grep . \
      && return 0
-    inigrep -1 -p menu._default_.consumer | grep .
+    inigrep -1 -p "menu._default_.consumer" | grep .
 }
 
 do_generate() {

src/libexec/saturnin-uris

 #!/bin/bash
 
-. $(ffoom path)
+. "$(ffoom path)"
 
 ffoo import inigrep
 ffoo import pretty
     *)  break ;;
 esac done
 
-debug "\$@='$@'"
+debug "\$*='$*'"
 debug -v src
 
 case "$src" in
     args) uri="$(echo "$@" | saturnin_urimagic__scan)" ;;
-    file) uri="$(cat "$file" | saturnin_urimagic__scan)" ;;
+    file) uri="$(<"$file" saturnin_urimagic__scan)" ;;
     xpri) uri="$(clipln pri | saturnin_urimagic__scan)" ;;
     xsec) uri="$(clipln sec | saturnin_urimagic__scan)" ;;
     xclp) uri="$(clipln clp | saturnin_urimagic__scan)" ;;

src/libexec/saturnin-xuris

 
 # launch Uzbl once per each URI in stdin
 
-. $(ffoom path) || exit 3
+. "$(ffoom path)" || exit 3
 ffoo import pretty
 
 SATURNIN_XURIS_NOTIFICATIONS=true
 
 open_from() {
     local list="$1"
-    local count=$(wc -l <$list)
+    local count=$(wc -l <"$list")
 
-    test $count -gt $SATURNIN_XURIS_LIMIT && {
+    test "$count" -gt $SATURNIN_XURIS_LIMIT && {
         notify "too much URIs; giving up: $count > $SATURNIN_XURIS_LIMIT"
         return 1
     }
 
-    test $count -eq 0 && {
+    test "$count" -eq 0 && {
         $SATURNIN_XURIS_ALWAYS_RUN && $SATURNIN_XURIS_BIN &
         return 0
     }
 
-    cat $list \
-      | while read uri;
-        do
-            $SATURNIN_XURIS_BIN "$uri" &
-        done
+    while read uri;
+    do
+        $SATURNIN_XURIS_BIN "$uri" &
+    done < "$list"
 }
 
 while true; do case $1 in
          SATURNIN_XURIS_UNIQ
 
 SATURNIN_XURIS_URI_LIST=$(mktemp -t saturnin-xuris.XXXXXXXX)
-cat | maybe_uniq | grep . >$SATURNIN_XURIS_URI_LIST
+cat | maybe_uniq | grep . >"$SATURNIN_XURIS_URI_LIST"
 
 # choice of URI has been made; we may try to use dmenu
 bash -n <<<"$SATURNIN_XURIS_CHOICE"
 
 debug -v SATURNIN_XURIS_BIN
 
-open_from $SATURNIN_XURIS_URI_LIST
-rm $SATURNIN_XURIS_URI_LIST
+open_from "$SATURNIN_XURIS_URI_LIST"
+rm "$SATURNIN_XURIS_URI_LIST"

tests/TF_HEADER

 #!/bin/sh
 
-echo -n "version: ";
-saturnin --version-semver
+echo "version: $(saturnin --version-semver)"

tests/cli/TF_RUN

 #!/bin/bash
 
-. $TF_DIR/include/subtest.sh
-. $TF_DIR/include/tools.sh
+. "$TF_DIR/include/subtest.sh"
+. "$TF_DIR/include/tools.sh"
 
 tf_enum_subtests() {
     echo usage