Update MKit to v0.0.34

utils/mkit/include/build.sh

     #
     local ftype=$1      # file/builder type
     case $ftype in
-        MKIT_COMMON)    __expand_tokens "tokens" ;;
-        rpmstuff)       __expand_tokens "tokens" "rpmstuff:tokens" ;;
-        debstuff)       __expand_tokens "tokens" "debstuff:tokens" ;;
+        MKIT_COMMON)    __expand_macros "macros" ;;
+        rpmstuff)       __expand_macros "macros" "rpmstuff:macros" ;;
+        debstuff)       __expand_macros "macros" "debstuff:macros" ;;
         *)              die "unknown file type: $ftype" ;;
     esac
 }
 
-__expand_tokens() {
-    #
-    # Read stdin, expanding tokens from sections $@
-    #
-    local script        # sed script cache
-    local section       # each section to expand tokens from
-    local varname       # each token name
-    local varvalue      # each token value
-    script=$(mktemp --tmpdir mkit-tmp.XXXXXXXXXX)
-    {
-        for section in "$@"; do
-            debug_var section
-            ini lskeys "$section" \
-              | while read -r varname; do
-                    varvalue="$(ini 1value "$section:$varname" | __qfs )"
-                    echo "s|$varname|$varvalue|g;"
-                    debug_var varname varvalue
-                done
+__expand_line() {
+    #
+    # Expand macro from $MacroMap in single line $1
+    #
+    # If macro value has multiple lines, repeat original line with
+    # different substitution.
+    #
+    # E.g. if macro value is "foo\nbar" and macro name is __FOO__,
+    # line `see: "__FOO__"` will expand to two lines: `see: "foo"`
+    # and `see: "bar"`.
+    #
+    local line=$1   # line to process
+    local mname     # macro name
+    local mvline    # line of macro value
+    local xline     # expanded line
+    xline=$line
+    for mname in "${!MacroMap[@]}"; do
+        if ! test "${line//$mname}" == "$line"; then
+            xline=$(
+                while IFS= read -r mvline; do
+                    echo "${line//$mname/$mvline}"
+                done <<<"${MacroMap[$mname]}"
+            )
+        fi
+        line=$xline
+    done
+    echo "$xline"
+    return 1
+}
+
+__expand_macros() {
+    #
+    # Read stdin, expanding macros from sections $@
+    #
+    local section       # each section to expand macros from
+    local line          # each line on stdin
+    local mname         # each macro name
+    local -A MacroMap   # macro value map
+    MacroMap[__MKIT_PROJ_NAME__]=$(ini 1value project:name)
+    MacroMap[__MKIT_PROJ_CODENAME__]=$(ini 1value project:codename)
+    MacroMap[__MKIT_PROJ_LICENSE__]=$(ini 1value project:license)
+    MacroMap[__MKIT_PROJ_PKGNAME__]=$(ini 1value project:pkgname)
+    MacroMap[__MKIT_PROJ_TAGLINE__]=$(ini 1value project:tagline)
+    MacroMap[__MKIT_PROJ_MAINTAINER__]=$(ini 1value project:maintainer)
+    MacroMap[__MKIT_PROJ_VCS_BROWSER__]=$(ini 1value project:vcs_browser)
+    MacroMap[__MKIT_PROJ_GIT_LASTHASH__]=$(__cached git_lasthash)
+    MacroMap[__MKIT_PROJ_VERSION__]=$(__cached semver)
+    MacroMap[__MKIT_SELF_VERSION__]=$MKIT_VERSION
+    for section in "$@"; do
+        for mname in $(ini lskeys "$section"); do
+            MacroMap[$mname]=$(ini values "$section:$mname")
         done
-        echo "s|__MKIT_PROJ_NAME__|$(ini 1value project:name | __qfs)|g;"
-        echo "s|__MKIT_PROJ_CODENAME__|$(ini 1value project:codename | __qfs)|g;"
-        echo "s|__MKIT_PROJ_LICENSE__|$(ini 1value project:license | __qfs)|g;"
-        echo "s|__MKIT_PROJ_PKGNAME__|$(ini 1value project:pkgname | __qfs)|g;"
-        echo "s|__MKIT_PROJ_TAGLINE__|$(ini 1value project:tagline | __qfs)|g;"
-        echo "s|__MKIT_PROJ_MAINTAINER__|$(ini 1value project:maintainer | __qfs)|g;"
-        echo "s|__MKIT_PROJ_VCS_BROWSER__|$(ini 1value project:vcs_browser | __qfs)|g;"
-        echo "s|__MKIT_PROJ_GIT_LASTHASH__|$(__cached git_lasthash | __qfs)|g;"
-        echo "s|__MKIT_PROJ_VERSION__|$(__cached semver | __qfs)|g;"
-        echo "s|__MKIT_SELF_VERSION__|$MKIT_VERSION|g;"
-    } >> "$script"
-    sed -f "$script" || die "__expand_tokens failed"
-    rm "$script"
+    done
+    debug_var MacroMap
+    while IFS= read -r line; do
+        __expand_line "$line"
+    done
 }
 
 __guess_ftype() {
 
 _mkit_data() {
     #
-    # Build sampler showing all token values
+    # Build sampler showing all macro values
     #
-    local token
+    local macro
     local section
     local sections
     sections=()
-    ini lskeys tokens | grep -q . && sections=(tokens)
-    sections+=( $(ini lssect | grep ':tokens$') )
+    ini lskeys macros | grep -q . && sections=(macros)
+    sections+=( $(ini lssect | grep ':macros$') )
     {
         echo "(builtin):"
         echo "  x_MKIT_PROJ_NAME__ => '__MKIT_PROJ_NAME__'"
         echo "  x_MKIT_SELF_VERSION__ => '__MKIT_SELF_VERSION__'"
         for section in "${sections[@]}"; do
             echo "$section:"
-            for token in $(ini lskeys "$section"); do
-                echo "  x${token:1} => '$token'"
+            for macro in $(ini lskeys "$section"); do
+                echo "  x${macro:1} => '$macro'"
             done
         done
     } \
-      | __expand_tokens "MKIT_BUILTIN" "${sections[@]}" \
+      | __expand_macros "MKIT_BUILTIN" "${sections[@]}" \
       | sed '/^  x/ s|x|_|'
 }
 

utils/mkit/include/facts.sh

         latest_sha)
             git log -1 --pretty=format:%h HEAD
             ;;
+        latest_cdate)
+            git log -1 --format=%cd --date=unix HEAD
+            ;;
         *)
             warn "unknown git fact asked: $fact_name"
             ;;
     local prerl         # pre-release keyword (from mkit.ini, eg. 'beta')
     local latest_tag    # latest git tag
     local commit        # commit indicator (CURRENT_BRANCH.gHASH)
