Update MKit to v0.0.29

utils/mkit/include/build.sh

     test -n "$ftype"    || ftype=$(__guess_ftype "$dstpath")
     debug_var srcpath dstpath ftype
     <"$srcpath" __build1_ftype "$ftype" >"$dstpath"
-    rec_built "$dstpath"
+    __rec_built "$dstpath"
 }
 
 __build1_ftype() {
         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_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"
     '
 }
 
+__cached() {
+    #
+    # Cached value $1 of function $1()
+    #
+    # In order to support git-less builds, some values might be cached
+    # in $MKIT_LOCAL.  This function gets file $1 from that cache (cache
+    # hit) or re-creates it (cache miss), but prints its body in either
+    # case.
+    #
+    # The command to re-create file is the same as the key (ie. no
+    # arguments).
+    #
+    local name=$1
+    __local_get "$name" && return 0
+    "$name" | __local_putb "$name"
+    __local_get "$name"
+}
+
+__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
+}
+
+__rec_built() {
+    #
+    # Record file $1 for deletion on `clean`
+    #
+    local file=$1
+    mkdir -p "$MKIT_LOCAL"
+    echo "$file" >> "$MKIT_LOCAL/built.lst"
+}
+
 _mkit_data() {
     #
     # Build sampler showing all token values
     # Add meat to all skeletons
     #
     local srcpath   # each source path
-    semver >/dev/null
     find . -type f -name '*.skel' \
      | while read -r srcpath; do
            __build1 "$srcpath"
     local debian_skel   # 'debian' folder skeleton
     local dfsrc         # each source file from ^^
     local dftgt         # each built packaging file
-    version=$(semver)
+    version=$(__cached semver)
 
     # tarball - we should already have by means of 'dist'
     #
     mv "${MKIT_PROJ_PKGNAME}-$version.tar.gz" \
        "${MKIT_PROJ_PKGNAME}_$version.orig.tar.gz" \
      || die "could not rename tarball"
-    rec_built "${MKIT_PROJ_PKGNAME}_$version.orig.tar.gz"
+    __rec_built "${MKIT_PROJ_PKGNAME}_$version.orig.tar.gz"
 
     # read content of each mandatory file from debian_skel
     #
             mkdir -p "$(dirname "$dftgt")"
             __build1 "$dfsrc" "$dftgt" debstuff
         done
-    rec_built debian
+    __rec_built debian
 }
 
 dist() {
     git_lasthash=$(git_lasthash)
     mkdir -p "$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 "$version" > "$dirname/.mkit/semver"
     echo -n "$git_lasthash" > "$dirname/.mkit/git_lasthash"
     tar -cf "$dirname.tar" "$dirname"
     gzip -f "$dirname.tar"      # see above FIXME
-    rec_built "$dirname.tar.gz"
+    __rec_built "$dirname.tar.gz"
     rm -rf "$dirname"
 }
 

utils/mkit/include/facts.sh

     #
     # Show last commit hash (with .dirty suffix if needed)
     #
-    # If outside git repo, get it from .mkit/git_lasthash, which
-    # should have been put there by dist target.  (I.e., this won't
-    # work if you got outside the git repo in other way than dist
-    # target, but that's actually expected.)
+    # 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.
     #
     local last_hash     # last commit hash
