Update MKit to v0.0.8

utils/mkit/include/build.sh

     #
     # Process one skeleton
     #
-    local srcpath dstpath
-    srcpath=$1
-    dstpath=${srcpath%.skel}
-    case $dstpath in
-        *.md) <"$srcpath" expand_includes | expand_variables >"$dstpath" ;;
-        *)    <"$srcpath"                   expand_variables >"$dstpath" ;;
-    esac
+    local srcpath="$1"
+    local dstpath="$2"
+    local ftype="$3"
+    test -n "$dstpath"  || dstpath=${srcpath%.skel}
+    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"
 }
 
+guess_ftype() {
+    #
+    # Guess file type from destination path $1
+    #
+    local dstpath="$1"
+    case $dstpath in
+        *.md) echo markdown    ;;
+        *)    echo MKIT_COMMON ;;
+    esac
+}
+
+build1_ftype() {
+    #
+    # Build a file of type $1
+    #
+    local ftype="$1"
+    case $ftype in
+        MKIT_COMMON)    expand_variables "vars" ;;
+        markdown)       expand_includes | expand_variables "vars" ;;
+        rpmstuff)       expand_variables "vars" "rpmstuff:vars" ;;
+        *)              die "unknown file type: $ftype" ;;
+    esac
+}
+
 build_manpages() {
     local manfile mdfile
     if command -v ronn >/dev/null;
     #
     # Create distributable tarball
     #
+    #FIXME: lacking Makefile skills, we do this step twice fot
+    #       rpmstuff, hence -f hack for gzip
+    #
     local version=$(get_version)
     local dirname=$MKIT_PKGNAME-$version
     mkdir -p "$dirname"
     ini values "lists:dist" | xargs -I DIST_ITEM cp -R DIST_ITEM "$dirname"
     sed -i -e "s/^VERSION = .*/VERSION = $version/" "$dirname/config.mk"
     tar -cf "$dirname.tar" "$dirname"
-    gzip "$dirname.tar"
+    gzip -f "$dirname.tar"      # see above FIXME
+    mkdir -p "$MKIT_LOCAL"
+    echo "$dirname.tar.gz" >> "$MKIT_LOCAL/built.lst"
     rm -rf "$dirname"
 }
 
+rpmstuff() {
+    #
+    # Build specfile
+    #
+    local specname="$(ini 1value ENV:PKGNAME).spec"
+    local specsrc="$(ini 1value "rpmstuff:spec_skel")"
+    test -n "$specsrc" || die "rpmstuff:spec_skel not specified"
+    test -f "$specsrc" || die "specfile template not found: $specsrc"
+    build1 "$specsrc" "$specname"
+}
+
 expand_includes() {
     #
     # Expand include directives
 
 expand_variables() {
     #
-    # Expand variable values
+    # Expand variables from sections $@
     #
     local script=$(mktemp --tmpdir mkit-tmp.XXXXXXXXXX)
-    local varname varvalue
-    ini lskeys "vars" \
-      | while read varname;
-        do
-            varvalue="$(ini 1value "vars:$varname" | sed -e 's/\$/\\$/' )"
-            echo "s|$varname|$varvalue|;" >> "$script"
-        done
+    local section varname varvalue
+    for section in "$@";
+    do
+        debug_var section
+        ini lskeys "$section" \
+          | while read varname;
+            do
+                varvalue="$(ini 1value "$section:$varname" | sed -e 's/\$/\\$/' )"
+                echo "s|$varname|$varvalue|;" >> "$script"
+                debug_var varname varvalue
+            done
+    done
     echo "s|__CODENAME__|$CODENAME|;"     >> "$script"
     echo "s|__VERSION__|$(get_version)|;" >> "$script"
-    perl -wp "$script"
+    perl -wp "$script" || die "expand_variables failed"
     rm "$script"
 }
 
     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)
+        local latest_tag=$(
+            git log --format="%D" \
+              | sed 's/,/\n/g' \
+              | sed 's/^[[:blank:]]*//; ' \
+              | grep -E '^tag: v[[:digit:]]+\.' \
+              | cut -d' ' -f2 \
+              | head -1
+        )
         if ! git describe --tags --exact-match HEAD >&/dev/null;
         then    # we are at a later commit than the last tag
             local sha=g$(git log -1 --pretty=format:%h HEAD)
         then    # the tree is "dirty", i.e. has been edited
             local dirty=dirty
         fi
-        test -n "$lasttag" && version=${lasttag:1}
+        test -n "$latest_tag" && version=${latest_tag:1}
         local suffix=""
         case "$commit:$dirty" in
             :)       suffix=""                ;;

utils/mkit/include/deploy.sh

 #!/bin/bash
 