-    local dirty         # 0 if dirty, 1 if clean
+    local dirty=F       # F if dirty, T if clean
+    local btime         # timestamp or nothing (see $MKIT_TTAG)
     local suffix        # version suffix
     prerl=$(ini 1value project:prerl)
+    case $MKIT_TTAG in
+        none)   btime= ;;
+        btime)  btime=$(date -u +%Y%m%d%H%M%S) ;;
+        ctime)  btime=$(date -d @"$(git_fact latest_cdate)" -u +%Y%m%d%H%M%S) ;;
+    esac
     grep ":" <<<"$prerl" \
      && warn "colon in project:prerl may corrupt version data: $prerl"
     git_present || {
     then    # we are at a later commit than the last tag
         commit="$(git_fact current_branch).g$(git_fact latest_sha)"
     fi
-    git_bool dirty; dirty=$?
-    case "$dirty:$commit" in
-        1:)  suffix=""               ;;
-        0:)  suffix="+dirty"         ;;
-        1:*) suffix="+$commit"       ;;
-        0:*) suffix="+$commit.dirty" ;;
-        *)   suffix=MKIT_BUG
-             warn "MKIT_BUG: bad dirt/commit detection" ;;
+    git_bool dirty && dirty=T
+    case "$dirty:$btime:$commit" in
+        F:*:)   suffix=""                       ;;
+        T::)    suffix="+dirty"                 ;;
+        T:*:)   suffix="+t$btime.dirty"           ;;
+        F::*)   suffix="+$commit"               ;;
+        F:*:*)  suffix="+t$btime.$commit"         ;;
+        T::*)   suffix="+$commit.dirty"         ;;
+        T:*:*)  suffix="+t$btime.$commit.dirty"   ;;
+        *)      suffix=MKIT_BUG
+                warn "MKIT_BUG: bad dirt/commit detection" ;;
     esac
     test -n "$prerl" && suffix="-$prerl$suffix"
     echo "$xyz$suffix"

utils/mkit/include/ini.sh

     done
 }
 
+__ini_grepcmt() {
+    #
+    # Remove comments from INI file on stdin
+    #
+    grep -v '^[[:space:]]*#'
+}
+
 __ini_grepkey() {
     #
     # Read key from a section
     #
     local wnt=$1    # wanted key
     grep '.' \
-      | grep -v '\s*#' \
       | sed -e 's/ *= */=/; s/ +$//; s/^//;' \
       | grep -e "^$wnt=" \
       | cut -d= -f2- \
     local ok=false      # are we in the section?
     local line          # each input line
     grep '.' \
-      | grep -v '\s*#' \
       | while read -r line; do
             case "$line" in
                 \[$wnt\]) ok=true;  continue ;;
     fi
 }
 
