Update for Shellfu v0.9.x

The new Shellfu brings some large changes.  Among what touches us
directly:

 *  Most global variables were renamed (removing SHELLFU_* prefix).

 *  inigrep API has been revamped and the file merging/guessing
    feature has been dropped; it now belongs to us.

src/bin/app.skel

 . "$(shellfu-get path)" || exit 3
 
 shellfu import exit
-shellfu import inigrep
 shellfu import pretty
 
 #
 # =====BEGIN BUILT PART=====
 #
 
-SHELLFU_INIGREP_PATH="$(
-    inigrep__mkpath \
-        __SATURNIN_CONFIG_USER__/ini.d \
-        __SATURNIN_CONFIG_USER__ \
-        __SATURNIN_CONFIG_LOCAL__ \
-        __SATURNIN_SHARE__/ini.d
-)"
-
 SATURNIN_APP_CODENAME="__MKIT_PROJ_CODENAME__"
 SATURNIN_APP_TAGLINE="__MKIT_PROJ_TAGLINE__"
 SATURNIN_APP_VERSION="__MKIT_PROJ_VERSION__"
 SATURNIN_LIBEXEC="__SATURNIN_LIBEXEC__"
 SATURNIN_LIBEXEC_PREFIX="__MKIT_PROJ_PKGNAME__-"
 SHELLFU_PATH="__SATURNIN_SHELLFU_DIR__"
-SHELLFU_PRETTY_USAGE="subcommand"
+PRETTY_USAGE="subcommand"
+
+shellfu import saturnin
+
+SATURNIN_CONF_PATH="$(
+    saturnin__conf_mkpath \
+        __SATURNIN_CONFIG_USER__/ini.d \
+        __SATURNIN_CONFIG_USER__ \
+        __SATURNIN_CONFIG_LOCAL__ \
+        __SATURNIN_SHARE__/ini.d
+)"
 
 #
 # =====END BUILT PART=====
 #
 
-shellfu import saturnin
-
-export SHELLFU_INIGREP_PATH SHELLFU_PATH SHELLFU_PRETTY_USAGE \
+export SATURNIN_CONF_PATH SHELLFU_PATH PRETTY_USAGE \
        SATURNIN_CACHE_HOME
 
 saturnin__main "$@"

src/libexec/satcmd-echo

 
 . "$(shellfu-get path)" || exit 3
 
-shellfu import inigrep
+shellfu import saturnin
 
-SATCMD_ECHO__PREFIX="${SATCMD_ECHO__PREFIX:-$(inigrep -p "echo.prefix")}"
+SATCMD_ECHO__PREFIX="${SATCMD_ECHO__PREFIX:-$(saturnin__conf "echo.prefix")}"
 
 echo -n "$SATCMD_ECHO__PREFIX"
 echo "$@"

src/shellfu/saturnin.sh

 shellfu import inigrep
 shellfu import pretty
 
