shellfu/include/config.sh

#!/bin/bash

ffoo import pretty


#
# Expected filename extension (for guessing from -p path head)
#
# If no filename to read is given, cfgrep will guess filename
# as the path head plus this suffix (e.g. `foo.conf` for
# `cfgrep -p foo.bar.baz`)
#
FFOO_CONFIG_SUFFIX="${FFOO_CONFIG_SUFFIX:-.conf}"


__cfgrep__cat() {
    # cat without starting a process
    while IFS= read line;
    do echos "$line"; done
}


__cfgrep__fltcmt() {
    grep -v -e "^[[:space:]]*[#;]" -e "^[[:space:]]*$"
}


__cfgrep__fltkey() {
    # filter values from key=value pair
    while IFS= read line;                           # '  key  =  val  '
    do
        line="${line##*([[:space:]])}"              # line='key  =  val  '
        key="${line%%*([[:space:]])=*}"             # key='key'
        value="${line##$key*([[:space:]])=}"        # value='  val  '
        $strict || value="${value##*([[:space:]])}" # value='val'
        test "$key" = "$wntkey" || continue
        $list || echos "$value"
        $list && echos "$line"
    done
}


__cfgrep__fltsct() {
    # filter per section
    local sct_ok=false
    local line
    while IFS= read line;
    do
        case "$line" in
            \[$wntsct\]) sct_ok=true;               # our section
                         $list && echos $line;      # inform lister
                         continue               ;;
            \[*\])       sct_ok=false; continue ;;  # next section
        esac
        $sct_ok || continue
        $strict || line="${line##*([[:space:]])}"
        echos "$line"
    done
}


__cfgrep__fltlst() {
    local key="__NOKEY__" line="" sct="__NOSCT__"
    while read line;
    do
        case "$line" in
            \[*\]) sct=${line#[}; sct=${sct%]}; key=__NOKEY__     ;;
            *=*)   key="${line%%*([[:space:]])=*}" ;;   # key='key'
            *)     continue ;;                          # whatever
        esac
        case "$listobj:$sct:$key" in
            p*:__NOSCT__:*)         echos "$sct.$key" ;;
            p*:*:__NOKEY__)         continue          ;;
            p*:*:*)                 echos "$sct.$key" ;;
            s*:__NOSCT__:*)         echos "$sct"      ;;
            s*:*:__NOKEY__)         echos "$sct"      ;;
            s*:*:*)                 continue          ;;
            k*:__NOSCT__:__NOKEY__) continue          ;;
            k*:__NOSCT__:*)         echos "$key"      ;;
            k*:*:__NOKEY__)         continue          ;;
            k*:*:*)                 echos "$key"      ;;
        esac
    done
}




__cfgrep__merge() {
    local path
    debug -v strategy
    while read path;
    do
        debug -v path
        case $strategy in
            first)
                local winner
                if test -f "$path";
                then
                    debug "winner: $path"
                    cat "$path"
                    cat >/dev/null  # throw away rest of paths
                fi
                ;;
            join)
                debug -v path
                echo "# file: ${path/$HOME/~}"
                cat "$path" 2>/dev/null
                ;;
        esac
    done
}


