Update MKit to v0.0.28

utils/mkit/include/build.sh

 mkit_import facts
 
 
-_build1() {
+__build1() {
     #
     # Process one skeleton $1 of type $3 (or guessed) to path $2
     #
     local dstpath=$2    # destination meaty animal path
     local ftype=$3      # file/builder type
     test -n "$dstpath"  || dstpath=${srcpath%.skel}
-    test -n "$ftype"    || ftype=$(_guess_ftype "$dstpath")
+    test -n "$ftype"    || ftype=$(__guess_ftype "$dstpath")
     debug_var srcpath dstpath ftype
-    <"$srcpath" _build1_ftype "$ftype" >"$dstpath"
-    mkdir -p "$MKIT_LOCAL"
-    echo "$dstpath" >> "$MKIT_LOCAL/built.lst"
+    <"$srcpath" __build1_ftype "$ftype" >"$dstpath"
+    rec_built "$dstpath"
 }
 
-_build1_ftype() {
+__build1_ftype() {
     #
     # Build a file of type $1; fom stdin to stdout
     #
     local ftype=$1      # file/builder type
     case $ftype in
-        MKIT_COMMON)    _expand_tokens "tokens" ;;
-        markdown)       _expand_includes | _expand_tokens "tokens" ;;
-        rpmstuff)       _expand_tokens "tokens" "rpmstuff:tokens" ;;
-        debstuff)       _expand_tokens "tokens" "debstuff:tokens" ;;
+        MKIT_COMMON)    __expand_tokens "tokens" ;;
+        rpmstuff)       __expand_tokens "tokens" "rpmstuff:tokens" ;;
+        debstuff)       __expand_tokens "tokens" "debstuff:tokens" ;;
         *)              die "unknown file type: $ftype" ;;
     esac
 }
 
-_expand_includes() {
-    #
-    # Expand include directives
-    #
-    # Expand e.g. `<!-- include4: foo.sh -->` to include code of foo.sh
-    #
-    perl -we '
-        use strict;
-        my $text;
-        while (<>) {
-            chomp;
-            if (m/<!-- include4: (\S+) -->/) {
-                open my $fh, $1 or warn "cannot find: $1";
-                my $text = do { local($/); <$fh> };
-                close $fh;
-                $text =~ s/^(.)/    $1/gm;
-                chomp $text;
-                print "$text\n";
-            } else {
-                print "$_\n";
-            }
-        }
-    '
-}
-
-_expand_tokens() {
+__expand_tokens() {
     #
     # Read stdin, expanding tokens from sections $@
     #
             debug_var section
             ini lskeys "$section" \
               | while read -r varname; do
-                    varvalue="$(ini 1value "$section:$varname" | _qfs )"
+                    varvalue="$(ini 1value "$section:$varname" | __qfs )"
                     echo "s|$varname|$varvalue|g;"
                     debug_var varname varvalue
                 done
         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__|$(git_lasthash | _qfs)|g;"
-        echo "s|__MKIT_PROJ_VERSION__|$(semver | _qfs)|g;"
+        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__|$(git_lasthash | __qfs)|g;"
+        echo "s|__MKIT_PROJ_VERSION__|$(semver | __qfs)|g;"
         echo "s|__MKIT_SELF_VERSION__|$MKIT_VERSION|g;"
     } >> "$script"
-    sed -f "$script" || die "_expand_tokens failed"
+    sed -f "$script" || die "__expand_tokens failed"
     rm "$script"
 }
 
-_guess_ftype() {
+__guess_ftype() {
     #
     # Guess file type from destination path $1
     #
     local dstpath=$1    # destination path
     case $dstpath in
-        *.md) echo markdown    ;;
         *)    echo MKIT_COMMON ;;
     esac
 }
 
