Remove old Saturnin body

Saturnin Shellfu module used to be embedded into the repo; now it lives
its own life (we already have it in dependencies).  All the app needs is
meta-command and scripts.

src/shellfu/saturnin.sh

@@ -1,410 +0,0 @@
-#!/bin/bash
-
-shellfu import exit
-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: $*"; _saturnin__conf_usage ;;
-        *.*:*)  ig_mode=-e; ig_query=$1; shift 1; break ;;
-        --help:*) _saturnin__conf_usage -e 0                 ;;
-        *)      warn "bad syntax: $*"; _saturnin__conf_usage ;;
-    esac done
-    test -n "$ig_mode" || { warn "could not determine inigrep mode"; _saturnin__conf_usage; }
-    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"
-        _saturnin__conf_usage
-    fi
-    debug -v files
-    #shellcheck disable=SC2086
-    _saturnin__conf__load "${files[@]}" | inigrep $ig_limit $ig_mode "$ig_query"
-    return "${PIPESTATUS[0]}"
-}
-
-saturnin__get() {
-    #
-    # Show Saturnin Internal info by key $1 and exit
-    #
-    # Key $1 can be whole `--saturnin-get-stuff` argument or just
-    # the part after `--saturnin-get-`.
-    #
-    # This is aimed to help debugging and testing the app (or
-    # Saturnin itself) by showing packaging and deployment related
-    # info.
-    #
-    local key=${1#--saturnin-get-}
-    case "$key" in
-        shellfu-path)   echo "$SHELLFU_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 "$EXIT_USAGE" ;;
-    esac
-    exit "$EXIT_OK"
-}
-
-saturnin__lssc() {
-    #
-    # List subcommands
-    #
-    echo conf
-    find "$SATURNIN_LIBEXEC" \
-        -mindepth 1 \
-        -maxdepth 1 \
-        -executable \
-      | sed -e "s|^.*/||; s|^$SATURNIN_LIBEXEC_PREFIX||" \
-      | sort
-}
-
-saturnin__main() {
-    local subcommand
-    while true; do case $1 in
-        -d|--debug)     export PRETTY_DEBUG=true;   shift ;;
-        -v|--verbose)   export PRETTY_VERBOSE=true; shift ;;
-        -h|--help)      saturnin__usage -e 0;       exit  ;;
-        --version)      saturnin__version;          exit  ;;
-        --version-semver) saturnin__get app-version ;;
-        --saturnin-get-*) saturnin__get "$1"        ;;
-        -*)             saturnin__usage;            ;;
-        --*)            saturnin__usage;            ;;
-        --)             shift; break                ;;
-        "")             saturnin__usage;            ;;
-        *)              break;                      ;;
-    esac done
-    subcommand="$1"; shift
-    debug -v SHELLFU_PATH SATURNIN_LIBEXEC SATURNIN_CONF_PATH
-    case "$subcommand" in
-        conf)    saturnin__conf "$@"                ;;
-        _ls_sc)  saturnin__lssc                     ;;
-        _lsfun)  shellfu-get lsfun                  ;;
-        _lsmod)  shellfu-get lsmod                  ;;
-        *)       saturnin__runsc "$subcommand" "$@" ;;
-    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
-    #
-    local hname="$1"
-    local hook_code
-    test -n "$SATURNIN_SUBCOMMAND" || {
-        warn "unknown subcommand, ignoring hook: $hname"
-        return 0
-    }
-    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"
-        return 0
-    }
-    eval "$hook_code"
-}
-
-saturnin__runsc() {
-    #
-    # Run subcommand $SATURNIN_SUBCOMMAND
-    #
-    local subcommand="$1"; shift
-    local binpath   # path to subcommand's binary
-    binpath+="$SATURNIN_LIBEXEC/"
-    binpath+="$SATURNIN_LIBEXEC_PREFIX$subcommand"
-    debug -v binpath
-    debug "\$*='$*'"
-    test -x "$binpath" || {
-        warn "invalid sub-command: $subcommand"
-        saturnin__usage
-    }
-    SATURNIN_SUBCOMMAND="$subcommand" "$binpath" "$@"
-}
-
-saturnin__usage() {
-    #
-    # Show usage message and exit
-    #
-    #shellcheck disable=SC2046
-    mkusage "$@"                                            \
-            "[options] COMMAND [ARG...]"                    \
-        -o                                                  \
-            "-d, --debug    turn on debugging"              \
-            "-h, --help     show this help message and exit"\
-            "-v, --verbose  turn on verbosity"              \
-            "--version      show version and exit"          \
-        -c                                                  \
-            $(saturnin__lssc)
-}
-
-saturnin__version() {
-    #
-    # Print version info
-    #
-    local tagline=${SATURNIN_APP_TAGLINE:-Some app with default tagline}
-    local maybe_codename=""
-    test -n "$SATURNIN_APP_CODENAME" && maybe_codename=" - $SATURNIN_APP_CODENAME"
-    echo "$(basename "$0") ($tagline) $SATURNIN_APP_VERSION$maybe_codename"
-    return "$EXIT_OK"
-}
-
-saturnin__wraphook() {
-    #
-    # Wrap command "$@" in hooks
-    #
-    # Run pre hook, then "$@", then post hook.  Always exit
-    # with status of "$@", even if hooks fail.  Ignore
-    # post-hook if "$@" failed.
-    #
-    local es=0
-    saturnin__runhook pre
-    "$@" || return $?
-    es=$?
-    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
-    local found=false
-    while read -r path;
-    do
-        test -f "$path" || continue
-        found=true
-        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
-    $found
-}
-
-_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 es
-    es=0
-    for arg in "$@";
-    do
-        case $arg in
-            -|*/*)      # stdin, or path (with slash)
-                cat "$arg" || es=3
-            ;;
-        *)              # 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; es=$?
-            ;;
-        esac
-    done
-    return $es
-}
-
-_saturnin__conf_usage() {
-    #
-    # Show usage message and exit
-    #
-    PRETTY_USAGE="self=${0##*/} conf" \
-    mkusage "$@"                                                               \
-            "[options] [-e] SECTION.KEY [FNAME]"                               \
-            "[options] -r SECTION.KEY [FNAME]"                                 \
-            "[options] -K SECTION [FNAME]"                                     \
-            "[options] -P FNAME"                                               \
-            "[options] -S FNAME"                                               \
-        --                                                                     \
-            "Use inigrep to query config files."                               \
-        -o                                                                     \
-            "-j     join all files before applying query"                      \
-            "-1     ensure single line is returned"                            \
-        -c                                                                     \
-            "-e     use normal mode (default)"                                 \
-            "-r     use raw mode (preserves RHS whitespace and some comments)" \
-            "-K     list available keys in SECTION"                            \
-            "-S     list available sections in FNAME"                          \
-            "-P     list available keypaths (SECTION.KEY) in FNAME"            \
-        --                                                                     \
-            "FNAME is filename, which is then searched on all paths specified" \
-            "in SATURNIN_CONF_PATH and depending on -j parameter, first one"   \
-            "wins or all are joined.  If FNAME contains slash, this search is" \
-            "not done and FNAME is taken as path to file that is then queried."\
-            ""                                                                 \
-            "If FNAME is omitted, it is inferred from SECTION (e.g. .'foo.ini'"\
-            "if 'foo.bar' was section name; note that section name may contain"\
-            "dot)."
-}
-
-_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
-}