+#
+# Path where saturnin__conf should look for files
+#
+# If filename does not contain slash, it is looked up in each
+# (or all, based on strategy--see saturnin__conf() doc) path in this
+# list.  The list is colon-separated and non-dirs as well as
+# empty strings are silently ignored.
+#
+SATURNIN_CONF_PATH="${SATURNIN_CONF_PATH:-}"
+
+#
+# Expected config filename extension (for guessing from path head)
+#
+# If no filename to read is given, saturnin__conf() will guess
+# filename as the path head plus this suffix (e.g. `foo.ini` for
+# `saturnin__conf foo.bar.baz`)
+#
+SATURNIN_CONF_SUFFIX="${SATURNIN_CONF_SUFFIX:-.ini}"
+
+saturnin__conf() {
+    #
+    # inigrep smart loader
+    #
+    # Usage:
+    #   saturnin__conf [-j] [inigrep-query] [-- [file]..]
+    #
+    #
+    # File arguments
+    # ==============
+    #
+    # If omitted, *file* argument is inferred by taking part of
+    # kpath name before first dot and appending value of
+    # `$SATURNIN_CONF_SUFFIX`, (".ini" by default).
+    #
+    # Each *file* argument is then processed as follows:
+    #
+    #  *  `-` (single dash) is interpreted as reading from
+    #     STDIN.
+    #
+    #  *  If argument contains slash, it is expanded as a regular
+    #     path (relative or absolute).
+    #
+    #  *  Otherwise, it is taken as filename and searched for
+    #     in directories given in `$SATURNIN_CONF_PATH`.  (This can
+    #     yield more than one path, which is equivalent as if
+    #     all paths were provided.)
+    #
+    #     Not all files expanded based on `$SATURNIN_CONF_PATH`
+    #     are read by default; reading is governed by "merge
+    #     strategy": the default strategy "first" reads only
+    #     the first existing file.
+    #
+    #     "join" strategy on the other hand, means that any
+    #     files are simply concatenated and prefixed with
+    #     comment (visible only in raw mode) containing path
+    #     to the file.
+    #
+    #     This means that if a section is queried that is
+    #     present in both files, it is effectively concatenated
+    #     as well.
+    #
+    # Following calls are equivalent
+    #
+    #     saturnin__conf foo.bar.baz
+    #     saturnin__conf foo.bar.baz foo.ini
+    #
+    # and both result in reading of key *baz* from section *foo.bar*
+    # in file *foo.ini*, which is selected from *SATURNIN_CONF_PATH*.
+    # Should there be more foo.ini's, the first is selected.
+    # Using `-j` switch
+    #
+    #     saturnin__conf -j foo.bar.baz
+    #
+    # would cause all foo.ini's on *SATURNIN_CONF_PATH* be
+    # concatenated instead.
+    #
+    local ig_mode               # retrieval mode
+    local ig_query              # keypath or section name (when listing keys)
+    local ig_limit              # line limit
+    local files=()              # file specification
+    local Strategy=first        # merge strategy
+    while true; do case $1:$2 in
+        "":*)   break ;;
+        -j:*)   Strategy=join;           shift 1        ;;
+        -1:*)   ig_limit=$1;             shift 1        ;;
+        -e:*.*) ig_mode=$1; ig_query=$2; shift 2; break ;;
+        -r:*.*) ig_mode=$1; ig_query=$2; shift 2; break ;;
+        -K:*)   ig_mode=$1; ig_query=$2; shift 2; break ;;
+        -S:*)   ig_mode=$1; ig_query=""; shift 1; break ;;
+        -P:*)   ig_mode=$1; ig_query=""; shift 1; break ;;
+        .*:*)   warn "bad syntax: $*"; return 2 ;;
+        *.*:*)  ig_mode=-e; ig_query=$1; shift 1; break ;;
+        *)      warn "bad syntax: $*"; return 2 ;;
+    esac done
+    test -n "$ig_mode" || { warn "could not determine inigrep mode"; return 2; }
+    debug -v ig_limit ig_query ig_mode Strategy
+    if test -n "$*";
+    then
+        files=("$@")
+    elif test -n "$ig_query";
+    then
+        files=("${ig_query%%.*}$SATURNIN_CONF_SUFFIX")
+    else
+        warn "dunno what to load"
+        return 2
+    fi
+    debug -v files
+    #shellcheck disable=SC2086
+    _saturnin__conf__load "${files[@]}" | inigrep $ig_limit $ig_mode $ig_query
+}
+
 saturnin__get() {
     #
     # Show Saturnin Internal info by key $1 and exit
     local key=${1#--saturnin-get-}
     case "$key" in
         shellfu-path)   echo "$SHELLFU_PATH"                ;;
-        inigrep-path)   echo "$SHELLFU_INIGREP_PATH"        ;;
+        saturnin-conf-path) echo "$SATURNIN_CONF_PATH"      ;;
         app-git-hash)   echo "$SATURNIN_APP_GIT_HASH"       ;;
         app-version)    echo "$SATURNIN_APP_VERSION"        ;;
         cache-home)     echo "$SATURNIN_CACHE_HOME"         ;;
         libexec)        echo "$SATURNIN_LIBEXEC"            ;;
         libexec-prefix) echo "$SATURNIN_LIBEXEC_PREFIX"     ;;
         *)              warn "unknown devel key: $key"