-_qfs() {
+__qfs() {
     #
     # Quote for our sed scipt's RHS
     #
     '
 }
 
+_mkit_data() {
+    #
+    # Build sampler showing all token values
+    #
+    local token
+    local section
+    local sections
+    sections=()
+    ini lskeys tokens | grep -q . && sections=(tokens)
+    sections+=( $(ini lssect | grep ':tokens$') )
+    {
+        echo "(builtin):"
+        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_PKGNAME__ => '__MKIT_PROJ_PKGNAME__'"
+        echo "  x_MKIT_PROJ_TAGLINE__ => '__MKIT_PROJ_TAGLINE__'"
+        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_VERSION__ => '__MKIT_PROJ_VERSION__'"
+        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'"
+            done
+        done
+    } \
+      | __expand_tokens "MKIT_BUILTIN" "${sections[@]}" \
+      | sed '/^  x/ s|x|_|'
+}
+
 build() {
     #
     # Add meat to all skeletons
     #
     local srcpath   # each source path
-    find -type f -name '*.skel' \
+    semver >/dev/null
+    find . -type f -name '*.skel' \
      | while read -r srcpath; do
-           _build1 "$srcpath"
+           __build1 "$srcpath"
        done
 }
 
-build_manpages() {
-    #
-    # Build manpages using ronn
-    #
-    local manfile   # each manual file listed in '[files:man]'
-    local mdfile    # each source markdown file
-    if command -v ronn >/dev/null; then
-        ini lskeys "files:man" \
-          | while read -r manfile; do
-                mdfile="$manfile.md"
-                ronn -r "$mdfile"
-                mkdir -p "$MKIT_LOCAL"
-                echo "$manfile" >> "$MKIT_LOCAL/built.lst"
-            done
-    else
-        echo "ronn is not installed"
-        return 1
-    fi
-}
-
 clean() {
     #
     # Clean up tree after building
     mv "${MKIT_PROJ_PKGNAME}-$version.tar.gz" \
        "${MKIT_PROJ_PKGNAME}_$version.orig.tar.gz" \
      || die "could not rename tarball"
-    echo "${MKIT_PROJ_PKGNAME}_$version.orig.tar.gz" >> "$MKIT_LOCAL/built.lst"
+    rec_built "${MKIT_PROJ_PKGNAME}_$version.orig.tar.gz"
 
     # read content of each mandatory file from debian_skel
     #
       | while read -r dfsrc; do
             dftgt="debian/${dfsrc#$debian_skel}"
             mkdir -p "$(dirname "$dftgt")"
-            _build1 "$dfsrc" "$dftgt" debstuff
+            __build1 "$dfsrc" "$dftgt" debstuff
         done
-    echo debian >> "$MKIT_LOCAL/built.lst"
+    rec_built debian
 }
 
 dist() {
     #
     # Create distributable tarball
     #
-    #FIXME: lacking Makefile skills, we do this step twice fot
+    #FIXME: lacking Makefile skills, we do this step twice for
     #       rpmstuff, hence -f hack for gzip
     #
     local version           # tarball version
     echo -n "$git_lasthash" > "$dirname/.mkit/git_lasthash"
     tar -cf "$dirname.tar" "$dirname"
     gzip -f "$dirname.tar"      # see above FIXME
-    mkdir -p "$MKIT_LOCAL"
-    echo "$dirname.tar.gz" >> "$MKIT_LOCAL/built.lst"
+    rec_built "$dirname.tar.gz"
     rm -rf "$dirname"
 }
 
     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" rpmstuff
+    __build1 "$specsrc" "$specname" rpmstuff
 }

utils/mkit/include/deploy.sh

 
 mkit_import ini
 
