Update MKit to v0.0.14

utils/mkit/include/build.sh

 
     # read content of each mandatory file from debian_skel
     #
-    local debian_skel=$(ini 1value debstuff:debian_skel)
-    test -n "$debian_skel" || die "debstuff:debian_skel not specified"
+    local debian_skel=$(ini 1value dist:debstuff)
+    test -n "$debian_skel" || die "dist:debstuff not specified"
     test -d "$debian_skel" || die "debian directory template found: $debian_skel"
     mkdir -p debian/source
     local dfsrc dftgt
     local git_lasthash=$(git_lasthash)
     local dirname=$MKIT_PROJ_PKGNAME-$version
     mkdir -p "$dirname"
-    ini values "lists:dist" | xargs -I DIST_ITEM cp -R DIST_ITEM "$dirname"
+    ini values "dist:tarball" | xargs -I DIST_ITEM cp -R DIST_ITEM "$dirname"
     update_version "$version" "$dirname/mkit.ini"
     mkdir -p "$dirname/.mkit"
     echo -n "$git_lasthash" > "$dirname/.mkit/git_lasthash"
     # Build specfile
     #
     local specname="$MKIT_PROJ_PKGNAME.spec"
-    local specsrc="$(ini 1value "rpmstuff:spec_skel")"
-    test -n "$specsrc" || die "rpmstuff:spec_skel not specified"
+    local specsrc="$(ini 1value "dist:rpmstuff")"
+    test -n "$specsrc" || die "dist:rpmstuff not specified"
     test -f "$specsrc" || die "specfile template not found: $specsrc"
     _build1 "$specsrc" "$specname"
 }

utils/mkit/include/deploy.sh

     #
     local grp=$1
     local src=$2
-    echo "$(_get_root "$grp")/$(ini 1value "files:$grp:$src")"
+    local dst=$3
+    test -n "$dst" || dst=${src##*/}
+    echo "$(_get_root "$grp")/$dst"
 }
 
 _get_root() {
     #
-    # Find out target rooot for group $1
+    # Find out target root for group $1
     #
     local grp="$1"
     local root=$(ini 1value "roots:$grp")
     # Install product
     #
     local dst group mode src
-    ini values "lists:group" \
+    ini lskeys "files" \
+      | sort \
+      | uniq \
       | while read group;
         do
             mode=$(ini 1value "modes:$group")
-            ini lskeys "files:$group" \
-              | while read src;
+            ini values "files:$group" \
+              | while read src dst;
                 do
-                    dst=$(_get_dst "$group" "$src")
+                    dst=$(_get_dst "$group" "$src" "$dst")
                     _deploy_item "$src" "$dst" "$mode"
                 done
         done
     # Uninstall product
     #
     local dst group src
-    ini values "lists:group" \
+    ini lskeys "files" \
+      | sort \
+      | uniq \
       | while read group;
         do
-            ini lskeys "files:$group" \
-              | while read src;
+            ini values "files:$group" \
+              | while read src dst;
                 do
-                    dst=$(_get_dst "$group" "$src")
+                    dst=$(_get_dst "$group" "$src" "$dst")
                     _maybe rm -vrf "$dst"
                 done
         done

utils/mkit/include/facts.sh

     git_present || warn "can't give fact outside git repo: $fact_name"
     case "$fact_name" in
         latest_tag)
-            git log --format="%D" \
+            git log --format="%d" \
               | sed 's/,/\n/g' \
-              | sed 's/^[[:blank:]]*//; ' \
-              | grep -E '^tag: v[[:digit:]]+\.' \
-              | cut -d' ' -f2 \
-              | head -1
+              | sed 's/^[[:blank:]]*//' \
+              | grep -E '^\(?tag' \
+              | tr -cd '[[:digit:]].v\n' \
+              | grep . -m 1
             ;;
         latest_version)
             git_fact latest_tag | git_tag2ver

utils/mkit/include/ini.sh

     local arg=$2
     local fn
     local limit=_ini_cat
-    debug_var op arg
     case $op in
         lskeys) fn=_ini_lskeys   ;;
         sec)    fn=_ini_grepsec  ;;

utils/mkit/include/mkit.sh

 . "$MKIT_DIR/include/release.sh" || die "cannot import release.sh"
 . "$MKIT_DIR/include/ini.sh"    || die "cannot import ini.sh"
 
-MKIT_INI=${MKIT_INI:-mkit.ini}
-MKIT_INI_EXPAND=2
-MKIT_PROJ_PKGNAME=""
-MKIT_DEFAULT_MODE="644"
-
 _valid_targets() {
     #
     # List valid routes
     exit 4
 }
 