-                        exit "$SHELLFU_EXIT_USAGE" ;;
+                        exit "$EXIT_USAGE" ;;
     esac
-    exit "$SHELLFU_EXIT_OK"
+    exit "$EXIT_OK"
 }
 
 saturnin__help() {
         saturnin__lssc \
           | sed -e 's/^/    /'
     } | mkhelp -E -f -
-    return "$SHELLFU_EXIT_OK"
+    return "$EXIT_OK"
 }
 
 saturnin__lssc() {
 saturnin__main() {
     local subcommand
     while true; do case $1 in
-        -d|--debug)     export SHELLFU_DEBUG=true; shift   ;;
-        -v|--verbose)   export SHELLFU_VERBOSE=true; shift ;;
+        -d|--debug)     export PRETTY_DEBUG=true; shift   ;;
+        -v|--verbose)   export PRETTY_VERBOSE=true; shift ;;
         --version)      saturnin__version; exit            ;;
         --version-semver) saturnin__get app-version ;;
         --saturnin-get-*) saturnin__get "$1" ;;
         *)              break;                          ;;
     esac done
     subcommand="$1"; shift
-    debug -v SHELLFU_PATH SATURNIN_LIBEXEC SHELLFU_INIGREP_PATH
+    debug -v SHELLFU_PATH SATURNIN_LIBEXEC SATURNIN_CONF_PATH
     case "$subcommand" in
-        conf)               inigrep "$@"    ;;
+        conf)               saturnin__conf "$@" ;;
         help)               saturnin__help ;;
         _ls_subcommands)    saturnin__lssc ;;
         _lsfun)             shellfu-get lsfun ;;
     esac
 }
 
+saturnin__conf_mkpath() {
+    #
+    # Assemble SATURNIN_CONF_PATH from locations $@
+    #
+    # For each location, print colon-delimited list of
+    # directories.  If location ends with "/ini.d", list of
+    # subfolders, sorted by C locale is printed--this allows
+    # for modular configuration.  Otherwise the location
+    # is printed.  Non-existent or non-directory locations
+    # are silently ignored.
+    #
+    local location      # one location argument
+    local path          # one path listed
+    for location in "$@";
+    do
+        test -d "$location" || continue
+        case "$location" in
+            */ini.d)    # modular location--sort subfolders
+                find -L "$location" -mindepth 1 -maxdepth 1 -type d \
+                  | LC_ALL=C sort
+                ;;
+            *)
+                echo "$location"
+                ;;
+        esac
+    done \
+      | _saturnin__nl2colon
+}
+
 saturnin__runhook() {
     #
     # Run custom hook
         warn "unknown subcommand, ignoring hook: $hname"
         return 0
     }
-    hook_code="$(inigrep -j -p "hook.$SATURNIN_SUBCOMMAND.$hname")"
+    hook_code="$(saturnin__conf -j "hook.$SATURNIN_SUBCOMMAND.$hname")"
     debug -v SATURNIN_SUBCOMMAND hook_code hname
     bash -n <<<"$hook_code" || {
         warn "syntax errors, ignoring hook: $hname"
     test -x "$binpath" || {
         warn "invalid sub-command: $subcommand"
         saturnin__help
-        return "$SHELLFU_EXIT_USAGE"
+        return "$EXIT_USAGE"
     }
     SATURNIN_SUBCOMMAND="$subcommand" "$binpath" "$@"
 }
     local maybe_codename=""
     test -n "$SATURNIN_APP_CODENAME" && maybe_codename=" - $SATURNIN_APP_CODENAME"
     echo "$(basename "$0") ($tagline) $SATURNIN_APP_VERSION$maybe_codename"
-    return "$SHELLFU_EXIT_OK"
+    return "$EXIT_OK"
 }
 
 saturnin__wraphook() {
     saturnin__runhook post
     return $es
 }