-_deploy_item() {
+__deploy_item() {
     #
     # Deploy item and make it look like wanted
     #
-    # usage: _deploy_item src dst [mode]
+    # usage: __deploy_item src dst [mode]
     #
     # Both src and dst must be names of actual items[1],
     # whereas dst must not exist.  On update, dst is
                 [[ $item =~ .skel$ ]] \
                  && grep -q "${item%.skel}" "$MKIT_LOCAL/built.lst" \
                  && continue
-                _deploy_item "$item" "$dst${item#$src}" "$mode"
+                __deploy_item "$item" "$dst${item#$src}" "$mode"
             done
     else
-        _maybe install -DTvm "$mode" "$src" "$dst"
+        test "$mode" == "SRC" && mode=$(stat -c "%a" "$src")
+        __maybe install -DTvm "$mode" "$src" "$dst"
     fi
 }
 
-_get_dst() {
+__get_dst() {
     #
     # Find out target path for src file $2 of group $1
     #
     local src=$2        # each source
     local dst=$3        # alternative destination name
     test -n "$dst" || dst=${src##*/}
-    echo "$(_get_root "$grp")/$dst"
+    echo "$(__get_root "$grp")/$dst"
 }
 
-_get_root() {
+__get_root() {
     #
     # Find out target root for group $1
     #
     esac
 }
 
-_maybe() {
+__maybe() {
     #
     # Call the deploy command $1 $@ unless in dry mode
     #
             mode=$(ini 1value "modes:$group")
             ini values "files:$group" \
               | while read -r src dst; do
-                    dst=$(_get_dst "$group" "$src" "$dst")
-                    _deploy_item "$src" "$dst" "$mode"
+                    dst=$(__get_dst "$group" "$src" "$dst")
+                    __deploy_item "$src" "$dst" "$mode"
                 done
         done
     test -f "$MKIT_LOCAL/autoclean" && clean
       | while read -r group; do
             ini values "files:$group" \
               | while read -r src dst; do
-                    dst=$(_get_dst "$group" "$src" "$dst")
-                    _maybe rm -vrf "$dst"
+                    dst=$(__get_dst "$group" "$src" "$dst")
+                    __maybe rm -vrf "$dst"
                 done
         done
 }

utils/mkit/include/facts.sh

     local commit        # commit indicator (CURRENT_BRANCH.gHASH)
     local dirty         # 0 if dirty, 1 if clean
     local suffix        # version suffix
+    local_get semver && return 0
     version=$(ini 1value project:version)
     prerl=$(ini 1value project:prerl)
     grep ":" <<<"$prerl" \
         test -n "$prerl" && suffix="-$prerl$suffix"
         version="$version$suffix"
     fi
+    local_putb semver <<<"$version"
     echo "$version"
 }

utils/mkit/include/ini.sh

 # MKit - simple install helper
 # See LICENSE file for copyright and license details.
 
-_ini_cat() {
+__ini_cat() {
     #
     # A no-op for text stream
     #
     done
 }
 
-_ini_expand() {
+__ini_expand() {
     #
     # Expand reference value (prefix only)
     #
     done
 }
 
-_ini_grepkey() {
+__ini_grepkey() {
     #
     # Read key from a section
     #
       | sed -e 's/ *= */=/; s/ +$//; s/^//;' \
       | grep -e "^$wnt=" \
       | cut -d= -f2- \
-      | _ini_maybe_expand
+      | __ini_maybe_expand
 }
 
-_ini_greppath() {
+__ini_greppath() {
     #
     # Read key from the right section
     #
          && echo "$override" \
          && return
     fi
-    _ini_grepsec "$wntsec" | _ini_grepkey "$wntkey"
+    __ini_grepsec "$wntsec" | __ini_grepkey "$wntkey"
 }
 
-_ini_grepsec() {
+__ini_grepsec() {
     #
     # Read one INI section
     #
       | sed -e 's/ *= */=/; s/ +$//; s/^//;'
 }
 
-_ini_lskeys() {
+__ini_lskeys() {
     #
     # List keys from a section
     #
     local sct=$1    # section of interest
-    _ini_grepsec "$sct" | cut -d= -f1 | awk '!x[$0]++'
+    __ini_grepsec "$sct" | cut -d= -f1 | awk '!x[$0]++'
 }
 
-_ini_maybe_expand() {
+__ini_lssect() {
+    #
+    # List all section names
+    #
+    local arg=$1    # unused argument
+    grep -x '\[.*\]' | sed 's/^.//; s/.$//'
+}
+
+__ini_maybe_expand() {
     #
     # Decide whether or not to expand
     #
     if test "$MKIT_INI_EXPAND" -gt 0; then
-        MKIT_INI_EXPAND=$(( --MKIT_INI_EXPAND )) _ini_expand
+        MKIT_INI_EXPAND=$(( --MKIT_INI_EXPAND )) __ini_expand
     else
-        _ini_cat
+        __ini_cat
     fi
 }
 
     local op=$1             # operator
     local arg=$2            # argument
     local fn                # internal function implementing $op
-    local limit=_ini_cat    # limiting internal function
+    local limit=__ini_cat    # limiting internal function
     case $op in
-        lskeys) fn=_ini_lskeys   ;;
-        sec)    fn=_ini_grepsec  ;;
-        values) fn=_ini_greppath ;;
-        1value) fn=_ini_greppath; limit="tail -1" ;;
+        lskeys) fn=__ini_lskeys   ;;
+        lssect) fn=__ini_lssect   ;;
+        sec)    fn=__ini_grepsec  ;;
+        values) fn=__ini_greppath ;;
+        1value) fn=__ini_greppath; limit="tail -1" ;;
         *)      die "incorrect use of \`ini()\`"
     esac
     <"$MKIT_INI" $fn "$arg" | $limit
 
 update_version() {
     #
-    # Change project.version in mkit.ini at path $2 to version $1
+    # Change project:version in mkit.ini at path $2 to value $1
     #
     local version=$1    # new version
     local inifile=$2    # mkit.ini path

utils/mkit/include/mkit.sh

 mkit_import release
 mkit_import ini
 
-_valid_targets() {
+__valid_targets() {
     #
     # List valid routes
     #
+    echo _mkit_data
     echo build
-    echo build_manpages
     echo clean
     echo debstuff
     echo dist
     done
 }
 
-_compver() {
+__compver() {
     #
     # True if version $1 matches our version
     #
     return 0
 }
 
-_chkiniversion() {
+__chkiniversion() {
     #
     # Check if ini version is supported
     #
     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" \
+    __compver "$their_ver" \
      || die "bad mkit.ini version: $their_ver does not match $MKIT_VERSION"
 }
 
+local_putb() {
+    #
+    # Make file $1 in $MKIT_LOCAL from stdin and mark as built
+    #
+    local fpath=$1
+    local_put "$fpath" && rec_built "$MKIT_LOCAL/$fpath"
+}
+
+local_put() {
+    #
+    # Make file $1 in $MKIT_LOCAL from stdin
+    #
+    local fpath="$MKIT_LOCAL/$1"
+    { mkdir -p "${fpath%/*}" && cat >"$fpath"; } \
+     || die "cannot write to local cache: $fpath"
+}
+
+local_get() {
+    #
+    # Read file $1 in $MKIT_LOCAL
+    #
+    local fpath="$MKIT_LOCAL/$1"
+    cat "$fpath" 2>/dev/null
+}
+
 mkit_init() {
     #
     # Do basic initialization
     # Check for ini file and some variables
     #
     $MKIT_DRY && MKIT_DEBUG=true
+    #shellcheck disable=SC2034
     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'"
+    __chkiniversion
+}
+
+rec_built() {
+    #
+    # Record file $1 for deletion on `clean`
+    #
+    local file=$1
+    mkdir -p "$MKIT_LOCAL"
+    echo "$file" >> "$MKIT_LOCAL/built.lst"
 }
 
 route() {
     #
     # Call correct function based on $1
     #
-    if _valid_targets | grep -qwx "^$1"; then
+    if __valid_targets | grep -qwx "^$1"; then
         "$1"
     else
         {
             echo "usage: $(basename "$0") TARGET"
             echo
             echo "valid targets:"
-            _valid_targets | sed 's/^/    /'
+            __valid_targets | sed 's/^/    /'
         } >&2
     fi
 }

utils/mkit/include/release.sh

 mkit_import ini
 mkit_import facts
 
-_bump_version() {
+__bump_version() {
     #
     # Bump version on stdin by level $1 (x, y or z)
     #
     echo "$new"
 }
 
-_relck() {
+__relck() {
     #
     # Die if blocking condition $1 is detected
     #
              && die "WIP commit since $(git_fact latest_tag)"
             ;;
         ini_version)
-            oracle=$(git_fact latest_version | _bump_version "$rlevel")
+            oracle=$(git_fact latest_version | __bump_version "$rlevel")
             ini 1value project:version  \
               | grep -qFx "$oracle" \
              || die "new version not in mkit.ini: $oracle"
     esac
 }
 
-_release() {
+__release() {
     #
     # Prepare release
     #
     local relsrc        # release source branch (if any)
     local reldst        # release destination branch (if any)
 
-    _relck git_present
-    _relck at_relsrc
-    _relck not_dirty
-    _relck tags_ok
-    _relck vbump_hot
-    _relck no_wip
-    _relck ini_version
+    __relck git_present
+    __relck at_relsrc
+    __relck not_dirty
+    __relck tags_ok
+    __relck vbump_hot
+    __relck no_wip
+    __relck ini_version
 
-    newtag=$(git_fact latest_version | _bump_version "$rlevel" | git_ver2tag )
+    newtag=$(git_fact latest_version | __bump_version "$rlevel" | git_ver2tag )
     set -e
     debug_var newtag
     $MKIT_DRY && return
-    git tag -m "$(_release_msg)" "$newtag"
+    git tag -m "$(__release_msg)" "$newtag"
 
     relsrc=$(ini 1value project:relsrc)
     reldst=$(ini 1value project:reldst)
     fi
 }
 
-_release_msg() {
+__release_msg() {
     #
     # Generate message for annotated tag
     #
       | tail -n +3
 }
 
-_vbump() {
+__vbump() {
     #
     # Do version bump at level $1
     #
     #
     local rlevel=$1     # bump level (x, y or z)
     local nextver       # version after the bump
-    _relck git_present
-    _relck at_relsrc
-    _relck not_dirty
-    nextver=$(ini 1value project:version | _bump_version "$rlevel")
+    local cache         # cache for the message
+    __relck git_present
+    __relck at_relsrc
+    __relck not_dirty
+    nextver=$(ini 1value project:version | __bump_version "$rlevel")
     debug_var nextver
     $MKIT_DRY && return
     update_version "$nextver" mkit.ini \
       || die "failed to update version in mkit.ini"
     git add mkit.ini \
       || die "failed to add mkit.ini to the index"
-    git commit -e -m "$(_vbump_gitmsg)"
+    cache=$(mktemp -t "mkit._vbump_gitmsg.XXXXXXXX")
+    _vbump_gitmsg > "$cache"
+    git commit -e -F "$cache"   # note: reading from stdin will break vim
+    rm "$cache"
 }
 
 _vbump_gitmsg() {
     echo ""
     git_fact reldiff \
       | sed '
-            s/^[a-f0-9]\{7\} / *  &/; t PATHS
+            s/^[a-f0-9]\{7\} /\n *  &/; t PATHS
             s/^/        /
             :PATHS
         '
     #
     # Perform release on Z level
     #
-    _release z
+    __release z
 }
 
 release_x() {
     #
     # Perform release on X level
     #
-    _release x
+    __release x
 }
 
 release_y() {
     #
     # Perform release on Y level
     #
-    _release y
+    __release y
 }
 
 release_z() {
     #
     # Perform release on Z level
     #
-    _release z
+    __release z
 }
 
 vbump() {
     #
     # Perform version bump on Z level
     #
-    _vbump z
+    __vbump z
 }
 
 vbump_x() {
     #
     # Perform version bump on X level
     #
-    _vbump x
+    __vbump x
 }
 
 vbump_y() {
     #
     # Perform version bump on Y level
     #
-    _vbump y
+    __vbump y
 }
 
 vbump_z() {
     #
     # Perform version bump on Z level
     #
-    _vbump z
+    __vbump z
 }

utils/mkit/include/vars.sh

 #!/bin/bash
+#shellcheck disable=SC2034
 # MKit - simple install helper
 # See LICENSE file for copyright and license details.
 
 #
 # This MKit version
 #
-MKIT_VERSION=0.0.24
+MKIT_VERSION=0.0.28

utils/mkit/mkit.mk

 
 all: build
 
-build:
-	@$(MKIT_DIR)/make build
+_mkit_data:
+	@"$(MKIT_DIR)"/make _mkit_data
 
-manpages: build
-	@$(MKIT_DIR)/make build_manpages
+build:
+	@"$(MKIT_DIR)"/make build
 
 clean:
-	@$(MKIT_DIR)/make clean
+	@"$(MKIT_DIR)"/make clean
 
 debstuff: dist
-	@$(MKIT_DIR)/make debstuff
+	@"$(MKIT_DIR)"/make debstuff
 
 dist: clean
-	@$(MKIT_DIR)/make dist
+	@"$(MKIT_DIR)"/make dist
 
 rpmstuff: dist
-	@$(MKIT_DIR)/make rpmstuff
+	@"$(MKIT_DIR)"/make rpmstuff
 
 install: all
-	@$(MKIT_DIR)/make install
+	@"$(MKIT_DIR)"/make install
 
 release:
-	@$(MKIT_DIR)/make release
+	@"$(MKIT_DIR)"/make release
 
 release_x:
-	@$(MKIT_DIR)/make release_x
+	@"$(MKIT_DIR)"/make release_x
 
 release_y:
-	@$(MKIT_DIR)/make release_y
+	@"$(MKIT_DIR)"/make release_y
 
 release_z:
-	@$(MKIT_DIR)/make release_z
+	@"$(MKIT_DIR)"/make release_z
 
 uninstall:
-	@$(MKIT_DIR)/make uninstall
+	@"$(MKIT_DIR)"/make uninstall
 
 vbump:
-	@$(MKIT_DIR)/make vbump
+	@"$(MKIT_DIR)"/make vbump
 
 vbump_x:
-	@$(MKIT_DIR)/make vbump_x
+	@"$(MKIT_DIR)"/make vbump_x
 
 vbump_y:
-	@$(MKIT_DIR)/make vbump_y
+	@"$(MKIT_DIR)"/make vbump_y
 
 vbump_z:
-	@$(MKIT_DIR)/make vbump_z
+	@"$(MKIT_DIR)"/make vbump_z
 
-.PHONY: all clean dist rpmstuff install uninstall release release_x release_y release_z vbump vbump_x vbump_y vbump_z
+.PHONY: all _mkit_data clean dist rpmstuff install uninstall release release_x release_y release_z vbump vbump_x vbump_y vbump_z

utils/mkit/stub

             echo "$any_name"
             tr -c '=\n' '=' <<<"$any_name"
             echo ''
-            echo ''
             if test -n "$Tagline"; then
                 echo "$Tagline"
             else
 
         */mkit.ini|mkit.ini)
             echo "[project]"
-            echo "    version     = $Version"
-            test -n "$Codename"     && echo "    codename    = $Codename"
-            test -n "$NiceName"     && echo "    name        = $NiceName"
-            test -n "$Tagline"      && echo "    tagline     = $Tagline"
-            test -n "$PackageName"  && echo "    pkgname     = $PackageName"
-            test -n "$Maintainer"   && echo "    maintainer  = $Maintainer"
-            test -n "$VcsBrowser"   && echo "    vcs_browser = $VcsBrowser"
-            test -n "$RelSrc"       && echo "    relsrc      = $RelSrc"
-            test -n "$RelDst"       && echo "    reldst      = $RelDst"
+            {
+                echo "version = $Version"
+                test -n "$Codename"     && echo "codename    = $Codename"
+                test -n "$NiceName"     && echo "name        = $NiceName"
+                test -n "$Tagline"      && echo "tagline     = $Tagline"
+                test -n "$PackageName"  && echo "pkgname     = $PackageName"
+                test -n "$Maintainer"   && echo "maintainer  = $Maintainer"
+                test -n "$VcsBrowser"   && echo "vcs_browser = $VcsBrowser"
+                test -n "$RelSrc"       && echo "relsrc      = $RelSrc"
+                test -n "$RelDst"       && echo "reldst      = $RelDst"
+            } | reformat_section
             if updating; then
                 remake_section dist
                 remake_section ENV
             else
                 echo ""
                 echo "[dist]"
-                $MkLicense  && echo "    tarball = LICENSE.md"
-                $MkMakefile && echo "    tarball = Makefile"
-                $MkReadme   && echo "    tarball = README.md"
-                echo "    tarball = mkit.ini"
-                $MkPackaging && echo "    tarball = packaging"
-                echo "    tarball = src"
-                echo "    tarball = tests"
-                echo "    tarball = utils"
-                $MkPackaging && echo "    rpmstuff = packaging/template.spec"
-                $MkPackaging && echo "    debstuff = packaging/debian"
+                {
+                    $MkLicense  && echo "tarball = LICENSE.md"
+                    $MkMakefile && echo "tarball = Makefile"
+                    $MkReadme   && echo "tarball = README.md"
+                    echo "tarball = mkit.ini"
+                    $MkPackaging && echo "tarball = packaging"
+                    echo "tarball = src"
+                    echo "tarball = tests"
+                    echo "tarball = utils"
+                    $MkPackaging && echo "rpmstuff = packaging/template.spec"
+                    $MkPackaging && echo "debstuff = packaging/debian"
+                } | reformat_section
                 echo ""
                 echo "[ENV]"
-                echo "    PREFIX = /usr/local"
+                {
+                    echo "    PREFIX = /usr/local"
+                } | reformat_section
                 echo ""
                 echo "[roots]"
-                echo "    bin     = [ENV:PREFIX]/bin"
-                echo "    doc     = [ENV:PREFIX]/share/doc/$PackageName"
+                {
+                    echo "bin = [ENV:PREFIX]/bin"
+                    echo "doc = [ENV:PREFIX]/share/doc/$PackageName"
+                } | reformat_section
                 echo ""
                 echo "[tokens]"
-                echo "    __${PackageName^^}_FOO__ = Barr.."
+                {
+                    echo "__${PackageName^^}_FOO__ = Barr.."
+                } | reformat_section
                 echo ""
                 echo "[modes]"
-                echo "    bin     = 755"
-                echo "    doc     = 644"
+                {
+                    echo "bin = 755"
+                    echo "doc = 644"
+                } | reformat_section
                 echo ""
                 echo "[files]"
-                echo "    bin      = src/$PackageName"
-                $MkLicense && echo "    doc      = LICENSE.md"
-                $MkReadme  && echo "    doc      = README.md"
+                {
+                    echo "bin = src/$PackageName"
+                    $MkLicense && echo "doc = LICENSE.md"
+                    $MkReadme  && echo "doc = README.md"
+                } | reformat_section
             fi
             echo ""
             echo "#mkit version=$MKIT_VERSION"
             ;;
 
         packaging/template.spec)
-            echo 'Name:		__MKIT_PROJ_PKGNAME__'
-            echo 'Version:	__MKIT_PROJ_VERSION__'
-            echo 'Release:	1%{?dist}'
-            echo 'Summary:	__MKIT_PROJ_NAME__ - __MKIT_PROJ_TAGLINE__'
-            echo ''
-            $MkLicense && echo "License:	$License"
-            echo 'Source0:	%{name}-%{version}.tar.gz'
+            echo 'Name:       __MKIT_PROJ_PKGNAME__'
+            echo 'Version:    __MKIT_PROJ_VERSION__'
+            echo 'Release:    1%{?dist}'
+            echo 'Summary:    __MKIT_PROJ_NAME__ - __MKIT_PROJ_TAGLINE__'
+            test -n "$VcsBrowser" && echo 'URL:        __MKIT_PROJ_VCS_BROWSER__'
+            $MkLicense && echo "License:    $License"
             echo ''
-            echo 'BuildArch:	noarch'
-            echo 'BuildRequires:	coreutils git'
-            echo 'Requires:	MKIT_STUB_REQUIRES'
+            echo 'Source0:    %{name}-%{version}.tar.gz'
+            echo 'BuildArch:  noarch'
             echo ''
+            echo 'Requires: MKIT_STUB_REQUIRES'
             echo '%description'
             echo 'MKIT_STUB_DESCRIPTION'
             echo ''
             echo 'override_dh_auto_install:'
             echo ''
             echo '	make install PREFIX=/usr DESTDIR=debian/tmp'
-            echo ''
-            echo 'override_dh_usrlocal:'
-            echo ''
-            echo '	@true'
             ;;
 
         packaging/debian/source/format)
             echo '3.0 (quilt)'
             ;;
 
-        packaging/debian/*.install)
+        packaging/debian/install)
             echo MKIT_STUB_FILELIST
             ;;
 
             echo "     *  \`MKIT_STUB_FILELIST\` - List of full paths to"
             echo "        your files after installation."
             echo ""
-            echo "        Note that in case of debian/package.install files,"
-            echo "        PREFIX based paths (eg. /usr/bin) in this file should"
-            echo "        should be as if PREFIX was /usr."
+            echo "        Note that in case of debian/install files, PREFIX"
+            echo "        based paths (eg. /usr/bin) in this file should be as"
+            echo "        if PREFIX was /usr."
             echo ""
             echo "        In case of Fedora-based distro, you should make use"
             echo "        of RPM macros:"
     deploy packaging/debian/control
     deploy packaging/debian/changelog
     deploy packaging/debian/compat
+    deploy packaging/debian/install
     deploy packaging/debian/rules
     deploy packaging/debian/source/format
-    deploy packaging/debian/"$PackageName".install
 }
 
 init_from_existing() {
                     echo "$key = $value"
                 done
         done \
-      | column -to' ' \
+      | reformat_section
+}
+
+reformat_section() {
+    #
+    # Re-format "k = v" on stdin as "nice" ini section
+    #
+    local key
+    local eq
+    local value
+    while read -r key eq value; do
+        test "$eq" == "=" || {
+            warn "ignoring malformed ini line: $key $eq $value"
+            continue
+        }
+        echo "$key = $value"
+    done \
+      | sed 's/ *= */=/; s/^ *//; s/ *$//' \
+      | column -t -s= -o' = ' \
       | sed 's/^/    /'
 }