+_compver() {
+    #
+    # True if version $1 matches our version
+    #
+    # If our x is 0, check first two fragments, otherwise check just
+    # the x.  Fragments must equal.
+    #
+    local their_ver our_x our_y their_x their_y
+    their_ver="$1"
+    their_x=${their_ver%%.*}
+    their_y=${their_ver##$their_x.}
+    their_y=${their_y%%.*}
+    our_x=${MKIT_VERSION%%.*}
+    our_y=${MKIT_VERSION##$our_x.}
+    our_y=${our_y%%.*}
+    debug_var MKIT_VERSION our_x our_y their_ver their_x their_y
+    test "$their_x" -eq "$our_x" || return 1
+    test "$our_x" -eq 0 && {
+        test "$their_y" = "$our_y"
+        return $?
+    }
+    return 0
+}
+
+_chkiniversion() {
+    #
+    # Check if ini version is supported
+    #
+    # Look for "#mkit version=0.0.0" or similar in first or last
+    # 3 lines of the file; then check if the version is supported.
+    #
+    local ver_line
+    local their_ver
+    ver_line=$(
+        {
+            head -3 "$MKIT_INI"
+            tac "$MKIT_INI" | tail -3
+        } | grep -m 1 -E '^# *mkit +version *= *v?[0-9]+\.[0-9]+\.[0-9]+'
+    )
+    test -n "$ver_line" \
+     || die "version mark ('#mkit version=x.y.z') not found in: $MKIT_INI"
+    their_ver="$(tr -d '[:blank:]v' <<<"${ver_line##*=}")"
+    _compver "$their_ver" \
+     || die "bad mkit.ini version: $their_ver does not match $MKIT_VERSION"
+}
+
 mkit_init() {
     #
     # Do basic initialization
     #
     # Check for ini file and some variables
     #
+    $MKIT_DRY && MKIT_DEBUG=true
     MKIT_PROJ_PKGNAME=$(ini 1value "project:pkgname")
     test -f "$MKIT_INI" || die "cannot find mkit.ini: $MKIT_INI"
+    _chkiniversion
     test -n "$(tr -d '[:space:]' <<<"$MKIT_LOCAL")" \
      || die "MKIT_LOCAL must be non-blank: '$MKIT_LOCAL'"
 }

utils/mkit/include/release.sh

     #
     local rlevel=$1
     local newtag
+    local reldst
 
     _relck git_present
     _relck at_relsrc
     debug_var newtag
     $MKIT_DRY && return
     git tag -m "$(ini 1value project:name) $newtag - $CODENAME" "$newtag"
-    git branch -f "$(ini 1value project:reldst)" "$newtag"
+
+    reldst=$(ini 1value project:reldst)
+    debug_var reldst
+    if test -n "$reldst";
+    then
+        git branch -f "$reldst" "$newtag"
+    fi
 }
 
 _vbump() {

utils/mkit/make

     echo "$@" && exit 9
 }
 
-export MKIT_VERSION=0.0.13
 
-export MKIT_DIR=${MKIT_DIR:-$(dirname "$0")}
-export MKIT_LOCAL=${MKIT_LOCAL:-.mkit}
-export MKIT_DRY=${MKIT_DRY:-false}
-export MKIT_DEBUG=${MKIT_DEBUG:-false}
+#
+# Debug mode (true|false)
+#
+MKIT_DEBUG=${MKIT_DEBUG:-false}
+
+#
+# Default deploy mode for files
+#
+MKIT_DEFAULT_MODE="644"
+
+#
+# Path to MKit dir (where 'include' is)
+#
+MKIT_DIR=${MKIT_DIR:-$(dirname "$0")}
+
+#
+# Dry mode (true|false)
+#
+# Set to true to not install anything. Implies MKIT_DEBUG.
+#
+MKIT_DRY=${MKIT_DRY:-false}
+
+#
+# Path to mkit.ini
+#
+MKIT_INI=${MKIT_INI:-mkit.ini}
+
+#
+# Limit ini expansion depth
+#
+# To avoid endless loops, this value is subtracted each
+# time ini() expands a reference; when zero is reached,
+# no more expansions happen.
+#
+MKIT_INI_EXPAND=2
+
+#
+# Path to MKit local config and temp
+#
+# Typically hidden in project root, here MKit can
+# save its temporary lists.
+#
+MKIT_LOCAL=${MKIT_LOCAL:-.mkit}
+
+#
+# Package name
+#
+# Used as base for tarball and in some default tokens.
+#
+MKIT_PROJ_PKGNAME=""
+
+#
+# This MKit version
+#
+MKIT_VERSION=0.0.14
+
 
 . "$MKIT_DIR/include/mkit.sh" || die "failed to init; check if MKIT_DIR is set properly: $MKIT_DIR"