Update mkit from fastfoo v0.6.3

Makefile

 options:
 	@echo saturnin build options:
 	@echo "VERSION  = ${VERSION}"
+	@echo "PRERELEASE = ${PRERELEASE}"
 	@echo "PREFIX   = ${PREFIX}"
 
 build:
 install: all
 	@mkit/make install
 
+release_x:
+	@mkit/make release_x
+
+release_y:
+	@mkit/make release_y
+
+release_z:
+	@mkit/make release_z
+
 uninstall:
 	@mkit/make uninstall
 

config.mk

 VERSION = 0.0.15
-STAGE = devel
+RELSRC = master
+RELDST = last
 PREFIX=/usr/local

mkit/config.ini

 
 [ENV]
 
-    PROJNAME = saturnin
+    PKGNAME = saturnin
+    PROJNAME = Saturnin
     PREFIX = /usr
 
 [lists]

mkit/include/build.sh

     # Create distributable tarball
     #
     local version=$(get_version)
-    local dirname=$MKIT_PROJNAME-$version
+    local dirname=$MKIT_PKGNAME-$version
     mkdir -p $dirname
     local item
     cp -R $(ini values "lists:dist") $dirname
     #
     #  1. use VERSION (from config.mk)
     #  2. if we are in git, override the version with last tag
-    #  3. if set, add STAGE (from config.mk) as pre-release ID
+    #  3. if set, add PRERELEASE (from config.mk) as pre-release ID
     #     (afer dash)
-    #  4. if we are at a later commit than the last tag, add commit
-    #     sha1 to build metadata (after plus sign)
+    #  4. 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,
     #     add "dirty" to build metadata
     #
     # Examples:
     #
     #     myprog v1.0.7                         # all clear
-    #     myprog v1.0.7-alpha                   # STAGE="alpha"
-    #     myprog v1.0.7-alpha+g1aef811          # ^^ + some commits after
-    #     myprog v1.0.7-alpha+g1aef811.dirty    # ^^ + tree edited
+    #     myprog v1.0.7-alpha                   # PRERELEASE="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 stage
+    #     myprog 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
     #         from tags" fails if we are in shallow clone made from
     #         other than a tagged commit.
     #
+    # FIXME:  Using PRERELEASE for release IDs may not be compatible with
+    #         release strategy implemented in release.sh
+    #
     local version=$VERSION
-    local stage=$STAGE
+    local prerl=$PRERELEASE
+    grep ":" <<<"$prerl" && warn "colon in PRERELEASE may corrupt version data: $prerl"
     if git rev-parse HEAD >&/dev/null;
     then    # we are in git repo... so we can get smart
         local lasttag=$(git tag | grep ^v | sort -V | tail -n1)
         if ! git describe --tags --exact-match HEAD >&/dev/null;
-        then    # we are not at later commit than the last tag
+        then    # we are at a later commit than the last tag
             local sha=g$(git log -1 --pretty=format:%h HEAD)
+            local curbranch=$(git rev-parse --abbrev-ref HEAD)
+            local commit="$curbranch.$sha"
         fi
         if test "$(git diff --shortstat 2>/dev/null)" != "";
-        then    # thr tree is "dirty", i.e. has been edited
+        then    # the tree is "dirty", i.e. has been edited
             local dirty=dirty
         fi
         version=${lasttag:1}
         local suffix=""
-        case $stage:$sha:$dirty in
-            ::)         suffix=""                    ;;
-            ::dirty)    suffix="+$dirty"             ;;
-            :g*:)       suffix="+$sha"               ;;
-            :g*:dirty)  suffix="+$sha.dirty"         ;;
-            *::)        suffix="-$stage"             ;;
-            *::dirty)   suffix="-$stage+$dirty"      ;;
-            *:g*:)      suffix="-$stage+$sha"        ;;
-            *:g*:dirty) suffix="-$stage+$sha.$dirty" ;;
+        case $prerl:$commit:$dirty in
+            ::)        suffix=""                       ;;
+            ::dirty)   suffix="+$dirty"                ;;
+            :*:)       suffix="+$commit"               ;;
+            :*:dirty)  suffix="+$commit"               ;;
+            *::)       suffix="-$prerl"                ;;
+            *::dirty)  suffix="-$prerl+$dirty"         ;;
+            *:*:)      suffix="-$prerl+$commit"        ;;
+            *:*:dirty) suffix="-$prerl+$commit.$dirty" ;;
         esac
         version=$version$suffix
     fi