-    if git_present; then    # we are in git repo
-        last_hash=$(git rev-parse HEAD)
-        echo -n "$last_hash"
-        git_bool dirty && echo -n ".dirty"
-    else    # we are outside (eg. distributor's build dir')
-        grep . .mkit/git_lasthash || {
-            echo UNKNOWN
-            warn "malformed source, could not determine git hash"
-        }
-    fi
+    git_present || {
+        echo UNKNOWN_HASH
+        warn "no git present; could not determine last hash"
+        return 3
+    }
+    last_hash=$(git rev-parse HEAD)
+    echo -n "$last_hash"
+    git_bool dirty && echo -n ".dirty"
 }
 
 semver() {
     #
-    # Build semver version string with build metadata
+    # Build proper SemVer version string
     #
     # Build version string from available info using following
     # logic:
     #
-    #  1. use project.version (from mkit.ini)
-    #  2. if we are in git, override the version with last tag
-    #  3. if set, add project:prerl (from mkit.ini) as pre-release ID
+    #  1. Use version from last git tag (or mkit.ini if there is no
+    #     tag, which is possible on new project)
+    #  2. if set, add project:prerl (from mkit.ini) as pre-release ID
     #     (afer dash)
-    #  4. if we are at a later commit than the last tag, add branch
+    #  3. if we are at a later commit than the last tag, add branch
     #     name and commit sha1 to build metadata (after plus sign)
-    #  5. if the tree is "dirty", i.e. has uncommited changes,
+    #  4. if the tree is "dirty", i.e. has uncommited changes,
     #     add "dirty" to build metadata
     #
     # The version is compatible with SemVer 2.0.0.
     #
     # Examples:
     #
-    #     myprog v1.0.7                         # all clear
-    #     myprog v1.0.7-alpha                   # mkit.ini: project:prerl="alpha"
-    #     myprog v1.0.7-alpha+g1aef811.master   # ^^ + some commits after
-    #     myprog v1.0.7-alpha+gf14fc4f.api2     # ^^ + on a feature branch
-    #     myprog v1.0.7-alpha+gf14fc4f.api2.dirty  # ^^ + tree edited
-    #     myprog v1.0.7-alpha+dirty             # tag OK but tree edited
-    #     myprog v1.0.7+dirty                   # ^^ but no pre-release id
+    #     foo v1.0.7                            # all clear; proper release
+    #     foo v1.0.7-beta                       # mkit.ini: project:prerl="beta"
+    #     foo v1.0.7-beta+g1aef811.master       # ^^ + some commits after
+    #     foo v1.0.7-beta+gf14fc4f.api2         # ^^ + on a feature branch
+    #     foo v1.0.7-beta+gf14fc4f.api2.dirty   # ^^ + tree edited
+    #     foo v1.0.7-beta+dirty                 # tag OK but tree edited
+    #     foo v1.0.7+dirty                      # ^^ but no pre-release id
     #
     # Note that versions with "dirty" should be perceived as kind of
     # dangerous outside developer's own machine.  Versions with sha1 are
     # safer but must not be released.
     #
-    # I have considered decorating the git commit refs to make them
-    # sort of sortable (e.g. "r1.g1aef811"), but on second thought,
-    # I don't think it's good idea to give *any* semantics to meta-data
-    # at all.  First, there is no rule that r1<r2<r3; a commit can be
-    # removing what other just added and one change can be split to
-    # multiple commits.  Also, the whole thing breaks anyway once you
-    # rebase your branch (no, it's not a sin).  The sole purpose of
-    # meta-data is to *identify* the code, and provide safe path back
-    # to tree; commit refs are already perfect for that.
-    #
     # FIXME:  Using project:prerl for release IDs may not be compatible with
     #         release strategy implemented in release.sh
     #
-    local version       # version string (final result)
-    local prerl         # pre-release keyword (from mkit.ini, eg. 'alpha')
+    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         # 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" \
      && warn "colon in project:prerl may corrupt version data: $prerl"
-    if git_present;
-    then    # we are in git repo... so we can get smart
-        latest_tag=$(git_fact latest_tag)
-        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)"
-        fi
-        git_bool dirty; dirty=$?
-        test -n "$latest_tag" && version=${latest_tag:1}
-        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" ;;
-        esac
-        test -n "$prerl" && suffix="-$prerl$suffix"
-        version="$version$suffix"
+    git_present || {
+        echo UNKNOWN_VERSION
+        warn "no git present; could not determine SemVer"
+        return 3
+    }
+    latest_tag=$(git_fact latest_tag)
+    case $latest_tag in
+        v*) xyz=${latest_tag:1} ;;
+        "") warn "no tags, using base version from mkit.ini (ok for new project)"
+            xyz=$(ini 1value project:version) ;;
+        *)  warn "bad form of last tag, using base version from mkit.ini: tag is '$latest_tag'"
+            xyz=$(ini 1value project:version) ;;
+    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)"
     fi
