Update MKit to v0.0.40

mkit.ini

     share   = src/help
     share   = src/complete
 
-#mkit version=0.0.35
+#mkit version=0.0.40

packaging/debian/control

  shellfu-bash-saturnin (<< __VDEP_SATURNIN_LT__),
 Description: __MKIT_PROJ_TAGLINE__
 
-# control file built with MKit __MKIT_SELF_VERSION__
+# control file built with MKit __MKIT_MKIT_VERSION__

packaging/template.spec

 
 %changelog
 
-# specfile built with MKit __MKIT_SELF_VERSION__
+# specfile built with MKit __MKIT_MKIT_VERSION__

utils/mkit/include/build.sh

     local line          # each line on stdin
     local mname         # each macro name
     local -A MacroMap   # macro value map
+    MacroMap[__MKIT_MKIT_VERSION__]=$MKIT_VERSION
     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_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_GIT_LASTSUMMARY__]=$(__cached git_lastsummary)
     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")
     #
     local file=$1
     mkdir -p "$MKIT_LOCAL"
-    echo "$file" >> "$MKIT_LOCAL/built.lst"
+    echo "1:$file" >> "$MKIT_LOCAL/built.lst"
 }
 
 _mkit_data() {
     sections+=( $(ini lssect | grep ':macros$') )
     {
         echo "(builtin):"
+        echo "  x_MKIT_MKIT_VERSION__ => '__MKIT_MKIT_VERSION__'"
         echo "  x_MKIT_PROJ_NAME__ => '__MKIT_PROJ_NAME__'"
         echo "  x_MKIT_PROJ_CODENAME__ => '__MKIT_PROJ_CODENAME__'"
         echo "  x_MKIT_PROJ_LICENSE__ => '__MKIT_PROJ_LICENSE__'"
         echo "  x_MKIT_PROJ_MAINTAINER__ => '__MKIT_PROJ_MAINTAINER__'"
         echo "  x_MKIT_PROJ_VCS_BROWSER__ => '__MKIT_PROJ_VCS_BROWSER__'"
         echo "  x_MKIT_PROJ_GIT_LASTHASH__ => '__MKIT_PROJ_GIT_LASTHASH__'"
+        echo "  x_MKIT_PROJ_GIT_LASTSUMMARY__ => '__MKIT_PROJ_GIT_LASTSUMMARY__'"
         echo "  x_MKIT_PROJ_VERSION__ => '__MKIT_PROJ_VERSION__'"
-        echo "  x_MKIT_SELF_VERSION__ => '__MKIT_SELF_VERSION__'"
         for section in "${sections[@]}"; do
             echo "$section:"
             for macro in $(ini lskeys "$section"); do
     #
     # Clean up tree after building
     #
-    test -f "$MKIT_LOCAL/built.lst" && {
-        <"$MKIT_LOCAL/built.lst" grep -v -e '\.\.' -e ^/ \
-          | xargs -r rm -rf
-        rm -f "$MKIT_LOCAL/built.lst"
-        rmdir --ignore-fail-on-non-empty "$MKIT_LOCAL"
-    }
+    local path
+    local line
+    local depth
+    test -f "$MKIT_LOCAL/built.lst" || return 0
+    {
+        cat "$MKIT_LOCAL/built.lst"
+        echo "1:$MKIT_LOCAL/built.lst"
+        echo "1:$MKIT_LOCAL"
+    } \
+      | grep -v -e '\.\.' -e ^/ -e '^~' \
+      | while IFS=: read -r depth path; do
+            test -e "$path" || continue
+            case $depth in
+                1)  warn "removing: $path"
+                    test -d "$path" \
+                     && rmdir -p --ignore-fail-on-non-empty "$path"
+                    test -f "$path" && rm "$path"
+                    ;;
+                r)  warn "removing recursively: $path"
+                    rm -r "$path"
+                    ;;
+                *)  warn "invalid built.lst format!"
+                    ;;
+            esac
+        done
     true
 }
 

utils/mkit/include/deploy.sh

         find "$src" -type f \
           | while read -r item; do
                 [[ $item =~ .skel$ ]] \
-                 && grep -q "${item%.skel}" "$MKIT_LOCAL/built.lst" \
+                 && grep -qe "${item%.skel}" "$MKIT_LOCAL/built.lst" \
                  && continue
                 __deploy_item "$item" "$dst${item#$src}" "$mode"
             done