-
-check_env() {
-    #
-    # Check that environment variables have been set properly
-    #
-    PREFIX="$(readlink -m "$PREFIX")"
-    test -d "$PREFIX" || die "PREFIX points to non-existent directory: $PREFIX"
+_maybe() {
+    #
+    # Call the deploy command $1 $@ unless in dry mode
+    #
+    debug "$@"
+    local cmd="$1"; shift
+    $MKIT_DRY && return
+    case "$cmd" in
+        cp|rm|rmdir|chmod|mkdir) $cmd "$@" ;;
+        install)                 command -p install "$@" ;;
+        *)                       die "bad command called";;
+    esac
 }
 
 deploy_item() {
     local mode="${3:-$MKIT_DEFAULT_MODE}"
     if test -d "$src";
     then
-        cp -Tvr "$src" "$dst"
-        find "$dst" -type f -print0 | xargs -0 chmod -c "$mode"
+        _maybe mkdir -vp "$(dirname "$dst")"
+        _maybe cp -Tvr "$src" "$dst"
+        find "$dst" -type f \
+          | while read chmod_item;
+            do
+                _maybe chmod "$mode" "$chmod_item"
+            done
     else
-        command -p install -DTvm "$mode" "$src" "$dst"
+        _maybe install -DTvm "$mode" "$src" "$dst"
     fi
 }
 
     local grp="$1"
     local root=$(ini 1value "roots:$grp")
     test -n "$root" || die "missing in config.ini: roots:$grp"
-    echo "$root"
+    echo "$(ini 1value ENV:DESTDIR)$root"
 }
 
 install() {
     #
     # Install product
     #
-    check_env
     local dst group mode src
     ini values "lists:group" \
       | while read group;
     #
     # Uninstall product
     #
-    check_env
     local dst group src
     ini values "lists:group" \
       | while read group;
               | while read src;
                 do
                     dst=$(get_dst "$group" "$src")
-                    rm -vrf "$dst"
+                    _maybe rm -vrf "$dst"
                 done
         done
 }

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"
 
+debug() {
+    #
+    # Print debug message
+    #
+    $MKIT_DEBUG || return 0
+    echo "MKIT_DEBUG: ${FUNCNAME[1]}()" "$@" >&2
+}
+
+debug_var() {
+    #
+    # Print debug message
+    #
+    $MKIT_DEBUG || return 0
+    local __mkit_debug_var_name__
+    for __mkit_debug_var_name__ in "$@";
+    do
+        {
+            echo -n "MKIT_DEBUG: ${FUNCNAME[1]}():"
+            echo -n " $__mkit_debug_var_name__"
+            echo -n "='${!__mkit_debug_var_name__}'"
+            echo
+        } >&2
+    done
+}
+
 MKIT_INI=${MKIT_INI:-mkit.ini}
 MKIT_INI_EXPAND=2
 MKIT_PKGNAME=$(ini 1value "ENV:PKGNAME")
     # Call correct function based on $1
     #
     case $1 in
-        build|build_manpages|clean|dist|install|release_?|uninstall)
+        build|build_manpages|clean|dist|rpmstuff|install|release_?|uninstall|vbump_?)
             $1
             ;;
         *)
-            echo "usage: $(basename "$0") build|clean|dist|install|uninstall" >&2
+            echo "usage: $(basename "$0") build|clean|dist|rpmstuff|install|uninstall" >&2
     esac
 }

utils/mkit/include/release.sh

 #!/bin/bash
 