+
+
+#          #                           that what you see below this line #
+# INTERNAL # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #
+#          #                        use in your code to anger the divine #
+
+_saturnin__conf__merge() {
+    #
+    # Take paths and applying merge strategy, load file(s)
+    #
+    local path
+    while read -r path;
+    do
+        test -f "$path" || continue
+        case $Strategy in
+            first)
+                debug "winner: $path"
+                cat "$path"
+                cat >/dev/null  # throw away rest of paths
+                ;;
+            join)
+                echo "# file: ${path/$HOME/~}"
+                cat "$path" 2>/dev/null
+                ;;
+        esac
+    done
+}
+
+_saturnin__conf__load() {
+    #
+    # Print contents of files specified in $@
+    #
+    # Each argument means possible file candidate.  If candidate
+    # contains slash, it's treated as file path and is printed
+    # directly.  If it's single dash, standard input is copied.
+    #
+    # In all other cases, filename is searched in all elements
+    # of SATURNIN_CONF_PATH; output then depends on chosen $Strategy:
+    # with 'first' strategy, first existing file is printed, with
+    # 'join' strategy. all existing files are printed.
+    #
+    local arg trydir trypath
+    for arg in "$@";
+    do
+        case $arg in
+            -|*/*)      # stdin, or path (with slash)
+                cat "$arg"
+            ;;
+        *)              # name given, find all its incarnations
+            debug -v SATURNIN_CONF_PATH
+            echos "$SATURNIN_CONF_PATH" \
+              | tr ':' '\n' \
+              | while read -r trydir;
+                do
+                    test -n "$trydir" || continue
+                    trypath="$trydir/$arg"
+                    echos "$trypath"
+                done \
+              |  _saturnin__conf__merge
+            ;;
+        esac
+    done
+    true
+}
+
+_saturnin__nl2colon() {
+    #
+    # Convert newline-based list of paths to colon:based:list
+    #
+    # Empty paths must not be included in the resulting list,
+    # so we need to drop them and also get the colons right.
+    #
+    local idx=0     # current item index (zero-based)
+    local path
+    while read -r path;
+    do
+        test -z "$path" && continue
+        test $idx -gt 0 && echo -n ':'
+        echo -n "$path"
+        ((idx++))
+    done
+}

tests/cli/oracle/usage.stderr

-usage: satcmd [-d|-v] command [args...]
-usage: satcmd help
-usage: satcmd --version
+usage:
+  satcmd [-d|-v] command [args...]
+  satcmd help
+  satcmd --version

tests/saturnin-get/TF_RUN

     echo unknown_none
     echo unknown_same
     echo shellfu_path
-    echo inigrep_path
+    echo saturnin_conf_path
     echo app_version
     echo cache_home
     echo libexec
     cat > "$out"
     case "$name" in
         shellfu_path)   grep -q '^/usr/'                  ;;
-        inigrep_path)   grep -q '^/usr/'                  ;;
+        saturnin_conf_path)  tr : '\n' | grep -q '^/usr/' ;;
         app_version)    grep -q '[0-9]'                   ;;
         cache_home)     grep -qx '/home/.*/.cache/satcmd' ;;
         libexec)        grep -q '^/usr/'                  ;;
         unknown_none)   tf_testflt -n "$name" -E "$o_err" -S 2 satcmd --saturnin-get-                ;;
         unknown_same)   tf_testflt -n "$name" -E "$o_err" -S 2 satcmd --saturnin-get---saturnin-get  ;;
         shellfu_path)   satcmd --saturnin-get-shellfu-path    | ckfuzzy ;;
-        inigrep_path)   satcmd --saturnin-get-inigrep-path    | ckfuzzy ;;
+        saturnin_conf_path)   satcmd --saturnin-get-saturnin-conf-path | ckfuzzy ;;
         app_version)    satcmd --saturnin-get-app-version     | ckfuzzy ;;
         cache_home)     satcmd --saturnin-get-cache-home      | ckfuzzy ;;
         libexec)        satcmd --saturnin-get-libexec         | ckfuzzy ;;