utils/mkit/include/facts.sh

     git_bool dirty && echo -n ".dirty"
 }
 
+git_lastsummary() {
+    #
+    # Show last commit summary
+    #
+    # We can't do it outside git repo (or without git) but we should
+    # not be asked to; targets that don't require git should make use
+    # of cache built by dist target.
+    #
+    git_present || {
+        echo UNKNOWN_SUMMARY
+        warn "no git present; could not determine last summary"
+        return 3
+    }
+    git_bool dirty && {
+        echo "(index is dirty)"
+        return
+    }
+    git log -1 --format=oneline HEAD \
+      | cut -d' ' -f2-
+}
+
 semver() {
     #
     # Build proper SemVer version string
     local xyz           # base version string
     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=F       # F if dirty, T if clean
-    local btime         # timestamp or nothing (see $MKIT_TTAG)
+    local brname        # current branch name
+    local ghash         # current commit short hash
+    local is_tagged=T   # T if tagged (clean, no metadata), F if devel
+    local is_dirty=F    # F if dirty, T if clean
+    local stamp         # timestamp or nothing (see $MKIT_TSTAMP)
     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) ;;
+    case $MKIT_TSTAMP in
+        none)   stamp= ;;
+        btime)  stamp=$(date -u +%Y%m%d%H%M%S) ;;
+        ctime)  stamp=$(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"
     esac
     if ! git describe --tags --exact-match HEAD >&/dev/null;
     then    # we are at a later commit than the last tag
-        commit="$(git_fact current_branch).g$(git_fact latest_sha)"
+        is_tagged=F
+        brname=$(git_fact current_branch | sed 's/[^[:alnum:]]/_/g')
+        ghash=$(git_fact latest_sha)
     fi
-    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"   ;;
+    git_bool dirty && is_dirty=T
+    case "$is_dirty:$is_tagged:$stamp" in
+        F:T:*)  suffix=""                                 ;;
+        T:T:)   suffix="+dirty"                           ;;
+        T:T:*)  suffix="+t$stamp.dirty"                   ;;
+        F:F:)   suffix="+$brname.g$ghash"                 ;;
+        F:F:*)  suffix="+t$stamp.$brname.g$ghash"         ;;
+        T:F:)   suffix="+$brname.g$ghash.dirty"           ;;
+        T:F:*)  suffix="+t$stamp.$brname.g$ghash.dirty"   ;;
         *)      suffix=MKIT_BUG
                 warn "MKIT_BUG: bad dirt/commit detection" ;;
     esac

utils/mkit/include/ini.sh

     #
     local line      # each line
     while read -r line; do
-        printf -- "%s\n" "$line"
+        printf -- '%s\n' "$line"
     done
 }
 
     # Expand reference value (prefix only)
     #
     local line      # each input line
-    local suffix    # tail of the line
-    local ref       # reference
-    local value     # value if reference
     while read -r line; do                  # [foo:bar]/path
-        suffix="${line#\[*\]}"              # /path
-        ref="${line%$suffix}"               # [foo:bar]
-        ref="${ref%\]}"                     # [foo:bar
-        ref="${ref#\[}"                     # foo:bar
-        value="$(ini 1value "$ref")"        # foo_bar_value
-        printf -- "%s\n" "$value$suffix"    # foo_bar_value/path
+        __ini_expandln "$line"
     done
 }
 