+__die_if() {
+    #
+    # Die if blocking condition $1 is detected
+    #
+    local condition="$1"
+    local x
+    case "$condition" in
+        nogit)
+            git rev-parse HEAD >&/dev/null\
+             || die "cannot do this outside git repo"
+            ;;
+        norelbr)
+            __git_info curbranch \
+              | grep -qFx "$RELSRC" \
+             || die "you are not on RELSRC branch: $RELSRC"
+            ;;
+        dirty)
+            git diff --shortstat 2>/dev/null \
+              | grep -q . \
+             && die "tree is dirty: $dirt"
+            ;;
+        novertag)
+            __git_info lasttag \
+              | grep -q . \
+             || die "cannot find last tag"
+            ;;
+        nobump)
+            git diff-tree --no-commit-id --name-only -r HEAD \
+              | grep -qFx config.mk \
+             || die "last change must be version bump in config.mk"
+            ;;
+        wip)
+            __git_info reldiff \
+              | grep '^....... WIP ' \
+             && die "WIP commit since $(__git_info lasttag)"
+            ;;
+        old_c)
+            x=$(__ver_info nextver_g)
+            __ver_info currver_c \
+              | grep -qFx "$x" \
+             || die "new version not in config.mk: $x"
+            ;;
+    esac
+}
+
+__git_info() {
+    #
+    # Get git info $1
+    #
+    local info="$1"
+    case "$info" in
+        lasttag)    git tag | grep ^v | sort -V | tail -n1  ;;
+        curbranch)  git rev-parse --abbrev-ref HEAD         ;;
+        reldiff)    git log --oneline "$(__git_info lasttag)..HEAD" ;;
+    esac
+}
+
+__ver_info() {
+    #
+    # Get git info $1
+    #
+    local info="$1"
+    case "$info" in
+        lastver_g)  __git_info lasttag | sed s/^v// ;;
+        nextver_g)  __make_ver "$level" "$(__ver_info lastver_g)" ;;
+        currver_c)  grep -m 1 -w VERSION config.mk \
+                     | sed 's/ *= */=/' | cut -d = -f 2 | xargs echo ;;
+        nextver_c)  __make_ver "$level" "$(__ver_info currver_c)" ;;
+    esac
+}
+
 __make_ver() {
     local level=$1
     local old=$2
     #        compatible with this release strategy
     #
     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 newtag
 
-    local newver=$(__make_ver "$level" "${lasttag#v}")
-    local newtag=v$newver
-    local higher=$(echo -e "$oldtag\n$newtag" | sort -V | tail -n1)
+    __die_if nogit
+    __die_if norelbr
+    __die_if dirty
+    __die_if novertag
+    __die_if nobump
+    __die_if wip
+    __die_if old_c
 
-    test "$lastfile" = config.mk \
-     || die "last change must be version bump in config.mk"
-
-    test -n "$lasttag" \
-     || die "cannot find last tag"
-
-    test "$newtag" = "$higher" \
-     || die "generated tag looks older: $oldtag<$newtag"
-
-    grep -qw "$newver" config.mk \
-     || die "new version not in config.mk: $newver"
+    newtag=v$(__ver_info nextver_g)
+    set -e
+    debug_var newtag
+    $MKIT_DRY && return
+    git tag -m "$MKIT_PROJNAME $newtag - $CODENAME" "$newtag"
+    git branch -f "$RELDST" "$newtag"
+}
 
-    grep '^....... WIP ' <<<"$changelog" \
-     && die "WIP commit since $lasttag"
+__git_msg_vbump() {
+    echo "Bump version"
+    echo ""
+    __git_info reldiff | sed 's/^/ *  /'
+}
 
-    grep -qw "$curbranch" <<<"$RELSRC" \
-     || die "you are not on RELSRC branch: $RELSRC"
+__vbump() {
+    local level="$1"
+    local lastver   # current from config.mk
+    local nextver   # after the bump
+    __die_if nogit
+    __die_if norelbr
+    __die_if dirty
+    lastver=$(__ver_info currver_c)
+    nextver=$(__ver_info nextver_c)
+    debug_var lastver nextver
+    $MKIT_DRY && return
+    sed -i "s/$lastver/$nextver/" config.mk \
+      || die "failed to update config.mk"
+    git add config.mk \
+      || die "failed to add config.mk to the index"
+    git commit -e -m "$(__git_msg_vbump)"
+}
 
-    test -z "$dirt" \
-     || die "tree is dirty: $dirt"
+vbump_x() {
+    __vbump x
+}
 
-    # FIXME: Have user prepare proper message with changelog
+vbump_y() {
+    __vbump y
+}
 
-    set -e
-    git tag -m "$MKIT_PROJNAME $newtag - $CODENAME" "$newtag"
-    git branch -f "$RELDST" "$newtag"
+vbump_z() {
+    __vbump z
 }
 
 release_x() {

utils/mkit/make

     echo "$@" && exit 9
 }
 
-export MKIT_VERSION=0.0.3
+export MKIT_VERSION=0.0.8
 
 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}
 
 . "$MKIT_DIR/include/mkit.sh" || die "failed to init; check if MKIT_DIR is set properly: $MKIT_DIR"
 

utils/mkit/mkit.mk

 	@echo build options:
 	@echo "VERSION  = ${VERSION}"
 	@echo "PRERELEASE = ${PRERELEASE}"
+	@echo "DESTDIR   = ${DESTDIR}"
 	@echo "PREFIX   = ${PREFIX}"
 
 build:
 dist: clean
 	@$(MKIT_DIR)/make dist
 
+rpmstuff: dist
+	@$(MKIT_DIR)/make rpmstuff
+
 install: all
 	@$(MKIT_DIR)/make install
 
 uninstall:
 	@$(MKIT_DIR)/make uninstall
 
-.PHONY: all options clean dist install uninstall release_x release_y release_z
+vbump_x:
+	@$(MKIT_DIR)/make vbump_x
+
+vbump_y:
+	@$(MKIT_DIR)/make vbump_y
+
+vbump_z:
+	@$(MKIT_DIR)/make vbump_z
+
+.PHONY: all options clean dist rpmstuff install uninstall release_x release_y release_z vbump_x vbump_y vbump_z