+__ini_body() {
+    #
+    # Produce mkit.ini body including INCLUDE
+    #
+    # Note: recursive includes are not supported.
+    #
+    local inc                       # file to include
+    local incre='\[INCLUDE:.*\]'    # include directive regex
+    local iline                     # include directive line
+    if iline=$(grep -m1 -x "$incre" "$MKIT_INI"); then
+        inc=${iline#*:}; inc=${inc%]}
+        grep -vx "$incre" "$inc"
+        grep -vx "$incre" "$MKIT_INI"
+    else
+        cat "$MKIT_INI"
+    fi | __ini_grepcmt
+}
+
 ini() {
     #
     # do ini operation
         1value) fn=__ini_greppath; limit="tail -1" ;;
         *)      die "incorrect use of \`ini()\`"
     esac
-    <"$MKIT_INI" $fn "$arg" | $limit
+    __ini_body | $fn "$arg" | $limit
 }
 
 update_version() {

utils/mkit/include/mkit.sh

     #
     $MKIT_DEBUG || return 0
     local __mkit_debug_var_name__       # variable name to debug
+    local decl                          # declare string
     for __mkit_debug_var_name__ in "$@"; do
         {
-            echo -n "MKIT_DEBUG: ${FUNCNAME[1]}():"
-            echo -n " $__mkit_debug_var_name__"
-            echo -n "='${!__mkit_debug_var_name__}'"
-            echo
+            decl=$(declare -p "$__mkit_debug_var_name__")
+            decl=${decl#declare ?? }
+            echo "MKIT_DEBUG: ${FUNCNAME[1]}(): $decl"
         } >&2
     done
 }

utils/mkit/include/vars.sh

 #
 # Package name
 #
-# Used as base for tarball and in some default tokens.
+# Used as base for tarball and in some default macros.
 #
 MKIT_PROJ_PKGNAME=""
 
+#
+# Add time-based ordinal tag to SemVer build data?
+#
+# Can be 'none', 'ctime' or 'btime'.
+#
+# If 'ctime', devel builds have also timestamp-based tag in format of
+# `t%Y%m%d%H%M%S`, that is, a small character 't' followed by timestamp
+# without non-digit characters.  The timestamps are in UTC, ie. timezones
+# need not apply.  'btime' has the same format, except that it's derived
+# from build time, while 'ctime' is from last commit's commit date.
+#
+# This helps with deploying development builds where packaging system
+# is not SemVer-compliant and makes it hard to install arbitrary version.
+# For example, old yum version (as of RHEL-6) will not let you install
+# version that it deems older than is installed, making it hard to
+# continually upgrade during active development.  While packaging
+# systems have their own rukes (and SemVer says both versions should be
+# considered same) this tag will make it more likely to "win" the build
+# you made later.
+#
+# Note that this does not affect clean builds (ie. builds from clean
+# repo with HEAD corresponding to latest version tag.).
+#
+# Also note that 'btime' makes the version non-deterministic: merely
+# initiating the build a second later will result in different version.
+#
+MKIT_TTAG=${MKIT_TTAG:-ctime}
+
 #
 # This MKit version
 #
-MKIT_VERSION=0.0.29
+MKIT_VERSION=0.0.34

utils/mkit/stub

                 remake_section dist
                 remake_section ENV
                 remake_section roots
-                remake_section tokens
+                remake_section macros
                 remake_section modes
                 remake_section files
             else
                     echo "doc = [ENV:PREFIX]/share/doc/$PackageName"
                 } | reformat_section
                 echo ""
-                echo "[tokens]"
+                echo "[macros]"
                 {
                     echo "__${PackageName^^}_FOO__ = Barr.."
                 } | reformat_section
             echo "    machine should be uder 'src'."
             echo ""
             echo "    Note that during build time, files named ending with"
-            echo "    '.skel' are subject to token expansion, see mkit.ini"
+            echo "    '.skel' are subject to macro expansion, see mkit.ini"
             echo "    section below for details."
             echo ""
             echo " *  *notes* directory - here you shall store notes"
             echo " *  *packaging* directory contains templates that enable"
             echo "    MKit create raw stuffs used to create DEB or RPM"
             echo "    packages.  Similar to '.skel' files in 'src', all files"
-            echo "    here are automatically considered for token expansion,"
+            echo "    here are automatically considered for macro expansion,"
             echo "    no matter how they are named (see mkit.ini section"
             echo "    below)."
             echo ""
             echo "    \`[modes]\` section is your friend.  Permissions here"
             echo "    should be in UNIX octal format."
             echo ""
-            echo " 5. Next, \`[tokens]\` section allows you to define own"
+            echo " 5. Next, \`[macros]\` section allows you to define own"
             echo "    placeholders that will be replaced when your scripts are"
             echo "    built.  Each file in 'src' directory that is named with"
             echo "    '.skel' suffix, and each file from 'packaging' directory"
-            echo "    (no matter its name), can contain one or more of tokens"
-            echo "    defined here, plus range of tokens automatically defined"
-            echo "    by MKit.  During build, these tokens are replaced with"
+            echo "    (no matter its name), can contain one or more of macros"
+            echo "    defined here, plus range of macros automatically defined"
+            echo "    by MKit.  During build, these macros are replaced with"
             echo "    their actual values."
             echo ""
             echo " 6. Less interesting, but important section is \`[dist]\`,"