-    local_putb semver <<<"$version"
-    echo "$version"
+    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" ;;
+    esac
+    test -n "$prerl" && suffix="-$prerl$suffix"
+    echo "$xyz$suffix"
 }

utils/mkit/include/mkit.sh

      || 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
     __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

utils/mkit/include/vars.sh

 #
 # This MKit version
 #
-MKIT_VERSION=0.0.28
+MKIT_VERSION=0.0.29

utils/mkit/stub

             echo 'Summary:    __MKIT_PROJ_NAME__ - __MKIT_PROJ_TAGLINE__'
             test -n "$VcsBrowser" && echo 'URL:        __MKIT_PROJ_VCS_BROWSER__'
             $MkLicense && echo "License:    $License"
-            echo ''
             echo 'Source0:    %{name}-%{version}.tar.gz'
             echo 'BuildArch:  noarch'
             echo ''
             echo 'Section: misc'
             echo 'Priority: extra'
             echo 'Standards-Version: 3.9.2'
-            echo 'Build-Depends: debhelper (>= 9)'
+            echo 'Build-Depends:'
+            echo ' debhelper (>= 9),'
             echo ''
             echo 'Package: __MKIT_PROJ_PKGNAME__'
             echo 'Architecture: all'
             echo "everything, so few things still need to be done manually."
             echo "This document will guide you throught the rest of the"
             echo "process."
-
             echo ""
             echo ""
             echo "Structure"
             echo "    idea!), be prepared that you will need to follow their"
             echo "    guidelines.  This will most probably mean huge changes"
             echo "    to these packages or even changes to your workflow."
-
             echo ""
             echo ""
             echo "Placeholders"
             echo "    Typical example of a role is e.g. 'bin' for commands"
             echo "    (normally under '/usr/bin' or '/usr/local/bin'), 'doc'"
             echo "    for documents or 'lib' for libraries."
-
             echo ""
             echo " 2. Next, in \`[roots]\` section, you have to set target"
             echo "    root directory for each role.  However, in order to"
             echo "    environment variable.  For this reason, most paths"
             echo "    need to start with \`[ENV:PREFIX]\`."
             echo ""
-
             echo " 3. \`[files]\` section is where you assign actual files"
             echo "    from your repository to their final paths.  The format"
             echo "    is \`ROLE = REPOPATH [RENAMED]\`, where ROLE is file's"
             echo "    individually, if in your repo you have a directory with"
             echo "    100 files of the same role, you can add just path to the"
             echo "    directory itself."
-
             echo ""
             echo " 4. If some roles require special permissions on your files,"
             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 "    placeholders that will be replaced when your scripts are"
             echo "    defined here, plus range of tokens automatically defined"
             echo "    by MKit.  During build, these tokens are replaced with"
             echo "    their actual values."
-
             echo ""
             echo " 6. Less interesting, but important section is \`[dist]\`,"
             echo "    which lists files in your codebase that will be added"
             echo "    above).  Listing directory here will include all its"
             echo "    contents, and normally it's OK to be very inclusive, so"
             echo "    most of the time this section should be OK."
-
             echo ""
             echo " 7. Even less interesting is section \`[ENV]\`.  It is"
             echo "    special in that it provides *default* value for an"
             echo "    environment variable.  You almost never need to touch"
             echo "    this."
             echo ""
-
             echo " 8. Finally, the most interesting section!  \`[project]\`,"
             echo "    provides most general information for your project such"
             echo "    as name and version."
         echo "    -R            skip creating README.md"
         echo "    -M            skip creating Makefile"
         echo "    -P            skip creating packaging templates"
-        echo "    -L            list know licenses and exit"
+        echo "    -L            list known licenses and exit"
         echo ""
         echo "PKGNAME should be packaging-friendly name, ie. consist"
         echo "only of small letters, numbers, underscore and dash."