mkit/include/ini.sh

         1value) fn=_ini_greppath; limit="tail -1" ;;
         *)      die "incorrect use of \`ini()\`"
     esac
-    _ini_cached | $fn $arg | $limit
-}
-
-_ini_cached() {
-    #
-    # Load ini file to our cache (RAM disk) and cat it
-    #
-    # User should set MKIT_INI_CACHE to a ram-based file
-    # if mktemp cannot be relied upon.
-    #
-    if test -z "$_MKIT_INI_CACHED";
-    then
-        MKIT_INI_CACHE=${MKIT_INI_CACHE:-$(mktemp)}
-        _MKIT_INI_CACHED=$MKIT_INI_CACHE
-        test -r $MKIT_INI || die "cannot read MKIT_INI: $MKIT_INI"
-        cp $MKIT_INI $_MKIT_INI_CACHED
-    fi
-    cat $_MKIT_INI_CACHED
+    cat $MKIT_INI | $fn $arg | $limit
 }
 
 _ini_cat() {

mkit/include/mkit.sh

 #!/bin/bash
 
-. mkit/include/build.sh  || die "cannot import ini.sh"
-. mkit/include/deploy.sh || die "cannot import ini.sh"
+. mkit/include/build.sh  || die "cannot import build.sh"
+. mkit/include/deploy.sh || die "cannot import deploy.sh"
+. mkit/include/release.sh || die "cannot import release.sh"
 . mkit/include/ini.sh    || die "cannot import ini.sh"
 
 MKIT_INI=${MKIT_INI:-mkit/config.ini}
 MKIT_INI_EXPAND=2
+MKIT_PKGNAME=$(ini 1value "ENV:PKGNAME")
 MKIT_PROJNAME=$(ini 1value "ENV:PROJNAME")
 
 configure() {
     #
     # Exit with message and non-zero exit status
     #
-    echo "$@" >&2
+    echo "fatal: $@" >&2
     exit 4
 }
 
+warn() {
+    #
+    # Print warning message
+    #
+    echo "$@" >&2
+}
+
 route() {
     #
     # Call correct function based on $1
     #
     case $1 in
-        build|build_manpages|clean|dist|install|uninstall)
+        build|build_manpages|clean|dist|install|release_?|uninstall)
             $1
             ;;
         *)

mkit/include/release.sh

+#!/bin/bash
+
+__make_ver() {
+    local level=$1
+    local old=$2
+    local oldx=${old%.*.*}
+    local oldz=${old#*.*.}
+    local tmpy=${old%.*}
+    local oldy=${tmpy#*.}
+    case $level in
+        x) new="$((oldx+1)).0.0"            ;;
+        y) new="$oldx.$((oldy+1)).0"        ;;
+        z) new="$oldx.$oldy.$((oldz+1))"    ;;
+        *) die "invalid release level: $1"  ;;
+    esac
+    echo $new
+}
+
+__release() {
+    #
+    # Prepare release
+    #
+    # Span release routines: make a signed tag, check branch
+    # and update release branch
+    #
+    local level=$1
+    git rev-parse HEAD >&/dev/null || die "cannot release outside git repo"
+    local lastfile=$(git diff-tree --no-commit-id --name-only -r HEAD)
+    local lasttag=$(git tag | grep ^v | sort -V | tail -n1)
+    local changelog="$(git log --oneline $lasttag..HEAD)"
+    local curbranch=$(git rev-parse --abbrev-ref HEAD)
+    local dirt="$(git diff --shortstat 2>/dev/null)"
+
+    local newver=$(__make_ver $level ${lasttag#v})
+    local newtag=v$newver
+    local higher=$(echo -e "$oldtag\n$newtag" | sort -V | tail -n1)
+    test "$newtag" = "$higher"     || die "generated tag looks older: $oldtag<$newtag"
+
+    grep -qw "$newver" config.mk   || die "new version not in config.mk: $newver"
+    test -n "$lasttag"             || die "cannot find last tag"
+    grep '^....... WIP ' <<<"$changelog" && die "WIP commit since $lasttag"
+    grep -qw "$curbranch" <<<"$RELSRC"   || die "you are not on RELSRC branch: $RELSRC"
+    test -z "$dirt"                || die "tree is dirty: $dirt"
+
+    # FIXME: Have user prepare proper message with changelog
+
+    set -e
+    git tag -m "$MKIT_PROJNAME $newtag-$STAGE - $CODENAME" $newtag
+    git branch -f $RELDST $newtag
+}
+
+release_x() {
+    __release x
+}
+
+release_y() {
+    __release y
+}
+
+release_z() {
+    __release z
+}