__cfgrep__load() {
    if test -z "$1";
    then                # guess filename from section head
        local guess="${wntsct%%.*}$FFOO_CONFIG_SUFFIX"
        debug -v guess
        __cfgrep__load "$guess"
    fi
    local arg trydir trypath
    for arg in "$@";
    do
        case $arg in
            -|*/*)      # stdin, or path (with slash)
                debug -v arg
                cat "$arg"
            ;;
        *)              # name given, find all its incarnations
            debug -v FFOO_CONFIG_PATH
            echos "$FFOO_CONFIG_PATH" \
              | tr ':' '\n' \
              | while read trydir;
                do
                    test -n "$trydir" || continue
                    trypath="$trydir/$arg"
                    debug -v trypath
                    echos "$trypath"
                done \
              |  __cfgrep__merge
            ;;
        esac
    done
    true
}


cfgrep() {
    #
    # A flexible (not just) .conf/.ini file reader
    #
    # Usage:
    #   cfgrep [-S] [-1] [-j] [-s section] [-k key] [file...]
    #   cfgrep [-S] [-1] [-j] [-p path] [file...]
    #
    #
    # Selection
    # =========
    #
    # Probably most apparent use case is selection of key from
    # a section of INI file.  This can be achieved using
    # *path*, which is equivalent to providing both *key* and
    # *section* (i.e. `-p section.key` is the same as
    # `-s section -k key`).
    #
    # However, you can also provide only *section* to select
    # only that section (leaving any key=value pairs intact),
    # or provide only *key* to select only that key from *all*
    # sections in file (if there are any).  This in fact extends
    # use of this function beyond just INI-like format: if you
    # are brave enough, you could e.g. query a shell script for
    # a variable assignment (i.e. key=value pair).
    #
    # If suitable key is found at multiple lines, all values
    # are printed, unless you provided *-1* option.  This allows
    # for creating multi-line values.
    #
    # Leading/trailing spaces and empty lines are removed from
    # output by default, but strict mode (*-S* or *--strict*
    # switch) changes this si that values after `=` are left
    # intact.  Using strict mode when not selecting key or
    # section results in preserving empty lines and comments
    # as well.
    #
    #
    # File arguments
    # ==============
    #
    # Each *file* argument is processed as follows:
    #
    #  *  `-` (single dash), it is interprerted as reding from
    #     STDIN.
    #
    #  *  If argument contains slash, it is expanded as a regular
    #     path.
    #
    #  *  Otherwise, it is taken as filename and searched for
    #     in directories given in `$FFOO_CONFIG_PATH`.  (This can
    #     yield more than one path, which is equivalent as if
    #     all paths were provided.)
    #
    #     Not all files expanded based on `$FFOO_CONFIG_PATH`
    #     are read by default; reading is governed by "merge
    #     strategy": the default strategy "first" reads only
    #     the first existing file.  "join" strategy means
    #     that any files are simply concatenated and prefixed
    #     with comment containing path to the file, which can
    #     be observed in strict mode.  (This means that if a
    #     section is queried that is present in both files,
    #     it is effectively concatenated as well.
    #
    #     The merge strategy can be specified using parameter
    #     `--merge-strategy`, while `-j` or `--join` is a
    #     shorthand for `--merge-strategy join`
    #
    # Without *file* given at all, same procedure is used as in
    # case of filename without slash, except that *file* argument
    # is inferred by taking part of section name before first
    # dot and adding `$FFOO_CONFIG_SUFFIX`, (".conf" by default).
    # This allows for creating relatively rich config value
    # structure it divided in several files (e.g. by component)
    # but accessing them with as little typing as possible.
    #
    local wntsct=""
    local wntkey=""
    local list=false
    local listobj="paths"
    local strict=false
    local sct_ok=true
    local one_line=false
    local grepex="."  # i.e. throw away empty lines
    local strategy="first"
    while true; do case $1 in
        --)                                                       break   ;;
        -1|--one-line) one_line=true;                             shift 1 ;;
        -j|--join)     strategy="join";                           shift 1 ;;
        -k|--key)      wntkey="$2";                               shift 2 ;;
        -p|--path)     wntkey="${2##*.}"; wntsct="${2%.$wntkey}"; shift 2 ;;
        -s|--section)  wntsct="$2"; sct_ok=false;                 shift 2 ;;
        -S|--strict)   strict=true;                               shift 1 ;;
        -l)            list=true; listobj=paths;                  shift 1 ;;
        -L|--list)     list=true; listobj=$2;                     shift 2 ;;
        --merge-strategy) strategy="$2";                          shift 2 ;;
        *)                                                        break   ;;
    esac done
    case "$strategy" in
        first|join)                                   : ;;
        *) warn "invalid merge strategy: $strategy"; return 2 ;;
    esac
    case $listobj in
        p|paths)    : ;;
        k|keys)     : ;;
        s|sections) : ;;
        *) warn "invalid object type to list: $listobj" ;;
    esac
    fltsct=__cfgrep__cat
    fltkey=__cfgrep__cat
    fltcmt=__cfgrep__fltcmt
    fltlst=__cfgrep__cat
    limit_line=__cfgrep__cat
    test -n "$wntsct" && fltsct=__cfgrep__fltsct
    test -n "$wntkey" && fltkey=__cfgrep__fltkey
    $list && fltlst=__cfgrep__fltlst
    $one_line && limit_line="tail -1"
    $strict && grepex=""
    $strict && fltcmt=__cfgrep__cat
    debug -v wntkey wntsct list listobj
    debug "\$@='$@'"
    local restore_extglob=$(shopt -p extglob)
    shopt -s extglob
    __cfgrep__load "$@" \
        | $fltcmt \
        | $fltsct \
        | $fltkey \
        | $fltlst \
        | $limit_line \
        | grep "$grepex"
    $restore_extglob
}