+__ini_expandln() {
+    #
+    # Fully expand references in line $1
+    #
+    local line_orig=$1          # original line
+    local line_todo=$line_orig  # current state
+    local line_done             # next state
+    local Depth=0               # current depth
+    local MaxDepth=10           # maximum depth
+    while true; do
+        ((Depth++))
+        debug_var line_todo
+        test "$Depth" -le "$MaxDepth" || {
+            warn "expansion error: reached maximum depth: $Depth > $MaxDepth"
+            warn "    original line: $line_orig"
+            warn "    expanded line: $line_todo"
+            return 3
+        }
+        line_done=$(__ini_expandln_once "$line_todo")
+        debug_var line_done
+        test "$line_done" == "$line_todo" && break
+        line_todo=$line_done
+    done
+    echo "$line_done"
+}
+
+__ini_expandln_once() {
+    #
+    # Run through line $1 once and replace all references
+    #
+    local line=$1   # line to expand
+    local ref       # full reference (incl. brackets)
+    local ipath     # just ini path from ^^ (stripped brackets)
+    local value     # value of reference
+    local refs=()   # all references found in line
+    mapfile -t refs <<<"$(grep -Eo '[[][^]]+[]]' <<< "$line_todo")"
+    debug_var refs
+    for ref in "${refs[@]}"; do
+        test -n "$ref" || continue
+        ipath=${ref#[}; ipath=${ipath%]}
+        value=$(ini 1value "$ipath")
+        debug_var line ref ipath value
+        line=$(sed "s|\\[$ipath\\]|$value|" <<<"$line")
+    done
+    echo "$line"
+}
+
 __ini_grepcmt() {
     #
     # Remove comments from INI file on stdin
                 \[*\])    ok=false; continue ;;
             esac
             $ok || continue
-            printf -- "%s\n" "$line"
+            printf -- '%s\n' "$line"
         done \
       | sed -e 's/ *= */=/; s/ +$//; s/^//;'
 }
     #
     # List all section names
     #
-    local arg=$1    # unused argument
     grep -x '\[.*\]' | sed 's/^.//; s/.$//'
 }
 
     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
+    if iline=$(grep -m1 -xe "$incre" "$MKIT_INI"); then
         inc=${iline#*:}; inc=${inc%]}
-        grep -vx "$incre" "$inc"
-        grep -vx "$incre" "$MKIT_INI"
+        grep -vxe "$incre" "$inc"
+        grep -vxe "$incre" "$MKIT_INI"
     else
         cat "$MKIT_INI"
     fi | __ini_grepcmt

utils/mkit/include/release.sh

         at_relsrc)
             oracle=$(ini 1value project:relsrc)
             git_fact current_branch \
-              | grep -qFx "$oracle" \
+              | grep -qFxe "$oracle" \
              || die "you are not on release source branch: $oracle"
             ;;
         not_dirty)
         ini_version)
             oracle=$(git_fact latest_version | __bump_version "$rlevel")
             ini 1value project:version  \
-              | grep -qFx "$oracle" \
+              | grep -qFxe "$oracle" \
              || die "new version not in mkit.ini: $oracle"
             ;;
         *)
     git add mkit.ini \
       || die "failed to add mkit.ini to the index"
     cache=$(mktemp -t "mkit._vbump_gitmsg.XXXXXXXX")
-    _vbump_gitmsg > "$cache"
+    _vbump_gitmsg "$nextver" > "$cache"
     git commit -e -F "$cache"   # note: reading from stdin will break vim
     rm "$cache"
 }
     #
     # Compose git message template for 'Bump version' commit
     #
-    echo "Bump version"
+    local nextver=$1
+    echo "Bump version to $nextver"
     echo ""
     echo "Overview of changes:"
     echo ""

utils/mkit/include/vars.sh

 # 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
+# systems have their own rules (and SemVer says both versions should be
 # considered same) this tag will make it more likely to "win" the build
 # you made later.
 #
 # 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}
+MKIT_TSTAMP=${MKIT_TSTAMP:-ctime}
 
 #
 # This MKit version
 #
-MKIT_VERSION=0.0.35
+MKIT_VERSION=0.0.40

utils/mkit/stub

             echo ''
             echo '%changelog'
             echo ''
-            echo '# specfile built with MKit __MKIT_SELF_VERSION__'
+            echo '# specfile built with MKit __MKIT_MKIT_VERSION__'
             ;;
 
         packaging/debian/copyright)
             echo 'Description: __MKIT_PROJ_NAME__ - __MKIT_PROJ_TAGLINE__'
             echo ' MKIT_STUB_DESCRIPTION'
             echo ''
-            echo '# control file built with MKit __MKIT_SELF_VERSION__'
+            echo '# control file built with MKit __MKIT_MKIT_VERSION__'
             ;;
 
         packaging/debian/changelog)
     esac
     updating && init_from_existing
     if test -n "$License"; then
-        known_licenses | grep -qxF "$License" \
+        known_licenses | grep -qxFe "$License" \
          || die "unknown license (use -L to get list): $License"
         MkLicense=true
     fi