Rewrite caching and versioning logic

Essential fact.sh functions git_lasthash() and semver() have been updated
so that they explicitly depend on git or fail, ie. forget about the cache.

Previously git_lasthash() would try to use cache or fail, while semver()
would try to use cache or rely on mkit.ini, which in turn had to be hacked
by dist() in order to make git-less targets expand version correctly
(with build data, eg. `0.1.2+ge1f4a77.dirty`).

The old code was guilty of four sins: inconsistency (git_lasthash()
vs. semver()), side effects (semver() would actually write cache),
hidden dependencies (both actually relied on functions from mkit.sh)
and unnecessary complexity (speculative $version use in semver()).

New code remediates all of these by making both functions just do their
job (ie. get data from VCS).  Places that did benefit from the silent
caching are served by __cached() function created for this purpose.

src/include/build.sh

         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"
+}
+
 _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'
     #
     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

src/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 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.
     # 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 xyz           # base version string
     local prerl         # pre-release keyword (from mkit.ini, eg. 'alpha')
     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"
 }